drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

   1 /* Broadcom NetXtreme-C/E network driver.
   2  *
   3  * Copyright (c) 2016-2017 Broadcom Limited
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation.
   8  */
   9 #include <linux/kernel.h>
  10 #include <linux/errno.h>
  11 #include <linux/pci.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/etherdevice.h>
  14 #include <linux/if_vlan.h>
  15 #include <linux/bpf.h>
  16 #include <linux/bpf_trace.h>
  17 #include <linux/filter.h>
  18 #include <net/page_pool.h>
  19 #include "bnxt_hsi.h"
  20 #include "bnxt.h"
  21 #include "bnxt_xdp.h"
  22
  23 struct bnxt_sw_tx_bd *bnxt_xmit_bd(struct bnxt *bp,
  24                                    struct bnxt_tx_ring_info *txr,
  25                                    dma_addr_t mapping, u32 len)
  26 {
  27         struct bnxt_sw_tx_bd *tx_buf;
  28         struct tx_bd *txbd;
  29         u32 flags;
  30         u16 prod;
  31
  32         prod = txr->tx_prod;
  33         tx_buf = &txr->tx_buf_ring[prod];
  34
  35         txbd = &txr->tx_desc_ring[TX_RING(prod)][TX_IDX(prod)];
  36         flags = (len << TX_BD_LEN_SHIFT) | (1 << TX_BD_FLAGS_BD_CNT_SHIFT) |
  37                 TX_BD_FLAGS_PACKET_END | bnxt_lhint_arr[len >> 9];
  38         txbd->tx_bd_len_flags_type = cpu_to_le32(flags);
  39         txbd->tx_bd_opaque = prod;
  40         txbd->tx_bd_haddr = cpu_to_le64(mapping);
  41
  42         prod = NEXT_TX(prod);
  43         txr->tx_prod = prod;
  44         return tx_buf;
  45 }
  46
  47 static void __bnxt_xmit_xdp(struct bnxt *bp, struct bnxt_tx_ring_info *txr,
  48                             dma_addr_t mapping, u32 len, u16 rx_prod)
  49 {
  50         struct bnxt_sw_tx_bd *tx_buf;
  51
  52         tx_buf = bnxt_xmit_bd(bp, txr, mapping, len);
  53         tx_buf->rx_prod = rx_prod;
  54         tx_buf->action = XDP_TX;
  55 }
  56
  57 static void __bnxt_xmit_xdp_redirect(struct bnxt *bp,
  58                                      struct bnxt_tx_ring_info *txr,
  59                                      dma_addr_t mapping, u32 len,
  60                                      struct xdp_frame *xdpf)
  61 {
  62         struct bnxt_sw_tx_bd *tx_buf;
  63
  64         tx_buf = bnxt_xmit_bd(bp, txr, mapping, len);
  65         tx_buf->action = XDP_REDIRECT;
  66         tx_buf->xdpf = xdpf;
  67         dma_unmap_addr_set(tx_buf, mapping, mapping);
  68         dma_unmap_len_set(tx_buf, len, 0);
  69 }
  70
  71 void bnxt_tx_int_xdp(struct bnxt *bp, struct bnxt_napi *bnapi, int nr_pkts)
  72 {
  73         struct bnxt_tx_ring_info *txr = bnapi->tx_ring;
  74         struct bnxt_rx_ring_info *rxr = bnapi->rx_ring;
  75         bool rx_doorbell_needed = false;
  76         struct bnxt_sw_tx_bd *tx_buf;
  77         u16 tx_cons = txr->tx_cons;
  78         u16 last_tx_cons = tx_cons;
  79         int i;
  80
  81         for (i = 0; i < nr_pkts; i++) {
  82                 tx_buf = &txr->tx_buf_ring[tx_cons];
  83
  84                 if (tx_buf->action == XDP_REDIRECT) {
  85                         struct pci_dev *pdev = bp->pdev;
  86
  87                         dma_unmap_single(&pdev->dev,
  88                                          dma_unmap_addr(tx_buf, mapping),
  89                                          dma_unmap_len(tx_buf, len),
  90                                          PCI_DMA_TODEVICE);
  91                         xdp_return_frame(tx_buf->xdpf);
  92                         tx_buf->action = 0;
  93                         tx_buf->xdpf = NULL;
  94                 } else if (tx_buf->action == XDP_TX) {
  95                         rx_doorbell_needed = true;
  96                         last_tx_cons = tx_cons;
  97                 }
  98                 tx_cons = NEXT_TX(tx_cons);
  99         }
 100         txr->tx_cons = tx_cons;
 101         if (rx_doorbell_needed) {
 102                 tx_buf = &txr->tx_buf_ring[last_tx_cons];
 103                 bnxt_db_write(bp, &rxr->rx_db, tx_buf->rx_prod);
 104         }
 105 }
 106
 107 /* returns the following:
 108  * true    - packet consumed by XDP and new buffer is allocated.
 109  * false   - packet should be passed to the stack.
 110  */
 111 bool bnxt_rx_xdp(struct bnxt *bp, struct bnxt_rx_ring_info *rxr, u16 cons,
 112                  struct page *page, u8 **data_ptr, unsigned int *len, u8 *event)
 113 {
 114         struct bpf_prog *xdp_prog = READ_ONCE(rxr->xdp_prog);
 115         struct bnxt_tx_ring_info *txr;
 116         struct bnxt_sw_rx_bd *rx_buf;
 117         struct pci_dev *pdev;
 118         struct xdp_buff xdp;
 119         dma_addr_t mapping;
 120         void *orig_data;
 121         u32 tx_avail;
 122         u32 offset;
 123         u32 act;
 124
 125         if (!xdp_prog)
 126                 return false;
 127
 128         pdev = bp->pdev;
 129         rx_buf = &rxr->rx_buf_ring[cons];
 130         offset = bp->rx_offset;
 131
 132         mapping = rx_buf->mapping - bp->rx_dma_offset;
 133         dma_sync_single_for_cpu(&pdev->dev, mapping + offset, *len, bp->rx_dir);
 134
 135         txr = rxr->bnapi->tx_ring;
 136         /* BNXT_RX_PAGE_MODE(bp) when XDP enabled */
 137         xdp_init_buff(&xdp, PAGE_SIZE, &rxr->xdp_rxq);
 138         xdp_prepare_buff(&xdp, *data_ptr - offset, offset, *len, false);
 139         orig_data = xdp.data;
 140
 141         rcu_read_lock();
 142         act = bpf_prog_run_xdp(xdp_prog, &xdp);
 143         rcu_read_unlock();
 144
 145         tx_avail = bnxt_tx_avail(bp, txr);
 146         /* If the tx ring is not full, we must not update the rx producer yet
 147          * because we may still be transmitting on some BDs.
 148          */
 149         if (tx_avail != bp->tx_ring_size)
 150                 *event &= ~BNXT_RX_EVENT;
 151
 152         *len = xdp.data_end - xdp.data;
 153         if (orig_data != xdp.data) {
 154                 offset = xdp.data - xdp.data_hard_start;
 155                 *data_ptr = xdp.data_hard_start + offset;
 156         }
 157         switch (act) {
 158         case XDP_PASS:
 159                 return false;
 160
 161         case XDP_TX:
 162                 if (tx_avail < 1) {
 163                         trace_xdp_exception(bp->dev, xdp_prog, act);
 164                         bnxt_reuse_rx_data(rxr, cons, page);
 165                         return true;
 166                 }
 167
 168                 *event = BNXT_TX_EVENT;
 169                 dma_sync_single_for_device(&pdev->dev, mapping + offset, *len,
 170                                            bp->rx_dir);
 171                 __bnxt_xmit_xdp(bp, txr, mapping + offset, *len,
 172                                 NEXT_RX(rxr->rx_prod));
 173                 bnxt_reuse_rx_data(rxr, cons, page);
 174                 return true;
 175         case XDP_REDIRECT:
 176                 /* if we are calling this here then we know that the
 177                  * redirect is coming from a frame received by the
 178                  * bnxt_en driver.
 179                  */
 180                 dma_unmap_page_attrs(&pdev->dev, mapping,
 181                                      PAGE_SIZE, bp->rx_dir,
 182                                      DMA_ATTR_WEAK_ORDERING);
 183
 184                 /* if we are unable to allocate a new buffer, abort and reuse */
 185                 if (bnxt_alloc_rx_data(bp, rxr, rxr->rx_prod, GFP_ATOMIC)) {
 186                         trace_xdp_exception(bp->dev, xdp_prog, act);
 187                         bnxt_reuse_rx_data(rxr, cons, page);
 188                         return true;
 189                 }
 190
 191                 if (xdp_do_redirect(bp->dev, &xdp, xdp_prog)) {
 192                         trace_xdp_exception(bp->dev, xdp_prog, act);
 193                         page_pool_recycle_direct(rxr->page_pool, page);
 194                         return true;
 195                 }
 196
 197                 *event |= BNXT_REDIRECT_EVENT;
 198                 break;
 199         default:
 200                 bpf_warn_invalid_xdp_action(act);
 201                 fallthrough;
 202         case XDP_ABORTED:
 203                 trace_xdp_exception(bp->dev, xdp_prog, act);
 204                 fallthrough;
 205         case XDP_DROP:
 206                 bnxt_reuse_rx_data(rxr, cons, page);
 207                 break;
 208         }
 209         return true;
 210 }
 211
 212 int bnxt_xdp_xmit(struct net_device *dev, int num_frames,
 213                   struct xdp_frame **frames, u32 flags)
 214 {
 215         struct bnxt *bp = netdev_priv(dev);
 216         struct bpf_prog *xdp_prog = READ_ONCE(bp->xdp_prog);
 217         struct pci_dev *pdev = bp->pdev;
 218         struct bnxt_tx_ring_info *txr;
 219         dma_addr_t mapping;
 220         int drops = 0;
 221         int ring;
 222         int i;
 223
 224         if (!test_bit(BNXT_STATE_OPEN, &bp->state) ||
 225             !bp->tx_nr_rings_xdp ||
 226             !xdp_prog)
 227                 return -EINVAL;
 228
 229         ring = smp_processor_id() % bp->tx_nr_rings_xdp;
 230         txr = &bp->tx_ring[ring];
 231
 232         for (i = 0; i < num_frames; i++) {
 233                 struct xdp_frame *xdp = frames[i];
 234
 235                 if (!txr || !bnxt_tx_avail(bp, txr) ||
 236                     !(bp->bnapi[ring]->flags & BNXT_NAPI_FLAG_XDP)) {
 237                         xdp_return_frame_rx_napi(xdp);
 238                         drops++;
 239                         continue;
 240                 }
 241
 242                 mapping = dma_map_single(&pdev->dev, xdp->data, xdp->len,
 243                                          DMA_TO_DEVICE);
 244
 245                 if (dma_mapping_error(&pdev->dev, mapping)) {
 246                         xdp_return_frame_rx_napi(xdp);
 247                         drops++;
 248                         continue;
 249                 }
 250                 __bnxt_xmit_xdp_redirect(bp, txr, mapping, xdp->len, xdp);
 251         }
 252
 253         if (flags & XDP_XMIT_FLUSH) {
 254                 /* Sync BD data before updating doorbell */
 255                 wmb();
 256                 bnxt_db_write(bp, &txr->tx_db, txr->tx_prod);
 257         }
 258
 259         return num_frames - drops;
 260 }
 261
 262 /* Under rtnl_lock */
 263 static int bnxt_xdp_set(struct bnxt *bp, struct bpf_prog *prog)
 264 {
 265         struct net_device *dev = bp->dev;
 266         int tx_xdp = 0, rc, tc;
 267         struct bpf_prog *old;
 268
 269         if (prog && bp->dev->mtu > BNXT_MAX_PAGE_MODE_MTU) {
 270                 netdev_warn(dev, "MTU %d larger than largest XDP supported MTU %d.\n",
 271                             bp->dev->mtu, BNXT_MAX_PAGE_MODE_MTU);
 272                 return -EOPNOTSUPP;
 273         }
 274         if (!(bp->flags & BNXT_FLAG_SHARED_RINGS)) {
 275                 netdev_warn(dev, "ethtool rx/tx channels must be combined to support XDP.\n");
 276                 return -EOPNOTSUPP;
 277         }
 278         if (prog)
 279                 tx_xdp = bp->rx_nr_rings;
 280
 281         tc = netdev_get_num_tc(dev);
 282         if (!tc)
 283                 tc = 1;
 284         rc = bnxt_check_rings(bp, bp->tx_nr_rings_per_tc, bp->rx_nr_rings,
 285                               true, tc, tx_xdp);
 286         if (rc) {
 287                 netdev_warn(dev, "Unable to reserve enough TX rings to support XDP.\n");
 288                 return rc;
 289         }
 290         if (netif_running(dev))
 291                 bnxt_close_nic(bp, true, false);
 292
 293         old = xchg(&bp->xdp_prog, prog);
 294         if (old)
 295                 bpf_prog_put(old);
 296
 297         if (prog) {
 298                 bnxt_set_rx_skb_mode(bp, true);
 299         } else {
 300                 int rx, tx;
 301
 302                 bnxt_set_rx_skb_mode(bp, false);
 303                 bnxt_get_max_rings(bp, &rx, &tx, true);
 304                 if (rx > 1) {
 305                         bp->flags &= ~BNXT_FLAG_NO_AGG_RINGS;
 306                         bp->dev->hw_features |= NETIF_F_LRO;
 307                 }
 308         }
 309         bp->tx_nr_rings_xdp = tx_xdp;
 310         bp->tx_nr_rings = bp->tx_nr_rings_per_tc * tc + tx_xdp;
 311         bp->cp_nr_rings = max_t(int, bp->tx_nr_rings, bp->rx_nr_rings);
 312         bnxt_set_tpa_flags(bp);
 313         bnxt_set_ring_params(bp);
 314
 315         if (netif_running(dev))
 316                 return bnxt_open_nic(bp, true, false);
 317
 318         return 0;
 319 }
 320
 321 int bnxt_xdp(struct net_device *dev, struct netdev_bpf *xdp)
 322 {
 323         struct bnxt *bp = netdev_priv(dev);
 324         int rc;
 325
 326         switch (xdp->command) {
 327         case XDP_SETUP_PROG:
 328                 rc = bnxt_xdp_set(bp, xdp->prog);
 329                 break;
 330         default:
 331                 rc = -EINVAL;
 332                 break;
 333         }
 334         return rc;
 335 }