drivers/net/bnxt/bnxt_rxtx_vec_sse.c

   1 // SPDX-License-Identifier: BSD-3-Clause
   2 /* Copyright(c) 2019 Broadcom All rights reserved. */
   3
   4 #include <inttypes.h>
   5 #include <stdbool.h>
   6
   7 #include <rte_bitmap.h>
   8 #include <rte_byteorder.h>
   9 #include <rte_malloc.h>
  10 #include <rte_memory.h>
  11 #if defined(RTE_ARCH_X86)
  12 #include <tmmintrin.h>
  13 #else
  14 #error "bnxt vector pmd: unsupported target."
  15 #endif
  16
  17 #include "bnxt.h"
  18 #include "bnxt_cpr.h"
  19 #include "bnxt_ring.h"
  20 #include "bnxt_rxtx_vec_common.h"
  21
  22 #include "bnxt_txq.h"
  23 #include "bnxt_txr.h"
  24
  25 /*
  26  * RX Ring handling
  27  */
  28
  29 static inline void
  30 bnxt_rxq_rearm(struct bnxt_rx_queue *rxq, struct bnxt_rx_ring_info *rxr)
  31 {
  32         struct rx_prod_pkt_bd *rxbds = &rxr->rx_desc_ring[rxq->rxrearm_start];
  33         struct rte_mbuf **rx_bufs = &rxr->rx_buf_ring[rxq->rxrearm_start];
  34         struct rte_mbuf *mb0, *mb1;
  35         int nb, i;
  36
  37         const __m128i hdr_room = _mm_set_epi64x(RTE_PKTMBUF_HEADROOM, 0);
  38         const __m128i addrmask = _mm_set_epi64x(UINT64_MAX, 0);
  39
  40         /*
  41          * Number of mbufs to allocate must be a multiple of two. The
  42          * allocation must not go past the end of the ring.
  43          */
  44         nb = RTE_MIN(rxq->rxrearm_nb & ~0x1,
  45                      rxq->nb_rx_desc - rxq->rxrearm_start);
  46
  47         /* Allocate new mbufs into the software ring */
  48         if (rte_mempool_get_bulk(rxq->mb_pool, (void *)rx_bufs, nb) < 0) {
  49                 rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed += nb;
  50
  51                 return;
  52         }
  53
  54         /* Initialize the mbufs in vector, process 2 mbufs in one loop */
  55         for (i = 0; i < nb; i += 2, rx_bufs += 2) {
  56                 __m128i buf_addr0, buf_addr1;
  57                 __m128i rxbd0, rxbd1;
  58
  59                 mb0 = rx_bufs[0];
  60                 mb1 = rx_bufs[1];
  61
  62                 /* Load address fields from both mbufs */
  63                 buf_addr0 = _mm_loadu_si128((__m128i *)&mb0->buf_addr);
  64                 buf_addr1 = _mm_loadu_si128((__m128i *)&mb1->buf_addr);
  65
  66                 /* Load both rx descriptors (preserving some existing fields) */
  67                 rxbd0 = _mm_loadu_si128((__m128i *)(rxbds + 0));
  68                 rxbd1 = _mm_loadu_si128((__m128i *)(rxbds + 1));
  69
  70                 /* Add default offset to buffer address. */
  71                 buf_addr0 = _mm_add_epi64(buf_addr0, hdr_room);
  72                 buf_addr1 = _mm_add_epi64(buf_addr1, hdr_room);
  73
  74                 /* Clear all fields except address. */
  75                 buf_addr0 =  _mm_and_si128(buf_addr0, addrmask);
  76                 buf_addr1 =  _mm_and_si128(buf_addr1, addrmask);
  77
  78                 /* Clear address field in descriptor. */
  79                 rxbd0 = _mm_andnot_si128(addrmask, rxbd0);
  80                 rxbd1 = _mm_andnot_si128(addrmask, rxbd1);
  81
  82                 /* Set address field in descriptor. */
  83                 rxbd0 = _mm_add_epi64(rxbd0, buf_addr0);
  84                 rxbd1 = _mm_add_epi64(rxbd1, buf_addr1);
  85
  86                 /* Store descriptors to memory. */
  87                 _mm_store_si128((__m128i *)(rxbds++), rxbd0);
  88                 _mm_store_si128((__m128i *)(rxbds++), rxbd1);
  89         }
  90
  91         rxq->rxrearm_start += nb;
  92         bnxt_db_write(&rxr->rx_db, rxq->rxrearm_start - 1);
  93         if (rxq->rxrearm_start >= rxq->nb_rx_desc)
  94                 rxq->rxrearm_start = 0;
  95
  96         rxq->rxrearm_nb -= nb;
  97 }
  98
  99 static uint32_t
 100 bnxt_parse_pkt_type(struct rx_pkt_cmpl *rxcmp, struct rx_pkt_cmpl_hi *rxcmp1)
 101 {
 102         uint32_t l3, pkt_type = 0;
 103         uint32_t t_ipcs = 0, ip6 = 0, vlan = 0;
 104         uint32_t flags_type;
 105
 106         vlan = !!(rxcmp1->flags2 &
 107                 rte_cpu_to_le_32(RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN));
 108         pkt_type |= vlan ? RTE_PTYPE_L2_ETHER_VLAN : RTE_PTYPE_L2_ETHER;
 109
 110         t_ipcs = !!(rxcmp1->flags2 &
 111                 rte_cpu_to_le_32(RX_PKT_CMPL_FLAGS2_T_IP_CS_CALC));
 112         ip6 = !!(rxcmp1->flags2 &
 113                  rte_cpu_to_le_32(RX_PKT_CMPL_FLAGS2_IP_TYPE));
 114
 115         flags_type = rxcmp->flags_type &
 116                 rte_cpu_to_le_32(RX_PKT_CMPL_FLAGS_ITYPE_MASK);
 117
 118         if (!t_ipcs && !ip6)
 119                 l3 = RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
 120         else if (!t_ipcs && ip6)
 121                 l3 = RTE_PTYPE_L3_IPV6_EXT_UNKNOWN;
 122         else if (t_ipcs && !ip6)
 123                 l3 = RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN;
 124         else
 125                 l3 = RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN;
 126
 127         switch (flags_type) {
 128         case RTE_LE32(RX_PKT_CMPL_FLAGS_ITYPE_ICMP):
 129                 if (!t_ipcs)
 130                         pkt_type |= l3 | RTE_PTYPE_L4_ICMP;
 131                 else
 132                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_ICMP;
 133                 break;
 134
 135         case RTE_LE32(RX_PKT_CMPL_FLAGS_ITYPE_TCP):
 136                 if (!t_ipcs)
 137                         pkt_type |= l3 | RTE_PTYPE_L4_TCP;
 138                 else
 139                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_TCP;
 140                 break;
 141
 142         case RTE_LE32(RX_PKT_CMPL_FLAGS_ITYPE_UDP):
 143                 if (!t_ipcs)
 144                         pkt_type |= l3 | RTE_PTYPE_L4_UDP;
 145                 else
 146                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_UDP;
 147                 break;
 148
 149         case RTE_LE32(RX_PKT_CMPL_FLAGS_ITYPE_IP):
 150                 pkt_type |= l3;
 151                 break;
 152         }
 153
 154         return pkt_type;
 155 }
 156
 157 static void
 158 bnxt_parse_csum(struct rte_mbuf *mbuf, struct rx_pkt_cmpl_hi *rxcmp1)
 159 {
 160         uint32_t flags;
 161
 162         flags = flags2_0xf(rxcmp1);
 163         /* IP Checksum */
 164         if (likely(IS_IP_NONTUNNEL_PKT(flags))) {
 165                 if (unlikely(RX_CMP_IP_CS_ERROR(rxcmp1)))
 166                         mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
 167                 else
 168                         mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 169         } else if (IS_IP_TUNNEL_PKT(flags)) {
 170                 if (unlikely(RX_CMP_IP_OUTER_CS_ERROR(rxcmp1) ||
 171                              RX_CMP_IP_CS_ERROR(rxcmp1)))
 172                         mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
 173                 else
 174                         mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 175         } else if (unlikely(RX_CMP_IP_CS_UNKNOWN(rxcmp1))) {
 176                 mbuf->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
 177         }
 178
 179         /* L4 Checksum */
 180         if (likely(IS_L4_NONTUNNEL_PKT(flags))) {
 181                 if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
 182                         mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 183                 else
 184                         mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
 185         } else if (IS_L4_TUNNEL_PKT(flags)) {
 186                 if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
 187                         mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 188                 else
 189                         mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
 190                 if (unlikely(RX_CMP_L4_OUTER_CS_ERR2(rxcmp1))) {
 191                         mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
 192                 } else if (unlikely(IS_L4_TUNNEL_PKT_ONLY_INNER_L4_CS
 193                                     (flags))) {
 194                         mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_UNKNOWN;
 195                 } else {
 196                         mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_GOOD;
 197                 }
 198         } else if (unlikely(RX_CMP_L4_CS_UNKNOWN(rxcmp1))) {
 199                 mbuf->ol_flags |= PKT_RX_L4_CKSUM_UNKNOWN;
 200         }
 201 }
 202
 203 uint16_t
 204 bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
 205                    uint16_t nb_pkts)
 206 {
 207         struct bnxt_rx_queue *rxq = rx_queue;
 208         struct bnxt_cp_ring_info *cpr = rxq->cp_ring;
 209         struct bnxt_rx_ring_info *rxr = rxq->rx_ring;
 210         uint32_t raw_cons = cpr->cp_raw_cons;
 211         uint32_t cons;
 212         int nb_rx_pkts = 0;
 213         struct rx_pkt_cmpl *rxcmp;
 214         const __m128i mbuf_init = _mm_set_epi64x(0, rxq->mbuf_initializer);
 215         const __m128i shuf_msk =
 216                 _mm_set_epi8(15, 14, 13, 12,          /* rss */
 217                              0xFF, 0xFF,              /* vlan_tci (zeroes) */
 218                              3, 2,                    /* data_len */
 219                              0xFF, 0xFF, 3, 2,        /* pkt_len */
 220                              0xFF, 0xFF, 0xFF, 0xFF); /* pkt_type (zeroes) */
 221         int i;
 222
 223         /* If Rx Q was stopped return */
 224         if (unlikely(!rxq->rx_started))
 225                 return 0;
 226
 227         if (rxq->rxrearm_nb >= rxq->rx_free_thresh)
 228                 bnxt_rxq_rearm(rxq, rxr);
 229
 230         /* Return no more than RTE_BNXT_MAX_RX_BURST per call. */
 231         nb_pkts = RTE_MIN(nb_pkts, RTE_BNXT_MAX_RX_BURST);
 232
 233         /*
 234          * Make nb_pkts an integer multiple of RTE_BNXT_DESCS_PER_LOOP.
 235          * nb_pkts < RTE_BNXT_DESCS_PER_LOOP, just return no packet
 236          */
 237         nb_pkts = RTE_ALIGN_FLOOR(nb_pkts, RTE_BNXT_DESCS_PER_LOOP);
 238         if (!nb_pkts)
 239                 return 0;
 240
 241         /* Handle RX burst request */
 242         for (i = 0; i < nb_pkts; i++) {
 243                 struct rx_pkt_cmpl_hi *rxcmp1;
 244                 struct rte_mbuf *mbuf;
 245                 __m128i mm_rxcmp, pkt_mb;
 246
 247                 cons = RING_CMP(cpr->cp_ring_struct, raw_cons);
 248
 249                 rxcmp = (struct rx_pkt_cmpl *)&cpr->cp_desc_ring[cons];
 250                 rxcmp1 = (struct rx_pkt_cmpl_hi *)&cpr->cp_desc_ring[cons + 1];
 251
 252                 if (!CMP_VALID(rxcmp1, raw_cons + 1, cpr->cp_ring_struct))
 253                         break;
 254
 255                 raw_cons += 2;
 256                 cons = rxcmp->opaque;
 257
 258                 mbuf = rxr->rx_buf_ring[cons];
 259                 rte_prefetch0(mbuf);
 260                 rxr->rx_buf_ring[cons] = NULL;
 261
 262                 /* Set constant fields from mbuf initializer. */
 263                 _mm_store_si128((__m128i *)&mbuf->rearm_data, mbuf_init);
 264
 265                 /* Set mbuf pkt_len, data_len, and rss_hash fields. */
 266                 mm_rxcmp = _mm_load_si128((__m128i *)rxcmp);
 267                 pkt_mb = _mm_shuffle_epi8(mm_rxcmp, shuf_msk);
 268                 _mm_storeu_si128((void *)&mbuf->rx_descriptor_fields1, pkt_mb);
 269
 270                 rte_compiler_barrier();
 271
 272                 if (rxcmp->flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID)
 273                         mbuf->ol_flags |= PKT_RX_RSS_HASH;
 274
 275                 if (rxcmp1->flags2 &
 276                     RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN) {
 277                         mbuf->vlan_tci = rxcmp1->metadata &
 278                                 (RX_PKT_CMPL_METADATA_VID_MASK |
 279                                 RX_PKT_CMPL_METADATA_DE |
 280                                 RX_PKT_CMPL_METADATA_PRI_MASK);
 281                         mbuf->ol_flags |=
 282                                 PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
 283                 }
 284
 285                 bnxt_parse_csum(mbuf, rxcmp1);
 286                 mbuf->packet_type = bnxt_parse_pkt_type(rxcmp, rxcmp1);
 287
 288                 rx_pkts[nb_rx_pkts++] = mbuf;
 289         }
 290
 291         if (nb_rx_pkts) {
 292                 rxr->rx_prod =
 293                         RING_ADV(rxr->rx_ring_struct, rxr->rx_prod, nb_rx_pkts);
 294
 295                 rxq->rxrearm_nb += nb_rx_pkts;
 296                 cpr->cp_raw_cons = raw_cons;
 297                 cpr->valid =
 298                         !!(cpr->cp_raw_cons & cpr->cp_ring_struct->ring_size);
 299                 bnxt_db_cq(cpr);
 300         }
 301
 302         return nb_rx_pkts;
 303 }
 304
 305 static void
 306 bnxt_tx_cmp_vec(struct bnxt_tx_queue *txq, int nr_pkts)
 307 {
 308         struct bnxt_tx_ring_info *txr = txq->tx_ring;
 309         struct rte_mbuf **free = txq->free;
 310         uint16_t cons = txr->tx_cons;
 311         unsigned int blk = 0;
 312
 313         while (nr_pkts--) {
 314                 struct bnxt_sw_tx_bd *tx_buf;
 315                 struct rte_mbuf *mbuf;
 316
 317                 tx_buf = &txr->tx_buf_ring[cons];
 318                 cons = RING_NEXT(txr->tx_ring_struct, cons);
 319                 mbuf = rte_pktmbuf_prefree_seg(tx_buf->mbuf);
 320                 if (unlikely(mbuf == NULL))
 321                         continue;
 322                 tx_buf->mbuf = NULL;
 323
 324                 if (blk && mbuf->pool != free[0]->pool) {
 325                         rte_mempool_put_bulk(free[0]->pool, (void **)free, blk);
 326                         blk = 0;
 327                 }
 328                 free[blk++] = mbuf;
 329         }
 330         if (blk)
 331                 rte_mempool_put_bulk(free[0]->pool, (void **)free, blk);
 332
 333         txr->tx_cons = cons;
 334 }
 335
 336 static void
 337 bnxt_handle_tx_cp_vec(struct bnxt_tx_queue *txq)
 338 {
 339         struct bnxt_cp_ring_info *cpr = txq->cp_ring;
 340         uint32_t raw_cons = cpr->cp_raw_cons;
 341         uint32_t cons;
 342         uint32_t nb_tx_pkts = 0;
 343         struct tx_cmpl *txcmp;
 344         struct cmpl_base *cp_desc_ring = cpr->cp_desc_ring;
 345         struct bnxt_ring *cp_ring_struct = cpr->cp_ring_struct;
 346         uint32_t ring_mask = cp_ring_struct->ring_mask;
 347
 348         do {
 349                 cons = RING_CMPL(ring_mask, raw_cons);
 350                 txcmp = (struct tx_cmpl *)&cp_desc_ring[cons];
 351
 352                 if (!CMP_VALID(txcmp, raw_cons, cp_ring_struct))
 353                         break;
 354
 355                 if (likely(CMP_TYPE(txcmp) == TX_CMPL_TYPE_TX_L2))
 356                         nb_tx_pkts += txcmp->opaque;
 357                 else
 358                         RTE_LOG_DP(ERR, PMD,
 359                                    "Unhandled CMP type %02x\n",
 360                                    CMP_TYPE(txcmp));
 361                 raw_cons = NEXT_RAW_CMP(raw_cons);
 362         } while (nb_tx_pkts < ring_mask);
 363
 364         cpr->valid = !!(raw_cons & cp_ring_struct->ring_size);
 365         if (nb_tx_pkts) {
 366                 bnxt_tx_cmp_vec(txq, nb_tx_pkts);
 367                 cpr->cp_raw_cons = raw_cons;
 368                 bnxt_db_cq(cpr);
 369         }
 370 }
 371
 372 static uint16_t
 373 bnxt_xmit_fixed_burst_vec(void *tx_queue, struct rte_mbuf **tx_pkts,
 374                           uint16_t nb_pkts)
 375 {
 376         struct bnxt_tx_queue *txq = tx_queue;
 377         struct bnxt_tx_ring_info *txr = txq->tx_ring;
 378         uint16_t prod = txr->tx_prod;
 379         struct rte_mbuf *tx_mbuf;
 380         struct tx_bd_long *txbd = NULL;
 381         struct bnxt_sw_tx_bd *tx_buf;
 382         uint16_t to_send;
 383
 384         nb_pkts = RTE_MIN(nb_pkts, bnxt_tx_avail(txq));
 385
 386         if (unlikely(nb_pkts == 0))
 387                 return 0;
 388
 389         /* Handle TX burst request */
 390         to_send = nb_pkts;
 391         while (to_send) {
 392                 tx_mbuf = *tx_pkts++;
 393                 rte_prefetch0(tx_mbuf);
 394
 395                 tx_buf = &txr->tx_buf_ring[prod];
 396                 tx_buf->mbuf = tx_mbuf;
 397                 tx_buf->nr_bds = 1;
 398
 399                 txbd = &txr->tx_desc_ring[prod];
 400                 txbd->address = tx_mbuf->buf_iova + tx_mbuf->data_off;
 401                 txbd->len = tx_mbuf->data_len;
 402                 txbd->flags_type = bnxt_xmit_flags_len(tx_mbuf->data_len,
 403                                                        TX_BD_FLAGS_NOCMPL);
 404                 prod = RING_NEXT(txr->tx_ring_struct, prod);
 405                 to_send--;
 406         }
 407
 408         /* Request a completion for last packet in burst */
 409         if (txbd) {
 410                 txbd->opaque = nb_pkts;
 411                 txbd->flags_type &= ~TX_BD_LONG_FLAGS_NO_CMPL;
 412         }
 413
 414         rte_compiler_barrier();
 415         bnxt_db_write(&txr->tx_db, prod);
 416
 417         txr->tx_prod = prod;
 418
 419         return nb_pkts;
 420 }
 421
 422 uint16_t
 423 bnxt_xmit_pkts_vec(void *tx_queue, struct rte_mbuf **tx_pkts,
 424                    uint16_t nb_pkts)
 425 {
 426         int nb_sent = 0;
 427         struct bnxt_tx_queue *txq = tx_queue;
 428
 429         /* Tx queue was stopped; wait for it to be restarted */
 430         if (unlikely(!txq->tx_started)) {
 431                 PMD_DRV_LOG(DEBUG, "Tx q stopped;return\n");
 432                 return 0;
 433         }
 434
 435         /* Handle TX completions */
 436         if (bnxt_tx_bds_in_hw(txq) >= txq->tx_free_thresh)
 437                 bnxt_handle_tx_cp_vec(txq);
 438
 439         while (nb_pkts) {
 440                 uint16_t ret, num;
 441
 442                 num = RTE_MIN(nb_pkts, RTE_BNXT_MAX_TX_BURST);
 443                 ret = bnxt_xmit_fixed_burst_vec(tx_queue,
 444                                                 &tx_pkts[nb_sent],
 445                                                 num);
 446                 nb_sent += ret;
 447                 nb_pkts -= ret;
 448                 if (ret < num)
 449                         break;
 450         }
 451
 452         return nb_sent;
 453 }
 454
 455 int __rte_cold
 456 bnxt_rxq_vec_setup(struct bnxt_rx_queue *rxq)
 457 {
 458         return bnxt_rxq_vec_setup_common(rxq);
 459 }