drivers/net/e1000/em_rxtx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2016 Intel Corporation
   3  */
   4
   5 #include <sys/queue.h>
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <stdint.h>
  12 #include <stdarg.h>
  13 #include <inttypes.h>
  14
  15 #include <rte_interrupts.h>
  16 #include <rte_byteorder.h>
  17 #include <rte_common.h>
  18 #include <rte_log.h>
  19 #include <rte_debug.h>
  20 #include <rte_pci.h>
  21 #include <rte_memory.h>
  22 #include <rte_memcpy.h>
  23 #include <rte_memzone.h>
  24 #include <rte_launch.h>
  25 #include <rte_eal.h>
  26 #include <rte_per_lcore.h>
  27 #include <rte_lcore.h>
  28 #include <rte_atomic.h>
  29 #include <rte_branch_prediction.h>
  30 #include <rte_mempool.h>
  31 #include <rte_malloc.h>
  32 #include <rte_mbuf.h>
  33 #include <rte_ether.h>
  34 #include <rte_ethdev_driver.h>
  35 #include <rte_prefetch.h>
  36 #include <rte_ip.h>
  37 #include <rte_udp.h>
  38 #include <rte_tcp.h>
  39 #include <rte_sctp.h>
  40 #include <rte_net.h>
  41 #include <rte_string_fns.h>
  42
  43 #include "e1000_logs.h"
  44 #include "base/e1000_api.h"
  45 #include "e1000_ethdev.h"
  46 #include "base/e1000_osdep.h"
  47
  48 #define E1000_TXD_VLAN_SHIFT    16
  49
  50 #define E1000_RXDCTL_GRAN       0x01000000 /* RXDCTL Granularity */
  51
  52 #define E1000_TX_OFFLOAD_MASK ( \
  53                 PKT_TX_IP_CKSUM |       \
  54                 PKT_TX_L4_MASK |        \
  55                 PKT_TX_VLAN_PKT)
  56
  57 #define E1000_TX_OFFLOAD_NOTSUP_MASK \
  58                 (PKT_TX_OFFLOAD_MASK ^ E1000_TX_OFFLOAD_MASK)
  59
  60 /**
  61  * Structure associated with each descriptor of the RX ring of a RX queue.
  62  */
  63 struct em_rx_entry {
  64         struct rte_mbuf *mbuf; /**< mbuf associated with RX descriptor. */
  65 };
  66
  67 /**
  68  * Structure associated with each descriptor of the TX ring of a TX queue.
  69  */
  70 struct em_tx_entry {
  71         struct rte_mbuf *mbuf; /**< mbuf associated with TX desc, if any. */
  72         uint16_t next_id; /**< Index of next descriptor in ring. */
  73         uint16_t last_id; /**< Index of last scattered descriptor. */
  74 };
  75
  76 /**
  77  * Structure associated with each RX queue.
  78  */
  79 struct em_rx_queue {
  80         struct rte_mempool  *mb_pool;   /**< mbuf pool to populate RX ring. */
  81         volatile struct e1000_rx_desc *rx_ring; /**< RX ring virtual address. */
  82         uint64_t            rx_ring_phys_addr; /**< RX ring DMA address. */
  83         volatile uint32_t   *rdt_reg_addr; /**< RDT register address. */
  84         volatile uint32_t   *rdh_reg_addr; /**< RDH register address. */
  85         struct em_rx_entry *sw_ring;   /**< address of RX software ring. */
  86         struct rte_mbuf *pkt_first_seg; /**< First segment of current packet. */
  87         struct rte_mbuf *pkt_last_seg;  /**< Last segment of current packet. */
  88         uint64_t            offloads;   /**< Offloads of DEV_RX_OFFLOAD_* */
  89         uint16_t            nb_rx_desc; /**< number of RX descriptors. */
  90         uint16_t            rx_tail;    /**< current value of RDT register. */
  91         uint16_t            nb_rx_hold; /**< number of held free RX desc. */
  92         uint16_t            rx_free_thresh; /**< max free RX desc to hold. */
  93         uint16_t            queue_id;   /**< RX queue index. */
  94         uint16_t            port_id;    /**< Device port identifier. */
  95         uint8_t             pthresh;    /**< Prefetch threshold register. */
  96         uint8_t             hthresh;    /**< Host threshold register. */
  97         uint8_t             wthresh;    /**< Write-back threshold register. */
  98         uint8_t             crc_len;    /**< 0 if CRC stripped, 4 otherwise. */
  99 };
 100
 101 /**
 102  * Hardware context number
 103  */
 104 enum {
 105         EM_CTX_0    = 0, /**< CTX0 */
 106         EM_CTX_NUM  = 1, /**< CTX NUM */
 107 };
 108
 109 /** Offload features */
 110 union em_vlan_macip {
 111         uint32_t data;
 112         struct {
 113                 uint16_t l3_len:9; /**< L3 (IP) Header Length. */
 114                 uint16_t l2_len:7; /**< L2 (MAC) Header Length. */
 115                 uint16_t vlan_tci;
 116                 /**< VLAN Tag Control Identifier (CPU order). */
 117         } f;
 118 };
 119
 120 /*
 121  * Compare mask for vlan_macip_len.data,
 122  * should be in sync with em_vlan_macip.f layout.
 123  * */
 124 #define TX_VLAN_CMP_MASK        0xFFFF0000  /**< VLAN length - 16-bits. */
 125 #define TX_MAC_LEN_CMP_MASK     0x0000FE00  /**< MAC length - 7-bits. */
 126 #define TX_IP_LEN_CMP_MASK      0x000001FF  /**< IP  length - 9-bits. */
 127 /** MAC+IP  length. */
 128 #define TX_MACIP_LEN_CMP_MASK   (TX_MAC_LEN_CMP_MASK | TX_IP_LEN_CMP_MASK)
 129
 130 /**
 131  * Structure to check if new context need be built
 132  */
 133 struct em_ctx_info {
 134         uint64_t flags;              /**< ol_flags related to context build. */
 135         uint32_t cmp_mask;           /**< compare mask */
 136         union em_vlan_macip hdrlen;  /**< L2 and L3 header lenghts */
 137 };
 138
 139 /**
 140  * Structure associated with each TX queue.
 141  */
 142 struct em_tx_queue {
 143         volatile struct e1000_data_desc *tx_ring; /**< TX ring address */
 144         uint64_t               tx_ring_phys_addr; /**< TX ring DMA address. */
 145         struct em_tx_entry    *sw_ring; /**< virtual address of SW ring. */
 146         volatile uint32_t      *tdt_reg_addr; /**< Address of TDT register. */
 147         uint16_t               nb_tx_desc;    /**< number of TX descriptors. */
 148         uint16_t               tx_tail;  /**< Current value of TDT register. */
 149         /**< Start freeing TX buffers if there are less free descriptors than
 150              this value. */
 151         uint16_t               tx_free_thresh;
 152         /**< Number of TX descriptors to use before RS bit is set. */
 153         uint16_t               tx_rs_thresh;
 154         /** Number of TX descriptors used since RS bit was set. */
 155         uint16_t               nb_tx_used;
 156         /** Index to last TX descriptor to have been cleaned. */
 157         uint16_t               last_desc_cleaned;
 158         /** Total number of TX descriptors ready to be allocated. */
 159         uint16_t               nb_tx_free;
 160         uint16_t               queue_id; /**< TX queue index. */
 161         uint16_t               port_id;  /**< Device port identifier. */
 162         uint8_t                pthresh;  /**< Prefetch threshold register. */
 163         uint8_t                hthresh;  /**< Host threshold register. */
 164         uint8_t                wthresh;  /**< Write-back threshold register. */
 165         struct em_ctx_info ctx_cache;
 166         /**< Hardware context history.*/
 167         uint64_t               offloads; /**< offloads of DEV_TX_OFFLOAD_* */
 168 };
 169
 170 #if 1
 171 #define RTE_PMD_USE_PREFETCH
 172 #endif
 173
 174 #ifdef RTE_PMD_USE_PREFETCH
 175 #define rte_em_prefetch(p)      rte_prefetch0(p)
 176 #else
 177 #define rte_em_prefetch(p)      do {} while(0)
 178 #endif
 179
 180 #ifdef RTE_PMD_PACKET_PREFETCH
 181 #define rte_packet_prefetch(p) rte_prefetch1(p)
 182 #else
 183 #define rte_packet_prefetch(p)  do {} while(0)
 184 #endif
 185
 186 #ifndef DEFAULT_TX_FREE_THRESH
 187 #define DEFAULT_TX_FREE_THRESH  32
 188 #endif /* DEFAULT_TX_FREE_THRESH */
 189
 190 #ifndef DEFAULT_TX_RS_THRESH
 191 #define DEFAULT_TX_RS_THRESH  32
 192 #endif /* DEFAULT_TX_RS_THRESH */
 193
 194
 195 /*********************************************************************
 196  *
 197  *  TX function
 198  *
 199  **********************************************************************/
 200
 201 /*
 202  * Populates TX context descriptor.
 203  */
 204 static inline void
 205 em_set_xmit_ctx(struct em_tx_queue* txq,
 206                 volatile struct e1000_context_desc *ctx_txd,
 207                 uint64_t flags,
 208                 union em_vlan_macip hdrlen)
 209 {
 210         uint32_t cmp_mask, cmd_len;
 211         uint16_t ipcse, l2len;
 212         struct e1000_context_desc ctx;
 213
 214         cmp_mask = 0;
 215         cmd_len = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_C;
 216
 217         l2len = hdrlen.f.l2_len;
 218         ipcse = (uint16_t)(l2len + hdrlen.f.l3_len);
 219
 220         /* setup IPCS* fields */
 221         ctx.lower_setup.ip_fields.ipcss = (uint8_t)l2len;
 222         ctx.lower_setup.ip_fields.ipcso = (uint8_t)(l2len +
 223                         offsetof(struct ipv4_hdr, hdr_checksum));
 224
 225         /*
 226          * When doing checksum or TCP segmentation with IPv6 headers,
 227          * IPCSE field should be set t0 0.
 228          */
 229         if (flags & PKT_TX_IP_CKSUM) {
 230                 ctx.lower_setup.ip_fields.ipcse =
 231                         (uint16_t)rte_cpu_to_le_16(ipcse - 1);
 232                 cmd_len |= E1000_TXD_CMD_IP;
 233                 cmp_mask |= TX_MACIP_LEN_CMP_MASK;
 234         } else {
 235                 ctx.lower_setup.ip_fields.ipcse = 0;
 236         }
 237
 238         /* setup TUCS* fields */
 239         ctx.upper_setup.tcp_fields.tucss = (uint8_t)ipcse;
 240         ctx.upper_setup.tcp_fields.tucse = 0;
 241
 242         switch (flags & PKT_TX_L4_MASK) {
 243         case PKT_TX_UDP_CKSUM:
 244                 ctx.upper_setup.tcp_fields.tucso = (uint8_t)(ipcse +
 245                                 offsetof(struct udp_hdr, dgram_cksum));
 246                 cmp_mask |= TX_MACIP_LEN_CMP_MASK;
 247                 break;
 248         case PKT_TX_TCP_CKSUM:
 249                 ctx.upper_setup.tcp_fields.tucso = (uint8_t)(ipcse +
 250                                 offsetof(struct tcp_hdr, cksum));
 251                 cmd_len |= E1000_TXD_CMD_TCP;
 252                 cmp_mask |= TX_MACIP_LEN_CMP_MASK;
 253                 break;
 254         default:
 255                 ctx.upper_setup.tcp_fields.tucso = 0;
 256         }
 257
 258         ctx.cmd_and_length = rte_cpu_to_le_32(cmd_len);
 259         ctx.tcp_seg_setup.data = 0;
 260
 261         *ctx_txd = ctx;
 262
 263         txq->ctx_cache.flags = flags;
 264         txq->ctx_cache.cmp_mask = cmp_mask;
 265         txq->ctx_cache.hdrlen = hdrlen;
 266 }
 267
 268 /*
 269  * Check which hardware context can be used. Use the existing match
 270  * or create a new context descriptor.
 271  */
 272 static inline uint32_t
 273 what_ctx_update(struct em_tx_queue *txq, uint64_t flags,
 274                 union em_vlan_macip hdrlen)
 275 {
 276         /* If match with the current context */
 277         if (likely (txq->ctx_cache.flags == flags &&
 278                         ((txq->ctx_cache.hdrlen.data ^ hdrlen.data) &
 279                         txq->ctx_cache.cmp_mask) == 0))
 280                 return EM_CTX_0;
 281
 282         /* Mismatch */
 283         return EM_CTX_NUM;
 284 }
 285
 286 /* Reset transmit descriptors after they have been used */
 287 static inline int
 288 em_xmit_cleanup(struct em_tx_queue *txq)
 289 {
 290         struct em_tx_entry *sw_ring = txq->sw_ring;
 291         volatile struct e1000_data_desc *txr = txq->tx_ring;
 292         uint16_t last_desc_cleaned = txq->last_desc_cleaned;
 293         uint16_t nb_tx_desc = txq->nb_tx_desc;
 294         uint16_t desc_to_clean_to;
 295         uint16_t nb_tx_to_clean;
 296
 297         /* Determine the last descriptor needing to be cleaned */
 298         desc_to_clean_to = (uint16_t)(last_desc_cleaned + txq->tx_rs_thresh);
 299         if (desc_to_clean_to >= nb_tx_desc)
 300                 desc_to_clean_to = (uint16_t)(desc_to_clean_to - nb_tx_desc);
 301
 302         /* Check to make sure the last descriptor to clean is done */
 303         desc_to_clean_to = sw_ring[desc_to_clean_to].last_id;
 304         if (! (txr[desc_to_clean_to].upper.fields.status & E1000_TXD_STAT_DD))
 305         {
 306                 PMD_TX_FREE_LOG(DEBUG,
 307                                 "TX descriptor %4u is not done"
 308                                 "(port=%d queue=%d)", desc_to_clean_to,
 309                                 txq->port_id, txq->queue_id);
 310                 /* Failed to clean any descriptors, better luck next time */
 311                 return -(1);
 312         }
 313
 314         /* Figure out how many descriptors will be cleaned */
 315         if (last_desc_cleaned > desc_to_clean_to)
 316                 nb_tx_to_clean = (uint16_t)((nb_tx_desc - last_desc_cleaned) +
 317                                                         desc_to_clean_to);
 318         else
 319                 nb_tx_to_clean = (uint16_t)(desc_to_clean_to -
 320                                                 last_desc_cleaned);
 321
 322         PMD_TX_FREE_LOG(DEBUG,
 323                         "Cleaning %4u TX descriptors: %4u to %4u "
 324                         "(port=%d queue=%d)", nb_tx_to_clean,
 325                         last_desc_cleaned, desc_to_clean_to, txq->port_id,
 326                         txq->queue_id);
 327
 328         /*
 329          * The last descriptor to clean is done, so that means all the
 330          * descriptors from the last descriptor that was cleaned
 331          * up to the last descriptor with the RS bit set
 332          * are done. Only reset the threshold descriptor.
 333          */
 334         txr[desc_to_clean_to].upper.fields.status = 0;
 335
 336         /* Update the txq to reflect the last descriptor that was cleaned */
 337         txq->last_desc_cleaned = desc_to_clean_to;
 338         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + nb_tx_to_clean);
 339
 340         /* No Error */
 341         return 0;
 342 }
 343
 344 static inline uint32_t
 345 tx_desc_cksum_flags_to_upper(uint64_t ol_flags)
 346 {
 347         static const uint32_t l4_olinfo[2] = {0, E1000_TXD_POPTS_TXSM << 8};
 348         static const uint32_t l3_olinfo[2] = {0, E1000_TXD_POPTS_IXSM << 8};
 349         uint32_t tmp;
 350
 351         tmp = l4_olinfo[(ol_flags & PKT_TX_L4_MASK) != PKT_TX_L4_NO_CKSUM];
 352         tmp |= l3_olinfo[(ol_flags & PKT_TX_IP_CKSUM) != 0];
 353         return tmp;
 354 }
 355
 356 uint16_t
 357 eth_em_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 358                 uint16_t nb_pkts)
 359 {
 360         struct em_tx_queue *txq;
 361         struct em_tx_entry *sw_ring;
 362         struct em_tx_entry *txe, *txn;
 363         volatile struct e1000_data_desc *txr;
 364         volatile struct e1000_data_desc *txd;
 365         struct rte_mbuf     *tx_pkt;
 366         struct rte_mbuf     *m_seg;
 367         uint64_t buf_dma_addr;
 368         uint32_t popts_spec;
 369         uint32_t cmd_type_len;
 370         uint16_t slen;
 371         uint64_t ol_flags;
 372         uint16_t tx_id;
 373         uint16_t tx_last;
 374         uint16_t nb_tx;
 375         uint16_t nb_used;
 376         uint64_t tx_ol_req;
 377         uint32_t ctx;
 378         uint32_t new_ctx;
 379         union em_vlan_macip hdrlen;
 380
 381         txq = tx_queue;
 382         sw_ring = txq->sw_ring;
 383         txr     = txq->tx_ring;
 384         tx_id   = txq->tx_tail;
 385         txe = &sw_ring[tx_id];
 386
 387         /* Determine if the descriptor ring needs to be cleaned. */
 388          if (txq->nb_tx_free < txq->tx_free_thresh)
 389                 em_xmit_cleanup(txq);
 390
 391         /* TX loop */
 392         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
 393                 new_ctx = 0;
 394                 tx_pkt = *tx_pkts++;
 395
 396                 RTE_MBUF_PREFETCH_TO_FREE(txe->mbuf);
 397
 398                 /*
 399                  * Determine how many (if any) context descriptors
 400                  * are needed for offload functionality.
 401                  */
 402                 ol_flags = tx_pkt->ol_flags;
 403
 404                 /* If hardware offload required */
 405                 tx_ol_req = (ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_L4_MASK));
 406                 if (tx_ol_req) {
 407                         hdrlen.f.vlan_tci = tx_pkt->vlan_tci;
 408                         hdrlen.f.l2_len = tx_pkt->l2_len;
 409                         hdrlen.f.l3_len = tx_pkt->l3_len;
 410                         /* If new context to be built or reuse the exist ctx. */
 411                         ctx = what_ctx_update(txq, tx_ol_req, hdrlen);
 412
 413                         /* Only allocate context descriptor if required*/
 414                         new_ctx = (ctx == EM_CTX_NUM);
 415                 }
 416
 417                 /*
 418                  * Keep track of how many descriptors are used this loop
 419                  * This will always be the number of segments + the number of
 420                  * Context descriptors required to transmit the packet
 421                  */
 422                 nb_used = (uint16_t)(tx_pkt->nb_segs + new_ctx);
 423
 424                 /*
 425                  * The number of descriptors that must be allocated for a
 426                  * packet is the number of segments of that packet, plus 1
 427                  * Context Descriptor for the hardware offload, if any.
 428                  * Determine the last TX descriptor to allocate in the TX ring
 429                  * for the packet, starting from the current position (tx_id)
 430                  * in the ring.
 431                  */
 432                 tx_last = (uint16_t) (tx_id + nb_used - 1);
 433
 434                 /* Circular ring */
 435                 if (tx_last >= txq->nb_tx_desc)
 436                         tx_last = (uint16_t) (tx_last - txq->nb_tx_desc);
 437
 438                 PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u pktlen=%u"
 439                            " tx_first=%u tx_last=%u",
 440                            (unsigned) txq->port_id,
 441                            (unsigned) txq->queue_id,
 442                            (unsigned) tx_pkt->pkt_len,
 443                            (unsigned) tx_id,
 444                            (unsigned) tx_last);
 445
 446                 /*
 447                  * Make sure there are enough TX descriptors available to
 448                  * transmit the entire packet.
 449                  * nb_used better be less than or equal to txq->tx_rs_thresh
 450                  */
 451                 while (unlikely (nb_used > txq->nb_tx_free)) {
 452                         PMD_TX_FREE_LOG(DEBUG, "Not enough free TX descriptors "
 453                                         "nb_used=%4u nb_free=%4u "
 454                                         "(port=%d queue=%d)",
 455                                         nb_used, txq->nb_tx_free,
 456                                         txq->port_id, txq->queue_id);
 457
 458                         if (em_xmit_cleanup(txq) != 0) {
 459                                 /* Could not clean any descriptors */
 460                                 if (nb_tx == 0)
 461                                         return 0;
 462                                 goto end_of_tx;
 463                         }
 464                 }
 465
 466                 /*
 467                  * By now there are enough free TX descriptors to transmit
 468                  * the packet.
 469                  */
 470
 471                 /*
 472                  * Set common flags of all TX Data Descriptors.
 473                  *
 474                  * The following bits must be set in all Data Descriptors:
 475                  *    - E1000_TXD_DTYP_DATA
 476                  *    - E1000_TXD_DTYP_DEXT
 477                  *
 478                  * The following bits must be set in the first Data Descriptor
 479                  * and are ignored in the other ones:
 480                  *    - E1000_TXD_POPTS_IXSM
 481                  *    - E1000_TXD_POPTS_TXSM
 482                  *
 483                  * The following bits must be set in the last Data Descriptor
 484                  * and are ignored in the other ones:
 485                  *    - E1000_TXD_CMD_VLE
 486                  *    - E1000_TXD_CMD_IFCS
 487                  *
 488                  * The following bits must only be set in the last Data
 489                  * Descriptor:
 490                  *   - E1000_TXD_CMD_EOP
 491                  *
 492                  * The following bits can be set in any Data Descriptor, but
 493                  * are only set in the last Data Descriptor:
 494                  *   - E1000_TXD_CMD_RS
 495                  */
 496                 cmd_type_len = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
 497                         E1000_TXD_CMD_IFCS;
 498                 popts_spec = 0;
 499
 500                 /* Set VLAN Tag offload fields. */
 501                 if (ol_flags & PKT_TX_VLAN_PKT) {
 502                         cmd_type_len |= E1000_TXD_CMD_VLE;
 503                         popts_spec = tx_pkt->vlan_tci << E1000_TXD_VLAN_SHIFT;
 504                 }
 505
 506                 if (tx_ol_req) {
 507                         /*
 508                          * Setup the TX Context Descriptor if required
 509                          */
 510                         if (new_ctx) {
 511                                 volatile struct e1000_context_desc *ctx_txd;
 512
 513                                 ctx_txd = (volatile struct e1000_context_desc *)
 514                                         &txr[tx_id];
 515
 516                                 txn = &sw_ring[txe->next_id];
 517                                 RTE_MBUF_PREFETCH_TO_FREE(txn->mbuf);
 518
 519                                 if (txe->mbuf != NULL) {
 520                                         rte_pktmbuf_free_seg(txe->mbuf);
 521                                         txe->mbuf = NULL;
 522                                 }
 523
 524                                 em_set_xmit_ctx(txq, ctx_txd, tx_ol_req,
 525                                         hdrlen);
 526
 527                                 txe->last_id = tx_last;
 528                                 tx_id = txe->next_id;
 529                                 txe = txn;
 530                         }
 531
 532                         /*
 533                          * Setup the TX Data Descriptor,
 534                          * This path will go through
 535                          * whatever new/reuse the context descriptor
 536                          */
 537                         popts_spec |= tx_desc_cksum_flags_to_upper(ol_flags);
 538                 }
 539
 540                 m_seg = tx_pkt;
 541                 do {
 542                         txd = &txr[tx_id];
 543                         txn = &sw_ring[txe->next_id];
 544
 545                         if (txe->mbuf != NULL)
 546                                 rte_pktmbuf_free_seg(txe->mbuf);
 547                         txe->mbuf = m_seg;
 548
 549                         /*
 550                          * Set up Transmit Data Descriptor.
 551                          */
 552                         slen = m_seg->data_len;
 553                         buf_dma_addr = rte_mbuf_data_iova(m_seg);
 554
 555                         txd->buffer_addr = rte_cpu_to_le_64(buf_dma_addr);
 556                         txd->lower.data = rte_cpu_to_le_32(cmd_type_len | slen);
 557                         txd->upper.data = rte_cpu_to_le_32(popts_spec);
 558
 559                         txe->last_id = tx_last;
 560                         tx_id = txe->next_id;
 561                         txe = txn;
 562                         m_seg = m_seg->next;
 563                 } while (m_seg != NULL);
 564
 565                 /*
 566                  * The last packet data descriptor needs End Of Packet (EOP)
 567                  */
 568                 cmd_type_len |= E1000_TXD_CMD_EOP;
 569                 txq->nb_tx_used = (uint16_t)(txq->nb_tx_used + nb_used);
 570                 txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_used);
 571
 572                 /* Set RS bit only on threshold packets' last descriptor */
 573                 if (txq->nb_tx_used >= txq->tx_rs_thresh) {
 574                         PMD_TX_FREE_LOG(DEBUG,
 575                                         "Setting RS bit on TXD id=%4u "
 576                                         "(port=%d queue=%d)",
 577                                         tx_last, txq->port_id, txq->queue_id);
 578
 579                         cmd_type_len |= E1000_TXD_CMD_RS;
 580
 581                         /* Update txq RS bit counters */
 582                         txq->nb_tx_used = 0;
 583                 }
 584                 txd->lower.data |= rte_cpu_to_le_32(cmd_type_len);
 585         }
 586 end_of_tx:
 587         rte_wmb();
 588
 589         /*
 590          * Set the Transmit Descriptor Tail (TDT)
 591          */
 592         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 593                 (unsigned) txq->port_id, (unsigned) txq->queue_id,
 594                 (unsigned) tx_id, (unsigned) nb_tx);
 595         E1000_PCI_REG_WRITE_RELAXED(txq->tdt_reg_addr, tx_id);
 596         txq->tx_tail = tx_id;
 597
 598         return nb_tx;
 599 }
 600
 601 /*********************************************************************
 602  *
 603  *  TX prep functions
 604  *
 605  **********************************************************************/
 606 uint16_t
 607 eth_em_prep_pkts(__rte_unused void *tx_queue, struct rte_mbuf **tx_pkts,
 608                 uint16_t nb_pkts)
 609 {
 610         int i, ret;
 611         struct rte_mbuf *m;
 612
 613         for (i = 0; i < nb_pkts; i++) {
 614                 m = tx_pkts[i];
 615
 616                 if (m->ol_flags & E1000_TX_OFFLOAD_NOTSUP_MASK) {
 617                         rte_errno = -ENOTSUP;
 618                         return i;
 619                 }
 620
 621 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
 622                 ret = rte_validate_tx_offload(m);
 623                 if (ret != 0) {
 624                         rte_errno = ret;
 625                         return i;
 626                 }
 627 #endif
 628                 ret = rte_net_intel_cksum_prepare(m);
 629                 if (ret != 0) {
 630                         rte_errno = ret;
 631                         return i;
 632                 }
 633         }
 634
 635         return i;
 636 }
 637
 638 /*********************************************************************
 639  *
 640  *  RX functions
 641  *
 642  **********************************************************************/
 643
 644 static inline uint64_t
 645 rx_desc_status_to_pkt_flags(uint32_t rx_status)
 646 {
 647         uint64_t pkt_flags;
 648
 649         /* Check if VLAN present */
 650         pkt_flags = ((rx_status & E1000_RXD_STAT_VP) ?
 651                 PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED : 0);
 652
 653         return pkt_flags;
 654 }
 655
 656 static inline uint64_t
 657 rx_desc_error_to_pkt_flags(uint32_t rx_error)
 658 {
 659         uint64_t pkt_flags = 0;
 660
 661         if (rx_error & E1000_RXD_ERR_IPE)
 662                 pkt_flags |= PKT_RX_IP_CKSUM_BAD;
 663         if (rx_error & E1000_RXD_ERR_TCPE)
 664                 pkt_flags |= PKT_RX_L4_CKSUM_BAD;
 665         return pkt_flags;
 666 }
 667
 668 uint16_t
 669 eth_em_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
 670                 uint16_t nb_pkts)
 671 {
 672         volatile struct e1000_rx_desc *rx_ring;
 673         volatile struct e1000_rx_desc *rxdp;
 674         struct em_rx_queue *rxq;
 675         struct em_rx_entry *sw_ring;
 676         struct em_rx_entry *rxe;
 677         struct rte_mbuf *rxm;
 678         struct rte_mbuf *nmb;
 679         struct e1000_rx_desc rxd;
 680         uint64_t dma_addr;
 681         uint16_t pkt_len;
 682         uint16_t rx_id;
 683         uint16_t nb_rx;
 684         uint16_t nb_hold;
 685         uint8_t status;
 686
 687         rxq = rx_queue;
 688
 689         nb_rx = 0;
 690         nb_hold = 0;
 691         rx_id = rxq->rx_tail;
 692         rx_ring = rxq->rx_ring;
 693         sw_ring = rxq->sw_ring;
 694         while (nb_rx < nb_pkts) {
 695                 /*
 696                  * The order of operations here is important as the DD status
 697                  * bit must not be read after any other descriptor fields.
 698                  * rx_ring and rxdp are pointing to volatile data so the order
 699                  * of accesses cannot be reordered by the compiler. If they were
 700                  * not volatile, they could be reordered which could lead to
 701                  * using invalid descriptor fields when read from rxd.
 702                  */
 703                 rxdp = &rx_ring[rx_id];
 704                 status = rxdp->status;
 705                 if (! (status & E1000_RXD_STAT_DD))
 706                         break;
 707                 rxd = *rxdp;
 708
 709                 /*
 710                  * End of packet.
 711                  *
 712                  * If the E1000_RXD_STAT_EOP flag is not set, the RX packet is
 713                  * likely to be invalid and to be dropped by the various
 714                  * validation checks performed by the network stack.
 715                  *
 716                  * Allocate a new mbuf to replenish the RX ring descriptor.
 717                  * If the allocation fails:
 718                  *    - arrange for that RX descriptor to be the first one
 719                  *      being parsed the next time the receive function is
 720                  *      invoked [on the same queue].
 721                  *
 722                  *    - Stop parsing the RX ring and return immediately.
 723                  *
 724                  * This policy do not drop the packet received in the RX
 725                  * descriptor for which the allocation of a new mbuf failed.
 726                  * Thus, it allows that packet to be later retrieved if
 727                  * mbuf have been freed in the mean time.
 728                  * As a side effect, holding RX descriptors instead of
 729                  * systematically giving them back to the NIC may lead to
 730                  * RX ring exhaustion situations.
 731                  * However, the NIC can gracefully prevent such situations
 732                  * to happen by sending specific "back-pressure" flow control
 733                  * frames to its peer(s).
 734                  */
 735                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
 736                            "status=0x%x pkt_len=%u",
 737                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
 738                            (unsigned) rx_id, (unsigned) status,
 739                            (unsigned) rte_le_to_cpu_16(rxd.length));
 740
 741                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
 742                 if (nmb == NULL) {
 743                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
 744                                    "queue_id=%u",
 745                                    (unsigned) rxq->port_id,
 746                                    (unsigned) rxq->queue_id);
 747                         rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed++;
 748                         break;
 749                 }
 750
 751                 nb_hold++;
 752                 rxe = &sw_ring[rx_id];
 753                 rx_id++;
 754                 if (rx_id == rxq->nb_rx_desc)
 755                         rx_id = 0;
 756
 757                 /* Prefetch next mbuf while processing current one. */
 758                 rte_em_prefetch(sw_ring[rx_id].mbuf);
 759
 760                 /*
 761                  * When next RX descriptor is on a cache-line boundary,
 762                  * prefetch the next 4 RX descriptors and the next 8 pointers
 763                  * to mbufs.
 764                  */
 765                 if ((rx_id & 0x3) == 0) {
 766                         rte_em_prefetch(&rx_ring[rx_id]);
 767                         rte_em_prefetch(&sw_ring[rx_id]);
 768                 }
 769
 770                 /* Rearm RXD: attach new mbuf and reset status to zero. */
 771
 772                 rxm = rxe->mbuf;
 773                 rxe->mbuf = nmb;
 774                 dma_addr =
 775                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
 776                 rxdp->buffer_addr = dma_addr;
 777                 rxdp->status = 0;
 778
 779                 /*
 780                  * Initialize the returned mbuf.
 781                  * 1) setup generic mbuf fields:
 782                  *    - number of segments,
 783                  *    - next segment,
 784                  *    - packet length,
 785                  *    - RX port identifier.
 786                  * 2) integrate hardware offload data, if any:
 787                  *    - RSS flag & hash,
 788                  *    - IP checksum flag,
 789                  *    - VLAN TCI, if any,
 790                  *    - error flags.
 791                  */
 792                 pkt_len = (uint16_t) (rte_le_to_cpu_16(rxd.length) -
 793                                 rxq->crc_len);
 794                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
 795                 rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
 796                 rxm->nb_segs = 1;
 797                 rxm->next = NULL;
 798                 rxm->pkt_len = pkt_len;
 799                 rxm->data_len = pkt_len;
 800                 rxm->port = rxq->port_id;
 801
 802                 rxm->ol_flags = rx_desc_status_to_pkt_flags(status);
 803                 rxm->ol_flags = rxm->ol_flags |
 804                                 rx_desc_error_to_pkt_flags(rxd.errors);
 805
 806                 /* Only valid if PKT_RX_VLAN set in pkt_flags */
 807                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.special);
 808
 809                 /*
 810                  * Store the mbuf address into the next entry of the array
 811                  * of returned packets.
 812                  */
 813                 rx_pkts[nb_rx++] = rxm;
 814         }
 815         rxq->rx_tail = rx_id;
 816
 817         /*
 818          * If the number of free RX descriptors is greater than the RX free
 819          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
 820          * register.
 821          * Update the RDT with the value of the last processed RX descriptor
 822          * minus 1, to guarantee that the RDT register is never equal to the
 823          * RDH register, which creates a "full" ring situtation from the
 824          * hardware point of view...
 825          */
 826         nb_hold = (uint16_t) (nb_hold + rxq->nb_rx_hold);
 827         if (nb_hold > rxq->rx_free_thresh) {
 828                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
 829                            "nb_hold=%u nb_rx=%u",
 830                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
 831                            (unsigned) rx_id, (unsigned) nb_hold,
 832                            (unsigned) nb_rx);
 833                 rx_id = (uint16_t) ((rx_id == 0) ?
 834                         (rxq->nb_rx_desc - 1) : (rx_id - 1));
 835                 E1000_PCI_REG_WRITE(rxq->rdt_reg_addr, rx_id);
 836                 nb_hold = 0;
 837         }
 838         rxq->nb_rx_hold = nb_hold;
 839         return nb_rx;
 840 }
 841
 842 uint16_t
 843 eth_em_recv_scattered_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
 844                          uint16_t nb_pkts)
 845 {
 846         struct em_rx_queue *rxq;
 847         volatile struct e1000_rx_desc *rx_ring;
 848         volatile struct e1000_rx_desc *rxdp;
 849         struct em_rx_entry *sw_ring;
 850         struct em_rx_entry *rxe;
 851         struct rte_mbuf *first_seg;
 852         struct rte_mbuf *last_seg;
 853         struct rte_mbuf *rxm;
 854         struct rte_mbuf *nmb;
 855         struct e1000_rx_desc rxd;
 856         uint64_t dma; /* Physical address of mbuf data buffer */
 857         uint16_t rx_id;
 858         uint16_t nb_rx;
 859         uint16_t nb_hold;
 860         uint16_t data_len;
 861         uint8_t status;
 862
 863         rxq = rx_queue;
 864
 865         nb_rx = 0;
 866         nb_hold = 0;
 867         rx_id = rxq->rx_tail;
 868         rx_ring = rxq->rx_ring;
 869         sw_ring = rxq->sw_ring;
 870
 871         /*
 872          * Retrieve RX context of current packet, if any.
 873          */
 874         first_seg = rxq->pkt_first_seg;
 875         last_seg = rxq->pkt_last_seg;
 876
 877         while (nb_rx < nb_pkts) {
 878         next_desc:
 879                 /*
 880                  * The order of operations here is important as the DD status
 881                  * bit must not be read after any other descriptor fields.
 882                  * rx_ring and rxdp are pointing to volatile data so the order
 883                  * of accesses cannot be reordered by the compiler. If they were
 884                  * not volatile, they could be reordered which could lead to
 885                  * using invalid descriptor fields when read from rxd.
 886                  */
 887                 rxdp = &rx_ring[rx_id];
 888                 status = rxdp->status;
 889                 if (! (status & E1000_RXD_STAT_DD))
 890                         break;
 891                 rxd = *rxdp;
 892
 893                 /*
 894                  * Descriptor done.
 895                  *
 896                  * Allocate a new mbuf to replenish the RX ring descriptor.
 897                  * If the allocation fails:
 898                  *    - arrange for that RX descriptor to be the first one
 899                  *      being parsed the next time the receive function is
 900                  *      invoked [on the same queue].
 901                  *
 902                  *    - Stop parsing the RX ring and return immediately.
 903                  *
 904                  * This policy does not drop the packet received in the RX
 905                  * descriptor for which the allocation of a new mbuf failed.
 906                  * Thus, it allows that packet to be later retrieved if
 907                  * mbuf have been freed in the mean time.
 908                  * As a side effect, holding RX descriptors instead of
 909                  * systematically giving them back to the NIC may lead to
 910                  * RX ring exhaustion situations.
 911                  * However, the NIC can gracefully prevent such situations
 912                  * to happen by sending specific "back-pressure" flow control
 913                  * frames to its peer(s).
 914                  */
 915                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
 916                            "status=0x%x data_len=%u",
 917                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
 918                            (unsigned) rx_id, (unsigned) status,
 919                            (unsigned) rte_le_to_cpu_16(rxd.length));
 920
 921                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
 922                 if (nmb == NULL) {
 923                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
 924                                    "queue_id=%u", (unsigned) rxq->port_id,
 925                                    (unsigned) rxq->queue_id);
 926                         rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed++;
 927                         break;
 928                 }
 929
 930                 nb_hold++;
 931                 rxe = &sw_ring[rx_id];
 932                 rx_id++;
 933                 if (rx_id == rxq->nb_rx_desc)
 934                         rx_id = 0;
 935
 936                 /* Prefetch next mbuf while processing current one. */
 937                 rte_em_prefetch(sw_ring[rx_id].mbuf);
 938
 939                 /*
 940                  * When next RX descriptor is on a cache-line boundary,
 941                  * prefetch the next 4 RX descriptors and the next 8 pointers
 942                  * to mbufs.
 943                  */
 944                 if ((rx_id & 0x3) == 0) {
 945                         rte_em_prefetch(&rx_ring[rx_id]);
 946                         rte_em_prefetch(&sw_ring[rx_id]);
 947                 }
 948
 949                 /*
 950                  * Update RX descriptor with the physical address of the new
 951                  * data buffer of the new allocated mbuf.
 952                  */
 953                 rxm = rxe->mbuf;
 954                 rxe->mbuf = nmb;
 955                 dma = rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
 956                 rxdp->buffer_addr = dma;
 957                 rxdp->status = 0;
 958
 959                 /*
 960                  * Set data length & data buffer address of mbuf.
 961                  */
 962                 data_len = rte_le_to_cpu_16(rxd.length);
 963                 rxm->data_len = data_len;
 964                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
 965
 966                 /*
 967                  * If this is the first buffer of the received packet,
 968                  * set the pointer to the first mbuf of the packet and
 969                  * initialize its context.
 970                  * Otherwise, update the total length and the number of segments
 971                  * of the current scattered packet, and update the pointer to
 972                  * the last mbuf of the current packet.
 973                  */
 974                 if (first_seg == NULL) {
 975                         first_seg = rxm;
 976                         first_seg->pkt_len = data_len;
 977                         first_seg->nb_segs = 1;
 978                 } else {
 979                         first_seg->pkt_len += data_len;
 980                         first_seg->nb_segs++;
 981                         last_seg->next = rxm;
 982                 }
 983
 984                 /*
 985                  * If this is not the last buffer of the received packet,
 986                  * update the pointer to the last mbuf of the current scattered
 987                  * packet and continue to parse the RX ring.
 988                  */
 989                 if (! (status & E1000_RXD_STAT_EOP)) {
 990                         last_seg = rxm;
 991                         goto next_desc;
 992                 }
 993
 994                 /*
 995                  * This is the last buffer of the received packet.
 996                  * If the CRC is not stripped by the hardware:
 997                  *   - Subtract the CRC length from the total packet length.
 998                  *   - If the last buffer only contains the whole CRC or a part
 999                  *     of it, free the mbuf associated to the last buffer.
1000                  *     If part of the CRC is also contained in the previous
1001                  *     mbuf, subtract the length of that CRC part from the
1002                  *     data length of the previous mbuf.
1003                  */
1004                 rxm->next = NULL;
1005                 if (unlikely(rxq->crc_len > 0)) {
1006                         first_seg->pkt_len -= ETHER_CRC_LEN;
1007                         if (data_len <= ETHER_CRC_LEN) {
1008                                 rte_pktmbuf_free_seg(rxm);
1009                                 first_seg->nb_segs--;
1010                                 last_seg->data_len = (uint16_t)
1011                                         (last_seg->data_len -
1012                                          (ETHER_CRC_LEN - data_len));
1013                                 last_seg->next = NULL;
1014                         } else
1015                                 rxm->data_len =
1016                                         (uint16_t) (data_len - ETHER_CRC_LEN);
1017                 }
1018
1019                 /*
1020                  * Initialize the first mbuf of the returned packet:
1021                  *    - RX port identifier,
1022                  *    - hardware offload data, if any:
1023                  *      - IP checksum flag,
1024                  *      - error flags.
1025                  */
1026                 first_seg->port = rxq->port_id;
1027
1028                 first_seg->ol_flags = rx_desc_status_to_pkt_flags(status);
1029                 first_seg->ol_flags = first_seg->ol_flags |
1030                                         rx_desc_error_to_pkt_flags(rxd.errors);
1031
1032                 /* Only valid if PKT_RX_VLAN set in pkt_flags */
1033                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.special);
1034
1035                 /* Prefetch data of first segment, if configured to do so. */
1036                 rte_packet_prefetch((char *)first_seg->buf_addr +
1037                         first_seg->data_off);
1038
1039                 /*
1040                  * Store the mbuf address into the next entry of the array
1041                  * of returned packets.
1042                  */
1043                 rx_pkts[nb_rx++] = first_seg;
1044
1045                 /*
1046                  * Setup receipt context for a new packet.
1047                  */
1048                 first_seg = NULL;
1049         }
1050
1051         /*
1052          * Record index of the next RX descriptor to probe.
1053          */
1054         rxq->rx_tail = rx_id;
1055
1056         /*
1057          * Save receive context.
1058          */
1059         rxq->pkt_first_seg = first_seg;
1060         rxq->pkt_last_seg = last_seg;
1061
1062         /*
1063          * If the number of free RX descriptors is greater than the RX free
1064          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1065          * register.
1066          * Update the RDT with the value of the last processed RX descriptor
1067          * minus 1, to guarantee that the RDT register is never equal to the
1068          * RDH register, which creates a "full" ring situtation from the
1069          * hardware point of view...
1070          */
1071         nb_hold = (uint16_t) (nb_hold + rxq->nb_rx_hold);
1072         if (nb_hold > rxq->rx_free_thresh) {
1073                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1074                            "nb_hold=%u nb_rx=%u",
1075                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
1076                            (unsigned) rx_id, (unsigned) nb_hold,
1077                            (unsigned) nb_rx);
1078                 rx_id = (uint16_t) ((rx_id == 0) ?
1079                         (rxq->nb_rx_desc - 1) : (rx_id - 1));
1080                 E1000_PCI_REG_WRITE(rxq->rdt_reg_addr, rx_id);
1081                 nb_hold = 0;
1082         }
1083         rxq->nb_rx_hold = nb_hold;
1084         return nb_rx;
1085 }
1086
1087 #define EM_MAX_BUF_SIZE     16384
1088 #define EM_RCTL_FLXBUF_STEP 1024
1089
1090 static void
1091 em_tx_queue_release_mbufs(struct em_tx_queue *txq)
1092 {
1093         unsigned i;
1094
1095         if (txq->sw_ring != NULL) {
1096                 for (i = 0; i != txq->nb_tx_desc; i++) {
1097                         if (txq->sw_ring[i].mbuf != NULL) {
1098                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
1099                                 txq->sw_ring[i].mbuf = NULL;
1100                         }
1101                 }
1102         }
1103 }
1104
1105 static void
1106 em_tx_queue_release(struct em_tx_queue *txq)
1107 {
1108         if (txq != NULL) {
1109                 em_tx_queue_release_mbufs(txq);
1110                 rte_free(txq->sw_ring);
1111                 rte_free(txq);
1112         }
1113 }
1114
1115 void
1116 eth_em_tx_queue_release(void *txq)
1117 {
1118         em_tx_queue_release(txq);
1119 }
1120
1121 /* (Re)set dynamic em_tx_queue fields to defaults */
1122 static void
1123 em_reset_tx_queue(struct em_tx_queue *txq)
1124 {
1125         uint16_t i, nb_desc, prev;
1126         static const struct e1000_data_desc txd_init = {
1127                 .upper.fields = {.status = E1000_TXD_STAT_DD},
1128         };
1129
1130         nb_desc = txq->nb_tx_desc;
1131
1132         /* Initialize ring entries */
1133
1134         prev = (uint16_t) (nb_desc - 1);
1135
1136         for (i = 0; i < nb_desc; i++) {
1137                 txq->tx_ring[i] = txd_init;
1138                 txq->sw_ring[i].mbuf = NULL;
1139                 txq->sw_ring[i].last_id = i;
1140                 txq->sw_ring[prev].next_id = i;
1141                 prev = i;
1142         }
1143
1144         /*
1145          * Always allow 1 descriptor to be un-allocated to avoid
1146          * a H/W race condition
1147          */
1148         txq->nb_tx_free = (uint16_t)(nb_desc - 1);
1149         txq->last_desc_cleaned = (uint16_t)(nb_desc - 1);
1150         txq->nb_tx_used = 0;
1151         txq->tx_tail = 0;
1152
1153         memset((void*)&txq->ctx_cache, 0, sizeof (txq->ctx_cache));
1154 }
1155
1156 uint64_t
1157 em_get_tx_port_offloads_capa(struct rte_eth_dev *dev)
1158 {
1159         uint64_t tx_offload_capa;
1160
1161         RTE_SET_USED(dev);
1162         tx_offload_capa =
1163                 DEV_TX_OFFLOAD_VLAN_INSERT |
1164                 DEV_TX_OFFLOAD_IPV4_CKSUM  |
1165                 DEV_TX_OFFLOAD_UDP_CKSUM   |
1166                 DEV_TX_OFFLOAD_TCP_CKSUM;
1167
1168         return tx_offload_capa;
1169 }
1170
1171 uint64_t
1172 em_get_tx_queue_offloads_capa(struct rte_eth_dev *dev)
1173 {
1174         uint64_t tx_queue_offload_capa;
1175
1176         /*
1177          * As only one Tx queue can be used, let per queue offloading
1178          * capability be same to per port queue offloading capability
1179          * for better convenience.
1180          */
1181         tx_queue_offload_capa = em_get_tx_port_offloads_capa(dev);
1182
1183         return tx_queue_offload_capa;
1184 }
1185
1186 int
1187 eth_em_tx_queue_setup(struct rte_eth_dev *dev,
1188                          uint16_t queue_idx,
1189                          uint16_t nb_desc,
1190                          unsigned int socket_id,
1191                          const struct rte_eth_txconf *tx_conf)
1192 {
1193         const struct rte_memzone *tz;
1194         struct em_tx_queue *txq;
1195         struct e1000_hw     *hw;
1196         uint32_t tsize;
1197         uint16_t tx_rs_thresh, tx_free_thresh;
1198         uint64_t offloads;
1199
1200         hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1201
1202         offloads = tx_conf->offloads | dev->data->dev_conf.txmode.offloads;
1203
1204         /*
1205          * Validate number of transmit descriptors.
1206          * It must not exceed hardware maximum, and must be multiple
1207          * of E1000_ALIGN.
1208          */
1209         if (nb_desc % EM_TXD_ALIGN != 0 ||
1210                         (nb_desc > E1000_MAX_RING_DESC) ||
1211                         (nb_desc < E1000_MIN_RING_DESC)) {
1212                 return -(EINVAL);
1213         }
1214
1215         tx_free_thresh = tx_conf->tx_free_thresh;
1216         if (tx_free_thresh == 0)
1217                 tx_free_thresh = (uint16_t)RTE_MIN(nb_desc / 4,
1218                                         DEFAULT_TX_FREE_THRESH);
1219
1220         tx_rs_thresh = tx_conf->tx_rs_thresh;
1221         if (tx_rs_thresh == 0)
1222                 tx_rs_thresh = (uint16_t)RTE_MIN(tx_free_thresh,
1223                                         DEFAULT_TX_RS_THRESH);
1224
1225         if (tx_free_thresh >= (nb_desc - 3)) {
1226                 PMD_INIT_LOG(ERR, "tx_free_thresh must be less than the "
1227                              "number of TX descriptors minus 3. "
1228                              "(tx_free_thresh=%u port=%d queue=%d)",
1229                              (unsigned int)tx_free_thresh,
1230                              (int)dev->data->port_id, (int)queue_idx);
1231                 return -(EINVAL);
1232         }
1233         if (tx_rs_thresh > tx_free_thresh) {
1234                 PMD_INIT_LOG(ERR, "tx_rs_thresh must be less than or equal to "
1235                              "tx_free_thresh. (tx_free_thresh=%u "
1236                              "tx_rs_thresh=%u port=%d queue=%d)",
1237                              (unsigned int)tx_free_thresh,
1238                              (unsigned int)tx_rs_thresh,
1239                              (int)dev->data->port_id,
1240                              (int)queue_idx);
1241                 return -(EINVAL);
1242         }
1243
1244         /*
1245          * If rs_bit_thresh is greater than 1, then TX WTHRESH should be
1246          * set to 0. If WTHRESH is greater than zero, the RS bit is ignored
1247          * by the NIC and all descriptors are written back after the NIC
1248          * accumulates WTHRESH descriptors.
1249          */
1250         if (tx_conf->tx_thresh.wthresh != 0 && tx_rs_thresh != 1) {
1251                 PMD_INIT_LOG(ERR, "TX WTHRESH must be set to 0 if "
1252                              "tx_rs_thresh is greater than 1. (tx_rs_thresh=%u "
1253                              "port=%d queue=%d)", (unsigned int)tx_rs_thresh,
1254                              (int)dev->data->port_id, (int)queue_idx);
1255                 return -(EINVAL);
1256         }
1257
1258         /* Free memory prior to re-allocation if needed... */
1259         if (dev->data->tx_queues[queue_idx] != NULL) {
1260                 em_tx_queue_release(dev->data->tx_queues[queue_idx]);
1261                 dev->data->tx_queues[queue_idx] = NULL;
1262         }
1263
1264         /*
1265          * Allocate TX ring hardware descriptors. A memzone large enough to
1266          * handle the maximum ring size is allocated in order to allow for
1267          * resizing in later calls to the queue setup function.
1268          */
1269         tsize = sizeof(txq->tx_ring[0]) * E1000_MAX_RING_DESC;
1270         tz = rte_eth_dma_zone_reserve(dev, "tx_ring", queue_idx, tsize,
1271                                       RTE_CACHE_LINE_SIZE, socket_id);
1272         if (tz == NULL)
1273                 return -ENOMEM;
1274
1275         /* Allocate the tx queue data structure. */
1276         if ((txq = rte_zmalloc("ethdev TX queue", sizeof(*txq),
1277                         RTE_CACHE_LINE_SIZE)) == NULL)
1278                 return -ENOMEM;
1279
1280         /* Allocate software ring */
1281         if ((txq->sw_ring = rte_zmalloc("txq->sw_ring",
1282                         sizeof(txq->sw_ring[0]) * nb_desc,
1283                         RTE_CACHE_LINE_SIZE)) == NULL) {
1284                 em_tx_queue_release(txq);
1285                 return -ENOMEM;
1286         }
1287
1288         txq->nb_tx_desc = nb_desc;
1289         txq->tx_free_thresh = tx_free_thresh;
1290         txq->tx_rs_thresh = tx_rs_thresh;
1291         txq->pthresh = tx_conf->tx_thresh.pthresh;
1292         txq->hthresh = tx_conf->tx_thresh.hthresh;
1293         txq->wthresh = tx_conf->tx_thresh.wthresh;
1294         txq->queue_id = queue_idx;
1295         txq->port_id = dev->data->port_id;
1296
1297         txq->tdt_reg_addr = E1000_PCI_REG_ADDR(hw, E1000_TDT(queue_idx));
1298         txq->tx_ring_phys_addr = tz->iova;
1299         txq->tx_ring = (struct e1000_data_desc *) tz->addr;
1300
1301         PMD_INIT_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
1302                      txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr);
1303
1304         em_reset_tx_queue(txq);
1305
1306         dev->data->tx_queues[queue_idx] = txq;
1307         txq->offloads = offloads;
1308         return 0;
1309 }
1310
1311 static void
1312 em_rx_queue_release_mbufs(struct em_rx_queue *rxq)
1313 {
1314         unsigned i;
1315
1316         if (rxq->sw_ring != NULL) {
1317                 for (i = 0; i != rxq->nb_rx_desc; i++) {
1318                         if (rxq->sw_ring[i].mbuf != NULL) {
1319                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
1320                                 rxq->sw_ring[i].mbuf = NULL;
1321                         }
1322                 }
1323         }
1324 }
1325
1326 static void
1327 em_rx_queue_release(struct em_rx_queue *rxq)
1328 {
1329         if (rxq != NULL) {
1330                 em_rx_queue_release_mbufs(rxq);
1331                 rte_free(rxq->sw_ring);
1332                 rte_free(rxq);
1333         }
1334 }
1335
1336 void
1337 eth_em_rx_queue_release(void *rxq)
1338 {
1339         em_rx_queue_release(rxq);
1340 }
1341
1342 /* Reset dynamic em_rx_queue fields back to defaults */
1343 static void
1344 em_reset_rx_queue(struct em_rx_queue *rxq)
1345 {
1346         rxq->rx_tail = 0;
1347         rxq->nb_rx_hold = 0;
1348         rxq->pkt_first_seg = NULL;
1349         rxq->pkt_last_seg = NULL;
1350 }
1351
1352 uint64_t
1353 em_get_rx_port_offloads_capa(struct rte_eth_dev *dev)
1354 {
1355         uint64_t rx_offload_capa;
1356         uint32_t max_rx_pktlen;
1357
1358         max_rx_pktlen = em_get_max_pktlen(dev);
1359
1360         rx_offload_capa =
1361                 DEV_RX_OFFLOAD_VLAN_STRIP  |
1362                 DEV_RX_OFFLOAD_VLAN_FILTER |
1363                 DEV_RX_OFFLOAD_IPV4_CKSUM  |
1364                 DEV_RX_OFFLOAD_UDP_CKSUM   |
1365                 DEV_RX_OFFLOAD_TCP_CKSUM   |
1366                 DEV_RX_OFFLOAD_CRC_STRIP   |
1367                 DEV_RX_OFFLOAD_SCATTER;
1368         if (max_rx_pktlen > ETHER_MAX_LEN)
1369                 rx_offload_capa |= DEV_RX_OFFLOAD_JUMBO_FRAME;
1370
1371         return rx_offload_capa;
1372 }
1373
1374 uint64_t
1375 em_get_rx_queue_offloads_capa(struct rte_eth_dev *dev)
1376 {
1377         uint64_t rx_queue_offload_capa;
1378
1379         /*
1380          * As only one Rx queue can be used, let per queue offloading
1381          * capability be same to per port queue offloading capability
1382          * for better convenience.
1383          */
1384         rx_queue_offload_capa = em_get_rx_port_offloads_capa(dev);
1385
1386         return rx_queue_offload_capa;
1387 }
1388
1389 int
1390 eth_em_rx_queue_setup(struct rte_eth_dev *dev,
1391                 uint16_t queue_idx,
1392                 uint16_t nb_desc,
1393                 unsigned int socket_id,
1394                 const struct rte_eth_rxconf *rx_conf,
1395                 struct rte_mempool *mp)
1396 {
1397         const struct rte_memzone *rz;
1398         struct em_rx_queue *rxq;
1399         struct e1000_hw     *hw;
1400         uint32_t rsize;
1401         uint64_t offloads;
1402
1403         hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1404
1405         offloads = rx_conf->offloads | dev->data->dev_conf.rxmode.offloads;
1406
1407         /*
1408          * Validate number of receive descriptors.
1409          * It must not exceed hardware maximum, and must be multiple
1410          * of E1000_ALIGN.
1411          */
1412         if (nb_desc % EM_RXD_ALIGN != 0 ||
1413                         (nb_desc > E1000_MAX_RING_DESC) ||
1414                         (nb_desc < E1000_MIN_RING_DESC)) {
1415                 return -EINVAL;
1416         }
1417
1418         /*
1419          * EM devices don't support drop_en functionality
1420          */
1421         if (rx_conf->rx_drop_en) {
1422                 PMD_INIT_LOG(ERR, "drop_en functionality not supported by "
1423                              "device");
1424                 return -EINVAL;
1425         }
1426
1427         /* Free memory prior to re-allocation if needed. */
1428         if (dev->data->rx_queues[queue_idx] != NULL) {
1429                 em_rx_queue_release(dev->data->rx_queues[queue_idx]);
1430                 dev->data->rx_queues[queue_idx] = NULL;
1431         }
1432
1433         /* Allocate RX ring for max possible mumber of hardware descriptors. */
1434         rsize = sizeof(rxq->rx_ring[0]) * E1000_MAX_RING_DESC;
1435         rz = rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx, rsize,
1436                                       RTE_CACHE_LINE_SIZE, socket_id);
1437         if (rz == NULL)
1438                 return -ENOMEM;
1439
1440         /* Allocate the RX queue data structure. */
1441         if ((rxq = rte_zmalloc("ethdev RX queue", sizeof(*rxq),
1442                         RTE_CACHE_LINE_SIZE)) == NULL)
1443                 return -ENOMEM;
1444
1445         /* Allocate software ring. */
1446         if ((rxq->sw_ring = rte_zmalloc("rxq->sw_ring",
1447                         sizeof (rxq->sw_ring[0]) * nb_desc,
1448                         RTE_CACHE_LINE_SIZE)) == NULL) {
1449                 em_rx_queue_release(rxq);
1450                 return -ENOMEM;
1451         }
1452
1453         rxq->mb_pool = mp;
1454         rxq->nb_rx_desc = nb_desc;
1455         rxq->pthresh = rx_conf->rx_thresh.pthresh;
1456         rxq->hthresh = rx_conf->rx_thresh.hthresh;
1457         rxq->wthresh = rx_conf->rx_thresh.wthresh;
1458         rxq->rx_free_thresh = rx_conf->rx_free_thresh;
1459         rxq->queue_id = queue_idx;
1460         rxq->port_id = dev->data->port_id;
1461         rxq->crc_len = (uint8_t)((dev->data->dev_conf.rxmode.offloads &
1462                 DEV_RX_OFFLOAD_CRC_STRIP) ? 0 : ETHER_CRC_LEN);
1463
1464         rxq->rdt_reg_addr = E1000_PCI_REG_ADDR(hw, E1000_RDT(queue_idx));
1465         rxq->rdh_reg_addr = E1000_PCI_REG_ADDR(hw, E1000_RDH(queue_idx));
1466         rxq->rx_ring_phys_addr = rz->iova;
1467         rxq->rx_ring = (struct e1000_rx_desc *) rz->addr;
1468
1469         PMD_INIT_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
1470                      rxq->sw_ring, rxq->rx_ring, rxq->rx_ring_phys_addr);
1471
1472         dev->data->rx_queues[queue_idx] = rxq;
1473         em_reset_rx_queue(rxq);
1474         rxq->offloads = offloads;
1475
1476         return 0;
1477 }
1478
1479 uint32_t
1480 eth_em_rx_queue_count(struct rte_eth_dev *dev, uint16_t rx_queue_id)
1481 {
1482 #define EM_RXQ_SCAN_INTERVAL 4
1483         volatile struct e1000_rx_desc *rxdp;
1484         struct em_rx_queue *rxq;
1485         uint32_t desc = 0;
1486
1487         rxq = dev->data->rx_queues[rx_queue_id];
1488         rxdp = &(rxq->rx_ring[rxq->rx_tail]);
1489
1490         while ((desc < rxq->nb_rx_desc) &&
1491                 (rxdp->status & E1000_RXD_STAT_DD)) {
1492                 desc += EM_RXQ_SCAN_INTERVAL;
1493                 rxdp += EM_RXQ_SCAN_INTERVAL;
1494                 if (rxq->rx_tail + desc >= rxq->nb_rx_desc)
1495                         rxdp = &(rxq->rx_ring[rxq->rx_tail +
1496                                 desc - rxq->nb_rx_desc]);
1497         }
1498
1499         return desc;
1500 }
1501
1502 int
1503 eth_em_rx_descriptor_done(void *rx_queue, uint16_t offset)
1504 {
1505         volatile struct e1000_rx_desc *rxdp;
1506         struct em_rx_queue *rxq = rx_queue;
1507         uint32_t desc;
1508
1509         if (unlikely(offset >= rxq->nb_rx_desc))
1510                 return 0;
1511         desc = rxq->rx_tail + offset;
1512         if (desc >= rxq->nb_rx_desc)
1513                 desc -= rxq->nb_rx_desc;
1514
1515         rxdp = &rxq->rx_ring[desc];
1516         return !!(rxdp->status & E1000_RXD_STAT_DD);
1517 }
1518
1519 int
1520 eth_em_rx_descriptor_status(void *rx_queue, uint16_t offset)
1521 {
1522         struct em_rx_queue *rxq = rx_queue;
1523         volatile uint8_t *status;
1524         uint32_t desc;
1525
1526         if (unlikely(offset >= rxq->nb_rx_desc))
1527                 return -EINVAL;
1528
1529         if (offset >= rxq->nb_rx_desc - rxq->nb_rx_hold)
1530                 return RTE_ETH_RX_DESC_UNAVAIL;
1531
1532         desc = rxq->rx_tail + offset;
1533         if (desc >= rxq->nb_rx_desc)
1534                 desc -= rxq->nb_rx_desc;
1535
1536         status = &rxq->rx_ring[desc].status;
1537         if (*status & E1000_RXD_STAT_DD)
1538                 return RTE_ETH_RX_DESC_DONE;
1539
1540         return RTE_ETH_RX_DESC_AVAIL;
1541 }
1542
1543 int
1544 eth_em_tx_descriptor_status(void *tx_queue, uint16_t offset)
1545 {
1546         struct em_tx_queue *txq = tx_queue;
1547         volatile uint8_t *status;
1548         uint32_t desc;
1549
1550         if (unlikely(offset >= txq->nb_tx_desc))
1551                 return -EINVAL;
1552
1553         desc = txq->tx_tail + offset;
1554         /* go to next desc that has the RS bit */
1555         desc = ((desc + txq->tx_rs_thresh - 1) / txq->tx_rs_thresh) *
1556                 txq->tx_rs_thresh;
1557         if (desc >= txq->nb_tx_desc) {
1558                 desc -= txq->nb_tx_desc;
1559                 if (desc >= txq->nb_tx_desc)
1560                         desc -= txq->nb_tx_desc;
1561         }
1562
1563         status = &txq->tx_ring[desc].upper.fields.status;
1564         if (*status & E1000_TXD_STAT_DD)
1565                 return RTE_ETH_TX_DESC_DONE;
1566
1567         return RTE_ETH_TX_DESC_FULL;
1568 }
1569
1570 void
1571 em_dev_clear_queues(struct rte_eth_dev *dev)
1572 {
1573         uint16_t i;
1574         struct em_tx_queue *txq;
1575         struct em_rx_queue *rxq;
1576
1577         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1578                 txq = dev->data->tx_queues[i];
1579                 if (txq != NULL) {
1580                         em_tx_queue_release_mbufs(txq);
1581                         em_reset_tx_queue(txq);
1582                 }
1583         }
1584
1585         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1586                 rxq = dev->data->rx_queues[i];
1587                 if (rxq != NULL) {
1588                         em_rx_queue_release_mbufs(rxq);
1589                         em_reset_rx_queue(rxq);
1590                 }
1591         }
1592 }
1593
1594 void
1595 em_dev_free_queues(struct rte_eth_dev *dev)
1596 {
1597         uint16_t i;
1598
1599         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1600                 eth_em_rx_queue_release(dev->data->rx_queues[i]);
1601                 dev->data->rx_queues[i] = NULL;
1602         }
1603         dev->data->nb_rx_queues = 0;
1604
1605         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1606                 eth_em_tx_queue_release(dev->data->tx_queues[i]);
1607                 dev->data->tx_queues[i] = NULL;
1608         }
1609         dev->data->nb_tx_queues = 0;
1610 }
1611
1612 /*
1613  * Takes as input/output parameter RX buffer size.
1614  * Returns (BSIZE | BSEX | FLXBUF) fields of RCTL register.
1615  */
1616 static uint32_t
1617 em_rctl_bsize(__rte_unused enum e1000_mac_type hwtyp, uint32_t *bufsz)
1618 {
1619         /*
1620          * For BSIZE & BSEX all configurable sizes are:
1621          * 16384: rctl |= (E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX);
1622          *  8192: rctl |= (E1000_RCTL_SZ_8192  | E1000_RCTL_BSEX);
1623          *  4096: rctl |= (E1000_RCTL_SZ_4096  | E1000_RCTL_BSEX);
1624          *  2048: rctl |= E1000_RCTL_SZ_2048;
1625          *  1024: rctl |= E1000_RCTL_SZ_1024;
1626          *   512: rctl |= E1000_RCTL_SZ_512;
1627          *   256: rctl |= E1000_RCTL_SZ_256;
1628          */
1629         static const struct {
1630                 uint32_t bufsz;
1631                 uint32_t rctl;
1632         } bufsz_to_rctl[] = {
1633                 {16384, (E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX)},
1634                 {8192,  (E1000_RCTL_SZ_8192  | E1000_RCTL_BSEX)},
1635                 {4096,  (E1000_RCTL_SZ_4096  | E1000_RCTL_BSEX)},
1636                 {2048,  E1000_RCTL_SZ_2048},
1637                 {1024,  E1000_RCTL_SZ_1024},
1638                 {512,   E1000_RCTL_SZ_512},
1639                 {256,   E1000_RCTL_SZ_256},
1640         };
1641
1642         int i;
1643         uint32_t rctl_bsize;
1644
1645         rctl_bsize = *bufsz;
1646
1647         /*
1648          * Starting from 82571 it is possible to specify RX buffer size
1649          * by RCTL.FLXBUF. When this field is different from zero, the
1650          * RX buffer size = RCTL.FLXBUF * 1K
1651          * (e.g. t is possible to specify RX buffer size  1,2,...,15KB).
1652          * It is working ok on real HW, but by some reason doesn't work
1653          * on VMware emulated 82574L.
1654          * So for now, always use BSIZE/BSEX to setup RX buffer size.
1655          * If you don't plan to use it on VMware emulated 82574L and
1656          * would like to specify RX buffer size in 1K granularity,
1657          * uncomment the following lines:
1658          * ***************************************************************
1659          * if (hwtyp >= e1000_82571 && hwtyp <= e1000_82574 &&
1660          *              rctl_bsize >= EM_RCTL_FLXBUF_STEP) {
1661          *      rctl_bsize /= EM_RCTL_FLXBUF_STEP;
1662          *      *bufsz = rctl_bsize;
1663          *      return (rctl_bsize << E1000_RCTL_FLXBUF_SHIFT &
1664          *              E1000_RCTL_FLXBUF_MASK);
1665          * }
1666          * ***************************************************************
1667          */
1668
1669         for (i = 0; i != sizeof(bufsz_to_rctl) / sizeof(bufsz_to_rctl[0]);
1670                         i++) {
1671                 if (rctl_bsize >= bufsz_to_rctl[i].bufsz) {
1672                         *bufsz = bufsz_to_rctl[i].bufsz;
1673                         return bufsz_to_rctl[i].rctl;
1674                 }
1675         }
1676
1677         /* Should never happen. */
1678         return -EINVAL;
1679 }
1680
1681 static int
1682 em_alloc_rx_queue_mbufs(struct em_rx_queue *rxq)
1683 {
1684         struct em_rx_entry *rxe = rxq->sw_ring;
1685         uint64_t dma_addr;
1686         unsigned i;
1687         static const struct e1000_rx_desc rxd_init = {
1688                 .buffer_addr = 0,
1689         };
1690
1691         /* Initialize software ring entries */
1692         for (i = 0; i < rxq->nb_rx_desc; i++) {
1693                 volatile struct e1000_rx_desc *rxd;
1694                 struct rte_mbuf *mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
1695
1696                 if (mbuf == NULL) {
1697                         PMD_INIT_LOG(ERR, "RX mbuf alloc failed "
1698                                      "queue_id=%hu", rxq->queue_id);
1699                         return -ENOMEM;
1700                 }
1701
1702                 dma_addr =
1703                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(mbuf));
1704
1705                 /* Clear HW ring memory */
1706                 rxq->rx_ring[i] = rxd_init;
1707
1708                 rxd = &rxq->rx_ring[i];
1709                 rxd->buffer_addr = dma_addr;
1710                 rxe[i].mbuf = mbuf;
1711         }
1712
1713         return 0;
1714 }
1715
1716 /*********************************************************************
1717  *
1718  *  Enable receive unit.
1719  *
1720  **********************************************************************/
1721 int
1722 eth_em_rx_init(struct rte_eth_dev *dev)
1723 {
1724         struct e1000_hw *hw;
1725         struct em_rx_queue *rxq;
1726         struct rte_eth_rxmode *rxmode;
1727         uint32_t rctl;
1728         uint32_t rfctl;
1729         uint32_t rxcsum;
1730         uint32_t rctl_bsize;
1731         uint16_t i;
1732         int ret;
1733
1734         hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1735         rxmode = &dev->data->dev_conf.rxmode;
1736
1737         /*
1738          * Make sure receives are disabled while setting
1739          * up the descriptor ring.
1740          */
1741         rctl = E1000_READ_REG(hw, E1000_RCTL);
1742         E1000_WRITE_REG(hw, E1000_RCTL, rctl & ~E1000_RCTL_EN);
1743
1744         rfctl = E1000_READ_REG(hw, E1000_RFCTL);
1745
1746         /* Disable extended descriptor type. */
1747         rfctl &= ~E1000_RFCTL_EXTEN;
1748         /* Disable accelerated acknowledge */
1749         if (hw->mac.type == e1000_82574)
1750                 rfctl |= E1000_RFCTL_ACK_DIS;
1751
1752         E1000_WRITE_REG(hw, E1000_RFCTL, rfctl);
1753
1754         /*
1755          * XXX TEMPORARY WORKAROUND: on some systems with 82573
1756          * long latencies are observed, like Lenovo X60. This
1757          * change eliminates the problem, but since having positive
1758          * values in RDTR is a known source of problems on other
1759          * platforms another solution is being sought.
1760          */
1761         if (hw->mac.type == e1000_82573)
1762                 E1000_WRITE_REG(hw, E1000_RDTR, 0x20);
1763
1764         dev->rx_pkt_burst = (eth_rx_burst_t)eth_em_recv_pkts;
1765
1766         /* Determine RX bufsize. */
1767         rctl_bsize = EM_MAX_BUF_SIZE;
1768         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1769                 uint32_t buf_size;
1770
1771                 rxq = dev->data->rx_queues[i];
1772                 buf_size = rte_pktmbuf_data_room_size(rxq->mb_pool) -
1773                         RTE_PKTMBUF_HEADROOM;
1774                 rctl_bsize = RTE_MIN(rctl_bsize, buf_size);
1775         }
1776
1777         rctl |= em_rctl_bsize(hw->mac.type, &rctl_bsize);
1778
1779         /* Configure and enable each RX queue. */
1780         for (i = 0; i < dev->data->nb_rx_queues; i++) {
1781                 uint64_t bus_addr;
1782                 uint32_t rxdctl;
1783
1784                 rxq = dev->data->rx_queues[i];
1785
1786                 /* Allocate buffers for descriptor rings and setup queue */
1787                 ret = em_alloc_rx_queue_mbufs(rxq);
1788                 if (ret)
1789                         return ret;
1790
1791                 /*
1792                  * Reset crc_len in case it was changed after queue setup by a
1793                  *  call to configure
1794                  */
1795                 rxq->crc_len =
1796                         (uint8_t)(dev->data->dev_conf.rxmode.offloads &
1797                                 DEV_RX_OFFLOAD_CRC_STRIP ? 0 : ETHER_CRC_LEN);
1798
1799                 bus_addr = rxq->rx_ring_phys_addr;
1800                 E1000_WRITE_REG(hw, E1000_RDLEN(i),
1801                                 rxq->nb_rx_desc *
1802                                 sizeof(*rxq->rx_ring));
1803                 E1000_WRITE_REG(hw, E1000_RDBAH(i),
1804                                 (uint32_t)(bus_addr >> 32));
1805                 E1000_WRITE_REG(hw, E1000_RDBAL(i), (uint32_t)bus_addr);
1806
1807                 E1000_WRITE_REG(hw, E1000_RDH(i), 0);
1808                 E1000_WRITE_REG(hw, E1000_RDT(i), rxq->nb_rx_desc - 1);
1809
1810                 rxdctl = E1000_READ_REG(hw, E1000_RXDCTL(0));
1811                 rxdctl &= 0xFE000000;
1812                 rxdctl |= rxq->pthresh & 0x3F;
1813                 rxdctl |= (rxq->hthresh & 0x3F) << 8;
1814                 rxdctl |= (rxq->wthresh & 0x3F) << 16;
1815                 rxdctl |= E1000_RXDCTL_GRAN;
1816                 E1000_WRITE_REG(hw, E1000_RXDCTL(i), rxdctl);
1817
1818                 /*
1819                  * Due to EM devices not having any sort of hardware
1820                  * limit for packet length, jumbo frame of any size
1821                  * can be accepted, thus we have to enable scattered
1822                  * rx if jumbo frames are enabled (or if buffer size
1823                  * is too small to accommodate non-jumbo packets)
1824                  * to avoid splitting packets that don't fit into
1825                  * one buffer.
1826                  */
1827                 if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME ||
1828                                 rctl_bsize < ETHER_MAX_LEN) {
1829                         if (!dev->data->scattered_rx)
1830                                 PMD_INIT_LOG(DEBUG, "forcing scatter mode");
1831                         dev->rx_pkt_burst =
1832                                 (eth_rx_burst_t)eth_em_recv_scattered_pkts;
1833                         dev->data->scattered_rx = 1;
1834                 }
1835         }
1836
1837         if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_SCATTER) {
1838                 if (!dev->data->scattered_rx)
1839                         PMD_INIT_LOG(DEBUG, "forcing scatter mode");
1840                 dev->rx_pkt_burst = eth_em_recv_scattered_pkts;
1841                 dev->data->scattered_rx = 1;
1842         }
1843
1844         /*
1845          * Setup the Checksum Register.
1846          * Receive Full-Packet Checksum Offload is mutually exclusive with RSS.
1847          */
1848         rxcsum = E1000_READ_REG(hw, E1000_RXCSUM);
1849
1850         if (rxmode->offloads & DEV_RX_OFFLOAD_CHECKSUM)
1851                 rxcsum |= E1000_RXCSUM_IPOFL;
1852         else
1853                 rxcsum &= ~E1000_RXCSUM_IPOFL;
1854         E1000_WRITE_REG(hw, E1000_RXCSUM, rxcsum);
1855
1856         /* No MRQ or RSS support for now */
1857
1858         /* Set early receive threshold on appropriate hw */
1859         if ((hw->mac.type == e1000_ich9lan ||
1860                         hw->mac.type == e1000_pch2lan ||
1861                         hw->mac.type == e1000_ich10lan) &&
1862                         rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
1863                 u32 rxdctl = E1000_READ_REG(hw, E1000_RXDCTL(0));
1864                 E1000_WRITE_REG(hw, E1000_RXDCTL(0), rxdctl | 3);
1865                 E1000_WRITE_REG(hw, E1000_ERT, 0x100 | (1 << 13));
1866         }
1867
1868         if (hw->mac.type == e1000_pch2lan) {
1869                 if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME)
1870                         e1000_lv_jumbo_workaround_ich8lan(hw, TRUE);
1871                 else
1872                         e1000_lv_jumbo_workaround_ich8lan(hw, FALSE);
1873         }
1874
1875         /* Setup the Receive Control Register. */
1876         if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_CRC_STRIP)
1877                 rctl |= E1000_RCTL_SECRC; /* Strip Ethernet CRC. */
1878         else
1879                 rctl &= ~E1000_RCTL_SECRC; /* Do not Strip Ethernet CRC. */
1880
1881         rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
1882         rctl |= E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
1883                 E1000_RCTL_RDMTS_HALF |
1884                 (hw->mac.mc_filter_type << E1000_RCTL_MO_SHIFT);
1885
1886         /* Make sure VLAN Filters are off. */
1887         rctl &= ~E1000_RCTL_VFE;
1888         /* Don't store bad packets. */
1889         rctl &= ~E1000_RCTL_SBP;
1890         /* Legacy descriptor type. */
1891         rctl &= ~E1000_RCTL_DTYP_MASK;
1892
1893         /*
1894          * Configure support of jumbo frames, if any.
1895          */
1896         if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME)
1897                 rctl |= E1000_RCTL_LPE;
1898         else
1899                 rctl &= ~E1000_RCTL_LPE;
1900
1901         /* Enable Receives. */
1902         E1000_WRITE_REG(hw, E1000_RCTL, rctl);
1903
1904         return 0;
1905 }
1906
1907 /*********************************************************************
1908  *
1909  *  Enable transmit unit.
1910  *
1911  **********************************************************************/
1912 void
1913 eth_em_tx_init(struct rte_eth_dev *dev)
1914 {
1915         struct e1000_hw     *hw;
1916         struct em_tx_queue *txq;
1917         uint32_t tctl;
1918         uint32_t txdctl;
1919         uint16_t i;
1920
1921         hw = E1000_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1922
1923         /* Setup the Base and Length of the Tx Descriptor Rings. */
1924         for (i = 0; i < dev->data->nb_tx_queues; i++) {
1925                 uint64_t bus_addr;
1926
1927                 txq = dev->data->tx_queues[i];
1928                 bus_addr = txq->tx_ring_phys_addr;
1929                 E1000_WRITE_REG(hw, E1000_TDLEN(i),
1930                                 txq->nb_tx_desc *
1931                                 sizeof(*txq->tx_ring));
1932                 E1000_WRITE_REG(hw, E1000_TDBAH(i),
1933                                 (uint32_t)(bus_addr >> 32));
1934                 E1000_WRITE_REG(hw, E1000_TDBAL(i), (uint32_t)bus_addr);
1935
1936                 /* Setup the HW Tx Head and Tail descriptor pointers. */
1937                 E1000_WRITE_REG(hw, E1000_TDT(i), 0);
1938                 E1000_WRITE_REG(hw, E1000_TDH(i), 0);
1939
1940                 /* Setup Transmit threshold registers. */
1941                 txdctl = E1000_READ_REG(hw, E1000_TXDCTL(i));
1942                 /*
1943                  * bit 22 is reserved, on some models should always be 0,
1944                  * on others  - always 1.
1945                  */
1946                 txdctl &= E1000_TXDCTL_COUNT_DESC;
1947                 txdctl |= txq->pthresh & 0x3F;
1948                 txdctl |= (txq->hthresh & 0x3F) << 8;
1949                 txdctl |= (txq->wthresh & 0x3F) << 16;
1950                 txdctl |= E1000_TXDCTL_GRAN;
1951                 E1000_WRITE_REG(hw, E1000_TXDCTL(i), txdctl);
1952         }
1953
1954         /* Program the Transmit Control Register. */
1955         tctl = E1000_READ_REG(hw, E1000_TCTL);
1956         tctl &= ~E1000_TCTL_CT;
1957         tctl |= (E1000_TCTL_PSP | E1000_TCTL_RTLC | E1000_TCTL_EN |
1958                  (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT));
1959
1960         /* This write will effectively turn on the transmit unit. */
1961         E1000_WRITE_REG(hw, E1000_TCTL, tctl);
1962 }
1963
1964 void
1965 em_rxq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
1966         struct rte_eth_rxq_info *qinfo)
1967 {
1968         struct em_rx_queue *rxq;
1969
1970         rxq = dev->data->rx_queues[queue_id];
1971
1972         qinfo->mp = rxq->mb_pool;
1973         qinfo->scattered_rx = dev->data->scattered_rx;
1974         qinfo->nb_desc = rxq->nb_rx_desc;
1975         qinfo->conf.rx_free_thresh = rxq->rx_free_thresh;
1976         qinfo->conf.offloads = rxq->offloads;
1977 }
1978
1979 void
1980 em_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
1981         struct rte_eth_txq_info *qinfo)
1982 {
1983         struct em_tx_queue *txq;
1984
1985         txq = dev->data->tx_queues[queue_id];
1986
1987         qinfo->nb_desc = txq->nb_tx_desc;
1988
1989         qinfo->conf.tx_thresh.pthresh = txq->pthresh;
1990         qinfo->conf.tx_thresh.hthresh = txq->hthresh;
1991         qinfo->conf.tx_thresh.wthresh = txq->wthresh;
1992         qinfo->conf.tx_free_thresh = txq->tx_free_thresh;
1993         qinfo->conf.tx_rs_thresh = txq->tx_rs_thresh;
1994         qinfo->conf.offloads = txq->offloads;
1995 }