drivers/net/octeontx2/otx2_tx.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #ifndef __OTX2_TX_H__
   6 #define __OTX2_TX_H__
   7
   8 #define NIX_TX_OFFLOAD_NONE             (0)
   9 #define NIX_TX_OFFLOAD_L3_L4_CSUM_F     BIT(0)
  10 #define NIX_TX_OFFLOAD_OL3_OL4_CSUM_F   BIT(1)
  11 #define NIX_TX_OFFLOAD_VLAN_QINQ_F      BIT(2)
  12 #define NIX_TX_OFFLOAD_MBUF_NOFF_F      BIT(3)
  13 #define NIX_TX_OFFLOAD_TSTAMP_F         BIT(4)
  14
  15 /* Flags to control xmit_prepare function.
  16  * Defining it from backwards to denote its been
  17  * not used as offload flags to pick function
  18  */
  19 #define NIX_TX_MULTI_SEG_F              BIT(15)
  20
  21 #define NIX_TX_NEED_SEND_HDR_W1 \
  22         (NIX_TX_OFFLOAD_L3_L4_CSUM_F | NIX_TX_OFFLOAD_OL3_OL4_CSUM_F |  \
  23          NIX_TX_OFFLOAD_VLAN_QINQ_F)
  24
  25 #define NIX_TX_NEED_EXT_HDR \
  26         (NIX_TX_OFFLOAD_VLAN_QINQ_F | NIX_TX_OFFLOAD_TSTAMP_F)
  27
  28 /* Function to determine no of tx subdesc required in case ext
  29  * sub desc is enabled.
  30  */
  31 static __rte_always_inline int
  32 otx2_nix_tx_ext_subs(const uint16_t flags)
  33 {
  34         return (flags & NIX_TX_OFFLOAD_TSTAMP_F) ? 2 :
  35                 ((flags & NIX_TX_OFFLOAD_VLAN_QINQ_F) ? 1 : 0);
  36 }
  37
  38 static __rte_always_inline void
  39 otx2_nix_xmit_prepare_tstamp(uint64_t *cmd,  const uint64_t *send_mem_desc,
  40                              const uint64_t ol_flags, const uint16_t no_segdw,
  41                              const uint16_t flags)
  42 {
  43         if (flags & NIX_TX_OFFLOAD_TSTAMP_F) {
  44                 struct nix_send_mem_s *send_mem;
  45                 uint16_t off = (no_segdw - 1) << 1;
  46                 const uint8_t is_ol_tstamp = !(ol_flags & PKT_TX_IEEE1588_TMST);
  47
  48                 send_mem = (struct nix_send_mem_s *)(cmd + off);
  49                 if (flags & NIX_TX_MULTI_SEG_F) {
  50                         /* Retrieving the default desc values */
  51                         cmd[off] = send_mem_desc[6];
  52
  53                         /* Using compiler barier to avoid voilation of C
  54                          * aliasing rules.
  55                          */
  56                         rte_compiler_barrier();
  57                 }
  58
  59                 /* Packets for which PKT_TX_IEEE1588_TMST is not set, tx tstamp
  60                  * should not be recorded, hence changing the alg type to
  61                  * NIX_SENDMEMALG_SET and also changing send mem addr field to
  62                  * next 8 bytes as it corrpt the actual tx tstamp registered
  63                  * address.
  64                  */
  65                 send_mem->alg = NIX_SENDMEMALG_SETTSTMP - (is_ol_tstamp);
  66
  67                 send_mem->addr = (rte_iova_t)((uint64_t *)send_mem_desc[7] +
  68                                               (is_ol_tstamp));
  69         }
  70 }
  71
  72 static __rte_always_inline uint64_t
  73 otx2_pktmbuf_detach(struct rte_mbuf *m)
  74 {
  75         struct rte_mempool *mp = m->pool;
  76         uint32_t mbuf_size, buf_len;
  77         struct rte_mbuf *md;
  78         uint16_t priv_size;
  79         uint16_t refcount;
  80
  81         /* Update refcount of direct mbuf */
  82         md = rte_mbuf_from_indirect(m);
  83         refcount = rte_mbuf_refcnt_update(md, -1);
  84
  85         priv_size = rte_pktmbuf_priv_size(mp);
  86         mbuf_size = (uint32_t)(sizeof(struct rte_mbuf) + priv_size);
  87         buf_len = rte_pktmbuf_data_room_size(mp);
  88
  89         m->priv_size = priv_size;
  90         m->buf_addr = (char *)m + mbuf_size;
  91         m->buf_iova = rte_mempool_virt2iova(m) + mbuf_size;
  92         m->buf_len = (uint16_t)buf_len;
  93         rte_pktmbuf_reset_headroom(m);
  94         m->data_len = 0;
  95         m->ol_flags = 0;
  96         m->next = NULL;
  97         m->nb_segs = 1;
  98
  99         /* Now indirect mbuf is safe to free */
 100         rte_pktmbuf_free(m);
 101
 102         if (refcount == 0) {
 103                 rte_mbuf_refcnt_set(md, 1);
 104                 md->data_len = 0;
 105                 md->ol_flags = 0;
 106                 md->next = NULL;
 107                 md->nb_segs = 1;
 108                 return 0;
 109         } else {
 110                 return 1;
 111         }
 112 }
 113
 114 static __rte_always_inline uint64_t
 115 otx2_nix_prefree_seg(struct rte_mbuf *m)
 116 {
 117         if (likely(rte_mbuf_refcnt_read(m) == 1)) {
 118                 if (!RTE_MBUF_DIRECT(m))
 119                         return otx2_pktmbuf_detach(m);
 120
 121                 m->next = NULL;
 122                 m->nb_segs = 1;
 123                 return 0;
 124         } else if (rte_mbuf_refcnt_update(m, -1) == 0) {
 125                 if (!RTE_MBUF_DIRECT(m))
 126                         return otx2_pktmbuf_detach(m);
 127
 128                 rte_mbuf_refcnt_set(m, 1);
 129                 m->next = NULL;
 130                 m->nb_segs = 1;
 131                 return 0;
 132         }
 133
 134         /* Mbuf is having refcount more than 1 so need not to be freed */
 135         return 1;
 136 }
 137
 138 static inline void
 139 otx2_nix_xmit_prepare(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags)
 140 {
 141         struct nix_send_ext_s *send_hdr_ext;
 142         struct nix_send_hdr_s *send_hdr;
 143         uint64_t ol_flags = 0, mask;
 144         union nix_send_hdr_w1_u w1;
 145         union nix_send_sg_s *sg;
 146
 147         send_hdr = (struct nix_send_hdr_s *)cmd;
 148         if (flags & NIX_TX_NEED_EXT_HDR) {
 149                 send_hdr_ext = (struct nix_send_ext_s *)(cmd + 2);
 150                 sg = (union nix_send_sg_s *)(cmd + 4);
 151                 /* Clear previous markings */
 152                 send_hdr_ext->w0.lso = 0;
 153                 send_hdr_ext->w1.u = 0;
 154         } else {
 155                 sg = (union nix_send_sg_s *)(cmd + 2);
 156         }
 157
 158         if (flags & NIX_TX_NEED_SEND_HDR_W1) {
 159                 ol_flags = m->ol_flags;
 160                 w1.u = 0;
 161         }
 162
 163         if (!(flags & NIX_TX_MULTI_SEG_F)) {
 164                 send_hdr->w0.total = m->data_len;
 165                 send_hdr->w0.aura =
 166                         npa_lf_aura_handle_to_aura(m->pool->pool_id);
 167         }
 168
 169         /*
 170          * L3type:  2 => IPV4
 171          *          3 => IPV4 with csum
 172          *          4 => IPV6
 173          * L3type and L3ptr needs to be set for either
 174          * L3 csum or L4 csum or LSO
 175          *
 176          */
 177
 178         if ((flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) &&
 179             (flags & NIX_TX_OFFLOAD_L3_L4_CSUM_F)) {
 180                 const uint8_t csum = !!(ol_flags & PKT_TX_OUTER_UDP_CKSUM);
 181                 const uint8_t ol3type =
 182                         ((!!(ol_flags & PKT_TX_OUTER_IPV4)) << 1) +
 183                         ((!!(ol_flags & PKT_TX_OUTER_IPV6)) << 2) +
 184                         !!(ol_flags & PKT_TX_OUTER_IP_CKSUM);
 185
 186                 /* Outer L3 */
 187                 w1.ol3type = ol3type;
 188                 mask = 0xffffull << ((!!ol3type) << 4);
 189                 w1.ol3ptr = ~mask & m->outer_l2_len;
 190                 w1.ol4ptr = ~mask & (w1.ol3ptr + m->outer_l3_len);
 191
 192                 /* Outer L4 */
 193                 w1.ol4type = csum + (csum << 1);
 194
 195                 /* Inner L3 */
 196                 w1.il3type = ((!!(ol_flags & PKT_TX_IPV4)) << 1) +
 197                         ((!!(ol_flags & PKT_TX_IPV6)) << 2);
 198                 w1.il3ptr = w1.ol4ptr + m->l2_len;
 199                 w1.il4ptr = w1.il3ptr + m->l3_len;
 200                 /* Increment it by 1 if it is IPV4 as 3 is with csum */
 201                 w1.il3type = w1.il3type + !!(ol_flags & PKT_TX_IP_CKSUM);
 202
 203                 /* Inner L4 */
 204                 w1.il4type =  (ol_flags & PKT_TX_L4_MASK) >> 52;
 205
 206                 /* In case of no tunnel header use only
 207                  * shift IL3/IL4 fields a bit to use
 208                  * OL3/OL4 for header checksum
 209                  */
 210                 mask = !ol3type;
 211                 w1.u = ((w1.u & 0xFFFFFFFF00000000) >> (mask << 3)) |
 212                         ((w1.u & 0X00000000FFFFFFFF) >> (mask << 4));
 213
 214         } else if (flags & NIX_TX_OFFLOAD_OL3_OL4_CSUM_F) {
 215                 const uint8_t csum = !!(ol_flags & PKT_TX_OUTER_UDP_CKSUM);
 216                 const uint8_t outer_l2_len = m->outer_l2_len;
 217
 218                 /* Outer L3 */
 219                 w1.ol3ptr = outer_l2_len;
 220                 w1.ol4ptr = outer_l2_len + m->outer_l3_len;
 221                 /* Increment it by 1 if it is IPV4 as 3 is with csum */
 222                 w1.ol3type = ((!!(ol_flags & PKT_TX_OUTER_IPV4)) << 1) +
 223                         ((!!(ol_flags & PKT_TX_OUTER_IPV6)) << 2) +
 224                         !!(ol_flags & PKT_TX_OUTER_IP_CKSUM);
 225
 226                 /* Outer L4 */
 227                 w1.ol4type = csum + (csum << 1);
 228
 229         } else if (flags & NIX_TX_OFFLOAD_L3_L4_CSUM_F) {
 230                 const uint8_t l2_len = m->l2_len;
 231
 232                 /* Always use OLXPTR and OLXTYPE when only
 233                  * when one header is present
 234                  */
 235
 236                 /* Inner L3 */
 237                 w1.ol3ptr = l2_len;
 238                 w1.ol4ptr = l2_len + m->l3_len;
 239                 /* Increment it by 1 if it is IPV4 as 3 is with csum */
 240                 w1.ol3type = ((!!(ol_flags & PKT_TX_IPV4)) << 1) +
 241                         ((!!(ol_flags & PKT_TX_IPV6)) << 2) +
 242                         !!(ol_flags & PKT_TX_IP_CKSUM);
 243
 244                 /* Inner L4 */
 245                 w1.ol4type =  (ol_flags & PKT_TX_L4_MASK) >> 52;
 246         }
 247
 248         if (flags & NIX_TX_NEED_EXT_HDR &&
 249             flags & NIX_TX_OFFLOAD_VLAN_QINQ_F) {
 250                 send_hdr_ext->w1.vlan1_ins_ena = !!(ol_flags & PKT_TX_VLAN);
 251                 /* HW will update ptr after vlan0 update */
 252                 send_hdr_ext->w1.vlan1_ins_ptr = 12;
 253                 send_hdr_ext->w1.vlan1_ins_tci = m->vlan_tci;
 254
 255                 send_hdr_ext->w1.vlan0_ins_ena = !!(ol_flags & PKT_TX_QINQ);
 256                 /* 2B before end of l2 header */
 257                 send_hdr_ext->w1.vlan0_ins_ptr = 12;
 258                 send_hdr_ext->w1.vlan0_ins_tci = m->vlan_tci_outer;
 259         }
 260
 261         if (flags & NIX_TX_NEED_SEND_HDR_W1)
 262                 send_hdr->w1.u = w1.u;
 263
 264         if (!(flags & NIX_TX_MULTI_SEG_F)) {
 265                 sg->seg1_size = m->data_len;
 266                 *(rte_iova_t *)(++sg) = rte_mbuf_data_iova(m);
 267
 268                 if (flags & NIX_TX_OFFLOAD_MBUF_NOFF_F) {
 269                         /* DF bit = 1 if refcount of current mbuf or parent mbuf
 270                          *              is greater than 1
 271                          * DF bit = 0 otherwise
 272                          */
 273                         send_hdr->w0.df = otx2_nix_prefree_seg(m);
 274                 }
 275                 /* Mark mempool object as "put" since it is freed by NIX */
 276                 if (!send_hdr->w0.df)
 277                         __mempool_check_cookies(m->pool, (void **)&m, 1, 0);
 278         }
 279 }
 280
 281
 282 static __rte_always_inline void
 283 otx2_nix_xmit_one(uint64_t *cmd, void *lmt_addr,
 284                   const rte_iova_t io_addr, const uint32_t flags)
 285 {
 286         uint64_t lmt_status;
 287
 288         do {
 289                 otx2_lmt_mov(lmt_addr, cmd, otx2_nix_tx_ext_subs(flags));
 290                 lmt_status = otx2_lmt_submit(io_addr);
 291         } while (lmt_status == 0);
 292 }
 293
 294 static __rte_always_inline uint16_t
 295 otx2_nix_prepare_mseg(struct rte_mbuf *m, uint64_t *cmd, const uint16_t flags)
 296 {
 297         struct nix_send_hdr_s *send_hdr;
 298         union nix_send_sg_s *sg;
 299         struct rte_mbuf *m_next;
 300         uint64_t *slist, sg_u;
 301         uint64_t nb_segs;
 302         uint64_t segdw;
 303         uint8_t off, i;
 304
 305         send_hdr = (struct nix_send_hdr_s *)cmd;
 306         send_hdr->w0.total = m->pkt_len;
 307         send_hdr->w0.aura = npa_lf_aura_handle_to_aura(m->pool->pool_id);
 308
 309         if (flags & NIX_TX_NEED_EXT_HDR)
 310                 off = 2;
 311         else
 312                 off = 0;
 313
 314         sg = (union nix_send_sg_s *)&cmd[2 + off];
 315         /* Clear sg->u header before use */
 316         sg->u &= 0xFC00000000000000;
 317         sg_u = sg->u;
 318         slist = &cmd[3 + off];
 319
 320         i = 0;
 321         nb_segs = m->nb_segs;
 322
 323         /* Fill mbuf segments */
 324         do {
 325                 m_next = m->next;
 326                 sg_u = sg_u | ((uint64_t)m->data_len << (i << 4));
 327                 *slist = rte_mbuf_data_iova(m);
 328                 /* Set invert df if buffer is not to be freed by H/W */
 329                 if (flags & NIX_TX_OFFLOAD_MBUF_NOFF_F)
 330                         sg_u |= (otx2_nix_prefree_seg(m) << (i + 55));
 331                 /* Mark mempool object as "put" since it is freed by NIX */
 332                 if (!(sg_u & (1ULL << (i + 55)))) {
 333                         m->next = NULL;
 334                         __mempool_check_cookies(m->pool, (void **)&m, 1, 0);
 335                 }
 336                 slist++;
 337                 i++;
 338                 nb_segs--;
 339                 if (i > 2 && nb_segs) {
 340                         i = 0;
 341                         /* Next SG subdesc */
 342                         *(uint64_t *)slist = sg_u & 0xFC00000000000000;
 343                         sg->u = sg_u;
 344                         sg->segs = 3;
 345                         sg = (union nix_send_sg_s *)slist;
 346                         sg_u = sg->u;
 347                         slist++;
 348                 }
 349                 m = m_next;
 350         } while (nb_segs);
 351
 352         sg->u = sg_u;
 353         sg->segs = i;
 354         segdw = (uint64_t *)slist - (uint64_t *)&cmd[2 + off];
 355         /* Roundup extra dwords to multiple of 2 */
 356         segdw = (segdw >> 1) + (segdw & 0x1);
 357         /* Default dwords */
 358         segdw += (off >> 1) + 1 + !!(flags & NIX_TX_OFFLOAD_TSTAMP_F);
 359         send_hdr->w0.sizem1 = segdw - 1;
 360
 361         return segdw;
 362 }
 363
 364 static __rte_always_inline void
 365 otx2_nix_xmit_mseg_one(uint64_t *cmd, void *lmt_addr,
 366                        rte_iova_t io_addr, uint16_t segdw)
 367 {
 368         uint64_t lmt_status;
 369
 370         do {
 371                 otx2_lmt_mov_seg(lmt_addr, (const void *)cmd, segdw);
 372                 lmt_status = otx2_lmt_submit(io_addr);
 373         } while (lmt_status == 0);
 374 }
 375
 376 #define L3L4CSUM_F   NIX_TX_OFFLOAD_L3_L4_CSUM_F
 377 #define OL3OL4CSUM_F NIX_TX_OFFLOAD_OL3_OL4_CSUM_F
 378 #define VLAN_F       NIX_TX_OFFLOAD_VLAN_QINQ_F
 379 #define NOFF_F       NIX_TX_OFFLOAD_MBUF_NOFF_F
 380 #define TSP_F        NIX_TX_OFFLOAD_TSTAMP_F
 381
 382 /* [TSTMP] [NOFF] [VLAN] [OL3OL4CSUM] [L3L4CSUM] */
 383 #define NIX_TX_FASTPATH_MODES                                   \
 384 T(no_offload,                           0, 0, 0, 0, 0,  4,      \
 385                 NIX_TX_OFFLOAD_NONE)                            \
 386 T(l3l4csum,                             0, 0, 0, 0, 1,  4,      \
 387                 L3L4CSUM_F)                                     \
 388 T(ol3ol4csum,                           0, 0, 0, 1, 0,  4,      \
 389                 OL3OL4CSUM_F)                                   \
 390 T(ol3ol4csum_l3l4csum,                  0, 0, 0, 1, 1,  4,      \
 391                 OL3OL4CSUM_F | L3L4CSUM_F)                      \
 392 T(vlan,                                 0, 0, 1, 0, 0,  6,      \
 393                 VLAN_F)                                         \
 394 T(vlan_l3l4csum,                        0, 0, 1, 0, 1,  6,      \
 395                 VLAN_F | L3L4CSUM_F)                            \
 396 T(vlan_ol3ol4csum,                      0, 0, 1, 1, 0,  6,      \
 397                 VLAN_F | OL3OL4CSUM_F)                          \
 398 T(vlan_ol3ol4csum_l3l4csum,             0, 0, 1, 1, 1,  6,      \
 399                 VLAN_F | OL3OL4CSUM_F | L3L4CSUM_F)             \
 400 T(noff,                                 0, 1, 0, 0, 0,  4,      \
 401                 NOFF_F)                                         \
 402 T(noff_l3l4csum,                        0, 1, 0, 0, 1,  4,      \
 403                 NOFF_F | L3L4CSUM_F)                            \
 404 T(noff_ol3ol4csum,                      0, 1, 0, 1, 0,  4,      \
 405                 NOFF_F | OL3OL4CSUM_F)                          \
 406 T(noff_ol3ol4csum_l3l4csum,             0, 1, 0, 1, 1,  4,      \
 407                 NOFF_F | OL3OL4CSUM_F | L3L4CSUM_F)             \
 408 T(noff_vlan,                            0, 1, 1, 0, 0,  6,      \
 409                 NOFF_F | VLAN_F)                                \
 410 T(noff_vlan_l3l4csum,                   0, 1, 1, 0, 1,  6,      \
 411                 NOFF_F | VLAN_F | L3L4CSUM_F)                   \
 412 T(noff_vlan_ol3ol4csum,                 0, 1, 1, 1, 0,  6,      \
 413                 NOFF_F | VLAN_F | OL3OL4CSUM_F)                 \
 414 T(noff_vlan_ol3ol4csum_l3l4csum,        0, 1, 1, 1, 1,  6,      \
 415                 NOFF_F | VLAN_F | OL3OL4CSUM_F | L3L4CSUM_F)    \
 416 T(ts,                                   1, 0, 0, 0, 0,  8,      \
 417                 TSP_F)                                          \
 418 T(ts_l3l4csum,                  1, 0, 0, 0, 1,  8,              \
 419                 TSP_F | L3L4CSUM_F)                             \
 420 T(ts_ol3ol4csum,                        1, 0, 0, 1, 0,  8,      \
 421                 TSP_F | OL3OL4CSUM_F)                           \
 422 T(ts_ol3ol4csum_l3l4csum,               1, 0, 0, 1, 1,  8,      \
 423                 TSP_F | OL3OL4CSUM_F | L3L4CSUM_F)              \
 424 T(ts_vlan,                              1, 0, 1, 0, 0,  8,      \
 425                 TSP_F | VLAN_F)                                 \
 426 T(ts_vlan_l3l4csum,                     1, 0, 1, 0, 1,  8,      \
 427                 TSP_F | VLAN_F | L3L4CSUM_F)                    \
 428 T(ts_vlan_ol3ol4csum,           1, 0, 1, 1, 0,  8,              \
 429                 TSP_F | VLAN_F | OL3OL4CSUM_F)                  \
 430 T(ts_vlan_ol3ol4csum_l3l4csum,  1, 0, 1, 1, 1,  8,              \
 431                 TSP_F | VLAN_F | OL3OL4CSUM_F | L3L4CSUM_F)     \
 432 T(ts_noff,                              1, 1, 0, 0, 0,  8,      \
 433                 TSP_F | NOFF_F)                                 \
 434 T(ts_noff_l3l4csum,                     1, 1, 0, 0, 1,  8,      \
 435                 TSP_F | NOFF_F | L3L4CSUM_F)                    \
 436 T(ts_noff_ol3ol4csum,           1, 1, 0, 1, 0,  8,              \
 437                 TSP_F | NOFF_F | OL3OL4CSUM_F)                  \
 438 T(ts_noff_ol3ol4csum_l3l4csum,  1, 1, 0, 1, 1,  8,              \
 439                 TSP_F | NOFF_F | OL3OL4CSUM_F | L3L4CSUM_F)     \
 440 T(ts_noff_vlan,                 1, 1, 1, 0, 0,  8,              \
 441                 TSP_F | NOFF_F | VLAN_F)                        \
 442 T(ts_noff_vlan_l3l4csum,                1, 1, 1, 0, 1,  8,      \
 443                 TSP_F | NOFF_F | VLAN_F | L3L4CSUM_F)           \
 444 T(ts_noff_vlan_ol3ol4csum,              1, 1, 1, 1, 0,  8,      \
 445                 TSP_F | NOFF_F | VLAN_F | OL3OL4CSUM_F)         \
 446 T(ts_noff_vlan_ol3ol4csum_l3l4csum,     1, 1, 1, 1, 1,  8,      \
 447                 TSP_F | NOFF_F | VLAN_F | OL3OL4CSUM_F | L3L4CSUM_F)
 448
 449 #endif /* __OTX2_TX_H__ */