IB/mlx4: Initialize SR-IOV IB support for slaves in master context

Allocate SR-IOV paravirtualization resources and MAD demuxing contexts
on the master.

This has two parts.  The first part is to initialize the structures to
contain the contexts.  This is done at master startup time in
mlx4_ib_init_sriov().

The second part is to actually create the tunneling resources required
on the master to support a slave.  This is performed the master
detects that a slave has started up (MLX4_DEV_EVENT_SLAVE_INIT event
generated when a slave initializes its comm channel).

For the master, there is no such startup event, so it creates its own
tunneling resources when it starts up.  In addition, the master also
creates the real special QPs.  The ib_core layer on the master causes
creation of proxy special QPs, since the master is also
paravirtualized at the ib_core layer.

Signed-off-by: Jack Morgenstein <jackm@dev.mellanox.co.il>
Signed-off-by: Roland Dreier <roland@purestorage.com>

6 files changed, 798 insertions, 8 deletions

diff --git a/drivers/infiniband/hw/mlx4/mad.c b/drivers/infiniband/hw/mlx4/mad.c
index 9c2ae7efd00..e98849338a9 100644
--- a/drivers/infiniband/hw/mlx4/mad.c
+++ b/drivers/infiniband/hw/mlx4/mad.c
@@ -44,6 +44,35 @@ enum {
         MLX4_IB_VENDOR_CLASS2 = 0xa
 };
 
+#define MLX4_TUN_SEND_WRID_SHIFT 34
+#define MLX4_TUN_QPN_SHIFT 32
+#define MLX4_TUN_WRID_RECV (((u64) 1) << MLX4_TUN_SEND_WRID_SHIFT)
+#define MLX4_TUN_SET_WRID_QPN(a) (((u64) ((a) & 0x3)) << MLX4_TUN_QPN_SHIFT)
+
+#define MLX4_TUN_IS_RECV(a)  (((a) >>  MLX4_TUN_SEND_WRID_SHIFT) & 0x1)
+#define MLX4_TUN_WRID_QPN(a) (((a) >> MLX4_TUN_QPN_SHIFT) & 0x3)
+
+struct mlx4_mad_rcv_buf {
+        struct ib_grh grh;
+        u8 payload[256];
+} __packed;
+
+struct mlx4_mad_snd_buf {
+        u8 payload[256];
+} __packed;
+
+struct mlx4_tunnel_mad {
+        struct ib_grh grh;
+        struct mlx4_ib_tunnel_header hdr;
+        struct ib_mad mad;
+} __packed;
+
+struct mlx4_rcv_tunnel_mad {
+        struct mlx4_rcv_tunnel_hdr hdr;
+        struct ib_grh grh;
+        struct ib_mad mad;
+} __packed;
+
 int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int ignore_mkey, int ignore_bkey,
                  int port, struct ib_wc *in_wc, struct ib_grh *in_grh,
                  void *in_mad, void *response_mad)
@@ -516,3 +545,658 @@ void mlx4_ib_dispatch_event(struct mlx4_ib_dev *dev, u8 port_num,
 
         ib_dispatch_event(&event);
 }
+
+static void mlx4_ib_tunnel_comp_handler(struct ib_cq *cq, void *arg)
+{
+        unsigned long flags;
+        struct mlx4_ib_demux_pv_ctx *ctx = cq->cq_context;
+        struct mlx4_ib_dev *dev = to_mdev(ctx->ib_dev);
+        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
+        if (!dev->sriov.is_going_down && ctx->state == DEMUX_PV_STATE_ACTIVE)
+                queue_work(ctx->wq, &ctx->work);
+        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
+}
+
+static int mlx4_ib_post_pv_qp_buf(struct mlx4_ib_demux_pv_ctx *ctx,
+                                  struct mlx4_ib_demux_pv_qp *tun_qp,
+                                  int index)
+{
+        struct ib_sge sg_list;
+        struct ib_recv_wr recv_wr, *bad_recv_wr;
+        int size;
+
+        size = (tun_qp->qp->qp_type == IB_QPT_UD) ?
+                sizeof (struct mlx4_tunnel_mad) : sizeof (struct mlx4_mad_rcv_buf);
+
+        sg_list.addr = tun_qp->ring[index].map;
+        sg_list.length = size;
+        sg_list.lkey = ctx->mr->lkey;
+
+        recv_wr.next = NULL;
+        recv_wr.sg_list = &sg_list;
+        recv_wr.num_sge = 1;
+        recv_wr.wr_id = (u64) index | MLX4_TUN_WRID_RECV |
+                MLX4_TUN_SET_WRID_QPN(tun_qp->proxy_qpt);
+        ib_dma_sync_single_for_device(ctx->ib_dev, tun_qp->ring[index].map,
+                                      size, DMA_FROM_DEVICE);
+        return ib_post_recv(tun_qp->qp, &recv_wr, &bad_recv_wr);
+}
+
+static int mlx4_ib_alloc_pv_bufs(struct mlx4_ib_demux_pv_ctx *ctx,
+                                 enum ib_qp_type qp_type, int is_tun)
+{
+        int i;
+        struct mlx4_ib_demux_pv_qp *tun_qp;
+        int rx_buf_size, tx_buf_size;
+
+        if (qp_type > IB_QPT_GSI)
+                return -EINVAL;
+
+        tun_qp = &ctx->qp[qp_type];
+
+        tun_qp->ring = kzalloc(sizeof (struct mlx4_ib_buf) * MLX4_NUM_TUNNEL_BUFS,
+                               GFP_KERNEL);
+        if (!tun_qp->ring)
+                return -ENOMEM;
+
+        tun_qp->tx_ring = kcalloc(MLX4_NUM_TUNNEL_BUFS,
+                                  sizeof (struct mlx4_ib_tun_tx_buf),
+                                  GFP_KERNEL);
+        if (!tun_qp->tx_ring) {
+                kfree(tun_qp->ring);
+                tun_qp->ring = NULL;
+                return -ENOMEM;
+        }
+
+        if (is_tun) {
+                rx_buf_size = sizeof (struct mlx4_tunnel_mad);
+                tx_buf_size = sizeof (struct mlx4_rcv_tunnel_mad);
+        } else {
+                rx_buf_size = sizeof (struct mlx4_mad_rcv_buf);
+                tx_buf_size = sizeof (struct mlx4_mad_snd_buf);
+        }
+
+        for (i = 0; i < MLX4_NUM_TUNNEL_BUFS; i++) {
+                tun_qp->ring[i].addr = kmalloc(rx_buf_size, GFP_KERNEL);
+                if (!tun_qp->ring[i].addr)
+                        goto err;
+                tun_qp->ring[i].map = ib_dma_map_single(ctx->ib_dev,
+                                                        tun_qp->ring[i].addr,
+                                                        rx_buf_size,
+                                                        DMA_FROM_DEVICE);
+        }
+
+        for (i = 0; i < MLX4_NUM_TUNNEL_BUFS; i++) {
+                tun_qp->tx_ring[i].buf.addr =
+                        kmalloc(tx_buf_size, GFP_KERNEL);
+                if (!tun_qp->tx_ring[i].buf.addr)
+                        goto tx_err;
+                tun_qp->tx_ring[i].buf.map =
+                        ib_dma_map_single(ctx->ib_dev,
+                                          tun_qp->tx_ring[i].buf.addr,
+                                          tx_buf_size,
+                                          DMA_TO_DEVICE);
+                tun_qp->tx_ring[i].ah = NULL;
+        }
+        spin_lock_init(&tun_qp->tx_lock);
+        tun_qp->tx_ix_head = 0;
+        tun_qp->tx_ix_tail = 0;
+        tun_qp->proxy_qpt = qp_type;
+
+        return 0;
+
+tx_err:
+        while (i > 0) {
+                --i;
+                ib_dma_unmap_single(ctx->ib_dev, tun_qp->tx_ring[i].buf.map,
+                                    tx_buf_size, DMA_TO_DEVICE);
+                kfree(tun_qp->tx_ring[i].buf.addr);
+        }
+        kfree(tun_qp->tx_ring);
+        tun_qp->tx_ring = NULL;
+        i = MLX4_NUM_TUNNEL_BUFS;
+err:
+        while (i > 0) {
+                --i;
+                ib_dma_unmap_single(ctx->ib_dev, tun_qp->ring[i].map,
+                                    rx_buf_size, DMA_FROM_DEVICE);
+                kfree(tun_qp->ring[i].addr);
+        }
+        kfree(tun_qp->ring);
+        tun_qp->ring = NULL;
+        return -ENOMEM;
+}
+
+static void mlx4_ib_free_pv_qp_bufs(struct mlx4_ib_demux_pv_ctx *ctx,
+                                     enum ib_qp_type qp_type, int is_tun)
+{
+        int i;
+        struct mlx4_ib_demux_pv_qp *tun_qp;
+        int rx_buf_size, tx_buf_size;
+
+        if (qp_type > IB_QPT_GSI)
+                return;
+
+        tun_qp = &ctx->qp[qp_type];
+        if (is_tun) {
+                rx_buf_size = sizeof (struct mlx4_tunnel_mad);
+                tx_buf_size = sizeof (struct mlx4_rcv_tunnel_mad);
+        } else {
+                rx_buf_size = sizeof (struct mlx4_mad_rcv_buf);
+                tx_buf_size = sizeof (struct mlx4_mad_snd_buf);
+        }
+
+
+        for (i = 0; i < MLX4_NUM_TUNNEL_BUFS; i++) {
+                ib_dma_unmap_single(ctx->ib_dev, tun_qp->ring[i].map,
+                                    rx_buf_size, DMA_FROM_DEVICE);
+                kfree(tun_qp->ring[i].addr);
+        }
+
+        for (i = 0; i < MLX4_NUM_TUNNEL_BUFS; i++) {
+                ib_dma_unmap_single(ctx->ib_dev, tun_qp->tx_ring[i].buf.map,
+                                    tx_buf_size, DMA_TO_DEVICE);
+                kfree(tun_qp->tx_ring[i].buf.addr);
+                if (tun_qp->tx_ring[i].ah)