Author: hselasky
Date: Tue Feb 13 17:04:34 2018
New Revision: 329222
URL: https://svnweb.freebsd.org/changeset/base/329222

Log:
  Import the mthca kernel side infiniband driver from Linux 4.9 and fix
  compilation under FreeBSD. The mthca driver was temporarily removed as
  part of the Linux 4.9 RoCE/infinband upgrade.
  
  Top commit in Linux source tree:
  69973b830859bc6529a7a0468ba0d80ee5117826
  
  Sponsored by: Mellanox Technologies

Added:
  head/sys/dev/mthca/
  head/sys/dev/mthca/mthca_allocator.c   (contents, props changed)
  head/sys/dev/mthca/mthca_av.c   (contents, props changed)
  head/sys/dev/mthca/mthca_catas.c   (contents, props changed)
  head/sys/dev/mthca/mthca_cmd.c   (contents, props changed)
  head/sys/dev/mthca/mthca_cmd.h   (contents, props changed)
  head/sys/dev/mthca/mthca_config_reg.h   (contents, props changed)
  head/sys/dev/mthca/mthca_cq.c   (contents, props changed)
  head/sys/dev/mthca/mthca_dev.h   (contents, props changed)
  head/sys/dev/mthca/mthca_doorbell.h   (contents, props changed)
  head/sys/dev/mthca/mthca_eq.c   (contents, props changed)
  head/sys/dev/mthca/mthca_mad.c   (contents, props changed)
  head/sys/dev/mthca/mthca_main.c   (contents, props changed)
  head/sys/dev/mthca/mthca_mcg.c   (contents, props changed)
  head/sys/dev/mthca/mthca_memfree.c   (contents, props changed)
  head/sys/dev/mthca/mthca_memfree.h   (contents, props changed)
  head/sys/dev/mthca/mthca_mr.c   (contents, props changed)
  head/sys/dev/mthca/mthca_pd.c   (contents, props changed)
  head/sys/dev/mthca/mthca_profile.c   (contents, props changed)
  head/sys/dev/mthca/mthca_profile.h   (contents, props changed)
  head/sys/dev/mthca/mthca_provider.c   (contents, props changed)
  head/sys/dev/mthca/mthca_provider.h   (contents, props changed)
  head/sys/dev/mthca/mthca_qp.c   (contents, props changed)
  head/sys/dev/mthca/mthca_reset.c   (contents, props changed)
  head/sys/dev/mthca/mthca_srq.c   (contents, props changed)
  head/sys/dev/mthca/mthca_uar.c   (contents, props changed)
  head/sys/dev/mthca/mthca_user.h   (contents, props changed)
  head/sys/dev/mthca/mthca_wqe.h   (contents, props changed)
  head/sys/modules/mthca/
  head/sys/modules/mthca/Makefile   (contents, props changed)
  head/sys/ofed/include/uapi/rdma/mthca-abi.h   (contents, props changed)
Modified:
  head/sys/amd64/conf/NOTES
  head/sys/conf/files
  head/sys/i386/conf/NOTES
  head/sys/modules/Makefile

Modified: head/sys/amd64/conf/NOTES
==============================================================================
--- head/sys/amd64/conf/NOTES   Tue Feb 13 16:48:57 2018        (r329221)
+++ head/sys/amd64/conf/NOTES   Tue Feb 13 17:04:34 2018        (r329222)
@@ -315,6 +315,7 @@ options     DRM_DEBUG       # Include debug printfs (slow)
 #      Requires the iwn firmware module
 # ixl: Intel XL710 40Gbe PCIE Ethernet
 # ixlv:        Intel XL710 40Gbe VF PCIE Ethernet
+# mthca: Mellanox HCA InfiniBand
 # mlx4ib: Mellanox ConnectX HCA InfiniBand
 # mlx4en: Mellanox ConnectX HCA Ethernet
 # nfe: nVidia nForce MCP on-board Ethernet Networking (BSD open source)
@@ -334,6 +335,7 @@ device              iwn             # Intel 
4965/1000/5000/6000 wireless NICs
 device         ixl             # Intel XL710 40Gbe PCIE Ethernet
 options                IXL_IW          # Enable iWARP Client Interface in 
ixl(4)
 device         ixlv            # Intel XL710 40Gbe VF PCIE Ethernet
+device         mthca           # Mellanox HCA InfiniBand
 device         mlx4            # Shared code module between IB and Ethernet
 device         mlx4ib          # Mellanox ConnectX HCA InfiniBand
 device         mlx4en          # Mellanox ConnectX HCA Ethernet

Modified: head/sys/conf/files
==============================================================================
--- head/sys/conf/files Tue Feb 13 16:48:57 2018        (r329221)
+++ head/sys/conf/files Tue Feb 13 17:04:34 2018        (r329222)
@@ -4551,6 +4551,43 @@ ofed/drivers/infiniband/ulp/sdp/sdp_cma.c        
optional sdp
 ofed/drivers/infiniband/ulp/sdp/sdp_tx.c       optional sdp inet       \
        compile-with "${OFED_C} -I$S/ofed/drivers/infiniband/ulp/sdp/"
 
+dev/mthca/mthca_allocator.c            optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_av.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_catas.c                        optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_cmd.c                  optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_cq.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_eq.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_mad.c                  optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_main.c                 optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_mcg.c                  optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_memfree.c              optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_mr.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_pd.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_profile.c              optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_provider.c             optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_qp.c                   optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_reset.c                        optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_srq.c                  optional mthca pci ofed \
+       compile-with "${OFED_C}"
+dev/mthca/mthca_uar.c                  optional mthca pci ofed \
+       compile-with "${OFED_C}"
+
 dev/mlx4/mlx4_ib/mlx4_ib_alias_GUID.c          optional mlx4ib pci ofed \
        compile-with "${OFED_C}"
 dev/mlx4/mlx4_ib/mlx4_ib_mcg.c                 optional mlx4ib pci ofed \

Added: head/sys/dev/mthca/mthca_allocator.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/mthca/mthca_allocator.c        Tue Feb 13 17:04:34 2018        
(r329222)
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2004 Topspin Communications.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/bitmap.h>
+
+#include "mthca_dev.h"
+
+/* Trivial bitmap-based allocator */
+u32 mthca_alloc(struct mthca_alloc *alloc)
+{
+       unsigned long flags;
+       u32 obj;
+
+       spin_lock_irqsave(&alloc->lock, flags);
+
+       obj = find_next_zero_bit(alloc->table, alloc->max, alloc->last);
+       if (obj >= alloc->max) {
+               alloc->top = (alloc->top + alloc->max) & alloc->mask;
+               obj = find_first_zero_bit(alloc->table, alloc->max);
+       }
+
+       if (obj < alloc->max) {
+               set_bit(obj, alloc->table);
+               obj |= alloc->top;
+       } else
+               obj = -1;
+
+       spin_unlock_irqrestore(&alloc->lock, flags);
+
+       return obj;
+}
+
+void mthca_free(struct mthca_alloc *alloc, u32 obj)
+{
+       unsigned long flags;
+
+       obj &= alloc->max - 1;
+
+       spin_lock_irqsave(&alloc->lock, flags);
+
+       clear_bit(obj, alloc->table);
+       alloc->last = min(alloc->last, obj);
+       alloc->top = (alloc->top + alloc->max) & alloc->mask;
+
+       spin_unlock_irqrestore(&alloc->lock, flags);
+}
+
+int mthca_alloc_init(struct mthca_alloc *alloc, u32 num, u32 mask,
+                    u32 reserved)
+{
+       int i;
+
+       /* num must be a power of 2 */
+       if (num != 1 << (ffs(num) - 1))
+               return -EINVAL;
+
+       alloc->last = 0;
+       alloc->top  = 0;
+       alloc->max  = num;
+       alloc->mask = mask;
+       spin_lock_init(&alloc->lock);
+       alloc->table = kmalloc(BITS_TO_LONGS(num) * sizeof (long),
+                              GFP_KERNEL);
+       if (!alloc->table)
+               return -ENOMEM;
+
+       bitmap_zero(alloc->table, num);
+       for (i = 0; i < reserved; ++i)
+               set_bit(i, alloc->table);
+
+       return 0;
+}
+
+void mthca_alloc_cleanup(struct mthca_alloc *alloc)
+{
+       kfree(alloc->table);
+}
+
+/*
+ * Array of pointers with lazy allocation of leaf pages.  Callers of
+ * _get, _set and _clear methods must use a lock or otherwise
+ * serialize access to the array.
+ */
+
+#define MTHCA_ARRAY_MASK (PAGE_SIZE / sizeof (void *) - 1)
+
+void *mthca_array_get(struct mthca_array *array, int index)
+{
+       int p = (index * sizeof (void *)) >> PAGE_SHIFT;
+
+       if (array->page_list[p].page)
+               return array->page_list[p].page[index & MTHCA_ARRAY_MASK];
+       else
+               return NULL;
+}
+
+int mthca_array_set(struct mthca_array *array, int index, void *value)
+{
+       int p = (index * sizeof (void *)) >> PAGE_SHIFT;
+
+       /* Allocate with GFP_ATOMIC because we'll be called with locks held. */
+       if (!array->page_list[p].page)
+               array->page_list[p].page = (void **) 
get_zeroed_page(GFP_ATOMIC);
+
+       if (!array->page_list[p].page)
+               return -ENOMEM;
+
+       array->page_list[p].page[index & MTHCA_ARRAY_MASK] = value;
+       ++array->page_list[p].used;
+
+       return 0;
+}
+
+void mthca_array_clear(struct mthca_array *array, int index)
+{
+       int p = (index * sizeof (void *)) >> PAGE_SHIFT;
+
+       if (--array->page_list[p].used == 0) {
+               free_page((unsigned long) array->page_list[p].page);
+               array->page_list[p].page = NULL;
+       } else
+               array->page_list[p].page[index & MTHCA_ARRAY_MASK] = NULL;
+
+       if (array->page_list[p].used < 0)
+               pr_debug("Array %p index %d page %d with ref count %d < 0\n",
+                        array, index, p, array->page_list[p].used);
+}
+
+int mthca_array_init(struct mthca_array *array, int nent)
+{
+       int npage = (nent * sizeof (void *) + PAGE_SIZE - 1) / PAGE_SIZE;
+       int i;
+
+       array->page_list = kmalloc(npage * sizeof *array->page_list, 
GFP_KERNEL);
+       if (!array->page_list)
+               return -ENOMEM;
+
+       for (i = 0; i < npage; ++i) {
+               array->page_list[i].page = NULL;
+               array->page_list[i].used = 0;
+       }
+
+       return 0;
+}
+
+void mthca_array_cleanup(struct mthca_array *array, int nent)
+{
+       int i;
+
+       for (i = 0; i < (nent * sizeof (void *) + PAGE_SIZE - 1) / PAGE_SIZE; 
++i)
+               free_page((unsigned long) array->page_list[i].page);
+
+       kfree(array->page_list);
+}
+
+/*
+ * Handling for queue buffers -- we allocate a bunch of memory and
+ * register it in a memory region at HCA virtual address 0.  If the
+ * requested size is > max_direct, we split the allocation into
+ * multiple pages, so we don't require too much contiguous memory.
+ */
+
+int mthca_buf_alloc(struct mthca_dev *dev, int size, int max_direct,
+                   union mthca_buf *buf, int *is_direct, struct mthca_pd *pd,
+                   int hca_write, struct mthca_mr *mr)
+{
+       int err = -ENOMEM;
+       int npages, shift;
+       u64 *dma_list = NULL;
+       dma_addr_t t;
+       int i;
+
+       if (size <= max_direct) {
+               *is_direct = 1;
+               npages     = 1;
+               shift      = get_order(size) + PAGE_SHIFT;
+
+               buf->direct.buf = dma_alloc_coherent(&dev->pdev->dev,
+                                                    size, &t, GFP_KERNEL);
+               if (!buf->direct.buf)
+                       return -ENOMEM;
+
+               dma_unmap_addr_set(&buf->direct, mapping, t);
+
+               memset(buf->direct.buf, 0, size);
+
+               while (t & ((1 << shift) - 1)) {
+                       --shift;
+                       npages *= 2;
+               }
+
+               dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL);
+               if (!dma_list)
+                       goto err_free;
+
+               for (i = 0; i < npages; ++i)
+                       dma_list[i] = t + i * (1 << shift);
+       } else {
+               *is_direct = 0;
+               npages     = (size + PAGE_SIZE - 1) / PAGE_SIZE;
+               shift      = PAGE_SHIFT;
+
+               dma_list = kmalloc(npages * sizeof *dma_list, GFP_KERNEL);
+               if (!dma_list)
+                       return -ENOMEM;
+
+               buf->page_list = kmalloc(npages * sizeof *buf->page_list,
+                                        GFP_KERNEL);
+               if (!buf->page_list)
+                       goto err_out;
+
+               for (i = 0; i < npages; ++i)
+                       buf->page_list[i].buf = NULL;
+
+               for (i = 0; i < npages; ++i) {
+                       buf->page_list[i].buf =
+                               dma_alloc_coherent(&dev->pdev->dev, PAGE_SIZE,
+                                                  &t, GFP_KERNEL);
+                       if (!buf->page_list[i].buf)
+                               goto err_free;
+
+                       dma_list[i] = t;
+                       dma_unmap_addr_set(&buf->page_list[i], mapping, t);
+
+                       clear_page(buf->page_list[i].buf);
+               }
+       }
+
+       err = mthca_mr_alloc_phys(dev, pd->pd_num,
+                                 dma_list, shift, npages,
+                                 0, size,
+                                 MTHCA_MPT_FLAG_LOCAL_READ |
+                                 (hca_write ? MTHCA_MPT_FLAG_LOCAL_WRITE : 0),
+                                 mr);
+       if (err)
+               goto err_free;
+
+       kfree(dma_list);
+
+       return 0;
+
+err_free:
+       mthca_buf_free(dev, size, buf, *is_direct, NULL);
+
+err_out:
+       kfree(dma_list);
+
+       return err;
+}
+
+void mthca_buf_free(struct mthca_dev *dev, int size, union mthca_buf *buf,
+                   int is_direct, struct mthca_mr *mr)
+{
+       int i;
+
+       if (mr)
+               mthca_free_mr(dev, mr);
+
+       if (is_direct)
+               dma_free_coherent(&dev->pdev->dev, size, buf->direct.buf,
+                                 dma_unmap_addr(&buf->direct, mapping));
+       else {
+               for (i = 0; i < (size + PAGE_SIZE - 1) / PAGE_SIZE; ++i)
+                       dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,
+                                         buf->page_list[i].buf,
+                                         dma_unmap_addr(&buf->page_list[i],
+                                                        mapping));
+               kfree(buf->page_list);
+       }
+}

Added: head/sys/dev/mthca/mthca_av.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/mthca/mthca_av.c       Tue Feb 13 17:04:34 2018        
(r329222)
@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) 2004 Topspin Communications.  All rights reserved.
+ * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <linux/string.h>
+#include <linux/slab.h>
+
+#include <rdma/ib_verbs.h>
+#include <rdma/ib_cache.h>
+
+#include "mthca_dev.h"
+
+enum {
+      MTHCA_RATE_TAVOR_FULL   = 0,
+      MTHCA_RATE_TAVOR_1X     = 1,
+      MTHCA_RATE_TAVOR_4X     = 2,
+      MTHCA_RATE_TAVOR_1X_DDR = 3
+};
+
+enum {
+      MTHCA_RATE_MEMFREE_FULL    = 0,
+      MTHCA_RATE_MEMFREE_QUARTER = 1,
+      MTHCA_RATE_MEMFREE_EIGHTH  = 2,
+      MTHCA_RATE_MEMFREE_HALF    = 3
+};
+
+struct mthca_av {
+       __be32 port_pd;
+       u8     reserved1;
+       u8     g_slid;
+       __be16 dlid;
+       u8     reserved2;
+       u8     gid_index;
+       u8     msg_sr;
+       u8     hop_limit;
+       __be32 sl_tclass_flowlabel;
+       __be32 dgid[4];
+};
+
+static enum ib_rate memfree_rate_to_ib(u8 mthca_rate, u8 port_rate)
+{
+       switch (mthca_rate) {
+       case MTHCA_RATE_MEMFREE_EIGHTH:
+               return mult_to_ib_rate(port_rate >> 3);
+       case MTHCA_RATE_MEMFREE_QUARTER:
+               return mult_to_ib_rate(port_rate >> 2);
+       case MTHCA_RATE_MEMFREE_HALF:
+               return mult_to_ib_rate(port_rate >> 1);
+       case MTHCA_RATE_MEMFREE_FULL:
+       default:
+               return mult_to_ib_rate(port_rate);
+       }
+}
+
+static enum ib_rate tavor_rate_to_ib(u8 mthca_rate, u8 port_rate)
+{
+       switch (mthca_rate) {
+       case MTHCA_RATE_TAVOR_1X:     return IB_RATE_2_5_GBPS;
+       case MTHCA_RATE_TAVOR_1X_DDR: return IB_RATE_5_GBPS;
+       case MTHCA_RATE_TAVOR_4X:     return IB_RATE_10_GBPS;
+       default:                      return mult_to_ib_rate(port_rate);
+       }
+}
+
+enum ib_rate mthca_rate_to_ib(struct mthca_dev *dev, u8 mthca_rate, u8 port)
+{
+       if (mthca_is_memfree(dev)) {
+               /* Handle old Arbel FW */
+               if (dev->limits.stat_rate_support == 0x3 && mthca_rate)
+                       return IB_RATE_2_5_GBPS;
+
+               return memfree_rate_to_ib(mthca_rate, dev->rate[port - 1]);
+       } else
+               return tavor_rate_to_ib(mthca_rate, dev->rate[port - 1]);
+}
+
+static u8 ib_rate_to_memfree(u8 req_rate, u8 cur_rate)
+{
+       if (cur_rate <= req_rate)
+               return 0;
+
+       /*
+        * Inter-packet delay (IPD) to get from rate X down to a rate
+        * no more than Y is (X - 1) / Y.
+        */
+       switch ((cur_rate - 1) / req_rate) {
+       case 0:  return MTHCA_RATE_MEMFREE_FULL;
+       case 1:  return MTHCA_RATE_MEMFREE_HALF;
+       case 2:  /* fall through */
+       case 3:  return MTHCA_RATE_MEMFREE_QUARTER;
+       default: return MTHCA_RATE_MEMFREE_EIGHTH;
+       }
+}
+
+static u8 ib_rate_to_tavor(u8 static_rate)
+{
+       switch (static_rate) {
+       case IB_RATE_2_5_GBPS: return MTHCA_RATE_TAVOR_1X;
+       case IB_RATE_5_GBPS:   return MTHCA_RATE_TAVOR_1X_DDR;
+       case IB_RATE_10_GBPS:  return MTHCA_RATE_TAVOR_4X;
+       default:               return MTHCA_RATE_TAVOR_FULL;
+       }
+}
+
+u8 mthca_get_rate(struct mthca_dev *dev, int static_rate, u8 port)
+{
+       u8 rate;
+
+       if (!static_rate || ib_rate_to_mult(static_rate) >= dev->rate[port - 1])
+               return 0;
+
+       if (mthca_is_memfree(dev))
+               rate = ib_rate_to_memfree(ib_rate_to_mult(static_rate),
+                                         dev->rate[port - 1]);
+       else
+               rate = ib_rate_to_tavor(static_rate);
+
+       if (!(dev->limits.stat_rate_support & (1 << rate)))
+               rate = 1;
+
+       return rate;
+}
+
+int mthca_create_ah(struct mthca_dev *dev,
+                   struct mthca_pd *pd,
+                   struct ib_ah_attr *ah_attr,
+                   struct mthca_ah *ah)
+{
+       u32 index = -1;
+       struct mthca_av *av = NULL;
+
+       ah->type = MTHCA_AH_PCI_POOL;
+
+       if (mthca_is_memfree(dev)) {
+               ah->av   = kmalloc(sizeof *ah->av, GFP_ATOMIC);
+               if (!ah->av)
+                       return -ENOMEM;
+
+               ah->type = MTHCA_AH_KMALLOC;
+               av       = ah->av;
+       } else if (!atomic_read(&pd->sqp_count) &&
+                !(dev->mthca_flags & MTHCA_FLAG_DDR_HIDDEN)) {
+               index = mthca_alloc(&dev->av_table.alloc);
+
+               /* fall back to allocate in host memory */
+               if (index == -1)
+                       goto on_hca_fail;
+
+               av = kmalloc(sizeof *av, GFP_ATOMIC);
+               if (!av)
+                       goto on_hca_fail;
+
+               ah->type = MTHCA_AH_ON_HCA;
+               ah->avdma  = dev->av_table.ddr_av_base +
+                       index * MTHCA_AV_SIZE;
+       }
+
+on_hca_fail:
+       if (ah->type == MTHCA_AH_PCI_POOL) {
+               ah->av = pci_pool_alloc(dev->av_table.pool,
+                                       GFP_ATOMIC, &ah->avdma);
+               if (!ah->av)
+                       return -ENOMEM;
+
+               av = ah->av;
+       }
+
+       ah->key = pd->ntmr.ibmr.lkey;
+
+       memset(av, 0, MTHCA_AV_SIZE);
+
+       av->port_pd = cpu_to_be32(pd->pd_num | (ah_attr->port_num << 24));
+       av->g_slid  = ah_attr->src_path_bits;
+       av->dlid    = cpu_to_be16(ah_attr->dlid);
+       av->msg_sr  = (3 << 4) | /* 2K message */
+               mthca_get_rate(dev, ah_attr->static_rate, ah_attr->port_num);
+       av->sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28);
+       if (ah_attr->ah_flags & IB_AH_GRH) {
+               av->g_slid |= 0x80;
+               av->gid_index = (ah_attr->port_num - 1) * 
dev->limits.gid_table_len +
+                       ah_attr->grh.sgid_index;
+               av->hop_limit = ah_attr->grh.hop_limit;
+               av->sl_tclass_flowlabel |=
+                       cpu_to_be32((ah_attr->grh.traffic_class << 20) |
+                                   ah_attr->grh.flow_label);
+               memcpy(av->dgid, ah_attr->grh.dgid.raw, 16);
+       } else {
+               /* Arbel workaround -- low byte of GID must be 2 */
+               av->dgid[3] = cpu_to_be32(2);
+       }
+
+       if (0) {
+               int j;
+
+               mthca_dbg(dev, "Created UDAV at %p/%08lx:\n",
+                         av, (unsigned long) ah->avdma);
+               for (j = 0; j < 8; ++j)
+                       printk(KERN_DEBUG "  [%2x] %08x\n",
+                              j * 4, be32_to_cpu(((__be32 *) av)[j]));
+       }
+
+       if (ah->type == MTHCA_AH_ON_HCA) {
+               memcpy_toio(dev->av_table.av_map + index * MTHCA_AV_SIZE,
+                           av, MTHCA_AV_SIZE);
+               kfree(av);
+       }
+
+       return 0;
+}
+
+int mthca_destroy_ah(struct mthca_dev *dev, struct mthca_ah *ah)
+{
+       switch (ah->type) {
+       case MTHCA_AH_ON_HCA:
+               mthca_free(&dev->av_table.alloc,
+                          (ah->avdma - dev->av_table.ddr_av_base) /
+                          MTHCA_AV_SIZE);
+               break;
+
+       case MTHCA_AH_PCI_POOL:
+               pci_pool_free(dev->av_table.pool, ah->av, ah->avdma);
+               break;
+
+       case MTHCA_AH_KMALLOC:
+               kfree(ah->av);
+               break;
+       }
+
+       return 0;
+}
+
+int mthca_ah_grh_present(struct mthca_ah *ah)
+{
+       return !!(ah->av->g_slid & 0x80);
+}
+
+int mthca_read_ah(struct mthca_dev *dev, struct mthca_ah *ah,
+                 struct ib_ud_header *header)
+{
+       if (ah->type == MTHCA_AH_ON_HCA)
+               return -EINVAL;
+
+       header->lrh.service_level   = be32_to_cpu(ah->av->sl_tclass_flowlabel) 
>> 28;
+       header->lrh.destination_lid = ah->av->dlid;
+       header->lrh.source_lid      = cpu_to_be16(ah->av->g_slid & 0x7f);
+       if (mthca_ah_grh_present(ah)) {
+               header->grh.traffic_class =
+                       (be32_to_cpu(ah->av->sl_tclass_flowlabel) >> 20) & 0xff;
+               header->grh.flow_label    =
+                       ah->av->sl_tclass_flowlabel & cpu_to_be32(0xfffff);
+               header->grh.hop_limit     = ah->av->hop_limit;
+               ib_get_cached_gid(&dev->ib_dev,
+                                 be32_to_cpu(ah->av->port_pd) >> 24,
+                                 ah->av->gid_index % dev->limits.gid_table_len,
+                                 &header->grh.source_gid, NULL);
+               memcpy(header->grh.destination_gid.raw,
+                      ah->av->dgid, 16);
+       }
+
+       return 0;
+}
+
+int mthca_ah_query(struct ib_ah *ibah, struct ib_ah_attr *attr)
+{
+       struct mthca_ah *ah   = to_mah(ibah);
+       struct mthca_dev *dev = to_mdev(ibah->device);
+
+       /* Only implement for MAD and memfree ah for now. */
+       if (ah->type == MTHCA_AH_ON_HCA)
+               return -ENOSYS;
+
+       memset(attr, 0, sizeof *attr);
+       attr->dlid          = be16_to_cpu(ah->av->dlid);
+       attr->sl            = be32_to_cpu(ah->av->sl_tclass_flowlabel) >> 28;
+       attr->port_num      = be32_to_cpu(ah->av->port_pd) >> 24;
+       attr->static_rate   = mthca_rate_to_ib(dev, ah->av->msg_sr & 0x7,
+                                              attr->port_num);
+       attr->src_path_bits = ah->av->g_slid & 0x7F;
+       attr->ah_flags      = mthca_ah_grh_present(ah) ? IB_AH_GRH : 0;
+
+       if (attr->ah_flags) {
+               attr->grh.traffic_class =
+                       be32_to_cpu(ah->av->sl_tclass_flowlabel) >> 20;
+               attr->grh.flow_label =
+                       be32_to_cpu(ah->av->sl_tclass_flowlabel) & 0xfffff;
+               attr->grh.hop_limit  = ah->av->hop_limit;
+               attr->grh.sgid_index = ah->av->gid_index &
+                                      (dev->limits.gid_table_len - 1);
+               memcpy(attr->grh.dgid.raw, ah->av->dgid, 16);
+       }
+
+       return 0;
+}
+
+int mthca_init_av_table(struct mthca_dev *dev)
+{
+       int err;
+
+       if (mthca_is_memfree(dev))
+               return 0;
+
+       err = mthca_alloc_init(&dev->av_table.alloc,
+                              dev->av_table.num_ddr_avs,
+                              dev->av_table.num_ddr_avs - 1,
+                              0);
+       if (err)
+               return err;
+
+       dev->av_table.pool = pci_pool_create("mthca_av", dev->pdev,
+                                            MTHCA_AV_SIZE,
+                                            MTHCA_AV_SIZE, 0);
+       if (!dev->av_table.pool)
+               goto out_free_alloc;
+
+       if (!(dev->mthca_flags & MTHCA_FLAG_DDR_HIDDEN)) {
+               dev->av_table.av_map = ioremap(pci_resource_start(dev->pdev, 4) 
+
+                                              dev->av_table.ddr_av_base -
+                                              dev->ddr_start,
+                                              dev->av_table.num_ddr_avs *
+                                              MTHCA_AV_SIZE);
+               if (!dev->av_table.av_map)
+                       goto out_free_pool;
+       } else
+               dev->av_table.av_map = NULL;
+
+       return 0;
+
+ out_free_pool:
+       pci_pool_destroy(dev->av_table.pool);
+
+ out_free_alloc:
+       mthca_alloc_cleanup(&dev->av_table.alloc);
+       return -ENOMEM;
+}
+
+void mthca_cleanup_av_table(struct mthca_dev *dev)
+{
+       if (mthca_is_memfree(dev))
+               return;
+
+       if (dev->av_table.av_map)
+               iounmap(dev->av_table.av_map);
+       pci_pool_destroy(dev->av_table.pool);
+       mthca_alloc_cleanup(&dev->av_table.alloc);
+}

Added: head/sys/dev/mthca/mthca_catas.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/mthca/mthca_catas.c    Tue Feb 13 17:04:34 2018        
(r329222)
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2005 Cisco Systems.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define        LINUXKPI_PARAM_PREFIX mthca_
+
+#include <linux/jiffies.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+#include "mthca_dev.h"
+
+#define        MTHCA_CATAS_POLL_INTERVAL       (5 * HZ)
+
+enum {
+       MTHCA_CATAS_TYPE_INTERNAL       = 0,
+       MTHCA_CATAS_TYPE_UPLINK         = 3,
+       MTHCA_CATAS_TYPE_DDR            = 4,
+       MTHCA_CATAS_TYPE_PARITY         = 5,
+};
+
+static DEFINE_SPINLOCK(catas_lock);
+
+static LIST_HEAD(catas_list);
+static struct workqueue_struct *catas_wq;
+static struct work_struct catas_work;
+
+static int catas_reset_disable;
+module_param_named(catas_reset_disable, catas_reset_disable, int, 0644);
+MODULE_PARM_DESC(catas_reset_disable, "disable reset on catastrophic event if 
nonzero");
+
+static void catas_reset(struct work_struct *work)
+{
+       struct mthca_dev *dev, *tmpdev;
+       LIST_HEAD(tlist);
+       int ret;
+
+       mutex_lock(&mthca_device_mutex);
+
+       spin_lock_irq(&catas_lock);
+       list_splice_init(&catas_list, &tlist);
+       spin_unlock_irq(&catas_lock);
+
+       list_for_each_entry_safe(dev, tmpdev, &tlist, catas_err.list) {
+               struct pci_dev *pdev = dev->pdev;
+               ret = __mthca_restart_one(dev->pdev);
+               /* 'dev' now is not valid */
+               if (ret)
+                       printk(KERN_ERR "mthca %s: Reset failed (%d)\n",
+                              pci_name(pdev), ret);
+               else {
+                       struct mthca_dev *d = pci_get_drvdata(pdev);
+                       mthca_dbg(d, "Reset succeeded\n");
+               }
+       }
+
+       mutex_unlock(&mthca_device_mutex);
+}
+
+static void handle_catas(struct mthca_dev *dev)
+{
+       struct ib_event event;
+       unsigned long flags;
+       const char *type;
+       int i;
+
+       event.device = &dev->ib_dev;
+       event.event  = IB_EVENT_DEVICE_FATAL;
+       event.element.port_num = 0;
+       dev->active = false;
+
+       ib_dispatch_event(&event);
+
+       switch (swab32(readl(dev->catas_err.map)) >> 24) {
+       case MTHCA_CATAS_TYPE_INTERNAL:
+               type = "internal error";
+               break;
+       case MTHCA_CATAS_TYPE_UPLINK:
+               type = "uplink bus error";
+               break;
+       case MTHCA_CATAS_TYPE_DDR:
+               type = "DDR data error";
+               break;
+       case MTHCA_CATAS_TYPE_PARITY:
+               type = "internal parity error";
+               break;
+       default:
+               type = "unknown error";
+               break;
+       }
+
+       mthca_err(dev, "Catastrophic error detected: %s\n", type);
+       for (i = 0; i < dev->catas_err.size; ++i)
+               mthca_err(dev, "  buf[%02x]: %08x\n",
+                         i, swab32(readl(dev->catas_err.map + i)));
+
+       if (catas_reset_disable)
+               return;
+
+       spin_lock_irqsave(&catas_lock, flags);
+       list_add(&dev->catas_err.list, &catas_list);
+       queue_work(catas_wq, &catas_work);
+       spin_unlock_irqrestore(&catas_lock, flags);
+}
+
+static void poll_catas(unsigned long dev_ptr)
+{
+       struct mthca_dev *dev = (struct mthca_dev *) dev_ptr;
+       int i;
+
+       for (i = 0; i < dev->catas_err.size; ++i)
+               if (readl(dev->catas_err.map + i)) {
+                       handle_catas(dev);
+                       return;
+               }
+
+       mod_timer(&dev->catas_err.timer,
+                 round_jiffies(jiffies + MTHCA_CATAS_POLL_INTERVAL));
+}
+
+void mthca_start_catas_poll(struct mthca_dev *dev)
+{
+       phys_addr_t addr;
+
+       init_timer(&dev->catas_err.timer);
+       dev->catas_err.map  = NULL;
+
+       addr = pci_resource_start(dev->pdev, 0) +
+               ((pci_resource_len(dev->pdev, 0) - 1) &
+                dev->catas_err.addr);
+
+       dev->catas_err.map = ioremap(addr, dev->catas_err.size * 4);
+       if (!dev->catas_err.map) {
+               mthca_warn(dev, "couldn't map catastrophic error region "
+                          "at 0x%llx/0x%x\n", (unsigned long long) addr,
+                          dev->catas_err.size * 4);
+               return;
+       }
+
+       dev->catas_err.timer.data     = (unsigned long) dev;
+       dev->catas_err.timer.function = poll_catas;
+       dev->catas_err.timer.expires  = jiffies + MTHCA_CATAS_POLL_INTERVAL;
+       INIT_LIST_HEAD(&dev->catas_err.list);
+       add_timer(&dev->catas_err.timer);
+}
+
+void mthca_stop_catas_poll(struct mthca_dev *dev)
+{
+       del_timer_sync(&dev->catas_err.timer);
+
+       if (dev->catas_err.map)
+               iounmap(dev->catas_err.map);
+
+       spin_lock_irq(&catas_lock);
+       list_del(&dev->catas_err.list);
+       spin_unlock_irq(&catas_lock);
+}
+
+int __init mthca_catas_init(void)
+{
+       INIT_WORK(&catas_work, catas_reset);
+
+       catas_wq = alloc_ordered_workqueue("mthca_catas", WQ_MEM_RECLAIM);
+       if (!catas_wq)
+               return -ENOMEM;
+
+       return 0;
+}
+
+void mthca_catas_cleanup(void)
+{
+       destroy_workqueue(catas_wq);
+}

Added: head/sys/dev/mthca/mthca_cmd.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/mthca/mthca_cmd.c      Tue Feb 13 17:04:34 2018        
(r329222)
@@ -0,0 +1,1968 @@
+/*
+ * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
+ * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2005, 2006 Cisco Systems.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#define        LINUXKPI_PARAM_PREFIX mthca_
+
+#include <linux/completion.h>
+#include <linux/pci.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/page.h>
+#include <asm/io.h>
+#include <rdma/ib_mad.h>
+
+#include "mthca_dev.h"

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-head@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"

Reply via email to