drivers/net/ethernet/netronome/nfp/nfdk/dp.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2015-2019 Netronome Systems, Inc. */
   3
   4 #include <linux/bpf_trace.h>
   5 #include <linux/netdevice.h>
   6 #include <linux/overflow.h>
   7 #include <linux/sizes.h>
   8 #include <linux/bitfield.h>
   9
  10 #include "../nfp_app.h"
  11 #include "../nfp_net.h"
  12 #include "../nfp_net_dp.h"
  13 #include "../crypto/crypto.h"
  14 #include "../crypto/fw.h"
  15 #include "nfdk.h"
  16
  17 static int nfp_nfdk_tx_ring_should_wake(struct nfp_net_tx_ring *tx_ring)
  18 {
  19         return !nfp_net_tx_full(tx_ring, NFDK_TX_DESC_STOP_CNT * 2);
  20 }
  21
  22 static int nfp_nfdk_tx_ring_should_stop(struct nfp_net_tx_ring *tx_ring)
  23 {
  24         return nfp_net_tx_full(tx_ring, NFDK_TX_DESC_STOP_CNT);
  25 }
  26
  27 static void nfp_nfdk_tx_ring_stop(struct netdev_queue *nd_q,
  28                                   struct nfp_net_tx_ring *tx_ring)
  29 {
  30         netif_tx_stop_queue(nd_q);
  31
  32         /* We can race with the TX completion out of NAPI so recheck */
  33         smp_mb();
  34         if (unlikely(nfp_nfdk_tx_ring_should_wake(tx_ring)))
  35                 netif_tx_start_queue(nd_q);
  36 }
  37
  38 static __le64
  39 nfp_nfdk_tx_tso(struct nfp_net_r_vector *r_vec, struct nfp_nfdk_tx_buf *txbuf,
  40                 struct sk_buff *skb)
  41 {
  42         u32 segs, hdrlen, l3_offset, l4_offset;
  43         struct nfp_nfdk_tx_desc txd;
  44         u16 mss;
  45
  46         if (!skb->encapsulation) {
  47                 l3_offset = skb_network_offset(skb);
  48                 l4_offset = skb_transport_offset(skb);
  49                 hdrlen = skb_transport_offset(skb) + tcp_hdrlen(skb);
  50         } else {
  51                 l3_offset = skb_inner_network_offset(skb);
  52                 l4_offset = skb_inner_transport_offset(skb);
  53                 hdrlen = skb_inner_transport_header(skb) - skb->data +
  54                         inner_tcp_hdrlen(skb);
  55         }
  56
  57         segs = skb_shinfo(skb)->gso_segs;
  58         mss = skb_shinfo(skb)->gso_size & NFDK_DESC_TX_MSS_MASK;
  59
  60         /* Note: TSO of the packet with metadata prepended to skb is not
  61          * supported yet, in which case l3/l4_offset and lso_hdrlen need
  62          * be correctly handled here.
  63          * Concern:
  64          * The driver doesn't have md_bytes easily available at this point.
  65          * The PCI.IN PD ME won't have md_bytes bytes to add to lso_hdrlen,
  66          * so it needs the full length there.  The app MEs might prefer
  67          * l3_offset and l4_offset relative to the start of packet data,
  68          * but could probably cope with it being relative to the CTM buf
  69          * data offset.
  70          */
  71         txd.l3_offset = l3_offset;
  72         txd.l4_offset = l4_offset;
  73         txd.lso_meta_res = 0;
  74         txd.mss = cpu_to_le16(mss);
  75         txd.lso_hdrlen = hdrlen;
  76         txd.lso_totsegs = segs;
  77
  78         txbuf->pkt_cnt = segs;
  79         txbuf->real_len = skb->len + hdrlen * (txbuf->pkt_cnt - 1);
  80
  81         u64_stats_update_begin(&r_vec->tx_sync);
  82         r_vec->tx_lso++;
  83         u64_stats_update_end(&r_vec->tx_sync);
  84
  85         return txd.raw;
  86 }
  87
  88 static u8
  89 nfp_nfdk_tx_csum(struct nfp_net_dp *dp, struct nfp_net_r_vector *r_vec,
  90                  unsigned int pkt_cnt, struct sk_buff *skb, u64 flags)
  91 {
  92         struct ipv6hdr *ipv6h;
  93         struct iphdr *iph;
  94
  95         if (!(dp->ctrl & NFP_NET_CFG_CTRL_TXCSUM))
  96                 return flags;
  97
  98         if (skb->ip_summed != CHECKSUM_PARTIAL)
  99                 return flags;
 100
 101         flags |= NFDK_DESC_TX_L4_CSUM;
 102
 103         iph = skb->encapsulation ? inner_ip_hdr(skb) : ip_hdr(skb);
 104         ipv6h = skb->encapsulation ? inner_ipv6_hdr(skb) : ipv6_hdr(skb);
 105
 106         /* L3 checksum offloading flag is not required for ipv6 */
 107         if (iph->version == 4) {
 108                 flags |= NFDK_DESC_TX_L3_CSUM;
 109         } else if (ipv6h->version != 6) {
 110                 nn_dp_warn(dp, "partial checksum but ipv=%x!\n", iph->version);
 111                 return flags;
 112         }
 113
 114         u64_stats_update_begin(&r_vec->tx_sync);
 115         if (!skb->encapsulation) {
 116                 r_vec->hw_csum_tx += pkt_cnt;
 117         } else {
 118                 flags |= NFDK_DESC_TX_ENCAP;
 119                 r_vec->hw_csum_tx_inner += pkt_cnt;
 120         }
 121         u64_stats_update_end(&r_vec->tx_sync);
 122
 123         return flags;
 124 }
 125
 126 static int
 127 nfp_nfdk_tx_maybe_close_block(struct nfp_net_tx_ring *tx_ring,
 128                               unsigned int nr_frags, struct sk_buff *skb)
 129 {
 130         unsigned int n_descs, wr_p, nop_slots;
 131         const skb_frag_t *frag, *fend;
 132         struct nfp_nfdk_tx_desc *txd;
 133         unsigned int wr_idx;
 134         int err;
 135
 136 recount_descs:
 137         n_descs = nfp_nfdk_headlen_to_segs(skb_headlen(skb));
 138
 139         frag = skb_shinfo(skb)->frags;
 140         fend = frag + nr_frags;
 141         for (; frag < fend; frag++)
 142                 n_descs += DIV_ROUND_UP(skb_frag_size(frag),
 143                                         NFDK_TX_MAX_DATA_PER_DESC);
 144
 145         if (unlikely(n_descs > NFDK_TX_DESC_GATHER_MAX)) {
 146                 if (skb_is_nonlinear(skb)) {
 147                         err = skb_linearize(skb);
 148                         if (err)
 149                                 return err;
 150                         goto recount_descs;
 151                 }
 152                 return -EINVAL;
 153         }
 154
 155         /* Under count by 1 (don't count meta) for the round down to work out */
 156         n_descs += !!skb_is_gso(skb);
 157
 158         if (round_down(tx_ring->wr_p, NFDK_TX_DESC_BLOCK_CNT) !=
 159             round_down(tx_ring->wr_p + n_descs, NFDK_TX_DESC_BLOCK_CNT))
 160                 goto close_block;
 161
 162         if ((u32)tx_ring->data_pending + skb->len > NFDK_TX_MAX_DATA_PER_BLOCK)
 163                 goto close_block;
 164
 165         return 0;
 166
 167 close_block:
 168         wr_p = tx_ring->wr_p;
 169         nop_slots = D_BLOCK_CPL(wr_p);
 170
 171         wr_idx = D_IDX(tx_ring, wr_p);
 172         tx_ring->ktxbufs[wr_idx].skb = NULL;
 173         txd = &tx_ring->ktxds[wr_idx];
 174
 175         memset(txd, 0, array_size(nop_slots, sizeof(struct nfp_nfdk_tx_desc)));
 176
 177         tx_ring->data_pending = 0;
 178         tx_ring->wr_p += nop_slots;
 179         tx_ring->wr_ptr_add += nop_slots;
 180
 181         return 0;
 182 }
 183
 184 static int nfp_nfdk_prep_port_id(struct sk_buff *skb)
 185 {
 186         struct metadata_dst *md_dst = skb_metadata_dst(skb);
 187         unsigned char *data;
 188
 189         if (likely(!md_dst))
 190                 return 0;
 191         if (unlikely(md_dst->type != METADATA_HW_PORT_MUX))
 192                 return 0;
 193
 194         /* Note: Unsupported case when TSO a skb with metedata prepended.
 195          * See the comments in `nfp_nfdk_tx_tso` for details.
 196          */
 197         if (unlikely(md_dst && skb_is_gso(skb)))
 198                 return -EOPNOTSUPP;
 199
 200         if (unlikely(skb_cow_head(skb, sizeof(md_dst->u.port_info.port_id))))
 201                 return -ENOMEM;
 202
 203         data = skb_push(skb, sizeof(md_dst->u.port_info.port_id));
 204         put_unaligned_be32(md_dst->u.port_info.port_id, data);
 205
 206         return sizeof(md_dst->u.port_info.port_id);
 207 }
 208
 209 static int
 210 nfp_nfdk_prep_tx_meta(struct nfp_app *app, struct sk_buff *skb,
 211                       struct nfp_net_r_vector *r_vec)
 212 {
 213         unsigned char *data;
 214         int res, md_bytes;
 215         u32 meta_id = 0;
 216
 217         res = nfp_nfdk_prep_port_id(skb);
 218         if (unlikely(res <= 0))
 219                 return res;
 220
 221         md_bytes = res;
 222         meta_id = NFP_NET_META_PORTID;
 223
 224         if (unlikely(skb_cow_head(skb, sizeof(meta_id))))
 225                 return -ENOMEM;
 226
 227         md_bytes += sizeof(meta_id);
 228
 229         meta_id = FIELD_PREP(NFDK_META_LEN, md_bytes) |
 230                   FIELD_PREP(NFDK_META_FIELDS, meta_id);
 231
 232         data = skb_push(skb, sizeof(meta_id));
 233         put_unaligned_be32(meta_id, data);
 234
 235         return NFDK_DESC_TX_CHAIN_META;
 236 }
 237
 238 /**
 239  * nfp_nfdk_tx() - Main transmit entry point
 240  * @skb:    SKB to transmit
 241  * @netdev: netdev structure
 242  *
 243  * Return: NETDEV_TX_OK on success.
 244  */
 245 netdev_tx_t nfp_nfdk_tx(struct sk_buff *skb, struct net_device *netdev)
 246 {
 247         struct nfp_net *nn = netdev_priv(netdev);
 248         struct nfp_nfdk_tx_buf *txbuf, *etxbuf;
 249         u32 cnt, tmp_dlen, dlen_type = 0;
 250         struct nfp_net_tx_ring *tx_ring;
 251         struct nfp_net_r_vector *r_vec;
 252         const skb_frag_t *frag, *fend;
 253         struct nfp_nfdk_tx_desc *txd;
 254         unsigned int real_len, qidx;
 255         unsigned int dma_len, type;
 256         struct netdev_queue *nd_q;
 257         struct nfp_net_dp *dp;
 258         int nr_frags, wr_idx;
 259         dma_addr_t dma_addr;
 260         u64 metadata;
 261
 262         dp = &nn->dp;
 263         qidx = skb_get_queue_mapping(skb);
 264         tx_ring = &dp->tx_rings[qidx];
 265         r_vec = tx_ring->r_vec;
 266         nd_q = netdev_get_tx_queue(dp->netdev, qidx);
 267
 268         /* Don't bother counting frags, assume the worst */
 269         if (unlikely(nfp_net_tx_full(tx_ring, NFDK_TX_DESC_STOP_CNT))) {
 270                 nn_dp_warn(dp, "TX ring %d busy. wrp=%u rdp=%u\n",
 271                            qidx, tx_ring->wr_p, tx_ring->rd_p);
 272                 netif_tx_stop_queue(nd_q);
 273                 nfp_net_tx_xmit_more_flush(tx_ring);
 274                 u64_stats_update_begin(&r_vec->tx_sync);
 275                 r_vec->tx_busy++;
 276                 u64_stats_update_end(&r_vec->tx_sync);
 277                 return NETDEV_TX_BUSY;
 278         }
 279
 280         metadata = nfp_nfdk_prep_tx_meta(nn->app, skb, r_vec);
 281         if (unlikely((int)metadata < 0))
 282                 goto err_flush;
 283
 284         nr_frags = skb_shinfo(skb)->nr_frags;
 285         if (nfp_nfdk_tx_maybe_close_block(tx_ring, nr_frags, skb))
 286                 goto err_flush;
 287
 288         /* DMA map all */
 289         wr_idx = D_IDX(tx_ring, tx_ring->wr_p);
 290         txd = &tx_ring->ktxds[wr_idx];
 291         txbuf = &tx_ring->ktxbufs[wr_idx];
 292
 293         dma_len = skb_headlen(skb);
 294         if (skb_is_gso(skb))
 295                 type = NFDK_DESC_TX_TYPE_TSO;
 296         else if (!nr_frags && dma_len < NFDK_TX_MAX_DATA_PER_HEAD)
 297                 type = NFDK_DESC_TX_TYPE_SIMPLE;
 298         else
 299                 type = NFDK_DESC_TX_TYPE_GATHER;
 300
 301         dma_addr = dma_map_single(dp->dev, skb->data, dma_len, DMA_TO_DEVICE);
 302         if (dma_mapping_error(dp->dev, dma_addr))
 303                 goto err_warn_dma;
 304
 305         txbuf->skb = skb;
 306         txbuf++;
 307
 308         txbuf->dma_addr = dma_addr;
 309         txbuf++;
 310
 311         /* FIELD_PREP() implicitly truncates to chunk */
 312         dma_len -= 1;
 313         dlen_type = FIELD_PREP(NFDK_DESC_TX_DMA_LEN_HEAD, dma_len) |
 314                     FIELD_PREP(NFDK_DESC_TX_TYPE_HEAD, type);
 315
 316         txd->dma_len_type = cpu_to_le16(dlen_type);
 317         nfp_desc_set_dma_addr(txd, dma_addr);
 318
 319         /* starts at bit 0 */
 320         BUILD_BUG_ON(!(NFDK_DESC_TX_DMA_LEN_HEAD & 1));
 321
 322         /* Preserve the original dlen_type, this way below the EOP logic
 323          * can use dlen_type.
 324          */
 325         tmp_dlen = dlen_type & NFDK_DESC_TX_DMA_LEN_HEAD;
 326         dma_len -= tmp_dlen;
 327         dma_addr += tmp_dlen + 1;
 328         txd++;
 329
 330         /* The rest of the data (if any) will be in larger dma descritors
 331          * and is handled with the fragment loop.
 332          */
 333         frag = skb_shinfo(skb)->frags;
 334         fend = frag + nr_frags;
 335
 336         while (true) {
 337                 while (dma_len > 0) {
 338                         dma_len -= 1;
 339                         dlen_type = FIELD_PREP(NFDK_DESC_TX_DMA_LEN, dma_len);
 340
 341                         txd->dma_len_type = cpu_to_le16(dlen_type);
 342                         nfp_desc_set_dma_addr(txd, dma_addr);
 343
 344                         dma_len -= dlen_type;
 345                         dma_addr += dlen_type + 1;
 346                         txd++;
 347                 }
 348
 349                 if (frag >= fend)
 350                         break;
 351
 352                 dma_len = skb_frag_size(frag);
 353                 dma_addr = skb_frag_dma_map(dp->dev, frag, 0, dma_len,
 354                                             DMA_TO_DEVICE);
 355                 if (dma_mapping_error(dp->dev, dma_addr))
 356                         goto err_unmap;
 357
 358                 txbuf->dma_addr = dma_addr;
 359                 txbuf++;
 360
 361                 frag++;
 362         }
 363
 364         (txd - 1)->dma_len_type = cpu_to_le16(dlen_type | NFDK_DESC_TX_EOP);
 365
 366         if (!skb_is_gso(skb)) {
 367                 real_len = skb->len;
 368                 /* Metadata desc */
 369                 metadata = nfp_nfdk_tx_csum(dp, r_vec, 1, skb, metadata);
 370                 txd->raw = cpu_to_le64(metadata);
 371                 txd++;
 372         } else {
 373                 /* lso desc should be placed after metadata desc */
 374                 (txd + 1)->raw = nfp_nfdk_tx_tso(r_vec, txbuf, skb);
 375                 real_len = txbuf->real_len;
 376                 /* Metadata desc */
 377                 metadata = nfp_nfdk_tx_csum(dp, r_vec, txbuf->pkt_cnt, skb, metadata);
 378                 txd->raw = cpu_to_le64(metadata);
 379                 txd += 2;
 380                 txbuf++;
 381         }
 382
 383         cnt = txd - tx_ring->ktxds - wr_idx;
 384         if (unlikely(round_down(wr_idx, NFDK_TX_DESC_BLOCK_CNT) !=
 385                      round_down(wr_idx + cnt - 1, NFDK_TX_DESC_BLOCK_CNT)))
 386                 goto err_warn_overflow;
 387
 388         skb_tx_timestamp(skb);
 389
 390         tx_ring->wr_p += cnt;
 391         if (tx_ring->wr_p % NFDK_TX_DESC_BLOCK_CNT)
 392                 tx_ring->data_pending += skb->len;
 393         else
 394                 tx_ring->data_pending = 0;
 395
 396         if (nfp_nfdk_tx_ring_should_stop(tx_ring))
 397                 nfp_nfdk_tx_ring_stop(nd_q, tx_ring);
 398
 399         tx_ring->wr_ptr_add += cnt;
 400         if (__netdev_tx_sent_queue(nd_q, real_len, netdev_xmit_more()))
 401                 nfp_net_tx_xmit_more_flush(tx_ring);
 402
 403         return NETDEV_TX_OK;
 404
 405 err_warn_overflow:
 406         WARN_ONCE(1, "unable to fit packet into a descriptor wr_idx:%d head:%d frags:%d cnt:%d",
 407                   wr_idx, skb_headlen(skb), nr_frags, cnt);
 408         if (skb_is_gso(skb))
 409                 txbuf--;
 410 err_unmap:
 411         /* txbuf pointed to the next-to-use */
 412         etxbuf = txbuf;
 413         /* first txbuf holds the skb */
 414         txbuf = &tx_ring->ktxbufs[wr_idx + 1];
 415         if (txbuf < etxbuf) {
 416                 dma_unmap_single(dp->dev, txbuf->dma_addr,
 417                                  skb_headlen(skb), DMA_TO_DEVICE);
 418                 txbuf->raw = 0;
 419                 txbuf++;
 420         }
 421         frag = skb_shinfo(skb)->frags;
 422         while (etxbuf < txbuf) {
 423                 dma_unmap_page(dp->dev, txbuf->dma_addr,
 424                                skb_frag_size(frag), DMA_TO_DEVICE);
 425                 txbuf->raw = 0;
 426                 frag++;
 427                 txbuf++;
 428         }
 429 err_warn_dma:
 430         nn_dp_warn(dp, "Failed to map DMA TX buffer\n");
 431 err_flush:
 432         nfp_net_tx_xmit_more_flush(tx_ring);
 433         u64_stats_update_begin(&r_vec->tx_sync);
 434         r_vec->tx_errors++;
 435         u64_stats_update_end(&r_vec->tx_sync);
 436         dev_kfree_skb_any(skb);
 437         return NETDEV_TX_OK;
 438 }
 439
 440 /**
 441  * nfp_nfdk_tx_complete() - Handled completed TX packets
 442  * @tx_ring:    TX ring structure
 443  * @budget:     NAPI budget (only used as bool to determine if in NAPI context)
 444  */
 445 static void nfp_nfdk_tx_complete(struct nfp_net_tx_ring *tx_ring, int budget)
 446 {
 447         struct nfp_net_r_vector *r_vec = tx_ring->r_vec;
 448         struct nfp_net_dp *dp = &r_vec->nfp_net->dp;
 449         u32 done_pkts = 0, done_bytes = 0;
 450         struct nfp_nfdk_tx_buf *ktxbufs;
 451         struct device *dev = dp->dev;
 452         struct netdev_queue *nd_q;
 453         u32 rd_p, qcp_rd_p;
 454         int todo;
 455
 456         rd_p = tx_ring->rd_p;
 457         if (tx_ring->wr_p == rd_p)
 458                 return;
 459
 460         /* Work out how many descriptors have been transmitted */
 461         qcp_rd_p = nfp_net_read_tx_cmpl(tx_ring, dp);
 462
 463         if (qcp_rd_p == tx_ring->qcp_rd_p)
 464                 return;
 465
 466         todo = D_IDX(tx_ring, qcp_rd_p - tx_ring->qcp_rd_p);
 467         ktxbufs = tx_ring->ktxbufs;
 468
 469         while (todo > 0) {
 470                 const skb_frag_t *frag, *fend;
 471                 unsigned int size, n_descs = 1;
 472                 struct nfp_nfdk_tx_buf *txbuf;
 473                 struct sk_buff *skb;
 474
 475                 txbuf = &ktxbufs[D_IDX(tx_ring, rd_p)];
 476                 skb = txbuf->skb;
 477                 txbuf++;
 478
 479                 /* Closed block */
 480                 if (!skb) {
 481                         n_descs = D_BLOCK_CPL(rd_p);
 482                         goto next;
 483                 }
 484
 485                 /* Unmap head */
 486                 size = skb_headlen(skb);
 487                 n_descs += nfp_nfdk_headlen_to_segs(size);
 488                 dma_unmap_single(dev, txbuf->dma_addr, size, DMA_TO_DEVICE);
 489                 txbuf++;
 490
 491                 /* Unmap frags */
 492                 frag = skb_shinfo(skb)->frags;
 493                 fend = frag + skb_shinfo(skb)->nr_frags;
 494                 for (; frag < fend; frag++) {
 495                         size = skb_frag_size(frag);
 496                         n_descs += DIV_ROUND_UP(size,
 497                                                 NFDK_TX_MAX_DATA_PER_DESC);
 498                         dma_unmap_page(dev, txbuf->dma_addr,
 499                                        skb_frag_size(frag), DMA_TO_DEVICE);
 500                         txbuf++;
 501                 }
 502
 503                 if (!skb_is_gso(skb)) {
 504                         done_bytes += skb->len;
 505                         done_pkts++;
 506                 } else {
 507                         done_bytes += txbuf->real_len;
 508                         done_pkts += txbuf->pkt_cnt;
 509                         n_descs++;
 510                 }
 511
 512                 napi_consume_skb(skb, budget);
 513 next:
 514                 rd_p += n_descs;
 515                 todo -= n_descs;
 516         }
 517
 518         tx_ring->rd_p = rd_p;
 519         tx_ring->qcp_rd_p = qcp_rd_p;
 520
 521         u64_stats_update_begin(&r_vec->tx_sync);
 522         r_vec->tx_bytes += done_bytes;
 523         r_vec->tx_pkts += done_pkts;
 524         u64_stats_update_end(&r_vec->tx_sync);
 525
 526         if (!dp->netdev)
 527                 return;
 528
 529         nd_q = netdev_get_tx_queue(dp->netdev, tx_ring->idx);
 530         netdev_tx_completed_queue(nd_q, done_pkts, done_bytes);
 531         if (nfp_nfdk_tx_ring_should_wake(tx_ring)) {
 532                 /* Make sure TX thread will see updated tx_ring->rd_p */
 533                 smp_mb();
 534
 535                 if (unlikely(netif_tx_queue_stopped(nd_q)))
 536                         netif_tx_wake_queue(nd_q);
 537         }
 538
 539         WARN_ONCE(tx_ring->wr_p - tx_ring->rd_p > tx_ring->cnt,
 540                   "TX ring corruption rd_p=%u wr_p=%u cnt=%u\n",
 541                   tx_ring->rd_p, tx_ring->wr_p, tx_ring->cnt);
 542 }
 543
 544 static bool nfp_nfdk_xdp_complete(struct nfp_net_tx_ring *tx_ring)
 545 {
 546         return true;
 547 }
 548
 549 /* Receive processing */
 550 static void *
 551 nfp_nfdk_napi_alloc_one(struct nfp_net_dp *dp, dma_addr_t *dma_addr)
 552 {
 553         void *frag;
 554
 555         if (!dp->xdp_prog) {
 556                 frag = napi_alloc_frag(dp->fl_bufsz);
 557                 if (unlikely(!frag))
 558                         return NULL;
 559         } else {
 560                 struct page *page;
 561
 562                 page = dev_alloc_page();
 563                 if (unlikely(!page))
 564                         return NULL;
 565                 frag = page_address(page);
 566         }
 567
 568         *dma_addr = nfp_net_dma_map_rx(dp, frag);
 569         if (dma_mapping_error(dp->dev, *dma_addr)) {
 570                 nfp_net_free_frag(frag, dp->xdp_prog);
 571                 nn_dp_warn(dp, "Failed to map DMA RX buffer\n");
 572                 return NULL;
 573         }
 574
 575         return frag;
 576 }
 577
 578 /**
 579  * nfp_nfdk_rx_give_one() - Put mapped skb on the software and hardware rings
 580  * @dp:         NFP Net data path struct
 581  * @rx_ring:    RX ring structure
 582  * @frag:       page fragment buffer
 583  * @dma_addr:   DMA address of skb mapping
 584  */
 585 static void
 586 nfp_nfdk_rx_give_one(const struct nfp_net_dp *dp,
 587                      struct nfp_net_rx_ring *rx_ring,
 588                      void *frag, dma_addr_t dma_addr)
 589 {
 590         unsigned int wr_idx;
 591
 592         wr_idx = D_IDX(rx_ring, rx_ring->wr_p);
 593
 594         nfp_net_dma_sync_dev_rx(dp, dma_addr);
 595
 596         /* Stash SKB and DMA address away */
 597         rx_ring->rxbufs[wr_idx].frag = frag;
 598         rx_ring->rxbufs[wr_idx].dma_addr = dma_addr;
 599
 600         /* Fill freelist descriptor */
 601         rx_ring->rxds[wr_idx].fld.reserved = 0;
 602         rx_ring->rxds[wr_idx].fld.meta_len_dd = 0;
 603         nfp_desc_set_dma_addr(&rx_ring->rxds[wr_idx].fld,
 604                               dma_addr + dp->rx_dma_off);
 605
 606         rx_ring->wr_p++;
 607         if (!(rx_ring->wr_p % NFP_NET_FL_BATCH)) {
 608                 /* Update write pointer of the freelist queue. Make
 609                  * sure all writes are flushed before telling the hardware.
 610                  */
 611                 wmb();
 612                 nfp_qcp_wr_ptr_add(rx_ring->qcp_fl, NFP_NET_FL_BATCH);
 613         }
 614 }
 615
 616 /**
 617  * nfp_nfdk_rx_ring_fill_freelist() - Give buffers from the ring to FW
 618  * @dp:      NFP Net data path struct
 619  * @rx_ring: RX ring to fill
 620  */
 621 void nfp_nfdk_rx_ring_fill_freelist(struct nfp_net_dp *dp,
 622                                     struct nfp_net_rx_ring *rx_ring)
 623 {
 624         unsigned int i;
 625
 626         for (i = 0; i < rx_ring->cnt - 1; i++)
 627                 nfp_nfdk_rx_give_one(dp, rx_ring, rx_ring->rxbufs[i].frag,
 628                                      rx_ring->rxbufs[i].dma_addr);
 629 }
 630
 631 /**
 632  * nfp_nfdk_rx_csum_has_errors() - group check if rxd has any csum errors
 633  * @flags: RX descriptor flags field in CPU byte order
 634  */
 635 static int nfp_nfdk_rx_csum_has_errors(u16 flags)
 636 {
 637         u16 csum_all_checked, csum_all_ok;
 638
 639         csum_all_checked = flags & __PCIE_DESC_RX_CSUM_ALL;
 640         csum_all_ok = flags & __PCIE_DESC_RX_CSUM_ALL_OK;
 641
 642         return csum_all_checked != (csum_all_ok << PCIE_DESC_RX_CSUM_OK_SHIFT);
 643 }
 644
 645 /**
 646  * nfp_nfdk_rx_csum() - set SKB checksum field based on RX descriptor flags
 647  * @dp:  NFP Net data path struct
 648  * @r_vec: per-ring structure
 649  * @rxd: Pointer to RX descriptor
 650  * @meta: Parsed metadata prepend
 651  * @skb: Pointer to SKB
 652  */
 653 static void
 654 nfp_nfdk_rx_csum(struct nfp_net_dp *dp, struct nfp_net_r_vector *r_vec,
 655                  struct nfp_net_rx_desc *rxd, struct nfp_meta_parsed *meta,
 656                  struct sk_buff *skb)
 657 {
 658         skb_checksum_none_assert(skb);
 659
 660         if (!(dp->netdev->features & NETIF_F_RXCSUM))
 661                 return;
 662
 663         if (meta->csum_type) {
 664                 skb->ip_summed = meta->csum_type;
 665                 skb->csum = meta->csum;
 666                 u64_stats_update_begin(&r_vec->rx_sync);
 667                 r_vec->hw_csum_rx_complete++;
 668                 u64_stats_update_end(&r_vec->rx_sync);
 669                 return;
 670         }
 671
 672         if (nfp_nfdk_rx_csum_has_errors(le16_to_cpu(rxd->rxd.flags))) {
 673                 u64_stats_update_begin(&r_vec->rx_sync);
 674                 r_vec->hw_csum_rx_error++;
 675                 u64_stats_update_end(&r_vec->rx_sync);
 676                 return;
 677         }
 678
 679         /* Assume that the firmware will never report inner CSUM_OK unless outer
 680          * L4 headers were successfully parsed. FW will always report zero UDP
 681          * checksum as CSUM_OK.
 682          */
 683         if (rxd->rxd.flags & PCIE_DESC_RX_TCP_CSUM_OK ||
 684             rxd->rxd.flags & PCIE_DESC_RX_UDP_CSUM_OK) {
 685                 __skb_incr_checksum_unnecessary(skb);
 686                 u64_stats_update_begin(&r_vec->rx_sync);
 687                 r_vec->hw_csum_rx_ok++;
 688                 u64_stats_update_end(&r_vec->rx_sync);
 689         }
 690
 691         if (rxd->rxd.flags & PCIE_DESC_RX_I_TCP_CSUM_OK ||
 692             rxd->rxd.flags & PCIE_DESC_RX_I_UDP_CSUM_OK) {
 693                 __skb_incr_checksum_unnecessary(skb);
 694                 u64_stats_update_begin(&r_vec->rx_sync);
 695                 r_vec->hw_csum_rx_inner_ok++;
 696                 u64_stats_update_end(&r_vec->rx_sync);
 697         }
 698 }
 699
 700 static void
 701 nfp_nfdk_set_hash(struct net_device *netdev, struct nfp_meta_parsed *meta,
 702                   unsigned int type, __be32 *hash)
 703 {
 704         if (!(netdev->features & NETIF_F_RXHASH))
 705                 return;
 706
 707         switch (type) {
 708         case NFP_NET_RSS_IPV4:
 709         case NFP_NET_RSS_IPV6:
 710         case NFP_NET_RSS_IPV6_EX:
 711                 meta->hash_type = PKT_HASH_TYPE_L3;
 712                 break;
 713         default:
 714                 meta->hash_type = PKT_HASH_TYPE_L4;
 715                 break;
 716         }
 717
 718         meta->hash = get_unaligned_be32(hash);
 719 }
 720
 721 static bool
 722 nfp_nfdk_parse_meta(struct net_device *netdev, struct nfp_meta_parsed *meta,
 723                     void *data, void *pkt, unsigned int pkt_len, int meta_len)
 724 {
 725         u32 meta_info;
 726
 727         meta_info = get_unaligned_be32(data);
 728         data += 4;
 729
 730         while (meta_info) {
 731                 switch (meta_info & NFP_NET_META_FIELD_MASK) {
 732                 case NFP_NET_META_HASH:
 733                         meta_info >>= NFP_NET_META_FIELD_SIZE;
 734                         nfp_nfdk_set_hash(netdev, meta,
 735                                           meta_info & NFP_NET_META_FIELD_MASK,
 736                                           (__be32 *)data);
 737                         data += 4;
 738                         break;
 739                 case NFP_NET_META_MARK:
 740                         meta->mark = get_unaligned_be32(data);
 741                         data += 4;
 742                         break;
 743                 case NFP_NET_META_PORTID:
 744                         meta->portid = get_unaligned_be32(data);
 745                         data += 4;
 746                         break;
 747                 case NFP_NET_META_CSUM:
 748                         meta->csum_type = CHECKSUM_COMPLETE;
 749                         meta->csum =
 750                                 (__force __wsum)__get_unaligned_cpu32(data);
 751                         data += 4;
 752                         break;
 753                 case NFP_NET_META_RESYNC_INFO:
 754                         if (nfp_net_tls_rx_resync_req(netdev, data, pkt,
 755                                                       pkt_len))
 756                                 return false;
 757                         data += sizeof(struct nfp_net_tls_resync_req);
 758                         break;
 759                 default:
 760                         return true;
 761                 }
 762
 763                 meta_info >>= NFP_NET_META_FIELD_SIZE;
 764         }
 765
 766         return data != pkt;
 767 }
 768
 769 static void
 770 nfp_nfdk_rx_drop(const struct nfp_net_dp *dp, struct nfp_net_r_vector *r_vec,
 771                  struct nfp_net_rx_ring *rx_ring, struct nfp_net_rx_buf *rxbuf,
 772                  struct sk_buff *skb)
 773 {
 774         u64_stats_update_begin(&r_vec->rx_sync);
 775         r_vec->rx_drops++;
 776         /* If we have both skb and rxbuf the replacement buffer allocation
 777          * must have failed, count this as an alloc failure.
 778          */
 779         if (skb && rxbuf)
 780                 r_vec->rx_replace_buf_alloc_fail++;
 781         u64_stats_update_end(&r_vec->rx_sync);
 782
 783         /* skb is build based on the frag, free_skb() would free the frag
 784          * so to be able to reuse it we need an extra ref.
 785          */
 786         if (skb && rxbuf && skb->head == rxbuf->frag)
 787                 page_ref_inc(virt_to_head_page(rxbuf->frag));
 788         if (rxbuf)
 789                 nfp_nfdk_rx_give_one(dp, rx_ring, rxbuf->frag, rxbuf->dma_addr);
 790         if (skb)
 791                 dev_kfree_skb_any(skb);
 792 }
 793
 794 /**
 795  * nfp_nfdk_rx() - receive up to @budget packets on @rx_ring
 796  * @rx_ring:   RX ring to receive from
 797  * @budget:    NAPI budget
 798  *
 799  * Note, this function is separated out from the napi poll function to
 800  * more cleanly separate packet receive code from other bookkeeping
 801  * functions performed in the napi poll function.
 802  *
 803  * Return: Number of packets received.
 804  */
 805 static int nfp_nfdk_rx(struct nfp_net_rx_ring *rx_ring, int budget)
 806 {
 807         struct nfp_net_r_vector *r_vec = rx_ring->r_vec;
 808         struct nfp_net_dp *dp = &r_vec->nfp_net->dp;
 809         struct nfp_net_tx_ring *tx_ring;
 810         struct bpf_prog *xdp_prog;
 811         bool xdp_tx_cmpl = false;
 812         unsigned int true_bufsz;
 813         struct sk_buff *skb;
 814         int pkts_polled = 0;
 815         struct xdp_buff xdp;
 816         int idx;
 817
 818         xdp_prog = READ_ONCE(dp->xdp_prog);
 819         true_bufsz = xdp_prog ? PAGE_SIZE : dp->fl_bufsz;
 820         xdp_init_buff(&xdp, PAGE_SIZE - NFP_NET_RX_BUF_HEADROOM,
 821                       &rx_ring->xdp_rxq);
 822         tx_ring = r_vec->xdp_ring;
 823
 824         while (pkts_polled < budget) {
 825                 unsigned int meta_len, data_len, meta_off, pkt_len, pkt_off;
 826                 struct nfp_net_rx_buf *rxbuf;
 827                 struct nfp_net_rx_desc *rxd;
 828                 struct nfp_meta_parsed meta;
 829                 bool redir_egress = false;
 830                 struct net_device *netdev;
 831                 dma_addr_t new_dma_addr;
 832                 u32 meta_len_xdp = 0;
 833                 void *new_frag;
 834
 835                 idx = D_IDX(rx_ring, rx_ring->rd_p);
 836
 837                 rxd = &rx_ring->rxds[idx];
 838                 if (!(rxd->rxd.meta_len_dd & PCIE_DESC_RX_DD))
 839                         break;
 840
 841                 /* Memory barrier to ensure that we won't do other reads
 842                  * before the DD bit.
 843                  */
 844                 dma_rmb();
 845
 846                 memset(&meta, 0, sizeof(meta));
 847
 848                 rx_ring->rd_p++;
 849                 pkts_polled++;
 850
 851                 rxbuf = &rx_ring->rxbufs[idx];
 852                 /*         < meta_len >
 853                  *  <-- [rx_offset] -->
 854                  *  ---------------------------------------------------------
 855                  * | [XX] |  metadata  |             packet           | XXXX |
 856                  *  ---------------------------------------------------------
 857                  *         <---------------- data_len --------------->
 858                  *
 859                  * The rx_offset is fixed for all packets, the meta_len can vary
 860                  * on a packet by packet basis. If rx_offset is set to zero
 861                  * (_RX_OFFSET_DYNAMIC) metadata starts at the beginning of the
 862                  * buffer and is immediately followed by the packet (no [XX]).
 863                  */
 864                 meta_len = rxd->rxd.meta_len_dd & PCIE_DESC_RX_META_LEN_MASK;
 865                 data_len = le16_to_cpu(rxd->rxd.data_len);
 866                 pkt_len = data_len - meta_len;
 867
 868                 pkt_off = NFP_NET_RX_BUF_HEADROOM + dp->rx_dma_off;
 869                 if (dp->rx_offset == NFP_NET_CFG_RX_OFFSET_DYNAMIC)
 870                         pkt_off += meta_len;
 871                 else
 872                         pkt_off += dp->rx_offset;
 873                 meta_off = pkt_off - meta_len;
 874
 875                 /* Stats update */
 876                 u64_stats_update_begin(&r_vec->rx_sync);
 877                 r_vec->rx_pkts++;
 878                 r_vec->rx_bytes += pkt_len;
 879                 u64_stats_update_end(&r_vec->rx_sync);
 880
 881                 if (unlikely(meta_len > NFP_NET_MAX_PREPEND ||
 882                              (dp->rx_offset && meta_len > dp->rx_offset))) {
 883                         nn_dp_warn(dp, "oversized RX packet metadata %u\n",
 884                                    meta_len);
 885                         nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, NULL);
 886                         continue;
 887                 }
 888
 889                 nfp_net_dma_sync_cpu_rx(dp, rxbuf->dma_addr + meta_off,
 890                                         data_len);
 891
 892                 if (meta_len) {
 893                         if (unlikely(nfp_nfdk_parse_meta(dp->netdev, &meta,
 894                                                          rxbuf->frag + meta_off,
 895                                                          rxbuf->frag + pkt_off,
 896                                                          pkt_len, meta_len))) {
 897                                 nn_dp_warn(dp, "invalid RX packet metadata\n");
 898                                 nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf,
 899                                                  NULL);
 900                                 continue;
 901                         }
 902                 }
 903
 904                 if (xdp_prog && !meta.portid) {
 905                         void *orig_data = rxbuf->frag + pkt_off;
 906                         int act;
 907
 908                         xdp_prepare_buff(&xdp,
 909                                          rxbuf->frag + NFP_NET_RX_BUF_HEADROOM,
 910                                          pkt_off - NFP_NET_RX_BUF_HEADROOM,
 911                                          pkt_len, true);
 912
 913                         act = bpf_prog_run_xdp(xdp_prog, &xdp);
 914
 915                         pkt_len = xdp.data_end - xdp.data;
 916                         pkt_off += xdp.data - orig_data;
 917
 918                         switch (act) {
 919                         case XDP_PASS:
 920                                 meta_len_xdp = xdp.data - xdp.data_meta;
 921                                 break;
 922                         default:
 923                                 bpf_warn_invalid_xdp_action(dp->netdev, xdp_prog, act);
 924                                 fallthrough;
 925                         case XDP_ABORTED:
 926                                 trace_xdp_exception(dp->netdev, xdp_prog, act);
 927                                 fallthrough;
 928                         case XDP_DROP:
 929                                 nfp_nfdk_rx_give_one(dp, rx_ring, rxbuf->frag,
 930                                                      rxbuf->dma_addr);
 931                                 continue;
 932                         }
 933                 }
 934
 935                 if (likely(!meta.portid)) {
 936                         netdev = dp->netdev;
 937                 } else if (meta.portid == NFP_META_PORT_ID_CTRL) {
 938                         struct nfp_net *nn = netdev_priv(dp->netdev);
 939
 940                         nfp_app_ctrl_rx_raw(nn->app, rxbuf->frag + pkt_off,
 941                                             pkt_len);
 942                         nfp_nfdk_rx_give_one(dp, rx_ring, rxbuf->frag,
 943                                              rxbuf->dma_addr);
 944                         continue;
 945                 } else {
 946                         struct nfp_net *nn;
 947
 948                         nn = netdev_priv(dp->netdev);
 949                         netdev = nfp_app_dev_get(nn->app, meta.portid,
 950                                                  &redir_egress);
 951                         if (unlikely(!netdev)) {
 952                                 nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf,
 953                                                  NULL);
 954                                 continue;
 955                         }
 956
 957                         if (nfp_netdev_is_nfp_repr(netdev))
 958                                 nfp_repr_inc_rx_stats(netdev, pkt_len);
 959                 }
 960
 961                 skb = build_skb(rxbuf->frag, true_bufsz);
 962                 if (unlikely(!skb)) {
 963                         nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, NULL);
 964                         continue;
 965                 }
 966                 new_frag = nfp_nfdk_napi_alloc_one(dp, &new_dma_addr);
 967                 if (unlikely(!new_frag)) {
 968                         nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, skb);
 969                         continue;
 970                 }
 971
 972                 nfp_net_dma_unmap_rx(dp, rxbuf->dma_addr);
 973
 974                 nfp_nfdk_rx_give_one(dp, rx_ring, new_frag, new_dma_addr);
 975
 976                 skb_reserve(skb, pkt_off);
 977                 skb_put(skb, pkt_len);
 978
 979                 skb->mark = meta.mark;
 980                 skb_set_hash(skb, meta.hash, meta.hash_type);
 981
 982                 skb_record_rx_queue(skb, rx_ring->idx);
 983                 skb->protocol = eth_type_trans(skb, netdev);
 984
 985                 nfp_nfdk_rx_csum(dp, r_vec, rxd, &meta, skb);
 986
 987                 if (rxd->rxd.flags & PCIE_DESC_RX_VLAN)
 988                         __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
 989                                                le16_to_cpu(rxd->rxd.vlan));
 990                 if (meta_len_xdp)
 991                         skb_metadata_set(skb, meta_len_xdp);
 992
 993                 if (likely(!redir_egress)) {
 994                         napi_gro_receive(&rx_ring->r_vec->napi, skb);
 995                 } else {
 996                         skb->dev = netdev;
 997                         skb_reset_network_header(skb);
 998                         __skb_push(skb, ETH_HLEN);
 999                         dev_queue_xmit(skb);
1000                 }
1001         }
1002
1003         if (xdp_prog) {
1004                 if (tx_ring->wr_ptr_add)
1005                         nfp_net_tx_xmit_more_flush(tx_ring);
1006                 else if (unlikely(tx_ring->wr_p != tx_ring->rd_p) &&
1007                          !xdp_tx_cmpl)
1008                         if (!nfp_nfdk_xdp_complete(tx_ring))
1009                                 pkts_polled = budget;
1010         }
1011
1012         return pkts_polled;
1013 }
1014
1015 /**
1016  * nfp_nfdk_poll() - napi poll function
1017  * @napi:    NAPI structure
1018  * @budget:  NAPI budget
1019  *
1020  * Return: number of packets polled.
1021  */
1022 int nfp_nfdk_poll(struct napi_struct *napi, int budget)
1023 {
1024         struct nfp_net_r_vector *r_vec =
1025                 container_of(napi, struct nfp_net_r_vector, napi);
1026         unsigned int pkts_polled = 0;
1027
1028         if (r_vec->tx_ring)
1029                 nfp_nfdk_tx_complete(r_vec->tx_ring, budget);
1030         if (r_vec->rx_ring)
1031                 pkts_polled = nfp_nfdk_rx(r_vec->rx_ring, budget);
1032
1033         if (pkts_polled < budget)
1034                 if (napi_complete_done(napi, pkts_polled))
1035                         nfp_net_irq_unmask(r_vec->nfp_net, r_vec->irq_entry);
1036
1037         if (r_vec->nfp_net->rx_coalesce_adapt_on && r_vec->rx_ring) {
1038                 struct dim_sample dim_sample = {};
1039                 unsigned int start;
1040                 u64 pkts, bytes;
1041
1042                 do {
1043                         start = u64_stats_fetch_begin(&r_vec->rx_sync);
1044                         pkts = r_vec->rx_pkts;
1045                         bytes = r_vec->rx_bytes;
1046                 } while (u64_stats_fetch_retry(&r_vec->rx_sync, start));
1047
1048                 dim_update_sample(r_vec->event_ctr, pkts, bytes, &dim_sample);
1049                 net_dim(&r_vec->rx_dim, dim_sample);
1050         }
1051
1052         if (r_vec->nfp_net->tx_coalesce_adapt_on && r_vec->tx_ring) {
1053                 struct dim_sample dim_sample = {};
1054                 unsigned int start;
1055                 u64 pkts, bytes;
1056
1057                 do {
1058                         start = u64_stats_fetch_begin(&r_vec->tx_sync);
1059                         pkts = r_vec->tx_pkts;
1060                         bytes = r_vec->tx_bytes;
1061                 } while (u64_stats_fetch_retry(&r_vec->tx_sync, start));
1062
1063                 dim_update_sample(r_vec->event_ctr, pkts, bytes, &dim_sample);
1064                 net_dim(&r_vec->tx_dim, dim_sample);
1065         }
1066
1067         return pkts_polled;
1068 }
1069
1070 /* Control device data path
1071  */
1072
1073 bool
1074 nfp_nfdk_ctrl_tx_one(struct nfp_net *nn, struct nfp_net_r_vector *r_vec,
1075                      struct sk_buff *skb, bool old)
1076 {
1077         u32 cnt, tmp_dlen, dlen_type = 0;
1078         struct nfp_net_tx_ring *tx_ring;
1079         struct nfp_nfdk_tx_buf *txbuf;
1080         struct nfp_nfdk_tx_desc *txd;
1081         unsigned int dma_len, type;
1082         struct nfp_net_dp *dp;
1083         dma_addr_t dma_addr;
1084         u64 metadata = 0;
1085         int wr_idx;
1086
1087         dp = &r_vec->nfp_net->dp;
1088         tx_ring = r_vec->tx_ring;
1089
1090         if (WARN_ON_ONCE(skb_shinfo(skb)->nr_frags)) {
1091                 nn_dp_warn(dp, "Driver's CTRL TX does not implement gather\n");
1092                 goto err_free;
1093         }
1094
1095         /* Don't bother counting frags, assume the worst */
1096         if (unlikely(nfp_net_tx_full(tx_ring, NFDK_TX_DESC_STOP_CNT))) {
1097                 u64_stats_update_begin(&r_vec->tx_sync);
1098                 r_vec->tx_busy++;
1099                 u64_stats_update_end(&r_vec->tx_sync);
1100                 if (!old)
1101                         __skb_queue_tail(&r_vec->queue, skb);
1102                 else
1103                         __skb_queue_head(&r_vec->queue, skb);
1104                 return NETDEV_TX_BUSY;
1105         }
1106
1107         if (nfp_app_ctrl_has_meta(nn->app)) {
1108                 if (unlikely(skb_headroom(skb) < 8)) {
1109                         nn_dp_warn(dp, "CTRL TX on skb without headroom\n");
1110                         goto err_free;
1111                 }
1112                 metadata = NFDK_DESC_TX_CHAIN_META;
1113                 put_unaligned_be32(NFP_META_PORT_ID_CTRL, skb_push(skb, 4));
1114                 put_unaligned_be32(FIELD_PREP(NFDK_META_LEN, 8) |
1115                                    FIELD_PREP(NFDK_META_FIELDS,
1116                                               NFP_NET_META_PORTID),
1117                                    skb_push(skb, 4));
1118         }
1119
1120         if (nfp_nfdk_tx_maybe_close_block(tx_ring, 0, skb))
1121                 goto err_free;
1122
1123         /* DMA map all */
1124         wr_idx = D_IDX(tx_ring, tx_ring->wr_p);
1125         txd = &tx_ring->ktxds[wr_idx];
1126         txbuf = &tx_ring->ktxbufs[wr_idx];
1127
1128         dma_len = skb_headlen(skb);
1129         if (dma_len < NFDK_TX_MAX_DATA_PER_HEAD)
1130                 type = NFDK_DESC_TX_TYPE_SIMPLE;
1131         else
1132                 type = NFDK_DESC_TX_TYPE_GATHER;
1133
1134         dma_addr = dma_map_single(dp->dev, skb->data, dma_len, DMA_TO_DEVICE);
1135         if (dma_mapping_error(dp->dev, dma_addr))
1136                 goto err_warn_dma;
1137
1138         txbuf->skb = skb;
1139         txbuf++;
1140
1141         txbuf->dma_addr = dma_addr;
1142         txbuf++;
1143
1144         dma_len -= 1;
1145         dlen_type = FIELD_PREP(NFDK_DESC_TX_DMA_LEN_HEAD, dma_len) |
1146                     FIELD_PREP(NFDK_DESC_TX_TYPE_HEAD, type);
1147
1148         txd->dma_len_type = cpu_to_le16(dlen_type);
1149         nfp_desc_set_dma_addr(txd, dma_addr);
1150
1151         tmp_dlen = dlen_type & NFDK_DESC_TX_DMA_LEN_HEAD;
1152         dma_len -= tmp_dlen;
1153         dma_addr += tmp_dlen + 1;
1154         txd++;
1155
1156         while (dma_len > 0) {
1157                 dma_len -= 1;
1158                 dlen_type = FIELD_PREP(NFDK_DESC_TX_DMA_LEN, dma_len);
1159                 txd->dma_len_type = cpu_to_le16(dlen_type);
1160                 nfp_desc_set_dma_addr(txd, dma_addr);
1161
1162                 dlen_type &= NFDK_DESC_TX_DMA_LEN;
1163                 dma_len -= dlen_type;
1164                 dma_addr += dlen_type + 1;
1165                 txd++;
1166         }
1167
1168         (txd - 1)->dma_len_type = cpu_to_le16(dlen_type | NFDK_DESC_TX_EOP);
1169
1170         /* Metadata desc */
1171         txd->raw = cpu_to_le64(metadata);
1172         txd++;
1173
1174         cnt = txd - tx_ring->ktxds - wr_idx;
1175         if (unlikely(round_down(wr_idx, NFDK_TX_DESC_BLOCK_CNT) !=
1176                      round_down(wr_idx + cnt - 1, NFDK_TX_DESC_BLOCK_CNT)))
1177                 goto err_warn_overflow;
1178
1179         tx_ring->wr_p += cnt;
1180         if (tx_ring->wr_p % NFDK_TX_DESC_BLOCK_CNT)
1181                 tx_ring->data_pending += skb->len;
1182         else
1183                 tx_ring->data_pending = 0;
1184
1185         tx_ring->wr_ptr_add += cnt;
1186         nfp_net_tx_xmit_more_flush(tx_ring);
1187
1188         return NETDEV_TX_OK;
1189
1190 err_warn_overflow:
1191         WARN_ONCE(1, "unable to fit packet into a descriptor wr_idx:%d head:%d frags:%d cnt:%d",
1192                   wr_idx, skb_headlen(skb), 0, cnt);
1193         txbuf--;
1194         dma_unmap_single(dp->dev, txbuf->dma_addr,
1195                          skb_headlen(skb), DMA_TO_DEVICE);
1196         txbuf->raw = 0;
1197 err_warn_dma:
1198         nn_dp_warn(dp, "Failed to map DMA TX buffer\n");
1199 err_free:
1200         u64_stats_update_begin(&r_vec->tx_sync);
1201         r_vec->tx_errors++;
1202         u64_stats_update_end(&r_vec->tx_sync);
1203         dev_kfree_skb_any(skb);
1204         return NETDEV_TX_OK;
1205 }
1206
1207 static void __nfp_ctrl_tx_queued(struct nfp_net_r_vector *r_vec)
1208 {
1209         struct sk_buff *skb;
1210
1211         while ((skb = __skb_dequeue(&r_vec->queue)))
1212                 if (nfp_nfdk_ctrl_tx_one(r_vec->nfp_net, r_vec, skb, true))
1213                         return;
1214 }
1215
1216 static bool
1217 nfp_ctrl_meta_ok(struct nfp_net *nn, void *data, unsigned int meta_len)
1218 {
1219         u32 meta_type, meta_tag;
1220
1221         if (!nfp_app_ctrl_has_meta(nn->app))
1222                 return !meta_len;
1223
1224         if (meta_len != 8)
1225                 return false;
1226
1227         meta_type = get_unaligned_be32(data);
1228         meta_tag = get_unaligned_be32(data + 4);
1229
1230         return (meta_type == NFP_NET_META_PORTID &&
1231                 meta_tag == NFP_META_PORT_ID_CTRL);
1232 }
1233
1234 static bool
1235 nfp_ctrl_rx_one(struct nfp_net *nn, struct nfp_net_dp *dp,
1236                 struct nfp_net_r_vector *r_vec, struct nfp_net_rx_ring *rx_ring)
1237 {
1238         unsigned int meta_len, data_len, meta_off, pkt_len, pkt_off;
1239         struct nfp_net_rx_buf *rxbuf;
1240         struct nfp_net_rx_desc *rxd;
1241         dma_addr_t new_dma_addr;
1242         struct sk_buff *skb;
1243         void *new_frag;
1244         int idx;
1245
1246         idx = D_IDX(rx_ring, rx_ring->rd_p);
1247
1248         rxd = &rx_ring->rxds[idx];
1249         if (!(rxd->rxd.meta_len_dd & PCIE_DESC_RX_DD))
1250                 return false;
1251
1252         /* Memory barrier to ensure that we won't do other reads
1253          * before the DD bit.
1254          */
1255         dma_rmb();
1256
1257         rx_ring->rd_p++;
1258
1259         rxbuf = &rx_ring->rxbufs[idx];
1260         meta_len = rxd->rxd.meta_len_dd & PCIE_DESC_RX_META_LEN_MASK;
1261         data_len = le16_to_cpu(rxd->rxd.data_len);
1262         pkt_len = data_len - meta_len;
1263
1264         pkt_off = NFP_NET_RX_BUF_HEADROOM + dp->rx_dma_off;
1265         if (dp->rx_offset == NFP_NET_CFG_RX_OFFSET_DYNAMIC)
1266                 pkt_off += meta_len;
1267         else
1268                 pkt_off += dp->rx_offset;
1269         meta_off = pkt_off - meta_len;
1270
1271         /* Stats update */
1272         u64_stats_update_begin(&r_vec->rx_sync);
1273         r_vec->rx_pkts++;
1274         r_vec->rx_bytes += pkt_len;
1275         u64_stats_update_end(&r_vec->rx_sync);
1276
1277         nfp_net_dma_sync_cpu_rx(dp, rxbuf->dma_addr + meta_off, data_len);
1278
1279         if (unlikely(!nfp_ctrl_meta_ok(nn, rxbuf->frag + meta_off, meta_len))) {
1280                 nn_dp_warn(dp, "incorrect metadata for ctrl packet (%d)\n",
1281                            meta_len);
1282                 nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, NULL);
1283                 return true;
1284         }
1285
1286         skb = build_skb(rxbuf->frag, dp->fl_bufsz);
1287         if (unlikely(!skb)) {
1288                 nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, NULL);
1289                 return true;
1290         }
1291         new_frag = nfp_nfdk_napi_alloc_one(dp, &new_dma_addr);
1292         if (unlikely(!new_frag)) {
1293                 nfp_nfdk_rx_drop(dp, r_vec, rx_ring, rxbuf, skb);
1294                 return true;
1295         }
1296
1297         nfp_net_dma_unmap_rx(dp, rxbuf->dma_addr);
1298
1299         nfp_nfdk_rx_give_one(dp, rx_ring, new_frag, new_dma_addr);
1300
1301         skb_reserve(skb, pkt_off);
1302         skb_put(skb, pkt_len);
1303
1304         nfp_app_ctrl_rx(nn->app, skb);
1305
1306         return true;
1307 }
1308
1309 static bool nfp_ctrl_rx(struct nfp_net_r_vector *r_vec)
1310 {
1311         struct nfp_net_rx_ring *rx_ring = r_vec->rx_ring;
1312         struct nfp_net *nn = r_vec->nfp_net;
1313         struct nfp_net_dp *dp = &nn->dp;
1314         unsigned int budget = 512;
1315
1316         while (nfp_ctrl_rx_one(nn, dp, r_vec, rx_ring) && budget--)
1317                 continue;
1318
1319         return budget;
1320 }
1321
1322 void nfp_nfdk_ctrl_poll(struct tasklet_struct *t)
1323 {
1324         struct nfp_net_r_vector *r_vec = from_tasklet(r_vec, t, tasklet);
1325
1326         spin_lock(&r_vec->lock);
1327         nfp_nfdk_tx_complete(r_vec->tx_ring, 0);
1328         __nfp_ctrl_tx_queued(r_vec);
1329         spin_unlock(&r_vec->lock);
1330
1331         if (nfp_ctrl_rx(r_vec)) {
1332                 nfp_net_irq_unmask(r_vec->nfp_net, r_vec->irq_entry);
1333         } else {
1334                 tasklet_schedule(&r_vec->tasklet);
1335                 nn_dp_warn(&r_vec->nfp_net->dp,
1336                            "control message budget exceeded!\n");
1337         }
1338 }