Patched in Tegra support.

184 files changed, 3962 insertions, 30051 deletions

diff --git a/drivers/infiniband/Kconfig b/drivers/infiniband/Kconfig
index a0f29c1d03b..0f9a84c1046 100644
--- a/drivers/infiniband/Kconfig
+++ b/drivers/infiniband/Kconfig
@@ -51,12 +51,10 @@ source "drivers/infiniband/hw/cxgb3/Kconfig"
 source "drivers/infiniband/hw/cxgb4/Kconfig"
 source "drivers/infiniband/hw/mlx4/Kconfig"
 source "drivers/infiniband/hw/nes/Kconfig"
-source "drivers/infiniband/hw/ocrdma/Kconfig"
 
 source "drivers/infiniband/ulp/ipoib/Kconfig"
 
 source "drivers/infiniband/ulp/srp/Kconfig"
-source "drivers/infiniband/ulp/srpt/Kconfig"
 
 source "drivers/infiniband/ulp/iser/Kconfig"
 
diff --git a/drivers/infiniband/Makefile b/drivers/infiniband/Makefile
index bf846a14b9d..9cc7a47d3e6 100644
--- a/drivers/infiniband/Makefile
+++ b/drivers/infiniband/Makefile
@@ -8,8 +8,6 @@ obj-$(CONFIG_INFINIBAND_CXGB3)		+= hw/cxgb3/
 obj-$(CONFIG_INFINIBAND_CXGB4)          += hw/cxgb4/
 obj-$(CONFIG_MLX4_INFINIBAND)           += hw/mlx4/
 obj-$(CONFIG_INFINIBAND_NES)            += hw/nes/
-obj-$(CONFIG_INFINIBAND_OCRDMA)         += hw/ocrdma/
 obj-$(CONFIG_INFINIBAND_IPOIB)          += ulp/ipoib/
 obj-$(CONFIG_INFINIBAND_SRP)            += ulp/srp/
-obj-$(CONFIG_INFINIBAND_SRPT)           += ulp/srpt/
 obj-$(CONFIG_INFINIBAND_ISER)           += ulp/iser/
diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c
index eaec8d7a3b7..f2a84c6f854 100644
--- a/drivers/infiniband/core/addr.c
+++ b/drivers/infiniband/core/addr.c
@@ -37,7 +37,6 @@
 #include <linux/inetdevice.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
-#include <linux/module.h>
 #include <net/arp.h>
 #include <net/neighbour.h>
 #include <net/route.h>
@@ -129,7 +128,7 @@ int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
                 dev_put(dev);
                 break;
 
-#if IS_ENABLED(CONFIG_IPV6)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         case AF_INET6:
                 rcu_read_lock();
                 for_each_netdev_rcu(&init_net, dev) {
@@ -152,11 +151,13 @@ static void set_timeout(unsigned long time)
 {
         unsigned long delay;
 
+        cancel_delayed_work(&work);
+
         delay = time - jiffies;
         if ((long)delay <= 0)
                 delay = 1;
 
-        mod_delayed_work(addr_wq, &work, delay);
+        queue_delayed_work(addr_wq, &work, delay);
 }
 
 static void queue_req(struct addr_req *req)
@@ -176,29 +177,6 @@ static void queue_req(struct addr_req *req)
         mutex_unlock(&lock);
 }
 
-static int dst_fetch_ha(struct dst_entry *dst, struct rdma_dev_addr *dev_addr, void *daddr)
-{
-        struct neighbour *n;
-        int ret;
-
-        n = dst_neigh_lookup(dst, daddr);
-
-        rcu_read_lock();
-        if (!n || !(n->nud_state & NUD_VALID)) {
-                if (n)
-                        neigh_event_send(n, NULL);
-                ret = -ENODATA;
-        } else {
-                ret = rdma_copy_addr(dev_addr, dst->dev, n->ha);
-        }
-        rcu_read_unlock();
-
-        if (n)
-                neigh_release(n);
-
-        return ret;
-}
-
 static int addr4_resolve(struct sockaddr_in *src_in,
                          struct sockaddr_in *dst_in,
                          struct rdma_dev_addr *addr)
@@ -206,6 +184,7 @@ static int addr4_resolve(struct sockaddr_in *src_in,
         __be32 src_ip = src_in->sin_addr.s_addr;
         __be32 dst_ip = dst_in->sin_addr.s_addr;
         struct rtable *rt;
+        struct neighbour *neigh;
         struct flowi4 fl4;
         int ret;
 
@@ -234,25 +213,39 @@ static int addr4_resolve(struct sockaddr_in *src_in,
                 goto put;
         }
 
-        ret = dst_fetch_ha(&rt->dst, addr, &fl4.daddr);
+        neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->dst.dev);
+        if (!neigh || !(neigh->nud_state & NUD_VALID)) {
+                rcu_read_lock();
+                neigh_event_send(dst_get_neighbour(&rt->dst), NULL);
+                rcu_read_unlock();
+                ret = -ENODATA;
+                if (neigh)
+                        goto release;
+                goto put;
+        }
+
+        ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
+release:
+        neigh_release(neigh);
 put:
         ip_rt_put(rt);
 out:
         return ret;
 }
 
-#if IS_ENABLED(CONFIG_IPV6)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 static int addr6_resolve(struct sockaddr_in6 *src_in,
                          struct sockaddr_in6 *dst_in,
                          struct rdma_dev_addr *addr)
 {
         struct flowi6 fl6;
+        struct neighbour *neigh;
         struct dst_entry *dst;
         int ret;
 
         memset(&fl6, 0, sizeof fl6);
-        fl6.daddr = dst_in->sin6_addr;
-        fl6.saddr = src_in->sin6_addr;
+        ipv6_addr_copy(&fl6.daddr, &dst_in->sin6_addr);
+        ipv6_addr_copy(&fl6.saddr, &src_in->sin6_addr);
         fl6.flowi6_oif = addr->bound_dev_if;
 
         dst = ip6_route_output(&init_net, NULL, &fl6);
@@ -266,7 +259,7 @@ static int addr6_resolve(struct sockaddr_in6 *src_in,
                         goto put;
 
                 src_in->sin6_family = AF_INET6;
-                src_in->sin6_addr = fl6.saddr;
+                ipv6_addr_copy(&src_in->sin6_addr, &fl6.saddr);
         }
 
         if (dst->dev->flags & IFF_LOOPBACK) {
@@ -282,7 +275,16 @@ static int addr6_resolve(struct sockaddr_in6 *src_in,
                 goto put;
         }
 
-        ret = dst_fetch_ha(dst, addr, &fl6.daddr);
+        rcu_read_lock();
+        neigh = dst_get_neighbour(dst);
+        if (!neigh || !(neigh->nud_state & NUD_VALID)) {
+                if (neigh)
+                        neigh_event_send(neigh, NULL);
+                ret = -ENODATA;
+        } else {
+                ret = rdma_copy_addr(addr, dst->dev, neigh->ha);
+        }
+        rcu_read_unlock();
 put:
         dst_release(dst);
         return ret;
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index 80f6cf2449f..9353992f9ee 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -167,7 +167,6 @@ int ib_find_cached_pkey(struct ib_device *device,
         unsigned long flags;
         int i;
         int ret = -ENOENT;
-        int partial_ix = -1;
 
         if (port_num < start_port(device) || port_num > end_port(device))
                 return -EINVAL;
@@ -180,46 +179,6 @@ int ib_find_cached_pkey(struct ib_device *device,
 
         for (i = 0; i < cache->table_len; ++i)
                 if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
-                        if (cache->table[i] & 0x8000) {
-                                *index = i;
-                                ret = 0;
-                                break;
-                        } else
-                                partial_ix = i;
-                }
-
-        if (ret && partial_ix >= 0) {
-                *index = partial_ix;
-                ret = 0;
-        }
-
-        read_unlock_irqrestore(&device->cache.lock, flags);
-
-        return ret;
-}
-EXPORT_SYMBOL(ib_find_cached_pkey);
-
-int ib_find_exact_cached_pkey(struct ib_device *device,
-                              u8                port_num,
-                              u16               pkey,
-                              u16              *index)
-{
-        struct ib_pkey_cache *cache;
-        unsigned long flags;
-        int i;
-        int ret = -ENOENT;
-
-        if (port_num < start_port(device) || port_num > end_port(device))
-                return -EINVAL;
-
-        read_lock_irqsave(&device->cache.lock, flags);
-
-        cache = device->cache.pkey_cache[port_num - start_port(device)];
-
-        *index = -1;
-
-        for (i = 0; i < cache->table_len; ++i)
-                if (cache->table[i] == pkey) {
                         *index = i;
                         ret = 0;
                         break;
@@ -229,7 +188,7 @@ int ib_find_exact_cached_pkey(struct ib_device *device,
 
         return ret;
 }
-EXPORT_SYMBOL(ib_find_exact_cached_pkey);
+EXPORT_SYMBOL(ib_find_cached_pkey);
 
 int ib_get_cached_lmc(struct ib_device *device,
                       u8                port_num,
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index 394fea2ba1b..fc0f2bd9ca8 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -36,7 +36,6 @@
 #include <linux/completion.h>
 #include <linux/dma-mapping.h>
 #include <linux/device.h>
-#include <linux/module.h>
 #include <linux/err.h>
 #include <linux/idr.h>
 #include <linux/interrupt.h>
@@ -390,7 +389,7 @@ static int cm_alloc_id(struct cm_id_private *cm_id_priv)
                 ret = idr_get_new_above(&cm.local_id_table, cm_id_priv,
                                         next_id, &id);
                 if (!ret)
-                        next_id = ((unsigned) id + 1) & MAX_IDR_MASK;
+                        next_id = ((unsigned) id + 1) & MAX_ID_MASK;
                 spin_unlock_irqrestore(&cm.lock, flags);
         } while( (ret == -EAGAIN) && idr_pre_get(&cm.local_id_table, GFP_KERNEL) );
 
@@ -890,8 +889,6 @@ retest:
                 break;
         case IB_CM_ESTABLISHED:
                 spin_unlock_irq(&cm_id_priv->lock);
-                if (cm_id_priv->qp_type == IB_QPT_XRC_TGT)
-                        break;
                 ib_send_cm_dreq(cm_id, NULL, 0);
                 goto retest;
         case IB_CM_DREQ_SENT:
@@ -1011,6 +1008,7 @@ static void cm_format_req(struct cm_req_msg *req_msg,
         req_msg->service_id = param->service_id;
         req_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
         cm_req_set_local_qpn(req_msg, cpu_to_be32(param->qp_num));
+        cm_req_set_resp_res(req_msg, param->responder_resources);
         cm_req_set_init_depth(req_msg, param->initiator_depth);
         cm_req_set_remote_resp_timeout(req_msg,
                                        param->remote_cm_response_timeout);
@@ -1019,16 +1017,12 @@ static void cm_format_req(struct cm_req_msg *req_msg,
         cm_req_set_starting_psn(req_msg, cpu_to_be32(param->starting_psn));
         cm_req_set_local_resp_timeout(req_msg,
                                       param->local_cm_response_timeout);
+        cm_req_set_retry_count(req_msg, param->retry_count);
         req_msg->pkey = param->primary_path->pkey;
         cm_req_set_path_mtu(req_msg, param->primary_path->mtu);
+        cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);
         cm_req_set_max_cm_retries(req_msg, param->max_cm_retries);
-
-        if (param->qp_type != IB_QPT_XRC_INI) {
-                cm_req_set_resp_res(req_msg, param->responder_resources);
-                cm_req_set_retry_count(req_msg, param->retry_count);
-                cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);
-                cm_req_set_srq(req_msg, param->srq);
-        }
+        cm_req_set_srq(req_msg, param->srq);
 
         if (pri_path->hop_limit <= 1) {
                 req_msg->primary_local_lid = pri_path->slid;
@@ -1086,8 +1080,7 @@ static int cm_validate_req_param(struct ib_cm_req_param *param)
         if (!param->primary_path)
                 return -EINVAL;
 
-        if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC &&
-            param->qp_type != IB_QPT_XRC_INI)
+        if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC)
                 return -EINVAL;
 
         if (param->private_data &&
@@ -1608,24 +1601,18 @@ static void cm_format_rep(struct cm_rep_msg *rep_msg,
         cm_format_mad_hdr(&rep_msg->hdr, CM_REP_ATTR_ID, cm_id_priv->tid);
         rep_msg->local_comm_id = cm_id_priv->id.local_id;
         rep_msg->remote_comm_id = cm_id_priv->id.remote_id;
+        cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));
         cm_rep_set_starting_psn(rep_msg, cpu_to_be32(param->starting_psn));
         rep_msg->resp_resources = param->responder_resources;
+        rep_msg->initiator_depth = param->initiator_depth;
         cm_rep_set_target_ack_delay(rep_msg,
                                     cm_id_priv->av.port->cm_dev->ack_delay);
         cm_rep_set_failover(rep_msg, param->failover_accepted);
+        cm_rep_set_flow_ctrl(rep_msg, param->flow_control);
         cm_rep_set_rnr_retry_count(rep_msg, param->rnr_retry_count);
+        cm_rep_set_srq(rep_msg, param->srq);
         rep_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
 
-        if (cm_id_priv->qp_type != IB_QPT_XRC_TGT) {
-                rep_msg->initiator_depth = param->initiator_depth;
-                cm_rep_set_flow_ctrl(rep_msg, param->flow_control);
-                cm_rep_set_srq(rep_msg, param->srq);
-                cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));
-        } else {
-                cm_rep_set_srq(rep_msg, 1);
-                cm_rep_set_local_eecn(rep_msg, cpu_to_be32(param->qp_num));
-        }
-
         if (param->private_data && param->private_data_len)
                 memcpy(rep_msg->private_data, param->private_data,
                        param->private_data_len);
@@ -1673,7 +1660,7 @@ int ib_send_cm_rep(struct ib_cm_id *cm_id,
         cm_id_priv->initiator_depth = param->initiator_depth;
         cm_id_priv->responder_resources = param->responder_resources;
         cm_id_priv->rq_psn = cm_rep_get_starting_psn(rep_msg);
-        cm_id_priv->local_qpn = cpu_to_be32(param->qp_num & 0xFFFFFF);
+        cm_id_priv->local_qpn = cm_rep_get_local_qpn(rep_msg);
 
 out:    spin_unlock_irqrestore(&cm_id_priv->lock, flags);
         return ret;
@@ -1744,7 +1731,7 @@ error:	spin_unlock_irqrestore(&cm_id_priv->lock, flags);
 }
 EXPORT_SYMBOL(ib_send_cm_rtu);
 
-static void cm_format_rep_event(struct cm_work *work, enum ib_qp_type qp_type)
+static void cm_format_rep_event(struct cm_work *work)
 {
         struct cm_rep_msg *rep_msg;
         struct ib_cm_rep_event_param *param;
@@ -1753,7 +1740,7 @@ static void cm_format_rep_event(struct cm_work *work, enum ib_qp_type qp_type)
         param = &work->cm_event.param.rep_rcvd;
         param->remote_ca_guid = rep_msg->local_ca_guid;
         param->remote_qkey = be32_to_cpu(rep_msg->local_qkey);
-        param->remote_qpn = be32_to_cpu(cm_rep_get_qpn(rep_msg, qp_type));
+        param->remote_qpn = be32_to_cpu(cm_rep_get_local_qpn(rep_msg));
         param->starting_psn = be32_to_cpu(cm_rep_get_starting_psn(rep_msg));
         param->responder_resources = rep_msg->initiator_depth;
         param->initiator_depth = rep_msg->resp_resources;
@@ -1821,7 +1808,7 @@ static int cm_rep_handler(struct cm_work *work)
                 return -EINVAL;
         }
 
-        cm_format_rep_event(work, cm_id_priv->qp_type);
+        cm_format_rep_event(work);
 
         spin_lock_irq(&cm_id_priv->lock);
         switch (cm_id_priv->id.state) {
@@ -1836,7 +1823,7 @@ static int cm_rep_handler(struct cm_work *work)
 
         cm_id_priv->timewait_info->work.remote_id = rep_msg->local_comm_id;
         cm_id_priv->timewait_info->remote_ca_guid = rep_msg->local_ca_guid;
-        cm_id_priv->timewait_info->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
+        cm_id_priv->timewait_info->remote_qpn = cm_rep_get_local_qpn(rep_msg);
 
         spin_lock(&cm.lock);
         /* Check for duplicate REP. */
@@ -1863,7 +1850,7 @@ static int cm_rep_handler(struct cm_work *work)
 
         cm_id_priv->id.state = IB_CM_REP_RCVD;
         cm_id_priv->id.remote_id = rep_msg->local_comm_id;
-        cm_id_priv->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
+        cm_id_priv->remote_qpn = cm_rep_get_local_qpn(rep_msg);
         cm_id_priv->initiator_depth = rep_msg->resp_resources;
         cm_id_priv->responder_resources = rep_msg->initiator_depth;
         cm_id_priv->sq_psn = cm_rep_get_starting_psn(rep_msg);
@@ -3505,8 +3492,7 @@ static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
                 qp_attr->path_mtu = cm_id_priv->path_mtu;
                 qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);
                 qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);
-                if (cm_id_priv->qp_type == IB_QPT_RC ||
-                    cm_id_priv->qp_type == IB_QPT_XRC_TGT) {
+                if (cm_id_priv->qp_type == IB_QPT_RC) {
                         *qp_attr_mask |= IB_QP_MAX_DEST_RD_ATOMIC |
                                          IB_QP_MIN_RNR_TIMER;
                         qp_attr->max_dest_rd_atomic =
@@ -3551,21 +3537,15 @@ static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv,
                 if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT) {
                         *qp_attr_mask = IB_QP_STATE | IB_QP_SQ_PSN;
                         qp_attr->sq_psn = be32_to_cpu(cm_id_priv->sq_psn);
-                        switch (cm_id_priv->qp_type) {
-                        case IB_QPT_RC:
-                        case IB_QPT_XRC_INI:
-                                *qp_attr_mask |= IB_QP_RETRY_CNT | IB_QP_RNR_RETRY |
+                        if (cm_id_priv->qp_type == IB_QPT_RC) {
+                                *qp_attr_mask |= IB_QP_TIMEOUT | IB_QP_RETRY_CNT |
+                                                 IB_QP_RNR_RETRY |
                                                  IB_QP_MAX_QP_RD_ATOMIC;
+                                qp_attr->timeout = cm_id_priv->av.timeout;
                                 qp_attr->retry_cnt = cm_id_priv->retry_count;
                                 qp_attr->rnr_retry = cm_id_priv->rnr_retry_count;
-                                qp_attr->max_rd_atomic = cm_id_priv->initiator_depth;
-                                /* fall through */
-                        case IB_QPT_XRC_TGT:
-                                *qp_attr_mask |= IB_QP_TIMEOUT;
-                                qp_attr->timeout = cm_id_priv->av.timeout;
-                                break;
-                        default:
-                                break;
+                                qp_attr->max_rd_atomic =
+                                        cm_id_priv->initiator_depth;
                         }
                         if (cm_id_priv->alt_av.ah_attr.dlid) {
                                 *qp_attr_mask |= IB_QP_PATH_MIG_STATE;
@@ -3659,7 +3639,7 @@ static struct kobj_type cm_port_obj_type = {
         .release = cm_release_port_obj
 };
 
-static char *cm_devnode(struct device *dev, umode_t *mode)
+static char *cm_devnode(struct device *dev, mode_t *mode)
 {
         if (mode)
                 *mode = 0666;
@@ -3848,28 +3828,24 @@ static int __init ib_cm_init(void)
         INIT_LIST_HEAD(&cm.timewait_list);
 
         ret = class_register(&cm_class);
-        if (ret) {
-                ret = -ENOMEM;
-                goto error1;
-        }
+        if (ret)
+                return -ENOMEM;
 
         cm.wq = create_workqueue("ib_cm");
         if (!cm.wq) {
                 ret = -ENOMEM;
-                goto error2;
+                goto error1;
         }
 
         ret = ib_register_client(&cm_client);
         if (ret)
-                goto error3;
+                goto error2;
 
         return 0;
-error3:
-        destroy_workqueue(cm.wq);
 error2:
-        class_unregister(&cm_class);
+        destroy_workqueue(cm.wq);
 error1:
-        idr_destroy(&cm.local_id_table);
+        class_unregister(&cm_class);
         return ret;
 }
 
diff --git a/drivers/infiniband/core/cm_msgs.h b/drivers/infiniband/core/cm_msgs.h
index be068f47e47..7e63c08f697 100644
--- a/drivers/infiniband/core/cm_msgs.h
+++ b/drivers/infiniband/core/cm_msgs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2004, 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2004 Intel Corporation.  All rights reserved.
  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
  *
@@ -44,6 +44,18 @@
 
 #define IB_CM_CLASS_VERSION     2 /* IB specification 1.2 */
 
+#define CM_REQ_ATTR_ID          cpu_to_be16(0x0010)
+#define CM_MRA_ATTR_ID          cpu_to_be16(0x0011)
+#define CM_REJ_ATTR_ID          cpu_to_be16(0x0012)
+#define CM_REP_ATTR_ID          cpu_to_be16(0x0013)
+#define CM_RTU_ATTR_ID          cpu_to_be16(0x0014)
+#define CM_DREQ_ATTR_ID         cpu_to_be16(0x0015)
+#define CM_DREP_ATTR_ID         cpu_to_be16(0x0016)
+#define CM_SIDR_REQ_ATTR_ID     cpu_to_be16(0x0017)
+#define CM_SIDR_REP_ATTR_ID     cpu_to_be16(0x0018)
+#define CM_LAP_ATTR_ID          cpu_to_be16(0x0019)
+#define CM_APR_ATTR_ID          cpu_to_be16(0x001A)
+
 enum cm_msg_sequence {
         CM_MSG_SEQUENCE_REQ,
         CM_MSG_SEQUENCE_LAP,
@@ -74,7 +86,7 @@ struct cm_req_msg {
         __be16 pkey;
         /* path MTU:4, RDC exists:1, RNR retry count:3. */
         u8 offset50;
-        /* max CM Retries:4, SRQ:1, extended transport type:3 */
+        /* max CM Retries:4, SRQ:1, rsvd:3 */
         u8 offset51;
 
         __be16 primary_local_lid;
@@ -163,11 +175,6 @@ static inline enum ib_qp_type cm_req_get_qp_type(struct cm_req_msg *req_msg)
         switch(transport_type) {
         case 0: return IB_QPT_RC;
         case 1: return IB_QPT_UC;
-        case 3:
-                switch (req_msg->offset51 & 0x7) {
-                case 1: return IB_QPT_XRC_TGT;
-                default: return 0;
-                }
         default: return 0;
         }
 }
@@ -181,12 +188,6 @@ static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg,
                                                   req_msg->offset40) &
                                                    0xFFFFFFF9) | 0x2);
                 break;
-        case IB_QPT_XRC_INI:
-                req_msg->offset40 = cpu_to_be32((be32_to_cpu(
-                                                 req_msg->offset40) &
-                                                   0xFFFFFFF9) | 0x6);
-                req_msg->offset51 = (req_msg->offset51 & 0xF8) | 1;
-                break;
         default:
                 req_msg->offset40 = cpu_to_be32(be32_to_cpu(
                                                  req_msg->offset40) &
@@ -526,23 +527,6 @@ static inline void cm_rep_set_local_qpn(struct cm_rep_msg *rep_msg, __be32 qpn)
                             (be32_to_cpu(rep_msg->offset12) & 0x000000FF));
 }
 
-static inline __be32 cm_rep_get_local_eecn(struct cm_rep_msg *rep_msg)
-{
-        return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8);
-}
-
-static inline void cm_rep_set_local_eecn(struct cm_rep_msg *rep_msg, __be32 eecn)
-{
-        rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) |
-                            (be32_to_cpu(rep_msg->offset16) & 0x000000FF));
-}
-
-static inline __be32 cm_rep_get_qpn(struct cm_rep_msg *rep_msg, enum ib_qp_type qp_type)
-{
-        return (qp_type == IB_QPT_XRC_INI) ?
-                cm_rep_get_local_eecn(rep_msg) : cm_rep_get_local_qpn(rep_msg);
-}
-
 static inline __be32 cm_rep_get_starting_psn(struct cm_rep_msg *rep_msg)
 {
         return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8);
@@ -787,7 +771,6 @@ struct cm_apr_msg {
 
         u8 info_length;
         u8 ap_status;
-        __be16 rsvd;
         u8 info[IB_CM_APR_INFO_LENGTH];
 
         u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE];
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index d789eea3216..ca4c5dcd713 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -41,8 +41,6 @@
 #include <linux/idr.h>
 #include <linux/inetdevice.h>
 #include <linux/slab.h>
-#include <linux/module.h>
-#include <net/route.h>
 
 #include <net/tcp.h>
 #include <net/ipv6.h>
@@ -83,7 +81,6 @@ static DEFINE_IDR(sdp_ps);
 static DEFINE_IDR(tcp_ps);
 static DEFINE_IDR(udp_ps);
 static DEFINE_IDR(ipoib_ps);
-static DEFINE_IDR(ib_ps);
 
 struct cma_device {
         struct list_head        list;
@@ -99,10 +96,6 @@ struct rdma_bind_list {
         unsigned short          port;
 };
 
-enum {
-        CMA_OPTION_AFONLY,
-};
-
 /*
  * Device removal can occur at anytime, so we need extra handling to
  * serialize notifying the user of device removal with other callbacks.
@@ -141,11 +134,9 @@ struct rdma_id_private {
         u32                     qkey;
         u32                     qp_num;
         pid_t                   owner;
-        u32                     options;
         u8                      srq;
         u8                      tos;
         u8                      reuseaddr;
-        u8                      afonly;
 };
 
 struct cma_multicast {
@@ -345,17 +336,17 @@ static int find_gid_port(struct ib_device *device, union ib_gid *gid, u8 port_nu
 
         err = ib_query_port(device, port_num, &props);
         if (err)
-                return err;
+                return 1;
 
         for (i = 0; i < props.gid_tbl_len; ++i) {
                 err = ib_query_gid(device, port_num, i, &tmp);
                 if (err)
-                        return err;
+                        return 1;
                 if (!memcmp(&tmp, gid, sizeof tmp))
                         return 0;
         }
 
-        return -EADDRNOTAVAIL;
+        return -EAGAIN;
 }
 
 static int cma_acquire_dev(struct rdma_id_private *id_priv)
@@ -388,7 +379,8 @@ static int cma_acquire_dev(struct rdma_id_private *id_priv)
                                 if (!ret) {
                                         id_priv->id.port_num = port;
                                         goto out;
-                                }
+                                } else if (ret == 1)
+                                        break;
                         }
                 }
         }
@@ -1116,7 +1108,7 @@ static struct rdma_id_private *cma_new_conn_id(struct rdma_cm_id *listen_id,
         if (cma_any_addr((struct sockaddr *) &rt->addr.src_addr)) {
                 rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;
                 rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
-                ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
+                ib_addr_set_pkey(&rt->addr.dev_addr, rt->path_rec[0].pkey);
         } else {
                 ret = rdma_translate_ip((struct sockaddr *) &rt->addr.src_addr,
                                         &rt->addr.dev_addr);
@@ -1187,15 +1179,6 @@ static void cma_set_req_event_data(struct rdma_cm_event *event,
         event->param.conn.qp_num = req_data->remote_qpn;
 }
 
-static int cma_check_req_qp_type(struct rdma_cm_id *id, struct ib_cm_event *ib_event)
-{
-        return (((ib_event->event == IB_CM_REQ_RECEIVED) &&
-                 (ib_event->param.req_rcvd.qp_type == id->qp_type)) ||
-                ((ib_event->event == IB_CM_SIDR_REQ_RECEIVED) &&
-                 (id->qp_type == IB_QPT_UD)) ||
-                (!id->qp_type));
-}
-
 static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
 {
         struct rdma_id_private *listen_id, *conn_id;
@@ -1203,16 +1186,13 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
         int offset, ret;
 
         listen_id = cm_id->context;
-        if (!cma_check_req_qp_type(&listen_id->id, ib_event))
-                return -EINVAL;
-
         if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))
                 return -ECONNABORTED;
 
         memset(&event, 0, sizeof event);
         offset = cma_user_data_offset(listen_id->id.ps);
         event.event = RDMA_CM_EVENT_CONNECT_REQUEST;
-        if (ib_event->event == IB_CM_SIDR_REQ_RECEIVED) {
+        if (listen_id->id.qp_type == IB_QPT_UD) {
                 conn_id = cma_new_udp_id(&listen_id->id, ib_event);
                 event.param.ud.private_data = ib_event->private_data + offset;
                 event.param.ud.private_data_len =
@@ -1224,13 +1204,13 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
         }
         if (!conn_id) {
                 ret = -ENOMEM;
-                goto err1;
+                goto out;
         }
 
         mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);
         ret = cma_acquire_dev(conn_id);
         if (ret)
-                goto err2;
+                goto release_conn_id;
 
         conn_id->cm_id.ib = cm_id;
         cm_id->context = conn_id;
@@ -1242,33 +1222,31 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
          */
         atomic_inc(&conn_id->refcount);
         ret = conn_id->id.event_handler(&conn_id->id, &event);
-        if (ret)
-                goto err3;
-
-        /*
-         * Acquire mutex to prevent user executing rdma_destroy_id()
-         * while we're accessing the cm_id.
-         */
-        mutex_lock(&lock);
-        if (cma_comp(conn_id, RDMA_CM_CONNECT) && (conn_id->id.qp_type != IB_QPT_UD))
-                ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0);
-        mutex_unlock(&lock);
-        mutex_unlock(&conn_id->handler_mutex);
-        mutex_unlock(&listen_id->handler_mutex);
+        if (!ret) {
+                /*
+                 * Acquire mutex to prevent user executing rdma_destroy_id()
+                 * while we're accessing the cm_id.
+                 */
+                mutex_lock(&lock);
+                if (cma_comp(conn_id, RDMA_CM_CONNECT) && (conn_id->id.qp_type != IB_QPT_UD))
+                        ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0);
+                mutex_unlock(&lock);
+                mutex_unlock(&conn_id->handler_mutex);
+                cma_deref_id(conn_id);
+                goto out;
+        }
         cma_deref_id(conn_id);
-        return 0;
 
-err3:
-        cma_deref_id(conn_id);
         /* Destroy the CM ID by returning a non-zero value. */
         conn_id->cm_id.ib = NULL;
-err2:
+
+release_conn_id:
         cma_exch(conn_id, RDMA_CM_DESTROYING);
         mutex_unlock(&conn_id->handler_mutex);
-err1:
+        rdma_destroy_id(&conn_id->id);
+
+out:
         mutex_unlock(&listen_id->handler_mutex);
-        if (conn_id)
-                rdma_destroy_id(&conn_id->id);
         return ret;
 }
 
@@ -1302,10 +1280,8 @@ static void cma_set_compare_data(enum rdma_port_space ps, struct sockaddr *addr,
                 } else {
                         cma_set_ip_ver(cma_data, 4);
                         cma_set_ip_ver(cma_mask, 0xF);
-                        if (!cma_any_addr(addr)) {
-                                cma_data->dst_addr.ip4.addr = ip4_addr;
-                                cma_mask->dst_addr.ip4.addr = htonl(~0);
-                        }
+                        cma_data->dst_addr.ip4.addr = ip4_addr;
+                        cma_mask->dst_addr.ip4.addr = htonl(~0);
                 }
                 break;
         case AF_INET6:
@@ -1319,11 +1295,9 @@ static void cma_set_compare_data(enum rdma_port_space ps, struct sockaddr *addr,
                 } else {
                         cma_set_ip_ver(cma_data, 6);
                         cma_set_ip_ver(cma_mask, 0xF);
-                        if (!cma_any_addr(addr)) {
-                                cma_data->dst_addr.ip6 = ip6_addr;
-                                memset(&cma_mask->dst_addr.ip6, 0xFF,
-                                       sizeof cma_mask->dst_addr.ip6);
-                        }
+                        cma_data->dst_addr.ip6 = ip6_addr;
+                        memset(&cma_mask->dst_addr.ip6, 0xFF,
+                               sizeof cma_mask->dst_addr.ip6);
                 }
                 break;
         default:
@@ -1354,8 +1328,6 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
                 switch (iw_event->status) {
                 case 0:
                         event.event = RDMA_CM_EVENT_ESTABLISHED;
-                        event.param.conn.initiator_depth = iw_event->ird;
-                        event.param.conn.responder_resources = iw_event->ord;
                         break;
                 case -ECONNRESET:
                 case -ECONNREFUSED:
@@ -1371,8 +1343,6 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
                 break;
         case IW_CM_EVENT_ESTABLISHED:
                 event.event = RDMA_CM_EVENT_ESTABLISHED;
-                event.param.conn.initiator_depth = iw_event->ird;
-                event.param.conn.responder_resources = iw_event->ord;
                 break;
         default:
                 BUG_ON(1);
@@ -1463,8 +1433,8 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
         event.event = RDMA_CM_EVENT_CONNECT_REQUEST;
         event.param.conn.private_data = iw_event->private_data;
         event.param.conn.private_data_len = iw_event->private_data_len;
-        event.param.conn.initiator_depth = iw_event->ird;
-        event.param.conn.responder_resources = iw_event->ord;
+        event.param.conn.initiator_depth = attr.max_qp_init_rd_atom;
+        event.param.conn.responder_resources = attr.max_qp_rd_atom;
 
         /*
          * Protect against the user destroying conn_id from another thread
@@ -1508,7 +1478,7 @@ static int cma_ib_listen(struct rdma_id_private *id_priv)
 
         addr = (struct sockaddr *) &id_priv->id.route.addr.src_addr;
         svc_id = cma_get_service_id(id_priv->id.ps, addr);
-        if (cma_any_addr(addr) && !id_priv->afonly)
+        if (cma_any_addr(addr))
                 ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, NULL);
         else {
                 cma_set_compare_data(id_priv->id.ps, addr, &compare_data);
@@ -1582,7 +1552,6 @@ static void cma_listen_on_dev(struct rdma_id_private *id_priv,
         list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list);
         atomic_inc(&id_priv->refcount);
         dev_id_priv->internal_id = 1;
-        dev_id_priv->afonly = id_priv->afonly;
 
         ret = rdma_listen(id, id_priv->backlog);
         if (ret)
@@ -1839,10 +1808,7 @@ static int cma_resolve_iboe_route(struct rdma_id_private *id_priv)
         route->path_rec->reversible = 1;
         route->path_rec->pkey = cpu_to_be16(0xffff);
         route->path_rec->mtu_selector = IB_SA_EQ;
-        route->path_rec->sl = netdev_get_prio_tc_map(
-                        ndev->priv_flags & IFF_802_1Q_VLAN ?
-                                vlan_dev_real_dev(ndev) : ndev,
-                        rt_tos2priority(id_priv->tos));
+        route->path_rec->sl = id_priv->tos >> 5;
 
         route->path_rec->mtu = iboe_get_mtu(ndev->mtu);
         route->path_rec->rate_selector = IB_SA_EQ;
@@ -2021,11 +1987,11 @@ static int cma_resolve_loopback(struct rdma_id_private *id_priv)
         if (cma_zero_addr(src)) {
                 dst = (struct sockaddr *) &id_priv->id.route.addr.dst_addr;
                 if ((src->sa_family = dst->sa_family) == AF_INET) {
-                        ((struct sockaddr_in *)src)->sin_addr =
-                                ((struct sockaddr_in *)dst)->sin_addr;
+                        ((struct sockaddr_in *) src)->sin_addr.s_addr =
+                                ((struct sockaddr_in *) dst)->sin_addr.s_addr;
                 } else {
-                        ((struct sockaddr_in6 *)src)->sin6_addr =
-                                ((struct sockaddr_in6 *)dst)->sin6_addr;
+                        ipv6_addr_copy(&((struct sockaddr_in6 *) src)->sin6_addr,
+                                       &((struct sockaddr_in6 *) dst)->sin6_addr);
                 }
         }
 
@@ -2108,26 +2074,6 @@ int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse)
 }
 EXPORT_SYMBOL(rdma_set_reuseaddr);
 
-int rdma_set_afonly(struct rdma_cm_id *id, int afonly)
-{
-        struct rdma_id_private *id_priv;
-        unsigned long flags;
-        int ret;
-
-        id_priv = container_of(id, struct rdma_id_private, id);
-        spin_lock_irqsave(&id_priv->lock, flags);
-        if (id_priv->state == RDMA_CM_IDLE || id_priv->state == RDMA_CM_ADDR_BOUND) {
-                id_priv->options |= (1 << CMA_OPTION_AFONLY);
-                id_priv->afonly = afonly;
-                ret = 0;
-        } else {
-                ret = -EINVAL;
-        }
-        spin_unlock_irqrestore(&id_priv->lock, flags);
-        return ret;
-}
-EXPORT_SYMBOL(rdma_set_afonly);
-
 static void cma_bind_port(struct rdma_bind_list *bind_list,
                           struct rdma_id_private *id_priv)
 {
@@ -2217,24 +2163,22 @@ static int cma_check_port(struct rdma_bind_list *bind_list,
         struct hlist_node *node;
 
         addr = (struct sockaddr *) &id_priv->id.route.addr.src_addr;
+        if (cma_any_addr(addr) && !reuseaddr)
+                return -EADDRNOTAVAIL;
+
         hlist_for_each_entry(cur_id, node, &bind_list->owners, node) {
                 if (id_priv == cur_id)
                         continue;
 
-                if ((cur_id->state != RDMA_CM_LISTEN) && reuseaddr &&
-                    cur_id->reuseaddr)
-                        continue;
-
-                cur_addr = (struct sockaddr *) &cur_id->id.route.addr.src_addr;
-                if (id_priv->afonly && cur_id->afonly &&
-                    (addr->sa_family != cur_addr->sa_family))
-                        continue;
-
-                if (cma_any_addr(addr) || cma_any_addr(cur_addr))
-                        return -EADDRNOTAVAIL;
+                if ((cur_id->state == RDMA_CM_LISTEN) ||
+                    !reuseaddr || !cur_id->reuseaddr) {
+                        cur_addr = (struct sockaddr *) &cur_id->id.route.addr.src_addr;
+                        if (cma_any_addr(cur_addr))
+                                return -EADDRNOTAVAIL;
 
-                if (!cma_addr_cmp(addr, cur_addr))
-                        return -EADDRINUSE;
+                        if (!cma_addr_cmp(addr, cur_addr))
+                                return -EADDRINUSE;
+                }
         }
         return 0;
 }
@@ -2290,9 +2234,6 @@ static int cma_get_port(struct rdma_id_private *id_priv)
         case RDMA_PS_IPOIB:
                 ps = &ipoib_ps;
                 break;
-        case RDMA_PS_IB:
-                ps = &ib_ps;
-                break;
         default:
                 return -EPROTONOSUPPORT;
         }
@@ -2310,7 +2251,7 @@ static int cma_get_port(struct rdma_id_private *id_priv)
 static int cma_check_linklocal(struct rdma_dev_addr *dev_addr,
                                struct sockaddr *addr)
 {
-#if IS_ENABLED(CONFIG_IPV6)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
         struct sockaddr_in6 *sin6;
 
         if (addr->sa_family != AF_INET6)
@@ -2403,14 +2344,6 @@ int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
         }
 
         memcpy(&id->route.addr.src_addr, addr, ip_addr_size(addr));
-        if (!(id_priv->options & (1 << CMA_OPTION_AFONLY))) {
-                if (addr->sa_family == AF_INET)
-                        id_priv->afonly = 1;
-#if IS_ENABLED(CONFIG_IPV6)
-                else if (addr->sa_family == AF_INET6)
-                        id_priv->afonly = init_net.ipv6.sysctl.bindv6only;
-#endif
-        }
         ret = cma_get_port(id_priv);
         if (ret)
                 goto err2;
@@ -2559,9 +2492,6 @@ static int cma_resolve_ib_udp(struct rdma_id_private *id_priv,
 
         req.private_data_len = sizeof(struct cma_hdr) +
                                conn_param->private_data_len;
-        if (req.private_data_len < conn_param->private_data_len)
-                return -EINVAL;
-
         req.private_data = kzalloc(req.private_data_len, GFP_ATOMIC);
         if (!req.private_data)
                 return -ENOMEM;
@@ -2611,9 +2541,6 @@ static int cma_connect_ib(struct rdma_id_private *id_priv,
         memset(&req, 0, sizeof req);
         offset = cma_user_data_offset(id_priv->id.ps);
         req.private_data_len = offset + conn_param->private_data_len;
-        if (req.private_data_len < conn_param->private_data_len)
-                return -EINVAL;
-
         private_data = kzalloc(req.private_data_len, GFP_ATOMIC);
         if (!private_data)
                 return -ENOMEM;
@@ -2642,13 +2569,13 @@ static int cma_connect_ib(struct rdma_id_private *id_priv,
         req.service_id = cma_get_service_id(id_priv->id.ps,
                                             (struct sockaddr *) &route->addr.dst_addr);
         req.qp_num = id_priv->qp_num;
-        req.qp_type = id_priv->id.qp_type;
+        req.qp_type = IB_QPT_RC;
         req.starting_psn = id_priv->seq_num;
         req.responder_resources = conn_param->responder_resources;
         req.initiator_depth = conn_param->initiator_depth;
         req.flow_control = conn_param->flow_control;
-        req.retry_count = min_t(u8, 7, conn_param->retry_count);
-        req.rnr_retry_count = min_t(u8, 7, conn_param->rnr_retry_count);
+        req.retry_count = conn_param->retry_count;
+        req.rnr_retry_count = conn_param->rnr_retry_count;
         req.remote_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
         req.local_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
         req.max_cm_retries = CMA_MAX_CM_RETRIES;
@@ -2689,16 +2616,14 @@ static int cma_connect_iw(struct rdma_id_private *id_priv,
         if (ret)
                 goto out;
 
-        if (conn_param) {
-                iw_param.ord = conn_param->initiator_depth;
-                iw_param.ird = conn_param->responder_resources;
-                iw_param.private_data = conn_param->private_data;
-                iw_param.private_data_len = conn_param->private_data_len;
-                iw_param.qpn = id_priv->id.qp ? id_priv->qp_num : conn_param->qp_num;
-        } else {
-                memset(&iw_param, 0, sizeof iw_param);
+        iw_param.ord = conn_param->initiator_depth;
+        iw_param.ird = conn_param->responder_resources;
+        iw_param.private_data = conn_param->private_data;
+        iw_param.private_data_len = conn_param->private_data_len;
+        if (id_priv->id.qp)
                 iw_param.qpn = id_priv->qp_num;
-        }
+        else
+                iw_param.qpn = conn_param->qp_num;
         ret = iw_cm_connect(cm_id, &iw_param);
 out:
         if (ret) {
@@ -2769,7 +2694,7 @@ static int cma_accept_ib(struct rdma_id_private *id_priv,
         rep.initiator_depth = conn_param->initiator_depth;
         rep.failover_accepted = 0;
         rep.flow_control = conn_param->flow_control;
-        rep.rnr_retry_count = min_t(u8, 7, conn_param->rnr_retry_count);
+        rep.rnr_retry_count = conn_param->rnr_retry_count;
         rep.srq = id_priv->srq ? 1 : 0;
 
         ret = ib_send_cm_rep(id_priv->cm_id.ib, &rep);
@@ -2840,20 +2765,14 @@ int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
 
         switch (rdma_node_get_transport(id->device->node_type)) {
         case RDMA_TRANSPORT_IB:
-                if (id->qp_type == IB_QPT_UD) {
-                        if (conn_param)
-                                ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
-                                                        conn_param->private_data,
-                                                        conn_param->private_data_len);
-                        else
-                                ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
-                                                        NULL, 0);
-                } else {
-                        if (conn_param)
-                                ret = cma_accept_ib(id_priv, conn_param);
-                        else
-                                ret = cma_rep_recv(id_priv);
-                }
+                if (id->qp_type == IB_QPT_UD)
+                        ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
+                                                conn_param->private_data,
+                                                conn_param->private_data_len);
+                else if (conn_param)
+                        ret = cma_accept_ib(id_priv, conn_param);
+                else
+                        ret = cma_rep_recv(id_priv);
                 break;
         case RDMA_TRANSPORT_IWARP:
                 ret = cma_accept_iw(id_priv, conn_param);
@@ -2972,7 +2891,7 @@ static int cma_ib_mc_handler(int status, struct ib_sa_multicast *multicast)
         mutex_lock(&id_priv->qp_mutex);
         if (!status && id_priv->id.qp)
                 status = ib_attach_mcast(id_priv->id.qp, &multicast->rec.mgid,
-                                         be16_to_cpu(multicast->rec.mlid));
+                                         multicast->rec.mlid);
         mutex_unlock(&id_priv->qp_mutex);
 
         memset(&event, 0, sizeof event);
@@ -3057,16 +2976,16 @@ static int cma_join_ib_multicast(struct rdma_id_private *id_priv,
 
         if (id_priv->id.ps == RDMA_PS_IPOIB)
                 comp_mask |= IB_SA_MCMEMBER_REC_RATE |
-                             IB_SA_MCMEMBER_REC_RATE_SELECTOR |
-                             IB_SA_MCMEMBER_REC_MTU_SELECTOR |
-                             IB_SA_MCMEMBER_REC_MTU |
-                             IB_SA_MCMEMBER_REC_HOP_LIMIT;
+                             IB_SA_MCMEMBER_REC_RATE_SELECTOR;
 
         mc->multicast.ib = ib_sa_join_multicast(&sa_client, id_priv->id.device,
                                                 id_priv->id.port_num, &rec,
                                                 comp_mask, GFP_KERNEL,
                                                 cma_ib_mc_handler, mc);
-        return PTR_RET(mc->multicast.ib);
+        if (IS_ERR(mc->multicast.ib))
+                return PTR_ERR(mc->multicast.ib);
+
+        return 0;
 }
 
 static void iboe_mcast_work_handler(struct work_struct *work)
@@ -3233,7 +3152,7 @@ void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr)
                         if (id->qp)
                                 ib_detach_mcast(id->qp,
                                                 &mc->multicast.ib->rec.mgid,
-                                                be16_to_cpu(mc->multicast.ib->rec.mlid));
+                                                mc->multicast.ib->rec.mlid);
                         if (rdma_node_get_transport(id_priv->cma_dev->device->node_type) == RDMA_TRANSPORT_IB) {
                                 switch (rdma_port_get_link_layer(id->device, id->port_num)) {
                                 case IB_LINK_LAYER_INFINIBAND:
@@ -3497,8 +3416,7 @@ out:
 }
 
 static const struct ibnl_client_cbs cma_cb_table[] = {
-        [RDMA_NL_RDMA_CM_ID_STATS] = { .dump = cma_get_id_stats,
-                                       .module = THIS_MODULE },
+        [RDMA_NL_RDMA_CM_ID_STATS] = { .dump = cma_get_id_stats },
 };
 
 static int __init cma_init(void)
@@ -3542,7 +3460,6 @@ static void __exit cma_cleanup(void)
         idr_destroy(&tcp_ps);
         idr_destroy(&udp_ps);
         idr_destroy(&ipoib_ps);
-        idr_destroy(&ib_ps);
 }
 
 module_init(cma_init);
diff --git a/drivers/infiniband/core/device.c b/drivers/infiniband/core/device.c
index 18c1ece765f..e711de400a0 100644
--- a/drivers/infiniband/core/device.c
+++ b/drivers/infiniband/core/device.c
@@ -707,28 +707,18 @@ int ib_find_pkey(struct ib_device *device,
 {
         int ret, i;
         u16 tmp_pkey;
-        int partial_ix = -1;
 
         for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) {
                 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
                 if (ret)
                         return ret;
+
                 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
-                        /* if there is full-member pkey take it.*/
-                        if (tmp_pkey & 0x8000) {
-                                *index = i;
-                                return 0;
-                        }
-                        if (partial_ix < 0)
-                                partial_ix = i;
+                        *index = i;
+                        return 0;
                 }
         }
 
-        /*no full-member, if exists take the limited*/
-        if (partial_ix >= 0) {
-                *index = partial_ix;
-                return 0;
-        }
         return -ENOENT;
 }
 EXPORT_SYMBOL(ib_find_pkey);
diff --git a/drivers/infiniband/core/fmr_pool.c b/drivers/infiniband/core/fmr_pool.c
index 176c8f90f2b..4507043d24c 100644
--- a/drivers/infiniband/core/fmr_pool.c
+++ b/drivers/infiniband/core/fmr_pool.c
@@ -33,7 +33,6 @@
 
 #include <linux/errno.h>
 #include <linux/spinlock.h>
-#include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/jhash.h>
 #include <linux/kthread.h>
diff --git a/drivers/infiniband/core/iwcm.c b/drivers/infiniband/core/iwcm.c
index 0bb99bb3880..a9c042345c6 100644
--- a/drivers/infiniband/core/iwcm.c
+++ b/drivers/infiniband/core/iwcm.c
@@ -45,7 +45,6 @@
 #include <linux/workqueue.h>
 #include <linux/completion.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include <rdma/iw_cm.h>
 #include <rdma/ib_addr.h>
@@ -624,6 +623,17 @@ static void cm_conn_req_handler(struct iwcm_id_private *listen_id_priv,
          */
         BUG_ON(iw_event->status);
 
+        /*
+         * We could be destroying the listening id. If so, ignore this
+         * upcall.
+         */
+        spin_lock_irqsave(&listen_id_priv->lock, flags);
+        if (listen_id_priv->state != IW_CM_STATE_LISTEN) {
+                spin_unlock_irqrestore(&listen_id_priv->lock, flags);
+                goto out;
+        }
+        spin_unlock_irqrestore(&listen_id_priv->lock, flags);
+
         cm_id = iw_create_cm_id(listen_id_priv->id.device,
                                 listen_id_priv->id.cm_handler,
                                 listen_id_priv->id.context);
@@ -638,19 +648,6 @@ static void cm_conn_req_handler(struct iwcm_id_private *listen_id_priv,
         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
         cm_id_priv->state = IW_CM_STATE_CONN_RECV;
 
-        /*
-         * We could be destroying the listening id. If so, ignore this
-         * upcall.
-         */
-        spin_lock_irqsave(&listen_id_priv->lock, flags);
-        if (listen_id_priv->state != IW_CM_STATE_LISTEN) {
-                spin_unlock_irqrestore(&listen_id_priv->lock, flags);
-                iw_cm_reject(cm_id, NULL, 0);
-                iw_destroy_cm_id(cm_id);
-                goto out;
-        }
-        spin_unlock_irqrestore(&listen_id_priv->lock, flags);
-
         ret = alloc_work_entries(cm_id_priv, 3);
         if (ret) {
                 iw_cm_reject(cm_id, NULL, 0);
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index dc3fd1e8af0..b4d8672a3e4 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -35,7 +35,6 @@
  */
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <rdma/ib_cache.h>
 
 #include "mad_priv.h"
@@ -1597,9 +1596,6 @@ find_mad_agent(struct ib_mad_port_private *port_priv,
                                         mad->mad_hdr.class_version].class;
                         if (!class)
                                 goto out;
-                        if (convert_mgmt_class(mad->mad_hdr.mgmt_class) >=
-                            IB_MGMT_MAX_METHODS)
-                                goto out;
                         method = class->method_table[convert_mgmt_class(
                                                         mad->mad_hdr.mgmt_class)];
                         if (method)
@@ -1842,26 +1838,6 @@ static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv,
         }
 }
 
-static bool generate_unmatched_resp(struct ib_mad_private *recv,
-                                    struct ib_mad_private *response)
-{
-        if (recv->mad.mad.mad_hdr.method == IB_MGMT_METHOD_GET ||
-            recv->mad.mad.mad_hdr.method == IB_MGMT_METHOD_SET) {
-                memcpy(response, recv, sizeof *response);
-                response->header.recv_wc.wc = &response->header.wc;
-                response->header.recv_wc.recv_buf.mad = &response->mad.mad;
-                response->header.recv_wc.recv_buf.grh = &response->grh;
-                response->mad.mad.mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
-                response->mad.mad.mad_hdr.status =
-                        cpu_to_be16(IB_MGMT_MAD_STATUS_UNSUPPORTED_METHOD_ATTRIB);
-                if (recv->mad.mad.mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
-                        response->mad.mad.mad_hdr.status |= IB_SMP_DIRECTION;
-
-                return true;
-        } else {
-                return false;
-        }
-}
 static void ib_mad_recv_done_handler(struct ib_mad_port_private *port_priv,
                                      struct ib_wc *wc)
 {
@@ -1871,7 +1847,6 @@ static void ib_mad_recv_done_handler(struct ib_mad_port_private *port_priv,
         struct ib_mad_list_head *mad_list;
         struct ib_mad_agent_private *mad_agent;
         int port_num;
-        int ret = IB_MAD_RESULT_SUCCESS;
 
         mad_list = (struct ib_mad_list_head *)(unsigned long)wc->wr_id;
         qp_info = mad_list->mad_queue->qp_info;
@@ -1955,6 +1930,8 @@ static void ib_mad_recv_done_handler(struct ib_mad_port_private *port_priv,
 local:
         /* Give driver "right of first refusal" on incoming MAD */
         if (port_priv->device->process_mad) {
+                int ret;
+
                 ret = port_priv->device->process_mad(port_priv->device, 0,
                                                      port_priv->port_num,
                                                      wc, &recv->grh,
@@ -1982,10 +1959,6 @@ local:
                  * or via recv_handler in ib_mad_complete_recv()
                  */
                 recv = NULL;
-        } else if ((ret & IB_MAD_RESULT_SUCCESS) &&
-                   generate_unmatched_resp(recv, response)) {
-                agent_send_response(&response->mad.mad, &recv->grh, wc,
-                                    port_priv->device, port_num, qp_info->qp->qp_num);
         }
 
 out:
@@ -2004,7 +1977,7 @@ static void adjust_timeout(struct ib_mad_agent_private *mad_agent_priv)
         unsigned long delay;
 
         if (list_empty(&mad_agent_priv->wait_list)) {
-                cancel_delayed_work(&mad_agent_priv->timed_work);
+                __cancel_delayed_work(&mad_agent_priv->timed_work);
         } else {
                 mad_send_wr = list_entry(mad_agent_priv->wait_list.next,
                                          struct ib_mad_send_wr_private,
@@ -2013,11 +1986,13 @@ static void adjust_timeout(struct ib_mad_agent_private *mad_agent_priv)
                 if (time_after(mad_agent_priv->timeout,
                                mad_send_wr->timeout)) {
                         mad_agent_priv->timeout = mad_send_wr->timeout;
+                        __cancel_delayed_work(&mad_agent_priv->timed_work);
                         delay = mad_send_wr->timeout - jiffies;
                         if ((long)delay <= 0)
                                 delay = 1;
-                        mod_delayed_work(mad_agent_priv->qp_info->port_priv->wq,
-                                         &mad_agent_priv->timed_work, delay);
+                        queue_delayed_work(mad_agent_priv->qp_info->
+                                           port_priv->wq,
+                                           &mad_agent_priv->timed_work, delay);
                 }
         }
 }
@@ -2050,9 +2025,11 @@ static void wait_for_response(struct ib_mad_send_wr_private *mad_send_wr)
         list_add(&mad_send_wr->agent_list, list_item);
 
         /* Reschedule a work item if we have a shorter timeout */
-        if (mad_agent_priv->wait_list.next == &mad_send_wr->agent_list)
-                mod_delayed_work(mad_agent_priv->qp_info->port_priv->wq,
-                                 &mad_agent_priv->timed_work, delay);
+        if (mad_agent_priv->wait_list.next == &mad_send_wr->agent_list) {
+                __cancel_delayed_work(&mad_agent_priv->timed_work);
+                queue_delayed_work(mad_agent_priv->qp_info->port_priv->wq,
+                                   &mad_agent_priv->timed_work, delay);
+        }
 }
 
 void ib_reset_mad_timeout(struct ib_mad_send_wr_private *mad_send_wr,
diff --git a/drivers/infiniband/core/multicast.c b/drivers/infiniband/core/multicast.c
index d2360a8ef0b..68b4162fd9d 100644
--- a/drivers/infiniband/core/multicast.c
+++ b/drivers/infiniband/core/multicast.c
@@ -34,7 +34,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/err.h>
 #include <linux/interrupt.h>
-#include <linux/export.h>
 #include <linux/slab.h>
 #include <linux/bitops.h>
 #include <linux/random.h>
diff --git a/drivers/infiniband/core/netlink.c b/drivers/infiniband/core/netlink.c
index da06abde9e0..9227f4acd79 100644
--- a/drivers/infiniband/core/netlink.c
+++ b/drivers/infiniband/core/netlink.c
@@ -32,7 +32,6 @@
 
 #define pr_fmt(fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__
 
-#include <linux/export.h>
 #include <net/netlink.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
@@ -108,14 +107,12 @@ void *ibnl_put_msg(struct sk_buff *skb, struct nlmsghdr **nlh, int seq,
         unsigned char *prev_tail;
 
         prev_tail = skb_tail_pointer(skb);
-        *nlh = nlmsg_put(skb, 0, seq, RDMA_NL_GET_TYPE(client, op),
-                         len, NLM_F_MULTI);
-        if (!*nlh)
-                goto out_nlmsg_trim;
+        *nlh = NLMSG_NEW(skb, 0, seq, RDMA_NL_GET_TYPE(client, op),
+                        len, NLM_F_MULTI);
         (*nlh)->nlmsg_len = skb_tail_pointer(skb) - prev_tail;
-        return nlmsg_data(*nlh);
+        return NLMSG_DATA(*nlh);
 
-out_nlmsg_trim:
+nlmsg_failure:
         nlmsg_trim(skb, prev_tail);
         return NULL;
 }
@@ -127,8 +124,7 @@ int ibnl_put_attr(struct sk_buff *skb, struct nlmsghdr *nlh,
         unsigned char *prev_tail;
 
         prev_tail = skb_tail_pointer(skb);
-        if (nla_put(skb, type, len, data))
-                goto nla_put_failure;
+        NLA_PUT(skb, type, len, data);
         nlh->nlmsg_len += skb_tail_pointer(skb) - prev_tail;
         return 0;
 
@@ -150,14 +146,9 @@ static int ibnl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
                         if (op < 0 || op >= client->nops ||
                             !client->cb_table[RDMA_NL_GET_OP(op)].dump)
                                 return -EINVAL;
-
-                        {
-                                struct netlink_dump_control c = {
-                                        .dump = client->cb_table[op].dump,
-                                        .module = client->cb_table[op].module,
-                                };
-                                return netlink_dump_start(nls, skb, nlh, &c);
-                        }
+                        return netlink_dump_start(nls, skb, nlh,
+                                                  client->cb_table[op].dump,
+                                                  NULL, 0);
                 }
         }
 
@@ -174,11 +165,8 @@ static void ibnl_rcv(struct sk_buff *skb)
 
 int __init ibnl_init(void)
 {
-        struct netlink_kernel_cfg cfg = {
-                .input  = ibnl_rcv,
-        };
-
-        nls = netlink_kernel_create(&init_net, NETLINK_RDMA, &cfg);
+        nls = netlink_kernel_create(&init_net, NETLINK_RDMA, 0, ibnl_rcv,
+                                    NULL, THIS_MODULE);
         if (!nls) {
                 pr_warn("Failed to create netlink socket\n");
                 return -ENOMEM;
diff --git a/drivers/infiniband/core/packer.c b/drivers/infiniband/core/packer.c
index 1b65986c0be..019bd4b0863 100644
--- a/drivers/infiniband/core/packer.c
+++ b/drivers/infiniband/core/packer.c
@@ -31,7 +31,6 @@
  * SOFTWARE.
  */
 
-#include <linux/export.h>
 #include <linux/string.h>
 
 #include <rdma/ib_pack.h>
diff --git a/drivers/infiniband/core/sa_query.c b/drivers/infiniband/core/sa_query.c
index a8905abc56e..fbbfa24cf57 100644
--- a/drivers/infiniband/core/sa_query.c
+++ b/drivers/infiniband/core/sa_query.c
@@ -94,12 +94,6 @@ struct ib_sa_path_query {
         struct ib_sa_query sa_query;
 };
 
-struct ib_sa_guidinfo_query {
-        void (*callback)(int, struct ib_sa_guidinfo_rec *, void *);
-        void *context;
-        struct ib_sa_query sa_query;
-};
-
 struct ib_sa_mcmember_query {
         void (*callback)(int, struct ib_sa_mcmember_rec *, void *);
         void *context;
@@ -353,34 +347,6 @@ static const struct ib_field service_rec_table[] = {
           .size_bits    = 2*64 },
 };
 
-#define GUIDINFO_REC_FIELD(field) \
-        .struct_offset_bytes = offsetof(struct ib_sa_guidinfo_rec, field),      \
-        .struct_size_bytes   = sizeof((struct ib_sa_guidinfo_rec *) 0)->field,  \
-        .field_name          = "sa_guidinfo_rec:" #field
-
-static const struct ib_field guidinfo_rec_table[] = {
-        { GUIDINFO_REC_FIELD(lid),
-          .offset_words = 0,
-          .offset_bits  = 0,
-          .size_bits    = 16 },
-        { GUIDINFO_REC_FIELD(block_num),
-          .offset_words = 0,
-          .offset_bits  = 16,
-          .size_bits    = 8 },
-        { GUIDINFO_REC_FIELD(res1),
-          .offset_words = 0,
-          .offset_bits  = 24,
-          .size_bits    = 8 },
-        { GUIDINFO_REC_FIELD(res2),
-          .offset_words = 1,
-          .offset_bits  = 0,
-          .size_bits    = 32 },
-        { GUIDINFO_REC_FIELD(guid_info_list),
-          .offset_words = 2,
-          .offset_bits  = 0,
-          .size_bits    = 512 },
-};
-
 static void free_sm_ah(struct kref *kref)
 {
         struct ib_sa_sm_ah *sm_ah = container_of(kref, struct ib_sa_sm_ah, ref);
@@ -979,105 +945,6 @@ err1:
         return ret;
 }
 
-/* Support GuidInfoRecord */
-static void ib_sa_guidinfo_rec_callback(struct ib_sa_query *sa_query,
-                                        int status,
-                                        struct ib_sa_mad *mad)
-{
-        struct ib_sa_guidinfo_query *query =
-                container_of(sa_query, struct ib_sa_guidinfo_query, sa_query);
-
-        if (mad) {
-                struct ib_sa_guidinfo_rec rec;
-
-                ib_unpack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table),
-                          mad->data, &rec);
-                query->callback(status, &rec, query->context);
-        } else
-                query->callback(status, NULL, query->context);
-}
-
-static void ib_sa_guidinfo_rec_release(struct ib_sa_query *sa_query)
-{
-        kfree(container_of(sa_query, struct ib_sa_guidinfo_query, sa_query));
-}
-
-int ib_sa_guid_info_rec_query(struct ib_sa_client *client,
-                              struct ib_device *device, u8 port_num,
-                              struct ib_sa_guidinfo_rec *rec,
-                              ib_sa_comp_mask comp_mask, u8 method,
-                              int timeout_ms, gfp_t gfp_mask,
-                              void (*callback)(int status,
-                                               struct ib_sa_guidinfo_rec *resp,
-                                               void *context),
-                              void *context,
-                              struct ib_sa_query **sa_query)
-{
-        struct ib_sa_guidinfo_query *query;
-        struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
-        struct ib_sa_port *port;
-        struct ib_mad_agent *agent;
-        struct ib_sa_mad *mad;
-        int ret;
-
-        if (!sa_dev)
-                return -ENODEV;
-
-        if (method != IB_MGMT_METHOD_GET &&
-            method != IB_MGMT_METHOD_SET &&
-            method != IB_SA_METHOD_DELETE) {
-                return -EINVAL;
-        }
-
-        port  = &sa_dev->port[port_num - sa_dev->start_port];
-        agent = port->agent;
-
-        query = kmalloc(sizeof *query, gfp_mask);
-        if (!query)
-                return -ENOMEM;
-
-        query->sa_query.port = port;
-        ret = alloc_mad(&query->sa_query, gfp_mask);
-        if (ret)
-                goto err1;
-
-        ib_sa_client_get(client);
-        query->sa_query.client = client;
-        query->callback        = callback;
-        query->context         = context;
-
-        mad = query->sa_query.mad_buf->mad;
-        init_mad(mad, agent);
-
-        query->sa_query.callback = callback ? ib_sa_guidinfo_rec_callback : NULL;
-        query->sa_query.release  = ib_sa_guidinfo_rec_release;
-
-        mad->mad_hdr.method      = method;
-        mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_GUID_INFO_REC);
-        mad->sa_hdr.comp_mask    = comp_mask;
-
-        ib_pack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table), rec,
-                mad->data);
-
-        *sa_query = &query->sa_query;
-
-        ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
-        if (ret < 0)
-                goto err2;
-
-        return ret;
-
-err2:
-        *sa_query = NULL;
-        ib_sa_client_put(query->sa_query.client);
-        free_mad(&query->sa_query);
-
-err1:
-        kfree(query);
-        return ret;
-}
-EXPORT_SYMBOL(ib_sa_guid_info_rec_query);
-
 static void send_handler(struct ib_mad_agent *agent,
                          struct ib_mad_send_wc *mad_send_wc)
 {
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index 246fdc15165..9ab5df72df7 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -35,7 +35,6 @@
 #include "core_priv.h"
 
 #include <linux/slab.h>
-#include <linux/stat.h>
 #include <linux/string.h>
 
 #include <rdma/ib_mad.h>
@@ -179,7 +178,7 @@ static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused,
 {
         struct ib_port_attr attr;
         char *speed = "";
-        int rate;               /* in deci-Gb/sec */
+        int rate;
         ssize_t ret;
 
         ret = ib_query_port(p->ibdev, p->port_num, &attr);
@@ -187,33 +186,11 @@ static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused,
                 return ret;
 
         switch (attr.active_speed) {
-        case IB_SPEED_DDR:
-                speed = " DDR";
-                rate = 50;
-                break;
-        case IB_SPEED_QDR:
-                speed = " QDR";
-                rate = 100;
-                break;
-        case IB_SPEED_FDR10:
-                speed = " FDR10";
-                rate = 100;
-                break;
-        case IB_SPEED_FDR:
-                speed = " FDR";
-                rate = 140;
-                break;
-        case IB_SPEED_EDR:
-                speed = " EDR";
-                rate = 250;
-                break;
-        case IB_SPEED_SDR:
-        default:                /* default to SDR for invalid rates */
-                rate = 25;
-                break;
+        case 2: speed = " DDR"; break;
+        case 4: speed = " QDR"; break;
         }
 
-        rate *= ib_width_enum_to_int(attr.active_width);
+        rate = 25 * ib_width_enum_to_int(attr.active_width) * attr.active_speed;
         if (rate < 0)
                 return -EINVAL;
 
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 49b15ac1987..08f948df8fa 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -106,6 +106,9 @@ enum {
         IB_UCM_MAX_DEVICES = 32
 };
 
+/* ib_cm and ib_user_cm modules share /sys/class/infiniband_cm */
+extern struct class cm_class;
+
 #define IB_UCM_BASE_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_BASE_MINOR)
 
 static void ib_ucm_add_one(struct ib_device *device);
@@ -397,6 +400,7 @@ static ssize_t ib_ucm_event(struct ib_ucm_file *file,
         struct ib_ucm_event_get cmd;
         struct ib_ucm_event *uevent;
         int result = 0;
+        DEFINE_WAIT(wait);
 
         if (out_len < sizeof(struct ib_ucm_event_resp))
                 return -ENOSPC;
@@ -1118,7 +1122,7 @@ static ssize_t ib_ucm_write(struct file *filp, const char __user *buf,
         if (copy_from_user(&hdr, buf, sizeof(hdr)))
                 return -EFAULT;
 
-        if (hdr.cmd >= ARRAY_SIZE(ucm_cmd_table))
+        if (hdr.cmd < 0 || hdr.cmd >= ARRAY_SIZE(ucm_cmd_table))
                 return -EINVAL;
 
         if (hdr.in + sizeof(hdr) > len)
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index 2709ff58139..71be5eebd68 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -41,7 +41,6 @@
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
 #include <linux/sysctl.h>
-#include <linux/module.h>
 
 #include <rdma/rdma_user_cm.h>
 #include <rdma/ib_marshall.h>
@@ -66,6 +65,12 @@ static ctl_table ucma_ctl_table[] = {
         { }
 };
 
+static struct ctl_path ucma_ctl_path[] = {
+        { .procname = "net" },
+        { .procname = "rdma_ucm" },
+        { }
+};
+
 struct ucma_file {
         struct mutex            mut;
         struct file             *filp;
@@ -267,17 +272,17 @@ static int ucma_event_handler(struct rdma_cm_id *cm_id,
         if (!uevent)
                 return event->event == RDMA_CM_EVENT_CONNECT_REQUEST;
 
-        mutex_lock(&ctx->file->mut);
         uevent->cm_id = cm_id;
         ucma_set_event_context(ctx, event, uevent);
         uevent->resp.event = event->event;
         uevent->resp.status = event->status;
-        if (cm_id->qp_type == IB_QPT_UD)
+        if (cm_id->ps == RDMA_PS_UDP || cm_id->ps == RDMA_PS_IPOIB)
                 ucma_copy_ud_event(&uevent->resp.param.ud, &event->param.ud);
         else
                 ucma_copy_conn_event(&uevent->resp.param.conn,
                                      &event->param.conn);
 
+        mutex_lock(&ctx->file->mut);
         if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) {
                 if (!ctx->backlog) {
                         ret = -ENOMEM;
@@ -310,6 +315,7 @@ static ssize_t ucma_get_event(struct ucma_file *file, const char __user *inbuf,
         struct rdma_ucm_get_event cmd;
         struct ucma_event *uevent;
         int ret = 0;
+        DEFINE_WAIT(wait);
 
         if (out_len < sizeof uevent->resp)
                 return -ENOSPC;
@@ -371,9 +377,6 @@ static int ucma_get_qp_type(struct rdma_ucm_create_id *cmd, enum ib_qp_type *qp_
         case RDMA_PS_IPOIB:
                 *qp_type = IB_QPT_UD;
                 return 0;
-        case RDMA_PS_IB:
-                *qp_type = cmd->qp_type;
-                return 0;
         default:
                 return -EINVAL;
         }
@@ -442,6 +445,24 @@ static void ucma_cleanup_multicast(struct ucma_context *ctx)
         mutex_unlock(&mut);
 }
 
+static void ucma_cleanup_events(struct ucma_context *ctx)
+{
+        struct ucma_event *uevent, *tmp;
+
+        list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list) {
+                if (uevent->ctx != ctx)
+                        continue;
+
+                list_del(&uevent->list);
+
+                /* clear incoming connections. */
+                if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST)
+                        rdma_destroy_id(uevent->cm_id);
+
+                kfree(uevent);
+        }
+}
+
 static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
 {
         struct ucma_event *uevent, *tmp;
@@ -455,16 +476,9 @@ static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
         }
 }
 
-/*
- * We cannot hold file->mut when calling rdma_destroy_id() or we can
- * deadlock.  We also acquire file->mut in ucma_event_handler(), and
- * rdma_destroy_id() will wait until all callbacks have completed.
- */
 static int ucma_free_ctx(struct ucma_context *ctx)
 {
         int events_reported;
-        struct ucma_event *uevent, *tmp;
-        LIST_HEAD(list);
 
         /* No new events will be generated after destroying the id. */
         rdma_destroy_id(ctx->cm_id);
@@ -473,20 +487,10 @@ static int ucma_free_ctx(struct ucma_context *ctx)
 
         /* Cleanup events not yet reported to the user. */
         mutex_lock(&ctx->file->mut);
-        list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list) {
-                if (uevent->ctx == ctx)
-                        list_move_tail(&uevent->list, &list);
-        }
+        ucma_cleanup_events(ctx);
         list_del(&ctx->list);
         mutex_unlock(&ctx->file->mut);
 
-        list_for_each_entry_safe(uevent, tmp, &list, list) {
-                list_del(&uevent->list);
-                if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST)
-                        rdma_destroy_id(uevent->cm_id);
-                kfree(uevent);
-        }
-
         events_reported = ctx->events_reported;
         kfree(ctx);
         return events_reported;
@@ -800,12 +804,9 @@ static ssize_t ucma_accept(struct ucma_file *file, const char __user *inbuf,
                 return PTR_ERR(ctx);
 
         if (cmd.conn_param.valid) {
+                ctx->uid = cmd.uid;
                 ucma_copy_conn_param(&conn_param, &cmd.conn_param);
-                mutex_lock(&file->mut);
                 ret = rdma_accept(ctx->cm_id, &conn_param);
-                if (!ret)
-                        ctx->uid = cmd.uid;
-                mutex_unlock(&file->mut);
         } else
                 ret = rdma_accept(ctx->cm_id, NULL);
 
@@ -908,13 +909,6 @@ static int ucma_set_option_id(struct ucma_context *ctx, int optname,
                 }
                 ret = rdma_set_reuseaddr(ctx->cm_id, *((int *) optval) ? 1 : 0);
                 break;
-        case RDMA_OPTION_ID_AFONLY:
-                if (optlen != sizeof(int)) {
-                        ret = -EINVAL;
-                        break;
-                }
-                ret = rdma_set_afonly(ctx->cm_id, *((int *) optval) ? 1 : 0);
-                break;
         default:
                 ret = -ENOSYS;
         }
@@ -1001,18 +995,23 @@ static ssize_t ucma_set_option(struct ucma_file *file, const char __user *inbuf,
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
 
-        optval = memdup_user((void __user *) (unsigned long) cmd.optval,
-                             cmd.optlen);
-        if (IS_ERR(optval)) {
-                ret = PTR_ERR(optval);
-                goto out;
+        optval = kmalloc(cmd.optlen, GFP_KERNEL);
+        if (!optval) {
+                ret = -ENOMEM;
+                goto out1;
+        }
+
+        if (copy_from_user(optval, (void __user *) (unsigned long) cmd.optval,
+                           cmd.optlen)) {
+                ret = -EFAULT;
+                goto out2;
         }
 
         ret = ucma_set_option_level(ctx, cmd.level, cmd.optname, optval,
                                     cmd.optlen);
+out2:
         kfree(optval);
-
-out:
+out1:
         ucma_put_ctx(ctx);
         return ret;
 }
@@ -1183,7 +1182,7 @@ static ssize_t ucma_migrate_id(struct ucma_file *new_file,
         struct rdma_ucm_migrate_id cmd;
         struct rdma_ucm_migrate_resp resp;
         struct ucma_context *ctx;
-        struct fd f;
+        struct file *filp;
         struct ucma_file *cur_file;
         int ret = 0;
 
@@ -1191,12 +1190,12 @@ static ssize_t ucma_migrate_id(struct ucma_file *new_file,
                 return -EFAULT;
 
         /* Get current fd to protect against it being closed */
-        f = fdget(cmd.fd);
-        if (!f.file)
+        filp = fget(cmd.fd);
+        if (!filp)
                 return -ENOENT;
 
         /* Validate current fd and prevent destruction of id. */
-        ctx = ucma_get_ctx(f.file->private_data, cmd.id);
+        ctx = ucma_get_ctx(filp->private_data, cmd.id);
         if (IS_ERR(ctx)) {
                 ret = PTR_ERR(ctx);
                 goto file_put;
@@ -1230,7 +1229,7 @@ response:
 
         ucma_put_ctx(ctx);
 file_put:
-        fdput(f);
+        fput(filp);
         return ret;
 }
 
@@ -1271,7 +1270,7 @@ static ssize_t ucma_write(struct file *filp, const char __user *buf,
         if (copy_from_user(&hdr, buf, sizeof(hdr)))
                 return -EFAULT;
 
-        if (hdr.cmd >= ARRAY_SIZE(ucma_cmd_table))
+        if (hdr.cmd < 0 || hdr.cmd >= ARRAY_SIZE(ucma_cmd_table))
                 return -EINVAL;
 
         if (hdr.in + sizeof(hdr) > len)
@@ -1387,7 +1386,7 @@ static int __init ucma_init(void)
                 goto err1;
         }
 
-        ucma_ctl_table_hdr = register_net_sysctl(&init_net, "net/rdma_ucm", ucma_ctl_table);
+        ucma_ctl_table_hdr = register_sysctl_paths(ucma_ctl_path, ucma_ctl_table);
         if (!ucma_ctl_table_hdr) {
                 printk(KERN_ERR "rdma_ucm: couldn't register sysctl paths\n");
                 ret = -ENOMEM;
@@ -1403,7 +1402,7 @@ err1:
 
 static void __exit ucma_cleanup(void)
 {
-        unregister_net_sysctl_table(ucma_ctl_table_hdr);
+        unregister_sysctl_table(ucma_ctl_table_hdr);
         device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
         misc_deregister(&ucma_misc);
         idr_destroy(&ctx_idr);
diff --git a/drivers/infiniband/core/ud_header.c b/drivers/infiniband/core/ud_header.c
index 72feee620eb..9b737ff133e 100644
--- a/drivers/infiniband/core/ud_header.c
+++ b/drivers/infiniband/core/ud_header.c
@@ -33,7 +33,6 @@
 
 #include <linux/errno.h>
 #include <linux/string.h>
-#include <linux/export.h>
 #include <linux/if_ether.h>
 
 #include <rdma/ib_pack.h>
diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c
index a8411232207..b645e558876 100644
--- a/drivers/infiniband/core/umem.c
+++ b/drivers/infiniband/core/umem.c
@@ -35,7 +35,6 @@
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>
 #include <linux/sched.h>
-#include <linux/export.h>
 #include <linux/hugetlb.h>
 #include <linux/dma-attrs.h>
 #include <linux/slab.h>
@@ -137,7 +136,7 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
 
         down_write(&current->mm->mmap_sem);
 
-        locked     = npages + current->mm->pinned_vm;
+        locked     = npages + current->mm->locked_vm;
         lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 
         if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
@@ -207,7 +206,7 @@ out:
                 __ib_umem_release(context->device, umem, 0);
                 kfree(umem);
         } else
-                current->mm->pinned_vm = locked;
+                current->mm->locked_vm = locked;
 
         up_write(&current->mm->mmap_sem);
         if (vma_list)
@@ -223,7 +222,7 @@ static void ib_umem_account(struct work_struct *work)
         struct ib_umem *umem = container_of(work, struct ib_umem, work);
 
         down_write(&umem->mm->mmap_sem);
-        umem->mm->pinned_vm -= umem->diff;
+        umem->mm->locked_vm -= umem->diff;
         up_write(&umem->mm->mmap_sem);
         mmput(umem->mm);
         kfree(umem);
@@ -269,7 +268,7 @@ void ib_umem_release(struct ib_umem *umem)
         } else
                 down_write(&mm->mmap_sem);
 
-        current->mm->pinned_vm -= diff;
+        current->mm->locked_vm -= diff;
         up_write(&mm->mmap_sem);
         mmput(mm);
         kfree(umem);
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
index f0d588f8859..8d261b6ea5f 100644
--- a/drivers/infiniband/core/user_mad.c
+++ b/drivers/infiniband/core/user_mad.c
@@ -458,7 +458,8 @@ static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
                 goto err;
         }
 
-        if (packet->mad.hdr.id >= IB_UMAD_MAX_AGENTS) {
+        if (packet->mad.hdr.id < 0 ||
+            packet->mad.hdr.id >= IB_UMAD_MAX_AGENTS) {
                 ret = -EINVAL;
                 goto err;
         }
@@ -702,7 +703,7 @@ static int ib_umad_unreg_agent(struct ib_umad_file *file, u32 __user *arg)
         mutex_lock(&file->port->file_mutex);
         mutex_lock(&file->mutex);
 
-        if (id >= IB_UMAD_MAX_AGENTS || !__get_agent(file, id)) {
+        if (id < 0 || id >= IB_UMAD_MAX_AGENTS || !__get_agent(file, id)) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -1175,7 +1176,7 @@ static void ib_umad_remove_one(struct ib_device *device)
         kref_put(&umad_dev->ref, ib_umad_release_dev);
 }
 
-static char *umad_devnode(struct device *dev, umode_t *mode)
+static char *umad_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
 }
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index 5bcb2afd3dc..a078e5624d2 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -76,8 +76,6 @@ struct ib_uverbs_device {
         struct ib_device                       *ib_dev;
         int                                     devnum;
         struct cdev                             cdev;
-        struct rb_root                          xrcd_tree;
-        struct mutex                            xrcd_tree_mutex;
 };
 
 struct ib_uverbs_event_file {
@@ -122,16 +120,6 @@ struct ib_uevent_object {
         u32                     events_reported;
 };
 
-struct ib_uxrcd_object {
-        struct ib_uobject       uobject;
-        atomic_t                refcnt;
-};
-
-struct ib_usrq_object {
-        struct ib_uevent_object uevent;
-        struct ib_uxrcd_object *uxrcd;
-};
-
 struct ib_uqp_object {
         struct ib_uevent_object uevent;
         struct list_head        mcast_list;
@@ -154,7 +142,6 @@ extern struct idr ib_uverbs_ah_idr;
 extern struct idr ib_uverbs_cq_idr;
 extern struct idr ib_uverbs_qp_idr;
 extern struct idr ib_uverbs_srq_idr;
-extern struct idr ib_uverbs_xrcd_idr;
 
 void idr_remove_uobj(struct idr *idp, struct ib_uobject *uobj);
 
@@ -174,7 +161,6 @@ void ib_uverbs_qp_event_handler(struct ib_event *event, void *context_ptr);
 void ib_uverbs_srq_event_handler(struct ib_event *event, void *context_ptr);
 void ib_uverbs_event_handler(struct ib_event_handler *handler,
                              struct ib_event *event);
-void ib_uverbs_dealloc_xrcd(struct ib_uverbs_device *dev, struct ib_xrcd *xrcd);
 
 #define IB_UVERBS_DECLARE_CMD(name)                                     \
         ssize_t ib_uverbs_##name(struct ib_uverbs_file *file,           \
@@ -195,7 +181,6 @@ IB_UVERBS_DECLARE_CMD(poll_cq);
 IB_UVERBS_DECLARE_CMD(req_notify_cq);
 IB_UVERBS_DECLARE_CMD(destroy_cq);
 IB_UVERBS_DECLARE_CMD(create_qp);
-IB_UVERBS_DECLARE_CMD(open_qp);
 IB_UVERBS_DECLARE_CMD(query_qp);
 IB_UVERBS_DECLARE_CMD(modify_qp);
 IB_UVERBS_DECLARE_CMD(destroy_qp);
@@ -210,8 +195,5 @@ IB_UVERBS_DECLARE_CMD(create_srq);
 IB_UVERBS_DECLARE_CMD(modify_srq);
 IB_UVERBS_DECLARE_CMD(query_srq);
 IB_UVERBS_DECLARE_CMD(destroy_srq);
-IB_UVERBS_DECLARE_CMD(create_xsrq);
-IB_UVERBS_DECLARE_CMD(open_xrcd);
-IB_UVERBS_DECLARE_CMD(close_xrcd);
 
 #endif /* UVERBS_H */
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index 0cb0007724a..c42699285f8 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -41,18 +41,12 @@
 
 #include "uverbs.h"
 
-struct uverbs_lock_class {
-        struct lock_class_key   key;
-        char                    name[16];
-};
-
-static struct uverbs_lock_class pd_lock_class   = { .name = "PD-uobj" };
-static struct uverbs_lock_class mr_lock_class   = { .name = "MR-uobj" };
-static struct uverbs_lock_class cq_lock_class   = { .name = "CQ-uobj" };
-static struct uverbs_lock_class qp_lock_class   = { .name = "QP-uobj" };
-static struct uverbs_lock_class ah_lock_class   = { .name = "AH-uobj" };
-static struct uverbs_lock_class srq_lock_class  = { .name = "SRQ-uobj" };
-static struct uverbs_lock_class xrcd_lock_class = { .name = "XRCD-uobj" };
+static struct lock_class_key pd_lock_key;
+static struct lock_class_key mr_lock_key;
+static struct lock_class_key cq_lock_key;
+static struct lock_class_key qp_lock_key;
+static struct lock_class_key ah_lock_key;
+static struct lock_class_key srq_lock_key;
 
 #define INIT_UDATA(udata, ibuf, obuf, ilen, olen)                       \
         do {                                                            \
@@ -88,13 +82,13 @@ static struct uverbs_lock_class xrcd_lock_class = { .name = "XRCD-uobj" };
  */
 
 static void init_uobj(struct ib_uobject *uobj, u64 user_handle,
-                      struct ib_ucontext *context, struct uverbs_lock_class *c)
+                      struct ib_ucontext *context, struct lock_class_key *key)
 {
         uobj->user_handle = user_handle;
         uobj->context     = context;
         kref_init(&uobj->ref);
         init_rwsem(&uobj->mutex);
-        lockdep_set_class_and_name(&uobj->mutex, &c->key, c->name);
+        lockdep_set_class(&uobj->mutex, key);
         uobj->live        = 0;
 }
 
@@ -246,24 +240,11 @@ static struct ib_qp *idr_read_qp(int qp_handle, struct ib_ucontext *context)
         return idr_read_obj(&ib_uverbs_qp_idr, qp_handle, context, 0);
 }
 
-static struct ib_qp *idr_write_qp(int qp_handle, struct ib_ucontext *context)
-{
-        struct ib_uobject *uobj;
-
-        uobj = idr_write_uobj(&ib_uverbs_qp_idr, qp_handle, context);
-        return uobj ? uobj->object : NULL;
-}
-
 static void put_qp_read(struct ib_qp *qp)
 {
         put_uobj_read(qp->uobject);
 }
 
-static void put_qp_write(struct ib_qp *qp)
-{
-        put_uobj_write(qp->uobject);
-}
-
 static struct ib_srq *idr_read_srq(int srq_handle, struct ib_ucontext *context)
 {
         return idr_read_obj(&ib_uverbs_srq_idr, srq_handle, context, 0);
@@ -274,18 +255,6 @@ static void put_srq_read(struct ib_srq *srq)
         put_uobj_read(srq->uobject);
 }
 
-static struct ib_xrcd *idr_read_xrcd(int xrcd_handle, struct ib_ucontext *context,
-                                     struct ib_uobject **uobj)
-{
-        *uobj = idr_read_uobj(&ib_uverbs_xrcd_idr, xrcd_handle, context, 0);
-        return *uobj ? (*uobj)->object : NULL;
-}
-
-static void put_xrcd_read(struct ib_uobject *uobj)
-{
-        put_uobj_read(uobj);
-}
-
 ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
                               const char __user *buf,
                               int in_len, int out_len)
@@ -329,7 +298,6 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
         INIT_LIST_HEAD(&ucontext->qp_list);
         INIT_LIST_HEAD(&ucontext->srq_list);
         INIT_LIST_HEAD(&ucontext->ah_list);
-        INIT_LIST_HEAD(&ucontext->xrcd_list);
         ucontext->closing = 0;
 
         resp.num_comp_vectors = file->device->num_comp_vectors;
@@ -527,7 +495,7 @@ ssize_t ib_uverbs_alloc_pd(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        init_uobj(uobj, 0, file->ucontext, &pd_lock_class);
+        init_uobj(uobj, 0, file->ucontext, &pd_lock_key);
         down_write(&uobj->mutex);
 
         pd = file->device->ib_dev->alloc_pd(file->device->ib_dev,
@@ -611,305 +579,6 @@ ssize_t ib_uverbs_dealloc_pd(struct ib_uverbs_file *file,
         return in_len;
 }
 
-struct xrcd_table_entry {
-        struct rb_node  node;
-        struct ib_xrcd *xrcd;
-        struct inode   *inode;
-};
-
-static int xrcd_table_insert(struct ib_uverbs_device *dev,
-                            struct inode *inode,
-                            struct ib_xrcd *xrcd)
-{
-        struct xrcd_table_entry *entry, *scan;
-        struct rb_node **p = &dev->xrcd_tree.rb_node;
-        struct rb_node *parent = NULL;
-
-        entry = kmalloc(sizeof *entry, GFP_KERNEL);
-        if (!entry)
-                return -ENOMEM;
-
-        entry->xrcd  = xrcd;
-        entry->inode = inode;
-
-        while (*p) {
-                parent = *p;
-                scan = rb_entry(parent, struct xrcd_table_entry, node);
-
-                if (inode < scan->inode) {
-                        p = &(*p)->rb_left;
-                } else if (inode > scan->inode) {
-                        p = &(*p)->rb_right;
-                } else {
-                        kfree(entry);
-                        return -EEXIST;
-                }
-        }
-
-        rb_link_node(&entry->node, parent, p);
-        rb_insert_color(&entry->node, &dev->xrcd_tree);
-        igrab(inode);
-        return 0;
-}
-
-static struct xrcd_table_entry *xrcd_table_search(struct ib_uverbs_device *dev,
-                                                  struct inode *inode)
-{
-        struct xrcd_table_entry *entry;
-        struct rb_node *p = dev->xrcd_tree.rb_node;
-
-        while (p) {
-                entry = rb_entry(p, struct xrcd_table_entry, node);
-
-                if (inode < entry->inode)
-                        p = p->rb_left;
-                else if (inode > entry->inode)
-                        p = p->rb_right;
-                else
-                        return entry;
-        }
-
-        return NULL;
-}
-
-static struct ib_xrcd *find_xrcd(struct ib_uverbs_device *dev, struct inode *inode)
-{
-        struct xrcd_table_entry *entry;
-
-        entry = xrcd_table_search(dev, inode);
-        if (!entry)
-                return NULL;
-
-        return entry->xrcd;
-}
-
-static void xrcd_table_delete(struct ib_uverbs_device *dev,
-                              struct inode *inode)
-{
-        struct xrcd_table_entry *entry;
-
-        entry = xrcd_table_search(dev, inode);
-        if (entry) {
-                iput(inode);
-                rb_erase(&entry->node, &dev->xrcd_tree);
-                kfree(entry);
-        }
-}
-
-ssize_t ib_uverbs_open_xrcd(struct ib_uverbs_file *file,
-                            const char __user *buf, int in_len,
-                            int out_len)
-{
-        struct ib_uverbs_open_xrcd      cmd;
-        struct ib_uverbs_open_xrcd_resp resp;
-        struct ib_udata                 udata;
-        struct ib_uxrcd_object         *obj;
-        struct ib_xrcd                 *xrcd = NULL;
-        struct fd                       f = {NULL, 0};
-        struct inode                   *inode = NULL;
-        int                             ret = 0;
-        int                             new_xrcd = 0;
-
-        if (out_len < sizeof resp)
-                return -ENOSPC;
-
-        if (copy_from_user(&cmd, buf, sizeof cmd))
-                return -EFAULT;
-
-        INIT_UDATA(&udata, buf + sizeof cmd,
-                   (unsigned long) cmd.response + sizeof resp,
-                   in_len - sizeof cmd, out_len - sizeof  resp);
-
-        mutex_lock(&file->device->xrcd_tree_mutex);
-
-        if (cmd.fd != -1) {
-                /* search for file descriptor */
-                f = fdget(cmd.fd);
-                if (!f.file) {
-                        ret = -EBADF;
-                        goto err_tree_mutex_unlock;
-                }
-
-                inode = f.file->f_path.dentry->d_inode;
-                xrcd = find_xrcd(file->device, inode);
-                if (!xrcd && !(cmd.oflags & O_CREAT)) {
-                        /* no file descriptor. Need CREATE flag */
-                        ret = -EAGAIN;
-                        goto err_tree_mutex_unlock;
-                }
-
-                if (xrcd && cmd.oflags & O_EXCL) {
-                        ret = -EINVAL;
-                        goto err_tree_mutex_unlock;
-                }
-        }
-
-        obj = kmalloc(sizeof *obj, GFP_KERNEL);
-        if (!obj) {
-                ret = -ENOMEM;
-                goto err_tree_mutex_unlock;
-        }
-
-        init_uobj(&obj->uobject, 0, file->ucontext, &xrcd_lock_class);
-
-        down_write(&obj->uobject.mutex);
-
-        if (!xrcd) {
-                xrcd = file->device->ib_dev->alloc_xrcd(file->device->ib_dev,
-                                                        file->ucontext, &udata);
-                if (IS_ERR(xrcd)) {
-                        ret = PTR_ERR(xrcd);
-                        goto err;
-                }
-
-                xrcd->inode   = inode;
-                xrcd->device  = file->device->ib_dev;
-                atomic_set(&xrcd->usecnt, 0);
-                mutex_init(&xrcd->tgt_qp_mutex);
-                INIT_LIST_HEAD(&xrcd->tgt_qp_list);
-                new_xrcd = 1;
-        }
-
-        atomic_set(&obj->refcnt, 0);
-        obj->uobject.object = xrcd;
-        ret = idr_add_uobj(&ib_uverbs_xrcd_idr, &obj->uobject);
-        if (ret)
-                goto err_idr;
-
-        memset(&resp, 0, sizeof resp);
-        resp.xrcd_handle = obj->uobject.id;
-
-        if (inode) {
-                if (new_xrcd) {
-                        /* create new inode/xrcd table entry */
-                        ret = xrcd_table_insert(file->device, inode, xrcd);
-                        if (ret)
-                                goto err_insert_xrcd;
-                }
-                atomic_inc(&xrcd->usecnt);
-        }
-
-        if (copy_to_user((void __user *) (unsigned long) cmd.response,
-                         &resp, sizeof resp)) {
-                ret = -EFAULT;
-                goto err_copy;
-        }
-
-        if (f.file)
-                fdput(f);
-
-        mutex_lock(&file->mutex);
-        list_add_tail(&obj->uobject.list, &file->ucontext->xrcd_list);
-        mutex_unlock(&file->mutex);
-
-        obj->uobject.live = 1;
-        up_write(&obj->uobject.mutex);
-
-        mutex_unlock(&file->device->xrcd_tree_mutex);
-        return in_len;
-
-err_copy:
-        if (inode) {
-                if (new_xrcd)
-                        xrcd_table_delete(file->device, inode);
-                atomic_dec(&xrcd->usecnt);
-        }
-
-err_insert_xrcd:
-        idr_remove_uobj(&ib_uverbs_xrcd_idr, &obj->uobject);
-
-err_idr:
-        ib_dealloc_xrcd(xrcd);
-
-err:
-        put_uobj_write(&obj->uobject);
-
-err_tree_mutex_unlock:
-        if (f.file)
-                fdput(f);
-
-        mutex_unlock(&file->device->xrcd_tree_mutex);
-
-        return ret;
-}
-
-ssize_t ib_uverbs_close_xrcd(struct ib_uverbs_file *file,
-                             const char __user *buf, int in_len,
-                             int out_len)
-{
-        struct ib_uverbs_close_xrcd cmd;
-        struct ib_uobject           *uobj;
-        struct ib_xrcd              *xrcd = NULL;
-        struct inode                *inode = NULL;
-        struct ib_uxrcd_object      *obj;
-        int                         live;
-        int                         ret = 0;
-
-        if (copy_from_user(&cmd, buf, sizeof cmd))
-                return -EFAULT;
-
-        mutex_lock(&file->device->xrcd_tree_mutex);
-        uobj = idr_write_uobj(&ib_uverbs_xrcd_idr, cmd.xrcd_handle, file->ucontext);
-        if (!uobj) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        xrcd  = uobj->object;
-        inode = xrcd->inode;
-        obj   = container_of(uobj, struct ib_uxrcd_object, uobject);
-        if (atomic_read(&obj->refcnt)) {
-                put_uobj_write(uobj);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        if (!inode || atomic_dec_and_test(&xrcd->usecnt)) {
-                ret = ib_dealloc_xrcd(uobj->object);
-                if (!ret)
-                        uobj->live = 0;
-        }
-
-        live = uobj->live;
-        if (inode && ret)
-                atomic_inc(&xrcd->usecnt);
-
-        put_uobj_write(uobj);
-
-        if (ret)
-                goto out;
-
-        if (inode && !live)
-                xrcd_table_delete(file->device, inode);
-
-        idr_remove_uobj(&ib_uverbs_xrcd_idr, uobj);
-        mutex_lock(&file->mutex);
-        list_del(&uobj->list);
-        mutex_unlock(&file->mutex);
-
-        put_uobj(uobj);
-        ret = in_len;
-
-out:
-        mutex_unlock(&file->device->xrcd_tree_mutex);
-        return ret;
-}
-
-void ib_uverbs_dealloc_xrcd(struct ib_uverbs_device *dev,
-                            struct ib_xrcd *xrcd)
-{
-        struct inode *inode;
-
-        inode = xrcd->inode;
-        if (inode && !atomic_dec_and_test(&xrcd->usecnt))
-                return;
-
-        ib_dealloc_xrcd(xrcd);
-
-        if (inode)
-                xrcd_table_delete(dev, inode);
-}
-
 ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file,
                          const char __user *buf, int in_len,
                          int out_len)
@@ -947,7 +616,7 @@ ssize_t ib_uverbs_reg_mr(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        init_uobj(uobj, 0, file->ucontext, &mr_lock_class);
+        init_uobj(uobj, 0, file->ucontext, &mr_lock_key);
         down_write(&uobj->mutex);
 
         pd = idr_read_pd(cmd.pd_handle, file->ucontext);
@@ -1115,7 +784,7 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
         if (!obj)
                 return -ENOMEM;
 
-        init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &cq_lock_class);
+        init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &cq_lock_key);
         down_write(&obj->uobject.mutex);
 
         if (cmd.comp_channel >= 0) {
@@ -1383,12 +1052,9 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         struct ib_uverbs_create_qp_resp resp;
         struct ib_udata                 udata;
         struct ib_uqp_object           *obj;
-        struct ib_device               *device;
-        struct ib_pd                   *pd = NULL;
-        struct ib_xrcd                 *xrcd = NULL;
-        struct ib_uobject              *uninitialized_var(xrcd_uobj);
-        struct ib_cq                   *scq = NULL, *rcq = NULL;
-        struct ib_srq                  *srq = NULL;
+        struct ib_pd                   *pd;
+        struct ib_cq                   *scq, *rcq;
+        struct ib_srq                  *srq;
         struct ib_qp                   *qp;
         struct ib_qp_init_attr          attr;
         int ret;
@@ -1399,9 +1065,6 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        if (cmd.qp_type == IB_QPT_RAW_PACKET && !capable(CAP_NET_RAW))
-                return -EPERM;
-
         INIT_UDATA(&udata, buf + sizeof cmd,
                    (unsigned long) cmd.response + sizeof resp,
                    in_len - sizeof cmd, out_len - sizeof resp);
@@ -1410,46 +1073,18 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         if (!obj)
                 return -ENOMEM;
 
-        init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext, &qp_lock_class);
+        init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext, &qp_lock_key);
         down_write(&obj->uevent.uobject.mutex);
 
-        if (cmd.qp_type == IB_QPT_XRC_TGT) {
-                xrcd = idr_read_xrcd(cmd.pd_handle, file->ucontext, &xrcd_uobj);
-                if (!xrcd) {
-                        ret = -EINVAL;
-                        goto err_put;
-                }
-                device = xrcd->device;
-        } else {
-                if (cmd.qp_type == IB_QPT_XRC_INI) {
-                        cmd.max_recv_wr = cmd.max_recv_sge = 0;
-                } else {
-                        if (cmd.is_srq) {
-                                srq = idr_read_srq(cmd.srq_handle, file->ucontext);
-                                if (!srq || srq->srq_type != IB_SRQT_BASIC) {
-                                        ret = -EINVAL;
-                                        goto err_put;
-                                }
-                        }
-
-                        if (cmd.recv_cq_handle != cmd.send_cq_handle) {
-                                rcq = idr_read_cq(cmd.recv_cq_handle, file->ucontext, 0);
-                                if (!rcq) {
-                                        ret = -EINVAL;
-                                        goto err_put;
-                                }
-                        }
-                }
-
-                scq = idr_read_cq(cmd.send_cq_handle, file->ucontext, !!rcq);
-                rcq = rcq ?: scq;
-                pd  = idr_read_pd(cmd.pd_handle, file->ucontext);
-                if (!pd || !scq) {
-                        ret = -EINVAL;
-                        goto err_put;
-                }
+        srq = cmd.is_srq ? idr_read_srq(cmd.srq_handle, file->ucontext) : NULL;
+        pd  = idr_read_pd(cmd.pd_handle, file->ucontext);
+        scq = idr_read_cq(cmd.send_cq_handle, file->ucontext, 0);
+        rcq = cmd.recv_cq_handle == cmd.send_cq_handle ?
+                scq : idr_read_cq(cmd.recv_cq_handle, file->ucontext, 1);
 
-                device = pd->device;
+        if (!pd || !scq || !rcq || (cmd.is_srq && !srq)) {
+                ret = -EINVAL;
+                goto err_put;
         }
 
         attr.event_handler = ib_uverbs_qp_event_handler;
@@ -1457,7 +1092,6 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         attr.send_cq       = scq;
         attr.recv_cq       = rcq;
         attr.srq           = srq;
-        attr.xrcd          = xrcd;
         attr.sq_sig_type   = cmd.sq_sig_all ? IB_SIGNAL_ALL_WR : IB_SIGNAL_REQ_WR;
         attr.qp_type       = cmd.qp_type;
         attr.create_flags  = 0;
@@ -1472,35 +1106,26 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
         INIT_LIST_HEAD(&obj->uevent.event_list);
         INIT_LIST_HEAD(&obj->mcast_list);
 
-        if (cmd.qp_type == IB_QPT_XRC_TGT)
-                qp = ib_create_qp(pd, &attr);
-        else
-                qp = device->create_qp(pd, &attr, &udata);
-
+        qp = pd->device->create_qp(pd, &attr, &udata);
         if (IS_ERR(qp)) {
                 ret = PTR_ERR(qp);
                 goto err_put;
         }
 
-        if (cmd.qp_type != IB_QPT_XRC_TGT) {
-                qp->real_qp       = qp;
-                qp->device        = device;
-                qp->pd            = pd;
-                qp->send_cq       = attr.send_cq;
-                qp->recv_cq       = attr.recv_cq;
-                qp->srq           = attr.srq;
-                qp->event_handler = attr.event_handler;
-                qp->qp_context    = attr.qp_context;
-                qp->qp_type       = attr.qp_type;
-                atomic_set(&qp->usecnt, 0);
-                atomic_inc(&pd->usecnt);
-                atomic_inc(&attr.send_cq->usecnt);
-                if (attr.recv_cq)
-                        atomic_inc(&attr.recv_cq->usecnt);
-                if (attr.srq)
-                        atomic_inc(&attr.srq->usecnt);
-        }
-        qp->uobject = &obj->uevent.uobject;
+        qp->device        = pd->device;
+        qp->pd            = pd;
+        qp->send_cq       = attr.send_cq;
+        qp->recv_cq       = attr.recv_cq;
+        qp->srq           = attr.srq;
+        qp->uobject       = &obj->uevent.uobject;
+        qp->event_handler = attr.event_handler;
+        qp->qp_context    = attr.qp_context;
+        qp->qp_type       = attr.qp_type;
+        atomic_inc(&pd->usecnt);
+        atomic_inc(&attr.send_cq->usecnt);
+        atomic_inc(&attr.recv_cq->usecnt);
+        if (attr.srq)
+                atomic_inc(&attr.srq->usecnt);
 
         obj->uevent.uobject.object = qp;
         ret = idr_add_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject);
@@ -1522,13 +1147,9 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
                 goto err_copy;
         }
 
-        if (xrcd)
-                put_xrcd_read(xrcd_uobj);
-        if (pd)
-                put_pd_read(pd);
-        if (scq)
-                put_cq_read(scq);
-        if (rcq && rcq != scq)
+        put_pd_read(pd);
+        put_cq_read(scq);
+        if (rcq != scq)
                 put_cq_read(rcq);
         if (srq)
                 put_srq_read(srq);
@@ -1550,8 +1171,6 @@ err_destroy:
         ib_destroy_qp(qp);
 
 err_put:
-        if (xrcd)
-                put_xrcd_read(xrcd_uobj);
         if (pd)
                 put_pd_read(pd);
         if (scq)
@@ -1565,98 +1184,6 @@ err_put:
         return ret;
 }
 
-ssize_t ib_uverbs_open_qp(struct ib_uverbs_file *file,
-                          const char __user *buf, int in_len, int out_len)
-{
-        struct ib_uverbs_open_qp        cmd;
-        struct ib_uverbs_create_qp_resp resp;
-        struct ib_udata                 udata;
-        struct ib_uqp_object           *obj;
-        struct ib_xrcd                 *xrcd;
-        struct ib_uobject              *uninitialized_var(xrcd_uobj);
-        struct ib_qp                   *qp;
-        struct ib_qp_open_attr          attr;
-        int ret;
-
-        if (out_len < sizeof resp)
-                return -ENOSPC;
-
-        if (copy_from_user(&cmd, buf, sizeof cmd))
-                return -EFAULT;
-
-        INIT_UDATA(&udata, buf + sizeof cmd,
-                   (unsigned long) cmd.response + sizeof resp,
-                   in_len - sizeof cmd, out_len - sizeof resp);
-
-        obj = kmalloc(sizeof *obj, GFP_KERNEL);
-        if (!obj)
-                return -ENOMEM;
-
-        init_uobj(&obj->uevent.uobject, cmd.user_handle, file->ucontext, &qp_lock_class);
-        down_write(&obj->uevent.uobject.mutex);
-
-        xrcd = idr_read_xrcd(cmd.pd_handle, file->ucontext, &xrcd_uobj);
-        if (!xrcd) {
-                ret = -EINVAL;
-                goto err_put;
-        }
-
-        attr.event_handler = ib_uverbs_qp_event_handler;
-        attr.qp_context    = file;
-        attr.qp_num        = cmd.qpn;
-        attr.qp_type       = cmd.qp_type;
-
-        obj->uevent.events_reported = 0;
-        INIT_LIST_HEAD(&obj->uevent.event_list);
-        INIT_LIST_HEAD(&obj->mcast_list);
-
-        qp = ib_open_qp(xrcd, &attr);
-        if (IS_ERR(qp)) {
-                ret = PTR_ERR(qp);
-                goto err_put;
-        }
-
-        qp->uobject = &obj->uevent.uobject;
-
-        obj->uevent.uobject.object = qp;
-        ret = idr_add_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject);
-        if (ret)
-                goto err_destroy;
-
-        memset(&resp, 0, sizeof resp);
-        resp.qpn       = qp->qp_num;
-        resp.qp_handle = obj->uevent.uobject.id;
-
-        if (copy_to_user((void __user *) (unsigned long) cmd.response,
-                         &resp, sizeof resp)) {
-                ret = -EFAULT;
-                goto err_remove;
-        }
-
-        put_xrcd_read(xrcd_uobj);
-
-        mutex_lock(&file->mutex);
-        list_add_tail(&obj->uevent.uobject.list, &file->ucontext->qp_list);
-        mutex_unlock(&file->mutex);
-
-        obj->uevent.uobject.live = 1;
-
-        up_write(&obj->uevent.uobject.mutex);
-
-        return in_len;
-
-err_remove:
-        idr_remove_uobj(&ib_uverbs_qp_idr, &obj->uevent.uobject);
-
-err_destroy:
-        ib_destroy_qp(qp);
-
-err_put:
-        put_xrcd_read(xrcd_uobj);
-        put_uobj_write(&obj->uevent.uobject);
-        return ret;
-}
-
 ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,
                            const char __user *buf, int in_len,
                            int out_len)
@@ -1757,20 +1284,6 @@ out:
         return ret ? ret : in_len;
 }
 
-/* Remove ignored fields set in the attribute mask */
-static int modify_qp_mask(enum ib_qp_type qp_type, int mask)
-{
-        switch (qp_type) {
-        case IB_QPT_XRC_INI:
-                return mask & ~(IB_QP_MAX_DEST_RD_ATOMIC | IB_QP_MIN_RNR_TIMER);
-        case IB_QPT_XRC_TGT:
-                return mask & ~(IB_QP_MAX_QP_RD_ATOMIC | IB_QP_RETRY_CNT |
-                                IB_QP_RNR_RETRY);
-        default:
-                return mask;
-        }
-}
-
 ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
                             const char __user *buf, int in_len,
                             int out_len)
@@ -1843,12 +1356,7 @@ ssize_t ib_uverbs_modify_qp(struct ib_uverbs_file *file,
         attr->alt_ah_attr.ah_flags          = cmd.alt_dest.is_global ? IB_AH_GRH : 0;
         attr->alt_ah_attr.port_num          = cmd.alt_dest.port_num;
 
-        if (qp->real_qp == qp) {
-                ret = qp->device->modify_qp(qp, attr,
-                        modify_qp_mask(qp->qp_type, cmd.attr_mask), &udata);
-        } else {
-                ret = ib_modify_qp(qp, attr, modify_qp_mask(qp->qp_type, cmd.attr_mask));
-        }
+        ret = qp->device->modify_qp(qp, attr, cmd.attr_mask, &udata);
 
         put_qp_read(qp);
 
@@ -2045,7 +1553,7 @@ ssize_t ib_uverbs_post_send(struct ib_uverbs_file *file,
         }
 
         resp.bad_wr = 0;
-        ret = qp->device->post_send(qp->real_qp, wr, &bad_wr);
+        ret = qp->device->post_send(qp, wr, &bad_wr);
         if (ret)
                 for (next = wr; next; next = next->next) {
                         ++resp.bad_wr;
@@ -2183,7 +1691,7 @@ ssize_t ib_uverbs_post_recv(struct ib_uverbs_file *file,
                 goto out;
 
         resp.bad_wr = 0;
-        ret = qp->device->post_recv(qp->real_qp, wr, &bad_wr);
+        ret = qp->device->post_recv(qp, wr, &bad_wr);
 
         put_qp_read(qp);
 
@@ -2279,7 +1787,7 @@ ssize_t ib_uverbs_create_ah(struct ib_uverbs_file *file,
         if (!uobj)
                 return -ENOMEM;
 
-        init_uobj(uobj, cmd.user_handle, file->ucontext, &ah_lock_class);
+        init_uobj(uobj, cmd.user_handle, file->ucontext, &ah_lock_key);
         down_write(&uobj->mutex);
 
         pd = idr_read_pd(cmd.pd_handle, file->ucontext);
@@ -2396,7 +1904,7 @@ ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        qp = idr_write_qp(cmd.qp_handle, file->ucontext);
+        qp = idr_read_qp(cmd.qp_handle, file->ucontext);
         if (!qp)
                 return -EINVAL;
 
@@ -2425,7 +1933,7 @@ ssize_t ib_uverbs_attach_mcast(struct ib_uverbs_file *file,
                 kfree(mcast);
 
 out_put:
-        put_qp_write(qp);
+        put_qp_read(qp);
 
         return ret ? ret : in_len;
 }
@@ -2443,7 +1951,7 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
         if (copy_from_user(&cmd, buf, sizeof cmd))
                 return -EFAULT;
 
-        qp = idr_write_qp(cmd.qp_handle, file->ucontext);
+        qp = idr_read_qp(cmd.qp_handle, file->ucontext);
         if (!qp)
                 return -EINVAL;
 
@@ -2462,122 +1970,100 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
                 }
 
 out_put:
-        put_qp_write(qp);
+        put_qp_read(qp);
 
         return ret ? ret : in_len;
 }
 
-static int __uverbs_create_xsrq(struct ib_uverbs_file *file,
-                                struct ib_uverbs_create_xsrq *cmd,
-                                struct ib_udata *udata)
+ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file,
+                             const char __user *buf, int in_len,
+                             int out_len)
 {
+        struct ib_uverbs_create_srq      cmd;
         struct ib_uverbs_create_srq_resp resp;
-        struct ib_usrq_object           *obj;
+        struct ib_udata                  udata;
+        struct ib_uevent_object         *obj;
         struct ib_pd                    *pd;
         struct ib_srq                   *srq;
-        struct ib_uobject               *uninitialized_var(xrcd_uobj);
         struct ib_srq_init_attr          attr;
         int ret;
 
-        obj = kmalloc(sizeof *obj, GFP_KERNEL);
-        if (!obj)
-                return -ENOMEM;
+        if (out_len < sizeof resp)
+                return -ENOSPC;
 
-        init_uobj(&obj->uevent.uobject, cmd->user_handle, file->ucontext, &srq_lock_class);
-        down_write(&obj->uevent.uobject.mutex);
+        if (copy_from_user(&cmd, buf, sizeof cmd))
+                return -EFAULT;
 
-        if (cmd->srq_type == IB_SRQT_XRC) {
-                attr.ext.xrc.xrcd  = idr_read_xrcd(cmd->xrcd_handle, file->ucontext, &xrcd_uobj);
-                if (!attr.ext.xrc.xrcd) {
-                        ret = -EINVAL;
-                        goto err;
-                }
+        INIT_UDATA(&udata, buf + sizeof cmd,
+                   (unsigned long) cmd.response + sizeof resp,
+                   in_len - sizeof cmd, out_len - sizeof resp);
 
-                obj->uxrcd = container_of(xrcd_uobj, struct ib_uxrcd_object, uobject);
-                atomic_inc(&obj->uxrcd->refcnt);
+        obj = kmalloc(sizeof *obj, GFP_KERNEL);
+        if (!obj)
+                return -ENOMEM;
 
-                attr.ext.xrc.cq  = idr_read_cq(cmd->cq_handle, file->ucontext, 0);
-                if (!attr.ext.xrc.cq) {
-                        ret = -EINVAL;
-                        goto err_put_xrcd;
-                }
-        }
+        init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &srq_lock_key);
+        down_write(&obj->uobject.mutex);
 
-        pd  = idr_read_pd(cmd->pd_handle, file->ucontext);
+        pd  = idr_read_pd(cmd.pd_handle, file->ucontext);
         if (!pd) {
                 ret = -EINVAL;
-                goto err_put_cq;
+                goto err;
         }
 
         attr.event_handler  = ib_uverbs_srq_event_handler;
         attr.srq_context    = file;
-        attr.srq_type       = cmd->srq_type;
-        attr.attr.max_wr    = cmd->max_wr;
-        attr.attr.max_sge   = cmd->max_sge;
-        attr.attr.srq_limit = cmd->srq_limit;
+        attr.attr.max_wr    = cmd.max_wr;
+        attr.attr.max_sge   = cmd.max_sge;
+        attr.attr.srq_limit = cmd.srq_limit;
 
-        obj->uevent.events_reported = 0;
-        INIT_LIST_HEAD(&obj->uevent.event_list);
+        obj->events_reported     = 0;
+        INIT_LIST_HEAD(&obj->event_list);
 
-        srq = pd->device->create_srq(pd, &attr, udata);
+        srq = pd->device->create_srq(pd, &attr, &udata);
         if (IS_ERR(srq)) {
                 ret = PTR_ERR(srq);
                 goto err_put;
         }
 
-        srq->device        = pd->device;
-        srq->pd            = pd;
-        srq->srq_type      = cmd->srq_type;
-        srq->uobject       = &obj->uevent.uobject;
+        srq->device        = pd->device;
+        srq->pd            = pd;
+        srq->uobject       = &obj->uobject;
         srq->event_handler = attr.event_handler;
         srq->srq_context   = attr.srq_context;
-
-        if (cmd->srq_type == IB_SRQT_XRC) {
-                srq->ext.xrc.cq   = attr.ext.xrc.cq;
-                srq->ext.xrc.xrcd = attr.ext.xrc.xrcd;
-                atomic_inc(&attr.ext.xrc.cq->usecnt);
-                atomic_inc(&attr.ext.xrc.xrcd->usecnt);
-        }
-
         atomic_inc(&pd->usecnt);
         atomic_set(&srq->usecnt, 0);
 
-        obj->uevent.uobject.object = srq;
-        ret = idr_add_uobj(&ib_uverbs_srq_idr, &obj->uevent.uobject);
+        obj->uobject.object = srq;
+        ret = idr_add_uobj(&ib_uverbs_srq_idr, &obj->uobject);
         if (ret)
                 goto err_destroy;
 
         memset(&resp, 0, sizeof resp);
-        resp.srq_handle = obj->uevent.uobject.id;
+        resp.srq_handle = obj->uobject.id;
         resp.max_wr     = attr.attr.max_wr;
         resp.max_sge    = attr.attr.max_sge;
-        if (cmd->srq_type == IB_SRQT_XRC)
-                resp.srqn = srq->ext.xrc.srq_num;
 
-        if (copy_to_user((void __user *) (unsigned long) cmd->response,
+        if (copy_to_user((void __user *) (unsigned long) cmd.response,
                          &resp, sizeof resp)) {
                 ret = -EFAULT;
                 goto err_copy;
         }
 
-        if (cmd->srq_type == IB_SRQT_XRC) {
-                put_uobj_read(xrcd_uobj);
-                put_cq_read(attr.ext.xrc.cq);
-        }
         put_pd_read(pd);
 
         mutex_lock(&file->mutex);
-        list_add_tail(&obj->uevent.uobject.list, &file->ucontext->srq_list);
+        list_add_tail(&obj->uobject.list, &file->ucontext->srq_list);
         mutex_unlock(&file->mutex);
 
-        obj->uevent.uobject.live = 1;
+        obj->uobject.live = 1;
 
-        up_write(&obj->uevent.uobject.mutex);
+        up_write(&obj->uobject.mutex);
 
-        return 0;
+        return in_len;
 
 err_copy:
-        idr_remove_uobj(&ib_uverbs_srq_idr, &obj->uevent.uobject);
+        idr_remove_uobj(&ib_uverbs_srq_idr, &obj->uobject);
 
 err_destroy:
         ib_destroy_srq(srq);
@@ -2585,81 +2071,11 @@ err_destroy:
 err_put:
         put_pd_read(pd);
 
-err_put_cq:
-        if (cmd->srq_type == IB_SRQT_XRC)
-                put_cq_read(attr.ext.xrc.cq);
-
-err_put_xrcd:
-        if (cmd->srq_type == IB_SRQT_XRC) {
-                atomic_dec(&obj->uxrcd->refcnt);
-                put_uobj_read(xrcd_uobj);
-        }
-
 err:
-        put_uobj_write(&obj->uevent.uobject);
+        put_uobj_write(&obj->uobject);
         return ret;
 }
 
-ssize_t ib_uverbs_create_srq(struct ib_uverbs_file *file,
-                             const char __user *buf, int in_len,
-                             int out_len)
-{
-        struct ib_uverbs_create_srq      cmd;
-        struct ib_uverbs_create_xsrq     xcmd;
-        struct ib_uverbs_create_srq_resp resp;
-        struct ib_udata                  udata;
-        int ret;
-
-        if (out_len < sizeof resp)
-                return -ENOSPC;
-
-        if (copy_from_user(&cmd, buf, sizeof cmd))
-                return -EFAULT;
-
-        xcmd.response    = cmd.response;
-        xcmd.user_handle = cmd.user_handle;
-        xcmd.srq_type    = IB_SRQT_BASIC;
-        xcmd.pd_handle   = cmd.pd_handle;
-        xcmd.max_wr      = cmd.max_wr;
-        xcmd.max_sge     = cmd.max_sge;
-        xcmd.srq_limit   = cmd.srq_limit;
-
-        INIT_UDATA(&udata, buf + sizeof cmd,
-                   (unsigned long) cmd.response + sizeof resp,
-                   in_len - sizeof cmd, out_len - sizeof resp);
-
-        ret = __uverbs_create_xsrq(file, &xcmd, &udata);
-        if (ret)
-                return ret;
-
-        return in_len;
-}
-
-ssize_t ib_uverbs_create_xsrq(struct ib_uverbs_file *file,
-                              const char __user *buf, int in_len, int out_len)
-{
-        struct ib_uverbs_create_xsrq     cmd;
-        struct ib_uverbs_create_srq_resp resp;
-        struct ib_udata                  udata;
-        int ret;
-
-        if (out_len < sizeof resp)
-                return -ENOSPC;
-
-        if (copy_from_user(&cmd, buf, sizeof cmd))
-                return -EFAULT;
-
-        INIT_UDATA(&udata, buf + sizeof cmd,
-                   (unsigned long) cmd.response + sizeof resp,
-                   in_len - sizeof cmd, out_len - sizeof resp);
-
-        ret = __uverbs_create_xsrq(file, &cmd, &udata);
-        if (ret)
-                return ret;
-
-        return in_len;
-}
-
 ssize_t ib_uverbs_modify_srq(struct ib_uverbs_file *file,
                              const char __user *buf, int in_len,
                              int out_len)
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 6f2ce6fa98f..56898b6578a 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -72,7 +72,6 @@ DEFINE_IDR(ib_uverbs_ah_idr);
 DEFINE_IDR(ib_uverbs_cq_idr);
 DEFINE_IDR(ib_uverbs_qp_idr);
 DEFINE_IDR(ib_uverbs_srq_idr);
-DEFINE_IDR(ib_uverbs_xrcd_idr);
 
 static DEFINE_SPINLOCK(map_lock);
 static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES);
@@ -108,10 +107,6 @@ static ssize_t (*uverbs_cmd_table[])(struct ib_uverbs_file *file,
         [IB_USER_VERBS_CMD_MODIFY_SRQ]          = ib_uverbs_modify_srq,
         [IB_USER_VERBS_CMD_QUERY_SRQ]           = ib_uverbs_query_srq,
         [IB_USER_VERBS_CMD_DESTROY_SRQ]         = ib_uverbs_destroy_srq,
-        [IB_USER_VERBS_CMD_OPEN_XRCD]           = ib_uverbs_open_xrcd,
-        [IB_USER_VERBS_CMD_CLOSE_XRCD]          = ib_uverbs_close_xrcd,
-        [IB_USER_VERBS_CMD_CREATE_XSRQ]         = ib_uverbs_create_xsrq,
-        [IB_USER_VERBS_CMD_OPEN_QP]             = ib_uverbs_open_qp
 };
 
 static void ib_uverbs_add_one(struct ib_device *device);
@@ -207,12 +202,8 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
                         container_of(uobj, struct ib_uqp_object, uevent.uobject);
 
                 idr_remove_uobj(&ib_uverbs_qp_idr, uobj);
-                if (qp != qp->real_qp) {
-                        ib_close_qp(qp);
-                } else {
-                        ib_uverbs_detach_umcast(qp, uqp);
-                        ib_destroy_qp(qp);
-                }
+                ib_uverbs_detach_umcast(qp, uqp);
+                ib_destroy_qp(qp);
                 ib_uverbs_release_uevent(file, &uqp->uevent);
                 kfree(uqp);
         }
@@ -250,18 +241,6 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
                 kfree(uobj);
         }
 
-        mutex_lock(&file->device->xrcd_tree_mutex);
-        list_for_each_entry_safe(uobj, tmp, &context->xrcd_list, list) {
-                struct ib_xrcd *xrcd = uobj->object;
-                struct ib_uxrcd_object *uxrcd =
-                        container_of(uobj, struct ib_uxrcd_object, uobject);
-
-                idr_remove_uobj(&ib_uverbs_xrcd_idr, uobj);
-                ib_uverbs_dealloc_xrcd(file->device, xrcd);
-                kfree(uxrcd);
-        }
-        mutex_unlock(&file->device->xrcd_tree_mutex);
-
         list_for_each_entry_safe(uobj, tmp, &context->pd_list, list) {
                 struct ib_pd *pd = uobj->object;
 
@@ -541,15 +520,16 @@ struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file,
 struct ib_uverbs_event_file *ib_uverbs_lookup_comp_file(int fd)
 {
         struct ib_uverbs_event_file *ev_file = NULL;
-        struct fd f = fdget(fd);
+        struct file *filp;
 
-        if (!f.file)
+        filp = fget(fd);
+        if (!filp)
                 return NULL;
 
-        if (f.file->f_op != &uverbs_event_fops)
+        if (filp->f_op != &uverbs_event_fops)
                 goto out;
 
-        ev_file = f.file->private_data;
+        ev_file = filp->private_data;
         if (ev_file->is_async) {
                 ev_file = NULL;
                 goto out;
@@ -558,7 +538,7 @@ struct ib_uverbs_event_file *ib_uverbs_lookup_comp_file(int fd)
         kref_get(&ev_file->ref);
 
 out:
-        fdput(f);
+        fput(filp);
         return ev_file;
 }
 
@@ -577,7 +557,8 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
         if (hdr.in_words * 4 != count)
                 return -EINVAL;
 
-        if (hdr.command >= ARRAY_SIZE(uverbs_cmd_table) ||
+        if (hdr.command < 0                             ||
+            hdr.command >= ARRAY_SIZE(uverbs_cmd_table) ||
             !uverbs_cmd_table[hdr.command])
                 return -EINVAL;
 
@@ -760,8 +741,6 @@ static void ib_uverbs_add_one(struct ib_device *device)
 
         kref_init(&uverbs_dev->ref);
         init_completion(&uverbs_dev->comp);
-        uverbs_dev->xrcd_tree = RB_ROOT;
-        mutex_init(&uverbs_dev->xrcd_tree_mutex);
 
         spin_lock(&map_lock);
         devnum = find_first_zero_bit(dev_map, IB_UVERBS_MAX_DEVICES);
@@ -845,7 +824,7 @@ static void ib_uverbs_remove_one(struct ib_device *device)
         kfree(uverbs_dev);
 }
 
-static char *uverbs_devnode(struct device *dev, umode_t *mode)
+static char *uverbs_devnode(struct device *dev, mode_t *mode)
 {
         if (mode)
                 *mode = 0666;
diff --git a/drivers/infiniband/core/uverbs_marshall.c b/drivers/infiniband/core/uverbs_marshall.c
index e7bee46868d..1b1146f8712 100644
--- a/drivers/infiniband/core/uverbs_marshall.c
+++ b/drivers/infiniband/core/uverbs_marshall.c
@@ -30,7 +30,6 @@
  * SOFTWARE.
  */
 
-#include <linux/export.h>
 #include <rdma/ib_marshall.h>
 
 void ib_copy_ah_attr_to_user(struct ib_uverbs_ah_attr *dst,
diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
index 30f199e8579..af7a8b08b2e 100644
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@ -38,9 +38,7 @@
 
 #include <linux/errno.h>
 #include <linux/err.h>
-#include <linux/export.h>
 #include <linux/string.h>
-#include <linux/slab.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_cache.h>
@@ -79,31 +77,6 @@ enum ib_rate mult_to_ib_rate(int mult)
 }
 EXPORT_SYMBOL(mult_to_ib_rate);
 
-int ib_rate_to_mbps(enum ib_rate rate)
-{
-        switch (rate) {
-        case IB_RATE_2_5_GBPS: return 2500;
-        case IB_RATE_5_GBPS:   return 5000;
-        case IB_RATE_10_GBPS:  return 10000;
-        case IB_RATE_20_GBPS:  return 20000;
-        case IB_RATE_30_GBPS:  return 30000;
-        case IB_RATE_40_GBPS:  return 40000;
-        case IB_RATE_60_GBPS:  return 60000;
-        case IB_RATE_80_GBPS:  return 80000;
-        case IB_RATE_120_GBPS: return 120000;
-        case IB_RATE_14_GBPS:  return 14062;
-        case IB_RATE_56_GBPS:  return 56250;
-        case IB_RATE_112_GBPS: return 112500;
-        case IB_RATE_168_GBPS: return 168750;
-        case IB_RATE_25_GBPS:  return 25781;
-        case IB_RATE_100_GBPS: return 103125;
-        case IB_RATE_200_GBPS: return 206250;
-        case IB_RATE_300_GBPS: return 309375;
-        default:               return -1;
-        }
-}
-EXPORT_SYMBOL(ib_rate_to_mbps);
-
 enum rdma_transport_type
 rdma_node_get_transport(enum rdma_node_type node_type)
 {
@@ -277,13 +250,6 @@ struct ib_srq *ib_create_srq(struct ib_pd *pd,
                 srq->uobject       = NULL;
                 srq->event_handler = srq_init_attr->event_handler;
                 srq->srq_context   = srq_init_attr->srq_context;
-                srq->srq_type      = srq_init_attr->srq_type;
-                if (srq->srq_type == IB_SRQT_XRC) {
-                        srq->ext.xrc.xrcd = srq_init_attr->ext.xrc.xrcd;
-                        srq->ext.xrc.cq   = srq_init_attr->ext.xrc.cq;
-                        atomic_inc(&srq->ext.xrc.xrcd->usecnt);
-                        atomic_inc(&srq->ext.xrc.cq->usecnt);
-                }
                 atomic_inc(&pd->usecnt);
                 atomic_set(&srq->usecnt, 0);
         }
@@ -313,29 +279,16 @@ EXPORT_SYMBOL(ib_query_srq);
 int ib_destroy_srq(struct ib_srq *srq)
 {
         struct ib_pd *pd;
-        enum ib_srq_type srq_type;
-        struct ib_xrcd *uninitialized_var(xrcd);
-        struct ib_cq *uninitialized_var(cq);
         int ret;
 
         if (atomic_read(&srq->usecnt))
                 return -EBUSY;
 
         pd = srq->pd;
-        srq_type = srq->srq_type;
-        if (srq_type == IB_SRQT_XRC) {
-                xrcd = srq->ext.xrc.xrcd;
-                cq = srq->ext.xrc.cq;
-        }
 
         ret = srq->device->destroy_srq(srq);
-        if (!ret) {
+        if (!ret)
                 atomic_dec(&pd->usecnt);
-                if (srq_type == IB_SRQT_XRC) {
-                        atomic_dec(&xrcd->usecnt);
-                        atomic_dec(&cq->usecnt);
-                }
-        }
 
         return ret;
 }
@@ -343,123 +296,28 @@ EXPORT_SYMBOL(ib_destroy_srq);
 
 /* Queue pairs */
 
-static void __ib_shared_qp_event_handler(struct ib_event *event, void *context)
-{
-        struct ib_qp *qp = context;
-
-        list_for_each_entry(event->element.qp, &qp->open_list, open_list)
-                event->element.qp->event_handler(event, event->element.qp->qp_context);
-}
-
-static void __ib_insert_xrcd_qp(struct ib_xrcd *xrcd, struct ib_qp *qp)
-{
-        mutex_lock(&xrcd->tgt_qp_mutex);
-        list_add(&qp->xrcd_list, &xrcd->tgt_qp_list);
-        mutex_unlock(&xrcd->tgt_qp_mutex);
-}
-
-static struct ib_qp *__ib_open_qp(struct ib_qp *real_qp,
-                                  void (*event_handler)(struct ib_event *, void *),
-                                  void *qp_context)
-{
-        struct ib_qp *qp;
-        unsigned long flags;
-
-        qp = kzalloc(sizeof *qp, GFP_KERNEL);
-        if (!qp)
-                return ERR_PTR(-ENOMEM);
-
-        qp->real_qp = real_qp;
-        atomic_inc(&real_qp->usecnt);
-        qp->device = real_qp->device;
-        qp->event_handler = event_handler;
-        qp->qp_context = qp_context;
-        qp->qp_num = real_qp->qp_num;
-        qp->qp_type = real_qp->qp_type;
-
-        spin_lock_irqsave(&real_qp->device->event_handler_lock, flags);
-        list_add(&qp->open_list, &real_qp->open_list);
-        spin_unlock_irqrestore(&real_qp->device->event_handler_lock, flags);
-
-        return qp;
-}
-
-struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
-                         struct ib_qp_open_attr *qp_open_attr)
-{
-        struct ib_qp *qp, *real_qp;
-
-        if (qp_open_attr->qp_type != IB_QPT_XRC_TGT)
-                return ERR_PTR(-EINVAL);
-
-        qp = ERR_PTR(-EINVAL);
-        mutex_lock(&xrcd->tgt_qp_mutex);
-        list_for_each_entry(real_qp, &xrcd->tgt_qp_list, xrcd_list) {
-                if (real_qp->qp_num == qp_open_attr->qp_num) {
-                        qp = __ib_open_qp(real_qp, qp_open_attr->event_handler,
-                                          qp_open_attr->qp_context);
-                        break;
-                }
-        }
-        mutex_unlock(&xrcd->tgt_qp_mutex);
-        return qp;
-}
-EXPORT_SYMBOL(ib_open_qp);
-
 struct ib_qp *ib_create_qp(struct ib_pd *pd,
                            struct ib_qp_init_attr *qp_init_attr)
 {
-        struct ib_qp *qp, *real_qp;
-        struct ib_device *device;
+        struct ib_qp *qp;
 
-        device = pd ? pd->device : qp_init_attr->xrcd->device;
-        qp = device->create_qp(pd, qp_init_attr, NULL);
+        qp = pd->device->create_qp(pd, qp_init_attr, NULL);
 
         if (!IS_ERR(qp)) {
-                qp->device     = device;
-                qp->real_qp    = qp;
-                qp->uobject    = NULL;
-                qp->qp_type    = qp_init_attr->qp_type;
-
-                atomic_set(&qp->usecnt, 0);
-                if (qp_init_attr->qp_type == IB_QPT_XRC_TGT) {
-                        qp->event_handler = __ib_shared_qp_event_handler;
-                        qp->qp_context = qp;
-                        qp->pd = NULL;
-                        qp->send_cq = qp->recv_cq = NULL;
-                        qp->srq = NULL;
-                        qp->xrcd = qp_init_attr->xrcd;
-                        atomic_inc(&qp_init_attr->xrcd->usecnt);
-                        INIT_LIST_HEAD(&qp->open_list);
-
-                        real_qp = qp;
-                        qp = __ib_open_qp(real_qp, qp_init_attr->event_handler,
-                                          qp_init_attr->qp_context);
-                        if (!IS_ERR(qp))
-                                __ib_insert_xrcd_qp(qp_init_attr->xrcd, real_qp);
-                        else
-                                real_qp->device->destroy_qp(real_qp);
-                } else {
-                        qp->event_handler = qp_init_attr->event_handler;
-                        qp->qp_context = qp_init_attr->qp_context;
-                        if (qp_init_attr->qp_type == IB_QPT_XRC_INI) {
-                                qp->recv_cq = NULL;
-                                qp->srq = NULL;
-                        } else {
-                                qp->recv_cq = qp_init_attr->recv_cq;
-                                atomic_inc(&qp_init_attr->recv_cq->usecnt);
-                                qp->srq = qp_init_attr->srq;
-                                if (qp->srq)
-                                        atomic_inc(&qp_init_attr->srq->usecnt);
-                        }
-
-                        qp->pd      = pd;
-                        qp->send_cq = qp_init_attr->send_cq;
-                        qp->xrcd    = NULL;
-
-                        atomic_inc(&pd->usecnt);
-                        atomic_inc(&qp_init_attr->send_cq->usecnt);
-                }
+                qp->device        = pd->device;
+                qp->pd            = pd;
+                qp->send_cq       = qp_init_attr->send_cq;
+                qp->recv_cq       = qp_init_attr->recv_cq;
+                qp->srq           = qp_init_attr->srq;
+                qp->uobject       = NULL;
+                qp->event_handler = qp_init_attr->event_handler;
+                qp->qp_context    = qp_init_attr->qp_context;
+                qp->qp_type       = qp_init_attr->qp_type;
+                atomic_inc(&pd->usecnt);
+                atomic_inc(&qp_init_attr->send_cq->usecnt);
+                atomic_inc(&qp_init_attr->recv_cq->usecnt);
+                if (qp_init_attr->srq)
+                        atomic_inc(&qp_init_attr->srq->usecnt);
         }
 
         return qp;
@@ -468,8 +326,8 @@ EXPORT_SYMBOL(ib_create_qp);
 
 static const struct {
         int                     valid;
-        enum ib_qp_attr_mask    req_param[IB_QPT_MAX];
-        enum ib_qp_attr_mask    opt_param[IB_QPT_MAX];
+        enum ib_qp_attr_mask    req_param[IB_QPT_RAW_ETHERTYPE + 1];
+        enum ib_qp_attr_mask    opt_param[IB_QPT_RAW_ETHERTYPE + 1];
 } qp_state_table[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = {
         [IB_QPS_RESET] = {
                 [IB_QPS_RESET] = { .valid = 1 },
@@ -479,19 +337,12 @@ static const struct {
                                 [IB_QPT_UD]  = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_PORT                      |
                                                 IB_QP_QKEY),
-                                [IB_QPT_RAW_PACKET] = IB_QP_PORT,
                                 [IB_QPT_UC]  = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_PORT                      |
                                                 IB_QP_ACCESS_FLAGS),
                                 [IB_QPT_RC]  = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_PORT                      |
                                                 IB_QP_ACCESS_FLAGS),
-                                [IB_QPT_XRC_INI] = (IB_QP_PKEY_INDEX            |
-                                                IB_QP_PORT                      |
-                                                IB_QP_ACCESS_FLAGS),
-                                [IB_QPT_XRC_TGT] = (IB_QP_PKEY_INDEX            |
-                                                IB_QP_PORT                      |
-                                                IB_QP_ACCESS_FLAGS),
                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_QKEY),
                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
@@ -514,12 +365,6 @@ static const struct {
                                 [IB_QPT_RC]  = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_PORT                      |
                                                 IB_QP_ACCESS_FLAGS),
-                                [IB_QPT_XRC_INI] = (IB_QP_PKEY_INDEX            |
-                                                IB_QP_PORT                      |
-                                                IB_QP_ACCESS_FLAGS),
-                                [IB_QPT_XRC_TGT] = (IB_QP_PKEY_INDEX            |
-                                                IB_QP_PORT                      |
-                                                IB_QP_ACCESS_FLAGS),
                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_QKEY),
                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
@@ -539,16 +384,6 @@ static const struct {
                                                 IB_QP_RQ_PSN                    |
                                                 IB_QP_MAX_DEST_RD_ATOMIC        |
                                                 IB_QP_MIN_RNR_TIMER),
-                                [IB_QPT_XRC_INI] = (IB_QP_AV                    |
-                                                IB_QP_PATH_MTU                  |
-                                                IB_QP_DEST_QPN                  |
-                                                IB_QP_RQ_PSN),
-                                [IB_QPT_XRC_TGT] = (IB_QP_AV                    |
-                                                IB_QP_PATH_MTU                  |
-                                                IB_QP_DEST_QPN                  |
-                                                IB_QP_RQ_PSN                    |
-                                                IB_QP_MAX_DEST_RD_ATOMIC        |
-                                                IB_QP_MIN_RNR_TIMER),
                         },
                         .opt_param = {
                                  [IB_QPT_UD]  = (IB_QP_PKEY_INDEX               |
@@ -559,12 +394,6 @@ static const struct {
                                  [IB_QPT_RC]  = (IB_QP_ALT_PATH                 |
                                                  IB_QP_ACCESS_FLAGS             |
                                                  IB_QP_PKEY_INDEX),
-                                 [IB_QPT_XRC_INI] = (IB_QP_ALT_PATH             |
-                                                 IB_QP_ACCESS_FLAGS             |
-                                                 IB_QP_PKEY_INDEX),
-                                 [IB_QPT_XRC_TGT] = (IB_QP_ALT_PATH             |
-                                                 IB_QP_ACCESS_FLAGS             |
-                                                 IB_QP_PKEY_INDEX),
                                  [IB_QPT_SMI] = (IB_QP_PKEY_INDEX               |
                                                  IB_QP_QKEY),
                                  [IB_QPT_GSI] = (IB_QP_PKEY_INDEX               |
@@ -585,13 +414,6 @@ static const struct {
                                                 IB_QP_RNR_RETRY                 |
                                                 IB_QP_SQ_PSN                    |
                                                 IB_QP_MAX_QP_RD_ATOMIC),
-                                [IB_QPT_XRC_INI] = (IB_QP_TIMEOUT               |
-                                                IB_QP_RETRY_CNT                 |
-                                                IB_QP_RNR_RETRY                 |
-                                                IB_QP_SQ_PSN                    |
-                                                IB_QP_MAX_QP_RD_ATOMIC),
-                                [IB_QPT_XRC_TGT] = (IB_QP_TIMEOUT               |
-                                                IB_QP_SQ_PSN),
                                 [IB_QPT_SMI] = IB_QP_SQ_PSN,
                                 [IB_QPT_GSI] = IB_QP_SQ_PSN,
                         },
@@ -607,15 +429,6 @@ static const struct {
                                                  IB_QP_ACCESS_FLAGS             |
                                                  IB_QP_MIN_RNR_TIMER            |
                                                  IB_QP_PATH_MIG_STATE),
-                                 [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE            |
-                                                 IB_QP_ALT_PATH                 |
-                                                 IB_QP_ACCESS_FLAGS             |
-                                                 IB_QP_PATH_MIG_STATE),
-                                 [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE            |
-                                                 IB_QP_ALT_PATH                 |
-                                                 IB_QP_ACCESS_FLAGS             |
-                                                 IB_QP_MIN_RNR_TIMER            |
-                                                 IB_QP_PATH_MIG_STATE),
                                  [IB_QPT_SMI] = (IB_QP_CUR_STATE                |
                                                  IB_QP_QKEY),
                                  [IB_QPT_GSI] = (IB_QP_CUR_STATE                |
@@ -640,15 +453,6 @@ static const struct {
                                                 IB_QP_ALT_PATH                  |
                                                 IB_QP_PATH_MIG_STATE            |
                                                 IB_QP_MIN_RNR_TIMER),
-                                [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE             |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_PATH_MIG_STATE),
-                                [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE             |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_PATH_MIG_STATE            |
-                                                IB_QP_MIN_RNR_TIMER),
                                 [IB_QPT_SMI] = (IB_QP_CUR_STATE                 |
                                                 IB_QP_QKEY),
                                 [IB_QPT_GSI] = (IB_QP_CUR_STATE                 |
@@ -661,8 +465,6 @@ static const struct {
                                 [IB_QPT_UD]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
                                 [IB_QPT_UC]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
                                 [IB_QPT_RC]  = IB_QP_EN_SQD_ASYNC_NOTIFY,
-                                [IB_QPT_XRC_INI] = IB_QP_EN_SQD_ASYNC_NOTIFY,
-                                [IB_QPT_XRC_TGT] = IB_QP_EN_SQD_ASYNC_NOTIFY, /* ??? */
                                 [IB_QPT_SMI] = IB_QP_EN_SQD_ASYNC_NOTIFY,
                                 [IB_QPT_GSI] = IB_QP_EN_SQD_ASYNC_NOTIFY
                         }
@@ -685,15 +487,6 @@ static const struct {
                                                 IB_QP_ACCESS_FLAGS              |
                                                 IB_QP_MIN_RNR_TIMER             |
                                                 IB_QP_PATH_MIG_STATE),
-                                [IB_QPT_XRC_INI] = (IB_QP_CUR_STATE             |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_PATH_MIG_STATE),
-                                [IB_QPT_XRC_TGT] = (IB_QP_CUR_STATE             |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_MIN_RNR_TIMER             |
-                                                IB_QP_PATH_MIG_STATE),
                                 [IB_QPT_SMI] = (IB_QP_CUR_STATE                 |
                                                 IB_QP_QKEY),
                                 [IB_QPT_GSI] = (IB_QP_CUR_STATE                 |
@@ -722,25 +515,6 @@ static const struct {
                                                 IB_QP_PKEY_INDEX                |
                                                 IB_QP_MIN_RNR_TIMER             |
                                                 IB_QP_PATH_MIG_STATE),
-                                [IB_QPT_XRC_INI] = (IB_QP_PORT                  |
-                                                IB_QP_AV                        |
-                                                IB_QP_TIMEOUT                   |
-                                                IB_QP_RETRY_CNT                 |
-                                                IB_QP_RNR_RETRY                 |
-                                                IB_QP_MAX_QP_RD_ATOMIC          |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_PKEY_INDEX                |
-                                                IB_QP_PATH_MIG_STATE),
-                                [IB_QPT_XRC_TGT] = (IB_QP_PORT                  |
-                                                IB_QP_AV                        |
-                                                IB_QP_TIMEOUT                   |
-                                                IB_QP_MAX_DEST_RD_ATOMIC        |
-                                                IB_QP_ALT_PATH                  |
-                                                IB_QP_ACCESS_FLAGS              |
-                                                IB_QP_PKEY_INDEX                |
-                                                IB_QP_MIN_RNR_TIMER             |
-                                                IB_QP_PATH_MIG_STATE),
                                 [IB_QPT_SMI] = (IB_QP_PKEY_INDEX                |
                                                 IB_QP_QKEY),
                                 [IB_QPT_GSI] = (IB_QP_PKEY_INDEX                |
@@ -805,7 +579,7 @@ int ib_modify_qp(struct ib_qp *qp,
                  struct ib_qp_attr *qp_attr,
                  int qp_attr_mask)
 {
-        return qp->device->modify_qp(qp->real_qp, qp_attr, qp_attr_mask, NULL);
+        return qp->device->modify_qp(qp, qp_attr, qp_attr_mask, NULL);
 }
 EXPORT_SYMBOL(ib_modify_qp);
 
@@ -815,59 +589,11 @@ int ib_query_qp(struct ib_qp *qp,
                 struct ib_qp_init_attr *qp_init_attr)
 {
         return qp->device->query_qp ?
-                qp->device->query_qp(qp->real_qp, qp_attr, qp_attr_mask, qp_init_attr) :
+                qp->device->query_qp(qp, qp_attr, qp_attr_mask, qp_init_attr) :
                 -ENOSYS;
 }
 EXPORT_SYMBOL(ib_query_qp);
 
-int ib_close_qp(struct ib_qp *qp)
-{
-        struct ib_qp *real_qp;
-        unsigned long flags;
-
-        real_qp = qp->real_qp;
-        if (real_qp == qp)
-                return -EINVAL;
-
-        spin_lock_irqsave(&real_qp->device->event_handler_lock, flags);
-        list_del(&qp->open_list);
-        spin_unlock_irqrestore(&real_qp->device->event_handler_lock, flags);
-
-        atomic_dec(&real_qp->usecnt);
-        kfree(qp);
-
-        return 0;
-}
-EXPORT_SYMBOL(ib_close_qp);
-
-static int __ib_destroy_shared_qp(struct ib_qp *qp)
-{
-        struct ib_xrcd *xrcd;
-        struct ib_qp *real_qp;
-        int ret;
-
-        real_qp = qp->real_qp;
-        xrcd = real_qp->xrcd;
-
-        mutex_lock(&xrcd->tgt_qp_mutex);
-        ib_close_qp(qp);
-        if (atomic_read(&real_qp->usecnt) == 0)
-                list_del(&real_qp->xrcd_list);
-        else
-                real_qp = NULL;
-        mutex_unlock(&xrcd->tgt_qp_mutex);
-
-        if (real_qp) {
-                ret = ib_destroy_qp(real_qp);
-                if (!ret)
-                        atomic_dec(&xrcd->usecnt);
-                else
-                        __ib_insert_xrcd_qp(xrcd, real_qp);
-        }
-
-        return 0;
-}
-
 int ib_destroy_qp(struct ib_qp *qp)
 {
         struct ib_pd *pd;
@@ -875,25 +601,16 @@ int ib_destroy_qp(struct ib_qp *qp)
         struct ib_srq *srq;
         int ret;
 
-        if (atomic_read(&qp->usecnt))
-                return -EBUSY;
-
-        if (qp->real_qp != qp)
-                return __ib_destroy_shared_qp(qp);
-
-        pd   = qp->pd;
-        scq  = qp->send_cq;
-        rcq  = qp->recv_cq;
-        srq  = qp->srq;
+        pd  = qp->pd;
+        scq = qp->send_cq;
+        rcq = qp->recv_cq;
+        srq = qp->srq;
 
         ret = qp->device->destroy_qp(qp);
         if (!ret) {
-                if (pd)
-                        atomic_dec(&pd->usecnt);
-                if (scq)
-                        atomic_dec(&scq->usecnt);
-                if (rcq)
-                        atomic_dec(&rcq->usecnt);
+                atomic_dec(&pd->usecnt);
+                atomic_dec(&scq->usecnt);
+                atomic_dec(&rcq->usecnt);
                 if (srq)
                         atomic_dec(&srq->usecnt);
         }
@@ -1184,71 +901,22 @@ EXPORT_SYMBOL(ib_dealloc_fmr);
 
 int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 {
-        int ret;
-
         if (!qp->device->attach_mcast)
                 return -ENOSYS;
         if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
                 return -EINVAL;
 
-        ret = qp->device->attach_mcast(qp, gid, lid);
-        if (!ret)
-                atomic_inc(&qp->usecnt);
-        return ret;
+        return qp->device->attach_mcast(qp, gid, lid);
 }
 EXPORT_SYMBOL(ib_attach_mcast);
 
 int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 {
-        int ret;
-
         if (!qp->device->detach_mcast)
                 return -ENOSYS;
         if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
                 return -EINVAL;
 
-        ret = qp->device->detach_mcast(qp, gid, lid);
-        if (!ret)
-                atomic_dec(&qp->usecnt);
-        return ret;
+        return qp->device->detach_mcast(qp, gid, lid);
 }
 EXPORT_SYMBOL(ib_detach_mcast);
-
-struct ib_xrcd *ib_alloc_xrcd(struct ib_device *device)
-{
-        struct ib_xrcd *xrcd;
-
-        if (!device->alloc_xrcd)
-                return ERR_PTR(-ENOSYS);
-
-        xrcd = device->alloc_xrcd(device, NULL, NULL);
-        if (!IS_ERR(xrcd)) {
-                xrcd->device = device;
-                xrcd->inode = NULL;
-                atomic_set(&xrcd->usecnt, 0);
-                mutex_init(&xrcd->tgt_qp_mutex);
-                INIT_LIST_HEAD(&xrcd->tgt_qp_list);
-        }
-
-        return xrcd;
-}
-EXPORT_SYMBOL(ib_alloc_xrcd);
-
-int ib_dealloc_xrcd(struct ib_xrcd *xrcd)
-{
-        struct ib_qp *qp;
-        int ret;
-
-        if (atomic_read(&xrcd->usecnt))
-                return -EBUSY;
-
-        while (!list_empty(&xrcd->tgt_qp_list)) {
-                qp = list_entry(xrcd->tgt_qp_list.next, struct ib_qp, xrcd_list);
-                ret = ib_destroy_qp(qp);
-                if (ret)
-                        return ret;
-        }
-
-        return xrcd->device->dealloc_xrcd(xrcd);
-}
-EXPORT_SYMBOL(ib_dealloc_xrcd);
diff --git a/drivers/infiniband/hw/amso1100/c2.c b/drivers/infiniband/hw/amso1100/c2.c
index 7275e727e0f..444470a28de 100644
--- a/drivers/infiniband/hw/amso1100/c2.c
+++ b/drivers/infiniband/hw/amso1100/c2.c
@@ -800,10 +800,13 @@ static int c2_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         /* Loop thru additional data fragments and queue them */
         if (skb_shinfo(skb)->nr_frags) {
                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                        const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
-                        maplen = skb_frag_size(frag);
-                        mapaddr = skb_frag_dma_map(&c2dev->pcidev->dev, frag,
-                                                   0, maplen, DMA_TO_DEVICE);
+                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                        maplen = frag->size;
+                        mapaddr =
+                            pci_map_page(c2dev->pcidev, frag->page,
+                                         frag->page_offset, maplen,
+                                         PCI_DMA_TODEVICE);
+
                         elem = elem->next;
                         elem->skb = NULL;
                         elem->mapaddr = mapaddr;
@@ -920,7 +923,8 @@ static struct net_device *c2_devinit(struct c2_dev *c2dev,
         return netdev;
 }
 
-static int c2_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
+static int __devinit c2_probe(struct pci_dev *pcidev,
+                              const struct pci_device_id *ent)
 {
         int ret = 0, i;
         unsigned long reg0_start, reg0_flags, reg0_len;
@@ -1190,7 +1194,7 @@ static int c2_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
         return ret;
 }
 
-static void c2_remove(struct pci_dev *pcidev)
+static void __devexit c2_remove(struct pci_dev *pcidev)
 {
         struct c2_dev *c2dev = pci_get_drvdata(pcidev);
         struct net_device *netdev = c2dev->netdev;
@@ -1235,7 +1239,7 @@ static struct pci_driver c2_pci_driver = {
         .name = DRV_NAME,
         .id_table = c2_pci_table,
         .probe = c2_probe,
-        .remove = c2_remove,
+        .remove = __devexit_p(c2_remove),
 };
 
 static int __init c2_init_module(void)
diff --git a/drivers/infiniband/hw/amso1100/c2.h b/drivers/infiniband/hw/amso1100/c2.h
index ba7a1208ff9..6ae698e6877 100644
--- a/drivers/infiniband/hw/amso1100/c2.h
+++ b/drivers/infiniband/hw/amso1100/c2.h
@@ -498,16 +498,16 @@ extern int c2_post_send(struct ib_qp *ibqp, struct ib_send_wr *ib_wr,
                         struct ib_send_wr **bad_wr);
 extern int c2_post_receive(struct ib_qp *ibqp, struct ib_recv_wr *ib_wr,
                            struct ib_recv_wr **bad_wr);
-extern void c2_init_qp_table(struct c2_dev *c2dev);
-extern void c2_cleanup_qp_table(struct c2_dev *c2dev);
+extern void __devinit c2_init_qp_table(struct c2_dev *c2dev);
+extern void __devexit c2_cleanup_qp_table(struct c2_dev *c2dev);
 extern void c2_set_qp_state(struct c2_qp *, int);
 extern struct c2_qp *c2_find_qpn(struct c2_dev *c2dev, int qpn);
 
 /* PDs */
 extern int c2_pd_alloc(struct c2_dev *c2dev, int privileged, struct c2_pd *pd);
 extern void c2_pd_free(struct c2_dev *c2dev, struct c2_pd *pd);
-extern int c2_init_pd_table(struct c2_dev *c2dev);
-extern void c2_cleanup_pd_table(struct c2_dev *c2dev);
+extern int __devinit c2_init_pd_table(struct c2_dev *c2dev);
+extern void __devexit c2_cleanup_pd_table(struct c2_dev *c2dev);
 
 /* CQs */
 extern int c2_init_cq(struct c2_dev *c2dev, int entries,
diff --git a/drivers/infiniband/hw/amso1100/c2_ae.c b/drivers/infiniband/hw/amso1100/c2_ae.c
index 706cf97cbe8..24f9e3a90e8 100644
--- a/drivers/infiniband/hw/amso1100/c2_ae.c
+++ b/drivers/infiniband/hw/amso1100/c2_ae.c
@@ -288,11 +288,6 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index)
                 cm_event.private_data_len =
                         be32_to_cpu(req->private_data_length);
                 cm_event.private_data = req->private_data;
-                /*
-                 * Until ird/ord negotiation via MPAv2 support is added, send
-                 * max supported values
-                 */
-                cm_event.ird = cm_event.ord = 128;
 
                 if (cm_id->event_handler)
                         cm_id->event_handler(cm_id, &cm_event);
@@ -311,7 +306,6 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index)
                 if (cq->ibcq.event_handler)
                         cq->ibcq.event_handler(&ib_event,
                                                cq->ibcq.cq_context);
-                break;
         }
 
         default:
diff --git a/drivers/infiniband/hw/amso1100/c2_intr.c b/drivers/infiniband/hw/amso1100/c2_intr.c
index 8951db4ae29..0ebe4e806b8 100644
--- a/drivers/infiniband/hw/amso1100/c2_intr.c
+++ b/drivers/infiniband/hw/amso1100/c2_intr.c
@@ -183,11 +183,6 @@ static void handle_vq(struct c2_dev *c2dev, u32 mq_index)
         case IW_CM_EVENT_ESTABLISHED:
                 c2_set_qp_state(req->qp,
                                 C2_QP_STATE_RTS);
-                /*
-                 * Until ird/ord negotiation via MPAv2 support is added, send
-                 * max supported values
-                 */
-                cm_event.ird = cm_event.ord = 128;
         case IW_CM_EVENT_CLOSE:
 
                 /*
diff --git a/drivers/infiniband/hw/amso1100/c2_pd.c b/drivers/infiniband/hw/amso1100/c2_pd.c
index f3e81dc357b..161f2a28535 100644
--- a/drivers/infiniband/hw/amso1100/c2_pd.c
+++ b/drivers/infiniband/hw/amso1100/c2_pd.c
@@ -70,7 +70,7 @@ void c2_pd_free(struct c2_dev *c2dev, struct c2_pd *pd)
         spin_unlock(&c2dev->pd_table.lock);
 }
 
-int c2_init_pd_table(struct c2_dev *c2dev)
+int __devinit c2_init_pd_table(struct c2_dev *c2dev)
 {
 
         c2dev->pd_table.last = 0;
@@ -84,7 +84,7 @@ int c2_init_pd_table(struct c2_dev *c2dev)
         return 0;
 }
 
-void c2_cleanup_pd_table(struct c2_dev *c2dev)
+void __devexit c2_cleanup_pd_table(struct c2_dev *c2dev)
 {
         kfree(c2dev->pd_table.table);
 }
diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c
index 07eb3a8067d..f101bb73be6 100644
--- a/drivers/infiniband/hw/amso1100/c2_provider.c
+++ b/drivers/infiniband/hw/amso1100/c2_provider.c
@@ -94,7 +94,7 @@ static int c2_query_port(struct ib_device *ibdev,
         props->pkey_tbl_len = 1;
         props->qkey_viol_cntr = 0;
         props->active_width = 1;
-        props->active_speed = IB_SPEED_SDR;
+        props->active_speed = 1;
 
         return 0;
 }
@@ -753,7 +753,10 @@ static struct net_device *c2_pseudo_netdev_init(struct c2_dev *c2dev)
         memcpy_fromio(netdev->dev_addr, c2dev->kva + C2_REGS_RDMA_ENADDR, 6);
 
         /* Print out the MAC address */
-        pr_debug("%s: MAC %pM\n", netdev->name, netdev->dev_addr);
+        pr_debug("%s: MAC %02X:%02X:%02X:%02X:%02X:%02X\n",
+                netdev->name,
+                netdev->dev_addr[0], netdev->dev_addr[1], netdev->dev_addr[2],
+                netdev->dev_addr[3], netdev->dev_addr[4], netdev->dev_addr[5]);
 
 #if 0
         /* Disable network packets */
diff --git a/drivers/infiniband/hw/amso1100/c2_qp.c b/drivers/infiniband/hw/amso1100/c2_qp.c
index 28cd5cb5185..0d7b6f23caf 100644
--- a/drivers/infiniband/hw/amso1100/c2_qp.c
+++ b/drivers/infiniband/hw/amso1100/c2_qp.c
@@ -1010,13 +1010,13 @@ out:
         return err;
 }
 
-void c2_init_qp_table(struct c2_dev *c2dev)
+void __devinit c2_init_qp_table(struct c2_dev *c2dev)
 {
         spin_lock_init(&c2dev->qp_table.lock);
         idr_init(&c2dev->qp_table.idr);
 }
 
-void c2_cleanup_qp_table(struct c2_dev *c2dev)
+void __devexit c2_cleanup_qp_table(struct c2_dev *c2dev)
 {
         idr_destroy(&c2dev->qp_table.idr);
 }
diff --git a/drivers/infiniband/hw/amso1100/c2_rnic.c b/drivers/infiniband/hw/amso1100/c2_rnic.c
index b7c98699005..8c81992fa6d 100644
--- a/drivers/infiniband/hw/amso1100/c2_rnic.c
+++ b/drivers/infiniband/hw/amso1100/c2_rnic.c
@@ -439,10 +439,10 @@ static int c2_rnic_close(struct c2_dev *c2dev)
 
 /*
  * Called by c2_probe to initialize the RNIC. This principally
- * involves initializing the various limits and resource pools that
+ * involves initalizing the various limits and resouce pools that
  * comprise the RNIC instance.
  */
-int c2_rnic_init(struct c2_dev *c2dev)
+int __devinit c2_rnic_init(struct c2_dev *c2dev)
 {
         int err;
         u32 qsize, msgsize;
@@ -611,7 +611,7 @@ int c2_rnic_init(struct c2_dev *c2dev)
 /*
  * Called by c2_remove to cleanup the RNIC resources.
  */
-void c2_rnic_term(struct c2_dev *c2dev)
+void __devexit c2_rnic_term(struct c2_dev *c2dev)
 {
 
         /* Close the open adapter instance */
diff --git a/drivers/infiniband/hw/cxgb3/Makefile b/drivers/infiniband/hw/cxgb3/Makefile
index 2761364185a..621619c794e 100644
--- a/drivers/infiniband/hw/cxgb3/Makefile
+++ b/drivers/infiniband/hw/cxgb3/Makefile
@@ -1,4 +1,4 @@
-ccflags-y := -Idrivers/net/ethernet/chelsio/cxgb3
+ccflags-y := -Idrivers/net/cxgb3
 
 obj-$(CONFIG_INFINIBAND_CXGB3) += iw_cxgb3.o
 
diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c
index 3e094cd6a0e..e55ce7a428b 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c
@@ -128,8 +128,9 @@ static void stop_ep_timer(struct iwch_ep *ep)
 {
         PDBG("%s ep %p\n", __func__, ep);
         if (!timer_pending(&ep->timer)) {
-                WARN(1, "%s timer stopped when its not running!  ep %p state %u\n",
+                printk(KERN_ERR "%s timer stopped when its not running!  ep %p state %u\n",
                         __func__, ep, ep->com.state);
+                WARN_ON(1);
                 return;
         }
         del_timer_sync(&ep->timer);
@@ -752,11 +753,6 @@ static void connect_request_upcall(struct iwch_ep *ep)
         event.private_data_len = ep->plen;
         event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
         event.provider_data = ep;
-        /*
-         * Until ird/ord negotiation via MPAv2 support is added, send max
-         * supported values
-         */
-        event.ird = event.ord = 8;
         if (state_read(&ep->parent_ep->com) != DEAD) {
                 get_ep(&ep->com);
                 ep->parent_ep->com.cm_id->event_handler(
@@ -774,11 +770,6 @@ static void established_upcall(struct iwch_ep *ep)
         PDBG("%s ep %p\n", __func__, ep);
         memset(&event, 0, sizeof(event));
         event.event = IW_CM_EVENT_ESTABLISHED;
-        /*
-         * Until ird/ord negotiation via MPAv2 support is added, send max
-         * supported values
-         */
-        event.ird = event.ord = 8;
         if (ep->com.cm_id) {
                 PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid);
                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
@@ -1337,6 +1328,7 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
         struct iwch_ep *child_ep, *parent_ep = ctx;
         struct cpl_pass_accept_req *req = cplhdr(skb);
         unsigned int hwtid = GET_TID(req);
+        struct neighbour *neigh;
         struct dst_entry *dst;
         struct l2t_entry *l2t;
         struct rtable *rt;
@@ -1373,7 +1365,10 @@ static int pass_accept_req(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
                 goto reject;
         }
         dst = &rt->dst;
-        l2t = t3_l2t_get(tdev, dst, NULL, &req->peer_ip);
+        rcu_read_lock();
+        neigh = dst_get_neighbour(dst);
+        l2t = t3_l2t_get(tdev, neigh, neigh->dev);
+        rcu_read_unlock();
         if (!l2t) {
                 printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
                        __func__);
@@ -1679,7 +1674,7 @@ static int close_con_rpl(struct t3cdev *tdev, struct sk_buff *skb, void *ctx)
  * T3A does 3 things when a TERM is received:
  * 1) send up a CPL_RDMA_TERMINATE message with the TERM packet
  * 2) generate an async event on the QP with the TERMINATE opcode
- * 3) post a TERMINATE opcode cqe into the associated CQ.
+ * 3) post a TERMINATE opcde cqe into the associated CQ.
  *
  * For (1), we save the message in the qp for later consumer consumption.
  * For (2), we move the QP into TERMINATE, post a QP event and disconnect.
@@ -1755,8 +1750,9 @@ static void ep_timeout(unsigned long arg)
                 __state_set(&ep->com, ABORTING);
                 break;
         default:
-                WARN(1, "%s unexpected state ep %p state %u\n",
+                printk(KERN_ERR "%s unexpected state ep %p state %u\n",
                         __func__, ep, ep->com.state);
+                WARN_ON(1);
                 abort = 0;
         }
         spin_unlock_irqrestore(&ep->com.lock, flags);
@@ -1883,6 +1879,7 @@ static int is_loopback_dst(struct iw_cm_id *cm_id)
 int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 {
         struct iwch_dev *h = to_iwch_dev(cm_id->device);
+        struct neighbour *neigh;
         struct iwch_ep *ep;
         struct rtable *rt;
         int err = 0;
@@ -1940,8 +1937,13 @@ int iwch_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 goto fail3;
         }
         ep->dst = &rt->dst;
-        ep->l2t = t3_l2t_get(ep->com.tdev, ep->dst, NULL,
-                             &cm_id->remote_addr.sin_addr.s_addr);
+
+        rcu_read_lock();
+        neigh = dst_get_neighbour(ep->dst);
+
+        /* get a l2t entry */
+        ep->l2t = t3_l2t_get(ep->com.tdev, neigh, neigh->dev);
+        rcu_read_unlock();
         if (!ep->l2t) {
                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
                 err = -ENOMEM;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_ev.c b/drivers/infiniband/hw/cxgb3/iwch_ev.c
index abcc9e76962..71e0d845da3 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_ev.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_ev.c
@@ -46,7 +46,6 @@ static void post_qp_event(struct iwch_dev *rnicp, struct iwch_cq *chp,
         struct ib_event event;
         struct iwch_qp_attributes attrs;
         struct iwch_qp *qhp;
-        unsigned long flag;
 
         spin_lock(&rnicp->lock);
         qhp = get_qhp(rnicp, CQE_QPID(rsp_msg->cqe));
@@ -95,9 +94,7 @@ static void post_qp_event(struct iwch_dev *rnicp, struct iwch_cq *chp,
         if (qhp->ibqp.event_handler)
                 (*qhp->ibqp.event_handler)(&event, qhp->ibqp.qp_context);
 
-        spin_lock_irqsave(&chp->comp_handler_lock, flag);
         (*chp->ibcq.comp_handler)(&chp->ibcq, chp->ibcq.cq_context);
-        spin_unlock_irqrestore(&chp->comp_handler_lock, flag);
 
         if (atomic_dec_and_test(&qhp->refcnt))
                 wake_up(&qhp->wait);
@@ -110,7 +107,6 @@ void iwch_ev_dispatch(struct cxio_rdev *rdev_p, struct sk_buff *skb)
         struct iwch_cq *chp;
         struct iwch_qp *qhp;
         u32 cqid = RSPQ_CQID(rsp_msg);
-        unsigned long flag;
 
         rnicp = (struct iwch_dev *) rdev_p->ulp;
         spin_lock(&rnicp->lock);
@@ -174,9 +170,7 @@ void iwch_ev_dispatch(struct cxio_rdev *rdev_p, struct sk_buff *skb)
                  */
                 if (qhp->ep && SQ_TYPE(rsp_msg->cqe))
                         dst_confirm(qhp->ep->dst);
-                spin_lock_irqsave(&chp->comp_handler_lock, flag);
                 (*chp->ibcq.comp_handler)(&chp->ibcq, chp->ibcq.cq_context);
-                spin_unlock_irqrestore(&chp->comp_handler_lock, flag);
                 break;
 
         case TPT_ERR_STAG:
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index 0bdf09aa6f4..c7d9411f295 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -190,7 +190,6 @@ static struct ib_cq *iwch_create_cq(struct ib_device *ibdev, int entries, int ve
         chp->rhp = rhp;
         chp->ibcq.cqe = 1 << chp->cq.size_log2;
         spin_lock_init(&chp->lock);
-        spin_lock_init(&chp->comp_handler_lock);
         atomic_set(&chp->refcnt, 1);
         init_waitqueue_head(&chp->wait);
         if (insert_handle(rhp, &rhp->cqidr, chp, chp->cq.cqid)) {
@@ -1227,7 +1226,7 @@ static int iwch_query_port(struct ib_device *ibdev,
         props->gid_tbl_len = 1;
         props->pkey_tbl_len = 1;
         props->active_width = 2;
-        props->active_speed = IB_SPEED_DDR;
+        props->active_speed = 2;
         props->max_msg_sz = -1;
 
         return 0;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.h b/drivers/infiniband/hw/cxgb3/iwch_provider.h
index 87c14b0c5ac..9a342c9b220 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.h
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.h
@@ -103,7 +103,6 @@ struct iwch_cq {
         struct iwch_dev *rhp;
         struct t3_cq cq;
         spinlock_t lock;
-        spinlock_t comp_handler_lock;
         atomic_t refcnt;
         wait_queue_head_t wait;
         u32 __user *user_rptr_addr;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_qp.c b/drivers/infiniband/hw/cxgb3/iwch_qp.c
index 6de8463f453..ecd313f359a 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_qp.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_qp.c
@@ -803,7 +803,7 @@ int iwch_post_terminate(struct iwch_qp *qhp, struct respQ_msg_t *rsp_msg)
  * Assumes qhp lock is held.
  */
 static void __flush_qp(struct iwch_qp *qhp, struct iwch_cq *rchp,
-                                struct iwch_cq *schp)
+                                struct iwch_cq *schp, unsigned long *flag)
 {
         int count;
         int flushed;
@@ -812,44 +812,38 @@ static void __flush_qp(struct iwch_qp *qhp, struct iwch_cq *rchp,
         PDBG("%s qhp %p rchp %p schp %p\n", __func__, qhp, rchp, schp);
         /* take a ref on the qhp since we must release the lock */
         atomic_inc(&qhp->refcnt);
-        spin_unlock(&qhp->lock);
+        spin_unlock_irqrestore(&qhp->lock, *flag);
 
         /* locking hierarchy: cq lock first, then qp lock. */
-        spin_lock(&rchp->lock);
+        spin_lock_irqsave(&rchp->lock, *flag);
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&rchp->cq);
         cxio_count_rcqes(&rchp->cq, &qhp->wq, &count);
         flushed = cxio_flush_rq(&qhp->wq, &rchp->cq, count);
         spin_unlock(&qhp->lock);
-        spin_unlock(&rchp->lock);
-        if (flushed) {
-                spin_lock(&rchp->comp_handler_lock);
+        spin_unlock_irqrestore(&rchp->lock, *flag);
+        if (flushed)
                 (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock(&rchp->comp_handler_lock);
-        }
 
         /* locking hierarchy: cq lock first, then qp lock. */
-        spin_lock(&schp->lock);
+        spin_lock_irqsave(&schp->lock, *flag);
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&schp->cq);
         cxio_count_scqes(&schp->cq, &qhp->wq, &count);
         flushed = cxio_flush_sq(&qhp->wq, &schp->cq, count);
         spin_unlock(&qhp->lock);
-        spin_unlock(&schp->lock);
-        if (flushed) {
-                spin_lock(&schp->comp_handler_lock);
+        spin_unlock_irqrestore(&schp->lock, *flag);
+        if (flushed)
                 (*schp->ibcq.comp_handler)(&schp->ibcq, schp->ibcq.cq_context);
-                spin_unlock(&schp->comp_handler_lock);
-        }
 
         /* deref */
         if (atomic_dec_and_test(&qhp->refcnt))
                 wake_up(&qhp->wait);
 
-        spin_lock(&qhp->lock);
+        spin_lock_irqsave(&qhp->lock, *flag);
 }
 
-static void flush_qp(struct iwch_qp *qhp)
+static void flush_qp(struct iwch_qp *qhp, unsigned long *flag)
 {
         struct iwch_cq *rchp, *schp;
 
@@ -859,19 +853,15 @@ static void flush_qp(struct iwch_qp *qhp)
         if (qhp->ibqp.uobject) {
                 cxio_set_wq_in_error(&qhp->wq);
                 cxio_set_cq_in_error(&rchp->cq);
-                spin_lock(&rchp->comp_handler_lock);
                 (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock(&rchp->comp_handler_lock);
                 if (schp != rchp) {
                         cxio_set_cq_in_error(&schp->cq);
-                        spin_lock(&schp->comp_handler_lock);
                         (*schp->ibcq.comp_handler)(&schp->ibcq,
                                                    schp->ibcq.cq_context);
-                        spin_unlock(&schp->comp_handler_lock);
                 }
                 return;
         }
-        __flush_qp(qhp, rchp, schp);
+        __flush_qp(qhp, rchp, schp, flag);
 }
 
 
@@ -1030,7 +1020,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                         break;
                 case IWCH_QP_STATE_ERROR:
                         qhp->attr.state = IWCH_QP_STATE_ERROR;
-                        flush_qp(qhp);
+                        flush_qp(qhp, &flag);
                         break;
                 default:
                         ret = -EINVAL;
@@ -1078,7 +1068,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                 }
                 switch (attrs->next_state) {
                         case IWCH_QP_STATE_IDLE:
-                                flush_qp(qhp);
+                                flush_qp(qhp, &flag);
                                 qhp->attr.state = IWCH_QP_STATE_IDLE;
                                 qhp->attr.llp_stream_handle = NULL;
                                 put_ep(&qhp->ep->com);
@@ -1132,7 +1122,7 @@ err:
         free=1;
         wake_up(&qhp->wait);
         BUG_ON(!ep);
-        flush_qp(qhp);
+        flush_qp(qhp, &flag);
 out:
         spin_unlock_irqrestore(&qhp->lock, flag);
 
diff --git a/drivers/infiniband/hw/cxgb4/Makefile b/drivers/infiniband/hw/cxgb4/Makefile
index e11cf729994..cd20b1342ae 100644
--- a/drivers/infiniband/hw/cxgb4/Makefile
+++ b/drivers/infiniband/hw/cxgb4/Makefile
@@ -1,5 +1,5 @@
-ccflags-y := -Idrivers/net/ethernet/chelsio/cxgb4
+ccflags-y := -Idrivers/net/cxgb4
 
 obj-$(CONFIG_INFINIBAND_CXGB4) += iw_cxgb4.o
 
-iw_cxgb4-y :=  device.o cm.o provider.o mem.o cq.o qp.o resource.o ev.o id_table.o
+iw_cxgb4-y :=  device.o cm.o provider.o mem.o cq.o qp.o resource.o ev.o
diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c
index c13745cde7f..daa93e942e1 100644
--- a/drivers/infiniband/hw/cxgb4/cm.c
+++ b/drivers/infiniband/hw/cxgb4/cm.c
@@ -38,12 +38,10 @@
 #include <linux/inetdevice.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
-#include <linux/if_vlan.h>
 
 #include <net/neighbour.h>
 #include <net/netevent.h>
 #include <net/route.h>
-#include <net/tcp.h>
 
 #include "iw_cxgb4.h"
 
@@ -63,14 +61,6 @@ static char *states[] = {
         NULL,
 };
 
-static int nocong;
-module_param(nocong, int, 0644);
-MODULE_PARM_DESC(nocong, "Turn of congestion control (default=0)");
-
-static int enable_ecn;
-module_param(enable_ecn, int, 0644);
-MODULE_PARM_DESC(enable_ecn, "Enable ECN (default=0/disabled)");
-
 static int dack_mode = 1;
 module_param(dack_mode, int, 0644);
 MODULE_PARM_DESC(dack_mode, "Delayed ack mode (default=1)");
@@ -113,8 +103,7 @@ MODULE_PARM_DESC(ep_timeout_secs, "CM Endpoint operation timeout "
 static int mpa_rev = 1;
 module_param(mpa_rev, int, 0644);
 MODULE_PARM_DESC(mpa_rev, "MPA Revision, 0 supports amso1100, "
-                "1 is RFC0544 spec compliant, 2 is IETF MPA Peer Connect Draft"
-                " compliant (default=1)");
+                 "1 is spec compliant. (default=1)");
 
 static int markers_enabled;
 module_param(markers_enabled, int, 0644);
@@ -161,8 +150,9 @@ static void stop_ep_timer(struct c4iw_ep *ep)
 {
         PDBG("%s ep %p\n", __func__, ep);
         if (!timer_pending(&ep->timer)) {
-                WARN(1, "%s timer stopped when its not running! "
+                printk(KERN_ERR "%s timer stopped when its not running! "
                        "ep %p state %u\n", __func__, ep, ep->com.state);
+                WARN_ON(1);
                 return;
         }
         del_timer_sync(&ep->timer);
@@ -275,7 +265,6 @@ void _c4iw_free_ep(struct kref *kref)
                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
                 dst_release(ep->dst);
                 cxgb4_l2t_release(ep->l2t);
-                remove_handle(ep->com.dev, &ep->com.dev->hwtid_idr, ep->hwtid);
         }
         kfree(ep);
 }
@@ -452,50 +441,6 @@ static int send_abort(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 }
 
-#define VLAN_NONE 0xfff
-#define FILTER_SEL_VLAN_NONE 0xffff
-#define FILTER_SEL_WIDTH_P_FC (3+1) /* port uses 3 bits, FCoE one bit */
-#define FILTER_SEL_WIDTH_VIN_P_FC \
-        (6 + 7 + FILTER_SEL_WIDTH_P_FC) /* 6 bits are unused, VF uses 7 bits*/
-#define FILTER_SEL_WIDTH_TAG_P_FC \
-        (3 + FILTER_SEL_WIDTH_VIN_P_FC) /* PF uses 3 bits */
-#define FILTER_SEL_WIDTH_VLD_TAG_P_FC (1 + FILTER_SEL_WIDTH_TAG_P_FC)
-
-static unsigned int select_ntuple(struct c4iw_dev *dev, struct dst_entry *dst,
-                                  struct l2t_entry *l2t)
-{
-        unsigned int ntuple = 0;
-        u32 viid;
-
-        switch (dev->rdev.lldi.filt_mode) {
-
-        /* default filter mode */
-        case HW_TPL_FR_MT_PR_IV_P_FC:
-                if (l2t->vlan == VLAN_NONE)
-                        ntuple |= FILTER_SEL_VLAN_NONE << FILTER_SEL_WIDTH_P_FC;
-                else {
-                        ntuple |= l2t->vlan << FILTER_SEL_WIDTH_P_FC;
-                        ntuple |= 1 << FILTER_SEL_WIDTH_VLD_TAG_P_FC;
-                }
-                ntuple |= l2t->lport << S_PORT | IPPROTO_TCP <<
-                          FILTER_SEL_WIDTH_VLD_TAG_P_FC;
-                break;
-        case HW_TPL_FR_MT_PR_OV_P_FC: {
-                viid = cxgb4_port_viid(l2t->neigh->dev);
-
-                ntuple |= FW_VIID_VIN_GET(viid) << FILTER_SEL_WIDTH_P_FC;
-                ntuple |= FW_VIID_PFN_GET(viid) << FILTER_SEL_WIDTH_VIN_P_FC;
-                ntuple |= FW_VIID_VIVLD_GET(viid) << FILTER_SEL_WIDTH_TAG_P_FC;
-                ntuple |= l2t->lport << S_PORT | IPPROTO_TCP <<
-                          FILTER_SEL_WIDTH_VLD_TAG_P_FC;
-                break;
-        }
-        default:
-                break;
-        }
-        return ntuple;
-}
-
 static int send_connect(struct c4iw_ep *ep)
 {
         struct cpl_act_open_req *req;
@@ -518,8 +463,7 @@ static int send_connect(struct c4iw_ep *ep)
 
         cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
         wscale = compute_wscale(rcv_win);
-        opt0 = (nocong ? NO_CONG(1) : 0) |
-               KEEP_ALIVE(1) |
+        opt0 = KEEP_ALIVE(1) |
                DELACK(1) |
                WND_SCALE(wscale) |
                MSS_IDX(mtu_idx) |
@@ -530,7 +474,6 @@ static int send_connect(struct c4iw_ep *ep)
                ULP_MODE(ULP_MODE_TCPDDP) |
                RCV_BUFSIZ(rcv_win>>10);
         opt2 = RX_CHANNEL(0) |
-               CCTRL_ECN(enable_ecn) |
                RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid);
         if (enable_tcp_timestamps)
                 opt2 |= TSTAMPS_EN(1);
@@ -549,27 +492,22 @@ static int send_connect(struct c4iw_ep *ep)
         req->local_ip = ep->com.local_addr.sin_addr.s_addr;
         req->peer_ip = ep->com.remote_addr.sin_addr.s_addr;
         req->opt0 = cpu_to_be64(opt0);
-        req->params = cpu_to_be32(select_ntuple(ep->com.dev, ep->dst, ep->l2t));
+        req->params = 0;
         req->opt2 = cpu_to_be32(opt2);
-        set_bit(ACT_OPEN_REQ, &ep->com.history);
         return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
 }
 
-static void send_mpa_req(struct c4iw_ep *ep, struct sk_buff *skb,
-                u8 mpa_rev_to_use)
+static void send_mpa_req(struct c4iw_ep *ep, struct sk_buff *skb)
 {
         int mpalen, wrlen;
         struct fw_ofld_tx_data_wr *req;
         struct mpa_message *mpa;
-        struct mpa_v2_conn_params mpa_v2_params;
 
         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 
         BUG_ON(skb_cloned(skb));
 
         mpalen = sizeof(*mpa) + ep->plen;
-        if (mpa_rev_to_use == 2)
-                mpalen += sizeof(struct mpa_v2_conn_params);
         wrlen = roundup(mpalen + sizeof *req, 16);
         skb = get_skb(skb, wrlen, GFP_KERNEL);
         if (!skb) {
@@ -595,41 +533,12 @@ static void send_mpa_req(struct c4iw_ep *ep, struct sk_buff *skb,
         mpa = (struct mpa_message *)(req + 1);
         memcpy(mpa->key, MPA_KEY_REQ, sizeof(mpa->key));
         mpa->flags = (crc_enabled ? MPA_CRC : 0) |
-                     (markers_enabled ? MPA_MARKERS : 0) |
-                     (mpa_rev_to_use == 2 ? MPA_ENHANCED_RDMA_CONN : 0);
+                     (markers_enabled ? MPA_MARKERS : 0);
         mpa->private_data_size = htons(ep->plen);
-        mpa->revision = mpa_rev_to_use;
-        if (mpa_rev_to_use == 1) {
-                ep->tried_with_mpa_v1 = 1;
-                ep->retry_with_mpa_v1 = 0;
-        }
-
-        if (mpa_rev_to_use == 2) {
-                mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
-                                               sizeof (struct mpa_v2_conn_params));
-                mpa_v2_params.ird = htons((u16)ep->ird);
-                mpa_v2_params.ord = htons((u16)ep->ord);
-
-                if (peer2peer) {
-                        mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
-                        if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
-                                mpa_v2_params.ord |=
-                                        htons(MPA_V2_RDMA_WRITE_RTR);
-                        else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
-                                mpa_v2_params.ord |=
-                                        htons(MPA_V2_RDMA_READ_RTR);
-                }
-                memcpy(mpa->private_data, &mpa_v2_params,
-                       sizeof(struct mpa_v2_conn_params));
+        mpa->revision = mpa_rev;
 
-                if (ep->plen)
-                        memcpy(mpa->private_data +
-                               sizeof(struct mpa_v2_conn_params),
-                               ep->mpa_pkt + sizeof(*mpa), ep->plen);
-        } else
-                if (ep->plen)
-                        memcpy(mpa->private_data,
-                                        ep->mpa_pkt + sizeof(*mpa), ep->plen);
+        if (ep->plen)
+                memcpy(mpa->private_data, ep->mpa_pkt + sizeof(*mpa), ep->plen);
 
         /*
          * Reference the mpa skb.  This ensures the data area
@@ -653,13 +562,10 @@ static int send_mpa_reject(struct c4iw_ep *ep, const void *pdata, u8 plen)
         struct fw_ofld_tx_data_wr *req;
         struct mpa_message *mpa;
         struct sk_buff *skb;
-        struct mpa_v2_conn_params mpa_v2_params;
 
         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 
         mpalen = sizeof(*mpa) + plen;
-        if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
-                mpalen += sizeof(struct mpa_v2_conn_params);
         wrlen = roundup(mpalen + sizeof *req, 16);
 
         skb = get_skb(NULL, wrlen, GFP_KERNEL);
@@ -689,29 +595,8 @@ static int send_mpa_reject(struct c4iw_ep *ep, const void *pdata, u8 plen)
         mpa->flags = MPA_REJECT;
         mpa->revision = mpa_rev;
         mpa->private_data_size = htons(plen);
-
-        if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
-                mpa->flags |= MPA_ENHANCED_RDMA_CONN;
-                mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
-                                               sizeof (struct mpa_v2_conn_params));
-                mpa_v2_params.ird = htons(((u16)ep->ird) |
-                                          (peer2peer ? MPA_V2_PEER2PEER_MODEL :
-                                           0));
-                mpa_v2_params.ord = htons(((u16)ep->ord) | (peer2peer ?
-                                          (p2p_type ==
-                                           FW_RI_INIT_P2PTYPE_RDMA_WRITE ?
-                                           MPA_V2_RDMA_WRITE_RTR : p2p_type ==
-                                           FW_RI_INIT_P2PTYPE_READ_REQ ?
-                                           MPA_V2_RDMA_READ_RTR : 0) : 0));
-                memcpy(mpa->private_data, &mpa_v2_params,
-                       sizeof(struct mpa_v2_conn_params));
-
-                if (ep->plen)
-                        memcpy(mpa->private_data +
-                               sizeof(struct mpa_v2_conn_params), pdata, plen);
-        } else
-                if (plen)
-                        memcpy(mpa->private_data, pdata, plen);
+        if (plen)
+                memcpy(mpa->private_data, pdata, plen);
 
         /*
          * Reference the mpa skb again.  This ensures the data area
@@ -732,13 +617,10 @@ static int send_mpa_reply(struct c4iw_ep *ep, const void *pdata, u8 plen)
         struct fw_ofld_tx_data_wr *req;
         struct mpa_message *mpa;
         struct sk_buff *skb;
-        struct mpa_v2_conn_params mpa_v2_params;
 
         PDBG("%s ep %p tid %u pd_len %d\n", __func__, ep, ep->hwtid, ep->plen);
 
         mpalen = sizeof(*mpa) + plen;
-        if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn)
-                mpalen += sizeof(struct mpa_v2_conn_params);
         wrlen = roundup(mpalen + sizeof *req, 16);
 
         skb = get_skb(NULL, wrlen, GFP_KERNEL);
@@ -767,36 +649,10 @@ static int send_mpa_reply(struct c4iw_ep *ep, const void *pdata, u8 plen)
         memcpy(mpa->key, MPA_KEY_REP, sizeof(mpa->key));
         mpa->flags = (ep->mpa_attr.crc_enabled ? MPA_CRC : 0) |
                      (markers_enabled ? MPA_MARKERS : 0);
-        mpa->revision = ep->mpa_attr.version;
+        mpa->revision = mpa_rev;
         mpa->private_data_size = htons(plen);
-
-        if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
-                mpa->flags |= MPA_ENHANCED_RDMA_CONN;
-                mpa->private_data_size = htons(ntohs(mpa->private_data_size) +
-                                               sizeof (struct mpa_v2_conn_params));
-                mpa_v2_params.ird = htons((u16)ep->ird);
-                mpa_v2_params.ord = htons((u16)ep->ord);
-                if (peer2peer && (ep->mpa_attr.p2p_type !=
-                                        FW_RI_INIT_P2PTYPE_DISABLED)) {
-                        mpa_v2_params.ird |= htons(MPA_V2_PEER2PEER_MODEL);
-
-                        if (p2p_type == FW_RI_INIT_P2PTYPE_RDMA_WRITE)
-                                mpa_v2_params.ord |=
-                                        htons(MPA_V2_RDMA_WRITE_RTR);
-                        else if (p2p_type == FW_RI_INIT_P2PTYPE_READ_REQ)
-                                mpa_v2_params.ord |=
-                                        htons(MPA_V2_RDMA_READ_RTR);
-                }
-
-                memcpy(mpa->private_data, &mpa_v2_params,
-                       sizeof(struct mpa_v2_conn_params));
-
-                if (ep->plen)
-                        memcpy(mpa->private_data +
-                               sizeof(struct mpa_v2_conn_params), pdata, plen);
-        } else
-                if (plen)
-                        memcpy(mpa->private_data, pdata, plen);
+        if (plen)
+                memcpy(mpa->private_data, pdata, plen);
 
         /*
          * Reference the mpa skb.  This ensures the data area
@@ -828,7 +684,6 @@ static int act_establish(struct c4iw_dev *dev, struct sk_buff *skb)
         /* setup the hwtid for this connection */
         ep->hwtid = tid;
         cxgb4_insert_tid(t, ep, tid);
-        insert_handle(dev, &dev->hwtid_idr, ep, ep->hwtid);
 
         ep->snd_seq = be32_to_cpu(req->snd_isn);
         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
@@ -836,16 +691,11 @@ static int act_establish(struct c4iw_dev *dev, struct sk_buff *skb)
         set_emss(ep, ntohs(req->tcp_opt));
 
         /* dealloc the atid */
-        remove_handle(ep->com.dev, &ep->com.dev->atid_idr, atid);
         cxgb4_free_atid(t, atid);
-        set_bit(ACT_ESTAB, &ep->com.history);
 
         /* start MPA negotiation */
         send_flowc(ep, NULL);
-        if (ep->retry_with_mpa_v1)
-                send_mpa_req(ep, skb, 1);
-        else
-                send_mpa_req(ep, skb, mpa_rev);
+        send_mpa_req(ep, skb);
 
         return 0;
 }
@@ -864,7 +714,6 @@ static void close_complete_upcall(struct c4iw_ep *ep)
                 ep->com.cm_id->rem_ref(ep->com.cm_id);
                 ep->com.cm_id = NULL;
                 ep->com.qp = NULL;
-                set_bit(CLOSE_UPCALL, &ep->com.history);
         }
 }
 
@@ -873,7 +722,6 @@ static int abort_connection(struct c4iw_ep *ep, struct sk_buff *skb, gfp_t gfp)
         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
         close_complete_upcall(ep);
         state_set(&ep->com, ABORTING);
-        set_bit(ABORT_CONN, &ep->com.history);
         return send_abort(ep, skb, gfp);
 }
 
@@ -888,7 +736,6 @@ static void peer_close_upcall(struct c4iw_ep *ep)
                 PDBG("peer close delivered ep %p cm_id %p tid %u\n",
                      ep, ep->com.cm_id, ep->hwtid);
                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
-                set_bit(DISCONN_UPCALL, &ep->com.history);
         }
 }
 
@@ -907,7 +754,6 @@ static void peer_abort_upcall(struct c4iw_ep *ep)
                 ep->com.cm_id->rem_ref(ep->com.cm_id);
                 ep->com.cm_id = NULL;
                 ep->com.qp = NULL;
-                set_bit(ABORT_UPCALL, &ep->com.history);
         }
 }
 
@@ -923,24 +769,12 @@ static void connect_reply_upcall(struct c4iw_ep *ep, int status)
         event.remote_addr = ep->com.remote_addr;
 
         if ((status == 0) || (status == -ECONNREFUSED)) {
-                if (!ep->tried_with_mpa_v1) {
-                        /* this means MPA_v2 is used */
-                        event.private_data_len = ep->plen -
-                                sizeof(struct mpa_v2_conn_params);
-                        event.private_data = ep->mpa_pkt +
-                                sizeof(struct mpa_message) +
-                                sizeof(struct mpa_v2_conn_params);
-                } else {
-                        /* this means MPA_v1 is used */
-                        event.private_data_len = ep->plen;
-                        event.private_data = ep->mpa_pkt +
-                                sizeof(struct mpa_message);
-                }
+                event.private_data_len = ep->plen;
+                event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
         }
 
         PDBG("%s ep %p tid %u status %d\n", __func__, ep,
              ep->hwtid, status);
-        set_bit(CONN_RPL_UPCALL, &ep->com.history);
         ep->com.cm_id->event_handler(ep->com.cm_id, &event);
 
         if (status < 0) {
@@ -959,29 +793,15 @@ static void connect_request_upcall(struct c4iw_ep *ep)
         event.event = IW_CM_EVENT_CONNECT_REQUEST;
         event.local_addr = ep->com.local_addr;
         event.remote_addr = ep->com.remote_addr;
+        event.private_data_len = ep->plen;
+        event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
         event.provider_data = ep;
-        if (!ep->tried_with_mpa_v1) {
-                /* this means MPA_v2 is used */
-                event.ord = ep->ord;
-                event.ird = ep->ird;
-                event.private_data_len = ep->plen -
-                        sizeof(struct mpa_v2_conn_params);
-                event.private_data = ep->mpa_pkt + sizeof(struct mpa_message) +
-                        sizeof(struct mpa_v2_conn_params);
-        } else {
-                /* this means MPA_v1 is used. Send max supported */
-                event.ord = c4iw_max_read_depth;
-                event.ird = c4iw_max_read_depth;
-                event.private_data_len = ep->plen;
-                event.private_data = ep->mpa_pkt + sizeof(struct mpa_message);
-        }
         if (state_read(&ep->parent_ep->com) != DEAD) {
                 c4iw_get_ep(&ep->com);
                 ep->parent_ep->com.cm_id->event_handler(
                                                 ep->parent_ep->com.cm_id,
                                                 &event);
         }
-        set_bit(CONNREQ_UPCALL, &ep->com.history);
         c4iw_put_ep(&ep->parent_ep->com);
         ep->parent_ep = NULL;
 }
@@ -993,12 +813,9 @@ static void established_upcall(struct c4iw_ep *ep)
         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
         memset(&event, 0, sizeof(event));
         event.event = IW_CM_EVENT_ESTABLISHED;
-        event.ird = ep->ird;
-        event.ord = ep->ord;
         if (ep->com.cm_id) {
                 PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
                 ep->com.cm_id->event_handler(ep->com.cm_id, &event);
-                set_bit(ESTAB_UPCALL, &ep->com.history);
         }
 }
 
@@ -1031,10 +848,7 @@ static int update_rx_credits(struct c4iw_ep *ep, u32 credits)
 static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
 {
         struct mpa_message *mpa;
-        struct mpa_v2_conn_params *mpa_v2_params;
         u16 plen;
-        u16 resp_ird, resp_ord;
-        u8 rtr_mismatch = 0, insuff_ird = 0;
         struct c4iw_qp_attributes attrs;
         enum c4iw_qp_attr_mask mask;
         int err;
@@ -1074,9 +888,7 @@ static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
         mpa = (struct mpa_message *) ep->mpa_pkt;
 
         /* Validate MPA header. */
-        if (mpa->revision > mpa_rev) {
-                printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
-                       " Received = %d\n", __func__, mpa_rev, mpa->revision);
+        if (mpa->revision != mpa_rev) {
                 err = -EPROTO;
                 goto err;
         }
@@ -1126,66 +938,13 @@ static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
         ep->mpa_attr.recv_marker_enabled = markers_enabled;
         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
-        ep->mpa_attr.version = mpa->revision;
-        ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
-
-        if (mpa->revision == 2) {
-                ep->mpa_attr.enhanced_rdma_conn =
-                        mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
-                if (ep->mpa_attr.enhanced_rdma_conn) {
-                        mpa_v2_params = (struct mpa_v2_conn_params *)
-                                (ep->mpa_pkt + sizeof(*mpa));
-                        resp_ird = ntohs(mpa_v2_params->ird) &
-                                MPA_V2_IRD_ORD_MASK;
-                        resp_ord = ntohs(mpa_v2_params->ord) &
-                                MPA_V2_IRD_ORD_MASK;
-
-                        /*
-                         * This is a double-check. Ideally, below checks are
-                         * not required since ird/ord stuff has been taken
-                         * care of in c4iw_accept_cr
-                         */
-                        if ((ep->ird < resp_ord) || (ep->ord > resp_ird)) {
-                                err = -ENOMEM;
-                                ep->ird = resp_ord;
-                                ep->ord = resp_ird;
-                                insuff_ird = 1;
-                        }
-
-                        if (ntohs(mpa_v2_params->ird) &
-                                        MPA_V2_PEER2PEER_MODEL) {
-                                if (ntohs(mpa_v2_params->ord) &
-                                                MPA_V2_RDMA_WRITE_RTR)
-                                        ep->mpa_attr.p2p_type =
-                                                FW_RI_INIT_P2PTYPE_RDMA_WRITE;
-                                else if (ntohs(mpa_v2_params->ord) &
-                                                MPA_V2_RDMA_READ_RTR)
-                                        ep->mpa_attr.p2p_type =
-                                                FW_RI_INIT_P2PTYPE_READ_REQ;
-                        }
-                }
-        } else if (mpa->revision == 1)
-                if (peer2peer)
-                        ep->mpa_attr.p2p_type = p2p_type;
-
+        ep->mpa_attr.version = mpa_rev;
+        ep->mpa_attr.p2p_type = peer2peer ? p2p_type :
+                                            FW_RI_INIT_P2PTYPE_DISABLED;
         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
-             "xmit_marker_enabled=%d, version=%d p2p_type=%d local-p2p_type = "
-             "%d\n", __func__, ep->mpa_attr.crc_enabled,
-             ep->mpa_attr.recv_marker_enabled,
-             ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version,
-             ep->mpa_attr.p2p_type, p2p_type);
-
-        /*
-         * If responder's RTR does not match with that of initiator, assign
-         * FW_RI_INIT_P2PTYPE_DISABLED in mpa attributes so that RTR is not
-         * generated when moving QP to RTS state.
-         * A TERM message will be sent after QP has moved to RTS state
-         */
-        if ((ep->mpa_attr.version == 2) && peer2peer &&
-                        (ep->mpa_attr.p2p_type != p2p_type)) {
-                ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
-                rtr_mismatch = 1;
-        }
+             "xmit_marker_enabled=%d, version=%d\n", __func__,
+             ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
+             ep->mpa_attr.xmit_marker_enabled, ep->mpa_attr.version);
 
         attrs.mpa_attr = ep->mpa_attr;
         attrs.max_ird = ep->ird;
@@ -1202,39 +961,6 @@ static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
                              ep->com.qp, mask, &attrs, 1);
         if (err)
                 goto err;
-
-        /*
-         * If responder's RTR requirement did not match with what initiator
-         * supports, generate TERM message
-         */
-        if (rtr_mismatch) {
-                printk(KERN_ERR "%s: RTR mismatch, sending TERM\n", __func__);
-                attrs.layer_etype = LAYER_MPA | DDP_LLP;
-                attrs.ecode = MPA_NOMATCH_RTR;
-                attrs.next_state = C4IW_QP_STATE_TERMINATE;
-                err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
-                                C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
-                err = -ENOMEM;
-                goto out;
-        }
-
-        /*
-         * Generate TERM if initiator IRD is not sufficient for responder
-         * provided ORD. Currently, we do the same behaviour even when
-         * responder provided IRD is also not sufficient as regards to
-         * initiator ORD.
-         */
-        if (insuff_ird) {
-                printk(KERN_ERR "%s: Insufficient IRD, sending TERM\n",
-                                __func__);
-                attrs.layer_etype = LAYER_MPA | DDP_LLP;
-                attrs.ecode = MPA_INSUFF_IRD;
-                attrs.next_state = C4IW_QP_STATE_TERMINATE;
-                err = c4iw_modify_qp(ep->com.qp->rhp, ep->com.qp,
-                                C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
-                err = -ENOMEM;
-                goto out;
-        }
         goto out;
 err:
         state_set(&ep->com, ABORTING);
@@ -1247,7 +973,6 @@ out:
 static void process_mpa_request(struct c4iw_ep *ep, struct sk_buff *skb)
 {
         struct mpa_message *mpa;
-        struct mpa_v2_conn_params *mpa_v2_params;
         u16 plen;
 
         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
@@ -1288,9 +1013,7 @@ static void process_mpa_request(struct c4iw_ep *ep, struct sk_buff *skb)
         /*
          * Validate MPA Header.
          */
-        if (mpa->revision > mpa_rev) {
-                printk(KERN_ERR MOD "%s MPA version mismatch. Local = %d,"
-                       " Received = %d\n", __func__, mpa_rev, mpa->revision);
+        if (mpa->revision != mpa_rev) {
                 abort_connection(ep, skb, GFP_KERNEL);
                 return;
         }
@@ -1333,37 +1056,9 @@ static void process_mpa_request(struct c4iw_ep *ep, struct sk_buff *skb)
         ep->mpa_attr.crc_enabled = (mpa->flags & MPA_CRC) | crc_enabled ? 1 : 0;
         ep->mpa_attr.recv_marker_enabled = markers_enabled;
         ep->mpa_attr.xmit_marker_enabled = mpa->flags & MPA_MARKERS ? 1 : 0;
-        ep->mpa_attr.version = mpa->revision;
-        if (mpa->revision == 1)
-                ep->tried_with_mpa_v1 = 1;
-        ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
-
-        if (mpa->revision == 2) {
-                ep->mpa_attr.enhanced_rdma_conn =
-                        mpa->flags & MPA_ENHANCED_RDMA_CONN ? 1 : 0;
-                if (ep->mpa_attr.enhanced_rdma_conn) {
-                        mpa_v2_params = (struct mpa_v2_conn_params *)
-                                (ep->mpa_pkt + sizeof(*mpa));
-                        ep->ird = ntohs(mpa_v2_params->ird) &
-                                MPA_V2_IRD_ORD_MASK;
-                        ep->ord = ntohs(mpa_v2_params->ord) &
-                                MPA_V2_IRD_ORD_MASK;
-                        if (ntohs(mpa_v2_params->ird) & MPA_V2_PEER2PEER_MODEL)
-                                if (peer2peer) {
-                                        if (ntohs(mpa_v2_params->ord) &
-                                                        MPA_V2_RDMA_WRITE_RTR)
-                                                ep->mpa_attr.p2p_type =
-                                                FW_RI_INIT_P2PTYPE_RDMA_WRITE;
-                                        else if (ntohs(mpa_v2_params->ord) &
-                                                        MPA_V2_RDMA_READ_RTR)
-                                                ep->mpa_attr.p2p_type =
-                                                FW_RI_INIT_P2PTYPE_READ_REQ;
-                                }
-                }
-        } else if (mpa->revision == 1)
-                if (peer2peer)
-                        ep->mpa_attr.p2p_type = p2p_type;
-
+        ep->mpa_attr.version = mpa_rev;
+        ep->mpa_attr.p2p_type = peer2peer ? p2p_type :
+                                            FW_RI_INIT_P2PTYPE_DISABLED;
         PDBG("%s - crc_enabled=%d, recv_marker_enabled=%d, "
              "xmit_marker_enabled=%d, version=%d p2p_type=%d\n", __func__,
              ep->mpa_attr.crc_enabled, ep->mpa_attr.recv_marker_enabled,
@@ -1384,7 +1079,6 @@ static int rx_data(struct c4iw_dev *dev, struct sk_buff *skb)
         unsigned int dlen = ntohs(hdr->len);
         unsigned int tid = GET_TID(hdr);
         struct tid_info *t = dev->rdev.lldi.tids;
-        __u8 status = hdr->status;
 
         ep = lookup_tid(t, tid);
         PDBG("%s ep %p tid %u dlen %u\n", __func__, ep, ep->hwtid, dlen);
@@ -1407,9 +1101,9 @@ static int rx_data(struct c4iw_dev *dev, struct sk_buff *skb)
         case MPA_REP_SENT:
                 break;
         default:
-                pr_err("%s Unexpected streaming data." \
-                       " ep %p state %d tid %u status %d\n",
-                       __func__, ep, state_read(&ep->com), ep->hwtid, status);
+                printk(KERN_ERR MOD "%s Unexpected streaming data."
+                       " ep %p state %d tid %u\n",
+                       __func__, ep, state_read(&ep->com), ep->hwtid);
 
                 /*
                  * The ep will timeout and inform the ULP of the failure.
@@ -1429,11 +1123,8 @@ static int abort_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
         struct tid_info *t = dev->rdev.lldi.tids;
 
         ep = lookup_tid(t, tid);
-        if (!ep) {
-                printk(KERN_WARNING MOD "Abort rpl to freed endpoint\n");
-                return 0;
-        }
         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
+        BUG_ON(!ep);
         mutex_lock(&ep->com.mutex);
         switch (ep->com.state) {
         case ABORTING:
@@ -1452,63 +1143,6 @@ static int abort_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
         return 0;
 }
 
-static void send_fw_act_open_req(struct c4iw_ep *ep, unsigned int atid)
-{
-        struct sk_buff *skb;
-        struct fw_ofld_connection_wr *req;
-        unsigned int mtu_idx;
-        int wscale;
-
-        skb = get_skb(NULL, sizeof(*req), GFP_KERNEL);
-        req = (struct fw_ofld_connection_wr *)__skb_put(skb, sizeof(*req));
-        memset(req, 0, sizeof(*req));
-        req->op_compl = htonl(V_WR_OP(FW_OFLD_CONNECTION_WR));
-        req->len16_pkd = htonl(FW_WR_LEN16(DIV_ROUND_UP(sizeof(*req), 16)));
-        req->le.filter = cpu_to_be32(select_ntuple(ep->com.dev, ep->dst,
-                                     ep->l2t));
-        req->le.lport = ep->com.local_addr.sin_port;
-        req->le.pport = ep->com.remote_addr.sin_port;
-        req->le.u.ipv4.lip = ep->com.local_addr.sin_addr.s_addr;
-        req->le.u.ipv4.pip = ep->com.remote_addr.sin_addr.s_addr;
-        req->tcb.t_state_to_astid =
-                        htonl(V_FW_OFLD_CONNECTION_WR_T_STATE(TCP_SYN_SENT) |
-                        V_FW_OFLD_CONNECTION_WR_ASTID(atid));
-        req->tcb.cplrxdataack_cplpassacceptrpl =
-                        htons(F_FW_OFLD_CONNECTION_WR_CPLRXDATAACK);
-        req->tcb.tx_max = jiffies;
-        req->tcb.rcv_adv = htons(1);
-        cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
-        wscale = compute_wscale(rcv_win);
-        req->tcb.opt0 = TCAM_BYPASS(1) |
-                (nocong ? NO_CONG(1) : 0) |
-                KEEP_ALIVE(1) |
-                DELACK(1) |
-                WND_SCALE(wscale) |
-                MSS_IDX(mtu_idx) |
-                L2T_IDX(ep->l2t->idx) |
-                TX_CHAN(ep->tx_chan) |
-                SMAC_SEL(ep->smac_idx) |
-                DSCP(ep->tos) |
-                ULP_MODE(ULP_MODE_TCPDDP) |
-                RCV_BUFSIZ(rcv_win >> 10);
-        req->tcb.opt2 = PACE(1) |
-                TX_QUEUE(ep->com.dev->rdev.lldi.tx_modq[ep->tx_chan]) |
-                RX_CHANNEL(0) |
-                CCTRL_ECN(enable_ecn) |
-                RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid);
-        if (enable_tcp_timestamps)
-                req->tcb.opt2 |= TSTAMPS_EN(1);
-        if (enable_tcp_sack)
-                req->tcb.opt2 |= SACK_EN(1);
-        if (wscale && enable_tcp_window_scaling)
-                req->tcb.opt2 |= WND_SCALE_EN(1);
-        req->tcb.opt0 = cpu_to_be64(req->tcb.opt0);
-        req->tcb.opt2 = cpu_to_be32(req->tcb.opt2);
-        set_wr_txq(skb, CPL_PRIORITY_CONTROL, ep->ctrlq_idx);
-        set_bit(ACT_OFLD_CONN, &ep->com.history);
-        c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
-}
-
 /*
  * Return whether a failed active open has allocated a TID
  */
@@ -1518,111 +1152,6 @@ static inline int act_open_has_tid(int status)
                status != CPL_ERR_ARP_MISS;
 }
 
-#define ACT_OPEN_RETRY_COUNT 2
-
-static int c4iw_reconnect(struct c4iw_ep *ep)
-{
-        int err = 0;
-        struct rtable *rt;
-        struct port_info *pi;
-        struct net_device *pdev;
-        int step;
-        struct neighbour *neigh;
-
-        PDBG("%s qp %p cm_id %p\n", __func__, ep->com.qp, ep->com.cm_id);
-        init_timer(&ep->timer);
-
-        /*
-         * Allocate an active TID to initiate a TCP connection.
-         */
-        ep->atid = cxgb4_alloc_atid(ep->com.dev->rdev.lldi.tids, ep);
-        if (ep->atid == -1) {
-                pr_err("%s - cannot alloc atid.\n", __func__);
-                err = -ENOMEM;
-                goto fail2;
-        }
-        insert_handle(ep->com.dev, &ep->com.dev->atid_idr, ep, ep->atid);
-
-        /* find a route */
-        rt = find_route(ep->com.dev,
-                        ep->com.cm_id->local_addr.sin_addr.s_addr,
-                        ep->com.cm_id->remote_addr.sin_addr.s_addr,
-                        ep->com.cm_id->local_addr.sin_port,
-                        ep->com.cm_id->remote_addr.sin_port, 0);
-        if (!rt) {
-                pr_err("%s - cannot find route.\n", __func__);
-                err = -EHOSTUNREACH;
-                goto fail3;
-        }
-        ep->dst = &rt->dst;
-
-        neigh = dst_neigh_lookup(ep->dst,
-                        &ep->com.cm_id->remote_addr.sin_addr.s_addr);
-        /* get a l2t entry */
-        if (neigh->dev->flags & IFF_LOOPBACK) {
-                PDBG("%s LOOPBACK\n", __func__);
-                pdev = ip_dev_find(&init_net,
-                                ep->com.cm_id->remote_addr.sin_addr.s_addr);
-                ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t,
-                                neigh, pdev, 0);
-                pi = (struct port_info *)netdev_priv(pdev);
-                ep->mtu = pdev->mtu;
-                ep->tx_chan = cxgb4_port_chan(pdev);
-                ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
-                dev_put(pdev);
-        } else {
-                ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t,
-                                neigh, neigh->dev, 0);
-                pi = (struct port_info *)netdev_priv(neigh->dev);
-                ep->mtu = dst_mtu(ep->dst);
-                ep->tx_chan = cxgb4_port_chan(neigh->dev);
-                ep->smac_idx = (cxgb4_port_viid(neigh->dev) &
-                                0x7F) << 1;
-        }
-
-        step = ep->com.dev->rdev.lldi.ntxq / ep->com.dev->rdev.lldi.nchan;
-        ep->txq_idx = pi->port_id * step;
-        ep->ctrlq_idx = pi->port_id;
-        step = ep->com.dev->rdev.lldi.nrxq / ep->com.dev->rdev.lldi.nchan;
-        ep->rss_qid = ep->com.dev->rdev.lldi.rxq_ids[pi->port_id * step];
-
-        if (!ep->l2t) {
-                pr_err("%s - cannot alloc l2e.\n", __func__);
-                err = -ENOMEM;
-                goto fail4;
-        }
-
-        PDBG("%s txq_idx %u tx_chan %u smac_idx %u rss_qid %u l2t_idx %u\n",
-             __func__, ep->txq_idx, ep->tx_chan, ep->smac_idx, ep->rss_qid,
-             ep->l2t->idx);
-
-        state_set(&ep->com, CONNECTING);
-        ep->tos = 0;
-
-        /* send connect request to rnic */
-        err = send_connect(ep);
-        if (!err)
-                goto out;
-
-        cxgb4_l2t_release(ep->l2t);
-fail4:
-        dst_release(ep->dst);
-fail3:
-        remove_handle(ep->com.dev, &ep->com.dev->atid_idr, ep->atid);
-        cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
-fail2:
-        /*
-         * remember to send notification to upper layer.
-         * We are in here so the upper layer is not aware that this is
-         * re-connect attempt and so, upper layer is still waiting for
-         * response of 1st connect request.
-         */
-        connect_reply_upcall(ep, -ECONNRESET);
-        c4iw_put_ep(&ep->com);
-out:
-        return err;
-}
-
 static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
 {
         struct c4iw_ep *ep;
@@ -1643,56 +1172,12 @@ static int act_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
                 return 0;
         }
 
-        set_bit(ACT_OPEN_RPL, &ep->com.history);
-
-        /*
-         * Log interesting failures.
-         */
-        switch (status) {
-        case CPL_ERR_CONN_RESET:
-        case CPL_ERR_CONN_TIMEDOUT:
-                break;
-        case CPL_ERR_TCAM_FULL:
-                if (dev->rdev.lldi.enable_fw_ofld_conn) {
-                        mutex_lock(&dev->rdev.stats.lock);
-                        dev->rdev.stats.tcam_full++;
-                        mutex_unlock(&dev->rdev.stats.lock);
-                        send_fw_act_open_req(ep,
-                                             GET_TID_TID(GET_AOPEN_ATID(
-                                             ntohl(rpl->atid_status))));
-                        return 0;
-                }
-                break;
-        case CPL_ERR_CONN_EXIST:
-                if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
-                        set_bit(ACT_RETRY_INUSE, &ep->com.history);
-                        remove_handle(ep->com.dev, &ep->com.dev->atid_idr,
-                                        atid);
-                        cxgb4_free_atid(t, atid);
-                        dst_release(ep->dst);
-                        cxgb4_l2t_release(ep->l2t);
-                        c4iw_reconnect(ep);
-                        return 0;
-                }
-                break;
-        default:
-                printk(KERN_INFO MOD "Active open failure - "
-                       "atid %u status %u errno %d %pI4:%u->%pI4:%u\n",
-                       atid, status, status2errno(status),
-                       &ep->com.local_addr.sin_addr.s_addr,
-                       ntohs(ep->com.local_addr.sin_port),
-                       &ep->com.remote_addr.sin_addr.s_addr,
-                       ntohs(ep->com.remote_addr.sin_port));
-                break;
-        }
-
         connect_reply_upcall(ep, status2errno(status));
         state_set(&ep->com, DEAD);
 
         if (status && act_open_has_tid(status))
                 cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, GET_TID(rpl));
 
-        remove_handle(ep->com.dev, &ep->com.dev->atid_idr, atid);
         cxgb4_free_atid(t, atid);
         dst_release(ep->dst);
         cxgb4_l2t_release(ep->l2t);
@@ -1709,14 +1194,13 @@ static int pass_open_rpl(struct c4iw_dev *dev, struct sk_buff *skb)
         struct c4iw_listen_ep *ep = lookup_stid(t, stid);
 
         if (!ep) {
-                PDBG("%s stid %d lookup failure!\n", __func__, stid);
-                goto out;
+                printk(KERN_ERR MOD "stid %d lookup failure!\n", stid);
+                return 0;
         }
         PDBG("%s ep %p status %d error %d\n", __func__, ep,
              rpl->status, status2errno(rpl->status));
         c4iw_wake_up(&ep->com.wr_wait, status2errno(rpl->status));
 
-out:
         return 0;
 }
 
@@ -1768,15 +1252,14 @@ static void accept_cr(struct c4iw_ep *ep, __be32 peer_ip, struct sk_buff *skb,
         skb_get(skb);
         cxgb4_best_mtu(ep->com.dev->rdev.lldi.mtus, ep->mtu, &mtu_idx);
         wscale = compute_wscale(rcv_win);
-        opt0 = (nocong ? NO_CONG(1) : 0) |
-               KEEP_ALIVE(1) |
+        opt0 = KEEP_ALIVE(1) |
                DELACK(1) |
                WND_SCALE(wscale) |
                MSS_IDX(mtu_idx) |
                L2T_IDX(ep->l2t->idx) |
                TX_CHAN(ep->tx_chan) |
                SMAC_SEL(ep->smac_idx) |
-               DSCP(ep->tos >> 2) |
+               DSCP(ep->tos) |
                ULP_MODE(ULP_MODE_TCPDDP) |
                RCV_BUFSIZ(rcv_win>>10);
         opt2 = RX_CHANNEL(0) |
@@ -1788,15 +1271,6 @@ static void accept_cr(struct c4iw_ep *ep, __be32 peer_ip, struct sk_buff *skb,
                 opt2 |= SACK_EN(1);
         if (wscale && enable_tcp_window_scaling)
                 opt2 |= WND_SCALE_EN(1);
-        if (enable_ecn) {
-                const struct tcphdr *tcph;
-                u32 hlen = ntohl(req->hdr_len);
-
-                tcph = (const void *)(req + 1) + G_ETH_HDR_LEN(hlen) +
-                        G_IP_HDR_LEN(hlen);
-                if (tcph->ece && tcph->cwr)
-                        opt2 |= CCTRL_ECN(1);
-        }
 
         rpl = cplhdr(skb);
         INIT_TP_WR(rpl, ep->hwtid);
@@ -1844,98 +1318,30 @@ static void get_4tuple(struct cpl_pass_accept_req *req,
         return;
 }
 
-static int import_ep(struct c4iw_ep *ep, __be32 peer_ip, struct dst_entry *dst,
-                     struct c4iw_dev *cdev, bool clear_mpa_v1)
-{
-        struct neighbour *n;
-        int err, step;
-
-        n = dst_neigh_lookup(dst, &peer_ip);
-        if (!n)
-                return -ENODEV;
-
-        rcu_read_lock();
-        err = -ENOMEM;
-        if (n->dev->flags & IFF_LOOPBACK) {
-                struct net_device *pdev;
-
-                pdev = ip_dev_find(&init_net, peer_ip);
-                if (!pdev) {
-                        err = -ENODEV;
-                        goto out;
-                }
-                ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
-                                        n, pdev, 0);
-                if (!ep->l2t)
-                        goto out;
-                ep->mtu = pdev->mtu;
-                ep->tx_chan = cxgb4_port_chan(pdev);
-                ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
-                step = cdev->rdev.lldi.ntxq /
-                        cdev->rdev.lldi.nchan;
-                ep->txq_idx = cxgb4_port_idx(pdev) * step;
-                step = cdev->rdev.lldi.nrxq /
-                        cdev->rdev.lldi.nchan;
-                ep->ctrlq_idx = cxgb4_port_idx(pdev);
-                ep->rss_qid = cdev->rdev.lldi.rxq_ids[
-                        cxgb4_port_idx(pdev) * step];
-                dev_put(pdev);
-        } else {
-                ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
-                                        n, n->dev, 0);
-                if (!ep->l2t)
-                        goto out;
-                ep->mtu = dst_mtu(dst);
-                ep->tx_chan = cxgb4_port_chan(n->dev);
-                ep->smac_idx = (cxgb4_port_viid(n->dev) & 0x7F) << 1;
-                step = cdev->rdev.lldi.ntxq /
-                        cdev->rdev.lldi.nchan;
-                ep->txq_idx = cxgb4_port_idx(n->dev) * step;
-                ep->ctrlq_idx = cxgb4_port_idx(n->dev);
-                step = cdev->rdev.lldi.nrxq /
-                        cdev->rdev.lldi.nchan;
-                ep->rss_qid = cdev->rdev.lldi.rxq_ids[
-                        cxgb4_port_idx(n->dev) * step];
-
-                if (clear_mpa_v1) {
-                        ep->retry_with_mpa_v1 = 0;
-                        ep->tried_with_mpa_v1 = 0;
-                }
-        }
-        err = 0;
-out:
-        rcu_read_unlock();
-
-        neigh_release(n);
-
-        return err;
-}
-
 static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
 {
-        struct c4iw_ep *child_ep = NULL, *parent_ep;
+        struct c4iw_ep *child_ep, *parent_ep;
         struct cpl_pass_accept_req *req = cplhdr(skb);
         unsigned int stid = GET_POPEN_TID(ntohl(req->tos_stid));
         struct tid_info *t = dev->rdev.lldi.tids;
         unsigned int hwtid = GET_TID(req);
+        struct neighbour *neigh;
         struct dst_entry *dst;
+        struct l2t_entry *l2t;
         struct rtable *rt;
-        __be32 local_ip, peer_ip = 0;
+        __be32 local_ip, peer_ip;
         __be16 local_port, peer_port;
-        int err;
-        u16 peer_mss = ntohs(req->tcpopt.mss);
+        struct net_device *pdev;
+        u32 tx_chan, smac_idx;
+        u16 rss_qid;
+        u32 mtu;
+        int step;
+        int txq_idx, ctrlq_idx;
 
         parent_ep = lookup_stid(t, stid);
-        if (!parent_ep) {
-                PDBG("%s connect request on invalid stid %d\n", __func__, stid);
-                goto reject;
-        }
-        get_4tuple(req, &local_ip, &peer_ip, &local_port, &peer_port);
+        PDBG("%s parent ep %p tid %u\n", __func__, parent_ep, hwtid);
 
-        PDBG("%s parent ep %p hwtid %u laddr 0x%x raddr 0x%x lport %d " \
-             "rport %d peer_mss %d\n", __func__, parent_ep, hwtid,
-             ntohl(local_ip), ntohl(peer_ip), ntohs(local_port),
-             ntohs(peer_port), peer_mss);
+        get_4tuple(req, &local_ip, &peer_ip, &local_port, &peer_port);
 
         if (state_read(&parent_ep->com) != LISTEN) {
                 printk(KERN_ERR "%s - listening ep not in LISTEN\n",
@@ -1952,27 +1358,49 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
                 goto reject;
         }
         dst = &rt->dst;
-
-        child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
-        if (!child_ep) {
-                printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
+        rcu_read_lock();
+        neigh = dst_get_neighbour(dst);
+        if (neigh->dev->flags & IFF_LOOPBACK) {
+                pdev = ip_dev_find(&init_net, peer_ip);
+                BUG_ON(!pdev);
+                l2t = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh, pdev, 0);
+                mtu = pdev->mtu;
+                tx_chan = cxgb4_port_chan(pdev);
+                smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
+                step = dev->rdev.lldi.ntxq / dev->rdev.lldi.nchan;
+                txq_idx = cxgb4_port_idx(pdev) * step;
+                ctrlq_idx = cxgb4_port_idx(pdev);
+                step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
+                rss_qid = dev->rdev.lldi.rxq_ids[cxgb4_port_idx(pdev) * step];
+                dev_put(pdev);
+        } else {
+                l2t = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh, neigh->dev, 0);
+                mtu = dst_mtu(dst);
+                tx_chan = cxgb4_port_chan(neigh->dev);
+                smac_idx = (cxgb4_port_viid(neigh->dev) & 0x7F) << 1;
+                step = dev->rdev.lldi.ntxq / dev->rdev.lldi.nchan;
+                txq_idx = cxgb4_port_idx(neigh->dev) * step;
+                ctrlq_idx = cxgb4_port_idx(neigh->dev);
+                step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
+                rss_qid = dev->rdev.lldi.rxq_ids[
+                          cxgb4_port_idx(neigh->dev) * step];
+        }
+        rcu_read_unlock();
+        if (!l2t) {
+                printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
                        __func__);
                 dst_release(dst);
                 goto reject;
         }
 
-        err = import_ep(child_ep, peer_ip, dst, dev, false);
-        if (err) {
-                printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
+        child_ep = alloc_ep(sizeof(*child_ep), GFP_KERNEL);
+        if (!child_ep) {
+                printk(KERN_ERR MOD "%s - failed to allocate ep entry!\n",
                        __func__);
+                cxgb4_l2t_release(l2t);
                 dst_release(dst);
-                kfree(child_ep);
                 goto reject;
         }
-
-        if (peer_mss && child_ep->mtu > (peer_mss + 40))
-                child_ep->mtu = peer_mss + 40;
-
         state_set(&child_ep->com, CONNECTING);
         child_ep->com.dev = dev;
         child_ep->com.cm_id = NULL;
@@ -1985,16 +1413,22 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb)
         c4iw_get_ep(&parent_ep->com);
         child_ep->parent_ep = parent_ep;
         child_ep->tos = GET_POPEN_TOS(ntohl(req->tos_stid));
+        child_ep->l2t = l2t;
         child_ep->dst = dst;
         child_ep->hwtid = hwtid;
+        child_ep->tx_chan = tx_chan;
+        child_ep->smac_idx = smac_idx;
+        child_ep->rss_qid = rss_qid;
+        child_ep->mtu = mtu;
+        child_ep->txq_idx = txq_idx;
+        child_ep->ctrlq_idx = ctrlq_idx;
 
         PDBG("%s tx_chan %u smac_idx %u rss_qid %u\n", __func__,
-             child_ep->tx_chan, child_ep->smac_idx, child_ep->rss_qid);
+             tx_chan, smac_idx, rss_qid);
 
         init_timer(&child_ep->timer);
         cxgb4_insert_tid(t, child_ep, hwtid);
         accept_cr(child_ep, peer_ip, skb, req);
-        set_bit(PASS_ACCEPT_REQ, &child_ep->com.history);
         goto out;
 reject:
         reject_cr(dev, hwtid, peer_ip, skb);
@@ -2014,17 +1448,12 @@ static int pass_establish(struct c4iw_dev *dev, struct sk_buff *skb)
         ep->snd_seq = be32_to_cpu(req->snd_isn);
         ep->rcv_seq = be32_to_cpu(req->rcv_isn);
 
-        PDBG("%s ep %p hwtid %u tcp_opt 0x%02x\n", __func__, ep, tid,
-             ntohs(req->tcp_opt));
-
         set_emss(ep, ntohs(req->tcp_opt));
-        insert_handle(dev, &dev->hwtid_idr, ep, ep->hwtid);
 
         dst_confirm(ep->dst);
         state_set(&ep->com, MPA_REQ_WAIT);
         start_ep_timer(ep);
         send_flowc(ep, skb);
-        set_bit(PASS_ESTAB, &ep->com.history);
 
         return 0;
 }
@@ -2044,7 +1473,6 @@ static int peer_close(struct c4iw_dev *dev, struct sk_buff *skb)
         PDBG("%s ep %p tid %u\n", __func__, ep, ep->hwtid);
         dst_confirm(ep->dst);
 
-        set_bit(PEER_CLOSE, &ep->com.history);
         mutex_lock(&ep->com.mutex);
         switch (ep->com.state) {
         case MPA_REQ_WAIT:
@@ -2144,15 +1572,11 @@ static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
         }
         PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid,
              ep->com.state);
-        set_bit(PEER_ABORT, &ep->com.history);
 
         /*
          * Wake up any threads in rdma_init() or rdma_fini().
-         * However, this is not needed if com state is just
-         * MPA_REQ_SENT
          */
-        if (ep->com.state != MPA_REQ_SENT)
-                c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
+        c4iw_wake_up(&ep->com.wr_wait, -ECONNRESET);
 
         mutex_lock(&ep->com.mutex);
         switch (ep->com.state) {
@@ -2163,21 +1587,7 @@ static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
                 break;
         case MPA_REQ_SENT:
                 stop_ep_timer(ep);
-                if (mpa_rev == 2 && ep->tried_with_mpa_v1)
-                        connect_reply_upcall(ep, -ECONNRESET);
-                else {
-                        /*
-                         * we just don't send notification upwards because we
-                         * want to retry with mpa_v1 without upper layers even
-                         * knowing it.
-                         *
-                         * do some housekeeping so as to re-initiate the
-                         * connection
-                         */
-                        PDBG("%s: mpa_rev=%d. Retrying with mpav1\n", __func__,
-                             mpa_rev);
-                        ep->retry_with_mpa_v1 = 1;
-                }
+                connect_reply_upcall(ep, -ECONNRESET);
                 break;
         case MPA_REP_SENT:
                 break;
@@ -2213,9 +1623,7 @@ static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
         dst_confirm(ep->dst);
         if (ep->com.state != ABORTING) {
                 __state_set(&ep->com, DEAD);
-                /* we don't release if we want to retry with mpa_v1 */
-                if (!ep->retry_with_mpa_v1)
-                        release = 1;
+                release = 1;
         }
         mutex_unlock(&ep->com.mutex);
 
@@ -2235,15 +1643,6 @@ static int peer_abort(struct c4iw_dev *dev, struct sk_buff *skb)
 out:
         if (release)
                 release_ep_resources(ep);
-
-        /* retry with mpa-v1 */
-        if (ep && ep->retry_with_mpa_v1) {
-                cxgb4_remove_tid(ep->com.dev->rdev.lldi.tids, 0, ep->hwtid);
-                dst_release(ep->dst);
-                cxgb4_l2t_release(ep->l2t);
-                c4iw_reconnect(ep);
-        }
-
         return 0;
 }
 
@@ -2359,7 +1758,6 @@ int c4iw_reject_cr(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
                 c4iw_put_ep(&ep->com);
                 return -ECONNRESET;
         }
-        set_bit(ULP_REJECT, &ep->com.history);
         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
         if (mpa_rev == 0)
                 abort_connection(ep, NULL, GFP_KERNEL);
@@ -2389,7 +1787,6 @@ int c4iw_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         BUG_ON(state_read(&ep->com) != MPA_REQ_RCVD);
         BUG_ON(!qp);
 
-        set_bit(ULP_ACCEPT, &ep->com.history);
         if ((conn_param->ord > c4iw_max_read_depth) ||
             (conn_param->ird > c4iw_max_read_depth)) {
                 abort_connection(ep, NULL, GFP_KERNEL);
@@ -2397,40 +1794,18 @@ int c4iw_accept_cr(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 goto err;
         }
 
-        if (ep->mpa_attr.version == 2 && ep->mpa_attr.enhanced_rdma_conn) {
-                if (conn_param->ord > ep->ird) {
-                        ep->ird = conn_param->ird;
-                        ep->ord = conn_param->ord;
-                        send_mpa_reject(ep, conn_param->private_data,
-                                        conn_param->private_data_len);
-                        abort_connection(ep, NULL, GFP_KERNEL);
-                        err = -ENOMEM;
-                        goto err;
-                }
-                if (conn_param->ird > ep->ord) {
-                        if (!ep->ord)
-                                conn_param->ird = 1;
-                        else {
-                                abort_connection(ep, NULL, GFP_KERNEL);
-                                err = -ENOMEM;
-                                goto err;
-                        }
-                }
+        cm_id->add_ref(cm_id);
+        ep->com.cm_id = cm_id;
+        ep->com.qp = qp;
 
-        }
         ep->ird = conn_param->ird;
         ep->ord = conn_param->ord;
 
-        if (ep->mpa_attr.version != 2)
-                if (peer2peer && ep->ird == 0)
-                        ep->ird = 1;
+        if (peer2peer && ep->ird == 0)
+                ep->ird = 1;
 
         PDBG("%s %d ird %d ord %d\n", __func__, __LINE__, ep->ird, ep->ord);
 
-        cm_id->add_ref(cm_id);
-        ep->com.cm_id = cm_id;
-        ep->com.qp = qp;
-
         /* bind QP to EP and move to RTS */
         attrs.mpa_attr = ep->mpa_attr;
         attrs.max_ird = ep->ird;
@@ -2469,10 +1844,13 @@ err:
 
 int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 {
+        int err = 0;
         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
         struct c4iw_ep *ep;
         struct rtable *rt;
-        int err = 0;
+        struct net_device *pdev;
+        struct neighbour *neigh;
+        int step;
 
         if ((conn_param->ord > c4iw_max_read_depth) ||
             (conn_param->ird > c4iw_max_read_depth)) {
@@ -2513,7 +1891,6 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 err = -ENOMEM;
                 goto fail2;
         }
-        insert_handle(dev, &dev->atid_idr, ep, ep->atid);
 
         PDBG("%s saddr 0x%x sport 0x%x raddr 0x%x rport 0x%x\n", __func__,
              ntohl(cm_id->local_addr.sin_addr.s_addr),
@@ -2534,10 +1911,47 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         }
         ep->dst = &rt->dst;
 
-        err = import_ep(ep, cm_id->remote_addr.sin_addr.s_addr,
-                        ep->dst, ep->com.dev, true);
-        if (err) {
+        rcu_read_lock();
+        neigh = dst_get_neighbour(ep->dst);
+
+        /* get a l2t entry */
+        if (neigh->dev->flags & IFF_LOOPBACK) {
+                PDBG("%s LOOPBACK\n", __func__);
+                pdev = ip_dev_find(&init_net,
+                                   cm_id->remote_addr.sin_addr.s_addr);
+                ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t,
+                                        neigh, pdev, 0);
+                ep->mtu = pdev->mtu;
+                ep->tx_chan = cxgb4_port_chan(pdev);
+                ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1;
+                step = ep->com.dev->rdev.lldi.ntxq /
+                       ep->com.dev->rdev.lldi.nchan;
+                ep->txq_idx = cxgb4_port_idx(pdev) * step;
+                step = ep->com.dev->rdev.lldi.nrxq /
+                       ep->com.dev->rdev.lldi.nchan;
+                ep->ctrlq_idx = cxgb4_port_idx(pdev);
+                ep->rss_qid = ep->com.dev->rdev.lldi.rxq_ids[
+                              cxgb4_port_idx(pdev) * step];
+                dev_put(pdev);
+        } else {
+                ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t,
+                                        neigh, neigh->dev, 0);
+                ep->mtu = dst_mtu(ep->dst);
+                ep->tx_chan = cxgb4_port_chan(neigh->dev);
+                ep->smac_idx = (cxgb4_port_viid(neigh->dev) & 0x7F) << 1;
+                step = ep->com.dev->rdev.lldi.ntxq /
+                       ep->com.dev->rdev.lldi.nchan;
+                ep->txq_idx = cxgb4_port_idx(neigh->dev) * step;
+                ep->ctrlq_idx = cxgb4_port_idx(neigh->dev);
+                step = ep->com.dev->rdev.lldi.nrxq /
+                       ep->com.dev->rdev.lldi.nchan;
+                ep->rss_qid = ep->com.dev->rdev.lldi.rxq_ids[
+                              cxgb4_port_idx(neigh->dev) * step];
+        }
+        rcu_read_unlock();
+        if (!ep->l2t) {
                 printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
+                err = -ENOMEM;
                 goto fail4;
         }
 
@@ -2559,7 +1973,6 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 fail4:
         dst_release(ep->dst);
 fail3:
-        remove_handle(ep->com.dev, &ep->com.dev->atid_idr, ep->atid);
         cxgb4_free_atid(ep->com.dev->rdev.lldi.tids, ep->atid);
 fail2:
         cm_id->rem_ref(cm_id);
@@ -2574,6 +1987,7 @@ int c4iw_create_listen(struct iw_cm_id *cm_id, int backlog)
         struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
         struct c4iw_listen_ep *ep;
 
+
         might_sleep();
 
         ep = alloc_ep(sizeof(*ep), GFP_KERNEL);
@@ -2592,54 +2006,30 @@ int c4iw_create_listen(struct iw_cm_id *cm_id, int backlog)
         /*
          * Allocate a server TID.
          */
-        if (dev->rdev.lldi.enable_fw_ofld_conn)
-                ep->stid = cxgb4_alloc_sftid(dev->rdev.lldi.tids, PF_INET, ep);
-        else
-                ep->stid = cxgb4_alloc_stid(dev->rdev.lldi.tids, PF_INET, ep);
-
+        ep->stid = cxgb4_alloc_stid(dev->rdev.lldi.tids, PF_INET, ep);
         if (ep->stid == -1) {
                 printk(KERN_ERR MOD "%s - cannot alloc stid.\n", __func__);
                 err = -ENOMEM;
                 goto fail2;
         }
-        insert_handle(dev, &dev->stid_idr, ep, ep->stid);
+
         state_set(&ep->com, LISTEN);
-        if (dev->rdev.lldi.enable_fw_ofld_conn) {
-                do {
-                        err = cxgb4_create_server_filter(
-                                ep->com.dev->rdev.lldi.ports[0], ep->stid,
-                                ep->com.local_addr.sin_addr.s_addr,
-                                ep->com.local_addr.sin_port,
-                                0,
-                                ep->com.dev->rdev.lldi.rxq_ids[0],
-                                0,
-                                0);
-                        if (err == -EBUSY) {
-                                set_current_state(TASK_UNINTERRUPTIBLE);
-                                schedule_timeout(usecs_to_jiffies(100));
-                        }
-                } while (err == -EBUSY);
-        } else {
-                c4iw_init_wr_wait(&ep->com.wr_wait);
-                err = cxgb4_create_server(ep->com.dev->rdev.lldi.ports[0],
-                                ep->stid, ep->com.local_addr.sin_addr.s_addr,
-                                ep->com.local_addr.sin_port,
-                                0,
-                                ep->com.dev->rdev.lldi.rxq_ids[0]);
-                if (!err)
-                        err = c4iw_wait_for_reply(&ep->com.dev->rdev,
-                                                  &ep->com.wr_wait,
-                                                  0, 0, __func__);
-        }
+        c4iw_init_wr_wait(&ep->com.wr_wait);
+        err = cxgb4_create_server(ep->com.dev->rdev.lldi.ports[0], ep->stid,
+                                  ep->com.local_addr.sin_addr.s_addr,
+                                  ep->com.local_addr.sin_port,
+                                  ep->com.dev->rdev.lldi.rxq_ids[0]);
+        if (err)
+                goto fail3;
+
+        /* wait for pass_open_rpl */
+        err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait, 0, 0,
+                                  __func__);
         if (!err) {
                 cm_id->provider_data = ep;
                 goto out;
         }
-        pr_err("%s cxgb4_create_server/filter failed err %d " \
-               "stid %d laddr %08x lport %d\n", \
-               __func__, err, ep->stid,
-               ntohl(ep->com.local_addr.sin_addr.s_addr),
-               ntohs(ep->com.local_addr.sin_port));
+fail3:
         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid, PF_INET);
 fail2:
         cm_id->rem_ref(cm_id);
@@ -2658,19 +2048,12 @@ int c4iw_destroy_listen(struct iw_cm_id *cm_id)
 
         might_sleep();
         state_set(&ep->com, DEAD);
-        if (ep->com.dev->rdev.lldi.enable_fw_ofld_conn) {
-                err = cxgb4_remove_server_filter(
-                        ep->com.dev->rdev.lldi.ports[0], ep->stid,
-                        ep->com.dev->rdev.lldi.rxq_ids[0], 0);
-        } else {
-                c4iw_init_wr_wait(&ep->com.wr_wait);
-                err = listen_stop(ep);
-                if (err)
-                        goto done;
-                err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait,
-                                          0, 0, __func__);
-        }
-        remove_handle(ep->com.dev, &ep->com.dev->stid_idr, ep->stid);
+        c4iw_init_wr_wait(&ep->com.wr_wait);
+        err = listen_stop(ep);
+        if (err)
+                goto done;
+        err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait, 0, 0,
+                                  __func__);
         cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid, PF_INET);
 done:
         cm_id->rem_ref(cm_id);
@@ -2734,13 +2117,10 @@ int c4iw_ep_disconnect(struct c4iw_ep *ep, int abrupt, gfp_t gfp)
 
         if (close) {
                 if (abrupt) {
-                        set_bit(EP_DISC_ABORT, &ep->com.history);
                         close_complete_upcall(ep);
                         ret = send_abort(ep, NULL, gfp);
-                } else {
-                        set_bit(EP_DISC_CLOSE, &ep->com.history);
+                } else
                         ret = send_halfclose(ep, gfp);
-                }
                 if (ret)
                         fatal = 1;
         }
@@ -2750,323 +2130,10 @@ int c4iw_ep_disconnect(struct c4iw_ep *ep, int abrupt, gfp_t gfp)
         return ret;
 }
 
-static void active_ofld_conn_reply(struct c4iw_dev *dev, struct sk_buff *skb,
-                        struct cpl_fw6_msg_ofld_connection_wr_rpl *req)
-{
-        struct c4iw_ep *ep;
-        int atid = be32_to_cpu(req->tid);
-
-        ep = (struct c4iw_ep *)lookup_atid(dev->rdev.lldi.tids, req->tid);
-        if (!ep)
-                return;
-
-        switch (req->retval) {
-        case FW_ENOMEM:
-                set_bit(ACT_RETRY_NOMEM, &ep->com.history);
-                if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
-                        send_fw_act_open_req(ep, atid);
-                        return;
-                }
-        case FW_EADDRINUSE:
-                set_bit(ACT_RETRY_INUSE, &ep->com.history);
-                if (ep->retry_count++ < ACT_OPEN_RETRY_COUNT) {
-                        send_fw_act_open_req(ep, atid);
-                        return;
-                }
-                break;
-        default:
-                pr_info("%s unexpected ofld conn wr retval %d\n",
-                       __func__, req->retval);
-                break;
-        }
-        pr_err("active ofld_connect_wr failure %d atid %d\n",
-               req->retval, atid);
-        mutex_lock(&dev->rdev.stats.lock);
-        dev->rdev.stats.act_ofld_conn_fails++;
-        mutex_unlock(&dev->rdev.stats.lock);
-        connect_reply_upcall(ep, status2errno(req->retval));
-        state_set(&ep->com, DEAD);
-        remove_handle(dev, &dev->atid_idr, atid);
-        cxgb4_free_atid(dev->rdev.lldi.tids, atid);
-        dst_release(ep->dst);
-        cxgb4_l2t_release(ep->l2t);
-        c4iw_put_ep(&ep->com);
-}
-
-static void passive_ofld_conn_reply(struct c4iw_dev *dev, struct sk_buff *skb,
-                        struct cpl_fw6_msg_ofld_connection_wr_rpl *req)
-{
-        struct sk_buff *rpl_skb;
-        struct cpl_pass_accept_req *cpl;
-        int ret;
-
-        rpl_skb = (struct sk_buff *)cpu_to_be64(req->cookie);
-        BUG_ON(!rpl_skb);
-        if (req->retval) {
-                PDBG("%s passive open failure %d\n", __func__, req->retval);
-                mutex_lock(&dev->rdev.stats.lock);
-                dev->rdev.stats.pas_ofld_conn_fails++;
-                mutex_unlock(&dev->rdev.stats.lock);
-                kfree_skb(rpl_skb);
-        } else {
-                cpl = (struct cpl_pass_accept_req *)cplhdr(rpl_skb);
-                OPCODE_TID(cpl) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_REQ,
-                                                      htonl(req->tid)));
-                ret = pass_accept_req(dev, rpl_skb);
-                if (!ret)
-                        kfree_skb(rpl_skb);
-        }
-        return;
-}
-
-static int deferred_fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
+static int async_event(struct c4iw_dev *dev, struct sk_buff *skb)
 {
         struct cpl_fw6_msg *rpl = cplhdr(skb);
-        struct cpl_fw6_msg_ofld_connection_wr_rpl *req;
-
-        switch (rpl->type) {
-        case FW6_TYPE_CQE:
-                c4iw_ev_dispatch(dev, (struct t4_cqe *)&rpl->data[0]);
-                break;
-        case FW6_TYPE_OFLD_CONNECTION_WR_RPL:
-                req = (struct cpl_fw6_msg_ofld_connection_wr_rpl *)rpl->data;
-                switch (req->t_state) {
-                case TCP_SYN_SENT:
-                        active_ofld_conn_reply(dev, skb, req);
-                        break;
-                case TCP_SYN_RECV:
-                        passive_ofld_conn_reply(dev, skb, req);
-                        break;
-                default:
-                        pr_err("%s unexpected ofld conn wr state %d\n",
-                               __func__, req->t_state);
-                        break;
-                }
-                break;
-        }
-        return 0;
-}
-
-static void build_cpl_pass_accept_req(struct sk_buff *skb, int stid , u8 tos)
-{
-        u32 l2info;
-        u16 vlantag, len, hdr_len;
-        u8 intf;
-        struct cpl_rx_pkt *cpl = cplhdr(skb);
-        struct cpl_pass_accept_req *req;
-        struct tcp_options_received tmp_opt;
-
-        /* Store values from cpl_rx_pkt in temporary location. */
-        vlantag = cpl->vlan;
-        len = cpl->len;
-        l2info  = cpl->l2info;
-        hdr_len = cpl->hdr_len;
-        intf = cpl->iff;
-
-        __skb_pull(skb, sizeof(*req) + sizeof(struct rss_header));
-
-        /*
-         * We need to parse the TCP options from SYN packet.
-         * to generate cpl_pass_accept_req.
-         */
-        memset(&tmp_opt, 0, sizeof(tmp_opt));
-        tcp_clear_options(&tmp_opt);
-        tcp_parse_options(skb, &tmp_opt, 0, 0, NULL);
-
-        req = (struct cpl_pass_accept_req *)__skb_push(skb, sizeof(*req));
-        memset(req, 0, sizeof(*req));
-        req->l2info = cpu_to_be16(V_SYN_INTF(intf) |
-                         V_SYN_MAC_IDX(G_RX_MACIDX(htonl(l2info))) |
-                         F_SYN_XACT_MATCH);
-        req->hdr_len = cpu_to_be32(V_SYN_RX_CHAN(G_RX_CHAN(htonl(l2info))) |
-                                V_TCP_HDR_LEN(G_RX_TCPHDR_LEN(htons(hdr_len))) |
-                                V_IP_HDR_LEN(G_RX_IPHDR_LEN(htons(hdr_len))) |
-                                V_ETH_HDR_LEN(G_RX_ETHHDR_LEN(htonl(l2info))));
-        req->vlan = vlantag;
-        req->len = len;
-        req->tos_stid = cpu_to_be32(PASS_OPEN_TID(stid) |
-                                    PASS_OPEN_TOS(tos));
-        req->tcpopt.mss = htons(tmp_opt.mss_clamp);
-        if (tmp_opt.wscale_ok)
-                req->tcpopt.wsf = tmp_opt.snd_wscale;
-        req->tcpopt.tstamp = tmp_opt.saw_tstamp;
-        if (tmp_opt.sack_ok)
-                req->tcpopt.sack = 1;
-        OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_PASS_ACCEPT_REQ, 0));
-        return;
-}
-
-static void send_fw_pass_open_req(struct c4iw_dev *dev, struct sk_buff *skb,
-                                  __be32 laddr, __be16 lport,
-                                  __be32 raddr, __be16 rport,
-                                  u32 rcv_isn, u32 filter, u16 window,
-                                  u32 rss_qid, u8 port_id)
-{
-        struct sk_buff *req_skb;
-        struct fw_ofld_connection_wr *req;
-        struct cpl_pass_accept_req *cpl = cplhdr(skb);
-
-        req_skb = alloc_skb(sizeof(struct fw_ofld_connection_wr), GFP_KERNEL);
-        req = (struct fw_ofld_connection_wr *)__skb_put(req_skb, sizeof(*req));
-        memset(req, 0, sizeof(*req));
-        req->op_compl = htonl(V_WR_OP(FW_OFLD_CONNECTION_WR) | FW_WR_COMPL(1));
-        req->len16_pkd = htonl(FW_WR_LEN16(DIV_ROUND_UP(sizeof(*req), 16)));
-        req->le.version_cpl = htonl(F_FW_OFLD_CONNECTION_WR_CPL);
-        req->le.filter = filter;
-        req->le.lport = lport;
-        req->le.pport = rport;
-        req->le.u.ipv4.lip = laddr;
-        req->le.u.ipv4.pip = raddr;
-        req->tcb.rcv_nxt = htonl(rcv_isn + 1);
-        req->tcb.rcv_adv = htons(window);
-        req->tcb.t_state_to_astid =
-                 htonl(V_FW_OFLD_CONNECTION_WR_T_STATE(TCP_SYN_RECV) |
-                        V_FW_OFLD_CONNECTION_WR_RCV_SCALE(cpl->tcpopt.wsf) |
-                        V_FW_OFLD_CONNECTION_WR_ASTID(
-                        GET_PASS_OPEN_TID(ntohl(cpl->tos_stid))));
-
-        /*
-         * We store the qid in opt2 which will be used by the firmware
-         * to send us the wr response.
-         */
-        req->tcb.opt2 = htonl(V_RSS_QUEUE(rss_qid));
-
-        /*
-         * We initialize the MSS index in TCB to 0xF.
-         * So that when driver sends cpl_pass_accept_rpl
-         * TCB picks up the correct value. If this was 0
-         * TP will ignore any value > 0 for MSS index.
-         */
-        req->tcb.opt0 = cpu_to_be64(V_MSS_IDX(0xF));
-        req->cookie = cpu_to_be64((u64)skb);
-
-        set_wr_txq(req_skb, CPL_PRIORITY_CONTROL, port_id);
-        cxgb4_ofld_send(dev->rdev.lldi.ports[0], req_skb);
-}
-
-/*
- * Handler for CPL_RX_PKT message. Need to handle cpl_rx_pkt
- * messages when a filter is being used instead of server to
- * redirect a syn packet. When packets hit filter they are redirected
- * to the offload queue and driver tries to establish the connection
- * using firmware work request.
- */
-static int rx_pkt(struct c4iw_dev *dev, struct sk_buff *skb)
-{
-        int stid;
-        unsigned int filter;
-        struct ethhdr *eh = NULL;
-        struct vlan_ethhdr *vlan_eh = NULL;
-        struct iphdr *iph;
-        struct tcphdr *tcph;
-        struct rss_header *rss = (void *)skb->data;
-        struct cpl_rx_pkt *cpl = (void *)skb->data;
-        struct cpl_pass_accept_req *req = (void *)(rss + 1);
-        struct l2t_entry *e;
-        struct dst_entry *dst;
-        struct rtable *rt;
-        struct c4iw_ep *lep;
-        u16 window;
-        struct port_info *pi;
-        struct net_device *pdev;
-        u16 rss_qid;
-        int step;
-        u32 tx_chan;
-        struct neighbour *neigh;
-
-        /* Drop all non-SYN packets */
-        if (!(cpl->l2info & cpu_to_be32(F_RXF_SYN)))
-                goto reject;
-
-        /*
-         * Drop all packets which did not hit the filter.
-         * Unlikely to happen.
-         */
-        if (!(rss->filter_hit && rss->filter_tid))
-                goto reject;
-
-        /*
-         * Calculate the server tid from filter hit index from cpl_rx_pkt.
-         */
-        stid = cpu_to_be32(rss->hash_val) - dev->rdev.lldi.tids->sftid_base
-                                          + dev->rdev.lldi.tids->nstids;
-
-        lep = (struct c4iw_ep *)lookup_stid(dev->rdev.lldi.tids, stid);
-        if (!lep) {
-                PDBG("%s connect request on invalid stid %d\n", __func__, stid);
-                goto reject;
-        }
-
-        if (G_RX_ETHHDR_LEN(ntohl(cpl->l2info)) == ETH_HLEN) {
-                eh = (struct ethhdr *)(req + 1);
-                iph = (struct iphdr *)(eh + 1);
-        } else {
-                vlan_eh = (struct vlan_ethhdr *)(req + 1);
-                iph = (struct iphdr *)(vlan_eh + 1);
-                skb->vlan_tci = ntohs(cpl->vlan);
-        }
-
-        if (iph->version != 0x4)
-                goto reject;
-
-        tcph = (struct tcphdr *)(iph + 1);
-        skb_set_network_header(skb, (void *)iph - (void *)rss);
-        skb_set_transport_header(skb, (void *)tcph - (void *)rss);
-        skb_get(skb);
-
-        PDBG("%s lip 0x%x lport %u pip 0x%x pport %u tos %d\n", __func__,
-             ntohl(iph->daddr), ntohs(tcph->dest), ntohl(iph->saddr),
-             ntohs(tcph->source), iph->tos);
-
-        rt = find_route(dev, iph->daddr, iph->saddr, tcph->dest, tcph->source,
-                        iph->tos);
-        if (!rt) {
-                pr_err("%s - failed to find dst entry!\n",
-                       __func__);
-                goto reject;
-        }
-        dst = &rt->dst;
-        neigh = dst_neigh_lookup_skb(dst, skb);
-
-        if (neigh->dev->flags & IFF_LOOPBACK) {
-                pdev = ip_dev_find(&init_net, iph->daddr);
-                e = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh,
-                                    pdev, 0);
-                pi = (struct port_info *)netdev_priv(pdev);
-                tx_chan = cxgb4_port_chan(pdev);
-                dev_put(pdev);
-        } else {
-                e = cxgb4_l2t_get(dev->rdev.lldi.l2t, neigh,
-                                        neigh->dev, 0);
-                pi = (struct port_info *)netdev_priv(neigh->dev);
-                tx_chan = cxgb4_port_chan(neigh->dev);
-        }
-        if (!e) {
-                pr_err("%s - failed to allocate l2t entry!\n",
-                       __func__);
-                goto free_dst;
-        }
-
-        step = dev->rdev.lldi.nrxq / dev->rdev.lldi.nchan;
-        rss_qid = dev->rdev.lldi.rxq_ids[pi->port_id * step];
-        window = htons(tcph->window);
-
-        /* Calcuate filter portion for LE region. */
-        filter = cpu_to_be32(select_ntuple(dev, dst, e));
-
-        /*
-         * Synthesize the cpl_pass_accept_req. We have everything except the
-         * TID. Once firmware sends a reply with TID we update the TID field
-         * in cpl and pass it through the regular cpl_pass_accept_req path.
-         */
-        build_cpl_pass_accept_req(skb, stid, iph->tos);
-        send_fw_pass_open_req(dev, skb, iph->daddr, tcph->dest, iph->saddr,
-                              tcph->source, ntohl(tcph->seq), filter, window,
-                              rss_qid, pi->port_id);
-        cxgb4_l2t_release(e);
-free_dst:
-        dst_release(dst);
-reject:
+        c4iw_ev_dispatch(dev, (struct t4_cqe *)&rpl->data[0]);
         return 0;
 }
 
@@ -3089,8 +2156,7 @@ static c4iw_handler_func work_handlers[NUM_CPL_CMDS] = {
         [CPL_CLOSE_CON_RPL] = close_con_rpl,
         [CPL_RDMA_TERMINATE] = terminate,
         [CPL_FW4_ACK] = fw4_ack,
-        [CPL_FW6_MSG] = deferred_fw6_msg,
-        [CPL_RX_PKT] = rx_pkt
+        [CPL_FW6_MSG] = async_event
 };
 
 static void process_timeout(struct c4iw_ep *ep)
@@ -3101,7 +2167,6 @@ static void process_timeout(struct c4iw_ep *ep)
         mutex_lock(&ep->com.mutex);
         PDBG("%s ep %p tid %u state %d\n", __func__, ep, ep->hwtid,
              ep->com.state);
-        set_bit(TIMEDOUT, &ep->com.history);
         switch (ep->com.state) {
         case MPA_REQ_SENT:
                 __state_set(&ep->com, ABORTING);
@@ -3121,8 +2186,9 @@ static void process_timeout(struct c4iw_ep *ep)
                 __state_set(&ep->com, ABORTING);
                 break;
         default:
-                WARN(1, "%s unexpected state ep %p tid %u state %u\n",
+                printk(KERN_ERR "%s unexpected state ep %p tid %u state %u\n",
                         __func__, ep, ep->hwtid, ep->com.state);
+                WARN_ON(1);
                 abort = 0;
         }
         mutex_unlock(&ep->com.mutex);
@@ -3222,7 +2288,7 @@ static int fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
         PDBG("%s type %u\n", __func__, rpl->type);
 
         switch (rpl->type) {
-        case FW6_TYPE_WR_RPL:
+        case 1:
                 ret = (int)((be64_to_cpu(rpl->data[0]) >> 8) & 0xff);
                 wr_waitp = (struct c4iw_wr_wait *)(__force unsigned long) rpl->data[1];
                 PDBG("%s wr_waitp %p ret %u\n", __func__, wr_waitp, ret);
@@ -3230,8 +2296,7 @@ static int fw6_msg(struct c4iw_dev *dev, struct sk_buff *skb)
                         c4iw_wake_up(wr_waitp, ret ? -ret : 0);
                 kfree_skb(skb);
                 break;
-        case FW6_TYPE_CQE:
-        case FW6_TYPE_OFLD_CONNECTION_WR_RPL:
+        case 2:
                 sched(dev, skb);
                 break;
         default:
@@ -3251,12 +2316,6 @@ static int peer_abort_intr(struct c4iw_dev *dev, struct sk_buff *skb)
         unsigned int tid = GET_TID(req);
 
         ep = lookup_tid(t, tid);
-        if (!ep) {
-                printk(KERN_WARNING MOD
-                       "Abort on non-existent endpoint, tid %d\n", tid);
-                kfree_skb(skb);
-                return 0;
-        }
         if (is_neg_adv_abort(req->status)) {
                 PDBG("%s neg_adv_abort ep %p tid %u\n", __func__, ep,
                      ep->hwtid);
@@ -3294,8 +2353,7 @@ c4iw_handler_func c4iw_handlers[NUM_CPL_CMDS] = {
         [CPL_RDMA_TERMINATE] = sched,
         [CPL_FW4_ACK] = sched,
         [CPL_SET_TCB_RPL] = set_tcb_rpl,
-        [CPL_FW6_MSG] = fw6_msg,
-        [CPL_RX_PKT] = sched
+        [CPL_FW6_MSG] = fw6_msg
 };
 
 int __init c4iw_cm_init(void)
diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
index 0f1607c8325..1720dc790d1 100644
--- a/drivers/infiniband/hw/cxgb4/cq.c
+++ b/drivers/infiniband/hw/cxgb4/cq.c
@@ -185,7 +185,7 @@ static void insert_recv_cqe(struct t4_wq *wq, struct t4_cq *cq)
                                  V_CQE_OPCODE(FW_RI_SEND) |
                                  V_CQE_TYPE(0) |
                                  V_CQE_SWCQE(1) |
-                                 V_CQE_QPID(wq->sq.qid));
+                                 V_CQE_QPID(wq->rq.qid));
         cqe.bits_type_ts = cpu_to_be64(V_CQE_GENBIT((u64)cq->gen));
         cq->sw_queue[cq->sw_pidx] = cqe;
         t4_swcq_produce(cq);
@@ -311,7 +311,7 @@ void c4iw_count_rcqes(struct t4_cq *cq, struct t4_wq *wq, int *count)
         while (ptr != cq->sw_pidx) {
                 cqe = &cq->sw_queue[ptr];
                 if (RQ_TYPE(cqe) && (CQE_OPCODE(cqe) != FW_RI_READ_RESP) &&
-                    (CQE_QPID(cqe) == wq->sq.qid) && cqe_completes_wr(cqe, wq))
+                    (CQE_QPID(cqe) == wq->rq.qid) && cqe_completes_wr(cqe, wq))
                         (*count)++;
                 if (++ptr == cq->size)
                         ptr = 0;
@@ -818,7 +818,6 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
         chp->cq.size--;                         /* status page */
         chp->ibcq.cqe = entries - 2;
         spin_lock_init(&chp->lock);
-        spin_lock_init(&chp->comp_handler_lock);
         atomic_set(&chp->refcnt, 1);
         init_waitqueue_head(&chp->wait);
         ret = insert_handle(rhp, &rhp->cqidr, chp, chp->cq.cqid);
diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c
index ba11c76c0b5..40a13cc633a 100644
--- a/drivers/infiniband/hw/cxgb4/device.c
+++ b/drivers/infiniband/hw/cxgb4/device.c
@@ -32,7 +32,6 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/debugfs.h>
-#include <linux/vmalloc.h>
 
 #include <rdma/ib_verbs.h>
 
@@ -45,12 +44,6 @@ MODULE_DESCRIPTION("Chelsio T4 RDMA Driver");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(DRV_VERSION);
 
-struct uld_ctx {
-        struct list_head entry;
-        struct cxgb4_lld_info lldi;
-        struct c4iw_dev *dev;
-};
-
 static LIST_HEAD(uld_ctx_list);
 static DEFINE_MUTEX(dev_mutex);
 
@@ -122,7 +115,7 @@ static int qp_release(struct inode *inode, struct file *file)
                 printk(KERN_INFO "%s null qpd?\n", __func__);
                 return 0;
         }
-        vfree(qpd->buf);
+        kfree(qpd->buf);
         kfree(qpd);
         return 0;
 }
@@ -146,7 +139,7 @@ static int qp_open(struct inode *inode, struct file *file)
         spin_unlock_irq(&qpd->devp->lock);
 
         qpd->bufsize = count * 128;
-        qpd->buf = vmalloc(qpd->bufsize);
+        qpd->buf = kmalloc(qpd->bufsize, GFP_KERNEL);
         if (!qpd->buf) {
                 ret = -ENOMEM;
                 goto err1;
@@ -247,196 +240,6 @@ static const struct file_operations stag_debugfs_fops = {
         .llseek  = default_llseek,
 };
 
-static char *db_state_str[] = {"NORMAL", "FLOW_CONTROL", "RECOVERY"};
-
-static int stats_show(struct seq_file *seq, void *v)
-{
-        struct c4iw_dev *dev = seq->private;
-
-        seq_printf(seq, "   Object: %10s %10s %10s %10s\n", "Total", "Current",
-                   "Max", "Fail");
-        seq_printf(seq, "     PDID: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.pd.total, dev->rdev.stats.pd.cur,
-                        dev->rdev.stats.pd.max, dev->rdev.stats.pd.fail);
-        seq_printf(seq, "      QID: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.qid.total, dev->rdev.stats.qid.cur,
-                        dev->rdev.stats.qid.max, dev->rdev.stats.qid.fail);
-        seq_printf(seq, "   TPTMEM: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.stag.total, dev->rdev.stats.stag.cur,
-                        dev->rdev.stats.stag.max, dev->rdev.stats.stag.fail);
-        seq_printf(seq, "   PBLMEM: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.pbl.total, dev->rdev.stats.pbl.cur,
-                        dev->rdev.stats.pbl.max, dev->rdev.stats.pbl.fail);
-        seq_printf(seq, "   RQTMEM: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.rqt.total, dev->rdev.stats.rqt.cur,
-                        dev->rdev.stats.rqt.max, dev->rdev.stats.rqt.fail);
-        seq_printf(seq, "  OCQPMEM: %10llu %10llu %10llu %10llu\n",
-                        dev->rdev.stats.ocqp.total, dev->rdev.stats.ocqp.cur,
-                        dev->rdev.stats.ocqp.max, dev->rdev.stats.ocqp.fail);
-        seq_printf(seq, "  DB FULL: %10llu\n", dev->rdev.stats.db_full);
-        seq_printf(seq, " DB EMPTY: %10llu\n", dev->rdev.stats.db_empty);
-        seq_printf(seq, "  DB DROP: %10llu\n", dev->rdev.stats.db_drop);
-        seq_printf(seq, " DB State: %s Transitions %llu\n",
-                   db_state_str[dev->db_state],
-                   dev->rdev.stats.db_state_transitions);
-        seq_printf(seq, "TCAM_FULL: %10llu\n", dev->rdev.stats.tcam_full);
-        seq_printf(seq, "ACT_OFLD_CONN_FAILS: %10llu\n",
-                   dev->rdev.stats.act_ofld_conn_fails);
-        seq_printf(seq, "PAS_OFLD_CONN_FAILS: %10llu\n",
-                   dev->rdev.stats.pas_ofld_conn_fails);
-        return 0;
-}
-
-static int stats_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, stats_show, inode->i_private);
-}
-
-static ssize_t stats_clear(struct file *file, const char __user *buf,
-                size_t count, loff_t *pos)
-{
-        struct c4iw_dev *dev = ((struct seq_file *)file->private_data)->private;
-
-        mutex_lock(&dev->rdev.stats.lock);
-        dev->rdev.stats.pd.max = 0;
-        dev->rdev.stats.pd.fail = 0;
-        dev->rdev.stats.qid.max = 0;
-        dev->rdev.stats.qid.fail = 0;
-        dev->rdev.stats.stag.max = 0;
-        dev->rdev.stats.stag.fail = 0;
-        dev->rdev.stats.pbl.max = 0;
-        dev->rdev.stats.pbl.fail = 0;
-        dev->rdev.stats.rqt.max = 0;
-        dev->rdev.stats.rqt.fail = 0;
-        dev->rdev.stats.ocqp.max = 0;
-        dev->rdev.stats.ocqp.fail = 0;
-        dev->rdev.stats.db_full = 0;
-        dev->rdev.stats.db_empty = 0;
-        dev->rdev.stats.db_drop = 0;
-        dev->rdev.stats.db_state_transitions = 0;
-        dev->rdev.stats.tcam_full = 0;
-        dev->rdev.stats.act_ofld_conn_fails = 0;
-        dev->rdev.stats.pas_ofld_conn_fails = 0;
-        mutex_unlock(&dev->rdev.stats.lock);
-        return count;
-}
-
-static const struct file_operations stats_debugfs_fops = {
-        .owner   = THIS_MODULE,
-        .open    = stats_open,
-        .release = single_release,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .write   = stats_clear,
-};
-
-static int dump_ep(int id, void *p, void *data)
-{
-        struct c4iw_ep *ep = p;
-        struct c4iw_debugfs_data *epd = data;
-        int space;
-        int cc;
-
-        space = epd->bufsize - epd->pos - 1;
-        if (space == 0)
-                return 1;
-
-        cc = snprintf(epd->buf + epd->pos, space,
-                        "ep %p cm_id %p qp %p state %d flags 0x%lx history 0x%lx "
-                        "hwtid %d atid %d %pI4:%d <-> %pI4:%d\n",
-                        ep, ep->com.cm_id, ep->com.qp, (int)ep->com.state,
-                        ep->com.flags, ep->com.history, ep->hwtid, ep->atid,
-                        &ep->com.local_addr.sin_addr.s_addr,
-                        ntohs(ep->com.local_addr.sin_port),
-                        &ep->com.remote_addr.sin_addr.s_addr,
-                        ntohs(ep->com.remote_addr.sin_port));
-        if (cc < space)
-                epd->pos += cc;
-        return 0;
-}
-
-static int dump_listen_ep(int id, void *p, void *data)
-{
-        struct c4iw_listen_ep *ep = p;
-        struct c4iw_debugfs_data *epd = data;
-        int space;
-        int cc;
-
-        space = epd->bufsize - epd->pos - 1;
-        if (space == 0)
-                return 1;
-
-        cc = snprintf(epd->buf + epd->pos, space,
-                        "ep %p cm_id %p state %d flags 0x%lx stid %d backlog %d "
-                        "%pI4:%d\n", ep, ep->com.cm_id, (int)ep->com.state,
-                        ep->com.flags, ep->stid, ep->backlog,
-                        &ep->com.local_addr.sin_addr.s_addr,
-                        ntohs(ep->com.local_addr.sin_port));
-        if (cc < space)
-                epd->pos += cc;
-        return 0;
-}
-
-static int ep_release(struct inode *inode, struct file *file)
-{
-        struct c4iw_debugfs_data *epd = file->private_data;
-        if (!epd) {
-                pr_info("%s null qpd?\n", __func__);
-                return 0;
-        }
-        vfree(epd->buf);
-        kfree(epd);
-        return 0;
-}
-
-static int ep_open(struct inode *inode, struct file *file)
-{
-        struct c4iw_debugfs_data *epd;
-        int ret = 0;
-        int count = 1;
-
-        epd = kmalloc(sizeof(*epd), GFP_KERNEL);
-        if (!epd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        epd->devp = inode->i_private;
-        epd->pos = 0;
-
-        spin_lock_irq(&epd->devp->lock);
-        idr_for_each(&epd->devp->hwtid_idr, count_idrs, &count);
-        idr_for_each(&epd->devp->atid_idr, count_idrs, &count);
-        idr_for_each(&epd->devp->stid_idr, count_idrs, &count);
-        spin_unlock_irq(&epd->devp->lock);
-
-        epd->bufsize = count * 160;
-        epd->buf = vmalloc(epd->bufsize);
-        if (!epd->buf) {
-                ret = -ENOMEM;
-                goto err1;
-        }
-
-        spin_lock_irq(&epd->devp->lock);
-        idr_for_each(&epd->devp->hwtid_idr, dump_ep, epd);
-        idr_for_each(&epd->devp->atid_idr, dump_ep, epd);
-        idr_for_each(&epd->devp->stid_idr, dump_listen_ep, epd);
-        spin_unlock_irq(&epd->devp->lock);
-
-        file->private_data = epd;
-        goto out;
-err1:
-        kfree(epd);
-out:
-        return ret;
-}
-
-static const struct file_operations ep_debugfs_fops = {
-        .owner   = THIS_MODULE,
-        .open    = ep_open,
-        .release = ep_release,
-        .read    = debugfs_read,
-};
-
 static int setup_debugfs(struct c4iw_dev *devp)
 {
         struct dentry *de;
@@ -453,17 +256,6 @@ static int setup_debugfs(struct c4iw_dev *devp)
                                  (void *)devp, &stag_debugfs_fops);
         if (de && de->d_inode)
                 de->d_inode->i_size = 4096;
-
-        de = debugfs_create_file("stats", S_IWUSR, devp->debugfs_root,
-                        (void *)devp, &stats_debugfs_fops);
-        if (de && de->d_inode)
-                de->d_inode->i_size = 4096;
-
-        de = debugfs_create_file("eps", S_IWUSR, devp->debugfs_root,
-                        (void *)devp, &ep_debugfs_fops);
-        if (de && de->d_inode)
-                de->d_inode->i_size = 4096;
-
         return 0;
 }
 
@@ -477,13 +269,9 @@ void c4iw_release_dev_ucontext(struct c4iw_rdev *rdev,
         list_for_each_safe(pos, nxt, &uctx->qpids) {
                 entry = list_entry(pos, struct c4iw_qid_list, entry);
                 list_del_init(&entry->entry);
-                if (!(entry->qid & rdev->qpmask)) {
-                        c4iw_put_resource(&rdev->resource.qid_table,
-                                          entry->qid);
-                        mutex_lock(&rdev->stats.lock);
-                        rdev->stats.qid.cur -= rdev->qpmask + 1;
-                        mutex_unlock(&rdev->stats.lock);
-                }
+                if (!(entry->qid & rdev->qpmask))
+                        c4iw_put_resource(&rdev->resource.qid_fifo, entry->qid,
+                                          &rdev->resource.qid_fifo_lock);
                 kfree(entry);
         }
 
@@ -544,13 +332,6 @@ static int c4iw_rdev_open(struct c4iw_rdev *rdev)
                 goto err1;
         }
 
-        rdev->stats.pd.total = T4_MAX_NUM_PD;
-        rdev->stats.stag.total = rdev->lldi.vr->stag.size;
-        rdev->stats.pbl.total = rdev->lldi.vr->pbl.size;
-        rdev->stats.rqt.total = rdev->lldi.vr->rq.size;
-        rdev->stats.ocqp.total = rdev->lldi.vr->ocq.size;
-        rdev->stats.qid.total = rdev->lldi.vr->qp.size;
-
         err = c4iw_init_resource(rdev, c4iw_num_stags(rdev), T4_MAX_NUM_PD);
         if (err) {
                 printk(KERN_ERR MOD "error %d initializing resources\n", err);
@@ -589,44 +370,30 @@ static void c4iw_rdev_close(struct c4iw_rdev *rdev)
         c4iw_destroy_resource(&rdev->resource);
 }
 
-static void c4iw_dealloc(struct uld_ctx *ctx)
+struct uld_ctx {
+        struct list_head entry;
+        struct cxgb4_lld_info lldi;
+        struct c4iw_dev *dev;
+};
+
+static void c4iw_remove(struct uld_ctx *ctx)
 {
+        PDBG("%s c4iw_dev %p\n", __func__,  ctx->dev);
+        c4iw_unregister_device(ctx->dev);
         c4iw_rdev_close(&ctx->dev->rdev);
         idr_destroy(&ctx->dev->cqidr);
         idr_destroy(&ctx->dev->qpidr);
         idr_destroy(&ctx->dev->mmidr);
-        idr_destroy(&ctx->dev->hwtid_idr);
-        idr_destroy(&ctx->dev->stid_idr);
-        idr_destroy(&ctx->dev->atid_idr);
         iounmap(ctx->dev->rdev.oc_mw_kva);
         ib_dealloc_device(&ctx->dev->ibdev);
         ctx->dev = NULL;
 }
 
-static void c4iw_remove(struct uld_ctx *ctx)
-{
-        PDBG("%s c4iw_dev %p\n", __func__,  ctx->dev);
-        c4iw_unregister_device(ctx->dev);
-        c4iw_dealloc(ctx);
-}
-
-static int rdma_supported(const struct cxgb4_lld_info *infop)
-{
-        return infop->vr->stag.size > 0 && infop->vr->pbl.size > 0 &&
-               infop->vr->rq.size > 0 && infop->vr->qp.size > 0 &&
-               infop->vr->cq.size > 0 && infop->vr->ocq.size > 0;
-}
-
 static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
 {
         struct c4iw_dev *devp;
         int ret;
 
-        if (!rdma_supported(infop)) {
-                printk(KERN_INFO MOD "%s: RDMA not supported on this device.\n",
-                       pci_name(infop->pdev));
-                return ERR_PTR(-ENOSYS);
-        }
         devp = (struct c4iw_dev *)ib_alloc_device(sizeof(*devp));
         if (!devp) {
                 printk(KERN_ERR MOD "Cannot allocate ib device\n");
@@ -647,6 +414,7 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
 
         ret = c4iw_rdev_open(&devp->rdev);
         if (ret) {
+                mutex_unlock(&dev_mutex);
                 printk(KERN_ERR MOD "Unable to open CXIO rdev err %d\n", ret);
                 ib_dealloc_device(&devp->ibdev);
                 return ERR_PTR(ret);
@@ -655,12 +423,7 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
         idr_init(&devp->cqidr);
         idr_init(&devp->qpidr);
         idr_init(&devp->mmidr);
-        idr_init(&devp->hwtid_idr);
-        idr_init(&devp->stid_idr);
-        idr_init(&devp->atid_idr);
         spin_lock_init(&devp->lock);
-        mutex_init(&devp->rdev.stats.lock);
-        mutex_init(&devp->db_mutex);
 
         if (c4iw_debugfs_root) {
                 devp->debugfs_root = debugfs_create_dir(
@@ -703,76 +466,14 @@ out:
         return ctx;
 }
 
-static inline struct sk_buff *copy_gl_to_skb_pkt(const struct pkt_gl *gl,
-                                                 const __be64 *rsp,
-                                                 u32 pktshift)
-{
-        struct sk_buff *skb;
-
-        /*
-         * Allocate space for cpl_pass_accept_req which will be synthesized by
-         * driver. Once the driver synthesizes the request the skb will go
-         * through the regular cpl_pass_accept_req processing.
-         * The math here assumes sizeof cpl_pass_accept_req >= sizeof
-         * cpl_rx_pkt.
-         */
-        skb = alloc_skb(gl->tot_len + sizeof(struct cpl_pass_accept_req) +
-                        sizeof(struct rss_header) - pktshift, GFP_ATOMIC);
-        if (unlikely(!skb))
-                return NULL;
-
-         __skb_put(skb, gl->tot_len + sizeof(struct cpl_pass_accept_req) +
-                   sizeof(struct rss_header) - pktshift);
-
-        /*
-         * This skb will contain:
-         *   rss_header from the rspq descriptor (1 flit)
-         *   cpl_rx_pkt struct from the rspq descriptor (2 flits)
-         *   space for the difference between the size of an
-         *      rx_pkt and pass_accept_req cpl (1 flit)
-         *   the packet data from the gl
-         */
-        skb_copy_to_linear_data(skb, rsp, sizeof(struct cpl_pass_accept_req) +
-                                sizeof(struct rss_header));
-        skb_copy_to_linear_data_offset(skb, sizeof(struct rss_header) +
-                                       sizeof(struct cpl_pass_accept_req),
-                                       gl->va + pktshift,
-                                       gl->tot_len - pktshift);
-        return skb;
-}
-
-static inline int recv_rx_pkt(struct c4iw_dev *dev, const struct pkt_gl *gl,
-                           const __be64 *rsp)
-{
-        unsigned int opcode = *(u8 *)rsp;
-        struct sk_buff *skb;
-
-        if (opcode != CPL_RX_PKT)
-                goto out;
-
-        skb = copy_gl_to_skb_pkt(gl , rsp, dev->rdev.lldi.sge_pktshift);
-        if (skb == NULL)
-                goto out;
-
-        if (c4iw_handlers[opcode] == NULL) {
-                pr_info("%s no handler opcode 0x%x...\n", __func__,
-                       opcode);
-                kfree_skb(skb);
-                goto out;
-        }
-        c4iw_handlers[opcode](dev, skb);
-        return 1;
-out:
-        return 0;
-}
-
 static int c4iw_uld_rx_handler(void *handle, const __be64 *rsp,
                         const struct pkt_gl *gl)
 {
         struct uld_ctx *ctx = handle;
         struct c4iw_dev *dev = ctx->dev;
         struct sk_buff *skb;
-        u8 opcode;
+        const struct cpl_act_establish *rpl;
+        unsigned int opcode;
 
         if (gl == NULL) {
                 /* omit RSS and rsp_ctrl at end of descriptor */
@@ -789,29 +490,19 @@ static int c4iw_uld_rx_handler(void *handle, const __be64 *rsp,
                 u32 qid = be32_to_cpu(rc->pldbuflen_qid);
                 c4iw_ev_handler(dev, qid);
                 return 0;
-        } else if (unlikely(*(u8 *)rsp != *(u8 *)gl->va)) {
-                if (recv_rx_pkt(dev, gl, rsp))
-                        return 0;
-
-                pr_info("%s: unexpected FL contents at %p, " \
-                       "RSS %#llx, FL %#llx, len %u\n",
-                       pci_name(ctx->lldi.pdev), gl->va,
-                       (unsigned long long)be64_to_cpu(*rsp),
-                       (unsigned long long)be64_to_cpu(*(u64 *)gl->va),
-                       gl->tot_len);
-
-                return 0;
         } else {
                 skb = cxgb4_pktgl_to_skb(gl, 128, 128);
                 if (unlikely(!skb))
                         goto nomem;
         }
 
-        opcode = *(u8 *)rsp;
+        rpl = cplhdr(skb);
+        opcode = rpl->ot.opcode;
+
         if (c4iw_handlers[opcode])
                 c4iw_handlers[opcode](dev, skb);
         else
-                pr_info("%s no handler opcode 0x%x...\n", __func__,
+                printk(KERN_INFO "%s no handler opcode 0x%x...\n", __func__,
                        opcode);
 
         return 0;
@@ -828,24 +519,15 @@ static int c4iw_uld_state_change(void *handle, enum cxgb4_state new_state)
         case CXGB4_STATE_UP:
                 printk(KERN_INFO MOD "%s: Up\n", pci_name(ctx->lldi.pdev));
                 if (!ctx->dev) {
-                        int ret;
+                        int ret = 0;
 
                         ctx->dev = c4iw_alloc(&ctx->lldi);
-                        if (IS_ERR(ctx->dev)) {
-                                printk(KERN_ERR MOD
-                                       "%s: initialization failed: %ld\n",
-                                       pci_name(ctx->lldi.pdev),
-                                       PTR_ERR(ctx->dev));
-                                ctx->dev = NULL;
-                                break;
-                        }
-                        ret = c4iw_register_device(ctx->dev);
-                        if (ret) {
+                        if (!IS_ERR(ctx->dev))
+                                ret = c4iw_register_device(ctx->dev);
+                        if (IS_ERR(ctx->dev) || ret)
                                 printk(KERN_ERR MOD
                                        "%s: RDMA registration failed: %d\n",
                                        pci_name(ctx->lldi.pdev), ret);
-                                c4iw_dealloc(ctx);
-                        }
                 }
                 break;
         case CXGB4_STATE_DOWN:
@@ -878,234 +560,11 @@ static int c4iw_uld_state_change(void *handle, enum cxgb4_state new_state)
         return 0;
 }
 
-static int disable_qp_db(int id, void *p, void *data)
-{
-        struct c4iw_qp *qp = p;
-
-        t4_disable_wq_db(&qp->wq);
-        return 0;
-}
-
-static void stop_queues(struct uld_ctx *ctx)
-{
-        spin_lock_irq(&ctx->dev->lock);
-        if (ctx->dev->db_state == NORMAL) {
-                ctx->dev->rdev.stats.db_state_transitions++;
-                ctx->dev->db_state = FLOW_CONTROL;
-                idr_for_each(&ctx->dev->qpidr, disable_qp_db, NULL);
-        }
-        spin_unlock_irq(&ctx->dev->lock);
-}
-
-static int enable_qp_db(int id, void *p, void *data)
-{
-        struct c4iw_qp *qp = p;
-
-        t4_enable_wq_db(&qp->wq);
-        return 0;
-}
-
-static void resume_queues(struct uld_ctx *ctx)
-{
-        spin_lock_irq(&ctx->dev->lock);
-        if (ctx->dev->qpcnt <= db_fc_threshold &&
-            ctx->dev->db_state == FLOW_CONTROL) {
-                ctx->dev->db_state = NORMAL;
-                ctx->dev->rdev.stats.db_state_transitions++;
-                idr_for_each(&ctx->dev->qpidr, enable_qp_db, NULL);
-        }
-        spin_unlock_irq(&ctx->dev->lock);
-}
-
-struct qp_list {
-        unsigned idx;
-        struct c4iw_qp **qps;
-};
-
-static int add_and_ref_qp(int id, void *p, void *data)
-{
-        struct qp_list *qp_listp = data;
-        struct c4iw_qp *qp = p;
-
-        c4iw_qp_add_ref(&qp->ibqp);
-        qp_listp->qps[qp_listp->idx++] = qp;
-        return 0;
-}
-
-static int count_qps(int id, void *p, void *data)
-{
-        unsigned *countp = data;
-        (*countp)++;
-        return 0;
-}
-
-static void deref_qps(struct qp_list qp_list)
-{
-        int idx;
-
-        for (idx = 0; idx < qp_list.idx; idx++)
-                c4iw_qp_rem_ref(&qp_list.qps[idx]->ibqp);
-}
-
-static void recover_lost_dbs(struct uld_ctx *ctx, struct qp_list *qp_list)
-{
-        int idx;
-        int ret;
-
-        for (idx = 0; idx < qp_list->idx; idx++) {
-                struct c4iw_qp *qp = qp_list->qps[idx];
-
-                ret = cxgb4_sync_txq_pidx(qp->rhp->rdev.lldi.ports[0],
-                                          qp->wq.sq.qid,
-                                          t4_sq_host_wq_pidx(&qp->wq),
-                                          t4_sq_wq_size(&qp->wq));
-                if (ret) {
-                        printk(KERN_ERR MOD "%s: Fatal error - "
-                               "DB overflow recovery failed - "
-                               "error syncing SQ qid %u\n",
-                               pci_name(ctx->lldi.pdev), qp->wq.sq.qid);
-                        return;
-                }
-
-                ret = cxgb4_sync_txq_pidx(qp->rhp->rdev.lldi.ports[0],
-                                          qp->wq.rq.qid,
-                                          t4_rq_host_wq_pidx(&qp->wq),
-                                          t4_rq_wq_size(&qp->wq));
-
-                if (ret) {
-                        printk(KERN_ERR MOD "%s: Fatal error - "
-                               "DB overflow recovery failed - "
-                               "error syncing RQ qid %u\n",
-                               pci_name(ctx->lldi.pdev), qp->wq.rq.qid);
-                        return;
-                }
-
-                /* Wait for the dbfifo to drain */
-                while (cxgb4_dbfifo_count(qp->rhp->rdev.lldi.ports[0], 1) > 0) {
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        schedule_timeout(usecs_to_jiffies(10));
-                }
-        }
-}
-
-static void recover_queues(struct uld_ctx *ctx)
-{
-        int count = 0;
-        struct qp_list qp_list;
-        int ret;
-
-        /* lock out kernel db ringers */
-        mutex_lock(&ctx->dev->db_mutex);
-
-        /* put all queues in to recovery mode */
-        spin_lock_irq(&ctx->dev->lock);
-        ctx->dev->db_state = RECOVERY;
-        ctx->dev->rdev.stats.db_state_transitions++;
-        idr_for_each(&ctx->dev->qpidr, disable_qp_db, NULL);
-        spin_unlock_irq(&ctx->dev->lock);
-
-        /* slow everybody down */
-        set_current_state(TASK_UNINTERRUPTIBLE);
-        schedule_timeout(usecs_to_jiffies(1000));
-
-        /* Wait for the dbfifo to completely drain. */
-        while (cxgb4_dbfifo_count(ctx->dev->rdev.lldi.ports[0], 1) > 0) {
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(usecs_to_jiffies(10));
-        }
-
-        /* flush the SGE contexts */
-        ret = cxgb4_flush_eq_cache(ctx->dev->rdev.lldi.ports[0]);
-        if (ret) {
-                printk(KERN_ERR MOD "%s: Fatal error - DB overflow recovery failed\n",
-                       pci_name(ctx->lldi.pdev));
-                goto out;
-        }
-
-        /* Count active queues so we can build a list of queues to recover */
-        spin_lock_irq(&ctx->dev->lock);
-        idr_for_each(&ctx->dev->qpidr, count_qps, &count);
-
-        qp_list.qps = kzalloc(count * sizeof *qp_list.qps, GFP_ATOMIC);
-        if (!qp_list.qps) {
-                printk(KERN_ERR MOD "%s: Fatal error - DB overflow recovery failed\n",
-                       pci_name(ctx->lldi.pdev));
-                spin_unlock_irq(&ctx->dev->lock);
-                goto out;
-        }
-        qp_list.idx = 0;
-
-        /* add and ref each qp so it doesn't get freed */
-        idr_for_each(&ctx->dev->qpidr, add_and_ref_qp, &qp_list);
-
-        spin_unlock_irq(&ctx->dev->lock);
-
-        /* now traverse the list in a safe context to recover the db state*/
-        recover_lost_dbs(ctx, &qp_list);
-
-        /* we're almost done!  deref the qps and clean up */
-        deref_qps(qp_list);
-        kfree(qp_list.qps);
-
-        /* Wait for the dbfifo to completely drain again */
-        while (cxgb4_dbfifo_count(ctx->dev->rdev.lldi.ports[0], 1) > 0) {
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(usecs_to_jiffies(10));
-        }
-
-        /* resume the queues */
-        spin_lock_irq(&ctx->dev->lock);
-        if (ctx->dev->qpcnt > db_fc_threshold)
-                ctx->dev->db_state = FLOW_CONTROL;
-        else {
-                ctx->dev->db_state = NORMAL;
-                idr_for_each(&ctx->dev->qpidr, enable_qp_db, NULL);
-        }
-        ctx->dev->rdev.stats.db_state_transitions++;
-        spin_unlock_irq(&ctx->dev->lock);
-
-out:
-        /* start up kernel db ringers again */
-        mutex_unlock(&ctx->dev->db_mutex);
-}
-
-static int c4iw_uld_control(void *handle, enum cxgb4_control control, ...)
-{
-        struct uld_ctx *ctx = handle;
-
-        switch (control) {
-        case CXGB4_CONTROL_DB_FULL:
-                stop_queues(ctx);
-                mutex_lock(&ctx->dev->rdev.stats.lock);
-                ctx->dev->rdev.stats.db_full++;
-                mutex_unlock(&ctx->dev->rdev.stats.lock);
-                break;
-        case CXGB4_CONTROL_DB_EMPTY:
-                resume_queues(ctx);
-                mutex_lock(&ctx->dev->rdev.stats.lock);
-                ctx->dev->rdev.stats.db_empty++;
-                mutex_unlock(&ctx->dev->rdev.stats.lock);
-                break;
-        case CXGB4_CONTROL_DB_DROP:
-                recover_queues(ctx);
-                mutex_lock(&ctx->dev->rdev.stats.lock);
-                ctx->dev->rdev.stats.db_drop++;
-                mutex_unlock(&ctx->dev->rdev.stats.lock);
-                break;
-        default:
-                printk(KERN_WARNING MOD "%s: unknown control cmd %u\n",
-                       pci_name(ctx->lldi.pdev), control);
-                break;
-        }
-        return 0;
-}
-
 static struct cxgb4_uld_info c4iw_uld_info = {
         .name = DRV_NAME,
         .add = c4iw_uld_add,
         .rx_handler = c4iw_uld_rx_handler,
         .state_change = c4iw_uld_state_change,
-        .control = c4iw_uld_control,
 };
 
 static int __init c4iw_init_module(void)
diff --git a/drivers/infiniband/hw/cxgb4/ev.c b/drivers/infiniband/hw/cxgb4/ev.c
index cf2f6b47617..c13041a0aeb 100644
--- a/drivers/infiniband/hw/cxgb4/ev.c
+++ b/drivers/infiniband/hw/cxgb4/ev.c
@@ -42,7 +42,6 @@ static void post_qp_event(struct c4iw_dev *dev, struct c4iw_cq *chp,
 {
         struct ib_event event;
         struct c4iw_qp_attributes attrs;
-        unsigned long flag;
 
         if ((qhp->attr.state == C4IW_QP_STATE_ERROR) ||
             (qhp->attr.state == C4IW_QP_STATE_TERMINATE)) {
@@ -73,9 +72,7 @@ static void post_qp_event(struct c4iw_dev *dev, struct c4iw_cq *chp,
         if (qhp->ibqp.event_handler)
                 (*qhp->ibqp.event_handler)(&event, qhp->ibqp.qp_context);
 
-        spin_lock_irqsave(&chp->comp_handler_lock, flag);
         (*chp->ibcq.comp_handler)(&chp->ibcq, chp->ibcq.cq_context);
-        spin_unlock_irqrestore(&chp->comp_handler_lock, flag);
 }
 
 void c4iw_ev_dispatch(struct c4iw_dev *dev, struct t4_cqe *err_cqe)
@@ -84,7 +81,7 @@ void c4iw_ev_dispatch(struct c4iw_dev *dev, struct t4_cqe *err_cqe)
         struct c4iw_qp *qhp;
         u32 cqid;
 
-        spin_lock_irq(&dev->lock);
+        spin_lock(&dev->lock);
         qhp = get_qhp(dev, CQE_QPID(err_cqe));
         if (!qhp) {
                 printk(KERN_ERR MOD "BAD AE qpid 0x%x opcode %d "
@@ -93,7 +90,7 @@ void c4iw_ev_dispatch(struct c4iw_dev *dev, struct t4_cqe *err_cqe)
                        CQE_OPCODE(err_cqe), CQE_STATUS(err_cqe),
                        CQE_TYPE(err_cqe), CQE_WRID_HI(err_cqe),
                        CQE_WRID_LOW(err_cqe));
-                spin_unlock_irq(&dev->lock);
+                spin_unlock(&dev->lock);
                 goto out;
         }
 
@@ -109,13 +106,13 @@ void c4iw_ev_dispatch(struct c4iw_dev *dev, struct t4_cqe *err_cqe)
                        CQE_OPCODE(err_cqe), CQE_STATUS(err_cqe),
                        CQE_TYPE(err_cqe), CQE_WRID_HI(err_cqe),
                        CQE_WRID_LOW(err_cqe));
-                spin_unlock_irq(&dev->lock);
+                spin_unlock(&dev->lock);
                 goto out;
         }
 
         c4iw_qp_add_ref(&qhp->ibqp);
         atomic_inc(&chp->refcnt);
-        spin_unlock_irq(&dev->lock);
+        spin_unlock(&dev->lock);
 
         /* Bad incoming write */
         if (RQ_TYPE(err_cqe) &&
@@ -186,14 +183,11 @@ out:
 int c4iw_ev_handler(struct c4iw_dev *dev, u32 qid)
 {
         struct c4iw_cq *chp;
-        unsigned long flag;
 
         chp = get_chp(dev, qid);
-        if (chp) {
-                spin_lock_irqsave(&chp->comp_handler_lock, flag);
+        if (chp)
                 (*chp->ibcq.comp_handler)(&chp->ibcq, chp->ibcq.cq_context);
-                spin_unlock_irqrestore(&chp->comp_handler_lock, flag);
-        } else
+        else
                 PDBG("%s unknown cqid 0x%x\n", __func__, qid);
         return 0;
 }
diff --git a/drivers/infiniband/hw/cxgb4/id_table.c b/drivers/infiniband/hw/cxgb4/id_table.c
deleted file mode 100644
index f95e5df30db..00000000000
--- a/drivers/infiniband/hw/cxgb4/id_table.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2011 Chelsio 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/kernel.h>
-#include <linux/random.h>
-#include "iw_cxgb4.h"
-
-#define RANDOM_SKIP 16
-
-/*
- * Trivial bitmap-based allocator. If the random flag is set, the
- * allocator is designed to:
- * - pseudo-randomize the id returned such that it is not trivially predictable.
- * - avoid reuse of recently used id (at the expense of predictability)
- */
-u32 c4iw_id_alloc(struct c4iw_id_table *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)
-                obj = find_first_zero_bit(alloc->table, alloc->max);
-
-        if (obj < alloc->max) {
-                if (alloc->flags & C4IW_ID_TABLE_F_RANDOM)
-                        alloc->last += random32() % RANDOM_SKIP;
-                else
-                        alloc->last = obj + 1;
-                if (alloc->last >= alloc->max)
-                        alloc->last = 0;
-                set_bit(obj, alloc->table);
-                obj += alloc->start;
-        } else
-                obj = -1;
-
-        spin_unlock_irqrestore(&alloc->lock, flags);
-        return obj;
-}
-
-void c4iw_id_free(struct c4iw_id_table *alloc, u32 obj)
-{
-        unsigned long flags;
-
-        obj -= alloc->start;
-        BUG_ON((int)obj < 0);
-
-        spin_lock_irqsave(&alloc->lock, flags);
-        clear_bit(obj, alloc->table);
-        spin_unlock_irqrestore(&alloc->lock, flags);
-}
-
-int c4iw_id_table_alloc(struct c4iw_id_table *alloc, u32 start, u32 num,
-                        u32 reserved, u32 flags)
-{
-        int i;
-
-        alloc->start = start;
-        alloc->flags = flags;
-        if (flags & C4IW_ID_TABLE_F_RANDOM)
-                alloc->last = random32() % RANDOM_SKIP;
-        else
-                alloc->last = 0;
-        alloc->max  = num;
-        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);
-        if (!(alloc->flags & C4IW_ID_TABLE_F_EMPTY))
-                for (i = 0; i < reserved; ++i)
-                        set_bit(i, alloc->table);
-
-        return 0;
-}
-
-void c4iw_id_table_free(struct c4iw_id_table *alloc)
-{
-        kfree(alloc->table);
-}
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index 9c1644fb025..4f045375c8e 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -45,6 +45,7 @@
 #include <linux/kref.h>
 #include <linux/timer.h>
 #include <linux/io.h>
+#include <linux/kfifo.h>
 
 #include <asm/byteorder.h>
 
@@ -78,22 +79,13 @@ static inline void *cplhdr(struct sk_buff *skb)
         return skb->data;
 }
 
-#define C4IW_ID_TABLE_F_RANDOM 1       /* Pseudo-randomize the id's returned */
-#define C4IW_ID_TABLE_F_EMPTY  2       /* Table is initially empty */
-
-struct c4iw_id_table {
-        u32 flags;
-        u32 start;              /* logical minimal id */
-        u32 last;               /* hint for find */
-        u32 max;
-        spinlock_t lock;
-        unsigned long *table;
-};
-
 struct c4iw_resource {
-        struct c4iw_id_table tpt_table;
-        struct c4iw_id_table qid_table;
-        struct c4iw_id_table pdid_table;
+        struct kfifo tpt_fifo;
+        spinlock_t tpt_fifo_lock;
+        struct kfifo qid_fifo;
+        spinlock_t qid_fifo_lock;
+        struct kfifo pdid_fifo;
+        spinlock_t pdid_fifo_lock;
 };
 
 struct c4iw_qid_list {
@@ -111,30 +103,6 @@ enum c4iw_rdev_flags {
         T4_FATAL_ERROR = (1<<0),
 };
 
-struct c4iw_stat {
-        u64 total;
-        u64 cur;
-        u64 max;
-        u64 fail;
-};
-
-struct c4iw_stats {
-        struct mutex lock;
-        struct c4iw_stat qid;
-        struct c4iw_stat pd;
-        struct c4iw_stat stag;
-        struct c4iw_stat pbl;
-        struct c4iw_stat rqt;
-        struct c4iw_stat ocqp;
-        u64  db_full;
-        u64  db_empty;
-        u64  db_drop;
-        u64  db_state_transitions;
-        u64  tcam_full;
-        u64  act_ofld_conn_fails;
-        u64  pas_ofld_conn_fails;
-};
-
 struct c4iw_rdev {
         struct c4iw_resource resource;
         unsigned long qpshift;
@@ -149,7 +117,6 @@ struct c4iw_rdev {
         struct cxgb4_lld_info lldi;
         unsigned long oc_mw_pa;
         void __iomem *oc_mw_kva;
-        struct c4iw_stats stats;
 };
 
 static inline int c4iw_fatal_error(struct c4iw_rdev *rdev)
@@ -208,12 +175,6 @@ static inline int c4iw_wait_for_reply(struct c4iw_rdev *rdev,
         return wr_waitp->ret;
 }
 
-enum db_state {
-        NORMAL = 0,
-        FLOW_CONTROL = 1,
-        RECOVERY = 2
-};
-
 struct c4iw_dev {
         struct ib_device ibdev;
         struct c4iw_rdev rdev;
@@ -222,13 +183,7 @@ struct c4iw_dev {
         struct idr qpidr;
         struct idr mmidr;
         spinlock_t lock;
-        struct mutex db_mutex;
         struct dentry *debugfs_root;
-        enum db_state db_state;
-        int qpcnt;
-        struct idr hwtid_idr;
-        struct idr atid_idr;
-        struct idr stid_idr;
 };
 
 static inline struct c4iw_dev *to_c4iw_dev(struct ib_device *ibdev)
@@ -256,57 +211,29 @@ static inline struct c4iw_mr *get_mhp(struct c4iw_dev *rhp, u32 mmid)
         return idr_find(&rhp->mmidr, mmid);
 }
 
-static inline int _insert_handle(struct c4iw_dev *rhp, struct idr *idr,
-                                 void *handle, u32 id, int lock)
+static inline int insert_handle(struct c4iw_dev *rhp, struct idr *idr,
+                                void *handle, u32 id)
 {
         int ret;
         int newid;
 
         do {
-                if (!idr_pre_get(idr, lock ? GFP_KERNEL : GFP_ATOMIC))
+                if (!idr_pre_get(idr, GFP_KERNEL))
                         return -ENOMEM;
-                if (lock)
-                        spin_lock_irq(&rhp->lock);
+                spin_lock_irq(&rhp->lock);
                 ret = idr_get_new_above(idr, handle, id, &newid);
-                BUG_ON(!ret && newid != id);
-                if (lock)
-                        spin_unlock_irq(&rhp->lock);
+                BUG_ON(newid != id);
+                spin_unlock_irq(&rhp->lock);
         } while (ret == -EAGAIN);
 
         return ret;
 }
 
-static inline int insert_handle(struct c4iw_dev *rhp, struct idr *idr,
-                                void *handle, u32 id)
-{
-        return _insert_handle(rhp, idr, handle, id, 1);
-}
-
-static inline int insert_handle_nolock(struct c4iw_dev *rhp, struct idr *idr,
-                                       void *handle, u32 id)
-{
-        return _insert_handle(rhp, idr, handle, id, 0);
-}
-
-static inline void _remove_handle(struct c4iw_dev *rhp, struct idr *idr,
-                                   u32 id, int lock)
-{
-        if (lock)
-                spin_lock_irq(&rhp->lock);
-        idr_remove(idr, id);
-        if (lock)
-                spin_unlock_irq(&rhp->lock);
-}
-
 static inline void remove_handle(struct c4iw_dev *rhp, struct idr *idr, u32 id)
 {
-        _remove_handle(rhp, idr, id, 1);
-}
-
-static inline void remove_handle_nolock(struct c4iw_dev *rhp,
-                                         struct idr *idr, u32 id)
-{
-        _remove_handle(rhp, idr, id, 0);
+        spin_lock_irq(&rhp->lock);
+        idr_remove(idr, id);
+        spin_unlock_irq(&rhp->lock);
 }
 
 struct c4iw_pd {
@@ -382,7 +309,6 @@ struct c4iw_cq {
         struct c4iw_dev *rhp;
         struct t4_cq cq;
         spinlock_t lock;
-        spinlock_t comp_handler_lock;
         atomic_t refcnt;
         wait_queue_head_t wait;
 };
@@ -397,7 +323,6 @@ struct c4iw_mpa_attributes {
         u8 recv_marker_enabled;
         u8 xmit_marker_enabled;
         u8 crc_enabled;
-        u8 enhanced_rdma_conn;
         u8 version;
         u8 p2p_type;
 };
@@ -424,10 +349,6 @@ struct c4iw_qp_attributes {
         u8 is_terminate_local;
         struct c4iw_mpa_attributes mpa_attr;
         struct c4iw_ep *llp_stream_handle;
-        u8 layer_etype;
-        u8 ecode;
-        u16 sq_db_inc;
-        u16 rq_db_inc;
 };
 
 struct c4iw_qp {
@@ -502,8 +423,6 @@ static inline void insert_mmap(struct c4iw_ucontext *ucontext,
 
 enum c4iw_qp_attr_mask {
         C4IW_QP_ATTR_NEXT_STATE = 1 << 0,
-        C4IW_QP_ATTR_SQ_DB = 1<<1,
-        C4IW_QP_ATTR_RQ_DB = 1<<2,
         C4IW_QP_ATTR_ENABLE_RDMA_READ = 1 << 7,
         C4IW_QP_ATTR_ENABLE_RDMA_WRITE = 1 << 8,
         C4IW_QP_ATTR_ENABLE_RDMA_BIND = 1 << 9,
@@ -557,23 +476,6 @@ static inline int c4iw_convert_state(enum ib_qp_state ib_state)
         }
 }
 
-static inline int to_ib_qp_state(int c4iw_qp_state)
-{
-        switch (c4iw_qp_state) {
-        case C4IW_QP_STATE_IDLE:
-                return IB_QPS_INIT;
-        case C4IW_QP_STATE_RTS:
-                return IB_QPS_RTS;
-        case C4IW_QP_STATE_CLOSING:
-                return IB_QPS_SQD;
-        case C4IW_QP_STATE_TERMINATE:
-                return IB_QPS_SQE;
-        case C4IW_QP_STATE_ERROR:
-                return IB_QPS_ERR;
-        }
-        return IB_QPS_ERR;
-}
-
 static inline u32 c4iw_ib_to_tpt_access(int a)
 {
         return (a & IB_ACCESS_REMOTE_WRITE ? FW_RI_MEM_ACCESS_REM_WRITE : 0) |
@@ -599,18 +501,11 @@ enum c4iw_mmid_state {
 #define MPA_KEY_REP "MPA ID Rep Frame"
 
 #define MPA_MAX_PRIVATE_DATA    256
-#define MPA_ENHANCED_RDMA_CONN  0x10
 #define MPA_REJECT              0x20
 #define MPA_CRC                 0x40
 #define MPA_MARKERS             0x80
 #define MPA_FLAGS_MASK          0xE0
 
-#define MPA_V2_PEER2PEER_MODEL          0x8000
-#define MPA_V2_ZERO_LEN_FPDU_RTR        0x4000
-#define MPA_V2_RDMA_WRITE_RTR           0x8000
-#define MPA_V2_RDMA_READ_RTR            0x4000
-#define MPA_V2_IRD_ORD_MASK             0x3FFF
-
 #define c4iw_put_ep(ep) { \
         PDBG("put_ep (via %s:%u) ep %p refcnt %d\n", __func__, __LINE__,  \
              ep, atomic_read(&((ep)->kref.refcount))); \
@@ -633,11 +528,6 @@ struct mpa_message {
         u8 private_data[0];
 };
 
-struct mpa_v2_conn_params {
-        __be16 ird;
-        __be16 ord;
-};
-
 struct terminate_message {
         u8 layer_etype;
         u8 ecode;
@@ -690,10 +580,7 @@ enum c4iw_ddp_ecodes {
 
 enum c4iw_mpa_ecodes {
         MPA_CRC_ERR             = 0x02,
-        MPA_MARKER_ERR          = 0x03,
-        MPA_LOCAL_CATA          = 0x05,
-        MPA_INSUFF_IRD          = 0x06,
-        MPA_NOMATCH_RTR         = 0x07,
+        MPA_MARKER_ERR          = 0x03
 };
 
 enum c4iw_ep_state {
@@ -718,31 +605,6 @@ enum c4iw_ep_flags {
         CLOSE_SENT              = 3,
 };
 
-enum c4iw_ep_history {
-        ACT_OPEN_REQ            = 0,
-        ACT_OFLD_CONN           = 1,
-        ACT_OPEN_RPL            = 2,
-        ACT_ESTAB               = 3,
-        PASS_ACCEPT_REQ         = 4,
-        PASS_ESTAB              = 5,
-        ABORT_UPCALL            = 6,
-        ESTAB_UPCALL            = 7,
-        CLOSE_UPCALL            = 8,
-        ULP_ACCEPT              = 9,
-        ULP_REJECT              = 10,
-        TIMEDOUT                = 11,
-        PEER_ABORT              = 12,
-        PEER_CLOSE              = 13,
-        CONNREQ_UPCALL          = 14,
-        ABORT_CONN              = 15,
-        DISCONN_UPCALL          = 16,
-        EP_DISC_CLOSE           = 17,
-        EP_DISC_ABORT           = 18,
-        CONN_RPL_UPCALL         = 19,
-        ACT_RETRY_NOMEM         = 20,
-        ACT_RETRY_INUSE         = 21
-};
-
 struct c4iw_ep_common {
         struct iw_cm_id *cm_id;
         struct c4iw_qp *qp;
@@ -754,7 +616,6 @@ struct c4iw_ep_common {
         struct sockaddr_in remote_addr;
         struct c4iw_wr_wait wr_wait;
         unsigned long flags;
-        unsigned long history;
 };
 
 struct c4iw_listen_ep {
@@ -790,9 +651,6 @@ struct c4iw_ep {
         u16 txq_idx;
         u16 ctrlq_idx;
         u8 tos;
-        u8 retry_with_mpa_v1;
-        u8 tried_with_mpa_v1;
-        unsigned int retry_count;
 };
 
 static inline struct c4iw_ep *to_ep(struct iw_cm_id *cm_id)
@@ -814,20 +672,14 @@ static inline int compute_wscale(int win)
         return wscale;
 }
 
-u32 c4iw_id_alloc(struct c4iw_id_table *alloc);
-void c4iw_id_free(struct c4iw_id_table *alloc, u32 obj);
-int c4iw_id_table_alloc(struct c4iw_id_table *alloc, u32 start, u32 num,
-                        u32 reserved, u32 flags);
-void c4iw_id_table_free(struct c4iw_id_table *alloc);
-
 typedef int (*c4iw_handler_func)(struct c4iw_dev *dev, struct sk_buff *skb);
 
 int c4iw_ep_redirect(void *ctx, struct dst_entry *old, struct dst_entry *new,
                      struct l2t_entry *l2t);
 void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qpid,
                    struct c4iw_dev_ucontext *uctx);
-u32 c4iw_get_resource(struct c4iw_id_table *id_table);
-void c4iw_put_resource(struct c4iw_id_table *id_table, u32 entry);
+u32 c4iw_get_resource(struct kfifo *fifo, spinlock_t *lock);
+void c4iw_put_resource(struct kfifo *fifo, u32 entry, spinlock_t *lock);
 int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, u32 nr_pdid);
 int c4iw_init_ctrl_qp(struct c4iw_rdev *rdev);
 int c4iw_pblpool_create(struct c4iw_rdev *rdev);
@@ -896,8 +748,6 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd,
                              struct ib_udata *udata);
 int c4iw_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                                  int attr_mask, struct ib_udata *udata);
-int c4iw_ib_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
-                     int attr_mask, struct ib_qp_init_attr *init_attr);
 struct ib_qp *c4iw_get_qp(struct ib_device *dev, int qpn);
 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size);
 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size);
@@ -926,7 +776,5 @@ void c4iw_ev_dispatch(struct c4iw_dev *dev, struct t4_cqe *err_cqe);
 extern struct cxgb4_client t4c_client;
 extern c4iw_handler_func c4iw_handlers[NUM_CPL_CMDS];
 extern int c4iw_max_read_depth;
-extern int db_fc_threshold;
-
 
 #endif
diff --git a/drivers/infiniband/hw/cxgb4/mem.c b/drivers/infiniband/hw/cxgb4/mem.c
index afd81790ab3..40c835309e4 100644
--- a/drivers/infiniband/hw/cxgb4/mem.c
+++ b/drivers/infiniband/hw/cxgb4/mem.c
@@ -131,14 +131,10 @@ static int write_tpt_entry(struct c4iw_rdev *rdev, u32 reset_tpt_entry,
         stag_idx = (*stag) >> 8;
 
         if ((!reset_tpt_entry) && (*stag == T4_STAG_UNSET)) {
-                stag_idx = c4iw_get_resource(&rdev->resource.tpt_table);
+                stag_idx = c4iw_get_resource(&rdev->resource.tpt_fifo,
+                                             &rdev->resource.tpt_fifo_lock);
                 if (!stag_idx)
                         return -ENOMEM;
-                mutex_lock(&rdev->stats.lock);
-                rdev->stats.stag.cur += 32;
-                if (rdev->stats.stag.cur > rdev->stats.stag.max)
-                        rdev->stats.stag.max = rdev->stats.stag.cur;
-                mutex_unlock(&rdev->stats.lock);
                 *stag = (stag_idx << 8) | (atomic_inc_return(&key) & 0xff);
         }
         PDBG("%s stag_state 0x%0x type 0x%0x pdid 0x%0x, stag_idx 0x%x\n",
@@ -169,12 +165,9 @@ static int write_tpt_entry(struct c4iw_rdev *rdev, u32 reset_tpt_entry,
                                 (rdev->lldi.vr->stag.start >> 5),
                                 sizeof(tpt), &tpt);
 
-        if (reset_tpt_entry) {
-                c4iw_put_resource(&rdev->resource.tpt_table, stag_idx);
-                mutex_lock(&rdev->stats.lock);
-                rdev->stats.stag.cur -= 32;
-                mutex_unlock(&rdev->stats.lock);
-        }
+        if (reset_tpt_entry)
+                c4iw_put_resource(&rdev->resource.tpt_fifo, stag_idx,
+                                  &rdev->resource.tpt_fifo_lock);
         return err;
 }
 
@@ -468,7 +461,7 @@ struct ib_mr *c4iw_register_phys_mem(struct ib_pd *pd,
         ret = alloc_pbl(mhp, npages);
         if (ret) {
                 kfree(page_list);
-                goto err;
+                goto err_pbl;
         }
 
         ret = write_pbl(&mhp->rhp->rdev, page_list, mhp->attr.pbl_addr,
@@ -693,8 +686,8 @@ int c4iw_dealloc_mw(struct ib_mw *mw)
         mhp = to_c4iw_mw(mw);
         rhp = mhp->rhp;
         mmid = (mw->rkey) >> 8;
-        remove_handle(rhp, &rhp->mmidr, mmid);
         deallocate_window(&rhp->rdev, mhp->attr.stag);
+        remove_handle(rhp, &rhp->mmidr, mmid);
         kfree(mhp);
         PDBG("%s ib_mw %p mmid 0x%x ptr %p\n", __func__, mw, mmid, mhp);
         return 0;
@@ -796,12 +789,12 @@ int c4iw_dereg_mr(struct ib_mr *ib_mr)
         mhp = to_c4iw_mr(ib_mr);
         rhp = mhp->rhp;
         mmid = mhp->attr.stag >> 8;
-        remove_handle(rhp, &rhp->mmidr, mmid);
         dereg_mem(&rhp->rdev, mhp->attr.stag, mhp->attr.pbl_size,
                        mhp->attr.pbl_addr);
         if (mhp->attr.pbl_size)
                 c4iw_pblpool_free(&mhp->rhp->rdev, mhp->attr.pbl_addr,
                                   mhp->attr.pbl_size << 3);
+        remove_handle(rhp, &rhp->mmidr, mmid);
         if (mhp->kva)
                 kfree((void *) (unsigned long) mhp->kva);
         if (mhp->umem)
diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
index e084fdc6da7..247fe706e7f 100644
--- a/drivers/infiniband/hw/cxgb4/provider.c
+++ b/drivers/infiniband/hw/cxgb4/provider.c
@@ -188,10 +188,8 @@ static int c4iw_deallocate_pd(struct ib_pd *pd)
         php = to_c4iw_pd(pd);
         rhp = php->rhp;
         PDBG("%s ibpd %p pdid 0x%x\n", __func__, pd, php->pdid);
-        c4iw_put_resource(&rhp->rdev.resource.pdid_table, php->pdid);
-        mutex_lock(&rhp->rdev.stats.lock);
-        rhp->rdev.stats.pd.cur--;
-        mutex_unlock(&rhp->rdev.stats.lock);
+        c4iw_put_resource(&rhp->rdev.resource.pdid_fifo, php->pdid,
+                          &rhp->rdev.resource.pdid_fifo_lock);
         kfree(php);
         return 0;
 }
@@ -206,12 +204,14 @@ static struct ib_pd *c4iw_allocate_pd(struct ib_device *ibdev,
 
         PDBG("%s ibdev %p\n", __func__, ibdev);
         rhp = (struct c4iw_dev *) ibdev;
-        pdid =  c4iw_get_resource(&rhp->rdev.resource.pdid_table);
+        pdid =  c4iw_get_resource(&rhp->rdev.resource.pdid_fifo,
+                                  &rhp->rdev.resource.pdid_fifo_lock);
         if (!pdid)
                 return ERR_PTR(-EINVAL);
         php = kzalloc(sizeof(*php), GFP_KERNEL);
         if (!php) {
-                c4iw_put_resource(&rhp->rdev.resource.pdid_table, pdid);
+                c4iw_put_resource(&rhp->rdev.resource.pdid_fifo, pdid,
+                                  &rhp->rdev.resource.pdid_fifo_lock);
                 return ERR_PTR(-ENOMEM);
         }
         php->pdid = pdid;
@@ -222,11 +222,6 @@ static struct ib_pd *c4iw_allocate_pd(struct ib_device *ibdev,
                         return ERR_PTR(-EFAULT);
                 }
         }
-        mutex_lock(&rhp->rdev.stats.lock);
-        rhp->rdev.stats.pd.cur++;
-        if (rhp->rdev.stats.pd.cur > rhp->rdev.stats.pd.max)
-                rhp->rdev.stats.pd.max = rhp->rdev.stats.pd.cur;
-        mutex_unlock(&rhp->rdev.stats.lock);
         PDBG("%s pdid 0x%0x ptr 0x%p\n", __func__, pdid, php);
         return &php->ibpd;
 }
@@ -334,7 +329,7 @@ static int c4iw_query_port(struct ib_device *ibdev, u8 port,
         props->gid_tbl_len = 1;
         props->pkey_tbl_len = 1;
         props->active_width = 2;
-        props->active_speed = IB_SPEED_DDR;
+        props->active_speed = 2;
         props->max_msg_sz = -1;
 
         return 0;
@@ -443,7 +438,6 @@ int c4iw_register_device(struct c4iw_dev *dev)
             (1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ) |
             (1ull << IB_USER_VERBS_CMD_CREATE_QP) |
             (1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
-            (1ull << IB_USER_VERBS_CMD_QUERY_QP) |
             (1ull << IB_USER_VERBS_CMD_POLL_CQ) |
             (1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
             (1ull << IB_USER_VERBS_CMD_POST_SEND) |
@@ -466,7 +460,6 @@ int c4iw_register_device(struct c4iw_dev *dev)
         dev->ibdev.destroy_ah = c4iw_ah_destroy;
         dev->ibdev.create_qp = c4iw_create_qp;
         dev->ibdev.modify_qp = c4iw_ib_modify_qp;
-        dev->ibdev.query_qp = c4iw_ib_query_qp;
         dev->ibdev.destroy_qp = c4iw_destroy_qp;
         dev->ibdev.create_cq = c4iw_create_cq;
         dev->ibdev.destroy_cq = c4iw_destroy_cq;
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index 05bfe53bff6..a41578e48c7 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -29,24 +29,12 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-
-#include <linux/module.h>
-
 #include "iw_cxgb4.h"
 
-static int db_delay_usecs = 1;
-module_param(db_delay_usecs, int, 0644);
-MODULE_PARM_DESC(db_delay_usecs, "Usecs to delay awaiting db fifo to drain");
-
 static int ocqp_support = 1;
 module_param(ocqp_support, int, 0644);
 MODULE_PARM_DESC(ocqp_support, "Support on-chip SQs (default=1)");
 
-int db_fc_threshold = 2000;
-module_param(db_fc_threshold, int, 0644);
-MODULE_PARM_DESC(db_fc_threshold, "QP count/threshold that triggers automatic "
-                 "db flow control mode (default = 2000)");
-
 static void set_state(struct c4iw_qp *qhp, enum c4iw_qp_state state)
 {
         unsigned long flag;
@@ -137,25 +125,19 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
                 return -ENOMEM;
 
         wq->rq.qid = c4iw_get_qpid(rdev, uctx);
-        if (!wq->rq.qid) {
-                ret = -ENOMEM;
-                goto free_sq_qid;
-        }
+        if (!wq->rq.qid)
+                goto err1;
 
         if (!user) {
                 wq->sq.sw_sq = kzalloc(wq->sq.size * sizeof *wq->sq.sw_sq,
                                  GFP_KERNEL);
-                if (!wq->sq.sw_sq) {
-                        ret = -ENOMEM;
-                        goto free_rq_qid;
-                }
+                if (!wq->sq.sw_sq)
+                        goto err2;
 
                 wq->rq.sw_rq = kzalloc(wq->rq.size * sizeof *wq->rq.sw_rq,
                                  GFP_KERNEL);
-                if (!wq->rq.sw_rq) {
-                        ret = -ENOMEM;
-                        goto free_sw_sq;
-                }
+                if (!wq->rq.sw_rq)
+                        goto err3;
         }
 
         /*
@@ -163,23 +145,15 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
          */
         wq->rq.rqt_size = roundup_pow_of_two(wq->rq.size);
         wq->rq.rqt_hwaddr = c4iw_rqtpool_alloc(rdev, wq->rq.rqt_size);
-        if (!wq->rq.rqt_hwaddr) {
-                ret = -ENOMEM;
-                goto free_sw_rq;
-        }
+        if (!wq->rq.rqt_hwaddr)
+                goto err4;
 
         if (user) {
-                ret = alloc_oc_sq(rdev, &wq->sq);
-                if (ret)
-                        goto free_hwaddr;
-
-                ret = alloc_host_sq(rdev, &wq->sq);
-                if (ret)
-                        goto free_sq;
+                if (alloc_oc_sq(rdev, &wq->sq) && alloc_host_sq(rdev, &wq->sq))
+                        goto err5;
         } else
-                ret = alloc_host_sq(rdev, &wq->sq);
-                if (ret)
-                        goto free_hwaddr;
+                if (alloc_host_sq(rdev, &wq->sq))
+                        goto err5;
         memset(wq->sq.queue, 0, wq->sq.memsize);
         dma_unmap_addr_set(&wq->sq, mapping, wq->sq.dma_addr);
 
@@ -187,7 +161,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
                                           wq->rq.memsize, &(wq->rq.dma_addr),
                                           GFP_KERNEL);
         if (!wq->rq.queue)
-                goto free_sq;
+                goto err6;
         PDBG("%s sq base va 0x%p pa 0x%llx rq base va 0x%p pa 0x%llx\n",
                 __func__, wq->sq.queue,
                 (unsigned long long)virt_to_phys(wq->sq.queue),
@@ -215,7 +189,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         skb = alloc_skb(wr_len, GFP_KERNEL);
         if (!skb) {
                 ret = -ENOMEM;
-                goto free_dma;
+                goto err7;
         }
         set_wr_txq(skb, CPL_PRIORITY_CONTROL, 0);
 
@@ -280,33 +254,33 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
 
         ret = c4iw_ofld_send(rdev, skb);
         if (ret)
-                goto free_dma;
+                goto err7;
         ret = c4iw_wait_for_reply(rdev, &wr_wait, 0, wq->sq.qid, __func__);
         if (ret)
-                goto free_dma;
+                goto err7;
 
         PDBG("%s sqid 0x%x rqid 0x%x kdb 0x%p squdb 0x%llx rqudb 0x%llx\n",
              __func__, wq->sq.qid, wq->rq.qid, wq->db,
              (unsigned long long)wq->sq.udb, (unsigned long long)wq->rq.udb);
 
         return 0;
-free_dma:
+err7:
         dma_free_coherent(&(rdev->lldi.pdev->dev),
                           wq->rq.memsize, wq->rq.queue,
                           dma_unmap_addr(&wq->rq, mapping));
-free_sq:
+err6:
         dealloc_sq(rdev, &wq->sq);
-free_hwaddr:
+err5:
         c4iw_rqtpool_free(rdev, wq->rq.rqt_hwaddr, wq->rq.rqt_size);
-free_sw_rq:
+err4:
         kfree(wq->rq.sw_rq);
-free_sw_sq:
+err3:
         kfree(wq->sq.sw_sq);
-free_rq_qid:
+err2:
         c4iw_put_qpid(rdev, wq->rq.qid, uctx);
-free_sq_qid:
+err1:
         c4iw_put_qpid(rdev, wq->sq.qid, uctx);
-        return ret;
+        return -ENOMEM;
 }
 
 static int build_immd(struct t4_sq *sq, struct fw_ri_immd *immdp,
@@ -943,11 +917,7 @@ static void post_terminate(struct c4iw_qp *qhp, struct t4_cqe *err_cqe,
         wqe->u.terminate.type = FW_RI_TYPE_TERMINATE;
         wqe->u.terminate.immdlen = cpu_to_be32(sizeof *term);
         term = (struct terminate_message *)wqe->u.terminate.termmsg;
-        if (qhp->attr.layer_etype == (LAYER_MPA|DDP_LLP)) {
-                term->layer_etype = qhp->attr.layer_etype;
-                term->ecode = qhp->attr.ecode;
-        } else
-                build_term_codes(err_cqe, &term->layer_etype, &term->ecode);
+        build_term_codes(err_cqe, &term->layer_etype, &term->ecode);
         c4iw_ofld_send(&qhp->rhp->rdev, skb);
 }
 
@@ -971,11 +941,8 @@ static void __flush_qp(struct c4iw_qp *qhp, struct c4iw_cq *rchp,
         flushed = c4iw_flush_rq(&qhp->wq, &rchp->cq, count);
         spin_unlock(&qhp->lock);
         spin_unlock_irqrestore(&rchp->lock, flag);
-        if (flushed) {
-                spin_lock_irqsave(&rchp->comp_handler_lock, flag);
+        if (flushed)
                 (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock_irqrestore(&rchp->comp_handler_lock, flag);
-        }
 
         /* locking hierarchy: cq lock first, then qp lock. */
         spin_lock_irqsave(&schp->lock, flag);
@@ -985,17 +952,13 @@ static void __flush_qp(struct c4iw_qp *qhp, struct c4iw_cq *rchp,
         flushed = c4iw_flush_sq(&qhp->wq, &schp->cq, count);
         spin_unlock(&qhp->lock);
         spin_unlock_irqrestore(&schp->lock, flag);
-        if (flushed) {
-                spin_lock_irqsave(&schp->comp_handler_lock, flag);
+        if (flushed)
                 (*schp->ibcq.comp_handler)(&schp->ibcq, schp->ibcq.cq_context);
-                spin_unlock_irqrestore(&schp->comp_handler_lock, flag);
-        }
 }
 
 static void flush_qp(struct c4iw_qp *qhp)
 {
         struct c4iw_cq *rchp, *schp;
-        unsigned long flag;
 
         rchp = get_chp(qhp->rhp, qhp->attr.rcq);
         schp = get_chp(qhp->rhp, qhp->attr.scq);
@@ -1003,16 +966,8 @@ static void flush_qp(struct c4iw_qp *qhp)
         if (qhp->ibqp.uobject) {
                 t4_set_wq_in_error(&qhp->wq);
                 t4_set_cq_in_error(&rchp->cq);
-                spin_lock_irqsave(&rchp->comp_handler_lock, flag);
-                (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock_irqrestore(&rchp->comp_handler_lock, flag);
-                if (schp != rchp) {
+                if (schp != rchp)
                         t4_set_cq_in_error(&schp->cq);
-                        spin_lock_irqsave(&schp->comp_handler_lock, flag);
-                        (*schp->ibcq.comp_handler)(&schp->ibcq,
-                                        schp->ibcq.cq_context);
-                        spin_unlock_irqrestore(&schp->comp_handler_lock, flag);
-                }
                 return;
         }
         __flush_qp(qhp, rchp, schp);
@@ -1057,7 +1012,6 @@ out:
 
 static void build_rtr_msg(u8 p2p_type, struct fw_ri_init *init)
 {
-        PDBG("%s p2p_type = %d\n", __func__, p2p_type);
         memset(&init->u, 0, sizeof init->u);
         switch (p2p_type) {
         case FW_RI_INIT_P2PTYPE_RDMA_WRITE:
@@ -1151,35 +1105,6 @@ out:
         return ret;
 }
 
-/*
- * Called by the library when the qp has user dbs disabled due to
- * a DB_FULL condition.  This function will single-thread all user
- * DB rings to avoid overflowing the hw db-fifo.
- */
-static int ring_kernel_db(struct c4iw_qp *qhp, u32 qid, u16 inc)
-{
-        int delay = db_delay_usecs;
-
-        mutex_lock(&qhp->rhp->db_mutex);
-        do {
-
-                /*
-                 * The interrupt threshold is dbfifo_int_thresh << 6. So
-                 * make sure we don't cross that and generate an interrupt.
-                 */
-                if (cxgb4_dbfifo_count(qhp->rhp->rdev.lldi.ports[0], 1) <
-                    (qhp->rhp->rdev.lldi.dbfifo_int_thresh << 5)) {
-                        writel(QID(qid) | PIDX(inc), qhp->wq.db);
-                        break;
-                }
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(usecs_to_jiffies(delay));
-                delay = min(delay << 1, 2000);
-        } while (1);
-        mutex_unlock(&qhp->rhp->db_mutex);
-        return 0;
-}
-
 int c4iw_modify_qp(struct c4iw_dev *rhp, struct c4iw_qp *qhp,
                    enum c4iw_qp_attr_mask mask,
                    struct c4iw_qp_attributes *attrs,
@@ -1228,15 +1153,6 @@ int c4iw_modify_qp(struct c4iw_dev *rhp, struct c4iw_qp *qhp,
                 qhp->attr = newattr;
         }
 
-        if (mask & C4IW_QP_ATTR_SQ_DB) {
-                ret = ring_kernel_db(qhp, qhp->wq.sq.qid, attrs->sq_db_inc);
-                goto out;
-        }
-        if (mask & C4IW_QP_ATTR_RQ_DB) {
-                ret = ring_kernel_db(qhp, qhp->wq.rq.qid, attrs->rq_db_inc);
-                goto out;
-        }
-
         if (!(mask & C4IW_QP_ATTR_NEXT_STATE))
                 goto out;
         if (qhp->attr.state == attrs->next_state)
@@ -1290,16 +1206,12 @@ int c4iw_modify_qp(struct c4iw_dev *rhp, struct c4iw_qp *qhp,
                                 disconnect = 1;
                                 c4iw_get_ep(&qhp->ep->com);
                         }
-                        if (qhp->ibqp.uobject)
-                                t4_set_wq_in_error(&qhp->wq);
                         ret = rdma_fini(rhp, qhp, ep);
                         if (ret)
                                 goto err;
                         break;
                 case C4IW_QP_STATE_TERMINATE:
                         set_state(qhp, C4IW_QP_STATE_TERMINATE);
-                        qhp->attr.layer_etype = attrs->layer_etype;
-                        qhp->attr.ecode = attrs->ecode;
                         if (qhp->ibqp.uobject)
                                 t4_set_wq_in_error(&qhp->wq);
                         ep = qhp->ep;
@@ -1310,8 +1222,6 @@ int c4iw_modify_qp(struct c4iw_dev *rhp, struct c4iw_qp *qhp,
                         break;
                 case C4IW_QP_STATE_ERROR:
                         set_state(qhp, C4IW_QP_STATE_ERROR);
-                        if (qhp->ibqp.uobject)
-                                t4_set_wq_in_error(&qhp->wq);
                         if (!internal) {
                                 abort = 1;
                                 disconnect = 1;
@@ -1413,14 +1323,6 @@ out:
         return ret;
 }
 
-static int enable_qp_db(int id, void *p, void *data)
-{
-        struct c4iw_qp *qp = p;
-
-        t4_enable_wq_db(&qp->wq);
-        return 0;
-}
-
 int c4iw_destroy_qp(struct ib_qp *ib_qp)
 {
         struct c4iw_dev *rhp;
@@ -1432,22 +1334,10 @@ int c4iw_destroy_qp(struct ib_qp *ib_qp)
         rhp = qhp->rhp;
 
         attrs.next_state = C4IW_QP_STATE_ERROR;
-        if (qhp->attr.state == C4IW_QP_STATE_TERMINATE)
-                c4iw_modify_qp(rhp, qhp, C4IW_QP_ATTR_NEXT_STATE, &attrs, 1);
-        else
-                c4iw_modify_qp(rhp, qhp, C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
+        c4iw_modify_qp(rhp, qhp, C4IW_QP_ATTR_NEXT_STATE, &attrs, 0);
         wait_event(qhp->wait, !qhp->ep);
 
-        spin_lock_irq(&rhp->lock);
-        remove_handle_nolock(rhp, &rhp->qpidr, qhp->wq.sq.qid);
-        rhp->qpcnt--;
-        BUG_ON(rhp->qpcnt < 0);
-        if (rhp->qpcnt <= db_fc_threshold && rhp->db_state == FLOW_CONTROL) {
-                rhp->rdev.stats.db_state_transitions++;
-                rhp->db_state = NORMAL;
-                idr_for_each(&rhp->qpidr, enable_qp_db, NULL);
-        }
-        spin_unlock_irq(&rhp->lock);
+        remove_handle(rhp, &rhp->qpidr, qhp->wq.sq.qid);
         atomic_dec(&qhp->refcnt);
         wait_event(qhp->wait, !atomic_read(&qhp->refcnt));
 
@@ -1461,14 +1351,6 @@ int c4iw_destroy_qp(struct ib_qp *ib_qp)
         return 0;
 }
 
-static int disable_qp_db(int id, void *p, void *data)
-{
-        struct c4iw_qp *qp = p;
-
-        t4_disable_wq_db(&qp->wq);
-        return 0;
-}
-
 struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
                              struct ib_udata *udata)
 {
@@ -1555,16 +1437,7 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
         init_waitqueue_head(&qhp->wait);
         atomic_set(&qhp->refcnt, 1);
 
-        spin_lock_irq(&rhp->lock);
-        if (rhp->db_state != NORMAL)
-                t4_disable_wq_db(&qhp->wq);
-        if (++rhp->qpcnt > db_fc_threshold && rhp->db_state == NORMAL) {
-                rhp->rdev.stats.db_state_transitions++;
-                rhp->db_state = FLOW_CONTROL;
-                idr_for_each(&rhp->qpidr, disable_qp_db, NULL);
-        }
-        ret = insert_handle_nolock(rhp, &rhp->qpidr, qhp, qhp->wq.sq.qid);
-        spin_unlock_irq(&rhp->lock);
+        ret = insert_handle(rhp, &rhp->qpidr, qhp, qhp->wq.sq.qid);
         if (ret)
                 goto err2;
 
@@ -1708,15 +1581,6 @@ int c4iw_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                          C4IW_QP_ATTR_ENABLE_RDMA_WRITE |
                          C4IW_QP_ATTR_ENABLE_RDMA_BIND) : 0;
 
-        /*
-         * Use SQ_PSN and RQ_PSN to pass in IDX_INC values for
-         * ringing the queue db when we're in DB_FULL mode.
-         */
-        attrs.sq_db_inc = attr->sq_psn;
-        attrs.rq_db_inc = attr->rq_psn;
-        mask |= (attr_mask & IB_QP_SQ_PSN) ? C4IW_QP_ATTR_SQ_DB : 0;
-        mask |= (attr_mask & IB_QP_RQ_PSN) ? C4IW_QP_ATTR_RQ_DB : 0;
-
         return c4iw_modify_qp(rhp, qhp, mask, &attrs, 0);
 }
 
@@ -1725,14 +1589,3 @@ struct ib_qp *c4iw_get_qp(struct ib_device *dev, int qpn)
         PDBG("%s ib_dev %p qpn 0x%x\n", __func__, dev, qpn);
         return (struct ib_qp *)get_qhp(to_c4iw_dev(dev), qpn);
 }
-
-int c4iw_ib_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
-                     int attr_mask, struct ib_qp_init_attr *init_attr)
-{
-        struct c4iw_qp *qhp = to_c4iw_qp(ibqp);
-
-        memset(attr, 0, sizeof *attr);
-        memset(init_attr, 0, sizeof *init_attr);
-        attr->qp_state = to_ib_qp_state(qhp->attr.state);
-        return 0;
-}
diff --git a/drivers/infiniband/hw/cxgb4/resource.c b/drivers/infiniband/hw/cxgb4/resource.c
index cdef4d7fb6d..407ff392415 100644
--- a/drivers/infiniband/hw/cxgb4/resource.c
+++ b/drivers/infiniband/hw/cxgb4/resource.c
@@ -30,25 +30,96 @@
  * SOFTWARE.
  */
 /* Crude resource management */
+#include <linux/kernel.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/kfifo.h>
 #include <linux/spinlock.h>
+#include <linux/errno.h>
 #include <linux/genalloc.h>
 #include <linux/ratelimit.h>
 #include "iw_cxgb4.h"
 
-static int c4iw_init_qid_table(struct c4iw_rdev *rdev)
+#define RANDOM_SIZE 16
+
+static int __c4iw_init_resource_fifo(struct kfifo *fifo,
+                                   spinlock_t *fifo_lock,
+                                   u32 nr, u32 skip_low,
+                                   u32 skip_high,
+                                   int random)
+{
+        u32 i, j, entry = 0, idx;
+        u32 random_bytes;
+        u32 rarray[16];
+        spin_lock_init(fifo_lock);
+
+        if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL))
+                return -ENOMEM;
+
+        for (i = 0; i < skip_low + skip_high; i++)
+                kfifo_in(fifo, (unsigned char *) &entry, sizeof(u32));
+        if (random) {
+                j = 0;
+                random_bytes = random32();
+                for (i = 0; i < RANDOM_SIZE; i++)
+                        rarray[i] = i + skip_low;
+                for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
+                        if (j >= RANDOM_SIZE) {
+                                j = 0;
+                                random_bytes = random32();
+                        }
+                        idx = (random_bytes >> (j * 2)) & 0xF;
+                        kfifo_in(fifo,
+                                (unsigned char *) &rarray[idx],
+                                sizeof(u32));
+                        rarray[idx] = i;
+                        j++;
+                }
+                for (i = 0; i < RANDOM_SIZE; i++)
+                        kfifo_in(fifo,
+                                (unsigned char *) &rarray[i],
+                                sizeof(u32));
+        } else
+                for (i = skip_low; i < nr - skip_high; i++)
+                        kfifo_in(fifo, (unsigned char *) &i, sizeof(u32));
+
+        for (i = 0; i < skip_low + skip_high; i++)
+                if (kfifo_out_locked(fifo, (unsigned char *) &entry,
+                                     sizeof(u32), fifo_lock))
+                        break;
+        return 0;
+}
+
+static int c4iw_init_resource_fifo(struct kfifo *fifo, spinlock_t * fifo_lock,
+                                   u32 nr, u32 skip_low, u32 skip_high)
+{
+        return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
+                                          skip_high, 0);
+}
+
+static int c4iw_init_resource_fifo_random(struct kfifo *fifo,
+                                   spinlock_t *fifo_lock,
+                                   u32 nr, u32 skip_low, u32 skip_high)
+{
+        return __c4iw_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
+                                          skip_high, 1);
+}
+
+static int c4iw_init_qid_fifo(struct c4iw_rdev *rdev)
 {
         u32 i;
 
-        if (c4iw_id_table_alloc(&rdev->resource.qid_table,
-                                rdev->lldi.vr->qp.start,
-                                rdev->lldi.vr->qp.size,
-                                rdev->lldi.vr->qp.size, 0))
+        spin_lock_init(&rdev->resource.qid_fifo_lock);
+
+        if (kfifo_alloc(&rdev->resource.qid_fifo, rdev->lldi.vr->qp.size *
+                        sizeof(u32), GFP_KERNEL))
                 return -ENOMEM;
 
         for (i = rdev->lldi.vr->qp.start;
-                i < rdev->lldi.vr->qp.start + rdev->lldi.vr->qp.size; i++)
+             i < rdev->lldi.vr->qp.start + rdev->lldi.vr->qp.size; i++)
                 if (!(i & rdev->qpmask))
-                        c4iw_id_free(&rdev->resource.qid_table, i);
+                        kfifo_in(&rdev->resource.qid_fifo,
+                                    (unsigned char *) &i, sizeof(u32));
         return 0;
 }
 
@@ -56,42 +127,44 @@ static int c4iw_init_qid_table(struct c4iw_rdev *rdev)
 int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, u32 nr_pdid)
 {
         int err = 0;
-        err = c4iw_id_table_alloc(&rdev->resource.tpt_table, 0, nr_tpt, 1,
-                                        C4IW_ID_TABLE_F_RANDOM);
+        err = c4iw_init_resource_fifo_random(&rdev->resource.tpt_fifo,
+                                             &rdev->resource.tpt_fifo_lock,
+                                             nr_tpt, 1, 0);
         if (err)
                 goto tpt_err;
-        err = c4iw_init_qid_table(rdev);
+        err = c4iw_init_qid_fifo(rdev);
         if (err)
                 goto qid_err;
-        err = c4iw_id_table_alloc(&rdev->resource.pdid_table, 0,
-                                        nr_pdid, 1, 0);
+        err = c4iw_init_resource_fifo(&rdev->resource.pdid_fifo,
+                                      &rdev->resource.pdid_fifo_lock,
+                                      nr_pdid, 1, 0);
         if (err)
                 goto pdid_err;
         return 0;
- pdid_err:
-        c4iw_id_table_free(&rdev->resource.qid_table);
- qid_err:
-        c4iw_id_table_free(&rdev->resource.tpt_table);
- tpt_err:
+pdid_err:
+        kfifo_free(&rdev->resource.qid_fifo);
+qid_err:
+        kfifo_free(&rdev->resource.tpt_fifo);
+tpt_err:
         return -ENOMEM;
 }
 
 /*
  * returns 0 if no resource available
  */
-u32 c4iw_get_resource(struct c4iw_id_table *id_table)
+u32 c4iw_get_resource(struct kfifo *fifo, spinlock_t *lock)
 {
         u32 entry;
-        entry = c4iw_id_alloc(id_table);
-        if (entry == (u32)(-1))
+        if (kfifo_out_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
+                return entry;
+        else
                 return 0;
-        return entry;
 }
 
-void c4iw_put_resource(struct c4iw_id_table *id_table, u32 entry)
+void c4iw_put_resource(struct kfifo *fifo, u32 entry, spinlock_t *lock)
 {
         PDBG("%s entry 0x%x\n", __func__, entry);
-        c4iw_id_free(id_table, entry);
+        kfifo_in_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock);
 }
 
 u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
@@ -108,12 +181,10 @@ u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
                 qid = entry->qid;
                 kfree(entry);
         } else {
-                qid = c4iw_get_resource(&rdev->resource.qid_table);
+                qid = c4iw_get_resource(&rdev->resource.qid_fifo,
+                                        &rdev->resource.qid_fifo_lock);
                 if (!qid)
                         goto out;
-                mutex_lock(&rdev->stats.lock);
-                rdev->stats.qid.cur += rdev->qpmask + 1;
-                mutex_unlock(&rdev->stats.lock);
                 for (i = qid+1; i & rdev->qpmask; i++) {
                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
                         if (!entry)
@@ -142,10 +213,6 @@ u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
 out:
         mutex_unlock(&uctx->lock);
         PDBG("%s qid 0x%x\n", __func__, qid);
-        mutex_lock(&rdev->stats.lock);
-        if (rdev->stats.qid.cur > rdev->stats.qid.max)
-                rdev->stats.qid.max = rdev->stats.qid.cur;
-        mutex_unlock(&rdev->stats.lock);
         return qid;
 }
 
@@ -178,12 +245,10 @@ u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
                 qid = entry->qid;
                 kfree(entry);
         } else {
-                qid = c4iw_get_resource(&rdev->resource.qid_table);
+                qid = c4iw_get_resource(&rdev->resource.qid_fifo,
+                                        &rdev->resource.qid_fifo_lock);
                 if (!qid)
                         goto out;
-                mutex_lock(&rdev->stats.lock);
-                rdev->stats.qid.cur += rdev->qpmask + 1;
-                mutex_unlock(&rdev->stats.lock);
                 for (i = qid+1; i & rdev->qpmask; i++) {
                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
                         if (!entry)
@@ -212,10 +277,6 @@ u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
 out:
         mutex_unlock(&uctx->lock);
         PDBG("%s qid 0x%x\n", __func__, qid);
-        mutex_lock(&rdev->stats.lock);
-        if (rdev->stats.qid.cur > rdev->stats.qid.max)
-                rdev->stats.qid.max = rdev->stats.qid.cur;
-        mutex_unlock(&rdev->stats.lock);
         return qid;
 }
 
@@ -236,9 +297,9 @@ void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid,
 
 void c4iw_destroy_resource(struct c4iw_resource *rscp)
 {
-        c4iw_id_table_free(&rscp->tpt_table);
-        c4iw_id_table_free(&rscp->qid_table);
-        c4iw_id_table_free(&rscp->pdid_table);
+        kfifo_free(&rscp->tpt_fifo);
+        kfifo_free(&rscp->qid_fifo);
+        kfifo_free(&rscp->pdid_fifo);
 }
 
 /*
@@ -251,23 +312,15 @@ u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size)
 {
         unsigned long addr = gen_pool_alloc(rdev->pbl_pool, size);
         PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
-        mutex_lock(&rdev->stats.lock);
-        if (addr) {
-                rdev->stats.pbl.cur += roundup(size, 1 << MIN_PBL_SHIFT);
-                if (rdev->stats.pbl.cur > rdev->stats.pbl.max)
-                        rdev->stats.pbl.max = rdev->stats.pbl.cur;
-        } else
-                rdev->stats.pbl.fail++;
-        mutex_unlock(&rdev->stats.lock);
+        if (!addr)
+                printk_ratelimited(KERN_WARNING MOD "%s: Out of PBL memory\n",
+                       pci_name(rdev->lldi.pdev));
         return (u32)addr;
 }
 
 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 {
         PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
-        mutex_lock(&rdev->stats.lock);
-        rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT);
-        mutex_unlock(&rdev->stats.lock);
         gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
 }
 
@@ -324,23 +377,12 @@ u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
         if (!addr)
                 printk_ratelimited(KERN_WARNING MOD "%s: Out of RQT memory\n",
                        pci_name(rdev->lldi.pdev));
-        mutex_lock(&rdev->stats.lock);
-        if (addr) {
-                rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT);
-                if (rdev->stats.rqt.cur > rdev->stats.rqt.max)
-                        rdev->stats.rqt.max = rdev->stats.rqt.cur;
-        } else
-                rdev->stats.rqt.fail++;
-        mutex_unlock(&rdev->stats.lock);
         return (u32)addr;
 }
 
 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 {
         PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
-        mutex_lock(&rdev->stats.lock);
-        rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT);
-        mutex_unlock(&rdev->stats.lock);
         gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
 }
 
@@ -391,22 +433,12 @@ u32 c4iw_ocqp_pool_alloc(struct c4iw_rdev *rdev, int size)
 {
         unsigned long addr = gen_pool_alloc(rdev->ocqp_pool, size);
         PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
-        if (addr) {
-                mutex_lock(&rdev->stats.lock);
-                rdev->stats.ocqp.cur += roundup(size, 1 << MIN_OCQP_SHIFT);
-                if (rdev->stats.ocqp.cur > rdev->stats.ocqp.max)
-                        rdev->stats.ocqp.max = rdev->stats.ocqp.cur;
-                mutex_unlock(&rdev->stats.lock);
-        }
         return (u32)addr;
 }
 
 void c4iw_ocqp_pool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 {
         PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
-        mutex_lock(&rdev->stats.lock);
-        rdev->stats.ocqp.cur -= roundup(size, 1 << MIN_OCQP_SHIFT);
-        mutex_unlock(&rdev->stats.lock);
         gen_pool_free(rdev->ocqp_pool, (unsigned long)addr, size);
 }
 
diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h
index 16f26ab2930..c0221eec881 100644
--- a/drivers/infiniband/hw/cxgb4/t4.h
+++ b/drivers/infiniband/hw/cxgb4/t4.h
@@ -62,10 +62,6 @@ struct t4_status_page {
         __be16 pidx;
         u8 qp_err;      /* flit 1 - sw owns */
         u8 db_off;
-        u8 pad;
-        u16 host_wq_pidx;
-        u16 host_cidx;
-        u16 host_pidx;
 };
 
 #define T4_EQ_ENTRY_SIZE 64
@@ -379,16 +375,6 @@ static inline void t4_rq_consume(struct t4_wq *wq)
                 wq->rq.cidx = 0;
 }
 
-static inline u16 t4_rq_host_wq_pidx(struct t4_wq *wq)
-{
-        return wq->rq.queue[wq->rq.size].status.host_wq_pidx;
-}
-
-static inline u16 t4_rq_wq_size(struct t4_wq *wq)
-{
-                return wq->rq.size * T4_RQ_NUM_SLOTS;
-}
-
 static inline int t4_sq_onchip(struct t4_sq *sq)
 {
         return sq->flags & T4_SQ_ONCHIP;
@@ -426,16 +412,6 @@ static inline void t4_sq_consume(struct t4_wq *wq)
                 wq->sq.cidx = 0;
 }
 
-static inline u16 t4_sq_host_wq_pidx(struct t4_wq *wq)
-{
-        return wq->sq.queue[wq->sq.size].status.host_wq_pidx;
-}
-
-static inline u16 t4_sq_wq_size(struct t4_wq *wq)
-{
-                return wq->sq.size * T4_SQ_NUM_SLOTS;
-}
-
 static inline void t4_ring_sq_db(struct t4_wq *wq, u16 inc)
 {
         wmb();
diff --git a/drivers/infiniband/hw/cxgb4/user.h b/drivers/infiniband/hw/cxgb4/user.h
index 32b754c35ab..e6669d54770 100644
--- a/drivers/infiniband/hw/cxgb4/user.h
+++ b/drivers/infiniband/hw/cxgb4/user.h
@@ -32,7 +32,7 @@
 #ifndef __C4IW_USER_H__
 #define __C4IW_USER_H__
 
-#define C4IW_UVERBS_ABI_VERSION 2
+#define C4IW_UVERBS_ABI_VERSION 1
 
 /*
  * Make sure that all structs defined in this file remain laid out so
diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index f08f6eaf3fa..aaf6023a483 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -379,8 +379,8 @@ extern spinlock_t shca_list_lock;
 
 extern int ehca_static_rate;
 extern int ehca_port_act_time;
-extern bool ehca_use_hp_mr;
-extern bool ehca_scaling_code;
+extern int ehca_use_hp_mr;
+extern int ehca_scaling_code;
 extern int ehca_lock_hcalls;
 extern int ehca_nr_ports;
 extern int ehca_max_cq;
diff --git a/drivers/infiniband/hw/ehca/ehca_cq.c b/drivers/infiniband/hw/ehca/ehca_cq.c
index 8f5290147e8..d9b0ebcb67d 100644
--- a/drivers/infiniband/hw/ehca/ehca_cq.c
+++ b/drivers/infiniband/hw/ehca/ehca_cq.c
@@ -220,7 +220,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
                         cq = ERR_PTR(-EAGAIN);
                         goto create_cq_exit4;
                 }
-                rpage = __pa(vpage);
+                rpage = virt_to_abs(vpage);
 
                 h_ret = hipz_h_register_rpage_cq(adapter_handle,
                                                  my_cq->ipz_cq_handle,
diff --git a/drivers/infiniband/hw/ehca/ehca_eq.c b/drivers/infiniband/hw/ehca/ehca_eq.c
index 90da6747d39..d9b1bb40f48 100644
--- a/drivers/infiniband/hw/ehca/ehca_eq.c
+++ b/drivers/infiniband/hw/ehca/ehca_eq.c
@@ -101,7 +101,7 @@ int ehca_create_eq(struct ehca_shca *shca,
                 if (!vpage)
                         goto create_eq_exit2;
 
-                rpage = __pa(vpage);
+                rpage = virt_to_abs(vpage);
                 h_ret = hipz_h_register_rpage_eq(shca->ipz_hca_handle,
                                                  eq->ipz_eq_handle,
                                                  &eq->pf,
@@ -125,7 +125,7 @@ int ehca_create_eq(struct ehca_shca *shca,
                 tasklet_init(&eq->interrupt_task, ehca_tasklet_eq, (long)shca);
 
                 ret = ibmebus_request_irq(eq->ist, ehca_interrupt_eq,
-                                          0, "ehca_eq",
+                                          IRQF_DISABLED, "ehca_eq",
                                           (void *)shca);
                 if (ret < 0)
                         ehca_err(ib_dev, "Can't map interrupt handler.");
@@ -133,7 +133,7 @@ int ehca_create_eq(struct ehca_shca *shca,
                 tasklet_init(&eq->interrupt_task, ehca_tasklet_neq, (long)shca);
 
                 ret = ibmebus_request_irq(eq->ist, ehca_interrupt_neq,
-                                          0, "ehca_neq",
+                                          IRQF_DISABLED, "ehca_neq",
                                           (void *)shca);
                 if (ret < 0)
                         ehca_err(ib_dev, "Can't map interrupt handler.");
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 9ed4d258830..73edc366866 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -233,7 +233,7 @@ int ehca_query_port(struct ib_device *ibdev,
                 props->phys_state      = 5;
                 props->state           = rblock->state;
                 props->active_width    = IB_WIDTH_12X;
-                props->active_speed    = IB_SPEED_SDR;
+                props->active_speed    = 0x1;
         }
 
 query_port1:
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index 8615d7cf7e0..e571e60ecb8 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -42,7 +42,6 @@
  */
 
 #include <linux/slab.h>
-#include <linux/smpboot.h>
 
 #include "ehca_classes.h"
 #include "ehca_irq.h"
@@ -653,7 +652,7 @@ void ehca_tasklet_eq(unsigned long data)
         ehca_process_eq((struct ehca_shca*)data, 1);
 }
 
-static int find_next_online_cpu(struct ehca_comp_pool *pool)
+static inline int find_next_online_cpu(struct ehca_comp_pool *pool)
 {
         int cpu;
         unsigned long flags;
@@ -663,20 +662,17 @@ static int find_next_online_cpu(struct ehca_comp_pool *pool)
                 ehca_dmp(cpu_online_mask, cpumask_size(), "");
 
         spin_lock_irqsave(&pool->last_cpu_lock, flags);
-        do {
-                cpu = cpumask_next(pool->last_cpu, cpu_online_mask);
-                if (cpu >= nr_cpu_ids)
-                        cpu = cpumask_first(cpu_online_mask);
-                pool->last_cpu = cpu;
-        } while (!per_cpu_ptr(pool->cpu_comp_tasks, cpu)->active);
+        cpu = cpumask_next(pool->last_cpu, cpu_online_mask);
+        if (cpu >= nr_cpu_ids)
+                cpu = cpumask_first(cpu_online_mask);
+        pool->last_cpu = cpu;
         spin_unlock_irqrestore(&pool->last_cpu_lock, flags);
 
         return cpu;
 }
 
 static void __queue_comp_task(struct ehca_cq *__cq,
-                              struct ehca_cpu_comp_task *cct,
-                              struct task_struct *thread)
+                              struct ehca_cpu_comp_task *cct)
 {
         unsigned long flags;
 
@@ -687,7 +683,7 @@ static void __queue_comp_task(struct ehca_cq *__cq,
                 __cq->nr_callbacks++;
                 list_add_tail(&__cq->entry, &cct->cq_list);
                 cct->cq_jobs++;
-                wake_up_process(thread);
+                wake_up(&cct->wait_queue);
         } else
                 __cq->nr_callbacks++;
 
@@ -699,7 +695,6 @@ static void queue_comp_task(struct ehca_cq *__cq)
 {
         int cpu_id;
         struct ehca_cpu_comp_task *cct;
-        struct task_struct *thread;
         int cq_jobs;
         unsigned long flags;
 
@@ -707,8 +702,7 @@ static void queue_comp_task(struct ehca_cq *__cq)
         BUG_ON(!cpu_online(cpu_id));
 
         cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu_id);
-        thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu_id);
-        BUG_ON(!cct || !thread);
+        BUG_ON(!cct);
 
         spin_lock_irqsave(&cct->task_lock, flags);
         cq_jobs = cct->cq_jobs;
@@ -716,25 +710,28 @@ static void queue_comp_task(struct ehca_cq *__cq)
         if (cq_jobs > 0) {
                 cpu_id = find_next_online_cpu(pool);
                 cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu_id);
-                thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu_id);
-                BUG_ON(!cct || !thread);
+                BUG_ON(!cct);
         }
-        __queue_comp_task(__cq, cct, thread);
+
+        __queue_comp_task(__cq, cct);
 }
 
 static void run_comp_task(struct ehca_cpu_comp_task *cct)
 {
         struct ehca_cq *cq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cct->task_lock, flags);
 
         while (!list_empty(&cct->cq_list)) {
                 cq = list_entry(cct->cq_list.next, struct ehca_cq, entry);
-                spin_unlock_irq(&cct->task_lock);
+                spin_unlock_irqrestore(&cct->task_lock, flags);
 
                 comp_event_callback(cq);
                 if (atomic_dec_and_test(&cq->nr_events))
                         wake_up(&cq->wait_completion);
 
-                spin_lock_irq(&cct->task_lock);
+                spin_lock_irqsave(&cct->task_lock, flags);
                 spin_lock(&cq->task_lock);
                 cq->nr_callbacks--;
                 if (!cq->nr_callbacks) {
@@ -743,76 +740,158 @@ static void run_comp_task(struct ehca_cpu_comp_task *cct)
                 }
                 spin_unlock(&cq->task_lock);
         }
+
+        spin_unlock_irqrestore(&cct->task_lock, flags);
 }
 
-static void comp_task_park(unsigned int cpu)
+static int comp_task(void *__cct)
 {
-        struct ehca_cpu_comp_task *cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
-        struct ehca_cpu_comp_task *target;
-        struct task_struct *thread;
-        struct ehca_cq *cq, *tmp;
-        LIST_HEAD(list);
+        struct ehca_cpu_comp_task *cct = __cct;
+        int cql_empty;
+        DECLARE_WAITQUEUE(wait, current);
 
-        spin_lock_irq(&cct->task_lock);
-        cct->cq_jobs = 0;
-        cct->active = 0;
-        list_splice_init(&cct->cq_list, &list);
-        spin_unlock_irq(&cct->task_lock);
+        set_current_state(TASK_INTERRUPTIBLE);
+        while (!kthread_should_stop()) {
+                add_wait_queue(&cct->wait_queue, &wait);
 
-        cpu = find_next_online_cpu(pool);
-        target = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
-        thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu);
-        spin_lock_irq(&target->task_lock);
-        list_for_each_entry_safe(cq, tmp, &list, entry) {
-                list_del(&cq->entry);
-                __queue_comp_task(cq, target, thread);
+                spin_lock_irq(&cct->task_lock);
+                cql_empty = list_empty(&cct->cq_list);
+                spin_unlock_irq(&cct->task_lock);
+                if (cql_empty)
+                        schedule();
+                else
+                        __set_current_state(TASK_RUNNING);
+
+                remove_wait_queue(&cct->wait_queue, &wait);
+
+                spin_lock_irq(&cct->task_lock);
+                cql_empty = list_empty(&cct->cq_list);
+                spin_unlock_irq(&cct->task_lock);
+                if (!cql_empty)
+                        run_comp_task(__cct);
+
+                set_current_state(TASK_INTERRUPTIBLE);
         }
-        spin_unlock_irq(&target->task_lock);
+        __set_current_state(TASK_RUNNING);
+
+        return 0;
 }
 
-static void comp_task_stop(unsigned int cpu, bool online)
+static struct task_struct *create_comp_task(struct ehca_comp_pool *pool,
+                                            int cpu)
 {
-        struct ehca_cpu_comp_task *cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+        struct ehca_cpu_comp_task *cct;
+
+        cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+        spin_lock_init(&cct->task_lock);
+        INIT_LIST_HEAD(&cct->cq_list);
+        init_waitqueue_head(&cct->wait_queue);
+        cct->task = kthread_create(comp_task, cct, "ehca_comp/%d", cpu);
 
-        spin_lock_irq(&cct->task_lock);
+        return cct->task;
+}
+
+static void destroy_comp_task(struct ehca_comp_pool *pool,
+                              int cpu)
+{
+        struct ehca_cpu_comp_task *cct;
+        struct task_struct *task;
+        unsigned long flags_cct;
+
+        cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+
+        spin_lock_irqsave(&cct->task_lock, flags_cct);
+
+        task = cct->task;
+        cct->task = NULL;
         cct->cq_jobs = 0;
-        cct->active = 0;
-        WARN_ON(!list_empty(&cct->cq_list));
-        spin_unlock_irq(&cct->task_lock);
+
+        spin_unlock_irqrestore(&cct->task_lock, flags_cct);
+
+        if (task)
+                kthread_stop(task);
 }
 
-static int comp_task_should_run(unsigned int cpu)
+static void __cpuinit take_over_work(struct ehca_comp_pool *pool, int cpu)
 {
         struct ehca_cpu_comp_task *cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+        LIST_HEAD(list);
+        struct ehca_cq *cq;
+        unsigned long flags_cct;
+
+        spin_lock_irqsave(&cct->task_lock, flags_cct);
+
+        list_splice_init(&cct->cq_list, &list);
+
+        while (!list_empty(&list)) {
+                cq = list_entry(cct->cq_list.next, struct ehca_cq, entry);
+
+                list_del(&cq->entry);
+                __queue_comp_task(cq, this_cpu_ptr(pool->cpu_comp_tasks));
+        }
+
+        spin_unlock_irqrestore(&cct->task_lock, flags_cct);
 
-        return cct->cq_jobs;
 }
 
-static void comp_task(unsigned int cpu)
+static int __cpuinit comp_pool_callback(struct notifier_block *nfb,
+                                        unsigned long action,
+                                        void *hcpu)
 {
-        struct ehca_cpu_comp_task *cct = this_cpu_ptr(pool->cpu_comp_tasks);
-        int cql_empty;
+        unsigned int cpu = (unsigned long)hcpu;
+        struct ehca_cpu_comp_task *cct;
 
-        spin_lock_irq(&cct->task_lock);
-        cql_empty = list_empty(&cct->cq_list);
-        if (!cql_empty) {
-                __set_current_state(TASK_RUNNING);
-                run_comp_task(cct);
+        switch (action) {
+        case CPU_UP_PREPARE:
+        case CPU_UP_PREPARE_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_PREPARE)", cpu);
+                if (!create_comp_task(pool, cpu)) {
+                        ehca_gen_err("Can't create comp_task for cpu: %x", cpu);
+                        return notifier_from_errno(-ENOMEM);
+                }
+                break;
+        case CPU_UP_CANCELED:
+        case CPU_UP_CANCELED_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_CANCELED)", cpu);
+                cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+                kthread_bind(cct->task, cpumask_any(cpu_online_mask));
+                destroy_comp_task(pool, cpu);
+                break;
+        case CPU_ONLINE:
+        case CPU_ONLINE_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_ONLINE)", cpu);
+                cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
+                kthread_bind(cct->task, cpu);
+                wake_up_process(cct->task);
+                break;
+        case CPU_DOWN_PREPARE:
+        case CPU_DOWN_PREPARE_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_DOWN_PREPARE)", cpu);
+                break;
+        case CPU_DOWN_FAILED:
+        case CPU_DOWN_FAILED_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_DOWN_FAILED)", cpu);
+                break;
+        case CPU_DEAD:
+        case CPU_DEAD_FROZEN:
+                ehca_gen_dbg("CPU: %x (CPU_DEAD)", cpu);
+                destroy_comp_task(pool, cpu);
+                take_over_work(pool, cpu);
+                break;
         }
-        spin_unlock_irq(&cct->task_lock);
+
+        return NOTIFY_OK;
 }
 
-static struct smp_hotplug_thread comp_pool_threads = {
-        .thread_should_run      = comp_task_should_run,
-        .thread_fn              = comp_task,
-        .thread_comm            = "ehca_comp/%u",
-        .cleanup                = comp_task_stop,
-        .park                   = comp_task_park,
+static struct notifier_block comp_pool_callback_nb __cpuinitdata = {
+        .notifier_call  = comp_pool_callback,
+        .priority       = 0,
 };
 
 int ehca_create_comp_pool(void)
 {
-        int cpu, ret = -ENOMEM;
+        int cpu;
+        struct task_struct *task;
 
         if (!ehca_scaling_code)
                 return 0;
@@ -825,46 +904,38 @@ int ehca_create_comp_pool(void)
         pool->last_cpu = cpumask_any(cpu_online_mask);
 
         pool->cpu_comp_tasks = alloc_percpu(struct ehca_cpu_comp_task);
-        if (!pool->cpu_comp_tasks)
-                goto out_pool;
-
-        pool->cpu_comp_threads = alloc_percpu(struct task_struct *);
-        if (!pool->cpu_comp_threads)
-                goto out_tasks;
-
-        for_each_present_cpu(cpu) {
-                struct ehca_cpu_comp_task *cct;
+        if (pool->cpu_comp_tasks == NULL) {
+                kfree(pool);
+                return -EINVAL;
+        }
 
-                cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu);
-                spin_lock_init(&cct->task_lock);
-                INIT_LIST_HEAD(&cct->cq_list);
+        for_each_online_cpu(cpu) {
+                task = create_comp_task(pool, cpu);
+                if (task) {
+                        kthread_bind(task, cpu);
+                        wake_up_process(task);
+                }
         }
 
-        comp_pool_threads.store = pool->cpu_comp_threads;
-        ret = smpboot_register_percpu_thread(&comp_pool_threads);
-        if (ret)
-                goto out_threads;
+        register_hotcpu_notifier(&comp_pool_callback_nb);
 
-        pr_info("eHCA scaling code enabled\n");
-        return ret;
+        printk(KERN_INFO "eHCA scaling code enabled\n");
 
-out_threads:
-        free_percpu(pool->cpu_comp_threads);
-out_tasks:
-        free_percpu(pool->cpu_comp_tasks);
-out_pool:
-        kfree(pool);
-        return ret;
+        return 0;
 }
 
 void ehca_destroy_comp_pool(void)
 {
+        int i;
+
         if (!ehca_scaling_code)
                 return;
 
-        smpboot_unregister_percpu_thread(&comp_pool_threads);
+        unregister_hotcpu_notifier(&comp_pool_callback_nb);
+
+        for_each_online_cpu(i)
+                destroy_comp_task(pool, i);
 
-        free_percpu(pool->cpu_comp_threads);
         free_percpu(pool->cpu_comp_tasks);
         kfree(pool);
 }
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.h b/drivers/infiniband/hw/ehca/ehca_irq.h
index 5370199f08c..3346cb06cea 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.h
+++ b/drivers/infiniband/hw/ehca/ehca_irq.h
@@ -58,15 +58,15 @@ void ehca_tasklet_eq(unsigned long data);
 void ehca_process_eq(struct ehca_shca *shca, int is_irq);
 
 struct ehca_cpu_comp_task {
+        wait_queue_head_t wait_queue;
         struct list_head cq_list;
+        struct task_struct *task;
         spinlock_t task_lock;
         int cq_jobs;
-        int active;
 };
 
 struct ehca_comp_pool {
-        struct ehca_cpu_comp_task __percpu *cpu_comp_tasks;
-        struct task_struct * __percpu *cpu_comp_threads;
+        struct ehca_cpu_comp_task *cpu_comp_tasks;
         int last_cpu;
         spinlock_t last_cpu_lock;
 };
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index f8a62918a88..c240e9972cb 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -59,16 +59,16 @@ MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
 MODULE_DESCRIPTION("IBM eServer HCA InfiniBand Device Driver");
 MODULE_VERSION(HCAD_VERSION);
 
-static bool ehca_open_aqp1    = 0;
+static int ehca_open_aqp1     = 0;
 static int ehca_hw_level      = 0;
-static bool ehca_poll_all_eqs = 1;
+static int ehca_poll_all_eqs  = 1;
 
 int ehca_debug_level   = 0;
 int ehca_nr_ports      = -1;
-bool ehca_use_hp_mr    = 0;
+int ehca_use_hp_mr     = 0;
 int ehca_port_act_time = 30;
 int ehca_static_rate   = -1;
-bool ehca_scaling_code = 0;
+int ehca_scaling_code  = 0;
 int ehca_lock_hcalls   = -1;
 int ehca_max_cq        = -1;
 int ehca_max_qp        = -1;
@@ -82,7 +82,7 @@ module_param_named(port_act_time, ehca_port_act_time, int,  S_IRUGO);
 module_param_named(poll_all_eqs,  ehca_poll_all_eqs,  bool, S_IRUGO);
 module_param_named(static_rate,   ehca_static_rate,   int,  S_IRUGO);
 module_param_named(scaling_code,  ehca_scaling_code,  bool, S_IRUGO);
-module_param_named(lock_hcalls,   ehca_lock_hcalls,   bint, S_IRUGO);
+module_param_named(lock_hcalls,   ehca_lock_hcalls,   bool, S_IRUGO);
 module_param_named(number_of_cqs, ehca_max_cq,        int,  S_IRUGO);
 module_param_named(number_of_qps, ehca_max_qp,        int,  S_IRUGO);
 
@@ -713,8 +713,8 @@ static struct attribute_group ehca_dev_attr_grp = {
         .attrs = ehca_dev_attrs
 };
 
-static int ehca_probe(struct platform_device *dev,
-                      const struct of_device_id *id)
+static int __devinit ehca_probe(struct platform_device *dev,
+                                const struct of_device_id *id)
 {
         struct ehca_shca *shca;
         const u64 *handle;
@@ -879,7 +879,7 @@ probe1:
         return -EINVAL;
 }
 
-static int ehca_remove(struct platform_device *dev)
+static int __devexit ehca_remove(struct platform_device *dev)
 {
         struct ehca_shca *shca = dev_get_drvdata(&dev->dev);
         unsigned long flags;
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index 87844869dcc..43cae84005f 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -112,7 +112,7 @@ static u32 ehca_encode_hwpage_size(u32 pgsize)
 
 static u64 ehca_get_max_hwpage_size(struct ehca_shca *shca)
 {
-        return rounddown_pow_of_two(shca->hca_cap_mr_pgsize);
+        return 1UL << ilog2(shca->hca_cap_mr_pgsize);
 }
 
 static struct ehca_mr *ehca_mr_new(void)
@@ -1136,7 +1136,7 @@ int ehca_reg_mr_rpages(struct ehca_shca *shca,
                 }
 
                 if (rnum > 1) {
-                        rpage = __pa(kpage);
+                        rpage = virt_to_abs(kpage);
                         if (!rpage) {
                                 ehca_err(&shca->ib_device, "kpage=%p i=%x",
                                          kpage, i);
@@ -1231,7 +1231,7 @@ inline int ehca_rereg_mr_rereg1(struct ehca_shca *shca,
                          pginfo->num_kpages, pginfo->num_hwpages, kpage);
                 goto ehca_rereg_mr_rereg1_exit1;
         }
-        rpage = __pa(kpage);
+        rpage = virt_to_abs(kpage);
         if (!rpage) {
                 ehca_err(&shca->ib_device, "kpage=%p", kpage);
                 ret = -EFAULT;
@@ -1525,7 +1525,7 @@ static inline void *ehca_calc_sectbase(int top, int dir, int idx)
         unsigned long ret = idx;
         ret |= dir << EHCA_DIR_INDEX_SHIFT;
         ret |= top << EHCA_TOP_INDEX_SHIFT;
-        return __va(ret << SECTION_SIZE_BITS);
+        return abs_to_virt(ret << SECTION_SIZE_BITS);
 }
 
 #define ehca_bmap_valid(entry) \
@@ -1537,7 +1537,7 @@ static u64 ehca_reg_mr_section(int top, int dir, int idx, u64 *kpage,
 {
         u64 h_ret = 0;
         unsigned long page = 0;
-        u64 rpage = __pa(kpage);
+        u64 rpage = virt_to_abs(kpage);
         int page_count;
 
         void *sectbase = ehca_calc_sectbase(top, dir, idx);
@@ -1553,7 +1553,7 @@ static u64 ehca_reg_mr_section(int top, int dir, int idx, u64 *kpage,
                 for (rnum = 0; (rnum < MAX_RPAGES) && (page < page_count);
                      rnum++) {
                         void *pg = sectbase + ((page++) * pginfo->hwpage_size);
-                        kpage[rnum] = __pa(pg);
+                        kpage[rnum] = virt_to_abs(pg);
                 }
 
                 h_ret = hipz_h_register_rpage_mr(shca->ipz_hca_handle, mr,
@@ -1870,8 +1870,9 @@ static int ehca_set_pagebuf_user1(struct ehca_mr_pginfo *pginfo,
                 for (i = pginfo->u.usr.next_nmap; i < chunk->nmap; ) {
                         pgaddr = page_to_pfn(sg_page(&chunk->page_list[i]))
                                 << PAGE_SHIFT ;
-                        *kpage = pgaddr + (pginfo->next_hwpage *
-                                           pginfo->hwpage_size);
+                        *kpage = phys_to_abs(pgaddr +
+                                             (pginfo->next_hwpage *
+                                              pginfo->hwpage_size));
                         if ( !(*kpage) ) {
                                 ehca_gen_err("pgaddr=%llx "
                                              "chunk->page_list[i]=%llx "
@@ -1926,7 +1927,7 @@ static int ehca_check_kpages_per_ate(struct scatterlist *page_list,
                 u64 pgaddr = page_to_pfn(sg_page(&page_list[t])) << PAGE_SHIFT;
                 if (ehca_debug_level >= 3)
                         ehca_gen_dbg("chunk_page=%llx value=%016llx", pgaddr,
-                                     *(u64 *)__va(pgaddr));
+                                     *(u64 *)abs_to_virt(phys_to_abs(pgaddr)));
                 if (pgaddr - PAGE_SIZE != *prev_pgaddr) {
                         ehca_gen_err("uncontiguous page found pgaddr=%llx "
                                      "prev_pgaddr=%llx page_list_i=%x",
@@ -1961,7 +1962,7 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                         if (nr_kpages == kpages_per_hwpage) {
                                 pgaddr = ( page_to_pfn(sg_page(&chunk->page_list[i]))
                                            << PAGE_SHIFT );
-                                *kpage = pgaddr;
+                                *kpage = phys_to_abs(pgaddr);
                                 if ( !(*kpage) ) {
                                         ehca_gen_err("pgaddr=%llx i=%x",
                                                      pgaddr, i);
@@ -1989,11 +1990,13 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                                                  (pginfo->hwpage_size - 1)) >>
                                                 PAGE_SHIFT;
                                         nr_kpages -= pginfo->kpage_cnt;
-                                        *kpage = pgaddr &
-                                                 ~(pginfo->hwpage_size - 1);
+                                        *kpage = phys_to_abs(
+                                                pgaddr &
+                                                ~(pginfo->hwpage_size - 1));
                                 }
                                 if (ehca_debug_level >= 3) {
-                                        u64 val = *(u64 *)__va(pgaddr);
+                                        u64 val = *(u64 *)abs_to_virt(
+                                                phys_to_abs(pgaddr));
                                         ehca_gen_dbg("kpage=%llx chunk_page=%llx "
                                                      "value=%016llx",
                                                      *kpage, pgaddr, val);
@@ -2081,8 +2084,9 @@ static int ehca_set_pagebuf_phys(struct ehca_mr_pginfo *pginfo,
                                              pginfo->num_hwpages, i);
                                 return -EFAULT;
                         }
-                        *kpage = (pbuf->addr & ~(pginfo->hwpage_size - 1)) +
-                                 (pginfo->next_hwpage * pginfo->hwpage_size);
+                        *kpage = phys_to_abs(
+                                (pbuf->addr & ~(pginfo->hwpage_size - 1)) +
+                                (pginfo->next_hwpage * pginfo->hwpage_size));
                         if ( !(*kpage) && pbuf->addr ) {
                                 ehca_gen_err("pbuf->addr=%llx pbuf->size=%llx "
                                              "next_hwpage=%llx", pbuf->addr,
@@ -2120,8 +2124,8 @@ static int ehca_set_pagebuf_fmr(struct ehca_mr_pginfo *pginfo,
         /* loop over desired page_list entries */
         fmrlist = pginfo->u.fmr.page_list + pginfo->u.fmr.next_listelem;
         for (i = 0; i < number; i++) {
-                *kpage = (*fmrlist & ~(pginfo->hwpage_size - 1)) +
-                           pginfo->next_hwpage * pginfo->hwpage_size;
+                *kpage = phys_to_abs((*fmrlist & ~(pginfo->hwpage_size - 1)) +
+                                     pginfo->next_hwpage * pginfo->hwpage_size);
                 if ( !(*kpage) ) {
                         ehca_gen_err("*fmrlist=%llx fmrlist=%p "
                                      "next_listelem=%llx next_hwpage=%llx",
@@ -2148,7 +2152,8 @@ static int ehca_set_pagebuf_fmr(struct ehca_mr_pginfo *pginfo,
                         u64 prev = *kpage;
                         /* check if adrs are contiguous */
                         for (j = 1; j < cnt_per_hwpage; j++) {
-                                u64 p = fmrlist[j] & ~(pginfo->hwpage_size - 1);
+                                u64 p = phys_to_abs(fmrlist[j] &
+                                                    ~(pginfo->hwpage_size - 1));
                                 if (prev + pginfo->u.fmr.fmr_pgsize != p) {
                                         ehca_gen_err("uncontiguous fmr pages "
                                                      "found prev=%llx p=%llx "
@@ -2383,8 +2388,8 @@ static int ehca_update_busmap(unsigned long pfn, unsigned long nr_pages)
                 memset(ehca_bmap, 0xFF, EHCA_TOP_MAP_SIZE);
         }
 
-        start_section = (pfn * PAGE_SIZE) / EHCA_SECTSIZE;
-        end_section = ((pfn + nr_pages) * PAGE_SIZE) / EHCA_SECTSIZE;
+        start_section = phys_to_abs(pfn * PAGE_SIZE) / EHCA_SECTSIZE;
+        end_section = phys_to_abs((pfn + nr_pages) * PAGE_SIZE) / EHCA_SECTSIZE;
         for (i = start_section; i < end_section; i++) {
                 int ret;
                 top = ehca_calc_index(i, EHCA_TOP_INDEX_SHIFT);
@@ -2503,7 +2508,7 @@ static u64 ehca_map_vaddr(void *caddr)
         if (!ehca_bmap)
                 return EHCA_INVAL_ADDR;
 
-        abs_addr = __pa(caddr);
+        abs_addr = virt_to_abs(caddr);
         top = ehca_calc_index(abs_addr, EHCA_TOP_INDEX_SHIFT + EHCA_SECTSHIFT);
         if (!ehca_bmap_valid(ehca_bmap->top[top]))
                 return EHCA_INVAL_ADDR;
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index 149393915ae..32fb34201ab 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -321,7 +321,7 @@ static inline int init_qp_queue(struct ehca_shca *shca,
                         ret = -EINVAL;
                         goto init_qp_queue1;
                 }
-                rpage = __pa(vpage);
+                rpage = virt_to_abs(vpage);
 
                 h_ret = hipz_h_register_rpage_qp(ipz_hca_handle,
                                                  my_qp->ipz_qp_handle,
@@ -977,9 +977,6 @@ struct ib_srq *ehca_create_srq(struct ib_pd *pd,
         struct hcp_modify_qp_control_block *mqpcb;
         u64 hret, update_mask;
 
-        if (srq_init_attr->srq_type != IB_SRQT_BASIC)
-                return ERR_PTR(-ENOSYS);
-
         /* For common attributes, internal_create_qp() takes its info
          * out of qp_init_attr, so copy all common attrs there.
          */
@@ -1094,7 +1091,7 @@ static int prepare_sqe_rts(struct ehca_qp *my_qp, struct ehca_shca *shca,
         ehca_dbg(&shca->ib_device, "qp_num=%x bad_send_wqe_p=%p",
                  qp_num, bad_send_wqe_p);
         /* convert wqe pointer to vadr */
-        bad_send_wqe_v = __va((u64)bad_send_wqe_p);
+        bad_send_wqe_v = abs_to_virt((u64)bad_send_wqe_p);
         if (ehca_debug_level >= 2)
                 ehca_dmp(bad_send_wqe_v, 32, "qp_num=%x bad_wqe", qp_num);
         squeue = &my_qp->ipz_squeue;
@@ -1138,7 +1135,7 @@ static int calc_left_cqes(u64 wqe_p, struct ipz_queue *ipz_queue,
         /* convert real to abs address */
         wqe_p = wqe_p & (~(1UL << 63));
 
-        wqe_v = __va(wqe_p);
+        wqe_v = abs_to_virt(wqe_p);
 
         if (ipz_queue_abs_to_offset(ipz_queue, wqe_p, &q_ofs)) {
                 ehca_gen_err("Invalid offset for calculating left cqes "
diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index 47f94984353..9a3fbfca9b4 100644
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -42,6 +42,7 @@
  */
 
 
+#include <asm/system.h>
 #include "ehca_classes.h"
 #include "ehca_tools.h"
 #include "ehca_qes.h"
@@ -135,7 +136,7 @@ static void trace_send_wr_ud(const struct ib_send_wr *send_wr)
                                      mad_hdr->attr_mod);
                 }
                 for (j = 0; j < send_wr->num_sge; j++) {
-                        u8 *data = __va(sge->addr);
+                        u8 *data = (u8 *)abs_to_virt(sge->addr);
                         ehca_gen_dbg("send_wr#%x sge#%x addr=%p length=%x "
                                      "lkey=%x",
                                      idx, j, data, sge->length, sge->lkey);
diff --git a/drivers/infiniband/hw/ehca/ehca_tools.h b/drivers/infiniband/hw/ehca/ehca_tools.h
index d280b12aae6..54c0d23bad9 100644
--- a/drivers/infiniband/hw/ehca/ehca_tools.h
+++ b/drivers/infiniband/hw/ehca/ehca_tools.h
@@ -59,6 +59,7 @@
 #include <linux/device.h>
 
 #include <linux/atomic.h>
+#include <asm/abs_addr.h>
 #include <asm/ibmebus.h>
 #include <asm/io.h>
 #include <asm/pgtable.h>
diff --git a/drivers/infiniband/hw/ehca/ehca_uverbs.c b/drivers/infiniband/hw/ehca/ehca_uverbs.c
index 1a1d5d99fcf..45ee89b65c2 100644
--- a/drivers/infiniband/hw/ehca/ehca_uverbs.c
+++ b/drivers/infiniband/hw/ehca/ehca_uverbs.c
@@ -117,7 +117,7 @@ static int ehca_mmap_fw(struct vm_area_struct *vma, struct h_galpas *galpas,
         physical = galpas->user.fw_handle;
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
         ehca_gen_dbg("vsize=%llx physical=%llx", vsize, physical);
-        /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */
+        /* VM_IO | VM_RESERVED are set by remap_pfn_range() */
         ret = remap_4k_pfn(vma, vma->vm_start, physical >> EHCA_PAGESHIFT,
                            vma->vm_page_prot);
         if (unlikely(ret)) {
@@ -139,7 +139,7 @@ static int ehca_mmap_queue(struct vm_area_struct *vma, struct ipz_queue *queue,
         u64 start, ofs;
         struct page *page;
 
-        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= VM_RESERVED;
         start = vma->vm_start;
         for (ofs = 0; ofs < queue->queue_length; ofs += PAGE_SIZE) {
                 u64 virt_addr = (u64)ipz_qeit_calc(queue, ofs);
diff --git a/drivers/infiniband/hw/ehca/hcp_if.c b/drivers/infiniband/hw/ehca/hcp_if.c
index 89517ffb438..e6f9cdd94c7 100644
--- a/drivers/infiniband/hw/ehca/hcp_if.c
+++ b/drivers/infiniband/hw/ehca/hcp_if.c
@@ -90,6 +90,26 @@
 
 static DEFINE_SPINLOCK(hcall_lock);
 
+static u32 get_longbusy_msecs(int longbusy_rc)
+{
+        switch (longbusy_rc) {
+        case H_LONG_BUSY_ORDER_1_MSEC:
+                return 1;
+        case H_LONG_BUSY_ORDER_10_MSEC:
+                return 10;
+        case H_LONG_BUSY_ORDER_100_MSEC:
+                return 100;
+        case H_LONG_BUSY_ORDER_1_SEC:
+                return 1000;
+        case H_LONG_BUSY_ORDER_10_SEC:
+                return 10000;
+        case H_LONG_BUSY_ORDER_100_SEC:
+                return 100000;
+        default:
+                return 1;
+        }
+}
+
 static long ehca_plpar_hcall_norets(unsigned long opcode,
                                     unsigned long arg1,
                                     unsigned long arg2,
@@ -376,7 +396,7 @@ u64 hipz_h_query_port(const struct ipz_adapter_handle adapter_handle,
                       struct hipz_query_port *query_port_response_block)
 {
         u64 ret;
-        u64 r_cb = __pa(query_port_response_block);
+        u64 r_cb = virt_to_abs(query_port_response_block);
 
         if (r_cb & (EHCA_PAGESIZE-1)) {
                 ehca_gen_err("response block not page aligned");
@@ -418,7 +438,7 @@ u64 hipz_h_modify_port(const struct ipz_adapter_handle adapter_handle,
 u64 hipz_h_query_hca(const struct ipz_adapter_handle adapter_handle,
                      struct hipz_query_hca *query_hca_rblock)
 {
-        u64 r_cb = __pa(query_hca_rblock);
+        u64 r_cb = virt_to_abs(query_hca_rblock);
 
         if (r_cb & (EHCA_PAGESIZE-1)) {
                 ehca_gen_err("response_block=%p not page aligned",
@@ -557,7 +577,7 @@ u64 hipz_h_modify_qp(const struct ipz_adapter_handle adapter_handle,
                                 adapter_handle.handle, /* r4 */
                                 qp_handle.handle,      /* r5 */
                                 update_mask,           /* r6 */
-                                __pa(mqpcb),           /* r7 */
+                                virt_to_abs(mqpcb),    /* r7 */
                                 0, 0, 0, 0, 0);
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
@@ -575,7 +595,7 @@ u64 hipz_h_query_qp(const struct ipz_adapter_handle adapter_handle,
         return ehca_plpar_hcall_norets(H_QUERY_QP,
                                        adapter_handle.handle, /* r4 */
                                        qp_handle.handle,      /* r5 */
-                                       __pa(qqpcb),           /* r6 */
+                                       virt_to_abs(qqpcb),    /* r6 */
                                        0, 0, 0, 0);
 }
 
@@ -767,7 +787,7 @@ u64 hipz_h_register_rpage_mr(const struct ipz_adapter_handle adapter_handle,
                 if (count > 1) {
                         u64 *kpage;
                         int i;
-                        kpage = __va(logical_address_of_page);
+                        kpage = (u64 *)abs_to_virt(logical_address_of_page);
                         for (i = 0; i < count; i++)
                                 ehca_gen_dbg("kpage[%d]=%p",
                                              i, (void *)kpage[i]);
@@ -924,7 +944,7 @@ u64 hipz_h_error_data(const struct ipz_adapter_handle adapter_handle,
                       void *rblock,
                       unsigned long *byte_count)
 {
-        u64 r_cb = __pa(rblock);
+        u64 r_cb = virt_to_abs(rblock);
 
         if (r_cb & (EHCA_PAGESIZE-1)) {
                 ehca_gen_err("rblock not page aligned.");
diff --git a/drivers/infiniband/hw/ehca/ipz_pt_fn.c b/drivers/infiniband/hw/ehca/ipz_pt_fn.c
index 62c71fadb4d..1898d6e7cce 100644
--- a/drivers/infiniband/hw/ehca/ipz_pt_fn.c
+++ b/drivers/infiniband/hw/ehca/ipz_pt_fn.c
@@ -81,7 +81,7 @@ int ipz_queue_abs_to_offset(struct ipz_queue *queue, u64 addr, u64 *q_offset)
 {
         int i;
         for (i = 0; i < queue->queue_length / queue->pagesize; i++) {
-                u64 page = __pa(queue->queue_pages[i]);
+                u64 page = (u64)virt_to_abs(queue->queue_pages[i]);
                 if (addr >= page && addr < page + queue->pagesize) {
                         *q_offset = addr - page + i * queue->pagesize;
                         return 0;
diff --git a/drivers/infiniband/hw/ipath/ipath_diag.c b/drivers/infiniband/hw/ipath/ipath_diag.c
index 714293b7851..daef61d5e5b 100644
--- a/drivers/infiniband/hw/ipath/ipath_diag.c
+++ b/drivers/infiniband/hw/ipath/ipath_diag.c
@@ -45,7 +45,6 @@
 #include <linux/pci.h>
 #include <linux/vmalloc.h>
 #include <linux/fs.h>
-#include <linux/export.h>
 #include <asm/uaccess.h>
 
 #include "ipath_kernel.h"
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index 7b371f545ec..be24ac72611 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -41,7 +41,6 @@
 #include <linux/vmalloc.h>
 #include <linux/bitmap.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include "ipath_kernel.h"
 #include "ipath_verbs.h"
@@ -127,8 +126,9 @@ const char *ipath_ibcstatus_str[] = {
         "LTState1C", "LTState1D", "LTState1E", "LTState1F"
 };
 
-static void ipath_remove_one(struct pci_dev *);
-static int ipath_init_one(struct pci_dev *, const struct pci_device_id *);
+static void __devexit ipath_remove_one(struct pci_dev *);
+static int __devinit ipath_init_one(struct pci_dev *,
+                                    const struct pci_device_id *);
 
 /* Only needed for registration, nothing else needs this info */
 #define PCI_VENDOR_ID_PATHSCALE 0x1fc1
@@ -147,7 +147,7 @@ MODULE_DEVICE_TABLE(pci, ipath_pci_tbl);
 static struct pci_driver ipath_driver = {
         .name = IPATH_DRV_NAME,
         .probe = ipath_init_one,
-        .remove = ipath_remove_one,
+        .remove = __devexit_p(ipath_remove_one),
         .id_table = ipath_pci_tbl,
         .driver = {
                 .groups = ipath_driver_attr_groups,
@@ -391,7 +391,8 @@ done:
 
 static void cleanup_device(struct ipath_devdata *dd);
 
-static int ipath_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit ipath_init_one(struct pci_dev *pdev,
+                                    const struct pci_device_id *ent)
 {
         int ret, len, j;
         struct ipath_devdata *dd;
@@ -735,7 +736,7 @@ static void cleanup_device(struct ipath_devdata *dd)
         kfree(tmp);
 }
 
-static void ipath_remove_one(struct pci_dev *pdev)
+static void __devexit ipath_remove_one(struct pci_dev *pdev)
 {
         struct ipath_devdata *dd = pci_get_drvdata(pdev);
 
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index 3eb7e454849..8697eca1435 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -35,7 +35,6 @@
 #include <linux/poll.h>
 #include <linux/cdev.h>
 #include <linux/swap.h>
-#include <linux/export.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>
@@ -1225,7 +1224,7 @@ static int mmap_kvaddr(struct vm_area_struct *vma, u64 pgaddr,
 
         vma->vm_pgoff = (unsigned long) addr >> PAGE_SHIFT;
         vma->vm_ops = &ipath_file_vm_ops;
-        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= VM_RESERVED | VM_DONTEXPAND;
         ret = 1;
 
 bail:
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index a4de9d58e9b..31ae1b108ae 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -46,7 +46,7 @@
 static struct super_block *ipath_super;
 
 static int ipathfs_mknod(struct inode *dir, struct dentry *dentry,
-                         umode_t mode, const struct file_operations *fops,
+                         int mode, const struct file_operations *fops,
                          void *data)
 {
         int error;
@@ -61,7 +61,7 @@ static int ipathfs_mknod(struct inode *dir, struct dentry *dentry,
         inode->i_mode = mode;
         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         inode->i_private = data;
-        if (S_ISDIR(mode)) {
+        if ((mode & S_IFMT) == S_IFDIR) {
                 inode->i_op = &simple_dir_inode_operations;
                 inc_nlink(inode);
                 inc_nlink(dir);
@@ -76,7 +76,7 @@ bail:
         return error;
 }
 
-static int create_file(const char *name, umode_t mode,
+static int create_file(const char *name, mode_t mode,
                        struct dentry *parent, struct dentry **dentry,
                        const struct file_operations *fops, void *data)
 {
@@ -89,7 +89,7 @@ static int create_file(const char *name, umode_t mode,
                 error = ipathfs_mknod(parent->d_inode, *dentry,
                                       mode, fops, data);
         else
-                error = PTR_ERR(*dentry);
+                error = PTR_ERR(dentry);
         mutex_unlock(&parent->d_inode->i_mutex);
 
         return error;
diff --git a/drivers/infiniband/hw/ipath/ipath_iba6110.c b/drivers/infiniband/hw/ipath/ipath_iba6110.c
index 7cc305488a3..1d7aea132a0 100644
--- a/drivers/infiniband/hw/ipath/ipath_iba6110.c
+++ b/drivers/infiniband/hw/ipath/ipath_iba6110.c
@@ -596,7 +596,8 @@ static void ipath_ht_handle_hwerrors(struct ipath_devdata *dd, char *msg,
 
         ipath_format_hwerrors(hwerrs,
                               ipath_6110_hwerror_msgs,
-                              ARRAY_SIZE(ipath_6110_hwerror_msgs),
+                              sizeof(ipath_6110_hwerror_msgs) /
+                              sizeof(ipath_6110_hwerror_msgs[0]),
                               msg, msgl);
 
         if (hwerrs & (_IPATH_HTLINK0_CRCBITS | _IPATH_HTLINK1_CRCBITS))
diff --git a/drivers/infiniband/hw/ipath/ipath_init_chip.c b/drivers/infiniband/hw/ipath/ipath_init_chip.c
index be2a60e142b..7c1eebe8c7c 100644
--- a/drivers/infiniband/hw/ipath/ipath_init_chip.c
+++ b/drivers/infiniband/hw/ipath/ipath_init_chip.c
@@ -33,9 +33,7 @@
 
 #include <linux/pci.h>
 #include <linux/netdevice.h>
-#include <linux/moduleparam.h>
 #include <linux/slab.h>
-#include <linux/stat.h>
 #include <linux/vmalloc.h>
 
 #include "ipath_kernel.h"
@@ -719,6 +717,16 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
                 goto done;
 
         /*
+         * we ignore most issues after reporting them, but have to specially
+         * handle hardware-disabled chips.
+         */
+        if (ret == 2) {
+                /* unique error, known to ipath_init_one */
+                ret = -EPERM;
+                goto done;
+        }
+
+        /*
          * We could bump this to allow for full rcvegrcnt + rcvtidcnt,
          * but then it no longer nicely fits power of two, and since
          * we now use routines that backend onto __get_free_pages, the
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index 26dfbc8ee0f..c0a03ac03ee 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -209,7 +209,8 @@ void ipath_format_hwerrors(u64 hwerrs,
 {
         int i;
         const int glen =
-            ARRAY_SIZE(ipath_generic_hwerror_msgs);
+            sizeof(ipath_generic_hwerror_msgs) /
+            sizeof(ipath_generic_hwerror_msgs[0]);
 
         for (i=0; i<glen; i++) {
                 if (hwerrs & ipath_generic_hwerror_msgs[i].mask) {
diff --git a/drivers/infiniband/hw/ipath/ipath_srq.c b/drivers/infiniband/hw/ipath/ipath_srq.c
index 26271984b71..386e2c717c5 100644
--- a/drivers/infiniband/hw/ipath/ipath_srq.c
+++ b/drivers/infiniband/hw/ipath/ipath_srq.c
@@ -107,11 +107,6 @@ struct ib_srq *ipath_create_srq(struct ib_pd *ibpd,
         u32 sz;
         struct ib_srq *ret;
 
-        if (srq_init_attr->srq_type != IB_SRQT_BASIC) {
-                ret = ERR_PTR(-ENOSYS);
-                goto done;
-        }
-
         if (srq_init_attr->attr.max_wr == 0) {
                 ret = ERR_PTR(-EINVAL);
                 goto done;
diff --git a/drivers/infiniband/hw/ipath/ipath_sysfs.c b/drivers/infiniband/hw/ipath/ipath_sysfs.c
index 75558f33f1c..8991677e9a0 100644
--- a/drivers/infiniband/hw/ipath/ipath_sysfs.c
+++ b/drivers/infiniband/hw/ipath/ipath_sysfs.c
@@ -32,7 +32,6 @@
  */
 
 #include <linux/ctype.h>
-#include <linux/stat.h>
 
 #include "ipath_kernel.h"
 #include "ipath_verbs.h"
diff --git a/drivers/infiniband/hw/ipath/ipath_user_pages.c b/drivers/infiniband/hw/ipath/ipath_user_pages.c
index dc66c450691..cfed5399f07 100644
--- a/drivers/infiniband/hw/ipath/ipath_user_pages.c
+++ b/drivers/infiniband/hw/ipath/ipath_user_pages.c
@@ -79,7 +79,7 @@ static int __ipath_get_user_pages(unsigned long start_page, size_t num_pages,
                         goto bail_release;
         }
 
-        current->mm->pinned_vm += num_pages;
+        current->mm->locked_vm += num_pages;
 
         ret = 0;
         goto bail;
@@ -178,7 +178,7 @@ void ipath_release_user_pages(struct page **p, size_t num_pages)
 
         __ipath_release_user_pages(p, num_pages, 1);
 
-        current->mm->pinned_vm -= num_pages;
+        current->mm->locked_vm -= num_pages;
 
         up_write(&current->mm->mmap_sem);
 }
@@ -195,7 +195,7 @@ static void user_pages_account(struct work_struct *_work)
                 container_of(_work, struct ipath_user_pages_work, work);
 
         down_write(&work->mm->mmap_sem);
-        work->mm->pinned_vm -= work->num_pages;
+        work->mm->locked_vm -= work->num_pages;
         up_write(&work->mm->mmap_sem);
         mmput(work->mm);
         kfree(work);
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index 439c35d4a66..dd7f26d04d4 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -35,7 +35,6 @@
 #include <rdma/ib_user_verbs.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <linux/utsname.h>
 #include <linux/rculist.h>
 
diff --git a/drivers/infiniband/hw/mlx4/Kconfig b/drivers/infiniband/hw/mlx4/Kconfig
index 24ab11a9ad1..bd995b2b50d 100644
--- a/drivers/infiniband/hw/mlx4/Kconfig
+++ b/drivers/infiniband/hw/mlx4/Kconfig
@@ -1,7 +1,6 @@
 config MLX4_INFINIBAND
         tristate "Mellanox ConnectX HCA support"
-        depends on NETDEVICES && ETHERNET && PCI
-        select NET_VENDOR_MELLANOX
+        depends on NETDEVICES && NETDEV_10000 && PCI
         select MLX4_CORE
         ---help---
           This driver provides low-level InfiniBand support for
diff --git a/drivers/infiniband/hw/mlx4/Makefile b/drivers/infiniband/hw/mlx4/Makefile
index f4213b3a8fe..70f09c7826d 100644
--- a/drivers/infiniband/hw/mlx4/Makefile
+++ b/drivers/infiniband/hw/mlx4/Makefile
@@ -1,3 +1,3 @@
 obj-$(CONFIG_MLX4_INFINIBAND)   += mlx4_ib.o
 
-mlx4_ib-y :=    ah.o cq.o doorbell.o mad.o main.o mr.o qp.o srq.o mcg.o cm.o alias_GUID.o sysfs.o
+mlx4_ib-y :=    ah.o cq.o doorbell.o mad.o main.o mr.o qp.o srq.o
diff --git a/drivers/infiniband/hw/mlx4/ah.c b/drivers/infiniband/hw/mlx4/ah.c
index a251becdaa9..4b8f9c49397 100644
--- a/drivers/infiniband/hw/mlx4/ah.c
+++ b/drivers/infiniband/hw/mlx4/ah.c
@@ -126,7 +126,7 @@ static struct ib_ah *create_iboe_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr
                 ah->av.ib.dlid = cpu_to_be16(0xc000);
 
         memcpy(ah->av.eth.dgid, ah_attr->grh.dgid.raw, 16);
-        ah->av.eth.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 29);
+        ah->av.eth.sl_tclass_flowlabel = cpu_to_be32(ah_attr->sl << 28);
 
         return &ah->ibah;
 }
diff --git a/drivers/infiniband/hw/mlx4/alias_GUID.c b/drivers/infiniband/hw/mlx4/alias_GUID.c
deleted file mode 100644
index 2f215b93db6..00000000000
--- a/drivers/infiniband/hw/mlx4/alias_GUID.c
+++ /dev/null
@@ -1,688 +0,0 @@
-/*
- * Copyright (c) 2012 Mellanox Technologies. 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.
- */
- /***********************************************************/
-/*This file support the handling of the Alias GUID feature. */
-/***********************************************************/
-#include <rdma/ib_mad.h>
-#include <rdma/ib_smi.h>
-#include <rdma/ib_cache.h>
-#include <rdma/ib_sa.h>
-#include <rdma/ib_pack.h>
-#include <linux/mlx4/cmd.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/errno.h>
-#include <rdma/ib_user_verbs.h>
-#include <linux/delay.h>
-#include "mlx4_ib.h"
-
-/*
-The driver keeps the current state of all guids, as they are in the HW.
-Whenever we receive an smp mad GUIDInfo record, the data will be cached.
-*/
-
-struct mlx4_alias_guid_work_context {
-        u8 port;
-        struct mlx4_ib_dev     *dev ;
-        struct ib_sa_query     *sa_query;
-        struct completion       done;
-        int                     query_id;
-        struct list_head        list;
-        int                     block_num;
-};
-
-struct mlx4_next_alias_guid_work {
-        u8 port;
-        u8 block_num;
-        struct mlx4_sriov_alias_guid_info_rec_det rec_det;
-};
-
-
-void mlx4_ib_update_cache_on_guid_change(struct mlx4_ib_dev *dev, int block_num,
-                                         u8 port_num, u8 *p_data)
-{
-        int i;
-        u64 guid_indexes;
-        int slave_id;
-        int port_index = port_num - 1;
-
-        if (!mlx4_is_master(dev->dev))
-                return;
-
-        guid_indexes = be64_to_cpu((__force __be64) dev->sriov.alias_guid.
-                                   ports_guid[port_num - 1].
-                                   all_rec_per_port[block_num].guid_indexes);
-        pr_debug("port: %d, guid_indexes: 0x%llx\n", port_num, guid_indexes);
-
-        for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
-                /* The location of the specific index starts from bit number 4
-                 * until bit num 11 */
-                if (test_bit(i + 4, (unsigned long *)&guid_indexes)) {
-                        slave_id = (block_num * NUM_ALIAS_GUID_IN_REC) + i ;
-                        if (slave_id >= dev->dev->num_slaves) {
-                                pr_debug("The last slave: %d\n", slave_id);
-                                return;
-                        }
-
-                        /* cache the guid: */
-                        memcpy(&dev->sriov.demux[port_index].guid_cache[slave_id],
-                               &p_data[i * GUID_REC_SIZE],
-                               GUID_REC_SIZE);
-                } else
-                        pr_debug("Guid number: %d in block: %d"
-                                 " was not updated\n", i, block_num);
-        }
-}
-
-static __be64 get_cached_alias_guid(struct mlx4_ib_dev *dev, int port, int index)
-{
-        if (index >= NUM_ALIAS_GUID_PER_PORT) {
-                pr_err("%s: ERROR: asked for index:%d\n", __func__, index);
-                return (__force __be64) -1;
-        }
-        return *(__be64 *)&dev->sriov.demux[port - 1].guid_cache[index];
-}
-
-
-ib_sa_comp_mask mlx4_ib_get_aguid_comp_mask_from_ix(int index)
-{
-        return IB_SA_COMP_MASK(4 + index);
-}
-
-/*
- * Whenever new GUID is set/unset (guid table change) create event and
- * notify the relevant slave (master also should be notified).
- * If the GUID value is not as we have in the cache the slave will not be
- * updated; in this case it waits for the smp_snoop or the port management
- * event to call the function and to update the slave.
- * block_number - the index of the block (16 blocks available)
- * port_number - 1 or 2
- */
-void mlx4_ib_notify_slaves_on_guid_change(struct mlx4_ib_dev *dev,
-                                          int block_num, u8 port_num,
-                                          u8 *p_data)
-{
-        int i;
-        u64 guid_indexes;
-        int slave_id;
-        enum slave_port_state new_state;
-        enum slave_port_state prev_state;
-        __be64 tmp_cur_ag, form_cache_ag;
-        enum slave_port_gen_event gen_event;
-
-        if (!mlx4_is_master(dev->dev))
-                return;
-
-        guid_indexes = be64_to_cpu((__force __be64) dev->sriov.alias_guid.
-                                   ports_guid[port_num - 1].
-                                   all_rec_per_port[block_num].guid_indexes);
-        pr_debug("port: %d, guid_indexes: 0x%llx\n", port_num, guid_indexes);
-
-        /*calculate the slaves and notify them*/
-        for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
-                /* the location of the specific index runs from bits 4..11 */
-                if (!(test_bit(i + 4, (unsigned long *)&guid_indexes)))
-                        continue;
-
-                slave_id = (block_num * NUM_ALIAS_GUID_IN_REC) + i ;
-                if (slave_id >= dev->dev->num_slaves)
-                        return;
-                tmp_cur_ag = *(__be64 *)&p_data[i * GUID_REC_SIZE];
-                form_cache_ag = get_cached_alias_guid(dev, port_num,
-                                        (NUM_ALIAS_GUID_IN_REC * block_num) + i);
-                /*
-                 * Check if guid is not the same as in the cache,
-                 * If it is different, wait for the snoop_smp or the port mgmt
-                 * change event to update the slave on its port state change
-                 */
-                if (tmp_cur_ag != form_cache_ag)
-                        continue;
-                mlx4_gen_guid_change_eqe(dev->dev, slave_id, port_num);
-
-                /*2 cases: Valid GUID, and Invalid Guid*/
-
-                if (tmp_cur_ag != MLX4_NOT_SET_GUID) { /*valid GUID*/
-                        prev_state = mlx4_get_slave_port_state(dev->dev, slave_id, port_num);
-                        new_state = set_and_calc_slave_port_state(dev->dev, slave_id, port_num,
-                                                                  MLX4_PORT_STATE_IB_PORT_STATE_EVENT_GID_VALID,
-                                                                  &gen_event);
-                        pr_debug("slave: %d, port: %d prev_port_state: %d,"
-                                 " new_port_state: %d, gen_event: %d\n",
-                                 slave_id, port_num, prev_state, new_state, gen_event);
-                        if (gen_event == SLAVE_PORT_GEN_EVENT_UP) {
-                                pr_debug("sending PORT_UP event to slave: %d, port: %d\n",
-                                         slave_id, port_num);
-                                mlx4_gen_port_state_change_eqe(dev->dev, slave_id,
-                                                               port_num, MLX4_PORT_CHANGE_SUBTYPE_ACTIVE);
-                        }
-                } else { /* request to invalidate GUID */
-                        set_and_calc_slave_port_state(dev->dev, slave_id, port_num,
-                                                      MLX4_PORT_STATE_IB_EVENT_GID_INVALID,
-                                                      &gen_event);
-                        pr_debug("sending PORT DOWN event to slave: %d, port: %d\n",
-                                 slave_id, port_num);
-                        mlx4_gen_port_state_change_eqe(dev->dev, slave_id, port_num,
-                                                       MLX4_PORT_CHANGE_SUBTYPE_DOWN);
-                }
-        }
-}
-
-static void aliasguid_query_handler(int status,
-                                    struct ib_sa_guidinfo_rec *guid_rec,
-                                    void *context)
-{
-        struct mlx4_ib_dev *dev;
-        struct mlx4_alias_guid_work_context *cb_ctx = context;
-        u8 port_index ;
-        int i;
-        struct mlx4_sriov_alias_guid_info_rec_det *rec;
-        unsigned long flags, flags1;
-
-        if (!context)
-                return;
-
-        dev = cb_ctx->dev;
-        port_index = cb_ctx->port - 1;
-        rec = &dev->sriov.alias_guid.ports_guid[port_index].
-                all_rec_per_port[cb_ctx->block_num];
-
-        if (status) {
-                rec->status = MLX4_GUID_INFO_STATUS_IDLE;
-                pr_debug("(port: %d) failed: status = %d\n",
-                         cb_ctx->port, status);
-                goto out;
-        }
-
-        if (guid_rec->block_num != cb_ctx->block_num) {
-                pr_err("block num mismatch: %d != %d\n",
-                       cb_ctx->block_num, guid_rec->block_num);
-                goto out;
-        }
-
-        pr_debug("lid/port: %d/%d, block_num: %d\n",
-                 be16_to_cpu(guid_rec->lid), cb_ctx->port,
-                 guid_rec->block_num);
-
-        rec = &dev->sriov.alias_guid.ports_guid[port_index].
-                all_rec_per_port[guid_rec->block_num];
-
-        rec->status = MLX4_GUID_INFO_STATUS_SET;
-        rec->method = MLX4_GUID_INFO_RECORD_SET;
-
-        for (i = 0 ; i < NUM_ALIAS_GUID_IN_REC; i++) {
-                __be64 tmp_cur_ag;
-                tmp_cur_ag = *(__be64 *)&guid_rec->guid_info_list[i * GUID_REC_SIZE];
-                /* check if the SM didn't assign one of the records.
-                 * if it didn't, if it was not sysadmin request:
-                 * ask the SM to give a new GUID, (instead of the driver request).
-                 */
-                if (tmp_cur_ag == MLX4_NOT_SET_GUID) {
-                        mlx4_ib_warn(&dev->ib_dev, "%s:Record num %d in "
-                                     "block_num: %d was declined by SM, "
-                                     "ownership by %d (0 = driver, 1=sysAdmin,"
-                                     " 2=None)\n", __func__, i,
-                                     guid_rec->block_num, rec->ownership);
-                        if (rec->ownership == MLX4_GUID_DRIVER_ASSIGN) {
-                                /* if it is driver assign, asks for new GUID from SM*/
-                                *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE] =
-                                        MLX4_NOT_SET_GUID;
-
-                                /* Mark the record as not assigned, and let it
-                                 * be sent again in the next work sched.*/
-                                rec->status = MLX4_GUID_INFO_STATUS_IDLE;
-                                rec->guid_indexes |= mlx4_ib_get_aguid_comp_mask_from_ix(i);
-                        }
-                } else {
-                       /* properly assigned record. */
-                       /* We save the GUID we just got from the SM in the
-                        * admin_guid in order to be persistent, and in the
-                        * request from the sm the process will ask for the same GUID */
-                        if (rec->ownership == MLX4_GUID_SYSADMIN_ASSIGN &&
-                            tmp_cur_ag != *(__be64 *)&rec->all_recs[i * GUID_REC_SIZE]) {
-                                /* the sysadmin assignment failed.*/
-                                mlx4_ib_warn(&dev->ib_dev, "%s: Failed to set"
-                                             " admin guid after SysAdmin "
-                                             "configuration. "
-                                             "Record num %d in block_num:%d "
-                                             "was declined by SM, "
-                                             "new val(0x%llx) was kept\n",
-                                              __func__, i,
-                                             guid_rec->block_num,
-                                             be64_to_cpu(*(__be64 *) &
-                                                         rec->all_recs[i * GUID_REC_SIZE]));
-                        } else {
-                                memcpy(&rec->all_recs[i * GUID_REC_SIZE],
-                                       &guid_rec->guid_info_list[i * GUID_REC_SIZE],
-                                       GUID_REC_SIZE);
-                        }
-                }
-        }
-        /*
-        The func is call here to close the cases when the
-        sm doesn't send smp, so in the sa response the driver
-        notifies the slave.
-        */
-        mlx4_ib_notify_slaves_on_guid_change(dev, guid_rec->block_num,
-                                             cb_ctx->port,
-                                             guid_rec->guid_info_list);
-out:
-        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
-        spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        if (!dev->sriov.is_going_down)
-                queue_delayed_work(dev->sriov.alias_guid.ports_guid[port_index].wq,
-                                   &dev->sriov.alias_guid.ports_guid[port_index].
-                                   alias_guid_work, 0);
-        if (cb_ctx->sa_query) {
-                list_del(&cb_ctx->list);
-                kfree(cb_ctx);
-        } else
-                complete(&cb_ctx->done);
-        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
-}
-
-static void invalidate_guid_record(struct mlx4_ib_dev *dev, u8 port, int index)
-{
-        int i;
-        u64 cur_admin_val;
-        ib_sa_comp_mask comp_mask = 0;
-
-        dev->sriov.alias_guid.ports_guid[port - 1].all_rec_per_port[index].status
-                = MLX4_GUID_INFO_STATUS_IDLE;
-        dev->sriov.alias_guid.ports_guid[port - 1].all_rec_per_port[index].method
-                = MLX4_GUID_INFO_RECORD_SET;
-
-        /* calculate the comp_mask for that record.*/
-        for (i = 0; i < NUM_ALIAS_GUID_IN_REC; i++) {
-                cur_admin_val =
-                        *(u64 *)&dev->sriov.alias_guid.ports_guid[port - 1].
-                        all_rec_per_port[index].all_recs[GUID_REC_SIZE * i];
-                /*
-                check the admin value: if it's for delete (~00LL) or
-                it is the first guid of the first record (hw guid) or
-                the records is not in ownership of the sysadmin and the sm doesn't
-                need to assign GUIDs, then don't put it up for assignment.
-                */
-                if (MLX4_GUID_FOR_DELETE_VAL == cur_admin_val ||
-                    (!index && !i) ||
-                    MLX4_GUID_NONE_ASSIGN == dev->sriov.alias_guid.
-                    ports_guid[port - 1].all_rec_per_port[index].ownership)
-                        continue;
-                comp_mask |= mlx4_ib_get_aguid_comp_mask_from_ix(i);
-        }
-        dev->sriov.alias_guid.ports_guid[port - 1].
-                all_rec_per_port[index].guid_indexes = comp_mask;
-}
-
-static int set_guid_rec(struct ib_device *ibdev,
-                        u8 port, int index,
-                        struct mlx4_sriov_alias_guid_info_rec_det *rec_det)
-{
-        int err;
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        struct ib_sa_guidinfo_rec guid_info_rec;
-        ib_sa_comp_mask comp_mask;
-        struct ib_port_attr attr;
-        struct mlx4_alias_guid_work_context *callback_context;
-        unsigned long resched_delay, flags, flags1;
-        struct list_head *head =
-                &dev->sriov.alias_guid.ports_guid[port - 1].cb_list;
-
-        err = __mlx4_ib_query_port(ibdev, port, &attr, 1);
-        if (err) {
-                pr_debug("mlx4_ib_query_port failed (err: %d), port: %d\n",
-                         err, port);
-                return err;
-        }
-        /*check the port was configured by the sm, otherwise no need to send */
-        if (attr.state != IB_PORT_ACTIVE) {
-                pr_debug("port %d not active...rescheduling\n", port);
-                resched_delay = 5 * HZ;
-                err = -EAGAIN;
-                goto new_schedule;
-        }
-
-        callback_context = kmalloc(sizeof *callback_context, GFP_KERNEL);
-        if (!callback_context) {
-                err = -ENOMEM;
-                resched_delay = HZ * 5;
-                goto new_schedule;
-        }
-        callback_context->port = port;
-        callback_context->dev = dev;
-        callback_context->block_num = index;
-
-        memset(&guid_info_rec, 0, sizeof (struct ib_sa_guidinfo_rec));
-
-        guid_info_rec.lid = cpu_to_be16(attr.lid);
-        guid_info_rec.block_num = index;
-
-        memcpy(guid_info_rec.guid_info_list, rec_det->all_recs,
-               GUID_REC_SIZE * NUM_ALIAS_GUID_IN_REC);
-        comp_mask = IB_SA_GUIDINFO_REC_LID | IB_SA_GUIDINFO_REC_BLOCK_NUM |
-                rec_det->guid_indexes;
-
-        init_completion(&callback_context->done);
-        spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        list_add_tail(&callback_context->list, head);
-        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-
-        callback_context->query_id =
-                ib_sa_guid_info_rec_query(dev->sriov.alias_guid.sa_client,
-                                          ibdev, port, &guid_info_rec,
-                                          comp_mask, rec_det->method, 1000,
-                                          GFP_KERNEL, aliasguid_query_handler,
-                                          callback_context,
-                                          &callback_context->sa_query);
-        if (callback_context->query_id < 0) {
-                pr_debug("ib_sa_guid_info_rec_query failed, query_id: "
-                         "%d. will reschedule to the next 1 sec.\n",
-                         callback_context->query_id);
-                spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-                list_del(&callback_context->list);
-                kfree(callback_context);
-                spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-                resched_delay = 1 * HZ;
-                err = -EAGAIN;
-                goto new_schedule;
-        }
-        err = 0;
-        goto out;
-
-new_schedule:
-        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
-        spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        invalidate_guid_record(dev, port, index);
-        if (!dev->sriov.is_going_down) {
-                queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq,
-                                   &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work,
-                                   resched_delay);
-        }
-        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
-
-out:
-        return err;
-}
-
-void mlx4_ib_invalidate_all_guid_record(struct mlx4_ib_dev *dev, int port)
-{
-        int i;
-        unsigned long flags, flags1;
-
-        pr_debug("port %d\n", port);
-
-        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
-        spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        for (i = 0; i < NUM_ALIAS_GUID_REC_IN_PORT; i++)
-                invalidate_guid_record(dev, port, i);
-
-        if (mlx4_is_master(dev->dev) && !dev->sriov.is_going_down) {
-                /*
-                make sure no work waits in the queue, if the work is already
-                queued(not on the timer) the cancel will fail. That is not a problem
-                because we just want the work started.
-                */
-                cancel_delayed_work(&dev->sriov.alias_guid.
-                                      ports_guid[port - 1].alias_guid_work);
-                queue_delayed_work(dev->sriov.alias_guid.ports_guid[port - 1].wq,
-                                   &dev->sriov.alias_guid.ports_guid[port - 1].alias_guid_work,
-                                   0);
-        }
-        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
-}
-
-/* The function returns the next record that was
- * not configured (or failed to be configured) */
-static int get_next_record_to_update(struct mlx4_ib_dev *dev, u8 port,
-                                     struct mlx4_next_alias_guid_work *rec)
-{
-        int j;
-        unsigned long flags;
-
-        for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) {
-                spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags);
-                if (dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[j].status ==
-                    MLX4_GUID_INFO_STATUS_IDLE) {
-                        memcpy(&rec->rec_det,
-                               &dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[j],
-                               sizeof (struct mlx4_sriov_alias_guid_info_rec_det));
-                        rec->port = port;
-                        rec->block_num = j;
-                        dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[j].status =
-                                MLX4_GUID_INFO_STATUS_PENDING;
-                        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags);
-                        return 0;
-                }
-                spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags);
-        }
-        return -ENOENT;
-}
-
-static void set_administratively_guid_record(struct mlx4_ib_dev *dev, int port,
-                                             int rec_index,
-                                             struct mlx4_sriov_alias_guid_info_rec_det *rec_det)
-{
-        dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[rec_index].guid_indexes =
-                rec_det->guid_indexes;
-        memcpy(dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[rec_index].all_recs,
-               rec_det->all_recs, NUM_ALIAS_GUID_IN_REC * GUID_REC_SIZE);
-        dev->sriov.alias_guid.ports_guid[port].all_rec_per_port[rec_index].status =
-                rec_det->status;
-}
-
-static void set_all_slaves_guids(struct mlx4_ib_dev *dev, int port)
-{
-        int j;
-        struct mlx4_sriov_alias_guid_info_rec_det rec_det ;
-
-        for (j = 0 ; j < NUM_ALIAS_GUID_REC_IN_PORT ; j++) {
-                memset(rec_det.all_recs, 0, NUM_ALIAS_GUID_IN_REC * GUID_REC_SIZE);
-                rec_det.guid_indexes = (!j ? 0 : IB_SA_GUIDINFO_REC_GID0) |
-                        IB_SA_GUIDINFO_REC_GID1 | IB_SA_GUIDINFO_REC_GID2 |
-                        IB_SA_GUIDINFO_REC_GID3 | IB_SA_GUIDINFO_REC_GID4 |
-                        IB_SA_GUIDINFO_REC_GID5 | IB_SA_GUIDINFO_REC_GID6 |
-                        IB_SA_GUIDINFO_REC_GID7;
-                rec_det.status = MLX4_GUID_INFO_STATUS_IDLE;
-                set_administratively_guid_record(dev, port, j, &rec_det);
-        }
-}
-
-static void alias_guid_work(struct work_struct *work)
-{
-        struct delayed_work *delay = to_delayed_work(work);
-        int ret = 0;
-        struct mlx4_next_alias_guid_work *rec;
-        struct mlx4_sriov_alias_guid_port_rec_det *sriov_alias_port =
-                container_of(delay, struct mlx4_sriov_alias_guid_port_rec_det,
-                             alias_guid_work);
-        struct mlx4_sriov_alias_guid *sriov_alias_guid = sriov_alias_port->parent;
-        struct mlx4_ib_sriov *ib_sriov = container_of(sriov_alias_guid,
-                                                struct mlx4_ib_sriov,
-                                                alias_guid);
-        struct mlx4_ib_dev *dev = container_of(ib_sriov, struct mlx4_ib_dev, sriov);
-
-        rec = kzalloc(sizeof *rec, GFP_KERNEL);
-        if (!rec) {
-                pr_err("alias_guid_work: No Memory\n");
-                return;
-        }
-
-        pr_debug("starting [port: %d]...\n", sriov_alias_port->port + 1);
-        ret = get_next_record_to_update(dev, sriov_alias_port->port, rec);
-        if (ret) {
-                pr_debug("No more records to update.\n");
-                goto out;
-        }
-
-        set_guid_rec(&dev->ib_dev, rec->port + 1, rec->block_num,
-                     &rec->rec_det);
-
-out:
-        kfree(rec);
-}
-
-
-void mlx4_ib_init_alias_guid_work(struct mlx4_ib_dev *dev, int port)
-{
-        unsigned long flags, flags1;
-
-        if (!mlx4_is_master(dev->dev))
-                return;
-        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
-        spin_lock_irqsave(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        if (!dev->sriov.is_going_down) {
-                queue_delayed_work(dev->sriov.alias_guid.ports_guid[port].wq,
-                           &dev->sriov.alias_guid.ports_guid[port].alias_guid_work, 0);
-        }
-        spin_unlock_irqrestore(&dev->sriov.alias_guid.ag_work_lock, flags1);
-        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
-}
-
-void mlx4_ib_destroy_alias_guid_service(struct mlx4_ib_dev *dev)
-{
-        int i;
-        struct mlx4_ib_sriov *sriov = &dev->sriov;
-        struct mlx4_alias_guid_work_context *cb_ctx;
-        struct mlx4_sriov_alias_guid_port_rec_det *det;
-        struct ib_sa_query *sa_query;
-        unsigned long flags;
-
-        for (i = 0 ; i < dev->num_ports; i++) {
-                cancel_delayed_work(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work);
-                det = &sriov->alias_guid.ports_guid[i];
-                spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags);
-                while (!list_empty(&det->cb_list)) {
-                        cb_ctx = list_entry(det->cb_list.next,
-                                            struct mlx4_alias_guid_work_context,
-                                            list);
-                        sa_query = cb_ctx->sa_query;
-                        cb_ctx->sa_query = NULL;
-                        list_del(&cb_ctx->list);
-                        spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags);
-                        ib_sa_cancel_query(cb_ctx->query_id, sa_query);
-                        wait_for_completion(&cb_ctx->done);
-                        kfree(cb_ctx);
-                        spin_lock_irqsave(&sriov->alias_guid.ag_work_lock, flags);
-                }
-                spin_unlock_irqrestore(&sriov->alias_guid.ag_work_lock, flags);
-        }
-        for (i = 0 ; i < dev->num_ports; i++) {
-                flush_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
-                destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
-        }
-        ib_sa_unregister_client(dev->sriov.alias_guid.sa_client);
-        kfree(dev->sriov.alias_guid.sa_client);
-}
-
-int mlx4_ib_init_alias_guid_service(struct mlx4_ib_dev *dev)
-{
-        char alias_wq_name[15];
-        int ret = 0;
-        int i, j, k;
-        union ib_gid gid;
-
-        if (!mlx4_is_master(dev->dev))
-                return 0;
-        dev->sriov.alias_guid.sa_client =
-                kzalloc(sizeof *dev->sriov.alias_guid.sa_client, GFP_KERNEL);
-        if (!dev->sriov.alias_guid.sa_client)
-                return -ENOMEM;
-
-        ib_sa_register_client(dev->sriov.alias_guid.sa_client);
-
-        spin_lock_init(&dev->sriov.alias_guid.ag_work_lock);
-
-        for (i = 1; i <= dev->num_ports; ++i) {
-                if (dev->ib_dev.query_gid(&dev->ib_dev , i, 0, &gid)) {
-                        ret = -EFAULT;
-                        goto err_unregister;
-                }
-        }
-
-        for (i = 0 ; i < dev->num_ports; i++) {
-                memset(&dev->sriov.alias_guid.ports_guid[i], 0,
-                       sizeof (struct mlx4_sriov_alias_guid_port_rec_det));
-                /*Check if the SM doesn't need to assign the GUIDs*/
-                for (j = 0; j < NUM_ALIAS_GUID_REC_IN_PORT; j++) {
-                        if (mlx4_ib_sm_guid_assign) {
-                                dev->sriov.alias_guid.ports_guid[i].
-                                        all_rec_per_port[j].
-                                        ownership = MLX4_GUID_DRIVER_ASSIGN;
-                                continue;
-                        }
-                        dev->sriov.alias_guid.ports_guid[i].all_rec_per_port[j].
-                                        ownership = MLX4_GUID_NONE_ASSIGN;
-                        /*mark each val as it was deleted,
-                          till the sysAdmin will give it valid val*/
-                        for (k = 0; k < NUM_ALIAS_GUID_IN_REC; k++) {
-                                *(__be64 *)&dev->sriov.alias_guid.ports_guid[i].
-                                        all_rec_per_port[j].all_recs[GUID_REC_SIZE * k] =
-                                                cpu_to_be64(MLX4_GUID_FOR_DELETE_VAL);
-                        }
-                }
-                INIT_LIST_HEAD(&dev->sriov.alias_guid.ports_guid[i].cb_list);
-                /*prepare the records, set them to be allocated by sm*/
-                for (j = 0 ; j < NUM_ALIAS_GUID_REC_IN_PORT; j++)
-                        invalidate_guid_record(dev, i + 1, j);
-
-                dev->sriov.alias_guid.ports_guid[i].parent = &dev->sriov.alias_guid;
-                dev->sriov.alias_guid.ports_guid[i].port  = i;
-                if (mlx4_ib_sm_guid_assign)
-                        set_all_slaves_guids(dev, i);
-
-                snprintf(alias_wq_name, sizeof alias_wq_name, "alias_guid%d", i);
-                dev->sriov.alias_guid.ports_guid[i].wq =
-                        create_singlethread_workqueue(alias_wq_name);
-                if (!dev->sriov.alias_guid.ports_guid[i].wq) {
-                        ret = -ENOMEM;
-                        goto err_thread;
-                }
-                INIT_DELAYED_WORK(&dev->sriov.alias_guid.ports_guid[i].alias_guid_work,
-                          alias_guid_work);
-        }
-        return 0;
-
-err_thread:
-        for (--i; i >= 0; i--) {
-                destroy_workqueue(dev->sriov.alias_guid.ports_guid[i].wq);
-                dev->sriov.alias_guid.ports_guid[i].wq = NULL;
-        }
-
-err_unregister:
-        ib_sa_unregister_client(dev->sriov.alias_guid.sa_client);
-        kfree(dev->sriov.alias_guid.sa_client);
-        dev->sriov.alias_guid.sa_client = NULL;
-        pr_err("init_alias_guid_service: Failed. (ret:%d)\n", ret);
-        return ret;
-}
diff --git a/drivers/infiniband/hw/mlx4/cm.c b/drivers/infiniband/hw/mlx4/cm.c
deleted file mode 100644
index dbc99d41605..00000000000
--- a/drivers/infiniband/hw/mlx4/cm.c
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
- * Copyright (c) 2012 Mellanox Technologies. 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 <rdma/ib_mad.h>
-
-#include <linux/mlx4/cmd.h>
-#include <linux/rbtree.h>
-#include <linux/idr.h>
-#include <rdma/ib_cm.h>
-
-#include "mlx4_ib.h"
-
-#define CM_CLEANUP_CACHE_TIMEOUT  (5 * HZ)
-
-struct id_map_entry {
-        struct rb_node node;
-
-        u32 sl_cm_id;
-        u32 pv_cm_id;
-        int slave_id;
-        int scheduled_delete;
-        struct mlx4_ib_dev *dev;
-
-        struct list_head list;
-        struct delayed_work timeout;
-};
-
-struct cm_generic_msg {
-        struct ib_mad_hdr hdr;
-
-        __be32 local_comm_id;
-        __be32 remote_comm_id;
-};
-
-struct cm_req_msg {
-        unsigned char unused[0x60];
-        union ib_gid primary_path_sgid;
-};
-
-
-static void set_local_comm_id(struct ib_mad *mad, u32 cm_id)
-{
-        struct cm_generic_msg *msg = (struct cm_generic_msg *)mad;
-        msg->local_comm_id = cpu_to_be32(cm_id);
-}
-
-static u32 get_local_comm_id(struct ib_mad *mad)
-{
-        struct cm_generic_msg *msg = (struct cm_generic_msg *)mad;
-
-        return be32_to_cpu(msg->local_comm_id);
-}
-
-static void set_remote_comm_id(struct ib_mad *mad, u32 cm_id)
-{
-        struct cm_generic_msg *msg = (struct cm_generic_msg *)mad;
-        msg->remote_comm_id = cpu_to_be32(cm_id);
-}
-
-static u32 get_remote_comm_id(struct ib_mad *mad)
-{
-        struct cm_generic_msg *msg = (struct cm_generic_msg *)mad;
-
-        return be32_to_cpu(msg->remote_comm_id);
-}
-
-static union ib_gid gid_from_req_msg(struct ib_device *ibdev, struct ib_mad *mad)
-{
-        struct cm_req_msg *msg = (struct cm_req_msg *)mad;
-
-        return msg->primary_path_sgid;
-}
-
-/* Lock should be taken before called */
-static struct id_map_entry *
-id_map_find_by_sl_id(struct ib_device *ibdev, u32 slave_id, u32 sl_cm_id)
-{
-        struct rb_root *sl_id_map = &to_mdev(ibdev)->sriov.sl_id_map;
-        struct rb_node *node = sl_id_map->rb_node;
-
-        while (node) {
-                struct id_map_entry *id_map_entry =
-                        rb_entry(node, struct id_map_entry, node);
-
-                if (id_map_entry->sl_cm_id > sl_cm_id)
-                        node = node->rb_left;
-                else if (id_map_entry->sl_cm_id < sl_cm_id)
-                        node = node->rb_right;
-                else if (id_map_entry->slave_id > slave_id)
-                        node = node->rb_left;
-                else if (id_map_entry->slave_id < slave_id)
-                        node = node->rb_right;
-                else
-                        return id_map_entry;
-        }
-        return NULL;
-}
-
-static void id_map_ent_timeout(struct work_struct *work)
-{
-        struct delayed_work *delay = to_delayed_work(work);
-        struct id_map_entry *ent = container_of(delay, struct id_map_entry, timeout);
-        struct id_map_entry *db_ent, *found_ent;
-        struct mlx4_ib_dev *dev = ent->dev;
-        struct mlx4_ib_sriov *sriov = &dev->sriov;
-        struct rb_root *sl_id_map = &sriov->sl_id_map;
-        int pv_id = (int) ent->pv_cm_id;
-
-        spin_lock(&sriov->id_map_lock);
-        db_ent = (struct id_map_entry *)idr_find(&sriov->pv_id_table, pv_id);
-        if (!db_ent)
-                goto out;
-        found_ent = id_map_find_by_sl_id(&dev->ib_dev, ent->slave_id, ent->sl_cm_id);
-        if (found_ent && found_ent == ent)
-                rb_erase(&found_ent->node, sl_id_map);
-        idr_remove(&sriov->pv_id_table, pv_id);
-
-out:
-        list_del(&ent->list);
-        spin_unlock(&sriov->id_map_lock);
-        kfree(ent);
-}
-
-static void id_map_find_del(struct ib_device *ibdev, int pv_cm_id)
-{
-        struct mlx4_ib_sriov *sriov = &to_mdev(ibdev)->sriov;
-        struct rb_root *sl_id_map = &sriov->sl_id_map;
-        struct id_map_entry *ent, *found_ent;
-
-        spin_lock(&sriov->id_map_lock);
-        ent = (struct id_map_entry *)idr_find(&sriov->pv_id_table, pv_cm_id);
-        if (!ent)
-                goto out;
-        found_ent = id_map_find_by_sl_id(ibdev, ent->slave_id, ent->sl_cm_id);
-        if (found_ent && found_ent == ent)
-                rb_erase(&found_ent->node, sl_id_map);
-        idr_remove(&sriov->pv_id_table, pv_cm_id);
-out:
-        spin_unlock(&sriov->id_map_lock);
-}
-
-static void sl_id_map_add(struct ib_device *ibdev, struct id_map_entry *new)
-{
-        struct rb_root *sl_id_map = &to_mdev(ibdev)->sriov.sl_id_map;
-        struct rb_node **link = &sl_id_map->rb_node, *parent = NULL;
-        struct id_map_entry *ent;
-        int slave_id = new->slave_id;
-        int sl_cm_id = new->sl_cm_id;
-
-        ent = id_map_find_by_sl_id(ibdev, slave_id, sl_cm_id);
-        if (ent) {
-                pr_debug("overriding existing sl_id_map entry (cm_id = %x)\n",
-                         sl_cm_id);
-
-                rb_replace_node(&ent->node, &new->node, sl_id_map);
-                return;
-        }
-
-        /* Go to the bottom of the tree */
-        while (*link) {
-                parent = *link;
-                ent = rb_entry(parent, struct id_map_entry, node);
-
-                if (ent->sl_cm_id > sl_cm_id || (ent->sl_cm_id == sl_cm_id && ent->slave_id > slave_id))
-                        link = &(*link)->rb_left;
-                else
-                        link = &(*link)->rb_right;
-        }
-
-        rb_link_node(&new->node, parent, link);
-        rb_insert_color(&new->node, sl_id_map);
-}
-
-static struct id_map_entry *
-id_map_alloc(struct ib_device *ibdev, int slave_id, u32 sl_cm_id)
-{
-        int ret, id;
-        static int next_id;
-        struct id_map_entry *ent;
-        struct mlx4_ib_sriov *sriov = &to_mdev(ibdev)->sriov;
-
-        ent = kmalloc(sizeof (struct id_map_entry), GFP_KERNEL);
-        if (!ent) {
-                mlx4_ib_warn(ibdev, "Couldn't allocate id cache entry - out of memory\n");
-                return ERR_PTR(-ENOMEM);
-        }
-
-        ent->sl_cm_id = sl_cm_id;
-        ent->slave_id = slave_id;
-        ent->scheduled_delete = 0;
-        ent->dev = to_mdev(ibdev);
-        INIT_DELAYED_WORK(&ent->timeout, id_map_ent_timeout);
-
-        do {
-                spin_lock(&to_mdev(ibdev)->sriov.id_map_lock);
-                ret = idr_get_new_above(&sriov->pv_id_table, ent,
-                                        next_id, &id);
-                if (!ret) {
-                        next_id = ((unsigned) id + 1) & MAX_IDR_MASK;
-                        ent->pv_cm_id = (u32)id;
-                        sl_id_map_add(ibdev, ent);
-                }
-
-                spin_unlock(&sriov->id_map_lock);
-        } while (ret == -EAGAIN && idr_pre_get(&sriov->pv_id_table, GFP_KERNEL));
-        /*the function idr_get_new_above can return -ENOSPC, so don't insert in that case.*/
-        if (!ret) {
-                spin_lock(&sriov->id_map_lock);
-                list_add_tail(&ent->list, &sriov->cm_list);
-                spin_unlock(&sriov->id_map_lock);
-                return ent;
-        }
-        /*error flow*/
-        kfree(ent);
-        mlx4_ib_warn(ibdev, "No more space in the idr (err:0x%x)\n", ret);
-        return ERR_PTR(-ENOMEM);
-}
-
-static struct id_map_entry *
-id_map_get(struct ib_device *ibdev, int *pv_cm_id, int sl_cm_id, int slave_id)
-{
-        struct id_map_entry *ent;
-        struct mlx4_ib_sriov *sriov = &to_mdev(ibdev)->sriov;
-
-        spin_lock(&sriov->id_map_lock);
-        if (*pv_cm_id == -1) {
-                ent = id_map_find_by_sl_id(ibdev, sl_cm_id, slave_id);
-                if (ent)
-                        *pv_cm_id = (int) ent->pv_cm_id;
-        } else
-                ent = (struct id_map_entry *)idr_find(&sriov->pv_id_table, *pv_cm_id);
-        spin_unlock(&sriov->id_map_lock);
-
-        return ent;
-}
-
-static void schedule_delayed(struct ib_device *ibdev, struct id_map_entry *id)
-{
-        struct mlx4_ib_sriov *sriov = &to_mdev(ibdev)->sriov;
-        unsigned long flags;
-
-        spin_lock(&sriov->id_map_lock);
-        spin_lock_irqsave(&sriov->going_down_lock, flags);
-        /*make sure that there is no schedule inside the scheduled work.*/
-        if (!sriov->is_going_down) {
-                id->scheduled_delete = 1;
-                schedule_delayed_work(&id->timeout, CM_CLEANUP_CACHE_TIMEOUT);
-        }
-        spin_unlock_irqrestore(&sriov->going_down_lock, flags);
-        spin_unlock(&sriov->id_map_lock);
-}
-
-int mlx4_ib_multiplex_cm_handler(struct ib_device *ibdev, int port, int slave_id,
-                struct ib_mad *mad)
-{
-        struct id_map_entry *id;
-        u32 sl_cm_id;
-        int pv_cm_id = -1;
-
-        sl_cm_id = get_local_comm_id(mad);
-
-        if (mad->mad_hdr.attr_id == CM_REQ_ATTR_ID ||
-                        mad->mad_hdr.attr_id == CM_REP_ATTR_ID) {
-                id = id_map_alloc(ibdev, slave_id, sl_cm_id);
-                if (IS_ERR(id)) {
-                        mlx4_ib_warn(ibdev, "%s: id{slave: %d, sl_cm_id: 0x%x} Failed to id_map_alloc\n",
-                                __func__, slave_id, sl_cm_id);
-                        return PTR_ERR(id);
-                }
-        } else if (mad->mad_hdr.attr_id == CM_REJ_ATTR_ID) {
-                return 0;
-        } else {
-                id = id_map_get(ibdev, &pv_cm_id, slave_id, sl_cm_id);
-        }
-
-        if (!id) {
-                pr_debug("id{slave: %d, sl_cm_id: 0x%x} is NULL!\n",
-                         slave_id, sl_cm_id);
-                return -EINVAL;
-        }
-
-        set_local_comm_id(mad, id->pv_cm_id);
-
-        if (mad->mad_hdr.attr_id == CM_DREQ_ATTR_ID)
-                schedule_delayed(ibdev, id);
-        else if (mad->mad_hdr.attr_id == CM_DREP_ATTR_ID)
-                id_map_find_del(ibdev, pv_cm_id);
-
-        return 0;
-}
-
-int mlx4_ib_demux_cm_handler(struct ib_device *ibdev, int port, int *slave,
-                                                             struct ib_mad *mad)
-{
-        u32 pv_cm_id;
-        struct id_map_entry *id;
-
-        if (mad->mad_hdr.attr_id == CM_REQ_ATTR_ID) {
-                union ib_gid gid;
-
-                gid = gid_from_req_msg(ibdev, mad);
-                *slave = mlx4_ib_find_real_gid(ibdev, port, gid.global.interface_id);
-                if (*slave < 0) {
-                        mlx4_ib_warn(ibdev, "failed matching slave_id by gid (0x%llx)\n",
-                                        gid.global.interface_id);
-                        return -ENOENT;
-                }
-                return 0;
-        }
-
-        pv_cm_id = get_remote_comm_id(mad);
-        id = id_map_get(ibdev, (int *)&pv_cm_id, -1, -1);
-
-        if (!id) {
-                pr_debug("Couldn't find an entry for pv_cm_id 0x%x\n", pv_cm_id);
-                return -ENOENT;
-        }
-
-        *slave = id->slave_id;
-        set_remote_comm_id(mad, id->sl_cm_id);
-
-        if (mad->mad_hdr.attr_id == CM_DREQ_ATTR_ID)
-                schedule_delayed(ibdev, id);
-        else if (mad->mad_hdr.attr_id == CM_REJ_ATTR_ID ||
-                        mad->mad_hdr.attr_id == CM_DREP_ATTR_ID) {
-                id_map_find_del(ibdev, (int) pv_cm_id);
-        }
-
-        return 0;
-}
-
-void mlx4_ib_cm_paravirt_init(struct mlx4_ib_dev *dev)
-{
-        spin_lock_init(&dev->sriov.id_map_lock);
-        INIT_LIST_HEAD(&dev->sriov.cm_list);
-        dev->sriov.sl_id_map = RB_ROOT;
-        idr_init(&dev->sriov.pv_id_table);
-        idr_pre_get(&dev->sriov.pv_id_table, GFP_KERNEL);
-}
-
-/* slave = -1 ==> all slaves */
-/* TBD -- call paravirt clean for single slave.  Need for slave RESET event */
-void mlx4_ib_cm_paravirt_clean(struct mlx4_ib_dev *dev, int slave)
-{
-        struct mlx4_ib_sriov *sriov = &dev->sriov;
-        struct rb_root *sl_id_map = &sriov->sl_id_map;
-        struct list_head lh;
-        struct rb_node *nd;
-        int need_flush = 1;
-        struct id_map_entry *map, *tmp_map;
-        /* cancel all delayed work queue entries */
-        INIT_LIST_HEAD(&lh);
-        spin_lock(&sriov->id_map_lock);
-        list_for_each_entry_safe(map, tmp_map, &dev->sriov.cm_list, list) {
-                if (slave < 0 || slave == map->slave_id) {
-                        if (map->scheduled_delete)
-                                need_flush &= !!cancel_delayed_work(&map->timeout);
-                }
-        }
-
-        spin_unlock(&sriov->id_map_lock);
-
-        if (!need_flush)
-                flush_scheduled_work(); /* make sure all timers were flushed */
-
-        /* now, remove all leftover entries from databases*/
-        spin_lock(&sriov->id_map_lock);
-        if (slave < 0) {
-                while (rb_first(sl_id_map)) {
-                        struct id_map_entry *ent =
-                                rb_entry(rb_first(sl_id_map),
-                                         struct id_map_entry, node);
-
-                        rb_erase(&ent->node, sl_id_map);
-                        idr_remove(&sriov->pv_id_table, (int) ent->pv_cm_id);
-                }
-                list_splice_init(&dev->sriov.cm_list, &lh);
-        } else {
-                /* first, move nodes belonging to slave to db remove list */
-                nd = rb_first(sl_id_map);
-                while (nd) {
-                        struct id_map_entry *ent =
-                                rb_entry(nd, struct id_map_entry, node);
-                        nd = rb_next(nd);
-                        if (ent->slave_id == slave)
-                                list_move_tail(&ent->list, &lh);
-                }
-                /* remove those nodes from databases */
-                list_for_each_entry_safe(map, tmp_map, &lh, list) {
-                        rb_erase(&map->node, sl_id_map);
-                        idr_remove(&sriov->pv_id_table, (int) map->pv_cm_id);
-                }
-
-                /* add remaining nodes from cm_list */
-                list_for_each_entry_safe(map, tmp_map, &dev->sriov.cm_list, list) {
-                        if (slave == map->slave_id)
-                                list_move_tail(&map->list, &lh);
-                }
-        }
-
-        spin_unlock(&sriov->id_map_lock);
-
-        /* free any map entries left behind due to cancel_delayed_work above */
-        list_for_each_entry_safe(map, tmp_map, &lh, list) {
-                list_del(&map->list);
-                kfree(map);
-        }
-}
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index ae67df35dd4..e8df155bc3b 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -50,7 +50,7 @@ static void mlx4_ib_cq_event(struct mlx4_cq *cq, enum mlx4_event type)
         struct ib_cq *ibcq;
 
         if (type != MLX4_EVENT_TYPE_CQ_ERROR) {
-                pr_warn("Unexpected event type %d "
+                printk(KERN_WARNING "mlx4_ib: Unexpected event type %d "
                        "on CQ %06x\n", type, cq->cqn);
                 return;
         }
@@ -66,7 +66,7 @@ static void mlx4_ib_cq_event(struct mlx4_cq *cq, enum mlx4_event type)
 
 static void *get_cqe_from_buf(struct mlx4_ib_cq_buf *buf, int n)
 {
-        return mlx4_buf_offset(&buf->buf, n * buf->entry_size);
+        return mlx4_buf_offset(&buf->buf, n * sizeof (struct mlx4_cqe));
 }
 
 static void *get_cqe(struct mlx4_ib_cq *cq, int n)
@@ -77,9 +77,8 @@ static void *get_cqe(struct mlx4_ib_cq *cq, int n)
 static void *get_sw_cqe(struct mlx4_ib_cq *cq, int n)
 {
         struct mlx4_cqe *cqe = get_cqe(cq, n & cq->ibcq.cqe);
-        struct mlx4_cqe *tcqe = ((cq->buf.entry_size == 64) ? (cqe + 1) : cqe);
 
-        return (!!(tcqe->owner_sr_opcode & MLX4_CQE_OWNER_MASK) ^
+        return (!!(cqe->owner_sr_opcode & MLX4_CQE_OWNER_MASK) ^
                 !!(n & (cq->ibcq.cqe + 1))) ? NULL : cqe;
 }
 
@@ -100,13 +99,12 @@ static int mlx4_ib_alloc_cq_buf(struct mlx4_ib_dev *dev, struct mlx4_ib_cq_buf *
 {
         int err;
 
-        err = mlx4_buf_alloc(dev->dev, nent * dev->dev->caps.cqe_size,
+        err = mlx4_buf_alloc(dev->dev, nent * sizeof(struct mlx4_cqe),
                              PAGE_SIZE * 2, &buf->buf);
 
         if (err)
                 goto out;
 
-        buf->entry_size = dev->dev->caps.cqe_size;
         err = mlx4_mtt_init(dev->dev, buf->buf.npages, buf->buf.page_shift,
                                     &buf->mtt);
         if (err)
@@ -122,7 +120,8 @@ err_mtt:
         mlx4_mtt_cleanup(dev->dev, &buf->mtt);
 
 err_buf:
-        mlx4_buf_free(dev->dev, nent * buf->entry_size, &buf->buf);
+        mlx4_buf_free(dev->dev, nent * sizeof(struct mlx4_cqe),
+                              &buf->buf);
 
 out:
         return err;
@@ -130,7 +129,7 @@ out:
 
 static void mlx4_ib_free_cq_buf(struct mlx4_ib_dev *dev, struct mlx4_ib_cq_buf *buf, int cqe)
 {
-        mlx4_buf_free(dev->dev, (cqe + 1) * buf->entry_size, &buf->buf);
+        mlx4_buf_free(dev->dev, (cqe + 1) * sizeof(struct mlx4_cqe), &buf->buf);
 }
 
 static int mlx4_ib_get_cq_umem(struct mlx4_ib_dev *dev, struct ib_ucontext *context,
@@ -138,9 +137,8 @@ static int mlx4_ib_get_cq_umem(struct mlx4_ib_dev *dev, struct ib_ucontext *cont
                                u64 buf_addr, int cqe)
 {
         int err;
-        int cqe_size = dev->dev->caps.cqe_size;
 
-        *umem = ib_umem_get(context, buf_addr, cqe * cqe_size,
+        *umem = ib_umem_get(context, buf_addr, cqe * sizeof (struct mlx4_cqe),
                             IB_ACCESS_LOCAL_WRITE, 1);
         if (IS_ERR(*umem))
                 return PTR_ERR(*umem);
@@ -224,9 +222,6 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector
                 uar = &dev->priv_uar;
         }
 
-        if (dev->eq_table)
-                vector = dev->eq_table[vector % ibdev->num_comp_vectors];
-
         err = mlx4_cq_alloc(dev->dev, entries, &cq->buf.mtt, uar,
                             cq->db.dma, &cq->mcq, vector, 0);
         if (err)
@@ -333,23 +328,16 @@ static void mlx4_ib_cq_resize_copy_cqes(struct mlx4_ib_cq *cq)
 {
         struct mlx4_cqe *cqe, *new_cqe;
         int i;
-        int cqe_size = cq->buf.entry_size;
-        int cqe_inc = cqe_size == 64 ? 1 : 0;
 
         i = cq->mcq.cons_index;
         cqe = get_cqe(cq, i & cq->ibcq.cqe);
-        cqe += cqe_inc;
-
         while ((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) != MLX4_CQE_OPCODE_RESIZE) {
                 new_cqe = get_cqe_from_buf(&cq->resize_buf->buf,
                                            (i + 1) & cq->resize_buf->cqe);
-                memcpy(new_cqe, get_cqe(cq, i & cq->ibcq.cqe), cqe_size);
-                new_cqe += cqe_inc;
-
+                memcpy(new_cqe, get_cqe(cq, i & cq->ibcq.cqe), sizeof(struct mlx4_cqe));
                 new_cqe->owner_sr_opcode = (cqe->owner_sr_opcode & ~MLX4_CQE_OWNER_MASK) |
                         (((i + 1) & (cq->resize_buf->cqe + 1)) ? MLX4_CQE_OWNER_MASK : 0);
                 cqe = get_cqe(cq, ++i & cq->ibcq.cqe);
-                cqe += cqe_inc;
         }
         ++cq->mcq.cons_index;
 }
@@ -447,7 +435,6 @@ err_buf:
 
 out:
         mutex_unlock(&cq->resize_mutex);
-
         return err;
 }
 
@@ -476,7 +463,7 @@ static void dump_cqe(void *cqe)
 {
         __be32 *buf = cqe;
 
-        pr_debug("CQE contents %08x %08x %08x %08x %08x %08x %08x %08x\n",
+        printk(KERN_DEBUG "CQE contents %08x %08x %08x %08x %08x %08x %08x %08x\n",
                be32_to_cpu(buf[0]), be32_to_cpu(buf[1]), be32_to_cpu(buf[2]),
                be32_to_cpu(buf[3]), be32_to_cpu(buf[4]), be32_to_cpu(buf[5]),
                be32_to_cpu(buf[6]), be32_to_cpu(buf[7]));
@@ -486,7 +473,7 @@ static void mlx4_ib_handle_error_cqe(struct mlx4_err_cqe *cqe,
                                      struct ib_wc *wc)
 {
         if (cqe->syndrome == MLX4_CQE_SYNDROME_LOCAL_QP_OP_ERR) {
-                pr_debug("local QP operation err "
+                printk(KERN_DEBUG "local QP operation err "
                        "(QPN %06x, WQE index %x, vendor syndrome %02x, "
                        "opcode = %02x)\n",
                        be32_to_cpu(cqe->my_qpn), be16_to_cpu(cqe->wqe_index),
@@ -557,26 +544,6 @@ static int mlx4_ib_ipoib_csum_ok(__be16 status, __be16 checksum)
                 checksum == cpu_to_be16(0xffff);
 }
 
-static int use_tunnel_data(struct mlx4_ib_qp *qp, struct mlx4_ib_cq *cq, struct ib_wc *wc,
-                           unsigned tail, struct mlx4_cqe *cqe)
-{
-        struct mlx4_ib_proxy_sqp_hdr *hdr;
-
-        ib_dma_sync_single_for_cpu(qp->ibqp.device,
-                                   qp->sqp_proxy_rcv[tail].map,
-                                   sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                   DMA_FROM_DEVICE);
-        hdr = (struct mlx4_ib_proxy_sqp_hdr *) (qp->sqp_proxy_rcv[tail].addr);
-        wc->pkey_index  = be16_to_cpu(hdr->tun.pkey_index);
-        wc->slid        = be16_to_cpu(hdr->tun.slid_mac_47_32);
-        wc->sl          = (u8) (be16_to_cpu(hdr->tun.sl_vid) >> 12);
-        wc->src_qp      = be32_to_cpu(hdr->tun.flags_src_qp) & 0xFFFFFF;
-        wc->wc_flags   |= (hdr->tun.g_ml_path & 0x80) ? (IB_WC_GRH) : 0;
-        wc->dlid_path_bits = 0;
-
-        return 0;
-}
-
 static int mlx4_ib_poll_one(struct mlx4_ib_cq *cq,
                             struct mlx4_ib_qp **cur_qp,
                             struct ib_wc *wc)
@@ -589,16 +556,12 @@ static int mlx4_ib_poll_one(struct mlx4_ib_cq *cq,
         int is_error;
         u32 g_mlpath_rqpn;
         u16 wqe_ctr;
-        unsigned tail = 0;
 
 repoll:
         cqe = next_cqe_sw(cq);
         if (!cqe)
                 return -EAGAIN;
 
-        if (cq->buf.entry_size == 64)
-                cqe++;
-
         ++cq->mcq.cons_index;
 
         /*
@@ -613,7 +576,7 @@ repoll:
 
         if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) == MLX4_OPCODE_NOP &&
                      is_send)) {
-                pr_warn("Completion for NOP opcode detected!\n");
+                printk(KERN_WARNING "Completion for NOP opcode detected!\n");
                 return -EINVAL;
         }
 
@@ -643,7 +606,7 @@ repoll:
                 mqp = __mlx4_qp_lookup(to_mdev(cq->ibcq.device)->dev,
                                        be32_to_cpu(cqe->vlan_my_qpn));
                 if (unlikely(!mqp)) {
-                        pr_warn("CQ %06x with entry for unknown QPN %06x\n",
+                        printk(KERN_WARNING "CQ %06x with entry for unknown QPN %06x\n",
                                cq->mcq.cqn, be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK);
                         return -EINVAL;
                 }
@@ -668,8 +631,7 @@ repoll:
                 mlx4_ib_free_srq_wqe(srq, wqe_ctr);
         } else {
                 wq        = &(*cur_qp)->rq;
-                tail      = wq->tail & (wq->wqe_cnt - 1);
-                wc->wr_id = wq->wrid[tail];
+                wc->wr_id = wq->wrid[wq->tail & (wq->wqe_cnt - 1)];
                 ++wq->tail;
         }
 
@@ -752,26 +714,14 @@ repoll:
                         break;
                 }
 
-                if (mlx4_is_mfunc(to_mdev(cq->ibcq.device)->dev)) {
-                        if ((*cur_qp)->mlx4_ib_qp_type &
-                            (MLX4_IB_QPT_PROXY_SMI_OWNER |
-                             MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI))
-                                return use_tunnel_data(*cur_qp, cq, wc, tail, cqe);
-                }
-
                 wc->slid           = be16_to_cpu(cqe->rlid);
+                wc->sl             = be16_to_cpu(cqe->sl_vid) >> 12;
                 g_mlpath_rqpn      = be32_to_cpu(cqe->g_mlpath_rqpn);
                 wc->src_qp         = g_mlpath_rqpn & 0xffffff;
                 wc->dlid_path_bits = (g_mlpath_rqpn >> 24) & 0x7f;
                 wc->wc_flags      |= g_mlpath_rqpn & 0x80000000 ? IB_WC_GRH : 0;
                 wc->pkey_index     = be32_to_cpu(cqe->immed_rss_invalid) & 0x7f;
-                wc->wc_flags      |= mlx4_ib_ipoib_csum_ok(cqe->status,
-                                        cqe->checksum) ? IB_WC_IP_CSUM_OK : 0;
-                if (rdma_port_get_link_layer(wc->qp->device,
-                                (*cur_qp)->port) == IB_LINK_LAYER_ETHERNET)
-                        wc->sl  = be16_to_cpu(cqe->sl_vid) >> 13;
-                else
-                        wc->sl  = be16_to_cpu(cqe->sl_vid) >> 12;
+                wc->csum_ok        = mlx4_ib_ipoib_csum_ok(cqe->status, cqe->checksum);
         }
 
         return 0;
@@ -793,7 +743,8 @@ int mlx4_ib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc)
                         break;
         }
 
-        mlx4_cq_set_ci(&cq->mcq);
+        if (npolled)
+                mlx4_cq_set_ci(&cq->mcq);
 
         spin_unlock_irqrestore(&cq->lock, flags);
 
@@ -820,7 +771,6 @@ void __mlx4_ib_cq_clean(struct mlx4_ib_cq *cq, u32 qpn, struct mlx4_ib_srq *srq)
         int nfreed = 0;
         struct mlx4_cqe *cqe, *dest;
         u8 owner_bit;
-        int cqe_inc = cq->buf.entry_size == 64 ? 1 : 0;
 
         /*
          * First we need to find the current producer index, so we
@@ -839,16 +789,12 @@ void __mlx4_ib_cq_clean(struct mlx4_ib_cq *cq, u32 qpn, struct mlx4_ib_srq *srq)
          */
         while ((int) --prod_index - (int) cq->mcq.cons_index >= 0) {
                 cqe = get_cqe(cq, prod_index & cq->ibcq.cqe);
-                cqe += cqe_inc;
-
                 if ((be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK) == qpn) {
                         if (srq && !(cqe->owner_sr_opcode & MLX4_CQE_IS_SEND_MASK))
                                 mlx4_ib_free_srq_wqe(srq, be16_to_cpu(cqe->wqe_index));
                         ++nfreed;
                 } else if (nfreed) {
                         dest = get_cqe(cq, (prod_index + nfreed) & cq->ibcq.cqe);
-                        dest += cqe_inc;
-
                         owner_bit = dest->owner_sr_opcode & MLX4_CQE_OWNER_MASK;
                         memcpy(dest, cqe, sizeof *cqe);
                         dest->owner_sr_opcode = owner_bit |
diff --git a/drivers/infiniband/hw/mlx4/mad.c b/drivers/infiniband/hw/mlx4/mad.c
index 0a903c129f0..f36da994a85 100644
--- a/drivers/infiniband/hw/mlx4/mad.c
+++ b/drivers/infiniband/hw/mlx4/mad.c
@@ -32,10 +32,7 @@
 
 #include <rdma/ib_mad.h>
 #include <rdma/ib_smi.h>
-#include <rdma/ib_sa.h>
-#include <rdma/ib_cache.h>
 
-#include <linux/random.h>
 #include <linux/mlx4/cmd.h>
 #include <linux/gfp.h>
 #include <rdma/ib_pma.h>
@@ -47,62 +44,7 @@ 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)
-
- /* Port mgmt change event handling */
-
-#define GET_BLK_PTR_FROM_EQE(eqe) be32_to_cpu(eqe->event.port_mgmt_change.params.tbl_change_info.block_ptr)
-#define GET_MASK_FROM_EQE(eqe) be32_to_cpu(eqe->event.port_mgmt_change.params.tbl_change_info.tbl_entries_mask)
-#define NUM_IDX_IN_PKEY_TBL_BLK 32
-#define GUID_TBL_ENTRY_SIZE 8      /* size in bytes */
-#define GUID_TBL_BLK_NUM_ENTRIES 8
-#define GUID_TBL_BLK_SIZE (GUID_TBL_ENTRY_SIZE * GUID_TBL_BLK_NUM_ENTRIES)
-
-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;
-
-static void handle_client_rereg_event(struct mlx4_ib_dev *dev, u8 port_num);
-static void handle_lid_change_event(struct mlx4_ib_dev *dev, u8 port_num);
-static void __propagate_pkey_ev(struct mlx4_ib_dev *dev, int port_num,
-                                int block, u32 change_bitmap);
-
-__be64 mlx4_ib_gen_node_guid(void)
-{
-#define NODE_GUID_HI    ((u64) (((u64)IB_OPENIB_OUI) << 40))
-        return cpu_to_be64(NODE_GUID_HI | random32());
-}
-
-__be64 mlx4_ib_get_new_demux_tid(struct mlx4_ib_demux_ctx *ctx)
-{
-        return cpu_to_be64(atomic_inc_return(&ctx->tid)) |
-                cpu_to_be64(0xff00000000000000LL);
-}
-
-int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int mad_ifc_flags,
+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)
 {
@@ -129,13 +71,10 @@ int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int mad_ifc_flags,
          * Key check traps can't be generated unless we have in_wc to
          * tell us where to send the trap.
          */
-        if ((mad_ifc_flags & MLX4_MAD_IFC_IGNORE_MKEY) || !in_wc)
+        if (ignore_mkey || !in_wc)
                 op_modifier |= 0x1;
-        if ((mad_ifc_flags & MLX4_MAD_IFC_IGNORE_BKEY) || !in_wc)
+        if (ignore_bkey || !in_wc)
                 op_modifier |= 0x2;
-        if (mlx4_is_mfunc(dev->dev) &&
-            (mad_ifc_flags & MLX4_MAD_IFC_NET_VIEW || in_wc))
-                op_modifier |= 0x8;
 
         if (in_wc) {
                 struct {
@@ -168,10 +107,9 @@ int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int mad_ifc_flags,
                 in_modifier |= in_wc->slid << 16;
         }
 
-        err = mlx4_cmd_box(dev->dev, inmailbox->dma, outmailbox->dma, in_modifier,
-                           mlx4_is_master(dev->dev) ? (op_modifier & ~0x8) : op_modifier,
-                           MLX4_CMD_MAD_IFC, MLX4_CMD_TIME_CLASS_C,
-                           (op_modifier & 0x8) ? MLX4_CMD_NATIVE : MLX4_CMD_WRAPPED);
+        err = mlx4_cmd_box(dev->dev, inmailbox->dma, outmailbox->dma,
+                           in_modifier, op_modifier,
+                           MLX4_CMD_MAD_IFC, MLX4_CMD_TIME_CLASS_C);
 
         if (!err)
                 memcpy(response_mad, outmailbox->buf, 256);
@@ -186,7 +124,6 @@ static void update_sm_ah(struct mlx4_ib_dev *dev, u8 port_num, u16 lid, u8 sl)
 {
         struct ib_ah *new_ah;
         struct ib_ah_attr ah_attr;
-        unsigned long flags;
 
         if (!dev->send_agent[port_num - 1][0])
                 return;
@@ -201,134 +138,53 @@ static void update_sm_ah(struct mlx4_ib_dev *dev, u8 port_num, u16 lid, u8 sl)
         if (IS_ERR(new_ah))
                 return;
 
-        spin_lock_irqsave(&dev->sm_lock, flags);
+        spin_lock(&dev->sm_lock);
         if (dev->sm_ah[port_num - 1])
                 ib_destroy_ah(dev->sm_ah[port_num - 1]);
         dev->sm_ah[port_num - 1] = new_ah;
-        spin_unlock_irqrestore(&dev->sm_lock, flags);
+        spin_unlock(&dev->sm_lock);
 }
 
 /*
- * Snoop SM MADs for port info, GUID info, and  P_Key table sets, so we can
- * synthesize LID change, Client-Rereg, GID change, and P_Key change events.
+ * Snoop SM MADs for port info and P_Key table sets, so we can
+ * synthesize LID change and P_Key change events.
  */
 static void smp_snoop(struct ib_device *ibdev, u8 port_num, struct ib_mad *mad,
-                      u16 prev_lid)
+                                u16 prev_lid)
 {
-        struct ib_port_info *pinfo;
-        u16 lid;
-        __be16 *base;
-        u32 bn, pkey_change_bitmap;
-        int i;
-
+        struct ib_event event;
 
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
         if ((mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
              mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) &&
-            mad->mad_hdr.method == IB_MGMT_METHOD_SET)
-                switch (mad->mad_hdr.attr_id) {
-                case IB_SMP_ATTR_PORT_INFO:
-                        pinfo = (struct ib_port_info *) ((struct ib_smp *) mad)->data;
-                        lid = be16_to_cpu(pinfo->lid);
+            mad->mad_hdr.method == IB_MGMT_METHOD_SET) {
+                if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO) {
+                        struct ib_port_info *pinfo =
+                                (struct ib_port_info *) ((struct ib_smp *) mad)->data;
+                        u16 lid = be16_to_cpu(pinfo->lid);
 
-                        update_sm_ah(dev, port_num,
+                        update_sm_ah(to_mdev(ibdev), port_num,
                                      be16_to_cpu(pinfo->sm_lid),
                                      pinfo->neighbormtu_mastersmsl & 0xf);
 
-                        if (pinfo->clientrereg_resv_subnetto & 0x80)
-                                handle_client_rereg_event(dev, port_num);
-
-                        if (prev_lid != lid)
-                                handle_lid_change_event(dev, port_num);
-                        break;
-
-                case IB_SMP_ATTR_PKEY_TABLE:
-                        if (!mlx4_is_mfunc(dev->dev)) {
-                                mlx4_ib_dispatch_event(dev, port_num,
-                                                       IB_EVENT_PKEY_CHANGE);
-                                break;
-                        }
+                        event.device           = ibdev;
+                        event.element.port_num = port_num;
 
-                        /* at this point, we are running in the master.
-                         * Slaves do not receive SMPs.
-                         */
-                        bn  = be32_to_cpu(((struct ib_smp *)mad)->attr_mod) & 0xFFFF;
-                        base = (__be16 *) &(((struct ib_smp *)mad)->data[0]);
-                        pkey_change_bitmap = 0;
-                        for (i = 0; i < 32; i++) {
-                                pr_debug("PKEY[%d] = x%x\n",
-                                         i + bn*32, be16_to_cpu(base[i]));
-                                if (be16_to_cpu(base[i]) !=
-                                    dev->pkeys.phys_pkey_cache[port_num - 1][i + bn*32]) {
-                                        pkey_change_bitmap |= (1 << i);
-                                        dev->pkeys.phys_pkey_cache[port_num - 1][i + bn*32] =
-                                                be16_to_cpu(base[i]);
-                                }
+                        if (pinfo->clientrereg_resv_subnetto & 0x80) {
+                                event.event    = IB_EVENT_CLIENT_REREGISTER;
+                                ib_dispatch_event(&event);
                         }
-                        pr_debug("PKEY Change event: port=%d, "
-                                 "block=0x%x, change_bitmap=0x%x\n",
-                                 port_num, bn, pkey_change_bitmap);
 
-                        if (pkey_change_bitmap) {
-                                mlx4_ib_dispatch_event(dev, port_num,
-                                                       IB_EVENT_PKEY_CHANGE);
-                                if (!dev->sriov.is_going_down)
-                                        __propagate_pkey_ev(dev, port_num, bn,
-                                                            pkey_change_bitmap);
+                        if (prev_lid != lid) {
+                                event.event    = IB_EVENT_LID_CHANGE;
+                                ib_dispatch_event(&event);
                         }
-                        break;
-
-                case IB_SMP_ATTR_GUID_INFO:
-                        /* paravirtualized master's guid is guid 0 -- does not change */
-                        if (!mlx4_is_master(dev->dev))
-                                mlx4_ib_dispatch_event(dev, port_num,
-                                                       IB_EVENT_GID_CHANGE);
-                        /*if master, notify relevant slaves*/
-                        if (mlx4_is_master(dev->dev) &&
-                            !dev->sriov.is_going_down) {
-                                bn = be32_to_cpu(((struct ib_smp *)mad)->attr_mod);
-                                mlx4_ib_update_cache_on_guid_change(dev, bn, port_num,
-                                                                    (u8 *)(&((struct ib_smp *)mad)->data));
-                                mlx4_ib_notify_slaves_on_guid_change(dev, bn, port_num,
-                                                                     (u8 *)(&((struct ib_smp *)mad)->data));
-                        }
-                        break;
-
-                default:
-                        break;
                 }
-}
 
-static void __propagate_pkey_ev(struct mlx4_ib_dev *dev, int port_num,
-                                int block, u32 change_bitmap)
-{
-        int i, ix, slave, err;
-        int have_event = 0;
-
-        for (slave = 0; slave < dev->dev->caps.sqp_demux; slave++) {
-                if (slave == mlx4_master_func_num(dev->dev))
-                        continue;
-                if (!mlx4_is_slave_active(dev->dev, slave))
-                        continue;
-
-                have_event = 0;
-                for (i = 0; i < 32; i++) {
-                        if (!(change_bitmap & (1 << i)))
-                                continue;
-                        for (ix = 0;
-                             ix < dev->dev->caps.pkey_table_len[port_num]; ix++) {
-                                if (dev->pkeys.virt2phys_pkey[slave][port_num - 1]
-                                    [ix] == i + 32 * block) {
-                                        err = mlx4_gen_pkey_eqe(dev->dev, slave, port_num);
-                                        pr_debug("propagate_pkey_ev: slave %d,"
-                                                 " port %d, ix %d (%d)\n",
-                                                 slave, port_num, ix, err);
-                                        have_event = 1;
-                                        break;
-                                }
-                        }
-                        if (have_event)
-                                break;
+                if (mad->mad_hdr.attr_id == IB_SMP_ATTR_PKEY_TABLE) {
+                        event.device           = ibdev;
+                        event.event            = IB_EVENT_PKEY_CHANGE;
+                        event.element.port_num = port_num;
+                        ib_dispatch_event(&event);
                 }
         }
 }
@@ -336,15 +192,13 @@ static void __propagate_pkey_ev(struct mlx4_ib_dev *dev, int port_num,
 static void node_desc_override(struct ib_device *dev,
                                struct ib_mad *mad)
 {
-        unsigned long flags;
-
         if ((mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED ||
              mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) &&
             mad->mad_hdr.method == IB_MGMT_METHOD_GET_RESP &&
             mad->mad_hdr.attr_id == IB_SMP_ATTR_NODE_DESC) {
-                spin_lock_irqsave(&to_mdev(dev)->sm_lock, flags);
+                spin_lock(&to_mdev(dev)->sm_lock);
                 memcpy(((struct ib_smp *) mad)->data, dev->node_desc, 64);
-                spin_unlock_irqrestore(&to_mdev(dev)->sm_lock, flags);
+                spin_unlock(&to_mdev(dev)->sm_lock);
         }
 }
 
@@ -354,7 +208,6 @@ static void forward_trap(struct mlx4_ib_dev *dev, u8 port_num, struct ib_mad *ma
         struct ib_mad_send_buf *send_buf;
         struct ib_mad_agent *agent = dev->send_agent[port_num - 1][qpn];
         int ret;
-        unsigned long flags;
 
         if (agent) {
                 send_buf = ib_create_send_mad(agent, qpn, 0, 0, IB_MGMT_MAD_HDR,
@@ -367,276 +220,19 @@ static void forward_trap(struct mlx4_ib_dev *dev, u8 port_num, struct ib_mad *ma
                  * wrong following the IB spec strictly, but we know
                  * it's OK for our devices).
                  */
-                spin_lock_irqsave(&dev->sm_lock, flags);
+                spin_lock(&dev->sm_lock);
                 memcpy(send_buf->mad, mad, sizeof *mad);
                 if ((send_buf->ah = dev->sm_ah[port_num - 1]))
                         ret = ib_post_send_mad(send_buf, NULL);
                 else
                         ret = -EINVAL;
-                spin_unlock_irqrestore(&dev->sm_lock, flags);
+                spin_unlock(&dev->sm_lock);
 
                 if (ret)
                         ib_free_send_mad(send_buf);
         }
 }
 
-static int mlx4_ib_demux_sa_handler(struct ib_device *ibdev, int port, int slave,
-                                                             struct ib_sa_mad *sa_mad)
-{
-        int ret = 0;
-
-        /* dispatch to different sa handlers */
-        switch (be16_to_cpu(sa_mad->mad_hdr.attr_id)) {
-        case IB_SA_ATTR_MC_MEMBER_REC:
-                ret = mlx4_ib_mcg_demux_handler(ibdev, port, slave, sa_mad);
-                break;
-        default:
-                break;
-        }
-        return ret;
-}
-
-int mlx4_ib_find_real_gid(struct ib_device *ibdev, u8 port, __be64 guid)
-{
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        int i;
-
-        for (i = 0; i < dev->dev->caps.sqp_demux; i++) {
-                if (dev->sriov.demux[port - 1].guid_cache[i] == guid)
-                        return i;
-        }
-        return -1;
-}
-
-
-static int find_slave_port_pkey_ix(struct mlx4_ib_dev *dev, int slave,
-                                   u8 port, u16 pkey, u16 *ix)
-{
-        int i, ret;
-        u8 unassigned_pkey_ix, pkey_ix, partial_ix = 0xFF;
-        u16 slot_pkey;
-
-        if (slave == mlx4_master_func_num(dev->dev))
-                return ib_find_cached_pkey(&dev->ib_dev, port, pkey, ix);
-
-        unassigned_pkey_ix = dev->dev->phys_caps.pkey_phys_table_len[port] - 1;
-
-        for (i = 0; i < dev->dev->caps.pkey_table_len[port]; i++) {
-                if (dev->pkeys.virt2phys_pkey[slave][port - 1][i] == unassigned_pkey_ix)
-                        continue;
-
-                pkey_ix = dev->pkeys.virt2phys_pkey[slave][port - 1][i];
-
-                ret = ib_get_cached_pkey(&dev->ib_dev, port, pkey_ix, &slot_pkey);
-                if (ret)
-                        continue;
-                if ((slot_pkey & 0x7FFF) == (pkey & 0x7FFF)) {
-                        if (slot_pkey & 0x8000) {
-                                *ix = (u16) pkey_ix;
-                                return 0;
-                        } else {
-                                /* take first partial pkey index found */
-                                if (partial_ix == 0xFF)
-                                        partial_ix = pkey_ix;
-                        }
-                }
-        }
-
-        if (partial_ix < 0xFF) {
-                *ix = (u16) partial_ix;
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
-int mlx4_ib_send_to_slave(struct mlx4_ib_dev *dev, int slave, u8 port,
-                          enum ib_qp_type dest_qpt, struct ib_wc *wc,
-                          struct ib_grh *grh, struct ib_mad *mad)
-{
-        struct ib_sge list;
-        struct ib_send_wr wr, *bad_wr;
-        struct mlx4_ib_demux_pv_ctx *tun_ctx;
-        struct mlx4_ib_demux_pv_qp *tun_qp;
-        struct mlx4_rcv_tunnel_mad *tun_mad;
-        struct ib_ah_attr attr;
-        struct ib_ah *ah;
-        struct ib_qp *src_qp = NULL;
-        unsigned tun_tx_ix = 0;
-        int dqpn;
-        int ret = 0;
-        u16 tun_pkey_ix;
-        u16 cached_pkey;
-
-        if (dest_qpt > IB_QPT_GSI)
-                return -EINVAL;
-
-        tun_ctx = dev->sriov.demux[port-1].tun[slave];
-
-        /* check if proxy qp created */
-        if (!tun_ctx || tun_ctx->state != DEMUX_PV_STATE_ACTIVE)
-                return -EAGAIN;
-
-        /* QP0 forwarding only for Dom0 */
-        if (!dest_qpt && (mlx4_master_func_num(dev->dev) != slave))
-                return -EINVAL;
-
-        if (!dest_qpt)
-                tun_qp = &tun_ctx->qp[0];
-        else
-                tun_qp = &tun_ctx->qp[1];
-
-        /* compute P_Key index to put in tunnel header for slave */
-        if (dest_qpt) {
-                u16 pkey_ix;
-                ret = ib_get_cached_pkey(&dev->ib_dev, port, wc->pkey_index, &cached_pkey);
-                if (ret)
-                        return -EINVAL;
-
-                ret = find_slave_port_pkey_ix(dev, slave, port, cached_pkey, &pkey_ix);
-                if (ret)
-                        return -EINVAL;
-                tun_pkey_ix = pkey_ix;
-        } else
-                tun_pkey_ix = dev->pkeys.virt2phys_pkey[slave][port - 1][0];
-
-        dqpn = dev->dev->phys_caps.base_proxy_sqpn + 8 * slave + port + (dest_qpt * 2) - 1;
-
-        /* get tunnel tx data buf for slave */
-        src_qp = tun_qp->qp;
-
-        /* create ah. Just need an empty one with the port num for the post send.
-         * The driver will set the force loopback bit in post_send */
-        memset(&attr, 0, sizeof attr);
-        attr.port_num = port;
-        ah = ib_create_ah(tun_ctx->pd, &attr);
-        if (IS_ERR(ah))
-                return -ENOMEM;
-
-        /* allocate tunnel tx buf after pass failure returns */
-        spin_lock(&tun_qp->tx_lock);
-        if (tun_qp->tx_ix_head - tun_qp->tx_ix_tail >=
-            (MLX4_NUM_TUNNEL_BUFS - 1))
-                ret = -EAGAIN;
-        else
-                tun_tx_ix = (++tun_qp->tx_ix_head) & (MLX4_NUM_TUNNEL_BUFS - 1);
-        spin_unlock(&tun_qp->tx_lock);
-        if (ret)
-                goto out;
-
-        tun_mad = (struct mlx4_rcv_tunnel_mad *) (tun_qp->tx_ring[tun_tx_ix].buf.addr);
-        if (tun_qp->tx_ring[tun_tx_ix].ah)
-                ib_destroy_ah(tun_qp->tx_ring[tun_tx_ix].ah);
-        tun_qp->tx_ring[tun_tx_ix].ah = ah;
-        ib_dma_sync_single_for_cpu(&dev->ib_dev,
-                                   tun_qp->tx_ring[tun_tx_ix].buf.map,
-                                   sizeof (struct mlx4_rcv_tunnel_mad),
-                                   DMA_TO_DEVICE);
-
-        /* copy over to tunnel buffer */
-        if (grh)
-                memcpy(&tun_mad->grh, grh, sizeof *grh);
-        memcpy(&tun_mad->mad, mad, sizeof *mad);
-
-        /* adjust tunnel data */
-        tun_mad->hdr.pkey_index = cpu_to_be16(tun_pkey_ix);
-        tun_mad->hdr.sl_vid = cpu_to_be16(((u16)(wc->sl)) << 12);
-        tun_mad->hdr.slid_mac_47_32 = cpu_to_be16(wc->slid);
-        tun_mad->hdr.flags_src_qp = cpu_to_be32(wc->src_qp & 0xFFFFFF);
-        tun_mad->hdr.g_ml_path = (grh && (wc->wc_flags & IB_WC_GRH)) ? 0x80 : 0;
-
-        ib_dma_sync_single_for_device(&dev->ib_dev,
-                                      tun_qp->tx_ring[tun_tx_ix].buf.map,
-                                      sizeof (struct mlx4_rcv_tunnel_mad),
-                                      DMA_TO_DEVICE);
-
-        list.addr = tun_qp->tx_ring[tun_tx_ix].buf.map;
-        list.length = sizeof (struct mlx4_rcv_tunnel_mad);
-        list.lkey = tun_ctx->mr->lkey;
-
-        wr.wr.ud.ah = ah;
-        wr.wr.ud.port_num = port;
-        wr.wr.ud.remote_qkey = IB_QP_SET_QKEY;
-        wr.wr.ud.remote_qpn = dqpn;
-        wr.next = NULL;
-        wr.wr_id = ((u64) tun_tx_ix) | MLX4_TUN_SET_WRID_QPN(dest_qpt);
-        wr.sg_list = &list;
-        wr.num_sge = 1;
-        wr.opcode = IB_WR_SEND;
-        wr.send_flags = IB_SEND_SIGNALED;
-
-        ret = ib_post_send(src_qp, &wr, &bad_wr);
-out:
-        if (ret)
-                ib_destroy_ah(ah);
-        return ret;
-}
-
-static int mlx4_ib_demux_mad(struct ib_device *ibdev, u8 port,
-                        struct ib_wc *wc, struct ib_grh *grh,
-                        struct ib_mad *mad)
-{
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        int err;
-        int slave;
-        u8 *slave_id;
-
-        /* Initially assume that this mad is for us */
-        slave = mlx4_master_func_num(dev->dev);
-
-        /* See if the slave id is encoded in a response mad */
-        if (mad->mad_hdr.method & 0x80) {
-                slave_id = (u8 *) &mad->mad_hdr.tid;
-                slave = *slave_id;
-                if (slave != 255) /*255 indicates the dom0*/
-                        *slave_id = 0; /* remap tid */
-        }
-
-        /* If a grh is present, we demux according to it */
-        if (wc->wc_flags & IB_WC_GRH) {
-                slave = mlx4_ib_find_real_gid(ibdev, port, grh->dgid.global.interface_id);
-                if (slave < 0) {
-                        mlx4_ib_warn(ibdev, "failed matching grh\n");
-                        return -ENOENT;
-                }
-        }
-        /* Class-specific handling */
-        switch (mad->mad_hdr.mgmt_class) {
-        case IB_MGMT_CLASS_SUBN_ADM:
-                if (mlx4_ib_demux_sa_handler(ibdev, port, slave,
-                                             (struct ib_sa_mad *) mad))
-                        return 0;
-                break;
-        case IB_MGMT_CLASS_CM:
-                if (mlx4_ib_demux_cm_handler(ibdev, port, &slave, mad))
-                        return 0;
-                break;
-        case IB_MGMT_CLASS_DEVICE_MGMT:
-                if (mad->mad_hdr.method != IB_MGMT_METHOD_GET_RESP)
-                        return 0;
-                break;
-        default:
-                /* Drop unsupported classes for slaves in tunnel mode */
-                if (slave != mlx4_master_func_num(dev->dev)) {
-                        pr_debug("dropping unsupported ingress mad from class:%d "
-                                 "for slave:%d\n", mad->mad_hdr.mgmt_class, slave);
-                        return 0;
-                }
-        }
-        /*make sure that no slave==255 was not handled yet.*/
-        if (slave >= dev->dev->caps.sqp_demux) {
-                mlx4_ib_warn(ibdev, "slave id: %d is bigger than allowed:%d\n",
-                             slave, dev->dev->caps.sqp_demux);
-                return -ENOENT;
-        }
-
-        err = mlx4_ib_send_to_slave(dev, slave, port, wc->qp->qp_type, wc, grh, mad);
-        if (err)
-                pr_debug("failed sending to slave %d via tunnel qp (%d)\n",
-                         slave, err);
-        return 0;
-}
-
 static int ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
                         struct ib_wc *in_wc, struct ib_grh *in_grh,
                         struct ib_mad *in_mad, struct ib_mad *out_mad)
@@ -645,25 +241,6 @@ static int ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
         int err;
         struct ib_port_attr pattr;
 
-        if (in_wc && in_wc->qp->qp_num) {
-                pr_debug("received MAD: slid:%d sqpn:%d "
-                        "dlid_bits:%d dqpn:%d wc_flags:0x%x, cls %x, mtd %x, atr %x\n",
-                        in_wc->slid, in_wc->src_qp,
-                        in_wc->dlid_path_bits,
-                        in_wc->qp->qp_num,
-                        in_wc->wc_flags,
-                        in_mad->mad_hdr.mgmt_class, in_mad->mad_hdr.method,
-                        be16_to_cpu(in_mad->mad_hdr.attr_id));
-                if (in_wc->wc_flags & IB_WC_GRH) {
-                        pr_debug("sgid_hi:0x%016llx sgid_lo:0x%016llx\n",
-                                 be64_to_cpu(in_grh->sgid.global.subnet_prefix),
-                                 be64_to_cpu(in_grh->sgid.global.interface_id));
-                        pr_debug("dgid_hi:0x%016llx dgid_lo:0x%016llx\n",
-                                 be64_to_cpu(in_grh->dgid.global.subnet_prefix),
-                                 be64_to_cpu(in_grh->dgid.global.interface_id));
-                }
-        }
-
         slid = in_wc ? in_wc->slid : be16_to_cpu(IB_LID_PERMISSIVE);
 
         if (in_mad->mad_hdr.method == IB_MGMT_METHOD_TRAP && slid == 0) {
@@ -679,9 +256,12 @@ static int ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
                         return IB_MAD_RESULT_SUCCESS;
 
                 /*
-                 * Don't process SMInfo queries -- the SMA can't handle them.
+                 * Don't process SMInfo queries or vendor-specific
+                 * MADs -- the SMA can't handle them.
                  */
-                if (in_mad->mad_hdr.attr_id == IB_SMP_ATTR_SM_INFO)
+                if (in_mad->mad_hdr.attr_id == IB_SMP_ATTR_SM_INFO ||
+                    ((in_mad->mad_hdr.attr_id & IB_SMP_ATTR_VENDOR_MASK) ==
+                     IB_SMP_ATTR_VENDOR_MASK))
                         return IB_MAD_RESULT_SUCCESS;
         } else if (in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_PERF_MGMT ||
                    in_mad->mad_hdr.mgmt_class == MLX4_IB_VENDOR_CLASS1   ||
@@ -701,19 +281,15 @@ static int ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
                 prev_lid = pattr.lid;
 
         err = mlx4_MAD_IFC(to_mdev(ibdev),
-                           (mad_flags & IB_MAD_IGNORE_MKEY ? MLX4_MAD_IFC_IGNORE_MKEY : 0) |
-                           (mad_flags & IB_MAD_IGNORE_BKEY ? MLX4_MAD_IFC_IGNORE_BKEY : 0) |
-                           MLX4_MAD_IFC_NET_VIEW,
+                           mad_flags & IB_MAD_IGNORE_MKEY,
+                           mad_flags & IB_MAD_IGNORE_BKEY,
                            port_num, in_wc, in_grh, in_mad, out_mad);
         if (err)
                 return IB_MAD_RESULT_FAILURE;
 
         if (!out_mad->mad_hdr.status) {
-                if (!(to_mdev(ibdev)->dev->caps.flags & MLX4_DEV_CAP_FLAG_PORT_MNG_CHG_EV))
-                        smp_snoop(ibdev, port_num, in_mad, prev_lid);
-                /* slaves get node desc from FW */
-                if (!mlx4_is_slave(to_mdev(ibdev)->dev))
-                        node_desc_override(ibdev, out_mad);
+                smp_snoop(ibdev, port_num, in_mad, prev_lid);
+                node_desc_override(ibdev, out_mad);
         }
 
         /* set return bit in status of directed route responses */
@@ -754,8 +330,7 @@ static int iboe_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
                 return IB_MAD_RESULT_FAILURE;
 
         err = mlx4_cmd_box(dev->dev, 0, mailbox->dma, inmod, 0,
-                           MLX4_CMD_QUERY_IF_STAT, MLX4_CMD_TIME_CLASS_C,
-                           MLX4_CMD_WRAPPED);
+                           MLX4_CMD_QUERY_IF_STAT, MLX4_CMD_TIME_CLASS_C);
         if (err)
                 err = IB_MAD_RESULT_FAILURE;
         else {
@@ -796,8 +371,6 @@ int mlx4_ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
 static void send_handler(struct ib_mad_agent *agent,
                          struct ib_mad_send_wc *mad_send_wc)
 {
-        if (mad_send_wc->send_buf->context[0])
-                ib_destroy_ah(mad_send_wc->send_buf->context[0]);
         ib_free_send_mad(mad_send_wc->send_buf);
 }
 
@@ -855,1194 +428,3 @@ void mlx4_ib_mad_cleanup(struct mlx4_ib_dev *dev)
                         ib_destroy_ah(dev->sm_ah[p]);
         }
 }
-
-static void handle_lid_change_event(struct mlx4_ib_dev *dev, u8 port_num)
-{
-        mlx4_ib_dispatch_event(dev, port_num, IB_EVENT_LID_CHANGE);
-
-        if (mlx4_is_master(dev->dev) && !dev->sriov.is_going_down)
-                mlx4_gen_slaves_port_mgt_ev(dev->dev, port_num,
-                                            MLX4_EQ_PORT_INFO_LID_CHANGE_MASK);
-}
-
-static void handle_client_rereg_event(struct mlx4_ib_dev *dev, u8 port_num)
-{
-        /* re-configure the alias-guid and mcg's */
-        if (mlx4_is_master(dev->dev)) {
-                mlx4_ib_invalidate_all_guid_record(dev, port_num);
-
-                if (!dev->sriov.is_going_down) {
-                        mlx4_ib_mcg_port_cleanup(&dev->sriov.demux[port_num - 1], 0);
-                        mlx4_gen_slaves_port_mgt_ev(dev->dev, port_num,
-                                                    MLX4_EQ_PORT_INFO_CLIENT_REREG_MASK);
-                }
-        }
-        mlx4_ib_dispatch_event(dev, port_num, IB_EVENT_CLIENT_REREGISTER);
-}
-
-static void propagate_pkey_ev(struct mlx4_ib_dev *dev, int port_num,
-                              struct mlx4_eqe *eqe)
-{
-        __propagate_pkey_ev(dev, port_num, GET_BLK_PTR_FROM_EQE(eqe),
-                            GET_MASK_FROM_EQE(eqe));
-}
-
-static void handle_slaves_guid_change(struct mlx4_ib_dev *dev, u8 port_num,
-                                      u32 guid_tbl_blk_num, u32 change_bitmap)
-{
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad  = NULL;
-        u16 i;
-
-        if (!mlx4_is_mfunc(dev->dev) || !mlx4_is_master(dev->dev))
-                return;
-
-        in_mad  = kmalloc(sizeof *in_mad, GFP_KERNEL);
-        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
-        if (!in_mad || !out_mad) {
-                mlx4_ib_warn(&dev->ib_dev, "failed to allocate memory for guid info mads\n");
-                goto out;
-        }
-
-        guid_tbl_blk_num  *= 4;
-
-        for (i = 0; i < 4; i++) {
-                if (change_bitmap && (!((change_bitmap >> (8 * i)) & 0xff)))
-                        continue;
-                memset(in_mad, 0, sizeof *in_mad);
-                memset(out_mad, 0, sizeof *out_mad);
-
-                in_mad->base_version  = 1;
-                in_mad->mgmt_class    = IB_MGMT_CLASS_SUBN_LID_ROUTED;
-                in_mad->class_version = 1;
-                in_mad->method        = IB_MGMT_METHOD_GET;
-                in_mad->attr_id       = IB_SMP_ATTR_GUID_INFO;
-                in_mad->attr_mod      = cpu_to_be32(guid_tbl_blk_num + i);
-
-                if (mlx4_MAD_IFC(dev,
-                                 MLX4_MAD_IFC_IGNORE_KEYS | MLX4_MAD_IFC_NET_VIEW,
-                                 port_num, NULL, NULL, in_mad, out_mad)) {
-                        mlx4_ib_warn(&dev->ib_dev, "Failed in get GUID INFO MAD_IFC\n");
-                        goto out;
-                }
-
-                mlx4_ib_update_cache_on_guid_change(dev, guid_tbl_blk_num + i,
-                                                    port_num,
-                                                    (u8 *)(&((struct ib_smp *)out_mad)->data));
-                mlx4_ib_notify_slaves_on_guid_change(dev, guid_tbl_blk_num + i,
-                                                     port_num,
-                                                     (u8 *)(&((struct ib_smp *)out_mad)->data));
-        }
-
-out:
-        kfree(in_mad);
-        kfree(out_mad);
-        return;
-}
-
-void handle_port_mgmt_change_event(struct work_struct *work)
-{
-        struct ib_event_work *ew = container_of(work, struct ib_event_work, work);
-        struct mlx4_ib_dev *dev = ew->ib_dev;
-        struct mlx4_eqe *eqe = &(ew->ib_eqe);
-        u8 port = eqe->event.port_mgmt_change.port;
-        u32 changed_attr;
-        u32 tbl_block;
-        u32 change_bitmap;
-
-        switch (eqe->subtype) {
-        case MLX4_DEV_PMC_SUBTYPE_PORT_INFO:
-                changed_attr = be32_to_cpu(eqe->event.port_mgmt_change.params.port_info.changed_attr);
-
-                /* Update the SM ah - This should be done before handling
-                   the other changed attributes so that MADs can be sent to the SM */
-                if (changed_attr & MSTR_SM_CHANGE_MASK) {
-                        u16 lid = be16_to_cpu(eqe->event.port_mgmt_change.params.port_info.mstr_sm_lid);
-                        u8 sl = eqe->event.port_mgmt_change.params.port_info.mstr_sm_sl & 0xf;
-                        update_sm_ah(dev, port, lid, sl);
-                }
-
-                /* Check if it is a lid change event */
-                if (changed_attr & MLX4_EQ_PORT_INFO_LID_CHANGE_MASK)
-                        handle_lid_change_event(dev, port);
-
-                /* Generate GUID changed event */
-                if (changed_attr & MLX4_EQ_PORT_INFO_GID_PFX_CHANGE_MASK) {
-                        mlx4_ib_dispatch_event(dev, port, IB_EVENT_GID_CHANGE);
-                        /*if master, notify all slaves*/
-                        if (mlx4_is_master(dev->dev))
-                                mlx4_gen_slaves_port_mgt_ev(dev->dev, port,
-                                                            MLX4_EQ_PORT_INFO_GID_PFX_CHANGE_MASK);
-                }
-
-                if (changed_attr & MLX4_EQ_PORT_INFO_CLIENT_REREG_MASK)
-                        handle_client_rereg_event(dev, port);
-                break;
-
-        case MLX4_DEV_PMC_SUBTYPE_PKEY_TABLE:
-                mlx4_ib_dispatch_event(dev, port, IB_EVENT_PKEY_CHANGE);
-                if (mlx4_is_master(dev->dev) && !dev->sriov.is_going_down)
-                        propagate_pkey_ev(dev, port, eqe);
-                break;
-        case MLX4_DEV_PMC_SUBTYPE_GUID_INFO:
-                /* paravirtualized master's guid is guid 0 -- does not change */
-                if (!mlx4_is_master(dev->dev))
-                        mlx4_ib_dispatch_event(dev, port, IB_EVENT_GID_CHANGE);
-                /*if master, notify relevant slaves*/
-                else if (!dev->sriov.is_going_down) {
-                        tbl_block = GET_BLK_PTR_FROM_EQE(eqe);
-                        change_bitmap = GET_MASK_FROM_EQE(eqe);
-                        handle_slaves_guid_change(dev, port, tbl_block, change_bitmap);
-                }
-                break;
-        default:
-                pr_warn("Unsupported subtype 0x%x for "
-                        "Port Management Change event\n", eqe->subtype);
-        }
-
-        kfree(ew);
-}
-
-void mlx4_ib_dispatch_event(struct mlx4_ib_dev *dev, u8 port_num,
-                            enum ib_event_type type)
-{
-        struct ib_event event;
-
-        event.device            = &dev->ib_dev;
-        event.element.port_num  = port_num;
-        event.event             = type;
-
-        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_multiplex_sa_handler(struct ib_device *ibdev, int port,
-                int slave, struct ib_sa_mad *sa_mad)
-{
-        int ret = 0;
-
-        /* dispatch to different sa handlers */
-        switch (be16_to_cpu(sa_mad->mad_hdr.attr_id)) {
-        case IB_SA_ATTR_MC_MEMBER_REC:
-                ret = mlx4_ib_mcg_multiplex_handler(ibdev, port, slave, sa_mad);
-                break;
-        default:
-                break;
-        }
-        return ret;
-}
-
-static int is_proxy_qp0(struct mlx4_ib_dev *dev, int qpn, int slave)
-{
-        int proxy_start = dev->dev->phys_caps.base_proxy_sqpn + 8 * slave;
-
-        return (qpn >= proxy_start && qpn <= proxy_start + 1);
-}
-
-
-int mlx4_ib_send_to_wire(struct mlx4_ib_dev *dev, int slave, u8 port,
-                         enum ib_qp_type dest_qpt, u16 pkey_index, u32 remote_qpn,
-                         u32 qkey, struct ib_ah_attr *attr, struct ib_mad *mad)
-{
-        struct ib_sge list;
-        struct ib_send_wr wr, *bad_wr;
-        struct mlx4_ib_demux_pv_ctx *sqp_ctx;
-        struct mlx4_ib_demux_pv_qp *sqp;
-        struct mlx4_mad_snd_buf *sqp_mad;
-        struct ib_ah *ah;
-        struct ib_qp *send_qp = NULL;
-        unsigned wire_tx_ix = 0;
-        int ret = 0;
-        u16 wire_pkey_ix;
-        int src_qpnum;
-        u8 sgid_index;
-
-
-        sqp_ctx = dev->sriov.sqps[port-1];
-
-        /* check if proxy qp created */
-        if (!sqp_ctx || sqp_ctx->state != DEMUX_PV_STATE_ACTIVE)
-                return -EAGAIN;
-
-        /* QP0 forwarding only for Dom0 */
-        if (dest_qpt == IB_QPT_SMI && (mlx4_master_func_num(dev->dev) != slave))
-                return -EINVAL;
-
-        if (dest_qpt == IB_QPT_SMI) {
-                src_qpnum = 0;
-                sqp = &sqp_ctx->qp[0];
-                wire_pkey_ix = dev->pkeys.virt2phys_pkey[slave][port - 1][0];
-        } else {
-                src_qpnum = 1;
-                sqp = &sqp_ctx->qp[1];
-                wire_pkey_ix = dev->pkeys.virt2phys_pkey[slave][port - 1][pkey_index];
-        }
-
-        send_qp = sqp->qp;
-
-        /* create ah */
-        sgid_index = attr->grh.sgid_index;
-        attr->grh.sgid_index = 0;
-        ah = ib_create_ah(sqp_ctx->pd, attr);
-        if (IS_ERR(ah))
-                return -ENOMEM;
-        attr->grh.sgid_index = sgid_index;
-        to_mah(ah)->av.ib.gid_index = sgid_index;
-        /* get rid of force-loopback bit */
-        to_mah(ah)->av.ib.port_pd &= cpu_to_be32(0x7FFFFFFF);
-        spin_lock(&sqp->tx_lock);
-        if (sqp->tx_ix_head - sqp->tx_ix_tail >=
-            (MLX4_NUM_TUNNEL_BUFS - 1))
-                ret = -EAGAIN;
-        else
-                wire_tx_ix = (++sqp->tx_ix_head) & (MLX4_NUM_TUNNEL_BUFS - 1);
-        spin_unlock(&sqp->tx_lock);
-        if (ret)
-                goto out;
-
-        sqp_mad = (struct mlx4_mad_snd_buf *) (sqp->tx_ring[wire_tx_ix].buf.addr);
-        if (sqp->tx_ring[wire_tx_ix].ah)
-                ib_destroy_ah(sqp->tx_ring[wire_tx_ix].ah);
-        sqp->tx_ring[wire_tx_ix].ah = ah;
-        ib_dma_sync_single_for_cpu(&dev->ib_dev,
-                                   sqp->tx_ring[wire_tx_ix].buf.map,
-                                   sizeof (struct mlx4_mad_snd_buf),
-                                   DMA_TO_DEVICE);
-
-        memcpy(&sqp_mad->payload, mad, sizeof *mad);
-
-        ib_dma_sync_single_for_device(&dev->ib_dev,
-                                      sqp->tx_ring[wire_tx_ix].buf.map,
-                                      sizeof (struct mlx4_mad_snd_buf),
-                                      DMA_TO_DEVICE);
-
-        list.addr = sqp->tx_ring[wire_tx_ix].buf.map;
-        list.length = sizeof (struct mlx4_mad_snd_buf);
-        list.lkey = sqp_ctx->mr->lkey;
-
-        wr.wr.ud.ah = ah;
-        wr.wr.ud.port_num = port;
-        wr.wr.ud.pkey_index = wire_pkey_ix;
-        wr.wr.ud.remote_qkey = qkey;
-        wr.wr.ud.remote_qpn = remote_qpn;
-        wr.next = NULL;
-        wr.wr_id = ((u64) wire_tx_ix) | MLX4_TUN_SET_WRID_QPN(src_qpnum);
-        wr.sg_list = &list;
-        wr.num_sge = 1;
-        wr.opcode = IB_WR_SEND;
-        wr.send_flags = IB_SEND_SIGNALED;
-
-        ret = ib_post_send(send_qp, &wr, &bad_wr);
-out:
-        if (ret)
-                ib_destroy_ah(ah);
-        return ret;
-}
-
-static void mlx4_ib_multiplex_mad(struct mlx4_ib_demux_pv_ctx *ctx, struct ib_wc *wc)
-{
-        struct mlx4_ib_dev *dev = to_mdev(ctx->ib_dev);
-        struct mlx4_ib_demux_pv_qp *tun_qp = &ctx->qp[MLX4_TUN_WRID_QPN(wc->wr_id)];
-        int wr_ix = wc->wr_id & (MLX4_NUM_TUNNEL_BUFS - 1);
-        struct mlx4_tunnel_mad *tunnel = tun_qp->ring[wr_ix].addr;
-        struct mlx4_ib_ah ah;
-        struct ib_ah_attr ah_attr;
-        u8 *slave_id;
-        int slave;
-
-        /* Get slave that sent this packet */
-        if (wc->src_qp < dev->dev->phys_caps.base_proxy_sqpn ||
-            wc->src_qp >= dev->dev->phys_caps.base_proxy_sqpn + 8 * MLX4_MFUNC_MAX ||
-            (wc->src_qp & 0x1) != ctx->port - 1 ||
-            wc->src_qp & 0x4) {
-                mlx4_ib_warn(ctx->ib_dev, "can't multiplex bad sqp:%d\n", wc->src_qp);
-                return;
-        }
-        slave = ((wc->src_qp & ~0x7) - dev->dev->phys_caps.base_proxy_sqpn) / 8;
-        if (slave != ctx->slave) {
-                mlx4_ib_warn(ctx->ib_dev, "can't multiplex bad sqp:%d: "
-                             "belongs to another slave\n", wc->src_qp);
-                return;
-        }
-        if (slave != mlx4_master_func_num(dev->dev) && !(wc->src_qp & 0x2)) {
-                mlx4_ib_warn(ctx->ib_dev, "can't multiplex bad sqp:%d: "
-                             "non-master trying to send QP0 packets\n", wc->src_qp);
-                return;
-        }
-
-        /* Map transaction ID */
-        ib_dma_sync_single_for_cpu(ctx->ib_dev, tun_qp->ring[wr_ix].map,
-                                   sizeof (struct mlx4_tunnel_mad),
-                                   DMA_FROM_DEVICE);
-        switch (tunnel->mad.mad_hdr.method) {
-        case IB_MGMT_METHOD_SET:
-        case IB_MGMT_METHOD_GET:
-        case IB_MGMT_METHOD_REPORT:
-        case IB_SA_METHOD_GET_TABLE:
-        case IB_SA_METHOD_DELETE:
-        case IB_SA_METHOD_GET_MULTI:
-        case IB_SA_METHOD_GET_TRACE_TBL:
-                slave_id = (u8 *) &tunnel->mad.mad_hdr.tid;
-                if (*slave_id) {
-                        mlx4_ib_warn(ctx->ib_dev, "egress mad has non-null tid msb:%d "
-                                     "class:%d slave:%d\n", *slave_id,
-                                     tunnel->mad.mad_hdr.mgmt_class, slave);
-                        return;
-                } else
-                        *slave_id = slave;
-        default:
-                /* nothing */;
-        }
-
-        /* Class-specific handling */
-        switch (tunnel->mad.mad_hdr.mgmt_class) {
-        case IB_MGMT_CLASS_SUBN_ADM:
-                if (mlx4_ib_multiplex_sa_handler(ctx->ib_dev, ctx->port, slave,
-                              (struct ib_sa_mad *) &tunnel->mad))
-                        return;
-                break;
-        case IB_MGMT_CLASS_CM:
-                if (mlx4_ib_multiplex_cm_handler(ctx->ib_dev, ctx->port, slave,
-                              (struct ib_mad *) &tunnel->mad))
-                        return;
-                break;
-        case IB_MGMT_CLASS_DEVICE_MGMT:
-                if (tunnel->mad.mad_hdr.method != IB_MGMT_METHOD_GET &&
-                    tunnel->mad.mad_hdr.method != IB_MGMT_METHOD_SET)
-                        return;
-                break;
-        default:
-                /* Drop unsupported classes for slaves in tunnel mode */
-                if (slave != mlx4_master_func_num(dev->dev)) {
-                        mlx4_ib_warn(ctx->ib_dev, "dropping unsupported egress mad from class:%d "
-                                     "for slave:%d\n", tunnel->mad.mad_hdr.mgmt_class, slave);
-                        return;
-                }
-        }
-
-        /* We are using standard ib_core services to send the mad, so generate a
-         * stadard address handle by decoding the tunnelled mlx4_ah fields */
-        memcpy(&ah.av, &tunnel->hdr.av, sizeof (struct mlx4_av));
-        ah.ibah.device = ctx->ib_dev;
-        mlx4_ib_query_ah(&ah.ibah, &ah_attr);
-        if ((ah_attr.ah_flags & IB_AH_GRH) &&
-            (ah_attr.grh.sgid_index != slave)) {
-                mlx4_ib_warn(ctx->ib_dev, "slave:%d accessed invalid sgid_index:%d\n",
-                             slave, ah_attr.grh.sgid_index);
-                return;
-        }
-
-        mlx4_ib_send_to_wire(dev, slave, ctx->port,
-                             is_proxy_qp0(dev, wc->src_qp, slave) ?
-                             IB_QPT_SMI : IB_QPT_GSI,
-                             be16_to_cpu(tunnel->hdr.pkey_index),
-                             be32_to_cpu(tunnel->hdr.remote_qpn),
-                             be32_to_cpu(tunnel->hdr.qkey),
-                             &ah_attr, &tunnel->mad);
-}
-
-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)
-                        ib_destroy_ah(tun_qp->tx_ring[i].ah);
-        }
-        kfree(tun_qp->tx_ring);
-        kfree(tun_qp->ring);
-}
-
-static void mlx4_ib_tunnel_comp_worker(struct work_struct *work)
-{
-        struct mlx4_ib_demux_pv_ctx *ctx;
-        struct mlx4_ib_demux_pv_qp *tun_qp;
-        struct ib_wc wc;
-        int ret;
-        ctx = container_of(work, struct mlx4_ib_demux_pv_ctx, work);
-        ib_req_notify_cq(ctx->cq, IB_CQ_NEXT_COMP);
-
-        while (ib_poll_cq(ctx->cq, 1, &wc) == 1) {
-                tun_qp = &ctx->qp[MLX4_TUN_WRID_QPN(wc.wr_id)];
-                if (wc.status == IB_WC_SUCCESS) {
-                        switch (wc.opcode) {
-                        case IB_WC_RECV:
-                                mlx4_ib_multiplex_mad(ctx, &wc);
-                                ret = mlx4_ib_post_pv_qp_buf(ctx, tun_qp,
-                                                             wc.wr_id &
-                                                             (MLX4_NUM_TUNNEL_BUFS - 1));
-                                if (ret)
-                                        pr_err("Failed reposting tunnel "
-                                               "buf:%lld\n", wc.wr_id);
-                                break;
-                        case IB_WC_SEND:
-                                pr_debug("received tunnel send completion:"
-                                         "wrid=0x%llx, status=0x%x\n",
-                                         wc.wr_id, wc.status);
-                                ib_destroy_ah(tun_qp->tx_ring[wc.wr_id &
-                                              (MLX4_NUM_TUNNEL_BUFS - 1)].ah);
-                                tun_qp->tx_ring[wc.wr_id & (MLX4_NUM_TUNNEL_BUFS - 1)].ah
-                                        = NULL;
-                                spin_lock(&tun_qp->tx_lock);
-                                tun_qp->tx_ix_tail++;
-                                spin_unlock(&tun_qp->tx_lock);
-
-                                break;
-                        default:
-                                break;
-                        }
-                } else  {
-                        pr_debug("mlx4_ib: completion error in tunnel: %d."
-                                 " status = %d, wrid = 0x%llx\n",
-                                 ctx->slave, wc.status, wc.wr_id);
-                        if (!MLX4_TUN_IS_RECV(wc.wr_id)) {
-                                ib_destroy_ah(tun_qp->tx_ring[wc.wr_id &
-                                              (MLX4_NUM_TUNNEL_BUFS - 1)].ah);
-                                tun_qp->tx_ring[wc.wr_id & (MLX4_NUM_TUNNEL_BUFS - 1)].ah
-                                        = NULL;
-                                spin_lock(&tun_qp->tx_lock);
-                                tun_qp->tx_ix_tail++;
-                                spin_unlock(&tun_qp->tx_lock);
-                        }
-                }
-        }
-}
-
-static void pv_qp_event_handler(struct ib_event *event, void *qp_context)
-{
-        struct mlx4_ib_demux_pv_ctx *sqp = qp_context;
-
-        /* It's worse than that! He's dead, Jim! */
-        pr_err("Fatal error (%d) on a MAD QP on port %d\n",
-               event->event, sqp->port);
-}
-
-static int create_pv_sqp(struct mlx4_ib_demux_pv_ctx *ctx,
-                            enum ib_qp_type qp_type, int create_tun)
-{
-        int i, ret;
-        struct mlx4_ib_demux_pv_qp *tun_qp;
-        struct mlx4_ib_qp_tunnel_init_attr qp_init_attr;
-        struct ib_qp_attr attr;
-        int qp_attr_mask_INIT;
-
-        if (qp_type > IB_QPT_GSI)
-                return -EINVAL;
-
-        tun_qp = &ctx->qp[qp_type];
-
-        memset(&qp_init_attr, 0, sizeof qp_init_attr);
-        qp_init_attr.init_attr.send_cq = ctx->cq;
-        qp_init_attr.init_attr.recv_cq = ctx->cq;
-        qp_init_attr.init_attr.sq_sig_type = IB_SIGNAL_ALL_WR;
-        qp_init_attr.init_attr.cap.max_send_wr = MLX4_NUM_TUNNEL_BUFS;
-        qp_init_attr.init_attr.cap.max_recv_wr = MLX4_NUM_TUNNEL_BUFS;
-        qp_init_attr.init_attr.cap.max_send_sge = 1;
-        qp_init_attr.init_attr.cap.max_recv_sge = 1;
-        if (create_tun) {
-                qp_init_attr.init_attr.qp_type = IB_QPT_UD;
-                qp_init_attr.init_attr.create_flags = MLX4_IB_SRIOV_TUNNEL_QP;
-                qp_init_attr.port = ctx->port;
-                qp_init_attr.slave = ctx->slave;
-                qp_init_attr.proxy_qp_type = qp_type;
-                qp_attr_mask_INIT = IB_QP_STATE | IB_QP_PKEY_INDEX |
-                           IB_QP_QKEY | IB_QP_PORT;
-        } else {
-                qp_init_attr.init_attr.qp_type = qp_type;
-                qp_init_attr.init_attr.create_flags = MLX4_IB_SRIOV_SQP;
-                qp_attr_mask_INIT = IB_QP_STATE | IB_QP_PKEY_INDEX | IB_QP_QKEY;
-        }
-        qp_init_attr.init_attr.port_num = ctx->port;
-        qp_init_attr.init_attr.qp_context = ctx;
-        qp_init_attr.init_attr.event_handler = pv_qp_event_handler;
-        tun_qp->qp = ib_create_qp(ctx->pd, &qp_init_attr.init_attr);
-        if (IS_ERR(tun_qp->qp)) {
-                ret = PTR_ERR(tun_qp->qp);
-                tun_qp->qp = NULL;
-                pr_err("Couldn't create %s QP (%d)\n",
-                       create_tun ? "tunnel" : "special", ret);
-                return ret;
-        }
-
-        memset(&attr, 0, sizeof attr);
-        attr.qp_state = IB_QPS_INIT;
-        attr.pkey_index =
-                to_mdev(ctx->ib_dev)->pkeys.virt2phys_pkey[ctx->slave][ctx->port - 1][0];
-        attr.qkey = IB_QP1_QKEY;
-        attr.port_num = ctx->port;
-        ret = ib_modify_qp(tun_qp->qp, &attr, qp_attr_mask_INIT);
-        if (ret) {
-                pr_err("Couldn't change %s qp state to INIT (%d)\n",
-                       create_tun ? "tunnel" : "special", ret);
-                goto err_qp;
-        }
-        attr.qp_state = IB_QPS_RTR;
-        ret = ib_modify_qp(tun_qp->qp, &attr, IB_QP_STATE);
-        if (ret) {
-                pr_err("Couldn't change %s qp state to RTR (%d)\n",
-                       create_tun ? "tunnel" : "special", ret);
-                goto err_qp;
-        }
-        attr.qp_state = IB_QPS_RTS;
-        attr.sq_psn = 0;
-        ret = ib_modify_qp(tun_qp->qp, &attr, IB_QP_STATE | IB_QP_SQ_PSN);
-        if (ret) {
-                pr_err("Couldn't change %s qp state to RTS (%d)\n",
-                       create_tun ? "tunnel" : "special", ret);
-                goto err_qp;
-        }
-
-        for (i = 0; i < MLX4_NUM_TUNNEL_BUFS; i++) {
-                ret = mlx4_ib_post_pv_qp_buf(ctx, tun_qp, i);
-                if (ret) {
-                        pr_err(" mlx4_ib_post_pv_buf error"
-                               " (err = %d, i = %d)\n", ret, i);
-                        goto err_qp;
-                }
-        }
-        return 0;
-
-err_qp:
-        ib_destroy_qp(tun_qp->qp);
-        tun_qp->qp = NULL;
-        return ret;
-}
-
-/*
- * IB MAD completion callback for real SQPs
- */
-static void mlx4_ib_sqp_comp_worker(struct work_struct *work)
-{
-        struct mlx4_ib_demux_pv_ctx *ctx;
-        struct mlx4_ib_demux_pv_qp *sqp;
-        struct ib_wc wc;
-        struct ib_grh *grh;
-        struct ib_mad *mad;
-
-        ctx = container_of(work, struct mlx4_ib_demux_pv_ctx, work);
-        ib_req_notify_cq(ctx->cq, IB_CQ_NEXT_COMP);
-
-        while (mlx4_ib_poll_cq(ctx->cq, 1, &wc) == 1) {
-                sqp = &ctx->qp[MLX4_TUN_WRID_QPN(wc.wr_id)];
-                if (wc.status == IB_WC_SUCCESS) {
-                        switch (wc.opcode) {
-                        case IB_WC_SEND:
-                                ib_destroy_ah(sqp->tx_ring[wc.wr_id &
-                                              (MLX4_NUM_TUNNEL_BUFS - 1)].ah);
-                                sqp->tx_ring[wc.wr_id & (MLX4_NUM_TUNNEL_BUFS - 1)].ah
-                                        = NULL;
-                                spin_lock(&sqp->tx_lock);
-                                sqp->tx_ix_tail++;
-                                spin_unlock(&sqp->tx_lock);
-                                break;
-                        case IB_WC_RECV:
-                                mad = (struct ib_mad *) &(((struct mlx4_mad_rcv_buf *)
-                                                (sqp->ring[wc.wr_id &
-                                                (MLX4_NUM_TUNNEL_BUFS - 1)].addr))->payload);
-                                grh = &(((struct mlx4_mad_rcv_buf *)
-                                                (sqp->ring[wc.wr_id &
-                                                (MLX4_NUM_TUNNEL_BUFS - 1)].addr))->grh);
-                                mlx4_ib_demux_mad(ctx->ib_dev, ctx->port, &wc, grh, mad);
-                                if (mlx4_ib_post_pv_qp_buf(ctx, sqp, wc.wr_id &
-                                                           (MLX4_NUM_TUNNEL_BUFS - 1)))
-                                        pr_err("Failed reposting SQP "
-                                               "buf:%lld\n", wc.wr_id);
-                                break;
-                        default:
-                                BUG_ON(1);
-                                break;
-                        }
-                } else  {
-                        pr_debug("mlx4_ib: completion error in tunnel: %d."
-                                 " status = %d, wrid = 0x%llx\n",
-                                 ctx->slave, wc.status, wc.wr_id);
-                        if (!MLX4_TUN_IS_RECV(wc.wr_id)) {
-                                ib_destroy_ah(sqp->tx_ring[wc.wr_id &
-                                              (MLX4_NUM_TUNNEL_BUFS - 1)].ah);
-                                sqp->tx_ring[wc.wr_id & (MLX4_NUM_TUNNEL_BUFS - 1)].ah
-                                        = NULL;
-                                spin_lock(&sqp->tx_lock);
-                                sqp->tx_ix_tail++;
-                                spin_unlock(&sqp->tx_lock);
-                        }
-                }
-        }
-}
-
-static int alloc_pv_object(struct mlx4_ib_dev *dev, int slave, int port,
-                               struct mlx4_ib_demux_pv_ctx **ret_ctx)
-{
-        struct mlx4_ib_demux_pv_ctx *ctx;
-
-        *ret_ctx = NULL;
-        ctx = kzalloc(sizeof (struct mlx4_ib_demux_pv_ctx), GFP_KERNEL);
-        if (!ctx) {
-                pr_err("failed allocating pv resource context "
-                       "for port %d, slave %d\n", port, slave);
-                return -ENOMEM;
-        }
-
-        ctx->ib_dev = &dev->ib_dev;
-        ctx->port = port;
-        ctx->slave = slave;
-        *ret_ctx = ctx;
-        return 0;
-}
-
-static void free_pv_object(struct mlx4_ib_dev *dev, int slave, int port)
-{
-        if (dev->sriov.demux[port - 1].tun[slave]) {
-                kfree(dev->sriov.demux[port - 1].tun[slave]);
-                dev->sriov.demux[port - 1].tun[slave] = NULL;
-        }
-}
-
-static int create_pv_resources(struct ib_device *ibdev, int slave, int port,
-                               int create_tun, struct mlx4_ib_demux_pv_ctx *ctx)
-{
-        int ret, cq_size;
-
-        if (ctx->state != DEMUX_PV_STATE_DOWN)
-                return -EEXIST;
-
-        ctx->state = DEMUX_PV_STATE_STARTING;
-        /* have QP0 only on port owner, and only if link layer is IB */
-        if (ctx->slave == mlx4_master_func_num(to_mdev(ctx->ib_dev)->dev) &&
-            rdma_port_get_link_layer(ibdev, ctx->port) == IB_LINK_LAYER_INFINIBAND)
-                ctx->has_smi = 1;
-
-        if (ctx->has_smi) {
-                ret = mlx4_ib_alloc_pv_bufs(ctx, IB_QPT_SMI, create_tun);
-                if (ret) {
-                        pr_err("Failed allocating qp0 tunnel bufs (%d)\n", ret);
-                        goto err_out;
-                }
-        }
-
-        ret = mlx4_ib_alloc_pv_bufs(ctx, IB_QPT_GSI, create_tun);
-        if (ret) {
-                pr_err("Failed allocating qp1 tunnel bufs (%d)\n", ret);
-                goto err_out_qp0;
-        }
-
-        cq_size = 2 * MLX4_NUM_TUNNEL_BUFS;
-        if (ctx->has_smi)
-                cq_size *= 2;
-
-        ctx->cq = ib_create_cq(ctx->ib_dev, mlx4_ib_tunnel_comp_handler,
-                               NULL, ctx, cq_size, 0);
-        if (IS_ERR(ctx->cq)) {
-                ret = PTR_ERR(ctx->cq);
-                pr_err("Couldn't create tunnel CQ (%d)\n", ret);
-                goto err_buf;
-        }
-
-        ctx->pd = ib_alloc_pd(ctx->ib_dev);
-        if (IS_ERR(ctx->pd)) {
-                ret = PTR_ERR(ctx->pd);
-                pr_err("Couldn't create tunnel PD (%d)\n", ret);
-                goto err_cq;
-        }
-
-        ctx->mr = ib_get_dma_mr(ctx->pd, IB_ACCESS_LOCAL_WRITE);
-        if (IS_ERR(ctx->mr)) {
-                ret = PTR_ERR(ctx->mr);
-                pr_err("Couldn't get tunnel DMA MR (%d)\n", ret);
-                goto err_pd;
-        }
-
-        if (ctx->has_smi) {
-                ret = create_pv_sqp(ctx, IB_QPT_SMI, create_tun);
-                if (ret) {
-                        pr_err("Couldn't create %s QP0 (%d)\n",
-                               create_tun ? "tunnel for" : "",  ret);
-                        goto err_mr;
-                }
-        }
-
-        ret = create_pv_sqp(ctx, IB_QPT_GSI, create_tun);
-        if (ret) {
-                pr_err("Couldn't create %s QP1 (%d)\n",
-                       create_tun ? "tunnel for" : "",  ret);
-                goto err_qp0;
-        }
-
-        if (create_tun)
-                INIT_WORK(&ctx->work, mlx4_ib_tunnel_comp_worker);
-        else
-                INIT_WORK(&ctx->work, mlx4_ib_sqp_comp_worker);
-
-        ctx->wq = to_mdev(ibdev)->sriov.demux[port - 1].wq;
-
-        ret = ib_req_notify_cq(ctx->cq, IB_CQ_NEXT_COMP);
-        if (ret) {
-                pr_err("Couldn't arm tunnel cq (%d)\n", ret);
-                goto err_wq;
-        }
-        ctx->state = DEMUX_PV_STATE_ACTIVE;
-        return 0;
-
-err_wq:
-        ctx->wq = NULL;
-        ib_destroy_qp(ctx->qp[1].qp);
-        ctx->qp[1].qp = NULL;
-
-
-err_qp0:
-        if (ctx->has_smi)
-                ib_destroy_qp(ctx->qp[0].qp);
-        ctx->qp[0].qp = NULL;
-
-err_mr:
-        ib_dereg_mr(ctx->mr);
-        ctx->mr = NULL;
-
-err_pd:
-        ib_dealloc_pd(ctx->pd);
-        ctx->pd = NULL;
-
-err_cq:
-        ib_destroy_cq(ctx->cq);
-        ctx->cq = NULL;
-
-err_buf:
-        mlx4_ib_free_pv_qp_bufs(ctx, IB_QPT_GSI, create_tun);
-
-err_out_qp0:
-        if (ctx->has_smi)
-                mlx4_ib_free_pv_qp_bufs(ctx, IB_QPT_SMI, create_tun);
-err_out:
-        ctx->state = DEMUX_PV_STATE_DOWN;
-        return ret;
-}
-
-static void destroy_pv_resources(struct mlx4_ib_dev *dev, int slave, int port,
-                                 struct mlx4_ib_demux_pv_ctx *ctx, int flush)
-{
-        if (!ctx)
-                return;
-        if (ctx->state > DEMUX_PV_STATE_DOWN) {
-                ctx->state = DEMUX_PV_STATE_DOWNING;
-                if (flush)
-                        flush_workqueue(ctx->wq);
-                if (ctx->has_smi) {
-                        ib_destroy_qp(ctx->qp[0].qp);
-                        ctx->qp[0].qp = NULL;
-                        mlx4_ib_free_pv_qp_bufs(ctx, IB_QPT_SMI, 1);
-                }
-                ib_destroy_qp(ctx->qp[1].qp);
-                ctx->qp[1].qp = NULL;
-                mlx4_ib_free_pv_qp_bufs(ctx, IB_QPT_GSI, 1);
-                ib_dereg_mr(ctx->mr);
-                ctx->mr = NULL;
-                ib_dealloc_pd(ctx->pd);
-                ctx->pd = NULL;
-                ib_destroy_cq(ctx->cq);
-                ctx->cq = NULL;
-                ctx->state = DEMUX_PV_STATE_DOWN;
-        }
-}
-
-static int mlx4_ib_tunnels_update(struct mlx4_ib_dev *dev, int slave,
-                                  int port, int do_init)
-{
-        int ret = 0;
-
-        if (!do_init) {
-                clean_vf_mcast(&dev->sriov.demux[port - 1], slave);
-                /* for master, destroy real sqp resources */
-                if (slave == mlx4_master_func_num(dev->dev))
-                        destroy_pv_resources(dev, slave, port,
-                                             dev->sriov.sqps[port - 1], 1);
-                /* destroy the tunnel qp resources */
-                destroy_pv_resources(dev, slave, port,
-                                     dev->sriov.demux[port - 1].tun[slave], 1);
-                return 0;
-        }
-
-        /* create the tunnel qp resources */
-        ret = create_pv_resources(&dev->ib_dev, slave, port, 1,
-                                  dev->sriov.demux[port - 1].tun[slave]);
-
-        /* for master, create the real sqp resources */
-        if (!ret && slave == mlx4_master_func_num(dev->dev))
-                ret = create_pv_resources(&dev->ib_dev, slave, port, 0,
-                                          dev->sriov.sqps[port - 1]);
-        return ret;
-}
-
-void mlx4_ib_tunnels_update_work(struct work_struct *work)
-{
-        struct mlx4_ib_demux_work *dmxw;
-
-        dmxw = container_of(work, struct mlx4_ib_demux_work, work);
-        mlx4_ib_tunnels_update(dmxw->dev, dmxw->slave, (int) dmxw->port,
-                               dmxw->do_init);
-        kfree(dmxw);
-        return;
-}
-
-static int mlx4_ib_alloc_demux_ctx(struct mlx4_ib_dev *dev,
-                                       struct mlx4_ib_demux_ctx *ctx,
-                                       int port)
-{
-        char name[12];
-        int ret = 0;
-        int i;
-
-        ctx->tun = kcalloc(dev->dev->caps.sqp_demux,
-                           sizeof (struct mlx4_ib_demux_pv_ctx *), GFP_KERNEL);
-        if (!ctx->tun)
-                return -ENOMEM;
-
-        ctx->dev = dev;
-        ctx->port = port;
-        ctx->ib_dev = &dev->ib_dev;
-
-        for (i = 0; i < dev->dev->caps.sqp_demux; i++) {
-                ret = alloc_pv_object(dev, i, port, &ctx->tun[i]);
-                if (ret) {
-                        ret = -ENOMEM;
-                        goto err_mcg;
-                }
-        }
-
-        ret = mlx4_ib_mcg_port_init(ctx);
-        if (ret) {
-                pr_err("Failed initializing mcg para-virt (%d)\n", ret);
-                goto err_mcg;
-        }
-
-        snprintf(name, sizeof name, "mlx4_ibt%d", port);
-        ctx->wq = create_singlethread_workqueue(name);
-        if (!ctx->wq) {
-                pr_err("Failed to create tunnelling WQ for port %d\n", port);
-                ret = -ENOMEM;
-                goto err_wq;
-        }
-
-        snprintf(name, sizeof name, "mlx4_ibud%d", port);
-        ctx->ud_wq = create_singlethread_workqueue(name);
-        if (!ctx->ud_wq) {
-                pr_err("Failed to create up/down WQ for port %d\n", port);
-                ret = -ENOMEM;
-                goto err_udwq;
-        }
-
-        return 0;
-
-err_udwq:
-        destroy_workqueue(ctx->wq);
-        ctx->wq = NULL;
-
-err_wq:
-        mlx4_ib_mcg_port_cleanup(ctx, 1);
-err_mcg:
-        for (i = 0; i < dev->dev->caps.sqp_demux; i++)
-                free_pv_object(dev, i, port);
-        kfree(ctx->tun);
-        ctx->tun = NULL;
-        return ret;
-}
-
-static void mlx4_ib_free_sqp_ctx(struct mlx4_ib_demux_pv_ctx *sqp_ctx)
-{
-        if (sqp_ctx->state > DEMUX_PV_STATE_DOWN) {
-                sqp_ctx->state = DEMUX_PV_STATE_DOWNING;
-                flush_workqueue(sqp_ctx->wq);
-                if (sqp_ctx->has_smi) {
-                        ib_destroy_qp(sqp_ctx->qp[0].qp);
-                        sqp_ctx->qp[0].qp = NULL;
-                        mlx4_ib_free_pv_qp_bufs(sqp_ctx, IB_QPT_SMI, 0);
-                }
-                ib_destroy_qp(sqp_ctx->qp[1].qp);
-                sqp_ctx->qp[1].qp = NULL;
-                mlx4_ib_free_pv_qp_bufs(sqp_ctx, IB_QPT_GSI, 0);
-                ib_dereg_mr(sqp_ctx->mr);
-                sqp_ctx->mr = NULL;
-                ib_dealloc_pd(sqp_ctx->pd);
-                sqp_ctx->pd = NULL;
-                ib_destroy_cq(sqp_ctx->cq);
-                sqp_ctx->cq = NULL;
-                sqp_ctx->state = DEMUX_PV_STATE_DOWN;
-        }
-}
-
-static void mlx4_ib_free_demux_ctx(struct mlx4_ib_demux_ctx *ctx)
-{
-        int i;
-        if (ctx) {
-                struct mlx4_ib_dev *dev = to_mdev(ctx->ib_dev);
-                mlx4_ib_mcg_port_cleanup(ctx, 1);
-                for (i = 0; i < dev->dev->caps.sqp_demux; i++) {
-                        if (!ctx->tun[i])
-                                continue;
-                        if (ctx->tun[i]->state > DEMUX_PV_STATE_DOWN)
-                                ctx->tun[i]->state = DEMUX_PV_STATE_DOWNING;
-                }
-                flush_workqueue(ctx->wq);
-                for (i = 0; i < dev->dev->caps.sqp_demux; i++) {
-                        destroy_pv_resources(dev, i, ctx->port, ctx->tun[i], 0);
-                        free_pv_object(dev, i, ctx->port);
-                }
-                kfree(ctx->tun);
-                destroy_workqueue(ctx->ud_wq);
-                destroy_workqueue(ctx->wq);
-        }
-}
-
-static void mlx4_ib_master_tunnels(struct mlx4_ib_dev *dev, int do_init)
-{
-        int i;
-
-        if (!mlx4_is_master(dev->dev))
-                return;
-        /* initialize or tear down tunnel QPs for the master */
-        for (i = 0; i < dev->dev->caps.num_ports; i++)
-                mlx4_ib_tunnels_update(dev, mlx4_master_func_num(dev->dev), i + 1, do_init);
-        return;
-}
-
-int mlx4_ib_init_sriov(struct mlx4_ib_dev *dev)
-{
-        int i = 0;
-        int err;
-
-        if (!mlx4_is_mfunc(dev->dev))
-                return 0;
-
-        dev->sriov.is_going_down = 0;
-        spin_lock_init(&dev->sriov.going_down_lock);
-        mlx4_ib_cm_paravirt_init(dev);
-
-        mlx4_ib_warn(&dev->ib_dev, "multi-function enabled\n");
-
-        if (mlx4_is_slave(dev->dev)) {
-                mlx4_ib_warn(&dev->ib_dev, "operating in qp1 tunnel mode\n");
-                return 0;
-        }
-
-        for (i = 0; i < dev->dev->caps.sqp_demux; i++) {
-                if (i == mlx4_master_func_num(dev->dev))
-                        mlx4_put_slave_node_guid(dev->dev, i, dev->ib_dev.node_guid);
-                else
-                        mlx4_put_slave_node_guid(dev->dev, i, mlx4_ib_gen_node_guid());
-        }
-
-        err = mlx4_ib_init_alias_guid_service(dev);
-        if (err) {
-                mlx4_ib_warn(&dev->ib_dev, "Failed init alias guid process.\n");
-                goto paravirt_err;
-        }
-        err = mlx4_ib_device_register_sysfs(dev);
-        if (err) {
-                mlx4_ib_warn(&dev->ib_dev, "Failed to register sysfs\n");
-                goto sysfs_err;
-        }
-
-        mlx4_ib_warn(&dev->ib_dev, "initializing demux service for %d qp1 clients\n",
-                     dev->dev->caps.sqp_demux);
-        for (i = 0; i < dev->num_ports; i++) {
-                union ib_gid gid;
-                err = __mlx4_ib_query_gid(&dev->ib_dev, i + 1, 0, &gid, 1);
-                if (err)
-                        goto demux_err;
-                dev->sriov.demux[i].guid_cache[0] = gid.global.interface_id;
-                err = alloc_pv_object(dev, mlx4_master_func_num(dev->dev), i + 1,
-                                      &dev->sriov.sqps[i]);
-                if (err)
-                        goto demux_err;
-                err = mlx4_ib_alloc_demux_ctx(dev, &dev->sriov.demux[i], i + 1);
-                if (err)
-                        goto demux_err;
-        }
-        mlx4_ib_master_tunnels(dev, 1);
-        return 0;
-
-demux_err:
-        while (i > 0) {
-                free_pv_object(dev, mlx4_master_func_num(dev->dev), i + 1);
-                mlx4_ib_free_demux_ctx(&dev->sriov.demux[i]);
-                --i;
-        }
-        mlx4_ib_device_unregister_sysfs(dev);
-
-sysfs_err:
-        mlx4_ib_destroy_alias_guid_service(dev);
-
-paravirt_err:
-        mlx4_ib_cm_paravirt_clean(dev, -1);
-
-        return err;
-}
-
-void mlx4_ib_close_sriov(struct mlx4_ib_dev *dev)
-{
-        int i;
-        unsigned long flags;
-
-        if (!mlx4_is_mfunc(dev->dev))
-                return;
-
-        spin_lock_irqsave(&dev->sriov.going_down_lock, flags);
-        dev->sriov.is_going_down = 1;
-        spin_unlock_irqrestore(&dev->sriov.going_down_lock, flags);
-        if (mlx4_is_master(dev->dev)) {
-                for (i = 0; i < dev->num_ports; i++) {
-                        flush_workqueue(dev->sriov.demux[i].ud_wq);
-                        mlx4_ib_free_sqp_ctx(dev->sriov.sqps[i]);
-                        kfree(dev->sriov.sqps[i]);
-                        dev->sriov.sqps[i] = NULL;
-                        mlx4_ib_free_demux_ctx(&dev->sriov.demux[i]);
-                }
-
-                mlx4_ib_cm_paravirt_clean(dev, -1);
-                mlx4_ib_destroy_alias_guid_service(dev);
-                mlx4_ib_device_unregister_sysfs(dev);
-        }
-}
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index e7d81c0d1ac..059a865b2b7 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -50,7 +50,7 @@
 #include "mlx4_ib.h"
 #include "user.h"
 
-#define DRV_NAME        MLX4_IB_DRV_NAME
+#define DRV_NAME        "mlx4_ib"
 #define DRV_VERSION     "1.0"
 #define DRV_RELDATE     "April 4, 2008"
 
@@ -59,10 +59,6 @@ MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(DRV_VERSION);
 
-int mlx4_ib_sm_guid_assign = 1;
-module_param_named(sm_guid_assign, mlx4_ib_sm_guid_assign, int, 0444);
-MODULE_PARM_DESC(sm_guid_assign, "Enable SM alias_GUID assignment if sm_guid_assign > 0 (Default: 1)");
-
 static const char mlx4_ib_version[] =
         DRV_NAME ": Mellanox ConnectX InfiniBand driver v"
         DRV_VERSION " (" DRV_RELDATE ")\n";
@@ -74,8 +70,6 @@ struct update_gid_work {
         int                     port;
 };
 
-static void do_slave_init(struct mlx4_ib_dev *ibdev, int slave, int do_init);
-
 static struct workqueue_struct *wq;
 
 static void init_query_mad(struct ib_smp *mad)
@@ -104,8 +98,7 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
         init_query_mad(in_mad);
         in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 
-        err = mlx4_MAD_IFC(to_mdev(ibdev), MLX4_MAD_IFC_IGNORE_KEYS,
-                           1, NULL, NULL, in_mad, out_mad);
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, 1, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
@@ -135,19 +128,17 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
             (dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_REMOTE_INV) &&
             (dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_FAST_REG_WR))
                 props->device_cap_flags |= IB_DEVICE_MEM_MGT_EXTENSIONS;
-        if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC)
-                props->device_cap_flags |= IB_DEVICE_XRC;
 
         props->vendor_id           = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
                 0xffffff;
-        props->vendor_part_id      = dev->dev->pdev->device;
+        props->vendor_part_id      = be16_to_cpup((__be16 *) (out_mad->data + 30));
         props->hw_ver              = be32_to_cpup((__be32 *) (out_mad->data + 32));
         memcpy(&props->sys_image_guid, out_mad->data +  4, 8);
 
         props->max_mr_size         = ~0ull;
         props->page_size_cap       = dev->dev->caps.page_size_cap;
         props->max_qp              = dev->dev->caps.num_qps - dev->dev->caps.reserved_qps;
-        props->max_qp_wr           = dev->dev->caps.max_wqes - MLX4_IB_SQ_MAX_SPARE;
+        props->max_qp_wr           = dev->dev->caps.max_wqes;
         props->max_sge             = min(dev->dev->caps.max_sq_sg,
                                          dev->dev->caps.max_rq_sg);
         props->max_cq              = dev->dev->caps.num_cqs - dev->dev->caps.reserved_cqs;
@@ -164,13 +155,13 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
         props->local_ca_ack_delay  = dev->dev->caps.local_ca_ack_delay;
         props->atomic_cap          = dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_ATOMIC ?
                 IB_ATOMIC_HCA : IB_ATOMIC_NONE;
-        props->masked_atomic_cap   = props->atomic_cap;
+        props->masked_atomic_cap   = IB_ATOMIC_HCA;
         props->max_pkeys           = dev->dev->caps.pkey_table_len[1];
         props->max_mcast_grp       = dev->dev->caps.num_mgms + dev->dev->caps.num_amgms;
         props->max_mcast_qp_attach = dev->dev->caps.num_qp_per_mgm;
         props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
                                            props->max_mcast_grp;
-        props->max_map_per_fmr = dev->dev->caps.max_fmr_maps;
+        props->max_map_per_fmr = (1 << (32 - ilog2(dev->dev->caps.num_mpts))) - 1;
 
 out:
         kfree(in_mad);
@@ -184,37 +175,14 @@ mlx4_ib_port_link_layer(struct ib_device *device, u8 port_num)
 {
         struct mlx4_dev *dev = to_mdev(device)->dev;
 
-        return dev->caps.port_mask[port_num] == MLX4_PORT_TYPE_IB ?
+        return dev->caps.port_mask & (1 << (port_num - 1)) ?
                 IB_LINK_LAYER_INFINIBAND : IB_LINK_LAYER_ETHERNET;
 }
 
 static int ib_link_query_port(struct ib_device *ibdev, u8 port,
-                              struct ib_port_attr *props, int netw_view)
+                              struct ib_port_attr *props,
+                              struct ib_smp *out_mad)
 {
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        int ext_active_speed;
-        int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
-        int err = -ENOMEM;
-
-        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
-        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
-        if (!in_mad || !out_mad)
-                goto out;
-
-        init_query_mad(in_mad);
-        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
-        in_mad->attr_mod = cpu_to_be32(port);
-
-        if (mlx4_is_mfunc(to_mdev(ibdev)->dev) && netw_view)
-                mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
-
-        err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port, NULL, NULL,
-                                in_mad, out_mad);
-        if (err)
-                goto out;
-
-
         props->lid              = be16_to_cpup((__be16 *) (out_mad->data + 16));
         props->lmc              = out_mad->data[34] & 0x7;
         props->sm_lid           = be16_to_cpup((__be16 *) (out_mad->data + 18));
@@ -222,10 +190,7 @@ static int ib_link_query_port(struct ib_device *ibdev, u8 port,
         props->state            = out_mad->data[32] & 0xf;
         props->phys_state       = out_mad->data[33] >> 4;
         props->port_cap_flags   = be32_to_cpup((__be32 *) (out_mad->data + 20));
-        if (netw_view)
-                props->gid_tbl_len = out_mad->data[50];
-        else
-                props->gid_tbl_len = to_mdev(ibdev)->dev->caps.gid_table_len[port];
+        props->gid_tbl_len      = to_mdev(ibdev)->dev->caps.gid_table_len[port];
         props->max_msg_sz       = to_mdev(ibdev)->dev->caps.max_msg_sz;
         props->pkey_tbl_len     = to_mdev(ibdev)->dev->caps.pkey_table_len[port];
         props->bad_pkey_cntr    = be16_to_cpup((__be16 *) (out_mad->data + 46));
@@ -238,44 +203,7 @@ static int ib_link_query_port(struct ib_device *ibdev, u8 port,
         props->max_vl_num       = out_mad->data[37] >> 4;
         props->init_type_reply  = out_mad->data[41] >> 4;
 
-        /* Check if extended speeds (EDR/FDR/...) are supported */
-        if (props->port_cap_flags & IB_PORT_EXTENDED_SPEEDS_SUP) {
-                ext_active_speed = out_mad->data[62] >> 4;
-
-                switch (ext_active_speed) {
-                case 1:
-                        props->active_speed = IB_SPEED_FDR;
-                        break;
-                case 2:
-                        props->active_speed = IB_SPEED_EDR;
-                        break;
-                }
-        }
-
-        /* If reported active speed is QDR, check if is FDR-10 */
-        if (props->active_speed == IB_SPEED_QDR) {
-                init_query_mad(in_mad);
-                in_mad->attr_id = MLX4_ATTR_EXTENDED_PORT_INFO;
-                in_mad->attr_mod = cpu_to_be32(port);
-
-                err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port,
-                                   NULL, NULL, in_mad, out_mad);
-                if (err)
-                        goto out;
-
-                /* Checking LinkSpeedActive for FDR-10 */
-                if (out_mad->data[15] & 0x1)
-                        props->active_speed = IB_SPEED_FDR10;
-        }
-
-        /* Avoid wrong speed value returned by FW if the IB link is down. */
-        if (props->state == IB_PORT_DOWN)
-                 props->active_speed = IB_SPEED_SDR;
-
-out:
-        kfree(in_mad);
-        kfree(out_mad);
-        return err;
+        return 0;
 }
 
 static u8 state_to_phys_state(enum ib_port_state state)
@@ -284,42 +212,32 @@ static u8 state_to_phys_state(enum ib_port_state state)
 }
 
 static int eth_link_query_port(struct ib_device *ibdev, u8 port,
-                               struct ib_port_attr *props, int netw_view)
+                               struct ib_port_attr *props,
+                               struct ib_smp *out_mad)
 {
-
-        struct mlx4_ib_dev *mdev = to_mdev(ibdev);
-        struct mlx4_ib_iboe *iboe = &mdev->iboe;
+        struct mlx4_ib_iboe *iboe = &to_mdev(ibdev)->iboe;
         struct net_device *ndev;
         enum ib_mtu tmp;
-        struct mlx4_cmd_mailbox *mailbox;
-        int err = 0;
-
-        mailbox = mlx4_alloc_cmd_mailbox(mdev->dev);
-        if (IS_ERR(mailbox))
-                return PTR_ERR(mailbox);
-
-        err = mlx4_cmd_box(mdev->dev, 0, mailbox->dma, port, 0,
-                           MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
-                           MLX4_CMD_WRAPPED);
-        if (err)
-                goto out;
 
-        props->active_width     =  (((u8 *)mailbox->buf)[5] == 0x40) ?
-                                                IB_WIDTH_4X : IB_WIDTH_1X;
-        props->active_speed     = IB_SPEED_QDR;
+        props->active_width     = IB_WIDTH_1X;
+        props->active_speed     = 4;
         props->port_cap_flags   = IB_PORT_CM_SUP;
-        props->gid_tbl_len      = mdev->dev->caps.gid_table_len[port];
-        props->max_msg_sz       = mdev->dev->caps.max_msg_sz;
+        props->gid_tbl_len      = to_mdev(ibdev)->dev->caps.gid_table_len[port];
+        props->max_msg_sz       = to_mdev(ibdev)->dev->caps.max_msg_sz;
         props->pkey_tbl_len     = 1;
-        props->max_mtu          = IB_MTU_4096;
-        props->max_vl_num       = 2;
+        props->bad_pkey_cntr    = be16_to_cpup((__be16 *) (out_mad->data + 46));
+        props->qkey_viol_cntr   = be16_to_cpup((__be16 *) (out_mad->data + 48));
+        props->max_mtu          = IB_MTU_2048;
+        props->subnet_timeout   = 0;
+        props->max_vl_num       = out_mad->data[37] >> 4;
+        props->init_type_reply  = 0;
         props->state            = IB_PORT_DOWN;
         props->phys_state       = state_to_phys_state(props->state);
         props->active_mtu       = IB_MTU_256;
         spin_lock(&iboe->lock);
         ndev = iboe->netdevs[port - 1];
         if (!ndev)
-                goto out_unlock;
+                goto out;
 
         tmp = iboe_get_mtu(ndev->mtu);
         props->active_mtu = tmp ? min(props->max_mtu, tmp) : IB_MTU_256;
@@ -327,43 +245,51 @@ static int eth_link_query_port(struct ib_device *ibdev, u8 port,
         props->state            = (netif_running(ndev) && netif_carrier_ok(ndev)) ?
                                         IB_PORT_ACTIVE : IB_PORT_DOWN;
         props->phys_state       = state_to_phys_state(props->state);
-out_unlock:
-        spin_unlock(&iboe->lock);
+
 out:
-        mlx4_free_cmd_mailbox(mdev->dev, mailbox);
-        return err;
+        spin_unlock(&iboe->lock);
+        return 0;
 }
 
-int __mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
-                         struct ib_port_attr *props, int netw_view)
+static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
+                              struct ib_port_attr *props)
 {
-        int err;
+        struct ib_smp *in_mad  = NULL;
+        struct ib_smp *out_mad = NULL;
+        int err = -ENOMEM;
+
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
+        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
+        if (!in_mad || !out_mad)
+                goto out;
 
         memset(props, 0, sizeof *props);
 
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
+        in_mad->attr_mod = cpu_to_be32(port);
+
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
+        if (err)
+                goto out;
+
         err = mlx4_ib_port_link_layer(ibdev, port) == IB_LINK_LAYER_INFINIBAND ?
-                ib_link_query_port(ibdev, port, props, netw_view) :
-                                eth_link_query_port(ibdev, port, props, netw_view);
+                ib_link_query_port(ibdev, port, props, out_mad) :
+                eth_link_query_port(ibdev, port, props, out_mad);
 
-        return err;
-}
+out:
+        kfree(in_mad);
+        kfree(out_mad);
 
-static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
-                              struct ib_port_attr *props)
-{
-        /* returns host view */
-        return __mlx4_ib_query_port(ibdev, port, props, 0);
+        return err;
 }
 
-int __mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
-                        union ib_gid *gid, int netw_view)
+static int __mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
+                               union ib_gid *gid)
 {
         struct ib_smp *in_mad  = NULL;
         struct ib_smp *out_mad = NULL;
         int err = -ENOMEM;
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        int clear = 0;
-        int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
 
         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
@@ -374,38 +300,23 @@ int __mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
         in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
         in_mad->attr_mod = cpu_to_be32(port);
 
-        if (mlx4_is_mfunc(dev->dev) && netw_view)
-                mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
-
-        err = mlx4_MAD_IFC(dev, mad_ifc_flags, port, NULL, NULL, in_mad, out_mad);
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
         memcpy(gid->raw, out_mad->data + 8, 8);
 
-        if (mlx4_is_mfunc(dev->dev) && !netw_view) {
-                if (index) {
-                        /* For any index > 0, return the null guid */
-                        err = 0;
-                        clear = 1;
-                        goto out;
-                }
-        }
-
         init_query_mad(in_mad);
         in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
         in_mad->attr_mod = cpu_to_be32(index / 8);
 
-        err = mlx4_MAD_IFC(dev, mad_ifc_flags, port,
-                           NULL, NULL, in_mad, out_mad);
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
         memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
 
 out:
-        if (clear)
-                memset(gid->raw + 8, 0, 8);
         kfree(in_mad);
         kfree(out_mad);
         return err;
@@ -425,17 +336,16 @@ static int mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
                              union ib_gid *gid)
 {
         if (rdma_port_get_link_layer(ibdev, port) == IB_LINK_LAYER_INFINIBAND)
-                return __mlx4_ib_query_gid(ibdev, port, index, gid, 0);
+                return __mlx4_ib_query_gid(ibdev, port, index, gid);
         else
                 return iboe_query_gid(ibdev, port, index, gid);
 }
 
-int __mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
-                         u16 *pkey, int netw_view)
+static int mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
+                              u16 *pkey)
 {
         struct ib_smp *in_mad  = NULL;
         struct ib_smp *out_mad = NULL;
-        int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
         int err = -ENOMEM;
 
         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
@@ -447,11 +357,7 @@ int __mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
         in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
         in_mad->attr_mod = cpu_to_be32(index / 32);
 
-        if (mlx4_is_mfunc(to_mdev(ibdev)->dev) && netw_view)
-                mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
-
-        err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port, NULL, NULL,
-                           in_mad, out_mad);
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
@@ -463,16 +369,10 @@ out:
         return err;
 }
 
-static int mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index, u16 *pkey)
-{
-        return __mlx4_ib_query_pkey(ibdev, port, index, pkey, 0);
-}
-
 static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
                                  struct ib_device_modify *props)
 {
         struct mlx4_cmd_mailbox *mailbox;
-        unsigned long flags;
 
         if (mask & ~IB_DEVICE_MODIFY_NODE_DESC)
                 return -EOPNOTSUPP;
@@ -480,12 +380,9 @@ static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
         if (!(mask & IB_DEVICE_MODIFY_NODE_DESC))
                 return 0;
 
-        if (mlx4_is_slave(to_mdev(ibdev)->dev))
-                return -EOPNOTSUPP;
-
-        spin_lock_irqsave(&to_mdev(ibdev)->sm_lock, flags);
+        spin_lock(&to_mdev(ibdev)->sm_lock);
         memcpy(ibdev->node_desc, props->node_desc, 64);
-        spin_unlock_irqrestore(&to_mdev(ibdev)->sm_lock, flags);
+        spin_unlock(&to_mdev(ibdev)->sm_lock);
 
         /*
          * If possible, pass node desc to FW, so it can generate
@@ -498,7 +395,7 @@ static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
         memset(mailbox->buf, 0, 256);
         memcpy(mailbox->buf, props->node_desc, 64);
         mlx4_cmd(to_mdev(ibdev)->dev, mailbox->dma, 1, 0,
-                 MLX4_CMD_SET_NODE, MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
+                 MLX4_CMD_SET_NODE, MLX4_CMD_TIME_CLASS_A);
 
         mlx4_free_cmd_mailbox(to_mdev(ibdev)->dev, mailbox);
 
@@ -527,7 +424,7 @@ static int mlx4_SET_PORT(struct mlx4_ib_dev *dev, u8 port, int reset_qkey_viols,
         }
 
         err = mlx4_cmd(dev->dev, mailbox->dma, port, is_eth, MLX4_CMD_SET_PORT,
-                       MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+                       MLX4_CMD_TIME_CLASS_B);
 
         mlx4_free_cmd_mailbox(dev->dev, mailbox);
         return err;
@@ -563,24 +460,15 @@ static struct ib_ucontext *mlx4_ib_alloc_ucontext(struct ib_device *ibdev,
 {
         struct mlx4_ib_dev *dev = to_mdev(ibdev);
         struct mlx4_ib_ucontext *context;
-        struct mlx4_ib_alloc_ucontext_resp_v3 resp_v3;
         struct mlx4_ib_alloc_ucontext_resp resp;
         int err;
 
         if (!dev->ib_active)
                 return ERR_PTR(-EAGAIN);
 
-        if (ibdev->uverbs_abi_ver == MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION) {
-                resp_v3.qp_tab_size      = dev->dev->caps.num_qps;
-                resp_v3.bf_reg_size      = dev->dev->caps.bf_reg_size;
-                resp_v3.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
-        } else {
-                resp.dev_caps         = dev->dev->caps.userspace_caps;
-                resp.qp_tab_size      = dev->dev->caps.num_qps;
-                resp.bf_reg_size      = dev->dev->caps.bf_reg_size;
-                resp.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
-                resp.cqe_size         = dev->dev->caps.cqe_size;
-        }
+        resp.qp_tab_size      = dev->dev->caps.num_qps;
+        resp.bf_reg_size      = dev->dev->caps.bf_reg_size;
+        resp.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
 
         context = kmalloc(sizeof *context, GFP_KERNEL);
         if (!context)
@@ -595,11 +483,7 @@ static struct ib_ucontext *mlx4_ib_alloc_ucontext(struct ib_device *ibdev,
         INIT_LIST_HEAD(&context->db_page_list);
         mutex_init(&context->db_page_mutex);
 
-        if (ibdev->uverbs_abi_ver == MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION)
-                err = ib_copy_to_udata(udata, &resp_v3, sizeof(resp_v3));
-        else
-                err = ib_copy_to_udata(udata, &resp, sizeof(resp));
-
+        err = ib_copy_to_udata(udata, &resp, sizeof resp);
         if (err) {
                 mlx4_uar_free(to_mdev(ibdev)->dev, &context->uar);
                 kfree(context);
@@ -682,57 +566,6 @@ static int mlx4_ib_dealloc_pd(struct ib_pd *pd)
         return 0;
 }
 
-static struct ib_xrcd *mlx4_ib_alloc_xrcd(struct ib_device *ibdev,
-                                          struct ib_ucontext *context,
-                                          struct ib_udata *udata)
-{
-        struct mlx4_ib_xrcd *xrcd;
-        int err;
-
-        if (!(to_mdev(ibdev)->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC))
-                return ERR_PTR(-ENOSYS);
-
-        xrcd = kmalloc(sizeof *xrcd, GFP_KERNEL);
-        if (!xrcd)
-                return ERR_PTR(-ENOMEM);
-
-        err = mlx4_xrcd_alloc(to_mdev(ibdev)->dev, &xrcd->xrcdn);
-        if (err)
-                goto err1;
-
-        xrcd->pd = ib_alloc_pd(ibdev);
-        if (IS_ERR(xrcd->pd)) {
-                err = PTR_ERR(xrcd->pd);
-                goto err2;
-        }
-
-        xrcd->cq = ib_create_cq(ibdev, NULL, NULL, xrcd, 1, 0);
-        if (IS_ERR(xrcd->cq)) {
-                err = PTR_ERR(xrcd->cq);
-                goto err3;
-        }
-
-        return &xrcd->ibxrcd;
-
-err3:
-        ib_dealloc_pd(xrcd->pd);
-err2:
-        mlx4_xrcd_free(to_mdev(ibdev)->dev, xrcd->xrcdn);
-err1:
-        kfree(xrcd);
-        return ERR_PTR(err);
-}
-
-static int mlx4_ib_dealloc_xrcd(struct ib_xrcd *xrcd)
-{
-        ib_destroy_cq(to_mxrcd(xrcd)->cq);
-        ib_dealloc_pd(to_mxrcd(xrcd)->pd);
-        mlx4_xrcd_free(to_mdev(xrcd->device)->dev, to_mxrcd(xrcd)->xrcdn);
-        kfree(xrcd);
-
-        return 0;
-}
-
 static int add_gid_entry(struct ib_qp *ibqp, union ib_gid *gid)
 {
         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
@@ -784,53 +617,26 @@ int mlx4_ib_add_mc(struct mlx4_ib_dev *mdev, struct mlx4_ib_qp *mqp,
         return ret;
 }
 
-struct mlx4_ib_steering {
-        struct list_head list;
-        u64 reg_id;
-        union ib_gid gid;
-};
-
 static int mlx4_ib_mcg_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 {
         int err;
         struct mlx4_ib_dev *mdev = to_mdev(ibqp->device);
         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
-        u64 reg_id;
-        struct mlx4_ib_steering *ib_steering = NULL;
-
-        if (mdev->dev->caps.steering_mode ==
-            MLX4_STEERING_MODE_DEVICE_MANAGED) {
-                ib_steering = kmalloc(sizeof(*ib_steering), GFP_KERNEL);
-                if (!ib_steering)
-                        return -ENOMEM;
-        }
 
-        err = mlx4_multicast_attach(mdev->dev, &mqp->mqp, gid->raw, mqp->port,
-                                    !!(mqp->flags &
-                                       MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK),
-                                    MLX4_PROT_IB_IPV6, &reg_id);
+        err = mlx4_multicast_attach(mdev->dev, &mqp->mqp, gid->raw,
+                                    !!(mqp->flags & MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK),
+                                    MLX4_PROT_IB_IPV6);
         if (err)
-                goto err_malloc;
+                return err;
 
         err = add_gid_entry(ibqp, gid);
         if (err)
                 goto err_add;
 
-        if (ib_steering) {
-                memcpy(ib_steering->gid.raw, gid->raw, 16);
-                ib_steering->reg_id = reg_id;
-                mutex_lock(&mqp->mutex);
-                list_add(&ib_steering->list, &mqp->steering_rules);
-                mutex_unlock(&mqp->mutex);
-        }
         return 0;
 
 err_add:
-        mlx4_multicast_detach(mdev->dev, &mqp->mqp, gid->raw,
-                              MLX4_PROT_IB_IPV6, reg_id);
-err_malloc:
-        kfree(ib_steering);
-
+        mlx4_multicast_detach(mdev->dev, &mqp->mqp, gid->raw, MLX4_PROT_IB_IPV6);
         return err;
 }
 
@@ -858,30 +664,9 @@ static int mlx4_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
         u8 mac[6];
         struct net_device *ndev;
         struct mlx4_ib_gid_entry *ge;
-        u64 reg_id = 0;
-
-        if (mdev->dev->caps.steering_mode ==
-            MLX4_STEERING_MODE_DEVICE_MANAGED) {
-                struct mlx4_ib_steering *ib_steering;
 
-                mutex_lock(&mqp->mutex);
-                list_for_each_entry(ib_steering, &mqp->steering_rules, list) {
-                        if (!memcmp(ib_steering->gid.raw, gid->raw, 16)) {
-                                list_del(&ib_steering->list);
-                                break;
-                        }
-                }
-                mutex_unlock(&mqp->mutex);
-                if (&ib_steering->list == &mqp->steering_rules) {
-                        pr_err("Couldn't find reg_id for mgid. Steering rule is left attached\n");
-                        return -EINVAL;
-                }
-                reg_id = ib_steering->reg_id;
-                kfree(ib_steering);
-        }
-
-        err = mlx4_multicast_detach(mdev->dev, &mqp->mqp, gid->raw,
-                                    MLX4_PROT_IB_IPV6, reg_id);
+        err = mlx4_multicast_detach(mdev->dev,
+                                    &mqp->mqp, gid->raw, MLX4_PROT_IB_IPV6);
         if (err)
                 return err;
 
@@ -903,7 +688,7 @@ static int mlx4_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
                 list_del(&ge->list);
                 kfree(ge);
         } else
-                pr_warn("could not find mgid entry\n");
+                printk(KERN_WARNING "could not find mgid entry\n");
 
         mutex_unlock(&mqp->mutex);
 
@@ -914,7 +699,6 @@ static int init_node_data(struct mlx4_ib_dev *dev)
 {
         struct ib_smp *in_mad  = NULL;
         struct ib_smp *out_mad = NULL;
-        int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
         int err = -ENOMEM;
 
         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
@@ -924,10 +708,8 @@ static int init_node_data(struct mlx4_ib_dev *dev)
 
         init_query_mad(in_mad);
         in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
-        if (mlx4_is_master(dev->dev))
-                mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
 
-        err = mlx4_MAD_IFC(dev, mad_ifc_flags, 1, NULL, NULL, in_mad, out_mad);
+        err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
@@ -935,11 +717,10 @@ static int init_node_data(struct mlx4_ib_dev *dev)
 
         in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 
-        err = mlx4_MAD_IFC(dev, mad_ifc_flags, 1, NULL, NULL, in_mad, out_mad);
+        err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
         if (err)
                 goto out;
 
-        dev->dev->rev_id = be32_to_cpup((__be32 *) (out_mad->data + 32));
         memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
 
 out:
@@ -1016,10 +797,11 @@ static void update_gids_task(struct work_struct *work)
         union ib_gid *gids;
         int err;
         struct mlx4_dev *dev = gw->dev->dev;
+        struct ib_event event;
 
         mailbox = mlx4_alloc_cmd_mailbox(dev);
         if (IS_ERR(mailbox)) {
-                pr_warn("update gid table failed %ld\n", PTR_ERR(mailbox));
+                printk(KERN_WARNING "update gid table failed %ld\n", PTR_ERR(mailbox));
                 return;
         }
 
@@ -1027,13 +809,15 @@ static void update_gids_task(struct work_struct *work)
         memcpy(gids, gw->gids, sizeof gw->gids);
 
         err = mlx4_cmd(dev, mailbox->dma, MLX4_SET_PORT_GID_TABLE << 8 | gw->port,
-                       1, MLX4_CMD_SET_PORT, MLX4_CMD_TIME_CLASS_B,
-                       MLX4_CMD_WRAPPED);
+                       1, MLX4_CMD_SET_PORT, MLX4_CMD_TIME_CLASS_B);
         if (err)
-                pr_warn("set port command failed\n");
+                printk(KERN_WARNING "set port command failed\n");
         else {
                 memcpy(gw->dev->iboe.gid_table[gw->port - 1], gw->gids, sizeof gw->gids);
-                mlx4_ib_dispatch_event(gw->dev, gw->port, IB_EVENT_GID_CHANGE);
+                event.device = &gw->dev->ib_dev;
+                event.element.port_num = gw->port;
+                event.event    = IB_EVENT_GID_CHANGE;
+                ib_dispatch_event(&event);
         }
 
         mlx4_free_cmd_mailbox(dev, mailbox);
@@ -1190,133 +974,16 @@ static int mlx4_ib_netdev_event(struct notifier_block *this, unsigned long event
         return NOTIFY_DONE;
 }
 
-static void init_pkeys(struct mlx4_ib_dev *ibdev)
-{
-        int port;
-        int slave;
-        int i;
-
-        if (mlx4_is_master(ibdev->dev)) {
-                for (slave = 0; slave <= ibdev->dev->num_vfs; ++slave) {
-                        for (port = 1; port <= ibdev->dev->caps.num_ports; ++port) {
-                                for (i = 0;
-                                     i < ibdev->dev->phys_caps.pkey_phys_table_len[port];
-                                     ++i) {
-                                        ibdev->pkeys.virt2phys_pkey[slave][port - 1][i] =
-                                        /* master has the identity virt2phys pkey mapping */
-                                                (slave == mlx4_master_func_num(ibdev->dev) || !i) ? i :
-                                                        ibdev->dev->phys_caps.pkey_phys_table_len[port] - 1;
-                                        mlx4_sync_pkey_table(ibdev->dev, slave, port, i,
-                                                             ibdev->pkeys.virt2phys_pkey[slave][port - 1][i]);
-                                }
-                        }
-                }
-                /* initialize pkey cache */
-                for (port = 1; port <= ibdev->dev->caps.num_ports; ++port) {
-                        for (i = 0;
-                             i < ibdev->dev->phys_caps.pkey_phys_table_len[port];
-                             ++i)
-                                ibdev->pkeys.phys_pkey_cache[port-1][i] =
-                                        (i) ? 0 : 0xFFFF;
-                }
-        }
-}
-
-static void mlx4_ib_alloc_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
-{
-        char name[32];
-        int eq_per_port = 0;
-        int added_eqs = 0;
-        int total_eqs = 0;
-        int i, j, eq;
-
-        /* Legacy mode or comp_pool is not large enough */
-        if (dev->caps.comp_pool == 0 ||
-            dev->caps.num_ports > dev->caps.comp_pool)
-                return;
-
-        eq_per_port = rounddown_pow_of_two(dev->caps.comp_pool/
-                                        dev->caps.num_ports);
-
-        /* Init eq table */
-        added_eqs = 0;
-        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
-                added_eqs += eq_per_port;
-
-        total_eqs = dev->caps.num_comp_vectors + added_eqs;
-
-        ibdev->eq_table = kzalloc(total_eqs * sizeof(int), GFP_KERNEL);
-        if (!ibdev->eq_table)
-                return;
-
-        ibdev->eq_added = added_eqs;
-
-        eq = 0;
-        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB) {
-                for (j = 0; j < eq_per_port; j++) {
-                        sprintf(name, "mlx4-ib-%d-%d@%s",
-                                i, j, dev->pdev->bus->name);
-                        /* Set IRQ for specific name (per ring) */
-                        if (mlx4_assign_eq(dev, name, NULL,
-                                           &ibdev->eq_table[eq])) {
-                                /* Use legacy (same as mlx4_en driver) */
-                                pr_warn("Can't allocate EQ %d; reverting to legacy\n", eq);
-                                ibdev->eq_table[eq] =
-                                        (eq % dev->caps.num_comp_vectors);
-                        }
-                        eq++;
-                }
-        }
-
-        /* Fill the reset of the vector with legacy EQ */
-        for (i = 0, eq = added_eqs; i < dev->caps.num_comp_vectors; i++)
-                ibdev->eq_table[eq++] = i;
-
-        /* Advertise the new number of EQs to clients */
-        ibdev->ib_dev.num_comp_vectors = total_eqs;
-}
-
-static void mlx4_ib_free_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
-{
-        int i;
-
-        /* no additional eqs were added */
-        if (!ibdev->eq_table)
-                return;
-
-        /* Reset the advertised EQ number */
-        ibdev->ib_dev.num_comp_vectors = dev->caps.num_comp_vectors;
-
-        /* Free only the added eqs */
-        for (i = 0; i < ibdev->eq_added; i++) {
-                /* Don't free legacy eqs if used */
-                if (ibdev->eq_table[i] <= dev->caps.num_comp_vectors)
-                        continue;
-                mlx4_release_eq(dev, ibdev->eq_table[i]);
-        }
-
-        kfree(ibdev->eq_table);
-}
-
 static void *mlx4_ib_add(struct mlx4_dev *dev)
 {
         struct mlx4_ib_dev *ibdev;
         int num_ports = 0;
-        int i, j;
+        int i;
         int err;
         struct mlx4_ib_iboe *iboe;
 
-        pr_info_once("%s", mlx4_ib_version);
+        printk_once(KERN_INFO "%s", mlx4_ib_version);
 
-        mlx4_foreach_non_ib_transport_port(i, dev)
-                num_ports++;
-
-        if (mlx4_is_mfunc(dev) && num_ports) {
-                dev_err(&dev->pdev->dev, "RoCE is not supported over SRIOV as yet\n");
-                return NULL;
-        }
-
-        num_ports = 0;
         mlx4_foreach_ib_transport_port(i, dev)
                 num_ports++;
 
@@ -1355,11 +1022,7 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         ibdev->ib_dev.num_comp_vectors  = dev->caps.num_comp_vectors;
         ibdev->ib_dev.dma_device        = &dev->pdev->dev;
 
-        if (dev->caps.userspace_caps)
-                ibdev->ib_dev.uverbs_abi_ver = MLX4_IB_UVERBS_ABI_VERSION;
-        else
-                ibdev->ib_dev.uverbs_abi_ver = MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION;
-
+        ibdev->ib_dev.uverbs_abi_ver    = MLX4_IB_UVERBS_ABI_VERSION;
         ibdev->ib_dev.uverbs_cmd_mask   =
                 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT)         |
                 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)        |
@@ -1381,9 +1044,7 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
                 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ)          |
                 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ)          |
                 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ)           |
-                (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ)         |
-                (1ull << IB_USER_VERBS_CMD_CREATE_XSRQ)         |
-                (1ull << IB_USER_VERBS_CMD_OPEN_QP);
+                (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);
 
         ibdev->ib_dev.query_device      = mlx4_ib_query_device;
         ibdev->ib_dev.query_port        = mlx4_ib_query_port;
@@ -1427,22 +1088,10 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         ibdev->ib_dev.detach_mcast      = mlx4_ib_mcg_detach;
         ibdev->ib_dev.process_mad       = mlx4_ib_process_mad;
 
-        if (!mlx4_is_slave(ibdev->dev)) {
-                ibdev->ib_dev.alloc_fmr         = mlx4_ib_fmr_alloc;
-                ibdev->ib_dev.map_phys_fmr      = mlx4_ib_map_phys_fmr;
-                ibdev->ib_dev.unmap_fmr         = mlx4_ib_unmap_fmr;
-                ibdev->ib_dev.dealloc_fmr       = mlx4_ib_fmr_dealloc;
-        }
-
-        if (dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC) {
-                ibdev->ib_dev.alloc_xrcd = mlx4_ib_alloc_xrcd;
-                ibdev->ib_dev.dealloc_xrcd = mlx4_ib_dealloc_xrcd;
-                ibdev->ib_dev.uverbs_cmd_mask |=
-                        (1ull << IB_USER_VERBS_CMD_OPEN_XRCD) |
-                        (1ull << IB_USER_VERBS_CMD_CLOSE_XRCD);
-        }
-
-        mlx4_ib_alloc_eqs(dev, ibdev);
+        ibdev->ib_dev.alloc_fmr         = mlx4_ib_fmr_alloc;
+        ibdev->ib_dev.map_phys_fmr      = mlx4_ib_map_phys_fmr;
+        ibdev->ib_dev.unmap_fmr         = mlx4_ib_unmap_fmr;
+        ibdev->ib_dev.dealloc_fmr       = mlx4_ib_fmr_dealloc;
 
         spin_lock_init(&iboe->lock);
 
@@ -1468,49 +1117,28 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         if (mlx4_ib_mad_init(ibdev))
                 goto err_reg;
 
-        if (mlx4_ib_init_sriov(ibdev))
-                goto err_mad;
-
         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_IBOE && !iboe->nb.notifier_call) {
                 iboe->nb.notifier_call = mlx4_ib_netdev_event;
                 err = register_netdevice_notifier(&iboe->nb);
                 if (err)
-                        goto err_sriov;
+                        goto err_reg;
         }
 
-        for (j = 0; j < ARRAY_SIZE(mlx4_class_attributes); ++j) {
+        for (i = 0; i < ARRAY_SIZE(mlx4_class_attributes); ++i) {
                 if (device_create_file(&ibdev->ib_dev.dev,
-                                       mlx4_class_attributes[j]))
+                                       mlx4_class_attributes[i]))
                         goto err_notif;
         }
 
         ibdev->ib_active = true;
 
-        if (mlx4_is_mfunc(ibdev->dev))
-                init_pkeys(ibdev);
-
-        /* create paravirt contexts for any VFs which are active */
-        if (mlx4_is_master(ibdev->dev)) {
-                for (j = 0; j < MLX4_MFUNC_MAX; j++) {
-                        if (j == mlx4_master_func_num(ibdev->dev))
-                                continue;
-                        if (mlx4_is_slave_active(ibdev->dev, j))
-                                do_slave_init(ibdev, j, 1);
-                }
-        }
         return ibdev;
 
 err_notif:
         if (unregister_netdevice_notifier(&ibdev->iboe.nb))
-                pr_warn("failure unregistering notifier\n");
+                printk(KERN_WARNING "failure unregistering notifier\n");
         flush_workqueue(wq);
 
-err_sriov:
-        mlx4_ib_close_sriov(ibdev);
-
-err_mad:
-        mlx4_ib_mad_cleanup(ibdev);
-
 err_reg:
         ib_unregister_device(&ibdev->ib_dev);
 
@@ -1539,12 +1167,11 @@ static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
         struct mlx4_ib_dev *ibdev = ibdev_ptr;
         int p;
 
-        mlx4_ib_close_sriov(ibdev);
         mlx4_ib_mad_cleanup(ibdev);
         ib_unregister_device(&ibdev->ib_dev);
         if (ibdev->iboe.nb.notifier_call) {
                 if (unregister_netdevice_notifier(&ibdev->iboe.nb))
-                        pr_warn("failure unregistering notifier\n");
+                        printk(KERN_WARNING "failure unregistering notifier\n");
                 ibdev->iboe.nb.notifier_call = NULL;
         }
         iounmap(ibdev->uar_map);
@@ -1554,87 +1181,26 @@ static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
         mlx4_foreach_port(p, dev, MLX4_PORT_TYPE_IB)
                 mlx4_CLOSE_PORT(dev, p);
 
-        mlx4_ib_free_eqs(dev, ibdev);
-
         mlx4_uar_free(dev, &ibdev->priv_uar);
         mlx4_pd_free(dev, ibdev->priv_pdn);
         ib_dealloc_device(&ibdev->ib_dev);
 }
 
-static void do_slave_init(struct mlx4_ib_dev *ibdev, int slave, int do_init)
-{
-        struct mlx4_ib_demux_work **dm = NULL;
-        struct mlx4_dev *dev = ibdev->dev;
-        int i;
-        unsigned long flags;
-
-        if (!mlx4_is_master(dev))
-                return;
-
-        dm = kcalloc(dev->caps.num_ports, sizeof *dm, GFP_ATOMIC);
-        if (!dm) {
-                pr_err("failed to allocate memory for tunneling qp update\n");
-                goto out;
-        }
-
-        for (i = 0; i < dev->caps.num_ports; i++) {
-                dm[i] = kmalloc(sizeof (struct mlx4_ib_demux_work), GFP_ATOMIC);
-                if (!dm[i]) {
-                        pr_err("failed to allocate memory for tunneling qp update work struct\n");
-                        for (i = 0; i < dev->caps.num_ports; i++) {
-                                if (dm[i])
-                                        kfree(dm[i]);
-                        }
-                        goto out;
-                }
-        }
-        /* initialize or tear down tunnel QPs for the slave */
-        for (i = 0; i < dev->caps.num_ports; i++) {
-                INIT_WORK(&dm[i]->work, mlx4_ib_tunnels_update_work);
-                dm[i]->port = i + 1;
-                dm[i]->slave = slave;
-                dm[i]->do_init = do_init;
-                dm[i]->dev = ibdev;
-                spin_lock_irqsave(&ibdev->sriov.going_down_lock, flags);
-                if (!ibdev->sriov.is_going_down)
-                        queue_work(ibdev->sriov.demux[i].ud_wq, &dm[i]->work);
-                spin_unlock_irqrestore(&ibdev->sriov.going_down_lock, flags);
-        }
-out:
-        if (dm)
-                kfree(dm);
-        return;
-}
-
 static void mlx4_ib_event(struct mlx4_dev *dev, void *ibdev_ptr,
-                          enum mlx4_dev_event event, unsigned long param)
+                          enum mlx4_dev_event event, int port)
 {
         struct ib_event ibev;
         struct mlx4_ib_dev *ibdev = to_mdev((struct ib_device *) ibdev_ptr);
-        struct mlx4_eqe *eqe = NULL;
-        struct ib_event_work *ew;
-        int p = 0;
 
-        if (event == MLX4_DEV_EVENT_PORT_MGMT_CHANGE)
-                eqe = (struct mlx4_eqe *)param;
-        else
-                p = (int) param;
+        if (port > ibdev->num_ports)
+                return;
 
         switch (event) {
         case MLX4_DEV_EVENT_PORT_UP:
-                if (p > ibdev->num_ports)
-                        return;
-                if (mlx4_is_master(dev) &&
-                    rdma_port_get_link_layer(&ibdev->ib_dev, p) ==
-                        IB_LINK_LAYER_INFINIBAND) {
-                        mlx4_ib_invalidate_all_guid_record(ibdev, p);
-                }
                 ibev.event = IB_EVENT_PORT_ACTIVE;
                 break;
 
         case MLX4_DEV_EVENT_PORT_DOWN:
-                if (p > ibdev->num_ports)
-                        return;
                 ibev.event = IB_EVENT_PORT_ERR;
                 break;
 
@@ -1643,39 +1209,12 @@ static void mlx4_ib_event(struct mlx4_dev *dev, void *ibdev_ptr,
                 ibev.event = IB_EVENT_DEVICE_FATAL;
                 break;
 
-        case MLX4_DEV_EVENT_PORT_MGMT_CHANGE:
-                ew = kmalloc(sizeof *ew, GFP_ATOMIC);
-                if (!ew) {
-                        pr_err("failed to allocate memory for events work\n");
-                        break;
-                }
-
-                INIT_WORK(&ew->work, handle_port_mgmt_change_event);
-                memcpy(&ew->ib_eqe, eqe, sizeof *eqe);
-                ew->ib_dev = ibdev;
-                /* need to queue only for port owner, which uses GEN_EQE */
-                if (mlx4_is_master(dev))
-                        queue_work(wq, &ew->work);
-                else
-                        handle_port_mgmt_change_event(&ew->work);
-                return;
-
-        case MLX4_DEV_EVENT_SLAVE_INIT:
-                /* here, p is the slave id */
-                do_slave_init(ibdev, p, 1);
-                return;
-
-        case MLX4_DEV_EVENT_SLAVE_SHUTDOWN:
-                /* here, p is the slave id */
-                do_slave_init(ibdev, p, 0);
-                return;
-
         default:
                 return;
         }
 
         ibev.device           = ibdev_ptr;
-        ibev.element.port_num = (u8) p;
+        ibev.element.port_num = port;
 
         ib_dispatch_event(&ibev);
 }
@@ -1695,28 +1234,18 @@ static int __init mlx4_ib_init(void)
         if (!wq)
                 return -ENOMEM;
 
-        err = mlx4_ib_mcg_init();
-        if (err)
-                goto clean_wq;
-
         err = mlx4_register_interface(&mlx4_ib_interface);
-        if (err)
-                goto clean_mcg;
+        if (err) {
+                destroy_workqueue(wq);
+                return err;
+        }
 
         return 0;
-
-clean_mcg:
-        mlx4_ib_mcg_destroy();
-
-clean_wq:
-        destroy_workqueue(wq);
-        return err;
 }
 
 static void __exit mlx4_ib_cleanup(void)
 {
         mlx4_unregister_interface(&mlx4_ib_interface);
-        mlx4_ib_mcg_destroy();
         destroy_workqueue(wq);
 }
 
diff --git a/drivers/infiniband/hw/mlx4/mcg.c b/drivers/infiniband/hw/mlx4/mcg.c
deleted file mode 100644
index 25b2cdff00f..00000000000
--- a/drivers/infiniband/hw/mlx4/mcg.c
+++ /dev/null
@@ -1,1256 +0,0 @@
-/*
- * Copyright (c) 2012 Mellanox Technologies. 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 <rdma/ib_mad.h>
-#include <rdma/ib_smi.h>
-#include <rdma/ib_cache.h>
-#include <rdma/ib_sa.h>
-
-#include <linux/mlx4/cmd.h>
-#include <linux/rbtree.h>
-#include <linux/delay.h>
-
-#include "mlx4_ib.h"
-
-#define MAX_VFS         80
-#define MAX_PEND_REQS_PER_FUNC 4
-#define MAD_TIMEOUT_MS  2000
-
-#define mcg_warn(fmt, arg...)   pr_warn("MCG WARNING: " fmt, ##arg)
-#define mcg_error(fmt, arg...)  pr_err(fmt, ##arg)
-#define mcg_warn_group(group, format, arg...) \
-        pr_warn("%s-%d: %16s (port %d): WARNING: " format, __func__, __LINE__,\
-        (group)->name, group->demux->port, ## arg)
-
-#define mcg_error_group(group, format, arg...) \
-        pr_err("  %16s: " format, (group)->name, ## arg)
-
-
-static union ib_gid mgid0;
-
-static struct workqueue_struct *clean_wq;
-
-enum mcast_state {
-        MCAST_NOT_MEMBER = 0,
-        MCAST_MEMBER,
-};
-
-enum mcast_group_state {
-        MCAST_IDLE,
-        MCAST_JOIN_SENT,
-        MCAST_LEAVE_SENT,
-        MCAST_RESP_READY
-};
-
-struct mcast_member {
-        enum mcast_state state;
-        uint8_t                 join_state;
-        int                     num_pend_reqs;
-        struct list_head        pending;
-};
-
-struct ib_sa_mcmember_data {
-        union ib_gid    mgid;
-        union ib_gid    port_gid;
-        __be32          qkey;
-        __be16          mlid;
-        u8              mtusel_mtu;
-        u8              tclass;
-        __be16          pkey;
-        u8              ratesel_rate;
-        u8              lifetmsel_lifetm;
-        __be32          sl_flowlabel_hoplimit;
-        u8              scope_join_state;
-        u8              proxy_join;
-        u8              reserved[2];
-};
-
-struct mcast_group {
-        struct ib_sa_mcmember_data rec;
-        struct rb_node          node;
-        struct list_head        mgid0_list;
-        struct mlx4_ib_demux_ctx *demux;
-        struct mcast_member     func[MAX_VFS];
-        struct mutex            lock;
-        struct work_struct      work;
-        struct list_head        pending_list;
-        int                     members[3];
-        enum mcast_group_state  state;
-        enum mcast_group_state  prev_state;
-        struct ib_sa_mad        response_sa_mad;
-        __be64                  last_req_tid;
-
-        char                    name[33]; /* MGID string */
-        struct device_attribute dentry;
-
-        /* refcount is the reference count for the following:
-           1. Each queued request
-           2. Each invocation of the worker thread
-           3. Membership of the port at the SA
-        */
-        atomic_t                refcount;
-
-        /* delayed work to clean pending SM request */
-        struct delayed_work     timeout_work;
-        struct list_head        cleanup_list;
-};
-
-struct mcast_req {
-        int                     func;
-        struct ib_sa_mad        sa_mad;
-        struct list_head        group_list;
-        struct list_head        func_list;
-        struct mcast_group      *group;
-        int                     clean;
-};
-
-
-#define safe_atomic_dec(ref) \
-        do {\
-                if (atomic_dec_and_test(ref)) \
-                        mcg_warn_group(group, "did not expect to reach zero\n"); \
-        } while (0)
-
-static const char *get_state_string(enum mcast_group_state state)
-{
-        switch (state) {
-        case MCAST_IDLE:
-                return "MCAST_IDLE";
-        case MCAST_JOIN_SENT:
-                return "MCAST_JOIN_SENT";
-        case MCAST_LEAVE_SENT:
-                return "MCAST_LEAVE_SENT";
-        case MCAST_RESP_READY:
-                return "MCAST_RESP_READY";
-        }
-        return "Invalid State";
-}
-
-static struct mcast_group *mcast_find(struct mlx4_ib_demux_ctx *ctx,
-                                      union ib_gid *mgid)
-{
-        struct rb_node *node = ctx->mcg_table.rb_node;
-        struct mcast_group *group;
-        int ret;
-
-        while (node) {
-                group = rb_entry(node, struct mcast_group, node);
-                ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid);
-                if (!ret)
-                        return group;
-
-                if (ret < 0)
-                        node = node->rb_left;
-                else
-                        node = node->rb_right;
-        }
-        return NULL;
-}
-
-static struct mcast_group *mcast_insert(struct mlx4_ib_demux_ctx *ctx,
-                                        struct mcast_group *group)
-{
-        struct rb_node **link = &ctx->mcg_table.rb_node;
-        struct rb_node *parent = NULL;
-        struct mcast_group *cur_group;
-        int ret;
-
-        while (*link) {
-                parent = *link;
-                cur_group = rb_entry(parent, struct mcast_group, node);
-
-                ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw,
-                             sizeof group->rec.mgid);
-                if (ret < 0)
-                        link = &(*link)->rb_left;
-                else if (ret > 0)
-                        link = &(*link)->rb_right;
-                else
-                        return cur_group;
-        }
-        rb_link_node(&group->node, parent, link);
-        rb_insert_color(&group->node, &ctx->mcg_table);
-        return NULL;
-}
-
-static int send_mad_to_wire(struct mlx4_ib_demux_ctx *ctx, struct ib_mad *mad)
-{
-        struct mlx4_ib_dev *dev = ctx->dev;
-        struct ib_ah_attr       ah_attr;
-
-        spin_lock(&dev->sm_lock);
-        if (!dev->sm_ah[ctx->port - 1]) {
-                /* port is not yet Active, sm_ah not ready */
-                spin_unlock(&dev->sm_lock);
-                return -EAGAIN;
-        }
-        mlx4_ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr);
-        spin_unlock(&dev->sm_lock);
-        return mlx4_ib_send_to_wire(dev, mlx4_master_func_num(dev->dev), ctx->port,
-                                    IB_QPT_GSI, 0, 1, IB_QP1_QKEY, &ah_attr, mad);
-}
-
-static int send_mad_to_slave(int slave, struct mlx4_ib_demux_ctx *ctx,
-                             struct ib_mad *mad)
-{
-        struct mlx4_ib_dev *dev = ctx->dev;
-        struct ib_mad_agent *agent = dev->send_agent[ctx->port - 1][1];
-        struct ib_wc wc;
-        struct ib_ah_attr ah_attr;
-
-        /* Our agent might not yet be registered when mads start to arrive */
-        if (!agent)
-                return -EAGAIN;
-
-        ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr);
-
-        if (ib_find_cached_pkey(&dev->ib_dev, ctx->port, IB_DEFAULT_PKEY_FULL, &wc.pkey_index))
-                return -EINVAL;
-        wc.sl = 0;
-        wc.dlid_path_bits = 0;
-        wc.port_num = ctx->port;
-        wc.slid = ah_attr.dlid;  /* opensm lid */
-        wc.src_qp = 1;
-        return mlx4_ib_send_to_slave(dev, slave, ctx->port, IB_QPT_GSI, &wc, NULL, mad);
-}
-
-static int send_join_to_wire(struct mcast_group *group, struct ib_sa_mad *sa_mad)
-{
-        struct ib_sa_mad mad;
-        struct ib_sa_mcmember_data *sa_mad_data = (struct ib_sa_mcmember_data *)&mad.data;
-        int ret;
-
-        /* we rely on a mad request as arrived from a VF */
-        memcpy(&mad, sa_mad, sizeof mad);
-
-        /* fix port GID to be the real one (slave 0) */
-        sa_mad_data->port_gid.global.interface_id = group->demux->guid_cache[0];
-
-        /* assign our own TID */
-        mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux);
-        group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */
-
-        ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad);
-        /* set timeout handler */
-        if (!ret) {
-                /* calls mlx4_ib_mcg_timeout_handler */
-                queue_delayed_work(group->demux->mcg_wq, &group->timeout_work,
-                                msecs_to_jiffies(MAD_TIMEOUT_MS));
-        }
-
-        return ret;
-}
-
-static int send_leave_to_wire(struct mcast_group *group, u8 join_state)
-{
-        struct ib_sa_mad mad;
-        struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data;
-        int ret;
-
-        memset(&mad, 0, sizeof mad);
-        mad.mad_hdr.base_version = 1;
-        mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
-        mad.mad_hdr.class_version = 2;
-        mad.mad_hdr.method = IB_SA_METHOD_DELETE;
-        mad.mad_hdr.status = cpu_to_be16(0);
-        mad.mad_hdr.class_specific = cpu_to_be16(0);
-        mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux);
-        group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */
-        mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
-        mad.mad_hdr.attr_mod = cpu_to_be32(0);
-        mad.sa_hdr.sm_key = 0x0;
-        mad.sa_hdr.attr_offset = cpu_to_be16(7);
-        mad.sa_hdr.comp_mask = IB_SA_MCMEMBER_REC_MGID |
-                IB_SA_MCMEMBER_REC_PORT_GID | IB_SA_MCMEMBER_REC_JOIN_STATE;
-
-        *sa_data = group->rec;
-        sa_data->scope_join_state = join_state;
-
-        ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad);
-        if (ret)
-                group->state = MCAST_IDLE;
-
-        /* set timeout handler */
-        if (!ret) {
-                /* calls mlx4_ib_mcg_timeout_handler */
-                queue_delayed_work(group->demux->mcg_wq, &group->timeout_work,
-                                msecs_to_jiffies(MAD_TIMEOUT_MS));
-        }
-
-        return ret;
-}
-
-static int send_reply_to_slave(int slave, struct mcast_group *group,
-                struct ib_sa_mad *req_sa_mad, u16 status)
-{
-        struct ib_sa_mad mad;
-        struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data;
-        struct ib_sa_mcmember_data *req_sa_data = (struct ib_sa_mcmember_data *)&req_sa_mad->data;
-        int ret;
-
-        memset(&mad, 0, sizeof mad);
-        mad.mad_hdr.base_version = 1;
-        mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM;
-        mad.mad_hdr.class_version = 2;
-        mad.mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
-        mad.mad_hdr.status = cpu_to_be16(status);
-        mad.mad_hdr.class_specific = cpu_to_be16(0);
-        mad.mad_hdr.tid = req_sa_mad->mad_hdr.tid;
-        *(u8 *)&mad.mad_hdr.tid = 0; /* resetting tid to 0 */
-        mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
-        mad.mad_hdr.attr_mod = cpu_to_be32(0);
-        mad.sa_hdr.sm_key = req_sa_mad->sa_hdr.sm_key;
-        mad.sa_hdr.attr_offset = cpu_to_be16(7);
-        mad.sa_hdr.comp_mask = 0; /* ignored on responses, see IBTA spec */
-
-        *sa_data = group->rec;
-
-        /* reconstruct VF's requested join_state and port_gid */
-        sa_data->scope_join_state &= 0xf0;
-        sa_data->scope_join_state |= (group->func[slave].join_state & 0x0f);
-        memcpy(&sa_data->port_gid, &req_sa_data->port_gid, sizeof req_sa_data->port_gid);
-
-        ret = send_mad_to_slave(slave, group->demux, (struct ib_mad *)&mad);
-        return ret;
-}
-
-static int check_selector(ib_sa_comp_mask comp_mask,
-                          ib_sa_comp_mask selector_mask,
-                          ib_sa_comp_mask value_mask,
-                          u8 src_value, u8 dst_value)
-{
-        int err;
-        u8 selector = dst_value >> 6;
-        dst_value &= 0x3f;
-        src_value &= 0x3f;
-
-        if (!(comp_mask & selector_mask) || !(comp_mask & value_mask))
-                return 0;
-
-        switch (selector) {
-        case IB_SA_GT:
-                err = (src_value <= dst_value);
-                break;
-        case IB_SA_LT:
-                err = (src_value >= dst_value);
-                break;
-        case IB_SA_EQ:
-                err = (src_value != dst_value);
-                break;
-        default:
-                err = 0;
-                break;
-        }
-
-        return err;
-}
-
-static u16 cmp_rec(struct ib_sa_mcmember_data *src,
-                   struct ib_sa_mcmember_data *dst, ib_sa_comp_mask comp_mask)
-{
-        /* src is group record, dst is request record */
-        /* MGID must already match */
-        /* Port_GID we always replace to our Port_GID, so it is a match */
-
-#define MAD_STATUS_REQ_INVALID 0x0200
-        if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey)
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid)
-                return MAD_STATUS_REQ_INVALID;
-        if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_MTU_SELECTOR,
-                                 IB_SA_MCMEMBER_REC_MTU,
-                                 src->mtusel_mtu, dst->mtusel_mtu))
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_TRAFFIC_CLASS &&
-            src->tclass != dst->tclass)
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey)
-                return MAD_STATUS_REQ_INVALID;
-        if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_RATE_SELECTOR,
-                                 IB_SA_MCMEMBER_REC_RATE,
-                                 src->ratesel_rate, dst->ratesel_rate))
-                return MAD_STATUS_REQ_INVALID;
-        if (check_selector(comp_mask,
-                                 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR,
-                                 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME,
-                                 src->lifetmsel_lifetm, dst->lifetmsel_lifetm))
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_SL &&
-                        (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0xf0000000) !=
-                        (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0xf0000000))
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_FLOW_LABEL &&
-                        (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x0fffff00) !=
-                        (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x0fffff00))
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_HOP_LIMIT &&
-                        (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x000000ff) !=
-                        (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x000000ff))
-                return MAD_STATUS_REQ_INVALID;
-        if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE &&
-                        (src->scope_join_state & 0xf0) !=
-                        (dst->scope_join_state & 0xf0))
-                return MAD_STATUS_REQ_INVALID;
-
-        /* join_state checked separately, proxy_join ignored */
-
-        return 0;
-}
-
-/* release group, return 1 if this was last release and group is destroyed
- * timout work is canceled sync */
-static int release_group(struct mcast_group *group, int from_timeout_handler)
-{
-        struct mlx4_ib_demux_ctx *ctx = group->demux;
-        int nzgroup;
-
-        mutex_lock(&ctx->mcg_table_lock);
-        mutex_lock(&group->lock);
-        if (atomic_dec_and_test(&group->refcount)) {
-                if (!from_timeout_handler) {
-                        if (group->state != MCAST_IDLE &&
-                            !cancel_delayed_work(&group->timeout_work)) {
-                                atomic_inc(&group->refcount);
-                                mutex_unlock(&group->lock);
-                                mutex_unlock(&ctx->mcg_table_lock);
-                                return 0;
-                        }
-                }
-
-                nzgroup = memcmp(&group->rec.mgid, &mgid0, sizeof mgid0);
-                if (nzgroup)
-                        del_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr);
-                if (!list_empty(&group->pending_list))
-                        mcg_warn_group(group, "releasing a group with non empty pending list\n");
-                if (nzgroup)
-                        rb_erase(&group->node, &ctx->mcg_table);
-                list_del_init(&group->mgid0_list);
-                mutex_unlock(&group->lock);
-                mutex_unlock(&ctx->mcg_table_lock);
-                kfree(group);
-                return 1;
-        } else {
-                mutex_unlock(&group->lock);
-                mutex_unlock(&ctx->mcg_table_lock);
-        }
-        return 0;
-}
-
-static void adjust_membership(struct mcast_group *group, u8 join_state, int inc)
-{
-        int i;
-
-        for (i = 0; i < 3; i++, join_state >>= 1)
-                if (join_state & 0x1)
-                        group->members[i] += inc;
-}
-
-static u8 get_leave_state(struct mcast_group *group)
-{
-        u8 leave_state = 0;
-        int i;
-
-        for (i = 0; i < 3; i++)
-                if (!group->members[i])
-                        leave_state |= (1 << i);
-
-        return leave_state & (group->rec.scope_join_state & 7);
-}
-
-static int join_group(struct mcast_group *group, int slave, u8 join_mask)
-{
-        int ret = 0;
-        u8 join_state;
-
-        /* remove bits that slave is already member of, and adjust */
-        join_state = join_mask & (~group->func[slave].join_state);
-        adjust_membership(group, join_state, 1);
-        group->func[slave].join_state |= join_state;
-        if (group->func[slave].state != MCAST_MEMBER && join_state) {
-                group->func[slave].state = MCAST_MEMBER;
-                ret = 1;
-        }
-        return ret;
-}
-
-static int leave_group(struct mcast_group *group, int slave, u8 leave_state)
-{
-        int ret = 0;
-
-        adjust_membership(group, leave_state, -1);
-        group->func[slave].join_state &= ~leave_state;
-        if (!group->func[slave].join_state) {
-                group->func[slave].state = MCAST_NOT_MEMBER;
-                ret = 1;
-        }
-        return ret;
-}
-
-static int check_leave(struct mcast_group *group, int slave, u8 leave_mask)
-{
-        if (group->func[slave].state != MCAST_MEMBER)
-                return MAD_STATUS_REQ_INVALID;
-
-        /* make sure we're not deleting unset bits */
-        if (~group->func[slave].join_state & leave_mask)
-                return MAD_STATUS_REQ_INVALID;
-
-        if (!leave_mask)
-                return MAD_STATUS_REQ_INVALID;
-
-        return 0;
-}
-
-static void mlx4_ib_mcg_timeout_handler(struct work_struct *work)
-{
-        struct delayed_work *delay = to_delayed_work(work);
-        struct mcast_group *group;
-        struct mcast_req *req = NULL;
-
-        group = container_of(delay, typeof(*group), timeout_work);
-
-        mutex_lock(&group->lock);
-        if (group->state == MCAST_JOIN_SENT) {
-                if (!list_empty(&group->pending_list)) {
-                        req = list_first_entry(&group->pending_list, struct mcast_req, group_list);
-                        list_del(&req->group_list);
-                        list_del(&req->func_list);
-                        --group->func[req->func].num_pend_reqs;
-                        mutex_unlock(&group->lock);
-                        kfree(req);
-                        if (memcmp(&group->rec.mgid, &mgid0, sizeof mgid0)) {
-                                if (release_group(group, 1))
-                                        return;
-                        } else {
-                                kfree(group);
-                                return;
-                        }
-                        mutex_lock(&group->lock);
-                } else
-                        mcg_warn_group(group, "DRIVER BUG\n");
-        } else if (group->state == MCAST_LEAVE_SENT) {
-                if (group->rec.scope_join_state & 7)
-                        group->rec.scope_join_state &= 0xf8;
-                group->state = MCAST_IDLE;
-                mutex_unlock(&group->lock);
-                if (release_group(group, 1))
-                        return;
-                mutex_lock(&group->lock);
-        } else
-                mcg_warn_group(group, "invalid state %s\n", get_state_string(group->state));
-        group->state = MCAST_IDLE;
-        atomic_inc(&group->refcount);
-        if (!queue_work(group->demux->mcg_wq, &group->work))
-                safe_atomic_dec(&group->refcount);
-
-        mutex_unlock(&group->lock);
-}
-
-static int handle_leave_req(struct mcast_group *group, u8 leave_mask,
-                            struct mcast_req *req)
-{
-        u16 status;
-
-        if (req->clean)
-                leave_mask = group->func[req->func].join_state;
-
-        status = check_leave(group, req->func, leave_mask);
-        if (!status)
-                leave_group(group, req->func, leave_mask);
-
-        if (!req->clean)
-                send_reply_to_slave(req->func, group, &req->sa_mad, status);
-        --group->func[req->func].num_pend_reqs;
-        list_del(&req->group_list);
-        list_del(&req->func_list);
-        kfree(req);
-        return 1;
-}
-
-static int handle_join_req(struct mcast_group *group, u8 join_mask,
-                           struct mcast_req *req)
-{
-        u8 group_join_state = group->rec.scope_join_state & 7;
-        int ref = 0;
-        u16 status;
-        struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data;
-
-        if (join_mask == (group_join_state & join_mask)) {
-                /* port's membership need not change */
-                status = cmp_rec(&group->rec, sa_data, req->sa_mad.sa_hdr.comp_mask);
-                if (!status)
-                        join_group(group, req->func, join_mask);
-
-                --group->func[req->func].num_pend_reqs;
-                send_reply_to_slave(req->func, group, &req->sa_mad, status);
-                list_del(&req->group_list);
-                list_del(&req->func_list);
-                kfree(req);
-                ++ref;
-        } else {
-                /* port's membership needs to be updated */
-                group->prev_state = group->state;
-                if (send_join_to_wire(group, &req->sa_mad)) {
-                        --group->func[req->func].num_pend_reqs;
-                        list_del(&req->group_list);
-                        list_del(&req->func_list);
-                        kfree(req);
-                        ref = 1;
-                        group->state = group->prev_state;
-                } else
-                        group->state = MCAST_JOIN_SENT;
-        }
-
-        return ref;
-}
-
-static void mlx4_ib_mcg_work_handler(struct work_struct *work)
-{
-        struct mcast_group *group;
-        struct mcast_req *req = NULL;
-        struct ib_sa_mcmember_data *sa_data;
-        u8 req_join_state;
-        int rc = 1; /* release_count - this is for the scheduled work */
-        u16 status;
-        u8 method;
-
-        group = container_of(work, typeof(*group), work);
-
-        mutex_lock(&group->lock);
-
-        /* First, let's see if a response from SM is waiting regarding this group.
-         * If so, we need to update the group's REC. If this is a bad response, we
-         * may need to send a bad response to a VF waiting for it. If VF is waiting
-         * and this is a good response, the VF will be answered later in this func. */
-        if (group->state == MCAST_RESP_READY) {
-                /* cancels mlx4_ib_mcg_timeout_handler */
-                cancel_delayed_work(&group->timeout_work);
-                status = be16_to_cpu(group->response_sa_mad.mad_hdr.status);
-                method = group->response_sa_mad.mad_hdr.method;
-                if (group->last_req_tid != group->response_sa_mad.mad_hdr.tid) {
-                        mcg_warn_group(group, "Got MAD response to existing MGID but wrong TID, dropping. Resp TID=%llx, group TID=%llx\n",
-                                be64_to_cpu(group->response_sa_mad.mad_hdr.tid),
-                                be64_to_cpu(group->last_req_tid));
-                        group->state = group->prev_state;
-                        goto process_requests;
-                }
-                if (status) {
-                        if (!list_empty(&group->pending_list))
-                                req = list_first_entry(&group->pending_list,
-                                                struct mcast_req, group_list);
-                        if ((method == IB_MGMT_METHOD_GET_RESP)) {
-                                        if (req) {
-                                                send_reply_to_slave(req->func, group, &req->sa_mad, status);
-                                                --group->func[req->func].num_pend_reqs;
-                                                list_del(&req->group_list);
-                                                list_del(&req->func_list);
-                                                kfree(req);
-                                                ++rc;
-                                        } else
-                                                mcg_warn_group(group, "no request for failed join\n");
-                        } else if (method == IB_SA_METHOD_DELETE_RESP && group->demux->flushing)
-                                ++rc;
-                } else {
-                        u8 resp_join_state;
-                        u8 cur_join_state;
-
-                        resp_join_state = ((struct ib_sa_mcmember_data *)
-                                                group->response_sa_mad.data)->scope_join_state & 7;
-                        cur_join_state = group->rec.scope_join_state & 7;
-
-                        if (method == IB_MGMT_METHOD_GET_RESP) {
-                                /* successfull join */
-                                if (!cur_join_state && resp_join_state)
-                                        --rc;
-                        } else if (!resp_join_state)
-                                        ++rc;
-                        memcpy(&group->rec, group->response_sa_mad.data, sizeof group->rec);
-                }
-                group->state = MCAST_IDLE;
-        }
-
-process_requests:
-        /* We should now go over pending join/leave requests, as long as we are idle. */
-        while (!list_empty(&group->pending_list) && group->state == MCAST_IDLE) {
-                req = list_first_entry(&group->pending_list, struct mcast_req,
-                                       group_list);
-                sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data;
-                req_join_state = sa_data->scope_join_state & 0x7;
-
-                /* For a leave request, we will immediately answer the VF, and
-                 * update our internal counters. The actual leave will be sent
-                 * to SM later, if at all needed. We dequeue the request now. */
-                if (req->sa_mad.mad_hdr.method == IB_SA_METHOD_DELETE)
-                        rc += handle_leave_req(group, req_join_state, req);
-                else
-                        rc += handle_join_req(group, req_join_state, req);
-        }
-
-        /* Handle leaves */
-        if (group->state == MCAST_IDLE) {
-                req_join_state = get_leave_state(group);
-                if (req_join_state) {
-                        group->rec.scope_join_state &= ~req_join_state;
-                        group->prev_state = group->state;
-                        if (send_leave_to_wire(group, req_join_state)) {
-                                group->state = group->prev_state;
-                                ++rc;
-                        } else
-                                group->state = MCAST_LEAVE_SENT;
-                }
-        }
-
-        if (!list_empty(&group->pending_list) && group->state == MCAST_IDLE)
-                goto process_requests;
-        mutex_unlock(&group->lock);
-
-        while (rc--)
-                release_group(group, 0);
-}
-
-static struct mcast_group *search_relocate_mgid0_group(struct mlx4_ib_demux_ctx *ctx,
-                                                       __be64 tid,
-                                                       union ib_gid *new_mgid)
-{
-        struct mcast_group *group = NULL, *cur_group;
-        struct mcast_req *req;
-        struct list_head *pos;
-        struct list_head *n;
-
-        mutex_lock(&ctx->mcg_table_lock);
-        list_for_each_safe(pos, n, &ctx->mcg_mgid0_list) {
-                group = list_entry(pos, struct mcast_group, mgid0_list);
-                mutex_lock(&group->lock);
-                if (group->last_req_tid == tid) {
-                        if (memcmp(new_mgid, &mgid0, sizeof mgid0)) {
-                                group->rec.mgid = *new_mgid;
-                                sprintf(group->name, "%016llx%016llx",
-                                                be64_to_cpu(group->rec.mgid.global.subnet_prefix),
-                                                be64_to_cpu(group->rec.mgid.global.interface_id));
-                                list_del_init(&group->mgid0_list);
-                                cur_group = mcast_insert(ctx, group);
-                                if (cur_group) {
-                                        /* A race between our code and SM. Silently cleaning the new one */
-                                        req = list_first_entry(&group->pending_list,
-                                                               struct mcast_req, group_list);
-                                        --group->func[req->func].num_pend_reqs;
-                                        list_del(&req->group_list);
-                                        list_del(&req->func_list);
-                                        kfree(req);
-                                        mutex_unlock(&group->lock);
-                                        mutex_unlock(&ctx->mcg_table_lock);
-                                        release_group(group, 0);
-                                        return NULL;
-                                }
-
-                                atomic_inc(&group->refcount);
-                                add_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr);
-                                mutex_unlock(&group->lock);
-                                mutex_unlock(&ctx->mcg_table_lock);
-                                return group;
-                        } else {
-                                struct mcast_req *tmp1, *tmp2;
-
-                                list_del(&group->mgid0_list);
-                                if (!list_empty(&group->pending_list) && group->state != MCAST_IDLE)
-                                        cancel_delayed_work_sync(&group->timeout_work);
-
-                                list_for_each_entry_safe(tmp1, tmp2, &group->pending_list, group_list) {
-                                        list_del(&tmp1->group_list);
-                                        kfree(tmp1);
-                                }
-                                mutex_unlock(&group->lock);
-                                mutex_unlock(&ctx->mcg_table_lock);
-                                kfree(group);
-                                return NULL;
-                        }
-                }
-                mutex_unlock(&group->lock);
-        }
-        mutex_unlock(&ctx->mcg_table_lock);
-
-        return NULL;
-}
-
-static ssize_t sysfs_show_group(struct device *dev,
-                struct device_attribute *attr, char *buf);
-
-static struct mcast_group *acquire_group(struct mlx4_ib_demux_ctx *ctx,
-                                         union ib_gid *mgid, int create,
-                                         gfp_t gfp_mask)
-{
-        struct mcast_group *group, *cur_group;
-        int is_mgid0;
-        int i;
-
-        is_mgid0 = !memcmp(&mgid0, mgid, sizeof mgid0);
-        if (!is_mgid0) {
-                group = mcast_find(ctx, mgid);
-                if (group)
-                        goto found;
-        }
-
-        if (!create)
-                return ERR_PTR(-ENOENT);
-
-        group = kzalloc(sizeof *group, gfp_mask);
-        if (!group)
-                return ERR_PTR(-ENOMEM);
-
-        group->demux = ctx;
-        group->rec.mgid = *mgid;
-        INIT_LIST_HEAD(&group->pending_list);
-        INIT_LIST_HEAD(&group->mgid0_list);
-        for (i = 0; i < MAX_VFS; ++i)
-                INIT_LIST_HEAD(&group->func[i].pending);
-        INIT_WORK(&group->work, mlx4_ib_mcg_work_handler);
-        INIT_DELAYED_WORK(&group->timeout_work, mlx4_ib_mcg_timeout_handler);
-        mutex_init(&group->lock);
-        sprintf(group->name, "%016llx%016llx",
-                        be64_to_cpu(group->rec.mgid.global.subnet_prefix),
-                        be64_to_cpu(group->rec.mgid.global.interface_id));
-        sysfs_attr_init(&group->dentry.attr);
-        group->dentry.show = sysfs_show_group;
-        group->dentry.store = NULL;
-        group->dentry.attr.name = group->name;
-        group->dentry.attr.mode = 0400;
-        group->state = MCAST_IDLE;
-
-        if (is_mgid0) {
-                list_add(&group->mgid0_list, &ctx->mcg_mgid0_list);
-                goto found;
-        }
-
-        cur_group = mcast_insert(ctx, group);
-        if (cur_group) {
-                mcg_warn("group just showed up %s - confused\n", cur_group->name);
-                kfree(group);
-                return ERR_PTR(-EINVAL);
-        }
-
-        add_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr);
-
-found:
-        atomic_inc(&group->refcount);
-        return group;
-}
-
-static void queue_req(struct mcast_req *req)
-{
-        struct mcast_group *group = req->group;
-
-        atomic_inc(&group->refcount); /* for the request */
-        atomic_inc(&group->refcount); /* for scheduling the work */
-        list_add_tail(&req->group_list, &group->pending_list);
-        list_add_tail(&req->func_list, &group->func[req->func].pending);
-        /* calls mlx4_ib_mcg_work_handler */
-        if (!queue_work(group->demux->mcg_wq, &group->work))
-                safe_atomic_dec(&group->refcount);
-}
-
-int mlx4_ib_mcg_demux_handler(struct ib_device *ibdev, int port, int slave,
-                              struct ib_sa_mad *mad)
-{
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)mad->data;
-        struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1];
-        struct mcast_group *group;
-
-        switch (mad->mad_hdr.method) {
-        case IB_MGMT_METHOD_GET_RESP:
-        case IB_SA_METHOD_DELETE_RESP:
-                mutex_lock(&ctx->mcg_table_lock);
-                group = acquire_group(ctx, &rec->mgid, 0, GFP_KERNEL);
-                mutex_unlock(&ctx->mcg_table_lock);
-                if (IS_ERR(group)) {
-                        if (mad->mad_hdr.method == IB_MGMT_METHOD_GET_RESP) {
-                                __be64 tid = mad->mad_hdr.tid;
-                                *(u8 *)(&tid) = (u8)slave; /* in group we kept the modified TID */
-                                group = search_relocate_mgid0_group(ctx, tid, &rec->mgid);
-                        } else
-                                group = NULL;
-                }
-
-                if (!group)
-                        return 1;
-
-                mutex_lock(&group->lock);
-                group->response_sa_mad = *mad;
-                group->prev_state = group->state;
-                group->state = MCAST_RESP_READY;
-                /* calls mlx4_ib_mcg_work_handler */
-                atomic_inc(&group->refcount);
-                if (!queue_work(ctx->mcg_wq, &group->work))
-                        safe_atomic_dec(&group->refcount);
-                mutex_unlock(&group->lock);
-                release_group(group, 0);
-                return 1; /* consumed */
-        case IB_MGMT_METHOD_SET:
-        case IB_SA_METHOD_GET_TABLE:
-        case IB_SA_METHOD_GET_TABLE_RESP:
-        case IB_SA_METHOD_DELETE:
-                return 0; /* not consumed, pass-through to guest over tunnel */
-        default:
-                mcg_warn("In demux, port %d: unexpected MCMember method: 0x%x, dropping\n",
-                        port, mad->mad_hdr.method);
-                return 1; /* consumed */
-        }
-}
-
-int mlx4_ib_mcg_multiplex_handler(struct ib_device *ibdev, int port,
-                                  int slave, struct ib_sa_mad *sa_mad)
-{
-        struct mlx4_ib_dev *dev = to_mdev(ibdev);
-        struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)sa_mad->data;
-        struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1];
-        struct mcast_group *group;
-        struct mcast_req *req;
-        int may_create = 0;
-
-        if (ctx->flushing)
-                return -EAGAIN;
-
-        switch (sa_mad->mad_hdr.method) {
-        case IB_MGMT_METHOD_SET:
-                may_create = 1;
-        case IB_SA_METHOD_DELETE:
-                req = kzalloc(sizeof *req, GFP_KERNEL);
-                if (!req)
-                        return -ENOMEM;
-
-                req->func = slave;
-                req->sa_mad = *sa_mad;
-
-                mutex_lock(&ctx->mcg_table_lock);
-                group = acquire_group(ctx, &rec->mgid, may_create, GFP_KERNEL);
-                mutex_unlock(&ctx->mcg_table_lock);
-                if (IS_ERR(group)) {
-                        kfree(req);
-                        return PTR_ERR(group);
-                }
-                mutex_lock(&group->lock);
-                if (group->func[slave].num_pend_reqs > MAX_PEND_REQS_PER_FUNC) {
-                        mutex_unlock(&group->lock);
-                        mcg_warn_group(group, "Port %d, Func %d has too many pending requests (%d), dropping\n",
-                                       port, slave, MAX_PEND_REQS_PER_FUNC);
-                        release_group(group, 0);
-                        kfree(req);
-                        return -ENOMEM;
-                }
-                ++group->func[slave].num_pend_reqs;
-                req->group = group;
-                queue_req(req);
-                mutex_unlock(&group->lock);
-                release_group(group, 0);
-                return 1; /* consumed */
-        case IB_SA_METHOD_GET_TABLE:
-        case IB_MGMT_METHOD_GET_RESP:
-        case IB_SA_METHOD_GET_TABLE_RESP:
-        case IB_SA_METHOD_DELETE_RESP:
-                return 0; /* not consumed, pass-through */
-        default:
-                mcg_warn("In multiplex, port %d, func %d: unexpected MCMember method: 0x%x, dropping\n",
-                        port, slave, sa_mad->mad_hdr.method);
-                return 1; /* consumed */
-        }
-}
-
-static ssize_t sysfs_show_group(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct mcast_group *group =
-                container_of(attr, struct mcast_group, dentry);
-        struct mcast_req *req = NULL;
-        char pending_str[40];
-        char state_str[40];
-        ssize_t len = 0;
-        int f;
-
-        if (group->state == MCAST_IDLE)
-                sprintf(state_str, "%s", get_state_string(group->state));
-        else
-                sprintf(state_str, "%s(TID=0x%llx)",
-                                get_state_string(group->state),
-                                be64_to_cpu(group->last_req_tid));
-        if (list_empty(&group->pending_list)) {
-                sprintf(pending_str, "No");
-        } else {
-                req = list_first_entry(&group->pending_list, struct mcast_req, group_list);
-                sprintf(pending_str, "Yes(TID=0x%llx)",
-                                be64_to_cpu(req->sa_mad.mad_hdr.tid));
-        }
-        len += sprintf(buf + len, "%1d [%02d,%02d,%02d] %4d %4s %5s     ",
-                        group->rec.scope_join_state & 0xf,
-                        group->members[2], group->members[1], group->members[0],
-                        atomic_read(&group->refcount),
-                        pending_str,
-                        state_str);
-        for (f = 0; f < MAX_VFS; ++f)
-                if (group->func[f].state == MCAST_MEMBER)
-                        len += sprintf(buf + len, "%d[%1x] ",
-                                        f, group->func[f].join_state);
-
-        len += sprintf(buf + len, "\t\t(%4hx %4x %2x %2x %2x %2x %2x "
-                "%4x %4x %2x %2x)\n",
-                be16_to_cpu(group->rec.pkey),
-                be32_to_cpu(group->rec.qkey),
-                (group->rec.mtusel_mtu & 0xc0) >> 6,
-                group->rec.mtusel_mtu & 0x3f,
-                group->rec.tclass,
-                (group->rec.ratesel_rate & 0xc0) >> 6,
-                group->rec.ratesel_rate & 0x3f,
-                (be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0xf0000000) >> 28,
-                (be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0x0fffff00) >> 8,
-                be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0x000000ff,
-                group->rec.proxy_join);
-
-        return len;
-}
-
-int mlx4_ib_mcg_port_init(struct mlx4_ib_demux_ctx *ctx)
-{
-        char name[20];
-
-        atomic_set(&ctx->tid, 0);
-        sprintf(name, "mlx4_ib_mcg%d", ctx->port);
-        ctx->mcg_wq = create_singlethread_workqueue(name);
-        if (!ctx->mcg_wq)
-                return -ENOMEM;
-
-        mutex_init(&ctx->mcg_table_lock);
-        ctx->mcg_table = RB_ROOT;
-        INIT_LIST_HEAD(&ctx->mcg_mgid0_list);
-        ctx->flushing = 0;
-
-        return 0;
-}
-
-static void force_clean_group(struct mcast_group *group)
-{
-        struct mcast_req *req, *tmp
-                ;
-        list_for_each_entry_safe(req, tmp, &group->pending_list, group_list) {
-                list_del(&req->group_list);
-                kfree(req);
-        }
-        del_sysfs_port_mcg_attr(group->demux->dev, group->demux->port, &group->dentry.attr);
-        rb_erase(&group->node, &group->demux->mcg_table);
-        kfree(group);
-}
-
-static void _mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq)
-{
-        int i;
-        struct rb_node *p;
-        struct mcast_group *group;
-        unsigned long end;
-        int count;
-
-        for (i = 0; i < MAX_VFS; ++i)
-                clean_vf_mcast(ctx, i);
-
-        end = jiffies + msecs_to_jiffies(MAD_TIMEOUT_MS + 3000);
-        do {
-                count = 0;
-                mutex_lock(&ctx->mcg_table_lock);
-                for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p))
-                        ++count;
-                mutex_unlock(&ctx->mcg_table_lock);
-                if (!count)
-                        break;
-
-                msleep(1);
-        } while (time_after(end, jiffies));
-
-        flush_workqueue(ctx->mcg_wq);
-        if (destroy_wq)
-                destroy_workqueue(ctx->mcg_wq);
-
-        mutex_lock(&ctx->mcg_table_lock);
-        while ((p = rb_first(&ctx->mcg_table)) != NULL) {
-                group = rb_entry(p, struct mcast_group, node);
-                if (atomic_read(&group->refcount))
-                        mcg_warn_group(group, "group refcount %d!!! (pointer %p)\n", atomic_read(&group->refcount), group);
-
-                force_clean_group(group);
-        }
-        mutex_unlock(&ctx->mcg_table_lock);
-}
-
-struct clean_work {
-        struct work_struct work;
-        struct mlx4_ib_demux_ctx *ctx;
-        int destroy_wq;
-};
-
-static void mcg_clean_task(struct work_struct *work)
-{
-        struct clean_work *cw = container_of(work, struct clean_work, work);
-
-        _mlx4_ib_mcg_port_cleanup(cw->ctx, cw->destroy_wq);
-        cw->ctx->flushing = 0;
-        kfree(cw);
-}
-
-void mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq)
-{
-        struct clean_work *work;
-
-        if (ctx->flushing)
-                return;
-
-        ctx->flushing = 1;
-
-        if (destroy_wq) {
-                _mlx4_ib_mcg_port_cleanup(ctx, destroy_wq);
-                ctx->flushing = 0;
-                return;
-        }
-
-        work = kmalloc(sizeof *work, GFP_KERNEL);
-        if (!work) {
-                ctx->flushing = 0;
-                mcg_warn("failed allocating work for cleanup\n");
-                return;
-        }
-
-        work->ctx = ctx;
-        work->destroy_wq = destroy_wq;
-        INIT_WORK(&work->work, mcg_clean_task);
-        queue_work(clean_wq, &work->work);
-}
-
-static void build_leave_mad(struct mcast_req *req)
-{
-        struct ib_sa_mad *mad = &req->sa_mad;
-
-        mad->mad_hdr.method = IB_SA_METHOD_DELETE;
-}
-
-
-static void clear_pending_reqs(struct mcast_group *group, int vf)
-{
-        struct mcast_req *req, *tmp, *group_first = NULL;
-        int clear;
-        int pend = 0;
-
-        if (!list_empty(&group->pending_list))
-                group_first = list_first_entry(&group->pending_list, struct mcast_req, group_list);
-
-        list_for_each_entry_safe(req, tmp, &group->func[vf].pending, func_list) {
-                clear = 1;
-                if (group_first == req &&
-                    (group->state == MCAST_JOIN_SENT ||
-                     group->state == MCAST_LEAVE_SENT)) {
-                        clear = cancel_delayed_work(&group->timeout_work);
-                        pend = !clear;
-                        group->state = MCAST_IDLE;
-                }
-                if (clear) {
-                        --group->func[vf].num_pend_reqs;
-                        list_del(&req->group_list);
-                        list_del(&req->func_list);
-                        kfree(req);
-                        atomic_dec(&group->refcount);
-                }
-        }
-
-        if (!pend && (!list_empty(&group->func[vf].pending) || group->func[vf].num_pend_reqs)) {
-                mcg_warn_group(group, "DRIVER BUG: list_empty %d, num_pend_reqs %d\n",
-                               list_empty(&group->func[vf].pending), group->func[vf].num_pend_reqs);
-        }
-}
-
-static int push_deleteing_req(struct mcast_group *group, int slave)
-{
-        struct mcast_req *req;
-        struct mcast_req *pend_req;
-
-        if (!group->func[slave].join_state)
-                return 0;
-
-        req = kzalloc(sizeof *req, GFP_KERNEL);
-        if (!req) {
-                mcg_warn_group(group, "failed allocation - may leave stall groups\n");
-                return -ENOMEM;
-        }
-
-        if (!list_empty(&group->func[slave].pending)) {
-                pend_req = list_entry(group->func[slave].pending.prev, struct mcast_req, group_list);
-                if (pend_req->clean) {
-                        kfree(req);
-                        return 0;
-                }
-        }
-
-        req->clean = 1;
-        req->func = slave;
-        req->group = group;
-        ++group->func[slave].num_pend_reqs;
-        build_leave_mad(req);
-        queue_req(req);
-        return 0;
-}
-
-void clean_vf_mcast(struct mlx4_ib_demux_ctx *ctx, int slave)
-{
-        struct mcast_group *group;
-        struct rb_node *p;
-
-        mutex_lock(&ctx->mcg_table_lock);
-        for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p)) {
-                group = rb_entry(p, struct mcast_group, node);
-                mutex_lock(&group->lock);
-                if (atomic_read(&group->refcount)) {
-                        /* clear pending requests of this VF */
-                        clear_pending_reqs(group, slave);
-                        push_deleteing_req(group, slave);
-                }
-                mutex_unlock(&group->lock);
-        }
-        mutex_unlock(&ctx->mcg_table_lock);
-}
-
-
-int mlx4_ib_mcg_init(void)
-{
-        clean_wq = create_singlethread_workqueue("mlx4_ib_mcg");
-        if (!clean_wq)
-                return -ENOMEM;
-
-        return 0;
-}
-
-void mlx4_ib_mcg_destroy(void)
-{
-        destroy_workqueue(clean_wq);
-}
diff --git a/drivers/infiniband/hw/mlx4/mlx4_ib.h b/drivers/infiniband/hw/mlx4/mlx4_ib.h
index dcd845bc30f..e4bf2cff866 100644
--- a/drivers/infiniband/hw/mlx4/mlx4_ib.h
+++ b/drivers/infiniband/hw/mlx4/mlx4_ib.h
@@ -37,37 +37,13 @@
 #include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
-#include <linux/idr.h>
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_umem.h>
-#include <rdma/ib_mad.h>
-#include <rdma/ib_sa.h>
 
 #include <linux/mlx4/device.h>
 #include <linux/mlx4/doorbell.h>
 
-#define MLX4_IB_DRV_NAME        "mlx4_ib"
-
-#ifdef pr_fmt
-#undef pr_fmt
-#endif
-#define pr_fmt(fmt)     "<" MLX4_IB_DRV_NAME "> %s: " fmt, __func__
-
-#define mlx4_ib_warn(ibdev, format, arg...) \
-        dev_warn((ibdev)->dma_device, MLX4_IB_DRV_NAME ": " format, ## arg)
-
-enum {
-        MLX4_IB_SQ_MIN_WQE_SHIFT = 6,
-        MLX4_IB_MAX_HEADROOM     = 2048
-};
-
-#define MLX4_IB_SQ_HEADROOM(shift)      ((MLX4_IB_MAX_HEADROOM >> (shift)) + 1)
-#define MLX4_IB_SQ_MAX_SPARE            (MLX4_IB_SQ_HEADROOM(MLX4_IB_SQ_MIN_WQE_SHIFT))
-
-/*module param to indicate if SM assigns the alias_GUID*/
-extern int mlx4_ib_sm_guid_assign;
-
 struct mlx4_ib_ucontext {
         struct ib_ucontext      ibucontext;
         struct mlx4_uar         uar;
@@ -80,17 +56,9 @@ struct mlx4_ib_pd {
         u32                     pdn;
 };
 
-struct mlx4_ib_xrcd {
-        struct ib_xrcd          ibxrcd;
-        u32                     xrcdn;
-        struct ib_pd           *pd;
-        struct ib_cq           *cq;
-};
-
 struct mlx4_ib_cq_buf {
         struct mlx4_buf         buf;
         struct mlx4_mtt         mtt;
-        int                     entry_size;
 };
 
 struct mlx4_ib_cq_resize {
@@ -140,10 +108,8 @@ struct mlx4_ib_wq {
 };
 
 enum mlx4_ib_qp_flags {
-        MLX4_IB_QP_LSO = IB_QP_CREATE_IPOIB_UD_LSO,
-        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK = IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK,
-        MLX4_IB_SRIOV_TUNNEL_QP = 1 << 30,
-        MLX4_IB_SRIOV_SQP = 1 << 31,
+        MLX4_IB_QP_LSO                          = 1 << 0,
+        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK     = 1 << 1,
 };
 
 struct mlx4_ib_gid_entry {
@@ -153,80 +119,6 @@ struct mlx4_ib_gid_entry {
         u8                      port;
 };
 
-enum mlx4_ib_qp_type {
-        /*
-         * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
-         * here (and in that order) since the MAD layer uses them as
-         * indices into a 2-entry table.
-         */
-        MLX4_IB_QPT_SMI = IB_QPT_SMI,
-        MLX4_IB_QPT_GSI = IB_QPT_GSI,
-
-        MLX4_IB_QPT_RC = IB_QPT_RC,
-        MLX4_IB_QPT_UC = IB_QPT_UC,
-        MLX4_IB_QPT_UD = IB_QPT_UD,
-        MLX4_IB_QPT_RAW_IPV6 = IB_QPT_RAW_IPV6,
-        MLX4_IB_QPT_RAW_ETHERTYPE = IB_QPT_RAW_ETHERTYPE,
-        MLX4_IB_QPT_RAW_PACKET = IB_QPT_RAW_PACKET,
-        MLX4_IB_QPT_XRC_INI = IB_QPT_XRC_INI,
-        MLX4_IB_QPT_XRC_TGT = IB_QPT_XRC_TGT,
-
-        MLX4_IB_QPT_PROXY_SMI_OWNER     = 1 << 16,
-        MLX4_IB_QPT_PROXY_SMI           = 1 << 17,
-        MLX4_IB_QPT_PROXY_GSI           = 1 << 18,
-        MLX4_IB_QPT_TUN_SMI_OWNER       = 1 << 19,
-        MLX4_IB_QPT_TUN_SMI             = 1 << 20,
-        MLX4_IB_QPT_TUN_GSI             = 1 << 21,
-};
-
-#define MLX4_IB_QPT_ANY_SRIOV   (MLX4_IB_QPT_PROXY_SMI_OWNER | \
-        MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI | MLX4_IB_QPT_TUN_SMI_OWNER | \
-        MLX4_IB_QPT_TUN_SMI | MLX4_IB_QPT_TUN_GSI)
-
-enum mlx4_ib_mad_ifc_flags {
-        MLX4_MAD_IFC_IGNORE_MKEY        = 1,
-        MLX4_MAD_IFC_IGNORE_BKEY        = 2,
-        MLX4_MAD_IFC_IGNORE_KEYS        = (MLX4_MAD_IFC_IGNORE_MKEY |
-                                           MLX4_MAD_IFC_IGNORE_BKEY),
-        MLX4_MAD_IFC_NET_VIEW           = 4,
-};
-
-enum {
-        MLX4_NUM_TUNNEL_BUFS            = 256,
-};
-
-struct mlx4_ib_tunnel_header {
-        struct mlx4_av av;
-        __be32 remote_qpn;
-        __be32 qkey;
-        __be16 vlan;
-        u8 mac[6];
-        __be16 pkey_index;
-        u8 reserved[6];
-};
-
-struct mlx4_ib_buf {
-        void *addr;
-        dma_addr_t map;
-};
-
-struct mlx4_rcv_tunnel_hdr {
-        __be32 flags_src_qp; /* flags[6:5] is defined for VLANs:
-                              * 0x0 - no vlan was in the packet
-                              * 0x01 - C-VLAN was in the packet */
-        u8 g_ml_path; /* gid bit stands for ipv6/4 header in RoCE */
-        u8 reserved;
-        __be16 pkey_index;
-        __be16 sl_vid;
-        __be16 slid_mac_47_32;
-        __be32 mac_31_0;
-};
-
-struct mlx4_ib_proxy_sqp_hdr {
-        struct ib_grh grh;
-        struct mlx4_rcv_tunnel_hdr tun;
-}  __packed;
-
 struct mlx4_ib_qp {
         struct ib_qp            ibqp;
         struct mlx4_qp          mqp;
@@ -242,12 +134,10 @@ struct mlx4_ib_qp {
         int                     sq_spare_wqes;
         struct mlx4_ib_wq       sq;
 
-        enum mlx4_ib_qp_type    mlx4_ib_qp_type;
         struct ib_umem         *umem;
         struct mlx4_mtt         mtt;
         int                     buf_size;
         struct mutex            mutex;
-        u16                     xrcdn;
         u32                     flags;
         u8                      port;
         u8                      alt_port;
@@ -257,9 +147,6 @@ struct mlx4_ib_qp {
         u8                      state;
         int                     mlx_type;
         struct list_head        gid_list;
-        struct list_head        steering_rules;
-        struct mlx4_ib_buf      *sqp_proxy_rcv;
-
 };
 
 struct mlx4_ib_srq {
@@ -282,138 +169,6 @@ struct mlx4_ib_ah {
         union mlx4_ext_av       av;
 };
 
-/****************************************/
-/* alias guid support */
-/****************************************/
-#define NUM_PORT_ALIAS_GUID             2
-#define NUM_ALIAS_GUID_IN_REC           8
-#define NUM_ALIAS_GUID_REC_IN_PORT      16
-#define GUID_REC_SIZE                   8
-#define NUM_ALIAS_GUID_PER_PORT         128
-#define MLX4_NOT_SET_GUID               (0x00LL)
-#define MLX4_GUID_FOR_DELETE_VAL        (~(0x00LL))
-
-enum mlx4_guid_alias_rec_status {
-        MLX4_GUID_INFO_STATUS_IDLE,
-        MLX4_GUID_INFO_STATUS_SET,
-        MLX4_GUID_INFO_STATUS_PENDING,
-};
-
-enum mlx4_guid_alias_rec_ownership {
-        MLX4_GUID_DRIVER_ASSIGN,
-        MLX4_GUID_SYSADMIN_ASSIGN,
-        MLX4_GUID_NONE_ASSIGN, /*init state of each record*/
-};
-
-enum mlx4_guid_alias_rec_method {
-        MLX4_GUID_INFO_RECORD_SET       = IB_MGMT_METHOD_SET,
-        MLX4_GUID_INFO_RECORD_DELETE    = IB_SA_METHOD_DELETE,
-};
-
-struct mlx4_sriov_alias_guid_info_rec_det {
-        u8 all_recs[GUID_REC_SIZE * NUM_ALIAS_GUID_IN_REC];
-        ib_sa_comp_mask guid_indexes; /*indicates what from the 8 records are valid*/
-        enum mlx4_guid_alias_rec_status status; /*indicates the administraively status of the record.*/
-        u8 method; /*set or delete*/
-        enum mlx4_guid_alias_rec_ownership ownership; /*indicates who assign that alias_guid record*/
-};
-
-struct mlx4_sriov_alias_guid_port_rec_det {
-        struct mlx4_sriov_alias_guid_info_rec_det all_rec_per_port[NUM_ALIAS_GUID_REC_IN_PORT];
-        struct workqueue_struct *wq;
-        struct delayed_work alias_guid_work;
-        u8 port;
-        struct mlx4_sriov_alias_guid *parent;
-        struct list_head cb_list;
-};
-
-struct mlx4_sriov_alias_guid {
-        struct mlx4_sriov_alias_guid_port_rec_det ports_guid[MLX4_MAX_PORTS];
-        spinlock_t ag_work_lock;
-        struct ib_sa_client *sa_client;
-};
-
-struct mlx4_ib_demux_work {
-        struct work_struct      work;
-        struct mlx4_ib_dev     *dev;
-        int                     slave;
-        int                     do_init;
-        u8                      port;
-
-};
-
-struct mlx4_ib_tun_tx_buf {
-        struct mlx4_ib_buf buf;
-        struct ib_ah *ah;
-};
-
-struct mlx4_ib_demux_pv_qp {
-        struct ib_qp *qp;
-        enum ib_qp_type proxy_qpt;
-        struct mlx4_ib_buf *ring;
-        struct mlx4_ib_tun_tx_buf *tx_ring;
-        spinlock_t tx_lock;
-        unsigned tx_ix_head;
-        unsigned tx_ix_tail;
-};
-
-enum mlx4_ib_demux_pv_state {
-        DEMUX_PV_STATE_DOWN,
-        DEMUX_PV_STATE_STARTING,
-        DEMUX_PV_STATE_ACTIVE,
-        DEMUX_PV_STATE_DOWNING,
-};
-
-struct mlx4_ib_demux_pv_ctx {
-        int port;
-        int slave;
-        enum mlx4_ib_demux_pv_state state;
-        int has_smi;
-        struct ib_device *ib_dev;
-        struct ib_cq *cq;
-        struct ib_pd *pd;
-        struct ib_mr *mr;
-        struct work_struct work;
-        struct workqueue_struct *wq;
-        struct mlx4_ib_demux_pv_qp qp[2];
-};
-
-struct mlx4_ib_demux_ctx {
-        struct ib_device *ib_dev;
-        int port;
-        struct workqueue_struct *wq;
-        struct workqueue_struct *ud_wq;
-        spinlock_t ud_lock;
-        __be64 subnet_prefix;
-        __be64 guid_cache[128];
-        struct mlx4_ib_dev *dev;
-        /* the following lock protects both mcg_table and mcg_mgid0_list */
-        struct mutex            mcg_table_lock;
-        struct rb_root          mcg_table;
-        struct list_head        mcg_mgid0_list;
-        struct workqueue_struct *mcg_wq;
-        struct mlx4_ib_demux_pv_ctx **tun;
-        atomic_t tid;
-        int    flushing; /* flushing the work queue */
-};
-
-struct mlx4_ib_sriov {
-        struct mlx4_ib_demux_ctx demux[MLX4_MAX_PORTS];
-        struct mlx4_ib_demux_pv_ctx *sqps[MLX4_MAX_PORTS];
-        /* when using this spinlock you should use "irq" because
-         * it may be called from interrupt context.*/
-        spinlock_t going_down_lock;
-        int is_going_down;
-
-        struct mlx4_sriov_alias_guid alias_guid;
-
-        /* CM paravirtualization fields */
-        struct list_head cm_list;
-        spinlock_t id_map_lock;
-        struct rb_root sl_id_map;
-        struct idr pv_id_table;
-};
-
 struct mlx4_ib_iboe {
         spinlock_t              lock;
         struct net_device      *netdevs[MLX4_MAX_PORTS];
@@ -421,42 +176,6 @@ struct mlx4_ib_iboe {
         union ib_gid            gid_table[MLX4_MAX_PORTS][128];
 };
 
-struct pkey_mgt {
-        u8                      virt2phys_pkey[MLX4_MFUNC_MAX][MLX4_MAX_PORTS][MLX4_MAX_PORT_PKEYS];
-        u16                     phys_pkey_cache[MLX4_MAX_PORTS][MLX4_MAX_PORT_PKEYS];
-        struct list_head        pkey_port_list[MLX4_MFUNC_MAX];
-        struct kobject         *device_parent[MLX4_MFUNC_MAX];
-};
-
-struct mlx4_ib_iov_sysfs_attr {
-        void *ctx;
-        struct kobject *kobj;
-        unsigned long data;
-        u32 entry_num;
-        char name[15];
-        struct device_attribute dentry;
-        struct device *dev;
-};
-
-struct mlx4_ib_iov_sysfs_attr_ar {
-        struct mlx4_ib_iov_sysfs_attr dentries[3 * NUM_ALIAS_GUID_PER_PORT + 1];
-};
-
-struct mlx4_ib_iov_port {
-        char name[100];
-        u8 num;
-        struct mlx4_ib_dev *dev;
-        struct list_head list;
-        struct mlx4_ib_iov_sysfs_attr_ar *dentr_ar;
-        struct ib_port_attr attr;
-        struct kobject  *cur_port;
-        struct kobject  *admin_alias_parent;
-        struct kobject  *gids_parent;
-        struct kobject  *pkeys_parent;
-        struct kobject  *mcgs_parent;
-        struct mlx4_ib_iov_sysfs_attr mcg_dentry;
-};
-
 struct mlx4_ib_dev {
         struct ib_device        ib_dev;
         struct mlx4_dev        *dev;
@@ -470,32 +189,11 @@ struct mlx4_ib_dev {
         struct ib_mad_agent    *send_agent[MLX4_MAX_PORTS][2];
         struct ib_ah           *sm_ah[MLX4_MAX_PORTS];
         spinlock_t              sm_lock;
-        struct mlx4_ib_sriov    sriov;
 
         struct mutex            cap_mask_mutex;
         bool                    ib_active;
         struct mlx4_ib_iboe     iboe;
         int                     counters[MLX4_MAX_PORTS];
-        int                    *eq_table;
-        int                     eq_added;
-        struct kobject         *iov_parent;
-        struct kobject         *ports_parent;
-        struct kobject         *dev_ports_parent[MLX4_MFUNC_MAX];
-        struct mlx4_ib_iov_port iov_ports[MLX4_MAX_PORTS];
-        struct pkey_mgt         pkeys;
-};
-
-struct ib_event_work {
-        struct work_struct      work;
-        struct mlx4_ib_dev      *ib_dev;
-        struct mlx4_eqe         ib_eqe;
-};
-
-struct mlx4_ib_qp_tunnel_init_attr {
-        struct ib_qp_init_attr init_attr;
-        int slave;
-        enum ib_qp_type proxy_qp_type;
-        u8 port;
 };
 
 static inline struct mlx4_ib_dev *to_mdev(struct ib_device *ibdev)
@@ -513,11 +211,6 @@ static inline struct mlx4_ib_pd *to_mpd(struct ib_pd *ibpd)
         return container_of(ibpd, struct mlx4_ib_pd, ibpd);
 }
 
-static inline struct mlx4_ib_xrcd *to_mxrcd(struct ib_xrcd *ibxrcd)
-{
-        return container_of(ibxrcd, struct mlx4_ib_xrcd, ibxrcd);
-}
-
 static inline struct mlx4_ib_cq *to_mcq(struct ib_cq *ibcq)
 {
         return container_of(ibcq, struct mlx4_ib_cq, ibcq);
@@ -567,9 +260,6 @@ static inline struct mlx4_ib_ah *to_mah(struct ib_ah *ibah)
         return container_of(ibah, struct mlx4_ib_ah, ibah);
 }
 
-int mlx4_ib_init_sriov(struct mlx4_ib_dev *dev);
-void mlx4_ib_close_sriov(struct mlx4_ib_dev *dev);
-
 int mlx4_ib_db_map_user(struct mlx4_ib_ucontext *context, unsigned long virt,
                         struct mlx4_db *db);
 void mlx4_ib_db_unmap_user(struct mlx4_ib_ucontext *context, struct mlx4_db *db);
@@ -626,7 +316,7 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
 int mlx4_ib_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *wr,
                       struct ib_recv_wr **bad_wr);
 
-int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int mad_ifc_flags,
+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);
 int mlx4_ib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
@@ -641,13 +331,6 @@ int mlx4_ib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list, int npages,
                          u64 iova);
 int mlx4_ib_unmap_fmr(struct list_head *fmr_list);
 int mlx4_ib_fmr_dealloc(struct ib_fmr *fmr);
-int __mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
-                         struct ib_port_attr *props, int netw_view);
-int __mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
-                         u16 *pkey, int netw_view);
-
-int __mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
-                        union ib_gid *gid, int netw_view);
 
 int mlx4_ib_resolve_grh(struct mlx4_ib_dev *dev, const struct ib_ah_attr *ah_attr,
                         u8 *mac, int *is_mcast, u8 port);
@@ -662,69 +345,7 @@ static inline int mlx4_ib_ah_grh_present(struct mlx4_ib_ah *ah)
         return !!(ah->av.ib.g_slid & 0x80);
 }
 
-int mlx4_ib_mcg_port_init(struct mlx4_ib_demux_ctx *ctx);
-void mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq);
-void clean_vf_mcast(struct mlx4_ib_demux_ctx *ctx, int slave);
-int mlx4_ib_mcg_init(void);
-void mlx4_ib_mcg_destroy(void);
-
-int mlx4_ib_find_real_gid(struct ib_device *ibdev, u8 port, __be64 guid);
-
-int mlx4_ib_mcg_multiplex_handler(struct ib_device *ibdev, int port, int slave,
-                                  struct ib_sa_mad *sa_mad);
-int mlx4_ib_mcg_demux_handler(struct ib_device *ibdev, int port, int slave,
-                              struct ib_sa_mad *mad);
-
 int mlx4_ib_add_mc(struct mlx4_ib_dev *mdev, struct mlx4_ib_qp *mqp,
                    union ib_gid *gid);
 
-void mlx4_ib_dispatch_event(struct mlx4_ib_dev *dev, u8 port_num,
-                            enum ib_event_type type);
-
-void mlx4_ib_tunnels_update_work(struct work_struct *work);
-
-int mlx4_ib_send_to_slave(struct mlx4_ib_dev *dev, int slave, u8 port,
-                          enum ib_qp_type qpt, struct ib_wc *wc,
-                          struct ib_grh *grh, struct ib_mad *mad);
-int mlx4_ib_send_to_wire(struct mlx4_ib_dev *dev, int slave, u8 port,
-                         enum ib_qp_type dest_qpt, u16 pkey_index, u32 remote_qpn,
-                         u32 qkey, struct ib_ah_attr *attr, struct ib_mad *mad);
-__be64 mlx4_ib_get_new_demux_tid(struct mlx4_ib_demux_ctx *ctx);
-
-int mlx4_ib_demux_cm_handler(struct ib_device *ibdev, int port, int *slave,
-                struct ib_mad *mad);
-
-int mlx4_ib_multiplex_cm_handler(struct ib_device *ibdev, int port, int slave_id,
-                struct ib_mad *mad);
-
-void mlx4_ib_cm_paravirt_init(struct mlx4_ib_dev *dev);
-void mlx4_ib_cm_paravirt_clean(struct mlx4_ib_dev *dev, int slave_id);
-
-/* alias guid support */
-void mlx4_ib_init_alias_guid_work(struct mlx4_ib_dev *dev, int port);
-int mlx4_ib_init_alias_guid_service(struct mlx4_ib_dev *dev);
-void mlx4_ib_destroy_alias_guid_service(struct mlx4_ib_dev *dev);
-void mlx4_ib_invalidate_all_guid_record(struct mlx4_ib_dev *dev, int port);
-
-void mlx4_ib_notify_slaves_on_guid_change(struct mlx4_ib_dev *dev,
-                                          int block_num,
-                                          u8 port_num, u8 *p_data);
-
-void mlx4_ib_update_cache_on_guid_change(struct mlx4_ib_dev *dev,
-                                         int block_num, u8 port_num,
-                                         u8 *p_data);
-
-int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
-                            struct attribute *attr);
-void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
-                             struct attribute *attr);
-ib_sa_comp_mask mlx4_ib_get_aguid_comp_mask_from_ix(int index);
-
-int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *device) ;
-
-void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device);
-
-__be64 mlx4_ib_gen_node_guid(void);
-
-
 #endif /* MLX4_IB_H */
diff --git a/drivers/infiniband/hw/mlx4/mr.c b/drivers/infiniband/hw/mlx4/mr.c
index bbaf6176f20..dca55b19a6f 100644
--- a/drivers/infiniband/hw/mlx4/mr.c
+++ b/drivers/infiniband/hw/mlx4/mr.c
@@ -338,7 +338,7 @@ int mlx4_ib_unmap_fmr(struct list_head *fmr_list)
 
         err = mlx4_SYNC_TPT(mdev);
         if (err)
-                pr_warn("SYNC_TPT error %d when "
+                printk(KERN_WARNING "mlx4_ib: SYNC_TPT error %d when "
                        "unmapping FMRs\n", err);
 
         return 0;
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 19e0637220b..5c22514b871 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -38,7 +38,6 @@
 #include <rdma/ib_cache.h>
 #include <rdma/ib_pack.h>
 #include <rdma/ib_addr.h>
-#include <rdma/ib_mad.h>
 
 #include <linux/mlx4/qp.h>
 
@@ -85,11 +84,6 @@ enum {
         MLX4_IB_CACHE_LINE_SIZE = 64,
 };
 
-enum {
-        MLX4_RAW_QP_MTU         = 7,
-        MLX4_RAW_QP_MSGMAX      = 31,
-};
-
 static const __be32 mlx4_ib_opcode[] = {
         [IB_WR_SEND]                            = cpu_to_be32(MLX4_OPCODE_SEND),
         [IB_WR_LSO]                             = cpu_to_be32(MLX4_OPCODE_LSO),
@@ -111,62 +105,16 @@ static struct mlx4_ib_sqp *to_msqp(struct mlx4_ib_qp *mqp)
         return container_of(mqp, struct mlx4_ib_sqp, qp);
 }
 
-static int is_tunnel_qp(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp)
-{
-        if (!mlx4_is_master(dev->dev))
-                return 0;
-
-        return qp->mqp.qpn >= dev->dev->phys_caps.base_tunnel_sqpn &&
-               qp->mqp.qpn < dev->dev->phys_caps.base_tunnel_sqpn +
-                8 * MLX4_MFUNC_MAX;
-}
-
 static int is_sqp(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp)
 {
-        int proxy_sqp = 0;
-        int real_sqp = 0;
-        int i;
-        /* PPF or Native -- real SQP */
-        real_sqp = ((mlx4_is_master(dev->dev) || !mlx4_is_mfunc(dev->dev)) &&
-                    qp->mqp.qpn >= dev->dev->phys_caps.base_sqpn &&
-                    qp->mqp.qpn <= dev->dev->phys_caps.base_sqpn + 3);
-        if (real_sqp)
-                return 1;
-        /* VF or PF -- proxy SQP */
-        if (mlx4_is_mfunc(dev->dev)) {
-                for (i = 0; i < dev->dev->caps.num_ports; i++) {
-                        if (qp->mqp.qpn == dev->dev->caps.qp0_proxy[i] ||
-                            qp->mqp.qpn == dev->dev->caps.qp1_proxy[i]) {
-                                proxy_sqp = 1;
-                                break;
-                        }
-                }
-        }
-        return proxy_sqp;
+        return qp->mqp.qpn >= dev->dev->caps.sqp_start &&
+                qp->mqp.qpn <= dev->dev->caps.sqp_start + 3;
 }
 
-/* used for INIT/CLOSE port logic */
 static int is_qp0(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp)
 {
-        int proxy_qp0 = 0;
-        int real_qp0 = 0;
-        int i;
-        /* PPF or Native -- real QP0 */
-        real_qp0 = ((mlx4_is_master(dev->dev) || !mlx4_is_mfunc(dev->dev)) &&
-                    qp->mqp.qpn >= dev->dev->phys_caps.base_sqpn &&
-                    qp->mqp.qpn <= dev->dev->phys_caps.base_sqpn + 1);
-        if (real_qp0)
-                return 1;
-        /* VF or PF -- proxy QP0 */
-        if (mlx4_is_mfunc(dev->dev)) {
-                for (i = 0; i < dev->dev->caps.num_ports; i++) {
-                        if (qp->mqp.qpn == dev->dev->caps.qp0_proxy[i]) {
-                                proxy_qp0 = 1;
-                                break;
-                        }
-                }
-        }
-        return proxy_qp0;
+        return qp->mqp.qpn >= dev->dev->caps.sqp_start &&
+                qp->mqp.qpn <= dev->dev->caps.sqp_start + 1;
 }
 
 static void *get_wqe(struct mlx4_ib_qp *qp, int offset)
@@ -308,7 +256,7 @@ static void mlx4_ib_qp_event(struct mlx4_qp *qp, enum mlx4_event type)
                         event.event = IB_EVENT_QP_ACCESS_ERR;
                         break;
                 default:
-                        pr_warn("Unexpected event type %d "
+                        printk(KERN_WARNING "mlx4_ib: Unexpected event type %d "
                                "on QP %06x\n", type, qp->qpn);
                         return;
                 }
@@ -317,7 +265,7 @@ static void mlx4_ib_qp_event(struct mlx4_qp *qp, enum mlx4_event type)
         }
 }
 
-static int send_wqe_overhead(enum mlx4_ib_qp_type type, u32 flags)
+static int send_wqe_overhead(enum ib_qp_type type, u32 flags)
 {
         /*
          * UD WQEs must have a datagram segment.
@@ -326,29 +274,19 @@ static int send_wqe_overhead(enum mlx4_ib_qp_type type, u32 flags)
          * header and space for the ICRC).
          */
         switch (type) {
-        case MLX4_IB_QPT_UD:
+        case IB_QPT_UD:
                 return sizeof (struct mlx4_wqe_ctrl_seg) +
                         sizeof (struct mlx4_wqe_datagram_seg) +
                         ((flags & MLX4_IB_QP_LSO) ? MLX4_IB_LSO_HEADER_SPARE : 0);
-        case MLX4_IB_QPT_PROXY_SMI_OWNER:
-        case MLX4_IB_QPT_PROXY_SMI:
-        case MLX4_IB_QPT_PROXY_GSI:
-                return sizeof (struct mlx4_wqe_ctrl_seg) +
-                        sizeof (struct mlx4_wqe_datagram_seg) + 64;
-        case MLX4_IB_QPT_TUN_SMI_OWNER:
-        case MLX4_IB_QPT_TUN_GSI:
-                return sizeof (struct mlx4_wqe_ctrl_seg) +
-                        sizeof (struct mlx4_wqe_datagram_seg);
-
-        case MLX4_IB_QPT_UC:
+        case IB_QPT_UC:
                 return sizeof (struct mlx4_wqe_ctrl_seg) +
                         sizeof (struct mlx4_wqe_raddr_seg);
-        case MLX4_IB_QPT_RC:
+        case IB_QPT_RC:
                 return sizeof (struct mlx4_wqe_ctrl_seg) +
                         sizeof (struct mlx4_wqe_atomic_seg) +
                         sizeof (struct mlx4_wqe_raddr_seg);
-        case MLX4_IB_QPT_SMI:
-        case MLX4_IB_QPT_GSI:
+        case IB_QPT_SMI:
+        case IB_QPT_GSI:
                 return sizeof (struct mlx4_wqe_ctrl_seg) +
                         ALIGN(MLX4_IB_UD_HEADER_SIZE +
                               DIV_ROUND_UP(MLX4_IB_UD_HEADER_SIZE,
@@ -364,14 +302,15 @@ static int send_wqe_overhead(enum mlx4_ib_qp_type type, u32 flags)
 }
 
 static int set_rq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
-                       int is_user, int has_rq, struct mlx4_ib_qp *qp)
+                       int is_user, int has_srq, struct mlx4_ib_qp *qp)
 {
         /* Sanity check RQ size before proceeding */
-        if (cap->max_recv_wr > dev->dev->caps.max_wqes - MLX4_IB_SQ_MAX_SPARE ||
-            cap->max_recv_sge > min(dev->dev->caps.max_sq_sg, dev->dev->caps.max_rq_sg))
+        if (cap->max_recv_wr  > dev->dev->caps.max_wqes  ||
+            cap->max_recv_sge > dev->dev->caps.max_rq_sg)
                 return -EINVAL;
 
-        if (!has_rq) {
+        if (has_srq) {
+                /* QPs attached to an SRQ should have no RQ */
                 if (cap->max_recv_wr)
                         return -EINVAL;
 
@@ -386,29 +325,20 @@ static int set_rq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
                 qp->rq.wqe_shift = ilog2(qp->rq.max_gs * sizeof (struct mlx4_wqe_data_seg));
         }
 
-        /* leave userspace return values as they were, so as not to break ABI */
-        if (is_user) {
-                cap->max_recv_wr  = qp->rq.max_post = qp->rq.wqe_cnt;
-                cap->max_recv_sge = qp->rq.max_gs;
-        } else {
-                cap->max_recv_wr  = qp->rq.max_post =
-                        min(dev->dev->caps.max_wqes - MLX4_IB_SQ_MAX_SPARE, qp->rq.wqe_cnt);
-                cap->max_recv_sge = min(qp->rq.max_gs,
-                                        min(dev->dev->caps.max_sq_sg,
-                                            dev->dev->caps.max_rq_sg));
-        }
+        cap->max_recv_wr  = qp->rq.max_post = qp->rq.wqe_cnt;
+        cap->max_recv_sge = qp->rq.max_gs;
 
         return 0;
 }
 
 static int set_kernel_sq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
-                              enum mlx4_ib_qp_type type, struct mlx4_ib_qp *qp)
+                              enum ib_qp_type type, struct mlx4_ib_qp *qp)
 {
         int s;
 
         /* Sanity check SQ size before proceeding */
-        if (cap->max_send_wr  > (dev->dev->caps.max_wqes - MLX4_IB_SQ_MAX_SPARE) ||
-            cap->max_send_sge > min(dev->dev->caps.max_sq_sg, dev->dev->caps.max_rq_sg) ||
+        if (cap->max_send_wr     > dev->dev->caps.max_wqes  ||
+            cap->max_send_sge    > dev->dev->caps.max_sq_sg ||
             cap->max_inline_data + send_wqe_overhead(type, qp->flags) +
             sizeof (struct mlx4_wqe_inline_seg) > dev->dev->caps.max_sq_desc_sz)
                 return -EINVAL;
@@ -417,8 +347,7 @@ static int set_kernel_sq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
          * For MLX transport we need 2 extra S/G entries:
          * one for the header and one for the checksum at the end
          */
-        if ((type == MLX4_IB_QPT_SMI || type == MLX4_IB_QPT_GSI ||
-             type & (MLX4_IB_QPT_PROXY_SMI_OWNER | MLX4_IB_QPT_TUN_SMI_OWNER)) &&
+        if ((type == IB_QPT_SMI || type == IB_QPT_GSI) &&
             cap->max_send_sge + 2 > dev->dev->caps.max_sq_sg)
                 return -EINVAL;
 
@@ -462,9 +391,7 @@ static int set_kernel_sq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
          */
         if (dev->dev->caps.fw_ver >= MLX4_FW_VER_WQE_CTRL_NEC &&
             qp->sq_signal_bits && BITS_PER_LONG == 64 &&
-            type != MLX4_IB_QPT_SMI && type != MLX4_IB_QPT_GSI &&
-            !(type & (MLX4_IB_QPT_PROXY_SMI_OWNER | MLX4_IB_QPT_PROXY_SMI |
-                      MLX4_IB_QPT_PROXY_GSI | MLX4_IB_QPT_TUN_SMI_OWNER)))
+            type != IB_QPT_SMI && type != IB_QPT_GSI)
                 qp->sq.wqe_shift = ilog2(64);
         else
                 qp->sq.wqe_shift = ilog2(roundup_pow_of_two(s));
@@ -536,137 +463,23 @@ static int set_user_sq_size(struct mlx4_ib_dev *dev,
         return 0;
 }
 
-static int alloc_proxy_bufs(struct ib_device *dev, struct mlx4_ib_qp *qp)
-{
-        int i;
-
-        qp->sqp_proxy_rcv =
-                kmalloc(sizeof (struct mlx4_ib_buf) * qp->rq.wqe_cnt,
-                        GFP_KERNEL);
-        if (!qp->sqp_proxy_rcv)
-                return -ENOMEM;
-        for (i = 0; i < qp->rq.wqe_cnt; i++) {
-                qp->sqp_proxy_rcv[i].addr =
-                        kmalloc(sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                GFP_KERNEL);
-                if (!qp->sqp_proxy_rcv[i].addr)
-                        goto err;
-                qp->sqp_proxy_rcv[i].map =
-                        ib_dma_map_single(dev, qp->sqp_proxy_rcv[i].addr,
-                                          sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                          DMA_FROM_DEVICE);
-        }
-        return 0;
-
-err:
-        while (i > 0) {
-                --i;
-                ib_dma_unmap_single(dev, qp->sqp_proxy_rcv[i].map,
-                                    sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                    DMA_FROM_DEVICE);
-                kfree(qp->sqp_proxy_rcv[i].addr);
-        }
-        kfree(qp->sqp_proxy_rcv);
-        qp->sqp_proxy_rcv = NULL;
-        return -ENOMEM;
-}
-
-static void free_proxy_bufs(struct ib_device *dev, struct mlx4_ib_qp *qp)
-{
-        int i;
-
-        for (i = 0; i < qp->rq.wqe_cnt; i++) {
-                ib_dma_unmap_single(dev, qp->sqp_proxy_rcv[i].map,
-                                    sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                    DMA_FROM_DEVICE);
-                kfree(qp->sqp_proxy_rcv[i].addr);
-        }
-        kfree(qp->sqp_proxy_rcv);
-}
-
-static int qp_has_rq(struct ib_qp_init_attr *attr)
-{
-        if (attr->qp_type == IB_QPT_XRC_INI || attr->qp_type == IB_QPT_XRC_TGT)
-                return 0;
-
-        return !attr->srq;
-}
-
 static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                             struct ib_qp_init_attr *init_attr,
-                            struct ib_udata *udata, int sqpn, struct mlx4_ib_qp **caller_qp)
+                            struct ib_udata *udata, int sqpn, struct mlx4_ib_qp *qp)
 {
         int qpn;
         int err;
-        struct mlx4_ib_sqp *sqp;
-        struct mlx4_ib_qp *qp;
-        enum mlx4_ib_qp_type qp_type = (enum mlx4_ib_qp_type) init_attr->qp_type;
-
-        /* When tunneling special qps, we use a plain UD qp */
-        if (sqpn) {
-                if (mlx4_is_mfunc(dev->dev) &&
-                    (!mlx4_is_master(dev->dev) ||
-                     !(init_attr->create_flags & MLX4_IB_SRIOV_SQP))) {
-                        if (init_attr->qp_type == IB_QPT_GSI)
-                                qp_type = MLX4_IB_QPT_PROXY_GSI;
-                        else if (mlx4_is_master(dev->dev))
-                                qp_type = MLX4_IB_QPT_PROXY_SMI_OWNER;
-                        else
-                                qp_type = MLX4_IB_QPT_PROXY_SMI;
-                }
-                qpn = sqpn;
-                /* add extra sg entry for tunneling */
-                init_attr->cap.max_recv_sge++;
-        } else if (init_attr->create_flags & MLX4_IB_SRIOV_TUNNEL_QP) {
-                struct mlx4_ib_qp_tunnel_init_attr *tnl_init =
-                        container_of(init_attr,
-                                     struct mlx4_ib_qp_tunnel_init_attr, init_attr);
-                if ((tnl_init->proxy_qp_type != IB_QPT_SMI &&
-                     tnl_init->proxy_qp_type != IB_QPT_GSI)   ||
-                    !mlx4_is_master(dev->dev))
-                        return -EINVAL;
-                if (tnl_init->proxy_qp_type == IB_QPT_GSI)
-                        qp_type = MLX4_IB_QPT_TUN_GSI;
-                else if (tnl_init->slave == mlx4_master_func_num(dev->dev))
-                        qp_type = MLX4_IB_QPT_TUN_SMI_OWNER;
-                else
-                        qp_type = MLX4_IB_QPT_TUN_SMI;
-                /* we are definitely in the PPF here, since we are creating
-                 * tunnel QPs. base_tunnel_sqpn is therefore valid. */
-                qpn = dev->dev->phys_caps.base_tunnel_sqpn + 8 * tnl_init->slave
-                        + tnl_init->proxy_qp_type * 2 + tnl_init->port - 1;
-                sqpn = qpn;
-        }
-
-        if (!*caller_qp) {
-                if (qp_type == MLX4_IB_QPT_SMI || qp_type == MLX4_IB_QPT_GSI ||
-                    (qp_type & (MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_SMI_OWNER |
-                                MLX4_IB_QPT_PROXY_GSI | MLX4_IB_QPT_TUN_SMI_OWNER))) {
-                        sqp = kzalloc(sizeof (struct mlx4_ib_sqp), GFP_KERNEL);
-                        if (!sqp)
-                                return -ENOMEM;
-                        qp = &sqp->qp;
-                } else {
-                        qp = kzalloc(sizeof (struct mlx4_ib_qp), GFP_KERNEL);
-                        if (!qp)
-                                return -ENOMEM;
-                }
-        } else
-                qp = *caller_qp;
-
-        qp->mlx4_ib_qp_type = qp_type;
 
         mutex_init(&qp->mutex);
         spin_lock_init(&qp->sq.lock);
         spin_lock_init(&qp->rq.lock);
         INIT_LIST_HEAD(&qp->gid_list);
-        INIT_LIST_HEAD(&qp->steering_rules);
 
         qp->state        = IB_QPS_RESET;
         if (init_attr->sq_sig_type == IB_SIGNAL_ALL_WR)
                 qp->sq_signal_bits = cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE);
 
-        err = set_rq_size(dev, &init_attr->cap, !!pd->uobject, qp_has_rq(init_attr), qp);
+        err = set_rq_size(dev, &init_attr->cap, !!pd->uobject, !!init_attr->srq, qp);
         if (err)
                 goto err;
 
@@ -700,7 +513,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                 if (err)
                         goto err_mtt;
 
-                if (qp_has_rq(init_attr)) {
+                if (!init_attr->srq) {
                         err = mlx4_ib_db_map_user(to_mucontext(pd->uobject->context),
                                                   ucmd.db_addr, &qp->db);
                         if (err)
@@ -715,11 +528,11 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                 if (init_attr->create_flags & IB_QP_CREATE_IPOIB_UD_LSO)
                         qp->flags |= MLX4_IB_QP_LSO;
 
-                err = set_kernel_sq_size(dev, &init_attr->cap, qp_type, qp);
+                err = set_kernel_sq_size(dev, &init_attr->cap, init_attr->qp_type, qp);
                 if (err)
                         goto err;
 
-                if (qp_has_rq(init_attr)) {
+                if (!init_attr->srq) {
                         err = mlx4_db_alloc(dev->dev, &qp->db, 0);
                         if (err)
                                 goto err;
@@ -751,31 +564,17 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
         }
 
         if (sqpn) {
-                if (qp->mlx4_ib_qp_type & (MLX4_IB_QPT_PROXY_SMI_OWNER |
-                    MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI)) {
-                        if (alloc_proxy_bufs(pd->device, qp)) {
-                                err = -ENOMEM;
-                                goto err_wrid;
-                        }
-                }
+                qpn = sqpn;
         } else {
-                /* Raw packet QPNs must be aligned to 8 bits. If not, the WQE
-                 * BlueFlame setup flow wrongly causes VLAN insertion. */
-                if (init_attr->qp_type == IB_QPT_RAW_PACKET)
-                        err = mlx4_qp_reserve_range(dev->dev, 1, 1 << 8, &qpn);
-                else
-                        err = mlx4_qp_reserve_range(dev->dev, 1, 1, &qpn);
+                err = mlx4_qp_reserve_range(dev->dev, 1, 1, &qpn);
                 if (err)
-                        goto err_proxy;
+                        goto err_wrid;
         }
 
         err = mlx4_qp_alloc(dev->dev, qpn, &qp->mqp);
         if (err)
                 goto err_qpn;
 
-        if (init_attr->qp_type == IB_QPT_XRC_TGT)
-                qp->mqp.qpn |= (1 << 23);
-
         /*
          * Hardware wants QPN written in big-endian order (after
          * shifting) for send doorbell.  Precompute this value to save
@@ -784,20 +583,18 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
         qp->doorbell_qpn = swab32(qp->mqp.qpn << 8);
 
         qp->mqp.event = mlx4_ib_qp_event;
-        if (!*caller_qp)
-                *caller_qp = qp;
+
         return 0;
 
 err_qpn:
         if (!sqpn)
                 mlx4_qp_release_range(dev->dev, qpn, 1);
-err_proxy:
-        if (qp->mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_GSI)
-                free_proxy_bufs(pd->device, qp);
+
 err_wrid:
         if (pd->uobject) {
-                if (qp_has_rq(init_attr))
-                        mlx4_ib_db_unmap_user(to_mucontext(pd->uobject->context), &qp->db);
+                if (!init_attr->srq)
+                        mlx4_ib_db_unmap_user(to_mucontext(pd->uobject->context),
+                                              &qp->db);
         } else {
                 kfree(qp->sq.wrid);
                 kfree(qp->rq.wrid);
@@ -813,12 +610,10 @@ err_buf:
                 mlx4_buf_free(dev->dev, qp->buf_size, &qp->buf);
 
 err_db:
-        if (!pd->uobject && qp_has_rq(init_attr))
+        if (!pd->uobject && !init_attr->srq)
                 mlx4_db_free(dev->dev, &qp->db);
 
 err:
-        if (!*caller_qp)
-                kfree(qp);
         return err;
 }
 
@@ -876,33 +671,6 @@ static void del_gid_entries(struct mlx4_ib_qp *qp)
         }
 }
 
-static struct mlx4_ib_pd *get_pd(struct mlx4_ib_qp *qp)
-{
-        if (qp->ibqp.qp_type == IB_QPT_XRC_TGT)
-                return to_mpd(to_mxrcd(qp->ibqp.xrcd)->pd);
-        else
-                return to_mpd(qp->ibqp.pd);
-}
-
-static void get_cqs(struct mlx4_ib_qp *qp,
-                    struct mlx4_ib_cq **send_cq, struct mlx4_ib_cq **recv_cq)
-{
-        switch (qp->ibqp.qp_type) {
-        case IB_QPT_XRC_TGT:
-                *send_cq = to_mcq(to_mxrcd(qp->ibqp.xrcd)->cq);
-                *recv_cq = *send_cq;
-                break;
-        case IB_QPT_XRC_INI:
-                *send_cq = to_mcq(qp->ibqp.send_cq);
-                *recv_cq = *send_cq;
-                break;
-        default:
-                *send_cq = to_mcq(qp->ibqp.send_cq);
-                *recv_cq = to_mcq(qp->ibqp.recv_cq);
-                break;
-        }
-}
-
 static void destroy_qp_common(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp,
                               int is_user)
 {
@@ -911,10 +679,11 @@ static void destroy_qp_common(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp,
         if (qp->state != IB_QPS_RESET)
                 if (mlx4_qp_modify(dev->dev, NULL, to_mlx4_state(qp->state),
                                    MLX4_QP_STATE_RST, NULL, 0, 0, &qp->mqp))
-                        pr_warn("modify QP %06x to RESET failed.\n",
+                        printk(KERN_WARNING "mlx4_ib: modify QP %06x to RESET failed.\n",
                                qp->mqp.qpn);
 
-        get_cqs(qp, &send_cq, &recv_cq);
+        send_cq = to_mcq(qp->ibqp.send_cq);
+        recv_cq = to_mcq(qp->ibqp.recv_cq);
 
         mlx4_ib_lock_cqs(send_cq, recv_cq);
 
@@ -931,99 +700,64 @@ static void destroy_qp_common(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp,
 
         mlx4_qp_free(dev->dev, &qp->mqp);
 
-        if (!is_sqp(dev, qp) && !is_tunnel_qp(dev, qp))
+        if (!is_sqp(dev, qp))
                 mlx4_qp_release_range(dev->dev, qp->mqp.qpn, 1);
 
         mlx4_mtt_cleanup(dev->dev, &qp->mtt);
 
         if (is_user) {
-                if (qp->rq.wqe_cnt)
+                if (!qp->ibqp.srq)
                         mlx4_ib_db_unmap_user(to_mucontext(qp->ibqp.uobject->context),
                                               &qp->db);
                 ib_umem_release(qp->umem);
         } else {
                 kfree(qp->sq.wrid);
                 kfree(qp->rq.wrid);
-                if (qp->mlx4_ib_qp_type & (MLX4_IB_QPT_PROXY_SMI_OWNER |
-                    MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI))
-                        free_proxy_bufs(&dev->ib_dev, qp);
                 mlx4_buf_free(dev->dev, qp->buf_size, &qp->buf);
-                if (qp->rq.wqe_cnt)
+                if (!qp->ibqp.srq)
                         mlx4_db_free(dev->dev, &qp->db);
         }
 
         del_gid_entries(qp);
 }
 
-static u32 get_sqp_num(struct mlx4_ib_dev *dev, struct ib_qp_init_attr *attr)
-{
-        /* Native or PPF */
-        if (!mlx4_is_mfunc(dev->dev) ||
-            (mlx4_is_master(dev->dev) &&
-             attr->create_flags & MLX4_IB_SRIOV_SQP)) {
-                return  dev->dev->phys_caps.base_sqpn +
-                        (attr->qp_type == IB_QPT_SMI ? 0 : 2) +
-                        attr->port_num - 1;
-        }
-        /* PF or VF -- creating proxies */
-        if (attr->qp_type == IB_QPT_SMI)
-                return dev->dev->caps.qp0_proxy[attr->port_num - 1];
-        else
-                return dev->dev->caps.qp1_proxy[attr->port_num - 1];
-}
-
 struct ib_qp *mlx4_ib_create_qp(struct ib_pd *pd,
                                 struct ib_qp_init_attr *init_attr,
                                 struct ib_udata *udata)
 {
-        struct mlx4_ib_qp *qp = NULL;
+        struct mlx4_ib_dev *dev = to_mdev(pd->device);
+        struct mlx4_ib_sqp *sqp;
+        struct mlx4_ib_qp *qp;
         int err;
-        u16 xrcdn = 0;
 
         /*
-         * We only support LSO, vendor flag1, and multicast loopback blocking,
-         * and only for kernel UD QPs.
+         * We only support LSO and multicast loopback blocking, and
+         * only for kernel UD QPs.
          */
-        if (init_attr->create_flags & ~(MLX4_IB_QP_LSO |
-                                        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK |
-                                        MLX4_IB_SRIOV_TUNNEL_QP | MLX4_IB_SRIOV_SQP))
+        if (init_attr->create_flags & ~(IB_QP_CREATE_IPOIB_UD_LSO |
+                                        IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK))
                 return ERR_PTR(-EINVAL);
 
         if (init_attr->create_flags &&
-            (udata ||
-             ((init_attr->create_flags & ~MLX4_IB_SRIOV_SQP) &&
-              init_attr->qp_type != IB_QPT_UD) ||
-             ((init_attr->create_flags & MLX4_IB_SRIOV_SQP) &&
-              init_attr->qp_type > IB_QPT_GSI)))
+            (pd->uobject || init_attr->qp_type != IB_QPT_UD))
                 return ERR_PTR(-EINVAL);
 
         switch (init_attr->qp_type) {
-        case IB_QPT_XRC_TGT:
-                pd = to_mxrcd(init_attr->xrcd)->pd;
-                xrcdn = to_mxrcd(init_attr->xrcd)->xrcdn;
-                init_attr->send_cq = to_mxrcd(init_attr->xrcd)->cq;
-                /* fall through */
-        case IB_QPT_XRC_INI:
-                if (!(to_mdev(pd->device)->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC))
-                        return ERR_PTR(-ENOSYS);
-                init_attr->recv_cq = init_attr->send_cq;
-                /* fall through */
         case IB_QPT_RC:
         case IB_QPT_UC:
-        case IB_QPT_RAW_PACKET:
+        case IB_QPT_UD:
+        {
                 qp = kzalloc(sizeof *qp, GFP_KERNEL);
                 if (!qp)
                         return ERR_PTR(-ENOMEM);
-                /* fall through */
-        case IB_QPT_UD:
-        {
-                err = create_qp_common(to_mdev(pd->device), pd, init_attr,
-                                       udata, 0, &qp);
-                if (err)
+
+                err = create_qp_common(dev, pd, init_attr, udata, 0, qp);
+                if (err) {
+                        kfree(qp);
                         return ERR_PTR(err);
+                }
 
                 qp->ibqp.qp_num = qp->mqp.qpn;
-                qp->xrcdn = xrcdn;
 
                 break;
         }
@@ -1031,14 +765,24 @@ struct ib_qp *mlx4_ib_create_qp(struct ib_pd *pd,
         case IB_QPT_GSI:
         {
                 /* Userspace is not allowed to create special QPs: */
-                if (udata)
+                if (pd->uobject)
                         return ERR_PTR(-EINVAL);
 
-                err = create_qp_common(to_mdev(pd->device), pd, init_attr, udata,
-                                       get_sqp_num(to_mdev(pd->device), init_attr),
-                                       &qp);
-                if (err)
+                sqp = kzalloc(sizeof *sqp, GFP_KERNEL);
+                if (!sqp)
+                        return ERR_PTR(-ENOMEM);
+
+                qp = &sqp->qp;
+
+                err = create_qp_common(dev, pd, init_attr, udata,
+                                       dev->dev->caps.sqp_start +
+                                       (init_attr->qp_type == IB_QPT_SMI ? 0 : 2) +
+                                       init_attr->port_num - 1,
+                                       qp);
+                if (err) {
+                        kfree(sqp);
                         return ERR_PTR(err);
+                }
 
                 qp->port        = init_attr->port_num;
                 qp->ibqp.qp_num = init_attr->qp_type == IB_QPT_SMI ? 0 : 1;
@@ -1057,13 +801,11 @@ int mlx4_ib_destroy_qp(struct ib_qp *qp)
 {
         struct mlx4_ib_dev *dev = to_mdev(qp->device);
         struct mlx4_ib_qp *mqp = to_mqp(qp);
-        struct mlx4_ib_pd *pd;
 
         if (is_qp0(dev, mqp))
                 mlx4_CLOSE_PORT(dev->dev, mqp->port);
 
-        pd = get_pd(mqp);
-        destroy_qp_common(dev, mqp, !!pd->ibpd.uobject);
+        destroy_qp_common(dev, mqp, !!qp->pd->uobject);
 
         if (is_sqp(dev, mqp))
                 kfree(to_msqp(mqp));
@@ -1073,27 +815,15 @@ int mlx4_ib_destroy_qp(struct ib_qp *qp)
         return 0;
 }
 
-static int to_mlx4_st(struct mlx4_ib_dev *dev, enum mlx4_ib_qp_type type)
+static int to_mlx4_st(enum ib_qp_type type)
 {
         switch (type) {
-        case MLX4_IB_QPT_RC:            return MLX4_QP_ST_RC;
-        case MLX4_IB_QPT_UC:            return MLX4_QP_ST_UC;
-        case MLX4_IB_QPT_UD:            return MLX4_QP_ST_UD;
-        case MLX4_IB_QPT_XRC_INI:
-        case MLX4_IB_QPT_XRC_TGT:       return MLX4_QP_ST_XRC;
-        case MLX4_IB_QPT_SMI:
-        case MLX4_IB_QPT_GSI:
-        case MLX4_IB_QPT_RAW_PACKET:    return MLX4_QP_ST_MLX;
-
-        case MLX4_IB_QPT_PROXY_SMI_OWNER:
-        case MLX4_IB_QPT_TUN_SMI_OWNER: return (mlx4_is_mfunc(dev->dev) ?
-                                                MLX4_QP_ST_MLX : -1);
-        case MLX4_IB_QPT_PROXY_SMI:
-        case MLX4_IB_QPT_TUN_SMI:
-        case MLX4_IB_QPT_PROXY_GSI:
-        case MLX4_IB_QPT_TUN_GSI:       return (mlx4_is_mfunc(dev->dev) ?
-                                                MLX4_QP_ST_UD : -1);
-        default:                        return -1;
+        case IB_QPT_RC:         return MLX4_QP_ST_RC;
+        case IB_QPT_UC:         return MLX4_QP_ST_UC;
+        case IB_QPT_UD:         return MLX4_QP_ST_UD;
+        case IB_QPT_SMI:
+        case IB_QPT_GSI:        return MLX4_QP_ST_MLX;
+        default:                return -1;
         }
 }
 
@@ -1166,7 +896,7 @@ static int mlx4_set_path(struct mlx4_ib_dev *dev, const struct ib_ah_attr *ah,
 
         if (ah->ah_flags & IB_AH_GRH) {
                 if (ah->grh.sgid_index >= dev->dev->caps.gid_table_len[port]) {
-                        pr_err("sgid_index (%u) too large. max is %d\n",
+                        printk(KERN_ERR "sgid_index (%u) too large. max is %d\n",
                                ah->grh.sgid_index, dev->dev->caps.gid_table_len[port] - 1);
                         return -1;
                 }
@@ -1182,7 +912,7 @@ static int mlx4_set_path(struct mlx4_ib_dev *dev, const struct ib_ah_attr *ah,
 
         if (is_eth) {
                 path->sched_queue = MLX4_IB_DEFAULT_SCHED_QUEUE |
-                        ((port - 1) << 6) | ((ah->sl & 7) << 3);
+                        ((port - 1) << 6) | ((ah->sl & 7) << 3) | ((ah->sl & 8) >> 1);
 
                 if (!(ah->ah_flags & IB_AH_GRH))
                         return -1;
@@ -1229,8 +959,6 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
 {
         struct mlx4_ib_dev *dev = to_mdev(ibqp->device);
         struct mlx4_ib_qp *qp = to_mqp(ibqp);
-        struct mlx4_ib_pd *pd;
-        struct mlx4_ib_cq *send_cq, *recv_cq;
         struct mlx4_qp_context *context;
         enum mlx4_qp_optpar optpar = 0;
         int sqd_event;
@@ -1241,7 +969,7 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                 return -ENOMEM;
 
         context->flags = cpu_to_be32((to_mlx4_state(new_state) << 28) |
-                                     (to_mlx4_st(dev, qp->mlx4_ib_qp_type) << 16));
+                                     (to_mlx4_st(ibqp->qp_type) << 16));
 
         if (!(attr_mask & IB_QP_PATH_MIG_STATE))
                 context->flags |= cpu_to_be32(MLX4_QP_PM_MIGRATED << 11);
@@ -1262,8 +990,6 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
 
         if (ibqp->qp_type == IB_QPT_GSI || ibqp->qp_type == IB_QPT_SMI)
                 context->mtu_msgmax = (IB_MTU_4096 << 5) | 11;
-        else if (ibqp->qp_type == IB_QPT_RAW_PACKET)
-                context->mtu_msgmax = (MLX4_RAW_QP_MTU << 5) | MLX4_RAW_QP_MSGMAX;
         else if (ibqp->qp_type == IB_QPT_UD) {
                 if (qp->flags & MLX4_IB_QP_LSO)
                         context->mtu_msgmax = (IB_MTU_4096 << 5) |
@@ -1272,7 +998,7 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                         context->mtu_msgmax = (IB_MTU_4096 << 5) | 12;
         } else if (attr_mask & IB_QP_PATH_MTU) {
                 if (attr->path_mtu < IB_MTU_256 || attr->path_mtu > IB_MTU_4096) {
-                        pr_err("path MTU (%u) is invalid\n",
+                        printk(KERN_ERR "path MTU (%u) is invalid\n",
                                attr->path_mtu);
                         goto out;
                 }
@@ -1288,10 +1014,8 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                 context->sq_size_stride = ilog2(qp->sq.wqe_cnt) << 3;
         context->sq_size_stride |= qp->sq.wqe_shift - 4;
 
-        if (cur_state == IB_QPS_RESET && new_state == IB_QPS_INIT) {
+        if (cur_state == IB_QPS_RESET && new_state == IB_QPS_INIT)
                 context->sq_size_stride |= !!qp->sq_no_prefetch << 7;
-                context->xrcd = cpu_to_be32((u32) qp->xrcdn);
-        }
 
         if (qp->ibqp.uobject)
                 context->usr_page = cpu_to_be32(to_mucontext(ibqp->uobject->context)->uar.index);
@@ -1319,16 +1043,13 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         }
 
         if (attr_mask & IB_QP_PKEY_INDEX) {
-                if (qp->mlx4_ib_qp_type & MLX4_IB_QPT_ANY_SRIOV)
-                        context->pri_path.disable_pkey_check = 0x40;
                 context->pri_path.pkey_index = attr->pkey_index;
                 optpar |= MLX4_QP_OPTPAR_PKEY_INDEX;
         }
 
         if (attr_mask & IB_QP_AV) {
                 if (mlx4_set_path(dev, &attr->ah_attr, &context->pri_path,
-                                  attr_mask & IB_QP_PORT ?
-                                  attr->port_num : qp->port))
+                                  attr_mask & IB_QP_PORT ? attr->port_num : qp->port))
                         goto out;
 
                 optpar |= (MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH |
@@ -1358,12 +1079,8 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                 optpar |= MLX4_QP_OPTPAR_ALT_ADDR_PATH;
         }
 
-        pd = get_pd(qp);
-        get_cqs(qp, &send_cq, &recv_cq);
-        context->pd       = cpu_to_be32(pd->pdn);
-        context->cqn_send = cpu_to_be32(send_cq->mcq.cqn);
-        context->cqn_recv = cpu_to_be32(recv_cq->mcq.cqn);
-        context->params1  = cpu_to_be32(MLX4_IB_ACK_REQ_FREQ << 28);
+        context->pd         = cpu_to_be32(to_mpd(ibqp->pd)->pdn);
+        context->params1    = cpu_to_be32(MLX4_IB_ACK_REQ_FREQ << 28);
 
         /* Set "fast registration enabled" for all kernel QPs */
         if (!qp->ibqp.uobject)
@@ -1389,6 +1106,8 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         if (attr_mask & IB_QP_SQ_PSN)
                 context->next_send_psn = cpu_to_be32(attr->sq_psn);
 
+        context->cqn_send = cpu_to_be32(to_mcq(ibqp->send_cq)->mcq.cqn);
+
         if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC) {
                 if (attr->max_dest_rd_atomic)
                         context->params2 |=
@@ -1411,50 +1130,28 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         if (attr_mask & IB_QP_RQ_PSN)
                 context->rnr_nextrecvpsn |= cpu_to_be32(attr->rq_psn);
 
-        /* proxy and tunnel qp qkeys will be changed in modify-qp wrappers */
+        context->cqn_recv = cpu_to_be32(to_mcq(ibqp->recv_cq)->mcq.cqn);
+
         if (attr_mask & IB_QP_QKEY) {
-                if (qp->mlx4_ib_qp_type &
-                    (MLX4_IB_QPT_PROXY_SMI_OWNER | MLX4_IB_QPT_TUN_SMI_OWNER))
-                        context->qkey = cpu_to_be32(IB_QP_SET_QKEY);
-                else {
-                        if (mlx4_is_mfunc(dev->dev) &&
-                            !(qp->mlx4_ib_qp_type & MLX4_IB_QPT_ANY_SRIOV) &&
-                            (attr->qkey & MLX4_RESERVED_QKEY_MASK) ==
-                            MLX4_RESERVED_QKEY_BASE) {
-                                pr_err("Cannot use reserved QKEY"
-                                       " 0x%x (range 0xffff0000..0xffffffff"
-                                       " is reserved)\n", attr->qkey);
-                                err = -EINVAL;
-                                goto out;
-                        }
-                        context->qkey = cpu_to_be32(attr->qkey);
-                }
+                context->qkey = cpu_to_be32(attr->qkey);
                 optpar |= MLX4_QP_OPTPAR_Q_KEY;
         }
 
         if (ibqp->srq)
                 context->srqn = cpu_to_be32(1 << 24 | to_msrq(ibqp->srq)->msrq.srqn);
 
-        if (qp->rq.wqe_cnt && cur_state == IB_QPS_RESET && new_state == IB_QPS_INIT)
+        if (!ibqp->srq && cur_state == IB_QPS_RESET && new_state == IB_QPS_INIT)
                 context->db_rec_addr = cpu_to_be64(qp->db.dma);
 
         if (cur_state == IB_QPS_INIT &&
             new_state == IB_QPS_RTR  &&
             (ibqp->qp_type == IB_QPT_GSI || ibqp->qp_type == IB_QPT_SMI ||
-             ibqp->qp_type == IB_QPT_UD ||
-             ibqp->qp_type == IB_QPT_RAW_PACKET)) {
+             ibqp->qp_type == IB_QPT_UD)) {
                 context->pri_path.sched_queue = (qp->port - 1) << 6;
-                if (qp->mlx4_ib_qp_type == MLX4_IB_QPT_SMI ||
-                    qp->mlx4_ib_qp_type &
-                    (MLX4_IB_QPT_PROXY_SMI_OWNER | MLX4_IB_QPT_TUN_SMI_OWNER)) {
+                if (is_qp0(dev, qp))
                         context->pri_path.sched_queue |= MLX4_IB_DEFAULT_QP0_SCHED_QUEUE;
-                        if (qp->mlx4_ib_qp_type != MLX4_IB_QPT_SMI)
-                                context->pri_path.fl = 0x80;
-                } else {
-                        if (qp->mlx4_ib_qp_type & MLX4_IB_QPT_ANY_SRIOV)
-                                context->pri_path.fl = 0x80;
+                else
                         context->pri_path.sched_queue |= MLX4_IB_DEFAULT_SCHED_QUEUE;
-                }
         }
 
         if (cur_state == IB_QPS_RTS && new_state == IB_QPS_SQD  &&
@@ -1515,7 +1212,7 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         if (is_qp0(dev, qp)) {
                 if (cur_state != IB_QPS_RTR && new_state == IB_QPS_RTR)
                         if (mlx4_INIT_PORT(dev->dev, qp->port))
-                                pr_warn("INIT_PORT failed for port %d\n",
+                                printk(KERN_WARNING "INIT_PORT failed for port %d\n",
                                        qp->port);
 
                 if (cur_state != IB_QPS_RESET && cur_state != IB_QPS_ERR &&
@@ -1528,17 +1225,17 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
          * entries and reinitialize the QP.
          */
         if (new_state == IB_QPS_RESET && !ibqp->uobject) {
-                mlx4_ib_cq_clean(recv_cq, qp->mqp.qpn,
+                mlx4_ib_cq_clean(to_mcq(ibqp->recv_cq), qp->mqp.qpn,
                                  ibqp->srq ? to_msrq(ibqp->srq): NULL);
-                if (send_cq != recv_cq)
-                        mlx4_ib_cq_clean(send_cq, qp->mqp.qpn, NULL);
+                if (ibqp->send_cq != ibqp->recv_cq)
+                        mlx4_ib_cq_clean(to_mcq(ibqp->send_cq), qp->mqp.qpn, NULL);
 
                 qp->rq.head = 0;
                 qp->rq.tail = 0;
                 qp->sq.head = 0;
                 qp->sq.tail = 0;
                 qp->sq_next_wqe = 0;
-                if (qp->rq.wqe_cnt)
+                if (!ibqp->srq)
                         *qp->db.db  = 0;
         }
 
@@ -1560,55 +1257,27 @@ int mlx4_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         cur_state = attr_mask & IB_QP_CUR_STATE ? attr->cur_qp_state : qp->state;
         new_state = attr_mask & IB_QP_STATE ? attr->qp_state : cur_state;
 
-        if (!ib_modify_qp_is_ok(cur_state, new_state, ibqp->qp_type, attr_mask)) {
-                pr_debug("qpn 0x%x: invalid attribute mask specified "
-                         "for transition %d to %d. qp_type %d,"
-                         " attr_mask 0x%x\n",
-                         ibqp->qp_num, cur_state, new_state,
-                         ibqp->qp_type, attr_mask);
+        if (!ib_modify_qp_is_ok(cur_state, new_state, ibqp->qp_type, attr_mask))
                 goto out;
-        }
 
         if ((attr_mask & IB_QP_PORT) &&
-            (attr->port_num == 0 || attr->port_num > dev->num_ports)) {
-                pr_debug("qpn 0x%x: invalid port number (%d) specified "
-                         "for transition %d to %d. qp_type %d\n",
-                         ibqp->qp_num, attr->port_num, cur_state,
-                         new_state, ibqp->qp_type);
+            (attr->port_num == 0 || attr->port_num > dev->dev->caps.num_ports)) {
                 goto out;
         }
 
-        if ((attr_mask & IB_QP_PORT) && (ibqp->qp_type == IB_QPT_RAW_PACKET) &&
-            (rdma_port_get_link_layer(&dev->ib_dev, attr->port_num) !=
-             IB_LINK_LAYER_ETHERNET))
-                goto out;
-
         if (attr_mask & IB_QP_PKEY_INDEX) {
                 int p = attr_mask & IB_QP_PORT ? attr->port_num : qp->port;
-                if (attr->pkey_index >= dev->dev->caps.pkey_table_len[p]) {
-                        pr_debug("qpn 0x%x: invalid pkey index (%d) specified "
-                                 "for transition %d to %d. qp_type %d\n",
-                                 ibqp->qp_num, attr->pkey_index, cur_state,
-                                 new_state, ibqp->qp_type);
+                if (attr->pkey_index >= dev->dev->caps.pkey_table_len[p])
                         goto out;
-                }
         }
 
         if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC &&
             attr->max_rd_atomic > dev->dev->caps.max_qp_init_rdma) {
-                pr_debug("qpn 0x%x: max_rd_atomic (%d) too large. "
-                         "Transition %d to %d. qp_type %d\n",
-                         ibqp->qp_num, attr->max_rd_atomic, cur_state,
-                         new_state, ibqp->qp_type);
                 goto out;
         }
 
         if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC &&
             attr->max_dest_rd_atomic > dev->dev->caps.max_qp_dest_rdma) {
-                pr_debug("qpn 0x%x: max_dest_rd_atomic (%d) too large. "
-                         "Transition %d to %d. qp_type %d\n",
-                         ibqp->qp_num, attr->max_dest_rd_atomic, cur_state,
-                         new_state, ibqp->qp_type);
                 goto out;
         }
 
@@ -1624,114 +1293,6 @@ out:
         return err;
 }
 
-static int build_sriov_qp0_header(struct mlx4_ib_sqp *sqp,
-                                  struct ib_send_wr *wr,
-                                  void *wqe, unsigned *mlx_seg_len)
-{
-        struct mlx4_ib_dev *mdev = to_mdev(sqp->qp.ibqp.device);
-        struct ib_device *ib_dev = &mdev->ib_dev;
-        struct mlx4_wqe_mlx_seg *mlx = wqe;
-        struct mlx4_wqe_inline_seg *inl = wqe + sizeof *mlx;
-        struct mlx4_ib_ah *ah = to_mah(wr->wr.ud.ah);
-        u16 pkey;
-        u32 qkey;
-        int send_size;
-        int header_size;
-        int spc;
-        int i;
-
-        if (wr->opcode != IB_WR_SEND)
-                return -EINVAL;
-
-        send_size = 0;
-
-        for (i = 0; i < wr->num_sge; ++i)
-                send_size += wr->sg_list[i].length;
-
-        /* for proxy-qp0 sends, need to add in size of tunnel header */
-        /* for tunnel-qp0 sends, tunnel header is already in s/g list */
-        if (sqp->qp.mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_SMI_OWNER)
-                send_size += sizeof (struct mlx4_ib_tunnel_header);
-
-        ib_ud_header_init(send_size, 1, 0, 0, 0, 0, &sqp->ud_header);
-
-        if (sqp->qp.mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_SMI_OWNER) {
-                sqp->ud_header.lrh.service_level =
-                        be32_to_cpu(ah->av.ib.sl_tclass_flowlabel) >> 28;
-                sqp->ud_header.lrh.destination_lid =
-                        cpu_to_be16(ah->av.ib.g_slid & 0x7f);
-                sqp->ud_header.lrh.source_lid =
-                        cpu_to_be16(ah->av.ib.g_slid & 0x7f);
-        }
-
-        mlx->flags &= cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE);
-
-        /* force loopback */
-        mlx->flags |= cpu_to_be32(MLX4_WQE_MLX_VL15 | 0x1 | MLX4_WQE_MLX_SLR);
-        mlx->rlid = sqp->ud_header.lrh.destination_lid;
-
-        sqp->ud_header.lrh.virtual_lane    = 0;
-        sqp->ud_header.bth.solicited_event = !!(wr->send_flags & IB_SEND_SOLICITED);
-        ib_get_cached_pkey(ib_dev, sqp->qp.port, 0, &pkey);
-        sqp->ud_header.bth.pkey = cpu_to_be16(pkey);
-        if (sqp->qp.mlx4_ib_qp_type == MLX4_IB_QPT_TUN_SMI_OWNER)
-                sqp->ud_header.bth.destination_qpn = cpu_to_be32(wr->wr.ud.remote_qpn);
-        else
-                sqp->ud_header.bth.destination_qpn =
-                        cpu_to_be32(mdev->dev->caps.qp0_tunnel[sqp->qp.port - 1]);
-
-        sqp->ud_header.bth.psn = cpu_to_be32((sqp->send_psn++) & ((1 << 24) - 1));
-        if (mlx4_get_parav_qkey(mdev->dev, sqp->qp.mqp.qpn, &qkey))
-                return -EINVAL;
-        sqp->ud_header.deth.qkey = cpu_to_be32(qkey);
-        sqp->ud_header.deth.source_qpn = cpu_to_be32(sqp->qp.mqp.qpn);
-
-        sqp->ud_header.bth.opcode        = IB_OPCODE_UD_SEND_ONLY;
-        sqp->ud_header.immediate_present = 0;
-
-        header_size = ib_ud_header_pack(&sqp->ud_header, sqp->header_buf);
-
-        /*
-         * Inline data segments may not cross a 64 byte boundary.  If
-         * our UD header is bigger than the space available up to the
-         * next 64 byte boundary in the WQE, use two inline data
-         * segments to hold the UD header.
-         */
-        spc = MLX4_INLINE_ALIGN -
-              ((unsigned long) (inl + 1) & (MLX4_INLINE_ALIGN - 1));
-        if (header_size <= spc) {
-                inl->byte_count = cpu_to_be32(1 << 31 | header_size);
-                memcpy(inl + 1, sqp->header_buf, header_size);
-                i = 1;
-        } else {
-                inl->byte_count = cpu_to_be32(1 << 31 | spc);
-                memcpy(inl + 1, sqp->header_buf, spc);
-
-                inl = (void *) (inl + 1) + spc;
-                memcpy(inl + 1, sqp->header_buf + spc, header_size - spc);
-                /*
-                 * Need a barrier here to make sure all the data is
-                 * visible before the byte_count field is set.
-                 * Otherwise the HCA prefetcher could grab the 64-byte
-                 * chunk with this inline segment and get a valid (!=
-                 * 0xffffffff) byte count but stale data, and end up
-                 * generating a packet with bad headers.
-                 *
-                 * The first inline segment's byte_count field doesn't
-                 * need a barrier, because it comes after a
-                 * control/MLX segment and therefore is at an offset
-                 * of 16 mod 64.
-                 */
-                wmb();
-                inl->byte_count = cpu_to_be32(1 << 31 | (header_size - spc));
-                i = 2;
-        }
-
-        *mlx_seg_len =
-        ALIGN(i * sizeof (struct mlx4_wqe_inline_seg) + header_size, 16);
-        return 0;
-}
-
 static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
                             void *wqe, unsigned *mlx_seg_len)
 {
@@ -1739,7 +1300,6 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
         struct mlx4_wqe_mlx_seg *mlx = wqe;
         struct mlx4_wqe_inline_seg *inl = wqe + sizeof *mlx;
         struct mlx4_ib_ah *ah = to_mah(wr->wr.ud.ah);
-        struct net_device *ndev;
         union ib_gid sgid;
         u16 pkey;
         int send_size;
@@ -1749,8 +1309,7 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
         int is_eth;
         int is_vlan = 0;
         int is_grh;
-        u16 vlan;
-        int err = 0;
+        u16 vlan = 0;
 
         send_size = 0;
         for (i = 0; i < wr->num_sge; ++i)
@@ -1759,24 +1318,8 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
         is_eth = rdma_port_get_link_layer(sqp->qp.ibqp.device, sqp->qp.port) == IB_LINK_LAYER_ETHERNET;
         is_grh = mlx4_ib_ah_grh_present(ah);
         if (is_eth) {
-                if (mlx4_is_mfunc(to_mdev(ib_dev)->dev)) {
-                        /* When multi-function is enabled, the ib_core gid
-                         * indexes don't necessarily match the hw ones, so
-                         * we must use our own cache */
-                        sgid.global.subnet_prefix =
-                                to_mdev(ib_dev)->sriov.demux[sqp->qp.port - 1].
-                                subnet_prefix;
-                        sgid.global.interface_id =
-                                to_mdev(ib_dev)->sriov.demux[sqp->qp.port - 1].
-                                guid_cache[ah->av.ib.gid_index];
-                } else  {
-                        err = ib_get_cached_gid(ib_dev,
-                                                be32_to_cpu(ah->av.ib.port_pd) >> 24,
-                                                ah->av.ib.gid_index, &sgid);
-                        if (err)
-                                return err;
-                }
-
+                ib_get_cached_gid(ib_dev, be32_to_cpu(ah->av.ib.port_pd) >> 24,
+                                  ah->av.ib.gid_index, &sgid);
                 vlan = rdma_get_vlan_id(&sgid);
                 is_vlan = vlan < 0x1000;
         }
@@ -1795,21 +1338,8 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
                 sqp->ud_header.grh.flow_label    =
                         ah->av.ib.sl_tclass_flowlabel & cpu_to_be32(0xfffff);
                 sqp->ud_header.grh.hop_limit     = ah->av.ib.hop_limit;
-                if (mlx4_is_mfunc(to_mdev(ib_dev)->dev)) {
-                        /* When multi-function is enabled, the ib_core gid
-                         * indexes don't necessarily match the hw ones, so
-                         * we must use our own cache */
-                        sqp->ud_header.grh.source_gid.global.subnet_prefix =
-                                to_mdev(ib_dev)->sriov.demux[sqp->qp.port - 1].
-                                                       subnet_prefix;
-                        sqp->ud_header.grh.source_gid.global.interface_id =
-                                to_mdev(ib_dev)->sriov.demux[sqp->qp.port - 1].
-                                               guid_cache[ah->av.ib.gid_index];
-                } else
-                        ib_get_cached_gid(ib_dev,
-                                          be32_to_cpu(ah->av.ib.port_pd) >> 24,
-                                          ah->av.ib.gid_index,
-                                          &sqp->ud_header.grh.source_gid);
+                ib_get_cached_gid(ib_dev, be32_to_cpu(ah->av.ib.port_pd) >> 24,
+                                  ah->av.ib.gid_index, &sqp->ud_header.grh.source_gid);
                 memcpy(sqp->ud_header.grh.destination_gid.raw,
                        ah->av.ib.dgid, 16);
         }
@@ -1821,8 +1351,6 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
                                           (sqp->ud_header.lrh.destination_lid ==
                                            IB_LID_PERMISSIVE ? MLX4_WQE_MLX_SLR : 0) |
                                           (sqp->ud_header.lrh.service_level << 8));
-                if (ah->av.ib.port_pd & cpu_to_be32(0x80000000))
-                        mlx->flags |= cpu_to_be32(0x1); /* force loopback */
                 mlx->rlid = sqp->ud_header.lrh.destination_lid;
         }
 
@@ -1842,23 +1370,20 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
 
         if (is_eth) {
                 u8 *smac;
-                u16 pcp = (be32_to_cpu(ah->av.ib.sl_tclass_flowlabel) >> 29) << 13;
-
-                mlx->sched_prio = cpu_to_be16(pcp);
 
                 memcpy(sqp->ud_header.eth.dmac_h, ah->av.eth.mac, 6);
                 /* FIXME: cache smac value? */
-                ndev = to_mdev(sqp->qp.ibqp.device)->iboe.netdevs[sqp->qp.port - 1];
-                if (!ndev)
-                        return -ENODEV;
-                smac = ndev->dev_addr;
+                smac = to_mdev(sqp->qp.ibqp.device)->iboe.netdevs[sqp->qp.port - 1]->dev_addr;
                 memcpy(sqp->ud_header.eth.smac_h, smac, 6);
                 if (!memcmp(sqp->ud_header.eth.smac_h, sqp->ud_header.eth.dmac_h, 6))
                         mlx->flags |= cpu_to_be32(MLX4_WQE_CTRL_FORCE_LOOPBACK);
                 if (!is_vlan) {
                         sqp->ud_header.eth.type = cpu_to_be16(MLX4_IB_IBOE_ETHERTYPE);
                 } else {
+                        u16 pcp;
+
                         sqp->ud_header.vlan.type = cpu_to_be16(MLX4_IB_IBOE_ETHERTYPE);
+                        pcp = (be32_to_cpu(ah->av.ib.sl_tclass_flowlabel) >> 27 & 3) << 13;
                         sqp->ud_header.vlan.tag = cpu_to_be16(vlan | pcp);
                 }
         } else {
@@ -1881,16 +1406,16 @@ static int build_mlx_header(struct mlx4_ib_sqp *sqp, struct ib_send_wr *wr,
         header_size = ib_ud_header_pack(&sqp->ud_header, sqp->header_buf);
 
         if (0) {
-                pr_err("built UD header of size %d:\n", header_size);
+                printk(KERN_ERR "built UD header of size %d:\n", header_size);
                 for (i = 0; i < header_size / 4; ++i) {
                         if (i % 8 == 0)
-                                pr_err("  [%02x] ", i * 4);
-                        pr_cont(" %08x",
-                                be32_to_cpu(((__be32 *) sqp->header_buf)[i]));
+                                printk("  [%02x] ", i * 4);
+                        printk(" %08x",
+                               be32_to_cpu(((__be32 *) sqp->header_buf)[i]));
                         if ((i + 1) % 8 == 0)
-                                pr_cont("\n");
+                                printk("\n");
                 }
-                pr_err("\n");
+                printk("\n");
         }
 
         /*
@@ -2022,70 +1547,14 @@ static void set_masked_atomic_seg(struct mlx4_wqe_masked_atomic_seg *aseg,
 }
 
 static void set_datagram_seg(struct mlx4_wqe_datagram_seg *dseg,
-                             struct ib_send_wr *wr)
+                             struct ib_send_wr *wr, __be16 *vlan)
 {
         memcpy(dseg->av, &to_mah(wr->wr.ud.ah)->av, sizeof (struct mlx4_av));
         dseg->dqpn = cpu_to_be32(wr->wr.ud.remote_qpn);
         dseg->qkey = cpu_to_be32(wr->wr.ud.remote_qkey);
         dseg->vlan = to_mah(wr->wr.ud.ah)->av.eth.vlan;
         memcpy(dseg->mac, to_mah(wr->wr.ud.ah)->av.eth.mac, 6);
-}
-
-static void set_tunnel_datagram_seg(struct mlx4_ib_dev *dev,
-                                    struct mlx4_wqe_datagram_seg *dseg,
-                                    struct ib_send_wr *wr, enum ib_qp_type qpt)
-{
-        union mlx4_ext_av *av = &to_mah(wr->wr.ud.ah)->av;
-        struct mlx4_av sqp_av = {0};
-        int port = *((u8 *) &av->ib.port_pd) & 0x3;
-
-        /* force loopback */
-        sqp_av.port_pd = av->ib.port_pd | cpu_to_be32(0x80000000);
-        sqp_av.g_slid = av->ib.g_slid & 0x7f; /* no GRH */
-        sqp_av.sl_tclass_flowlabel = av->ib.sl_tclass_flowlabel &
-                        cpu_to_be32(0xf0000000);
-
-        memcpy(dseg->av, &sqp_av, sizeof (struct mlx4_av));
-        /* This function used only for sending on QP1 proxies */
-        dseg->dqpn = cpu_to_be32(dev->dev->caps.qp1_tunnel[port - 1]);
-        /* Use QKEY from the QP context, which is set by master */
-        dseg->qkey = cpu_to_be32(IB_QP_SET_QKEY);
-}
-
-static void build_tunnel_header(struct ib_send_wr *wr, void *wqe, unsigned *mlx_seg_len)
-{
-        struct mlx4_wqe_inline_seg *inl = wqe;
-        struct mlx4_ib_tunnel_header hdr;
-        struct mlx4_ib_ah *ah = to_mah(wr->wr.ud.ah);
-        int spc;
-        int i;
-
-        memcpy(&hdr.av, &ah->av, sizeof hdr.av);
-        hdr.remote_qpn = cpu_to_be32(wr->wr.ud.remote_qpn);
-        hdr.pkey_index = cpu_to_be16(wr->wr.ud.pkey_index);
-        hdr.qkey = cpu_to_be32(wr->wr.ud.remote_qkey);
-
-        spc = MLX4_INLINE_ALIGN -
-                ((unsigned long) (inl + 1) & (MLX4_INLINE_ALIGN - 1));
-        if (sizeof (hdr) <= spc) {
-                memcpy(inl + 1, &hdr, sizeof (hdr));
-                wmb();
-                inl->byte_count = cpu_to_be32(1 << 31 | sizeof (hdr));
-                i = 1;
-        } else {
-                memcpy(inl + 1, &hdr, spc);
-                wmb();
-                inl->byte_count = cpu_to_be32(1 << 31 | spc);
-
-                inl = (void *) (inl + 1) + spc;
-                memcpy(inl + 1, (void *) &hdr + spc, sizeof (hdr) - spc);
-                wmb();
-                inl->byte_count = cpu_to_be32(1 << 31 | (sizeof (hdr) - spc));
-                i = 2;
-        }
-
-        *mlx_seg_len =
-                ALIGN(i * sizeof (struct mlx4_wqe_inline_seg) + sizeof (hdr), 16);
+        *vlan = dseg->vlan;
 }
 
 static void set_mlx_icrc_seg(void *dseg)
@@ -2169,13 +1638,6 @@ static __be32 send_ieth(struct ib_send_wr *wr)
         }
 }
 
-static void add_zero_len_inline(void *wqe)
-{
-        struct mlx4_wqe_inline_seg *inl = wqe;
-        memset(wqe, 0, 16);
-        inl->byte_count = cpu_to_be32(1 << 31);
-}
-
 int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                       struct ib_send_wr **bad_wr)
 {
@@ -2195,6 +1657,7 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
         __be32 uninitialized_var(lso_hdr_sz);
         __be32 blh;
         int i;
+        __be16 vlan = cpu_to_be16(0xffff);
 
         spin_lock_irqsave(&qp->sq.lock, flags);
 
@@ -2234,9 +1697,9 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 wqe += sizeof *ctrl;
                 size = sizeof *ctrl / 16;
 
-                switch (qp->mlx4_ib_qp_type) {
-                case MLX4_IB_QPT_RC:
-                case MLX4_IB_QPT_UC:
+                switch (ibqp->qp_type) {
+                case IB_QPT_RC:
+                case IB_QPT_UC:
                         switch (wr->opcode) {
                         case IB_WR_ATOMIC_CMP_AND_SWP:
                         case IB_WR_ATOMIC_FETCH_AND_ADD:
@@ -2297,26 +1760,8 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         }
                         break;
 
-                case MLX4_IB_QPT_TUN_SMI_OWNER:
-                        err =  build_sriov_qp0_header(to_msqp(qp), wr, ctrl, &seglen);
-                        if (unlikely(err)) {
-                                *bad_wr = wr;
-                                goto out;
-                        }
-                        wqe  += seglen;
-                        size += seglen / 16;
-                        break;
-                case MLX4_IB_QPT_TUN_SMI:
-                case MLX4_IB_QPT_TUN_GSI:
-                        /* this is a UD qp used in MAD responses to slaves. */
-                        set_datagram_seg(wqe, wr);
-                        /* set the forced-loopback bit in the data seg av */
-                        *(__be32 *) wqe |= cpu_to_be32(0x80000000);
-                        wqe  += sizeof (struct mlx4_wqe_datagram_seg);
-                        size += sizeof (struct mlx4_wqe_datagram_seg) / 16;
-                        break;
-                case MLX4_IB_QPT_UD:
-                        set_datagram_seg(wqe, wr);
+                case IB_QPT_UD:
+                        set_datagram_seg(wqe, wr, &vlan);
                         wqe  += sizeof (struct mlx4_wqe_datagram_seg);
                         size += sizeof (struct mlx4_wqe_datagram_seg) / 16;
 
@@ -2332,47 +1777,8 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         }
                         break;
 
-                case MLX4_IB_QPT_PROXY_SMI_OWNER:
-                        if (unlikely(!mlx4_is_master(to_mdev(ibqp->device)->dev))) {
-                                err = -ENOSYS;
-                                *bad_wr = wr;
-                                goto out;
-                        }
-                        err = build_sriov_qp0_header(to_msqp(qp), wr, ctrl, &seglen);
-                        if (unlikely(err)) {
-                                *bad_wr = wr;
-                                goto out;
-                        }
-                        wqe  += seglen;
-                        size += seglen / 16;
-                        /* to start tunnel header on a cache-line boundary */
-                        add_zero_len_inline(wqe);
-                        wqe += 16;
-                        size++;
-                        build_tunnel_header(wr, wqe, &seglen);
-                        wqe  += seglen;
-                        size += seglen / 16;
-                        break;
-                case MLX4_IB_QPT_PROXY_SMI:
-                        /* don't allow QP0 sends on guests */
-                        err = -ENOSYS;
-                        *bad_wr = wr;
-                        goto out;
-                case MLX4_IB_QPT_PROXY_GSI:
-                        /* If we are tunneling special qps, this is a UD qp.
-                         * In this case we first add a UD segment targeting
-                         * the tunnel qp, and then add a header with address
-                         * information */
-                        set_tunnel_datagram_seg(to_mdev(ibqp->device), wqe, wr, ibqp->qp_type);
-                        wqe  += sizeof (struct mlx4_wqe_datagram_seg);
-                        size += sizeof (struct mlx4_wqe_datagram_seg) / 16;
-                        build_tunnel_header(wr, wqe, &seglen);
-                        wqe  += seglen;
-                        size += seglen / 16;
-                        break;
-
-                case MLX4_IB_QPT_SMI:
-                case MLX4_IB_QPT_GSI:
+                case IB_QPT_SMI:
+                case IB_QPT_GSI:
                         err = build_mlx_header(to_msqp(qp), wr, ctrl, &seglen);
                         if (unlikely(err)) {
                                 *bad_wr = wr;
@@ -2398,10 +1804,8 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 size += wr->num_sge * (sizeof (struct mlx4_wqe_data_seg) / 16);
 
                 /* Add one more inline data segment for ICRC for MLX sends */
-                if (unlikely(qp->mlx4_ib_qp_type == MLX4_IB_QPT_SMI ||
-                             qp->mlx4_ib_qp_type == MLX4_IB_QPT_GSI ||
-                             qp->mlx4_ib_qp_type &
-                             (MLX4_IB_QPT_PROXY_SMI_OWNER | MLX4_IB_QPT_TUN_SMI_OWNER))) {
+                if (unlikely(qp->ibqp.qp_type == IB_QPT_SMI ||
+                             qp->ibqp.qp_type == IB_QPT_GSI)) {
                         set_mlx_icrc_seg(dseg + 1);
                         size += sizeof (struct mlx4_wqe_data_seg) / 16;
                 }
@@ -2420,6 +1824,11 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 ctrl->fence_size = (wr->send_flags & IB_SEND_FENCE ?
                                     MLX4_WQE_CTRL_FENCE : 0) | size;
 
+                if (be16_to_cpu(vlan) < 0x1000) {
+                        ctrl->ins_vlan = 1 << 6;
+                        ctrl->vlan_tag = vlan;
+                }
+
                 /*
                  * Make sure descriptor is fully written before
                  * setting ownership bit (because HW can start
@@ -2428,7 +1837,6 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 wmb();
 
                 if (wr->opcode < 0 || wr->opcode >= ARRAY_SIZE(mlx4_ib_opcode)) {
-                        *bad_wr = wr;
                         err = -EINVAL;
                         goto out;
                 }
@@ -2493,10 +1901,8 @@ int mlx4_ib_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *wr,
         int err = 0;
         int nreq;
         int ind;
-        int max_gs;
         int i;
 
-        max_gs = qp->rq.max_gs;
         spin_lock_irqsave(&qp->rq.lock, flags);
 
         ind = qp->rq.head & (qp->rq.wqe_cnt - 1);
@@ -2516,25 +1922,10 @@ int mlx4_ib_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *wr,
 
                 scat = get_recv_wqe(qp, ind);
 
-                if (qp->mlx4_ib_qp_type & (MLX4_IB_QPT_PROXY_SMI_OWNER |
-                    MLX4_IB_QPT_PROXY_SMI | MLX4_IB_QPT_PROXY_GSI)) {
-                        ib_dma_sync_single_for_device(ibqp->device,
-                                                      qp->sqp_proxy_rcv[ind].map,
-                                                      sizeof (struct mlx4_ib_proxy_sqp_hdr),
-                                                      DMA_FROM_DEVICE);
-                        scat->byte_count =
-                                cpu_to_be32(sizeof (struct mlx4_ib_proxy_sqp_hdr));
-                        /* use dma lkey from upper layer entry */
-                        scat->lkey = cpu_to_be32(wr->sg_list->lkey);
-                        scat->addr = cpu_to_be64(qp->sqp_proxy_rcv[ind].map);
-                        scat++;
-                        max_gs--;
-                }
-
                 for (i = 0; i < wr->num_sge; ++i)
                         __set_data_seg(scat + i, wr->sg_list + i);
 
-                if (i < max_gs) {
+                if (i < qp->rq.max_gs) {
                         scat[i].byte_count = 0;
                         scat[i].lkey       = cpu_to_be32(MLX4_INVALID_LKEY);
                         scat[i].addr       = 0;
@@ -2729,10 +2120,6 @@ done:
         if (qp->flags & MLX4_IB_QP_LSO)
                 qp_init_attr->create_flags |= IB_QP_CREATE_IPOIB_UD_LSO;
 
-        qp_init_attr->sq_sig_type =
-                qp->sq_signal_bits == cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE) ?
-                IB_SIGNAL_ALL_WR : IB_SIGNAL_REQ_WR;
-
 out:
         mutex_unlock(&qp->mutex);
         return err;
diff --git a/drivers/infiniband/hw/mlx4/srq.c b/drivers/infiniband/hw/mlx4/srq.c
index 60c5fb025fc..818b7ecace5 100644
--- a/drivers/infiniband/hw/mlx4/srq.c
+++ b/drivers/infiniband/hw/mlx4/srq.c
@@ -59,7 +59,7 @@ static void mlx4_ib_srq_event(struct mlx4_srq *srq, enum mlx4_event type)
                         event.event = IB_EVENT_SRQ_ERR;
                         break;
                 default:
-                        pr_warn("Unexpected event type %d "
+                        printk(KERN_WARNING "mlx4_ib: Unexpected event type %d "
                                "on SRQ %06x\n", type, srq->srqn);
                         return;
                 }
@@ -76,8 +76,6 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
         struct mlx4_ib_srq *srq;
         struct mlx4_wqe_srq_next_seg *next;
         struct mlx4_wqe_data_seg *scatter;
-        u32 cqn;
-        u16 xrcdn;
         int desc_size;
         int buf_size;
         int err;
@@ -176,18 +174,12 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
                 }
         }
 
-        cqn = (init_attr->srq_type == IB_SRQT_XRC) ?
-                to_mcq(init_attr->ext.xrc.cq)->mcq.cqn : 0;
-        xrcdn = (init_attr->srq_type == IB_SRQT_XRC) ?
-                to_mxrcd(init_attr->ext.xrc.xrcd)->xrcdn :
-                (u16) dev->dev->caps.reserved_xrcds;
-        err = mlx4_srq_alloc(dev->dev, to_mpd(pd)->pdn, cqn, xrcdn, &srq->mtt,
+        err = mlx4_srq_alloc(dev->dev, to_mpd(pd)->pdn, &srq->mtt,
                              srq->db.dma, &srq->msrq);
         if (err)
                 goto err_wrid;
 
         srq->msrq.event = mlx4_ib_srq_event;
-        srq->ibsrq.ext.xrc.srq_num = srq->msrq.srqn;
 
         if (pd->uobject)
                 if (ib_copy_to_udata(udata, &srq->msrq.srqn, sizeof (__u32))) {
diff --git a/drivers/infiniband/hw/mlx4/sysfs.c b/drivers/infiniband/hw/mlx4/sysfs.c
deleted file mode 100644
index 5b2a01dfb90..00000000000
--- a/drivers/infiniband/hw/mlx4/sysfs.c
+++ /dev/null
@@ -1,794 +0,0 @@
-/*
- * Copyright (c) 2012 Mellanox Technologies.  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 "core_priv.h"*/
-#include "mlx4_ib.h"
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/stat.h>
-
-#include <rdma/ib_mad.h>
-/*show_admin_alias_guid returns the administratively assigned value of that GUID.
- * Values returned in buf parameter string:
- *      0                       - requests opensm to assign a value.
- *      ffffffffffffffff        - delete this entry.
- *      other                   - value assigned by administrator.
- */
-static ssize_t show_admin_alias_guid(struct device *dev,
-                              struct device_attribute *attr, char *buf)
-{
-        int record_num;/*0-15*/
-        int guid_index_in_rec; /*0 - 7*/
-        struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
-                container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
-        struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
-        struct mlx4_ib_dev *mdev = port->dev;
-
-        record_num = mlx4_ib_iov_dentry->entry_num / 8 ;
-        guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8 ;
-
-        return sprintf(buf, "%llx\n",
-                       be64_to_cpu(*(__be64 *)&mdev->sriov.alias_guid.
-                                   ports_guid[port->num - 1].
-                                   all_rec_per_port[record_num].
-                                   all_recs[8 * guid_index_in_rec]));
-}
-
-/* store_admin_alias_guid stores the (new) administratively assigned value of that GUID.
- * Values in buf parameter string:
- *      0                       - requests opensm to assign a value.
- *      0xffffffffffffffff      - delete this entry.
- *      other                   - guid value assigned by the administrator.
- */
-static ssize_t store_admin_alias_guid(struct device *dev,
-                                      struct device_attribute *attr,
-                                      const char *buf, size_t count)
-{
-        int record_num;/*0-15*/
-        int guid_index_in_rec; /*0 - 7*/
-        struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
-                container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
-        struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
-        struct mlx4_ib_dev *mdev = port->dev;
-        u64 sysadmin_ag_val;
-
-        record_num = mlx4_ib_iov_dentry->entry_num / 8;
-        guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8;
-        if (0 == record_num && 0 == guid_index_in_rec) {
-                pr_err("GUID 0 block 0 is RO\n");
-                return count;
-        }
-        sscanf(buf, "%llx", &sysadmin_ag_val);
-        *(__be64 *)&mdev->sriov.alias_guid.ports_guid[port->num - 1].
-                all_rec_per_port[record_num].
-                all_recs[GUID_REC_SIZE * guid_index_in_rec] =
-                        cpu_to_be64(sysadmin_ag_val);
-
-        /* Change the state to be pending for update */
-        mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].status
-                = MLX4_GUID_INFO_STATUS_IDLE ;
-
-        mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
-                = MLX4_GUID_INFO_RECORD_SET;
-
-        switch (sysadmin_ag_val) {
-        case MLX4_GUID_FOR_DELETE_VAL:
-                mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].method
-                        = MLX4_GUID_INFO_RECORD_DELETE;
-                mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
-                        = MLX4_GUID_SYSADMIN_ASSIGN;
-                break;
-        /* The sysadmin requests the SM to re-assign */
-        case MLX4_NOT_SET_GUID:
-                mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
-                        = MLX4_GUID_DRIVER_ASSIGN;
-                break;
-        /* The sysadmin requests a specific value.*/
-        default:
-                mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].ownership
-                        = MLX4_GUID_SYSADMIN_ASSIGN;
-                break;
-        }
-
-        /* set the record index */
-        mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].guid_indexes
-                = mlx4_ib_get_aguid_comp_mask_from_ix(guid_index_in_rec);
-
-        mlx4_ib_init_alias_guid_work(mdev, port->num - 1);
-
-        return count;
-}
-
-static ssize_t show_port_gid(struct device *dev,
-                             struct device_attribute *attr,
-                             char *buf)
-{
-        struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
-                container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
-        struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
-        struct mlx4_ib_dev *mdev = port->dev;
-        union ib_gid gid;
-        ssize_t ret;
-
-        ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num,
-                                  mlx4_ib_iov_dentry->entry_num, &gid, 1);
-        if (ret)
-                return ret;
-        ret = sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
-                      be16_to_cpu(((__be16 *) gid.raw)[0]),
-                      be16_to_cpu(((__be16 *) gid.raw)[1]),
-                      be16_to_cpu(((__be16 *) gid.raw)[2]),
-                      be16_to_cpu(((__be16 *) gid.raw)[3]),
-                      be16_to_cpu(((__be16 *) gid.raw)[4]),
-                      be16_to_cpu(((__be16 *) gid.raw)[5]),
-                      be16_to_cpu(((__be16 *) gid.raw)[6]),
-                      be16_to_cpu(((__be16 *) gid.raw)[7]));
-        return ret;
-}
-
-static ssize_t show_phys_port_pkey(struct device *dev,
-                                   struct device_attribute *attr,
-                                   char *buf)
-{
-        struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry =
-                container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry);
-        struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx;
-        struct mlx4_ib_dev *mdev = port->dev;
-        u16 pkey;
-        ssize_t ret;
-
-        ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num,
-                                   mlx4_ib_iov_dentry->entry_num, &pkey, 1);
-        if (ret)
-                return ret;
-
-        return sprintf(buf, "0x%04x\n", pkey);
-}
-
-#define DENTRY_REMOVE(_dentry)                                          \
-do {                                                                    \
-        sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr);    \
-} while (0);
-
-static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry,
-                              char *_name, struct kobject *_kobj,
-                              ssize_t (*show)(struct device *dev,
-                                              struct device_attribute *attr,
-                                              char *buf),
-                              ssize_t (*store)(struct device *dev,
-                                               struct device_attribute *attr,
-                                               const char *buf, size_t count)
-                              )
-{
-        int ret = 0;
-        struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry;
-
-        vdentry->ctx = _ctx;
-        vdentry->dentry.show = show;
-        vdentry->dentry.store = store;
-        sysfs_attr_init(&vdentry->dentry.attr);
-        vdentry->dentry.attr.name = vdentry->name;
-        vdentry->dentry.attr.mode = 0;
-        vdentry->kobj = _kobj;
-        snprintf(vdentry->name, 15, "%s", _name);
-
-        if (vdentry->dentry.store)
-                vdentry->dentry.attr.mode |= S_IWUSR;
-
-        if (vdentry->dentry.show)
-                vdentry->dentry.attr.mode |= S_IRUGO;
-
-        ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr);
-        if (ret) {
-                pr_err("failed to create %s\n", vdentry->dentry.attr.name);
-                vdentry->ctx = NULL;
-                return ret;
-        }
-
-        return ret;
-}
-
-int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
-                struct attribute *attr)
-{
-        struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
-        int ret;
-
-        ret = sysfs_create_file(port->mcgs_parent, attr);
-        if (ret)
-                pr_err("failed to create %s\n", attr->name);
-
-        return ret;
-}
-
-void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num,
-                struct attribute *attr)
-{
-        struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1];
-
-        sysfs_remove_file(port->mcgs_parent, attr);
-}
-
-static int add_port_entries(struct mlx4_ib_dev *device, int port_num)
-{
-        int i;
-        char buff[10];
-        struct mlx4_ib_iov_port *port = NULL;
-        int ret = 0 ;
-        struct ib_port_attr attr;
-
-        /* get the physical gid and pkey table sizes.*/
-        ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1);
-        if (ret)
-                goto err;
-
-        port = &device->iov_ports[port_num - 1];
-        port->dev = device;
-        port->num = port_num;
-        /* Directory structure:
-         * iov -
-         *   port num -
-         *      admin_guids
-         *      gids (operational)
-         *      mcg_table
-         */
-        port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar),
-                                 GFP_KERNEL);
-        if (!port->dentr_ar) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        sprintf(buff, "%d", port_num);
-        port->cur_port = kobject_create_and_add(buff,
-                                 kobject_get(device->ports_parent));
-        if (!port->cur_port) {
-                ret = -ENOMEM;
-                goto kobj_create_err;
-        }
-        /* admin GUIDs */
-        port->admin_alias_parent = kobject_create_and_add("admin_guids",
-                                                  kobject_get(port->cur_port));
-        if (!port->admin_alias_parent) {
-                ret = -ENOMEM;
-                goto err_admin_guids;
-        }
-        for (i = 0 ; i < attr.gid_tbl_len; i++) {
-                sprintf(buff, "%d", i);
-                port->dentr_ar->dentries[i].entry_num = i;
-                ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i],
-                                          buff, port->admin_alias_parent,
-                                          show_admin_alias_guid, store_admin_alias_guid);
-                if (ret)
-                        goto err_admin_alias_parent;
-        }
-
-        /* gids subdirectory (operational gids) */
-        port->gids_parent = kobject_create_and_add("gids",
-                                                  kobject_get(port->cur_port));
-        if (!port->gids_parent) {
-                ret = -ENOMEM;
-                goto err_gids;
-        }
-
-        for (i = 0 ; i < attr.gid_tbl_len; i++) {
-                sprintf(buff, "%d", i);
-                port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i;
-                ret = create_sysfs_entry(port,
-                                         &port->dentr_ar->dentries[attr.gid_tbl_len + i],
-                                         buff,
-                                         port->gids_parent, show_port_gid, NULL);
-                if (ret)
-                        goto err_gids_parent;
-        }
-
-        /* physical port pkey table */
-        port->pkeys_parent =
-                kobject_create_and_add("pkeys", kobject_get(port->cur_port));
-        if (!port->pkeys_parent) {
-                ret = -ENOMEM;
-                goto err_pkeys;
-        }
-
-        for (i = 0 ; i < attr.pkey_tbl_len; i++) {
-                sprintf(buff, "%d", i);
-                port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i;
-                ret = create_sysfs_entry(port,
-                                         &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i],
-                                         buff, port->pkeys_parent,
-                                         show_phys_port_pkey, NULL);
-                if (ret)
-                        goto err_pkeys_parent;
-        }
-
-        /* MCGs table */
-        port->mcgs_parent =
-                kobject_create_and_add("mcgs", kobject_get(port->cur_port));
-        if (!port->mcgs_parent) {
-                ret = -ENOMEM;
-                goto err_mcgs;
-        }
-        return 0;
-
-err_mcgs:
-        kobject_put(port->cur_port);
-
-err_pkeys_parent:
-        kobject_put(port->pkeys_parent);
-
-err_pkeys:
-        kobject_put(port->cur_port);
-
-err_gids_parent:
-        kobject_put(port->gids_parent);
-
-err_gids:
-        kobject_put(port->cur_port);
-
-err_admin_alias_parent:
-        kobject_put(port->admin_alias_parent);
-
-err_admin_guids:
-        kobject_put(port->cur_port);
-        kobject_put(port->cur_port); /* once more for create_and_add buff */
-
-kobj_create_err:
-        kobject_put(device->ports_parent);
-        kfree(port->dentr_ar);
-
-err:
-        pr_err("add_port_entries FAILED: for port:%d, error: %d\n",
-               port_num, ret);
-        return ret;
-}
-
-static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max)
-{
-        char base_name[9];
-
-        /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n */
-        strlcpy(name, pci_name(dev->dev->pdev), max);
-        strncpy(base_name, name, 8); /*till xxxx:yy:*/
-        base_name[8] = '\0';
-        /* with no ARI only 3 last bits are used so when the fn is higher than 8
-         * need to add it to the dev num, so count in the last number will be
-         * modulo 8 */
-        sprintf(name, "%s%.2d.%d", base_name, (i/8), (i%8));
-}
-
-struct mlx4_port {
-        struct kobject         kobj;
-        struct mlx4_ib_dev    *dev;
-        struct attribute_group pkey_group;
-        struct attribute_group gid_group;
-        u8                     port_num;
-        int                    slave;
-};
-
-
-static void mlx4_port_release(struct kobject *kobj)
-{
-        struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
-        struct attribute *a;
-        int i;
-
-        for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
-                kfree(a);
-        kfree(p->pkey_group.attrs);
-        for (i = 0; (a = p->gid_group.attrs[i]); ++i)
-                kfree(a);
-        kfree(p->gid_group.attrs);
-        kfree(p);
-}
-
-struct port_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf);
-        ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
-                         const char *buf, size_t count);
-};
-
-static ssize_t port_attr_show(struct kobject *kobj,
-                              struct attribute *attr, char *buf)
-{
-        struct port_attribute *port_attr =
-                container_of(attr, struct port_attribute, attr);
-        struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
-
-        if (!port_attr->show)
-                return -EIO;
-        return port_attr->show(p, port_attr, buf);
-}
-
-static ssize_t port_attr_store(struct kobject *kobj,
-                               struct attribute *attr,
-                               const char *buf, size_t size)
-{
-        struct port_attribute *port_attr =
-                container_of(attr, struct port_attribute, attr);
-        struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj);
-
-        if (!port_attr->store)
-                return -EIO;
-        return port_attr->store(p, port_attr, buf, size);
-}
-
-static const struct sysfs_ops port_sysfs_ops = {
-        .show = port_attr_show,
-        .store = port_attr_store,
-};
-
-static struct kobj_type port_type = {
-        .release    = mlx4_port_release,
-        .sysfs_ops  = &port_sysfs_ops,
-};
-
-struct port_table_attribute {
-        struct port_attribute   attr;
-        char                    name[8];
-        int                     index;
-};
-
-static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
-                              char *buf)
-{
-        struct port_table_attribute *tab_attr =
-                container_of(attr, struct port_table_attribute, attr);
-        ssize_t ret = -ENODEV;
-
-        if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >=
-            (p->dev->dev->caps.pkey_table_len[p->port_num]))
-                ret = sprintf(buf, "none\n");
-        else
-                ret = sprintf(buf, "%d\n",
-                              p->dev->pkeys.virt2phys_pkey[p->slave]
-                              [p->port_num - 1][tab_attr->index]);
-        return ret;
-}
-
-static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr,
-                               const char *buf, size_t count)
-{
-        struct port_table_attribute *tab_attr =
-                container_of(attr, struct port_table_attribute, attr);
-        int idx;
-        int err;
-
-        /* do not allow remapping Dom0 virtual pkey table */
-        if (p->slave == mlx4_master_func_num(p->dev->dev))
-                return -EINVAL;
-
-        if (!strncasecmp(buf, "no", 2))
-                idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1;
-        else if (sscanf(buf, "%i", &idx) != 1 ||
-                 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] ||
-                 idx < 0)
-                return -EINVAL;
-
-        p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1]
-                                    [tab_attr->index] = idx;
-        mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num,
-                             tab_attr->index, idx);
-        err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num);
-        if (err) {
-                pr_err("mlx4_gen_pkey_eqe failed for slave %d,"
-                       " port %d, index %d\n", p->slave, p->port_num, idx);
-                return err;
-        }
-        return count;
-}
-
-static ssize_t show_port_gid_idx(struct mlx4_port *p,
-                                 struct port_attribute *attr, char *buf)
-{
-        return sprintf(buf, "%d\n", p->slave);
-}
-
-static struct attribute **
-alloc_group_attrs(ssize_t (*show)(struct mlx4_port *,
-                                  struct port_attribute *, char *buf),
-                  ssize_t (*store)(struct mlx4_port *, struct port_attribute *,
-                                   const char *buf, size_t count),
-                  int len)
-{
-        struct attribute **tab_attr;
-        struct port_table_attribute *element;
-        int i;
-
-        tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL);
-        if (!tab_attr)
-                return NULL;
-
-        for (i = 0; i < len; i++) {
-                element = kzalloc(sizeof (struct port_table_attribute),
-                                  GFP_KERNEL);
-                if (!element)
-                        goto err;
-                if (snprintf(element->name, sizeof (element->name),
-                             "%d", i) >= sizeof (element->name)) {
-                        kfree(element);
-                        goto err;
-                }
-                sysfs_attr_init(&element->attr.attr);
-                element->attr.attr.name  = element->name;
-                if (store) {
-                        element->attr.attr.mode  = S_IWUSR | S_IRUGO;
-                        element->attr.store      = store;
-                } else
-                        element->attr.attr.mode  = S_IRUGO;
-
-                element->attr.show       = show;
-                element->index           = i;
-                tab_attr[i] = &element->attr.attr;
-        }
-        return tab_attr;
-
-err:
-        while (--i >= 0)
-                kfree(tab_attr[i]);
-        kfree(tab_attr);
-        return NULL;
-}
-
-static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
-{
-        struct mlx4_port *p;
-        int i;
-        int ret;
-
-        p = kzalloc(sizeof *p, GFP_KERNEL);
-        if (!p)
-                return -ENOMEM;
-
-        p->dev = dev;
-        p->port_num = port_num;
-        p->slave = slave;
-
-        ret = kobject_init_and_add(&p->kobj, &port_type,
-                                   kobject_get(dev->dev_ports_parent[slave]),
-                                   "%d", port_num);
-        if (ret)
-                goto err_alloc;
-
-        p->pkey_group.name  = "pkey_idx";
-        p->pkey_group.attrs =
-                alloc_group_attrs(show_port_pkey, store_port_pkey,
-                                  dev->dev->caps.pkey_table_len[port_num]);
-        if (!p->pkey_group.attrs)
-                goto err_alloc;
-
-        ret = sysfs_create_group(&p->kobj, &p->pkey_group);
-        if (ret)
-                goto err_free_pkey;
-
-        p->gid_group.name  = "gid_idx";
-        p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
-        if (!p->gid_group.attrs)
-                goto err_free_pkey;
-
-        ret = sysfs_create_group(&p->kobj, &p->gid_group);
-        if (ret)
-                goto err_free_gid;
-
-        list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]);
-        return 0;
-
-err_free_gid:
-        kfree(p->gid_group.attrs[0]);
-        kfree(p->gid_group.attrs);
-
-err_free_pkey:
-        for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i)
-                kfree(p->pkey_group.attrs[i]);
-        kfree(p->pkey_group.attrs);
-
-err_alloc:
-        kobject_put(dev->dev_ports_parent[slave]);
-        kfree(p);
-        return ret;
-}
-
-static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave)
-{
-        char name[32];
-        int err;
-        int port;
-        struct kobject *p, *t;
-        struct mlx4_port *mport;
-
-        get_name(dev, name, slave, sizeof name);
-
-        dev->pkeys.device_parent[slave] =
-                kobject_create_and_add(name, kobject_get(dev->iov_parent));
-
-        if (!dev->pkeys.device_parent[slave]) {
-                err = -ENOMEM;
-                goto fail_dev;
-        }
-
-        INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]);
-
-        dev->dev_ports_parent[slave] =
-                kobject_create_and_add("ports",
-                                       kobject_get(dev->pkeys.device_parent[slave]));
-
-        if (!dev->dev_ports_parent[slave]) {
-                err = -ENOMEM;
-                goto err_ports;
-        }
-
-        for (port = 1; port <= dev->dev->caps.num_ports; ++port) {
-                err = add_port(dev, port, slave);
-                if (err)
-                        goto err_add;
-        }
-        return 0;
-
-err_add:
-        list_for_each_entry_safe(p, t,
-                                 &dev->pkeys.pkey_port_list[slave],
-                                 entry) {
-                list_del(&p->entry);
-                mport = container_of(p, struct mlx4_port, kobj);
-                sysfs_remove_group(p, &mport->pkey_group);
-                sysfs_remove_group(p, &mport->gid_group);
-                kobject_put(p);
-        }
-        kobject_put(dev->dev_ports_parent[slave]);
-
-err_ports:
-        kobject_put(dev->pkeys.device_parent[slave]);
-        /* extra put for the device_parent create_and_add */
-        kobject_put(dev->pkeys.device_parent[slave]);
-
-fail_dev:
-        kobject_put(dev->iov_parent);
-        return err;
-}
-
-static int register_pkey_tree(struct mlx4_ib_dev *device)
-{
-        int i;
-
-        if (!mlx4_is_master(device->dev))
-                return 0;
-
-        for (i = 0; i <= device->dev->num_vfs; ++i)
-                register_one_pkey_tree(device, i);
-
-        return 0;
-}
-
-static void unregister_pkey_tree(struct mlx4_ib_dev *device)
-{
-        int slave;
-        struct kobject *p, *t;
-        struct mlx4_port *port;
-
-        if (!mlx4_is_master(device->dev))
-                return;
-
-        for (slave = device->dev->num_vfs; slave >= 0; --slave) {
-                list_for_each_entry_safe(p, t,
-                                         &device->pkeys.pkey_port_list[slave],
-                                         entry) {
-                        list_del(&p->entry);
-                        port = container_of(p, struct mlx4_port, kobj);
-                        sysfs_remove_group(p, &port->pkey_group);
-                        sysfs_remove_group(p, &port->gid_group);
-                        kobject_put(p);
-                        kobject_put(device->dev_ports_parent[slave]);
-                }
-                kobject_put(device->dev_ports_parent[slave]);
-                kobject_put(device->pkeys.device_parent[slave]);
-                kobject_put(device->pkeys.device_parent[slave]);
-                kobject_put(device->iov_parent);
-        }
-}
-
-int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev)
-{
-        int i;
-        int ret = 0;
-
-        if (!mlx4_is_master(dev->dev))
-                return 0;
-
-        dev->iov_parent =
-                kobject_create_and_add("iov",
-                                       kobject_get(dev->ib_dev.ports_parent->parent));
-        if (!dev->iov_parent) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        dev->ports_parent =
-                kobject_create_and_add("ports",
-                                       kobject_get(dev->iov_parent));
-        if (!dev->iov_parent) {
-                ret = -ENOMEM;
-                goto err_ports;
-        }
-
-        for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) {
-                ret = add_port_entries(dev, i);
-                if (ret)
-                        goto err_add_entries;
-        }
-
-        ret = register_pkey_tree(dev);
-        if (ret)
-                goto err_add_entries;
-        return 0;
-
-err_add_entries:
-        kobject_put(dev->ports_parent);
-
-err_ports:
-        kobject_put(dev->iov_parent);
-err:
-        kobject_put(dev->ib_dev.ports_parent->parent);
-        pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret);
-        return ret;
-}
-
-static void unregister_alias_guid_tree(struct mlx4_ib_dev *device)
-{
-        struct mlx4_ib_iov_port *p;
-        int i;
-
-        if (!mlx4_is_master(device->dev))
-                return;
-
-        for (i = 0; i < device->dev->caps.num_ports; i++) {
-                p = &device->iov_ports[i];
-                kobject_put(p->admin_alias_parent);
-                kobject_put(p->gids_parent);
-                kobject_put(p->pkeys_parent);
-                kobject_put(p->mcgs_parent);
-                kobject_put(p->cur_port);
-                kobject_put(p->cur_port);
-                kobject_put(p->cur_port);
-                kobject_put(p->cur_port);
-                kobject_put(p->cur_port);
-                kobject_put(p->dev->ports_parent);
-                kfree(p->dentr_ar);
-        }
-}
-
-void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device)
-{
-        unregister_alias_guid_tree(device);
-        unregister_pkey_tree(device);
-        kobject_put(device->ports_parent);
-        kobject_put(device->iov_parent);
-        kobject_put(device->iov_parent);
-        kobject_put(device->ib_dev.ports_parent->parent);
-}
diff --git a/drivers/infiniband/hw/mlx4/user.h b/drivers/infiniband/hw/mlx4/user.h
index 07e6769ef43..13beedeeef9 100644
--- a/drivers/infiniband/hw/mlx4/user.h
+++ b/drivers/infiniband/hw/mlx4/user.h
@@ -40,9 +40,7 @@
  * Increment this value if any changes that break userspace ABI
  * compatibility are made.
  */
-
-#define MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION  3
-#define MLX4_IB_UVERBS_ABI_VERSION              4
+#define MLX4_IB_UVERBS_ABI_VERSION      3
 
 /*
  * Make sure that all structs defined in this file remain laid out so
@@ -52,18 +50,10 @@
  * instead.
  */
 
-struct mlx4_ib_alloc_ucontext_resp_v3 {
-        __u32   qp_tab_size;
-        __u16   bf_reg_size;
-        __u16   bf_regs_per_page;
-};
-
 struct mlx4_ib_alloc_ucontext_resp {
-        __u32   dev_caps;
         __u32   qp_tab_size;
         __u16   bf_reg_size;
         __u16   bf_regs_per_page;
-        __u32   cqe_size;
 };
 
 struct mlx4_ib_alloc_pd_resp {
diff --git a/drivers/infiniband/hw/mthca/mthca_catas.c b/drivers/infiniband/hw/mthca/mthca_catas.c
index 712d2a30fbe..e4a08c2819e 100644
--- a/drivers/infiniband/hw/mthca/mthca_catas.c
+++ b/drivers/infiniband/hw/mthca/mthca_catas.c
@@ -31,7 +31,6 @@
  */
 
 #include <linux/jiffies.h>
-#include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.c b/drivers/infiniband/hw/mthca/mthca_cmd.c
index 9d3e5c1ac60..3082b3b3d62 100644
--- a/drivers/infiniband/hw/mthca/mthca_cmd.c
+++ b/drivers/infiniband/hw/mthca/mthca_cmd.c
@@ -36,7 +36,6 @@
 #include <linux/pci.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 #include <asm/io.h>
 #include <rdma/ib_mad.h>
diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c
index 40ba8333815..53157b86a1b 100644
--- a/drivers/infiniband/hw/mthca/mthca_cq.c
+++ b/drivers/infiniband/hw/mthca/mthca_cq.c
@@ -643,8 +643,7 @@ static inline int mthca_poll_one(struct mthca_dev *dev,
                 entry->wc_flags   |= cqe->g_mlpath & 0x80 ? IB_WC_GRH : 0;
                 checksum = (be32_to_cpu(cqe->rqpn) >> 24) |
                                 ((be32_to_cpu(cqe->my_ee) >> 16) & 0xff00);
-                entry->wc_flags   |=  (cqe->sl_ipok & 1 && checksum == 0xffff) ?
-                                                        IB_WC_IP_CSUM_OK : 0;
+                entry->csum_ok = (cqe->sl_ipok & 1 && checksum == 0xffff);
         }
 
         entry->status = IB_WC_SUCCESS;
diff --git a/drivers/infiniband/hw/mthca/mthca_main.c b/drivers/infiniband/hw/mthca/mthca_main.c
index 87897b95666..aa12a533ae9 100644
--- a/drivers/infiniband/hw/mthca/mthca_main.c
+++ b/drivers/infiniband/hw/mthca/mthca_main.c
@@ -130,7 +130,7 @@ static int log_mtts_per_seg = ilog2(MTHCA_MTT_SEG_SIZE / 8);
 module_param_named(log_mtts_per_seg, log_mtts_per_seg, int, 0444);
 MODULE_PARM_DESC(log_mtts_per_seg, "Log2 number of MTT entries per segment (1-5)");
 
-static char mthca_version[] =
+static char mthca_version[] __devinitdata =
         DRV_NAME ": Mellanox InfiniBand HCA driver v"
         DRV_VERSION " (" DRV_RELDATE ")\n";
 
@@ -1139,7 +1139,8 @@ int __mthca_restart_one(struct pci_dev *pdev)
         return __mthca_init_one(pdev, hca_type);
 }
 
-static int mthca_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+static int __devinit mthca_init_one(struct pci_dev *pdev,
+                                    const struct pci_device_id *id)
 {
         int ret;
 
@@ -1161,7 +1162,7 @@ static int mthca_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         return ret;
 }
 
-static void mthca_remove_one(struct pci_dev *pdev)
+static void __devexit mthca_remove_one(struct pci_dev *pdev)
 {
         mutex_lock(&mthca_device_mutex);
         __mthca_remove_one(pdev);
@@ -1198,7 +1199,7 @@ static struct pci_driver mthca_driver = {
         .name           = DRV_NAME,
         .id_table       = mthca_pci_table,
         .probe          = mthca_init_one,
-        .remove         = mthca_remove_one,
+        .remove         = __devexit_p(mthca_remove_one)
 };
 
 static void __init __mthca_check_profile_val(const char *name, int *pval,
diff --git a/drivers/infiniband/hw/mthca/mthca_mr.c b/drivers/infiniband/hw/mthca/mthca_mr.c
index ed9a989e501..ab876f928a1 100644
--- a/drivers/infiniband/hw/mthca/mthca_mr.c
+++ b/drivers/infiniband/hw/mthca/mthca_mr.c
@@ -146,7 +146,7 @@ static int mthca_buddy_init(struct mthca_buddy *buddy, int max_order)
 
         buddy->bits = kzalloc((buddy->max_order + 1) * sizeof (long *),
                               GFP_KERNEL);
-        buddy->num_free = kcalloc((buddy->max_order + 1), sizeof *buddy->num_free,
+        buddy->num_free = kzalloc((buddy->max_order + 1) * sizeof (int *),
                                   GFP_KERNEL);
         if (!buddy->bits || !buddy->num_free)
                 goto err_out;
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 5b71d43bd89..365fe0e1419 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -40,9 +40,7 @@
 
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/stat.h>
 #include <linux/mm.h>
-#include <linux/export.h>
 
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
@@ -440,9 +438,6 @@ static struct ib_srq *mthca_create_srq(struct ib_pd *pd,
         struct mthca_srq *srq;
         int err;
 
-        if (init_attr->srq_type != IB_SRQT_BASIC)
-                return ERR_PTR(-ENOSYS);
-
         srq = kmalloc(sizeof *srq, GFP_KERNEL);
         if (!srq)
                 return ERR_PTR(-ENOMEM);
diff --git a/drivers/infiniband/hw/mthca/mthca_qp.c b/drivers/infiniband/hw/mthca/mthca_qp.c
index 26a68453610..9601049e14d 100644
--- a/drivers/infiniband/hw/mthca/mthca_qp.c
+++ b/drivers/infiniband/hw/mthca/mthca_qp.c
@@ -247,8 +247,7 @@ void mthca_qp_event(struct mthca_dev *dev, u32 qpn,
         spin_unlock(&dev->qp_table.lock);
 
         if (!qp) {
-                mthca_warn(dev, "Async event %d for bogus QP %08x\n",
-                           event_type, qpn);
+                mthca_warn(dev, "Async event for bogus QP %08x\n", qpn);
                 return;
         }
 
@@ -502,7 +501,6 @@ done:
         qp_attr->cap.max_inline_data = qp->max_inline_data;
 
         qp_init_attr->cap            = qp_attr->cap;
-        qp_init_attr->sq_sig_type    = qp->sq_policy;
 
 out_mailbox:
         mthca_free_mailbox(dev, mailbox);
diff --git a/drivers/infiniband/hw/mthca/mthca_reset.c b/drivers/infiniband/hw/mthca/mthca_reset.c
index 74c6a942604..4fa3534ec23 100644
--- a/drivers/infiniband/hw/mthca/mthca_reset.c
+++ b/drivers/infiniband/hw/mthca/mthca_reset.c
@@ -241,16 +241,16 @@ good:
 
         if (hca_pcie_cap) {
                 devctl = hca_header[(hca_pcie_cap + PCI_EXP_DEVCTL) / 4];
-                if (pcie_capability_write_word(mdev->pdev, PCI_EXP_DEVCTL,
-                                               devctl)) {
+                if (pci_write_config_word(mdev->pdev, hca_pcie_cap + PCI_EXP_DEVCTL,
+                                           devctl)) {
                         err = -ENODEV;
                         mthca_err(mdev, "Couldn't restore HCA PCI Express "
                                   "Device Control register, aborting.\n");
                         goto out;
                 }
                 linkctl = hca_header[(hca_pcie_cap + PCI_EXP_LNKCTL) / 4];
-                if (pcie_capability_write_word(mdev->pdev, PCI_EXP_LNKCTL,
-                                               linkctl)) {
+                if (pci_write_config_word(mdev->pdev, hca_pcie_cap + PCI_EXP_LNKCTL,
+                                           linkctl)) {
                         err = -ENODEV;
                         mthca_err(mdev, "Couldn't restore HCA PCI Express "
                                   "Link control register, aborting.\n");
diff --git a/drivers/infiniband/hw/nes/Makefile b/drivers/infiniband/hw/nes/Makefile
index 97820c23ece..35148513c47 100644
--- a/drivers/infiniband/hw/nes/Makefile
+++ b/drivers/infiniband/hw/nes/Makefile
@@ -1,3 +1,3 @@
 obj-$(CONFIG_INFINIBAND_NES) += iw_nes.o
 
-iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o nes_mgt.o
+iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o
diff --git a/drivers/infiniband/hw/nes/nes.c b/drivers/infiniband/hw/nes/nes.c
index 5b152a366df..2d668c69f6d 100644
--- a/drivers/infiniband/hw/nes/nes.c
+++ b/drivers/infiniband/hw/nes/nes.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  All rights reserved.
  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -79,7 +79,12 @@ int disable_mpa_crc = 0;
 module_param(disable_mpa_crc, int, 0644);
 MODULE_PARM_DESC(disable_mpa_crc, "Disable checking of MPA CRC");
 
-unsigned int nes_drv_opt = NES_DRV_OPT_DISABLE_INT_MOD | NES_DRV_OPT_ENABLE_PAU;
+unsigned int send_first = 0;
+module_param(send_first, int, 0644);
+MODULE_PARM_DESC(send_first, "Send RDMA Message First on Active Connection");
+
+
+unsigned int nes_drv_opt = 0;
 module_param(nes_drv_opt, int, 0644);
 MODULE_PARM_DESC(nes_drv_opt, "Driver option parameters");
 
@@ -91,7 +96,7 @@ unsigned int wqm_quanta = 0x10000;
 module_param(wqm_quanta, int, 0644);
 MODULE_PARM_DESC(wqm_quanta, "WQM quanta");
 
-static bool limit_maxrdreqsz;
+static unsigned int limit_maxrdreqsz;
 module_param(limit_maxrdreqsz, bool, 0644);
 MODULE_PARM_DESC(limit_maxrdreqsz, "Limit max read request size to 256 Bytes");
 
@@ -125,6 +130,9 @@ static struct notifier_block nes_net_notifier = {
         .notifier_call = nes_net_event
 };
 
+
+
+
 /**
  * nes_inetaddr_event
  */
@@ -313,9 +321,6 @@ void nes_rem_ref(struct ib_qp *ibqp)
         }
 
         if (atomic_dec_and_test(&nesqp->refcount)) {
-                if (nesqp->pau_mode)
-                        nes_destroy_pau_qp(nesdev, nesqp);
-
                 /* Destroy the QP */
                 cqp_request = nes_get_cqp_request(nesdev);
                 if (cqp_request == NULL) {
@@ -444,7 +449,7 @@ static irqreturn_t nes_interrupt(int irq, void *dev_id)
 /**
  * nes_probe - Device initialization
  */
-static int nes_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
+static int __devinit nes_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 {
         struct net_device *netdev = NULL;
         struct nes_device *nesdev = NULL;
@@ -749,7 +754,7 @@ static int nes_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 /**
  * nes_remove - unload from kernel
  */
-static void nes_remove(struct pci_dev *pcidev)
+static void __devexit nes_remove(struct pci_dev *pcidev)
 {
         struct nes_device *nesdev = pci_get_drvdata(pcidev);
         struct net_device *netdev;
@@ -810,7 +815,7 @@ static struct pci_driver nes_pci_driver = {
         .name = DRV_NAME,
         .id_table = nes_pci_table,
         .probe = nes_probe,
-        .remove = nes_remove,
+        .remove = __devexit_p(nes_remove),
 };
 
 static ssize_t nes_show_adapter(struct device_driver *ddp, char *buf)
diff --git a/drivers/infiniband/hw/nes/nes.h b/drivers/infiniband/hw/nes/nes.h
index 33cc58941a3..6fe79876009 100644
--- a/drivers/infiniband/hw/nes/nes.h
+++ b/drivers/infiniband/hw/nes/nes.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  All rights reserved.
  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -57,7 +57,7 @@
 #define QUEUE_DISCONNECTS
 
 #define DRV_NAME    "iw_nes"
-#define DRV_VERSION "1.5.0.1"
+#define DRV_VERSION "1.5.0.0"
 #define PFX         DRV_NAME ": "
 
 /*
@@ -102,7 +102,6 @@
 #define NES_DRV_OPT_NO_INLINE_DATA       0x00000080
 #define NES_DRV_OPT_DISABLE_INT_MOD      0x00000100
 #define NES_DRV_OPT_DISABLE_VIRT_WQ      0x00000200
-#define NES_DRV_OPT_ENABLE_PAU           0x00000400
 
 #define NES_AEQ_EVENT_TIMEOUT         2500
 #define NES_DISCONNECT_EVENT_TIMEOUT  2000
@@ -129,7 +128,6 @@
 #define NES_DBG_IW_RX       0x00020000
 #define NES_DBG_IW_TX       0x00040000
 #define NES_DBG_SHUTDOWN    0x00080000
-#define NES_DBG_PAU         0x00100000
 #define NES_DBG_RSVD1       0x10000000
 #define NES_DBG_RSVD2       0x20000000
 #define NES_DBG_RSVD3       0x40000000
@@ -164,7 +162,6 @@ do { \
 #include "nes_context.h"
 #include "nes_user.h"
 #include "nes_cm.h"
-#include "nes_mgt.h"
 
 extern int max_mtu;
 #define max_frame_len (max_mtu+ETH_HLEN)
@@ -172,6 +169,7 @@ extern int interrupt_mod_interval;
 extern int nes_if_count;
 extern int mpa_version;
 extern int disable_mpa_crc;
+extern unsigned int send_first;
 extern unsigned int nes_drv_opt;
 extern unsigned int nes_debug_level;
 extern unsigned int wqm_quanta;
@@ -204,8 +202,6 @@ extern atomic_t cm_nodes_created;
 extern atomic_t cm_nodes_destroyed;
 extern atomic_t cm_accel_dropped_pkts;
 extern atomic_t cm_resets_recvd;
-extern atomic_t pau_qps_created;
-extern atomic_t pau_qps_destroyed;
 
 extern u32 int_mod_timer_init;
 extern u32 int_mod_cq_depth_256;
@@ -277,14 +273,6 @@ struct nes_device {
         u8                     link_recheck;
 };
 
-/* Receive skb private area - must fit in skb->cb area */
-struct nes_rskb_cb {
-        u64                    busaddr;
-        u32                    maplen;
-        u32                    seqnum;
-        u8                     *data_start;
-        struct nes_qp          *nesqp;
-};
 
 static inline __le32 get_crc_value(struct nes_v4_quad *nes_quad)
 {
@@ -317,8 +305,8 @@ set_wqe_32bit_value(__le32 *wqe_words, u32 index, u32 value)
 static inline void
 nes_fill_init_cqp_wqe(struct nes_hw_cqp_wqe *cqp_wqe, struct nes_device *nesdev)
 {
-        cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_LOW_IDX]       = 0;
-        cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_HIGH_IDX]      = 0;
+        set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_COMP_CTX_LOW_IDX,
+                        (u64)((unsigned long) &nesdev->cqp));
         cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX]   = 0;
         cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX]  = 0;
         cqp_wqe->wqe_words[NES_CQP_STAG_WQE_PBL_BLK_COUNT_IDX] = 0;
@@ -398,20 +386,11 @@ static inline void nes_write8(void __iomem *addr, u8 val)
         writeb(val, addr);
 }
 
-enum nes_resource {
-        NES_RESOURCE_MW = 1,
-        NES_RESOURCE_FAST_MR,
-        NES_RESOURCE_PHYS_MR,
-        NES_RESOURCE_USER_MR,
-        NES_RESOURCE_PD,
-        NES_RESOURCE_QP,
-        NES_RESOURCE_CQ,
-        NES_RESOURCE_ARP
-};
+
 
 static inline int nes_alloc_resource(struct nes_adapter *nesadapter,
                 unsigned long *resource_array, u32 max_resources,
-                u32 *req_resource_num, u32 *next, enum nes_resource resource_type)
+                u32 *req_resource_num, u32 *next)
 {
         unsigned long flags;
         u32 resource_num;
@@ -422,7 +401,7 @@ static inline int nes_alloc_resource(struct nes_adapter *nesadapter,
         if (resource_num >= max_resources) {
                 resource_num = find_first_zero_bit(resource_array, max_resources);
                 if (resource_num >= max_resources) {
-                        printk(KERN_ERR PFX "%s: No available resources [type=%u].\n", __func__, resource_type);
+                        printk(KERN_ERR PFX "%s: No available resourcess.\n", __func__);
                         spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
                         return -EMFILE;
                 }
@@ -532,7 +511,6 @@ void nes_iwarp_ce_handler(struct nes_device *, struct nes_hw_cq *);
 int nes_destroy_cqp(struct nes_device *);
 int nes_nic_cm_xmit(struct sk_buff *, struct net_device *);
 void nes_recheck_link_status(struct work_struct *work);
-void nes_terminate_timeout(unsigned long context);
 
 /* nes_nic.c */
 struct net_device *nes_netdev_init(struct nes_device *, void __iomem *);
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index 22ea67eea5d..a237547330b 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -77,19 +77,26 @@ atomic_t cm_nodes_destroyed;
 atomic_t cm_accel_dropped_pkts;
 atomic_t cm_resets_recvd;
 
-static inline int mini_cm_accelerated(struct nes_cm_core *, struct nes_cm_node *);
-static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *, struct nes_vnic *, struct nes_cm_info *);
+static inline int mini_cm_accelerated(struct nes_cm_core *,
+        struct nes_cm_node *);
+static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *,
+        struct nes_vnic *, struct nes_cm_info *);
 static int mini_cm_del_listen(struct nes_cm_core *, struct nes_cm_listener *);
-static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *, struct nes_vnic *, u16, void *, struct nes_cm_info *);
+static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *,
+        struct nes_vnic *, u16, void *, struct nes_cm_info *);
 static int mini_cm_close(struct nes_cm_core *, struct nes_cm_node *);
-static int mini_cm_accept(struct nes_cm_core *, struct nes_cm_node *);
-static int mini_cm_reject(struct nes_cm_core *, struct nes_cm_node *);
-static int mini_cm_recv_pkt(struct nes_cm_core *, struct nes_vnic *, struct sk_buff *);
+static int mini_cm_accept(struct nes_cm_core *, struct ietf_mpa_frame *,
+        struct nes_cm_node *);
+static int mini_cm_reject(struct nes_cm_core *, struct ietf_mpa_frame *,
+        struct nes_cm_node *);
+static int mini_cm_recv_pkt(struct nes_cm_core *, struct nes_vnic *,
+        struct sk_buff *);
 static int mini_cm_dealloc_core(struct nes_cm_core *);
 static int mini_cm_get(struct nes_cm_core *);
 static int mini_cm_set(struct nes_cm_core *, u32, u32);
 
-static void form_cm_frame(struct sk_buff *, struct nes_cm_node *, void *, u32, void *, u32, u8);
+static void form_cm_frame(struct sk_buff *, struct nes_cm_node *,
+        void *, u32, void *, u32, u8);
 static int add_ref_cm_node(struct nes_cm_node *);
 static int rem_ref_cm_node(struct nes_cm_core *, struct nes_cm_node *);
 
@@ -104,14 +111,16 @@ static int send_syn(struct nes_cm_node *, u32, struct sk_buff *);
 static int send_reset(struct nes_cm_node *, struct sk_buff *);
 static int send_ack(struct nes_cm_node *cm_node, struct sk_buff *skb);
 static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb);
-static void process_packet(struct nes_cm_node *, struct sk_buff *, struct nes_cm_core *);
+static void process_packet(struct nes_cm_node *, struct sk_buff *,
+        struct nes_cm_core *);
 
 static void active_open_err(struct nes_cm_node *, struct sk_buff *, int);
 static void passive_open_err(struct nes_cm_node *, struct sk_buff *, int);
 static void cleanup_retrans_entry(struct nes_cm_node *);
 static void handle_rcv_mpa(struct nes_cm_node *, struct sk_buff *);
 static void free_retrans_entry(struct nes_cm_node *cm_node);
-static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph, struct sk_buff *skb, int optionsize, int passive);
+static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph,
+        struct sk_buff *skb, int optionsize, int passive);
 
 /* CM event handler functions */
 static void cm_event_connected(struct nes_cm_event *);
@@ -121,12 +130,6 @@ static void cm_event_mpa_req(struct nes_cm_event *);
 static void cm_event_mpa_reject(struct nes_cm_event *);
 static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node);
 
-/* MPA build functions */
-static int cm_build_mpa_frame(struct nes_cm_node *, u8 **, u16 *, u8 *, u8);
-static void build_mpa_v2(struct nes_cm_node *, void *, u8);
-static void build_mpa_v1(struct nes_cm_node *, void *, u8);
-static void build_rdma0_msg(struct nes_cm_node *, struct nes_qp **);
-
 static void print_core(struct nes_cm_core *core);
 
 /* External CM API Interface */
@@ -156,21 +159,12 @@ atomic_t cm_connecteds;
 atomic_t cm_connect_reqs;
 atomic_t cm_rejects;
 
-int nes_add_ref_cm_node(struct nes_cm_node *cm_node)
-{
-        return add_ref_cm_node(cm_node);
-}
-
-int nes_rem_ref_cm_node(struct nes_cm_node *cm_node)
-{
-        return rem_ref_cm_node(cm_node->cm_core, cm_node);
-}
 
 /**
  * create_event
  */
-static struct nes_cm_event *create_event(struct nes_cm_node *   cm_node,
-                                         enum nes_cm_event_type type)
+static struct nes_cm_event *create_event(struct nes_cm_node *cm_node,
+                enum nes_cm_event_type type)
 {
         struct nes_cm_event *event;
 
@@ -192,10 +186,10 @@ static struct nes_cm_event *create_event(struct nes_cm_node *	cm_node,
         event->cm_info.cm_id = cm_node->cm_id;
 
         nes_debug(NES_DBG_CM, "cm_node=%p Created event=%p, type=%u, "
-                  "dst_addr=%08x[%x], src_addr=%08x[%x]\n",
-                  cm_node, event, type, event->cm_info.loc_addr,
-                  event->cm_info.loc_port, event->cm_info.rem_addr,
-                  event->cm_info.rem_port);
+                "dst_addr=%08x[%x], src_addr=%08x[%x]\n",
+                cm_node, event, type, event->cm_info.loc_addr,
+                event->cm_info.loc_port, event->cm_info.rem_addr,
+                event->cm_info.rem_port);
 
         nes_cm_post_event(event);
         return event;
@@ -207,19 +201,14 @@ static struct nes_cm_event *create_event(struct nes_cm_node *	cm_node,
  */
 static int send_mpa_request(struct nes_cm_node *cm_node, struct sk_buff *skb)
 {
-        u8 start_addr = 0;
-        u8 *start_ptr = &start_addr;
-        u8 **start_buff = &start_ptr;
-        u16 buff_len = 0;
-
         if (!skb) {
                 nes_debug(NES_DBG_CM, "skb set to NULL\n");
                 return -1;
         }
 
         /* send an MPA Request frame */
-        cm_build_mpa_frame(cm_node, start_buff, &buff_len, NULL, MPA_KEY_REQUEST);
-        form_cm_frame(skb, cm_node, NULL, 0, *start_buff, buff_len, SET_ACK);
+        form_cm_frame(skb, cm_node, NULL, 0, &cm_node->mpa_frame,
+                        cm_node->mpa_frame_size, SET_ACK);
 
         return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
 }
@@ -228,12 +217,7 @@ static int send_mpa_request(struct nes_cm_node *cm_node, struct sk_buff *skb)
 
 static int send_mpa_reject(struct nes_cm_node *cm_node)
 {
-        struct sk_buff *skb = NULL;
-        u8 start_addr = 0;
-        u8 *start_ptr = &start_addr;
-        u8 **start_buff = &start_ptr;
-        u16 buff_len = 0;
-        struct ietf_mpa_v1 *mpa_frame;
+        struct sk_buff  *skb = NULL;
 
         skb = dev_alloc_skb(MAX_CM_BUFFER);
         if (!skb) {
@@ -242,10 +226,8 @@ static int send_mpa_reject(struct nes_cm_node *cm_node)
         }
 
         /* send an MPA reject frame */
-        cm_build_mpa_frame(cm_node, start_buff, &buff_len, NULL, MPA_KEY_REPLY);
-        mpa_frame = (struct ietf_mpa_v1 *)*start_buff;
-        mpa_frame->flags |= IETF_MPA_FLAGS_REJECT;
-        form_cm_frame(skb, cm_node, NULL, 0, *start_buff, buff_len, SET_ACK | SET_FIN);
+        form_cm_frame(skb, cm_node, NULL, 0, &cm_node->mpa_frame,
+                        cm_node->mpa_frame_size, SET_ACK | SET_FIN);
 
         cm_node->state = NES_CM_STATE_FIN_WAIT1;
         return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
@@ -257,31 +239,24 @@ static int send_mpa_reject(struct nes_cm_node *cm_node)
  * IETF MPA frame
  */
 static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
-                     u32 len)
+                u32 len)
 {
-        struct ietf_mpa_v1 *mpa_frame;
-        struct ietf_mpa_v2 *mpa_v2_frame;
-        struct ietf_rtr_msg *rtr_msg;
-        int mpa_hdr_len;
-        int priv_data_len;
+        struct ietf_mpa_frame *mpa_frame;
 
         *type = NES_MPA_REQUEST_ACCEPT;
 
         /* assume req frame is in tcp data payload */
-        if (len < sizeof(struct ietf_mpa_v1)) {
+        if (len < sizeof(struct ietf_mpa_frame)) {
                 nes_debug(NES_DBG_CM, "The received ietf buffer was too small (%x)\n", len);
                 return -EINVAL;
         }
 
-        /* points to the beginning of the frame, which could be MPA V1 or V2 */
-        mpa_frame = (struct ietf_mpa_v1 *)buffer;
-        mpa_hdr_len = sizeof(struct ietf_mpa_v1);
-        priv_data_len = ntohs(mpa_frame->priv_data_len);
-
+        mpa_frame = (struct ietf_mpa_frame *)buffer;
+        cm_node->mpa_frame_size = ntohs(mpa_frame->priv_data_len);
         /* make sure mpa private data len is less than 512 bytes */
-        if (priv_data_len > IETF_MAX_PRIV_DATA_LEN) {
+        if (cm_node->mpa_frame_size > IETF_MAX_PRIV_DATA_LEN) {
                 nes_debug(NES_DBG_CM, "The received Length of Private"
-                          " Data field exceeds 512 octets\n");
+                        " Data field exceeds 512 octets\n");
                 return -EINVAL;
         }
         /*
@@ -289,22 +264,11 @@ static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
          * received MPA version and MPA key information
          *
          */
-        if (mpa_frame->rev != IETF_MPA_V1 && mpa_frame->rev != IETF_MPA_V2) {
+        if (mpa_frame->rev != mpa_version) {
                 nes_debug(NES_DBG_CM, "The received mpa version"
-                          " is not supported\n");
+                                " can not be interoperated\n");
                 return -EINVAL;
         }
-        /*
-        * backwards compatibility only
-        */
-        if (mpa_frame->rev > cm_node->mpa_frame_rev) {
-                nes_debug(NES_DBG_CM, "The received mpa version"
-                        " can not be interoperated\n");
-                return -EINVAL;
-        } else {
-                cm_node->mpa_frame_rev = mpa_frame->rev;
-        }
-
         if (cm_node->state != NES_CM_STATE_MPAREQ_SENT) {
                 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE)) {
                         nes_debug(NES_DBG_CM, "Unexpected MPA Key received \n");
@@ -317,78 +281,25 @@ static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
                 }
         }
 
-
-        if (priv_data_len + mpa_hdr_len != len) {
+        if (cm_node->mpa_frame_size + sizeof(struct ietf_mpa_frame) != len) {
                 nes_debug(NES_DBG_CM, "The received ietf buffer was not right"
-                        " complete (%x + %x != %x)\n",
-                        priv_data_len, mpa_hdr_len, len);
+                                " complete (%x + %x != %x)\n",
+                                cm_node->mpa_frame_size,
+                                (u32)sizeof(struct ietf_mpa_frame), len);
                 return -EINVAL;
         }
         /* make sure it does not exceed the max size */
         if (len > MAX_CM_BUFFER) {
                 nes_debug(NES_DBG_CM, "The received ietf buffer was too large"
-                        " (%x + %x != %x)\n",
-                        priv_data_len, mpa_hdr_len, len);
+                                " (%x + %x != %x)\n",
+                                cm_node->mpa_frame_size,
+                                (u32)sizeof(struct ietf_mpa_frame), len);
                 return -EINVAL;
         }
 
-        cm_node->mpa_frame_size = priv_data_len;
-
-        switch (mpa_frame->rev) {
-        case IETF_MPA_V2: {
-                u16 ird_size;
-                u16 ord_size;
-                u16 rtr_ctrl_ird;
-                u16 rtr_ctrl_ord;
-
-                mpa_v2_frame = (struct ietf_mpa_v2 *)buffer;
-                mpa_hdr_len += IETF_RTR_MSG_SIZE;
-                cm_node->mpa_frame_size -= IETF_RTR_MSG_SIZE;
-                rtr_msg = &mpa_v2_frame->rtr_msg;
-
-                /* parse rtr message */
-                rtr_ctrl_ird = ntohs(rtr_msg->ctrl_ird);
-                rtr_ctrl_ord = ntohs(rtr_msg->ctrl_ord);
-                ird_size = rtr_ctrl_ird & IETF_NO_IRD_ORD;
-                ord_size = rtr_ctrl_ord & IETF_NO_IRD_ORD;
-
-                if (!(rtr_ctrl_ird & IETF_PEER_TO_PEER)) {
-                        /* send reset */
-                        return -EINVAL;
-                }
-
-                if (cm_node->state != NES_CM_STATE_MPAREQ_SENT) {
-                        /* responder */
-                        if (cm_node->ord_size > ird_size)
-                                cm_node->ord_size = ird_size;
-                } else {
-                        /* initiator */
-                        if (cm_node->ord_size > ird_size)
-                                cm_node->ord_size = ird_size;
-
-                        if (cm_node->ird_size < ord_size) {
-                                /* no resources available */
-                                /* send terminate message */
-                                return -EINVAL;
-                        }
-                }
-
-                if (rtr_ctrl_ord & IETF_RDMA0_READ) {
-                        cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
-                } else if (rtr_ctrl_ord & IETF_RDMA0_WRITE) {
-                        cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO;
-                } else {        /* Not supported RDMA0 operation */
-                        return -EINVAL;
-                }
-                break;
-        }
-        case IETF_MPA_V1:
-        default:
-                break;
-        }
-
         /* copy entire MPA frame to our cm_node's frame */
-        memcpy(cm_node->mpa_frame_buf, buffer + mpa_hdr_len, cm_node->mpa_frame_size);
+        memcpy(cm_node->mpa_frame_buf, buffer + sizeof(struct ietf_mpa_frame),
+                        cm_node->mpa_frame_size);
 
         if (mpa_frame->flags & IETF_MPA_FLAGS_REJECT)
                 *type = NES_MPA_REQUEST_REJECT;
@@ -401,8 +312,8 @@ static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
  * node info to build.
  */
 static void form_cm_frame(struct sk_buff *skb,
-                          struct nes_cm_node *cm_node, void *options, u32 optionsize,
-                          void *data, u32 datasize, u8 flags)
+        struct nes_cm_node *cm_node, void *options, u32 optionsize,
+        void *data, u32 datasize, u8 flags)
 {
         struct tcphdr *tcph;
         struct iphdr *iph;
@@ -411,14 +322,14 @@ static void form_cm_frame(struct sk_buff *skb,
         u16 packetsize = sizeof(*iph);
 
         packetsize += sizeof(*tcph);
-        packetsize += optionsize + datasize;
+        packetsize +=  optionsize + datasize;
 
-        skb_trim(skb, 0);
         memset(skb->data, 0x00, ETH_HLEN + sizeof(*iph) + sizeof(*tcph));
 
+        skb->len = 0;
         buf = skb_put(skb, packetsize + ETH_HLEN);
 
-        ethh = (struct ethhdr *)buf;
+        ethh = (struct ethhdr *) buf;
         buf += ETH_HLEN;
 
         iph = (struct iphdr *)buf;
@@ -426,12 +337,10 @@ static void form_cm_frame(struct sk_buff *skb,
         tcph = (struct tcphdr *)buf;
         skb_reset_mac_header(skb);
         skb_set_network_header(skb, ETH_HLEN);
-        skb_set_transport_header(skb, ETH_HLEN + sizeof(*iph));
+        skb_set_transport_header(skb, ETH_HLEN+sizeof(*iph));
         buf += sizeof(*tcph);
 
         skb->ip_summed = CHECKSUM_PARTIAL;
-        if (!(cm_node->netdev->features & NETIF_F_IP_CSUM))
-                skb->ip_summed = CHECKSUM_NONE;
         skb->protocol = htons(0x800);
         skb->data_len = 0;
         skb->mac_len = ETH_HLEN;
@@ -441,14 +350,14 @@ static void form_cm_frame(struct sk_buff *skb,
         ethh->h_proto = htons(0x0800);
 
         iph->version = IPVERSION;
-        iph->ihl = 5;           /* 5 * 4Byte words, IP headr len */
+        iph->ihl = 5;           /* 5 * 4Byte words, IP headr len */
         iph->tos = 0;
         iph->tot_len = htons(packetsize);
         iph->id = htons(++cm_node->tcp_cntxt.loc_id);
 
         iph->frag_off = htons(0x4000);
         iph->ttl = 0x40;
-        iph->protocol = 0x06;   /* IPPROTO_TCP */
+        iph->protocol = 0x06;   /* IPPROTO_TCP */
 
         iph->saddr = htonl(cm_node->loc_addr);
         iph->daddr = htonl(cm_node->rem_addr);
@@ -461,16 +370,14 @@ static void form_cm_frame(struct sk_buff *skb,
                 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
                 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
                 tcph->ack = 1;
-        } else {
+        } else
                 tcph->ack_seq = 0;
-        }
 
         if (flags & SET_SYN) {
                 cm_node->tcp_cntxt.loc_seq_num++;
                 tcph->syn = 1;
-        } else {
+        } else
                 cm_node->tcp_cntxt.loc_seq_num += datasize;
-        }
 
         if (flags & SET_FIN) {
                 cm_node->tcp_cntxt.loc_seq_num++;
@@ -491,8 +398,10 @@ static void form_cm_frame(struct sk_buff *skb,
 
         skb_shinfo(skb)->nr_frags = 0;
         cm_packets_created++;
+
 }
 
+
 /**
  * print_core - dump a cm core
  */
@@ -504,7 +413,7 @@ static void print_core(struct nes_cm_core *core)
                 return;
         nes_debug(NES_DBG_CM, "---------------------------------------------\n");
 
-        nes_debug(NES_DBG_CM, "State         : %u \n", core->state);
+        nes_debug(NES_DBG_CM, "State         : %u \n",  core->state);
 
         nes_debug(NES_DBG_CM, "Listen Nodes  : %u \n", atomic_read(&core->listen_node_cnt));
         nes_debug(NES_DBG_CM, "Active Nodes  : %u \n", atomic_read(&core->node_cnt));
@@ -514,147 +423,6 @@ static void print_core(struct nes_cm_core *core)
         nes_debug(NES_DBG_CM, "-------------- end core ---------------\n");
 }
 
-/**
- * cm_build_mpa_frame - build a MPA V1 frame or MPA V2 frame
- */
-static int cm_build_mpa_frame(struct nes_cm_node *cm_node, u8 **start_buff,
-                              u16 *buff_len, u8 *pci_mem, u8 mpa_key)
-{
-        int ret = 0;
-
-        *start_buff = (pci_mem) ? pci_mem : &cm_node->mpa_frame_buf[0];
-
-        switch (cm_node->mpa_frame_rev) {
-        case IETF_MPA_V1:
-                *start_buff = (u8 *)*start_buff + sizeof(struct ietf_rtr_msg);
-                *buff_len = sizeof(struct ietf_mpa_v1) + cm_node->mpa_frame_size;
-                build_mpa_v1(cm_node, *start_buff, mpa_key);
-                break;
-        case IETF_MPA_V2:
-                *buff_len = sizeof(struct ietf_mpa_v2) + cm_node->mpa_frame_size;
-                build_mpa_v2(cm_node, *start_buff, mpa_key);
-                break;
-        default:
-                ret = -EINVAL;
-        }
-        return ret;
-}
-
-/**
- * build_mpa_v2 - build a MPA V2 frame
- */
-static void build_mpa_v2(struct nes_cm_node *cm_node,
-                         void *start_addr, u8 mpa_key)
-{
-        struct ietf_mpa_v2 *mpa_frame = (struct ietf_mpa_v2 *)start_addr;
-        struct ietf_rtr_msg *rtr_msg = &mpa_frame->rtr_msg;
-        u16 ctrl_ird;
-        u16 ctrl_ord;
-
-        /* initialize the upper 5 bytes of the frame */
-        build_mpa_v1(cm_node, start_addr, mpa_key);
-        mpa_frame->flags |= IETF_MPA_V2_FLAG; /* set a bit to indicate MPA V2 */
-        mpa_frame->priv_data_len += htons(IETF_RTR_MSG_SIZE);
-
-        /* initialize RTR msg */
-        ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
-                            IETF_NO_IRD_ORD : cm_node->ird_size;
-        ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
-                            IETF_NO_IRD_ORD : cm_node->ord_size;
-
-        ctrl_ird |= IETF_PEER_TO_PEER;
-        ctrl_ird |= IETF_FLPDU_ZERO_LEN;
-
-        switch (mpa_key) {
-        case MPA_KEY_REQUEST:
-                ctrl_ord |= IETF_RDMA0_WRITE;
-                ctrl_ord |= IETF_RDMA0_READ;
-                break;
-        case MPA_KEY_REPLY:
-                switch (cm_node->send_rdma0_op) {
-                case SEND_RDMA_WRITE_ZERO:
-                        ctrl_ord |= IETF_RDMA0_WRITE;
-                        break;
-                case SEND_RDMA_READ_ZERO:
-                        ctrl_ord |= IETF_RDMA0_READ;
-                        break;
-                }
-        }
-        rtr_msg->ctrl_ird = htons(ctrl_ird);
-        rtr_msg->ctrl_ord = htons(ctrl_ord);
-}
-
-/**
- * build_mpa_v1 - build a MPA V1 frame
- */
-static void build_mpa_v1(struct nes_cm_node *cm_node, void *start_addr, u8 mpa_key)
-{
-        struct ietf_mpa_v1 *mpa_frame = (struct ietf_mpa_v1 *)start_addr;
-
-        switch (mpa_key) {
-        case MPA_KEY_REQUEST:
-                memcpy(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE);
-                break;
-        case MPA_KEY_REPLY:
-                memcpy(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE);
-                break;
-        }
-        mpa_frame->flags = IETF_MPA_FLAGS_CRC;
-        mpa_frame->rev = cm_node->mpa_frame_rev;
-        mpa_frame->priv_data_len = htons(cm_node->mpa_frame_size);
-}
-
-static void build_rdma0_msg(struct nes_cm_node *cm_node, struct nes_qp **nesqp_addr)
-{
-        u64 u64temp;
-        struct nes_qp *nesqp = *nesqp_addr;
-        struct nes_hw_qp_wqe *wqe = &nesqp->hwqp.sq_vbase[0];
-
-        u64temp = (unsigned long)nesqp;
-        u64temp |= NES_SW_CONTEXT_ALIGN >> 1;
-        set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX, u64temp);
-
-        wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_LOW_IDX] = 0;
-        wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_HIGH_IDX] = 0;
-
-        switch (cm_node->send_rdma0_op) {
-        case SEND_RDMA_WRITE_ZERO:
-                nes_debug(NES_DBG_CM, "Sending first write.\n");
-                wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] =
-                        cpu_to_le32(NES_IWARP_SQ_OP_RDMAW);
-                wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] = 0;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] = 0;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 0;
-                break;
-
-        case SEND_RDMA_READ_ZERO:
-        default:
-                if (cm_node->send_rdma0_op != SEND_RDMA_READ_ZERO)
-                        WARN(1, "Unsupported RDMA0 len operation=%u\n",
-                             cm_node->send_rdma0_op);
-                nes_debug(NES_DBG_CM, "Sending first rdma operation.\n");
-                wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] =
-                        cpu_to_le32(NES_IWARP_SQ_OP_RDMAR);
-                wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_TO_LOW_IDX] = 1;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_TO_HIGH_IDX] = 0;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_LENGTH_IDX] = 0;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_STAG_IDX] = 1;
-                wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 1;
-                break;
-        }
-
-        if (nesqp->sq_kmapped) {
-                nesqp->sq_kmapped = 0;
-                kunmap(nesqp->page);
-        }
-
-        /*use the reserved spot on the WQ for the extra first WQE*/
-        nesqp->nesqp_context->ird_ord_sizes &= cpu_to_le32(~(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT |
-                                                             NES_QPCONTEXT_ORDIRD_WRPDU |
-                                                             NES_QPCONTEXT_ORDIRD_ALSMM));
-        nesqp->skip_lsmm = 1;
-        nesqp->hwqp.sq_tail = 0;
-}
 
 /**
  * schedule_nes_timer
@@ -662,13 +430,14 @@ static void build_rdma0_msg(struct nes_cm_node *cm_node, struct nes_qp **nesqp_a
  *                      rem_ref_cm_node(cm_core, cm_node);add_ref_cm_node(cm_node);
  */
 int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                       enum nes_timer_type type, int send_retrans,
-                       int close_when_complete)
+                enum nes_timer_type type, int send_retrans,
+                int close_when_complete)
 {
-        unsigned long flags;
+        unsigned long  flags;
         struct nes_cm_core *cm_core = cm_node->cm_core;
         struct nes_timer_entry *new_send;
         int ret = 0;
+        u32 was_timer_set;
 
         new_send = kzalloc(sizeof(*new_send), GFP_ATOMIC);
         if (!new_send)
@@ -685,7 +454,7 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
         new_send->close_when_complete = close_when_complete;
 
         if (type == NES_TIMER_TYPE_CLOSE) {
-                new_send->timetosend += (HZ / 10);
+                new_send->timetosend += (HZ/10);
                 if (cm_node->recv_entry) {
                         kfree(new_send);
                         WARN_ON(1);
@@ -706,7 +475,7 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 ret = nes_nic_cm_xmit(new_send->skb, cm_node->netdev);
                 if (ret != NETDEV_TX_OK) {
                         nes_debug(NES_DBG_CM, "Error sending packet %p "
-                                  "(jiffies = %lu)\n", new_send, jiffies);
+                                "(jiffies = %lu)\n", new_send, jiffies);
                         new_send->timetosend = jiffies;
                         ret = NETDEV_TX_OK;
                 } else {
@@ -720,8 +489,12 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 }
         }
 
-        if (!timer_pending(&cm_core->tcp_timer))
-                mod_timer(&cm_core->tcp_timer, new_send->timetosend);
+        was_timer_set = timer_pending(&cm_core->tcp_timer);
+
+        if (!was_timer_set) {
+                cm_core->tcp_timer.expires = new_send->timetosend;
+                add_timer(&cm_core->tcp_timer);
+        }
 
         return ret;
 }
@@ -731,7 +504,6 @@ static void nes_retrans_expired(struct nes_cm_node *cm_node)
         struct iw_cm_id *cm_id = cm_node->cm_id;
         enum nes_cm_node_state state = cm_node->state;
         cm_node->state = NES_CM_STATE_CLOSED;
-
         switch (state) {
         case NES_CM_STATE_SYN_RCVD:
         case NES_CM_STATE_CLOSING:
@@ -764,10 +536,10 @@ static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node)
                 spin_lock_irqsave(&nesqp->lock, qplockflags);
                 if (nesqp->cm_id) {
                         nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, "
-                                  "refcount = %d: HIT A "
-                                  "NES_TIMER_TYPE_CLOSE with something "
-                                  "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
-                                  atomic_read(&nesqp->refcount));
+                                "refcount = %d: HIT A "
+                                "NES_TIMER_TYPE_CLOSE with something "
+                                "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
+                                atomic_read(&nesqp->refcount));
                         nesqp->hw_tcp_state = NES_AEQE_TCP_STATE_CLOSED;
                         nesqp->last_aeq = NES_AEQE_AEID_RESET_SENT;
                         nesqp->ibqp_state = IB_QPS_ERR;
@@ -776,10 +548,10 @@ static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node)
                 } else {
                         spin_unlock_irqrestore(&nesqp->lock, qplockflags);
                         nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, "
-                                  "refcount = %d: HIT A "
-                                  "NES_TIMER_TYPE_CLOSE with nothing "
-                                  "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
-                                  atomic_read(&nesqp->refcount));
+                                "refcount = %d: HIT A "
+                                "NES_TIMER_TYPE_CLOSE with nothing "
+                                "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
+                                atomic_read(&nesqp->refcount));
                 }
         } else if (rem_node) {
                 /* TIME_WAIT state */
@@ -808,12 +580,11 @@ static void nes_cm_timer_tick(unsigned long pass)
         int ret = NETDEV_TX_OK;
 
         struct list_head timer_list;
-
         INIT_LIST_HEAD(&timer_list);
         spin_lock_irqsave(&cm_core->ht_lock, flags);
 
         list_for_each_safe(list_node, list_core_temp,
-                           &cm_core->connected_nodes) {
+                                &cm_core->connected_nodes) {
                 cm_node = container_of(list_node, struct nes_cm_node, list);
                 if ((cm_node->recv_entry) || (cm_node->send_entry)) {
                         add_ref_cm_node(cm_node);
@@ -824,19 +595,18 @@ static void nes_cm_timer_tick(unsigned long pass)
 
         list_for_each_safe(list_node, list_core_temp, &timer_list) {
                 cm_node = container_of(list_node, struct nes_cm_node,
-                                       timer_entry);
+                                        timer_entry);
                 recv_entry = cm_node->recv_entry;
 
                 if (recv_entry) {
                         if (time_after(recv_entry->timetosend, jiffies)) {
                                 if (nexttimeout > recv_entry->timetosend ||
-                                    !settimer) {
+                                                !settimer) {
                                         nexttimeout = recv_entry->timetosend;
                                         settimer = 1;
                                 }
-                        } else {
+                        } else
                                 handle_recv_entry(cm_node, 1);
-                        }
                 }
 
                 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
@@ -847,8 +617,8 @@ static void nes_cm_timer_tick(unsigned long pass)
                         if (time_after(send_entry->timetosend, jiffies)) {
                                 if (cm_node->state != NES_CM_STATE_TSA) {
                                         if ((nexttimeout >
-                                             send_entry->timetosend) ||
-                                            !settimer) {
+                                                send_entry->timetosend) ||
+                                                !settimer) {
                                                 nexttimeout =
                                                         send_entry->timetosend;
                                                 settimer = 1;
@@ -860,13 +630,13 @@ static void nes_cm_timer_tick(unsigned long pass)
                         }
 
                         if ((cm_node->state == NES_CM_STATE_TSA) ||
-                            (cm_node->state == NES_CM_STATE_CLOSED)) {
+                                (cm_node->state == NES_CM_STATE_CLOSED)) {
                                 free_retrans_entry(cm_node);
                                 break;
                         }
 
                         if (!send_entry->retranscount ||
-                            !send_entry->retrycount) {
+                                !send_entry->retrycount) {
                                 cm_packets_dropped++;
                                 free_retrans_entry(cm_node);
 
@@ -875,28 +645,28 @@ static void nes_cm_timer_tick(unsigned long pass)
                                 nes_retrans_expired(cm_node);
                                 cm_node->state = NES_CM_STATE_CLOSED;
                                 spin_lock_irqsave(&cm_node->retrans_list_lock,
-                                                  flags);
+                                        flags);
                                 break;
                         }
                         atomic_inc(&send_entry->skb->users);
                         cm_packets_retrans++;
                         nes_debug(NES_DBG_CM, "Retransmitting send_entry %p "
-                                  "for node %p, jiffies = %lu, time to send = "
-                                  "%lu, retranscount = %u, send_entry->seq_num = "
-                                  "0x%08X, cm_node->tcp_cntxt.rem_ack_num = "
-                                  "0x%08X\n", send_entry, cm_node, jiffies,
-                                  send_entry->timetosend,
-                                  send_entry->retranscount,
-                                  send_entry->seq_num,
-                                  cm_node->tcp_cntxt.rem_ack_num);
+                                "for node %p, jiffies = %lu, time to send = "
+                                "%lu, retranscount = %u, send_entry->seq_num = "
+                                "0x%08X, cm_node->tcp_cntxt.rem_ack_num = "
+                                "0x%08X\n", send_entry, cm_node, jiffies,
+                                send_entry->timetosend,
+                                send_entry->retranscount,
+                                send_entry->seq_num,
+                                cm_node->tcp_cntxt.rem_ack_num);
 
                         spin_unlock_irqrestore(&cm_node->retrans_list_lock,
-                                               flags);
+                                flags);
                         ret = nes_nic_cm_xmit(send_entry->skb, cm_node->netdev);
                         spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
                         if (ret != NETDEV_TX_OK) {
                                 nes_debug(NES_DBG_CM, "rexmit failed for "
-                                          "node=%p\n", cm_node);
+                                        "node=%p\n", cm_node);
                                 cm_packets_bounced++;
                                 send_entry->retrycount--;
                                 nexttimeout = jiffies + NES_SHORT_TIME;
@@ -906,18 +676,18 @@ static void nes_cm_timer_tick(unsigned long pass)
                                 cm_packets_sent++;
                         }
                         nes_debug(NES_DBG_CM, "Packet Sent: retrans count = "
-                                  "%u, retry count = %u.\n",
-                                  send_entry->retranscount,
-                                  send_entry->retrycount);
+                                "%u, retry count = %u.\n",
+                                send_entry->retranscount,
+                                send_entry->retrycount);
                         if (send_entry->send_retrans) {
                                 send_entry->retranscount--;
                                 timetosend = (NES_RETRY_TIMEOUT <<
-                                              (NES_DEFAULT_RETRANS - send_entry->retranscount));
+                                        (NES_DEFAULT_RETRANS - send_entry->retranscount));
 
                                 send_entry->timetosend = jiffies +
-                                                         min(timetosend, NES_MAX_TIMEOUT);
+                                        min(timetosend, NES_MAX_TIMEOUT);
                                 if (nexttimeout > send_entry->timetosend ||
-                                    !settimer) {
+                                        !settimer) {
                                         nexttimeout = send_entry->timetosend;
                                         settimer = 1;
                                 }
@@ -926,11 +696,11 @@ static void nes_cm_timer_tick(unsigned long pass)
                                 close_when_complete =
                                         send_entry->close_when_complete;
                                 nes_debug(NES_DBG_CM, "cm_node=%p state=%d\n",
-                                          cm_node, cm_node->state);
+                                        cm_node, cm_node->state);
                                 free_retrans_entry(cm_node);
                                 if (close_when_complete)
                                         rem_ref_cm_node(cm_node->cm_core,
-                                                        cm_node);
+                                                cm_node);
                         }
                 } while (0);
 
@@ -939,8 +709,10 @@ static void nes_cm_timer_tick(unsigned long pass)
         }
 
         if (settimer) {
-                if (!timer_pending(&cm_core->tcp_timer))
-                        mod_timer(&cm_core->tcp_timer, nexttimeout);
+                if (!timer_pending(&cm_core->tcp_timer)) {
+                        cm_core->tcp_timer.expires  = nexttimeout;
+                        add_timer(&cm_core->tcp_timer);
+                }
         }
 }
 
@@ -949,13 +721,13 @@ static void nes_cm_timer_tick(unsigned long pass)
  * send_syn
  */
 static int send_syn(struct nes_cm_node *cm_node, u32 sendack,
-                    struct sk_buff *skb)
+        struct sk_buff *skb)
 {
         int ret;
         int flags = SET_SYN;
         char optionsbuffer[sizeof(struct option_mss) +
-                           sizeof(struct option_windowscale) + sizeof(struct option_base) +
-                           TCP_OPTIONS_PADDING];
+                sizeof(struct option_windowscale) + sizeof(struct option_base) +
+                TCP_OPTIONS_PADDING];
 
         int optionssize = 0;
         /* Sending MSS option */
@@ -1082,7 +854,7 @@ static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb)
  * find_node - find a cm node that matches the reference cm node
  */
 static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
-                                     u16 rem_port, nes_addr_t rem_addr, u16 loc_port, nes_addr_t loc_addr)
+                u16 rem_port, nes_addr_t rem_addr, u16 loc_port, nes_addr_t loc_addr)
 {
         unsigned long flags;
         struct list_head *hte;
@@ -1096,12 +868,12 @@ static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
         list_for_each_entry(cm_node, hte, list) {
                 /* compare quad, return node handle if a match */
                 nes_debug(NES_DBG_CM, "finding node %x:%x =? %x:%x ^ %x:%x =? %x:%x\n",
-                          cm_node->loc_addr, cm_node->loc_port,
-                          loc_addr, loc_port,
-                          cm_node->rem_addr, cm_node->rem_port,
-                          rem_addr, rem_port);
+                                cm_node->loc_addr, cm_node->loc_port,
+                                loc_addr, loc_port,
+                                cm_node->rem_addr, cm_node->rem_port,
+                                rem_addr, rem_port);
                 if ((cm_node->loc_addr == loc_addr) && (cm_node->loc_port == loc_port) &&
-                    (cm_node->rem_addr == rem_addr) && (cm_node->rem_port == rem_port)) {
+                                (cm_node->rem_addr == rem_addr) && (cm_node->rem_port == rem_port)) {
                         add_ref_cm_node(cm_node);
                         spin_unlock_irqrestore(&cm_core->ht_lock, flags);
                         return cm_node;
@@ -1118,7 +890,7 @@ static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
  * find_listener - find a cm node listening on this addr-port pair
  */
 static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
-                                             nes_addr_t dst_addr, u16 dst_port, enum nes_cm_listener_state listener_state)
+                nes_addr_t dst_addr, u16 dst_port, enum nes_cm_listener_state listener_state)
 {
         unsigned long flags;
         struct nes_cm_listener *listen_node;
@@ -1128,9 +900,9 @@ static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
         list_for_each_entry(listen_node, &cm_core->listen_list.list, list) {
                 /* compare node pair, return node handle if a match */
                 if (((listen_node->loc_addr == dst_addr) ||
-                     listen_node->loc_addr == 0x00000000) &&
-                    (listen_node->loc_port == dst_port) &&
-                    (listener_state & listen_node->listener_state)) {
+                                listen_node->loc_addr == 0x00000000) &&
+                                (listen_node->loc_port == dst_port) &&
+                                (listener_state & listen_node->listener_state)) {
                         atomic_inc(&listen_node->ref_count);
                         spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
                         return listen_node;
@@ -1155,7 +927,7 @@ static int add_hte_node(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node
                 return -EINVAL;
 
         nes_debug(NES_DBG_CM, "Adding Node %p to Active Connection HT\n",
-                  cm_node);
+                cm_node);
 
         spin_lock_irqsave(&cm_core->ht_lock, flags);
 
@@ -1174,7 +946,7 @@ static int add_hte_node(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node
  * mini_cm_dec_refcnt_listen
  */
 static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
-                                     struct nes_cm_listener *listener, int free_hanging_nodes)
+        struct nes_cm_listener *listener, int free_hanging_nodes)
 {
         int ret = -EINVAL;
         int err = 0;
@@ -1185,8 +957,8 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
         struct list_head reset_list;
 
         nes_debug(NES_DBG_CM, "attempting listener= %p free_nodes= %d, "
-                  "refcnt=%d\n", listener, free_hanging_nodes,
-                  atomic_read(&listener->ref_count));
+                "refcnt=%d\n", listener, free_hanging_nodes,
+                atomic_read(&listener->ref_count));
         /* free non-accelerated child nodes for this listener */
         INIT_LIST_HEAD(&reset_list);
         if (free_hanging_nodes) {
@@ -1194,7 +966,7 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
                 list_for_each_safe(list_pos, list_temp,
                                    &g_cm_core->connected_nodes) {
                         cm_node = container_of(list_pos, struct nes_cm_node,
-                                               list);
+                                list);
                         if ((cm_node->listener == listener) &&
                             (!cm_node->accelerated)) {
                                 add_ref_cm_node(cm_node);
@@ -1206,7 +978,7 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
 
         list_for_each_safe(list_pos, list_temp, &reset_list) {
                 cm_node = container_of(list_pos, struct nes_cm_node,
-                                       reset_entry);
+                                reset_entry);
                 {
                         struct nes_cm_node *loopback = cm_node->loopbackpartner;
                         enum nes_cm_node_state old_state;
@@ -1218,7 +990,7 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
                                         err = send_reset(cm_node, NULL);
                                         if (err) {
                                                 cm_node->state =
-                                                        NES_CM_STATE_CLOSED;
+                                                         NES_CM_STATE_CLOSED;
                                                 WARN_ON(1);
                                         } else {
                                                 old_state = cm_node->state;
@@ -1263,9 +1035,10 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
 
                 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
 
-                if (listener->nesvnic)
+                if (listener->nesvnic) {
                         nes_manage_apbvt(listener->nesvnic, listener->loc_port,
-                                         PCI_FUNC(listener->nesvnic->nesdev->pcidev->devfn), NES_MANAGE_APBVT_DEL);
+                                        PCI_FUNC(listener->nesvnic->nesdev->pcidev->devfn), NES_MANAGE_APBVT_DEL);
+                }
 
                 nes_debug(NES_DBG_CM, "destroying listener (%p)\n", listener);
 
@@ -1279,8 +1052,8 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
         if (listener) {
                 if (atomic_read(&listener->pend_accepts_cnt) > 0)
                         nes_debug(NES_DBG_CM, "destroying listener (%p)"
-                                  " with non-zero pending accepts=%u\n",
-                                  listener, atomic_read(&listener->pend_accepts_cnt));
+                                        " with non-zero pending accepts=%u\n",
+                                        listener, atomic_read(&listener->pend_accepts_cnt));
         }
 
         return ret;
@@ -1291,7 +1064,7 @@ static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
  * mini_cm_del_listen
  */
 static int mini_cm_del_listen(struct nes_cm_core *cm_core,
-                              struct nes_cm_listener *listener)
+                struct nes_cm_listener *listener)
 {
         listener->listener_state = NES_CM_LISTENER_PASSIVE_STATE;
         listener->cm_id = NULL; /* going to be destroyed pretty soon */
@@ -1303,8 +1076,9 @@ static int mini_cm_del_listen(struct nes_cm_core *cm_core,
  * mini_cm_accelerated
  */
 static inline int mini_cm_accelerated(struct nes_cm_core *cm_core,
-                                      struct nes_cm_node *cm_node)
+                struct nes_cm_node *cm_node)
 {
+        u32 was_timer_set;
         cm_node->accelerated = 1;
 
         if (cm_node->accept_pend) {
@@ -1314,8 +1088,11 @@ static inline int mini_cm_accelerated(struct nes_cm_core *cm_core,
                 BUG_ON(atomic_read(&cm_node->listener->pend_accepts_cnt) < 0);
         }
 
-        if (!timer_pending(&cm_core->tcp_timer))
-                mod_timer(&cm_core->tcp_timer, (jiffies + NES_SHORT_TIME));
+        was_timer_set = timer_pending(&cm_core->tcp_timer);
+        if (!was_timer_set) {
+                cm_core->tcp_timer.expires = jiffies + NES_SHORT_TIME;
+                add_timer(&cm_core->tcp_timer);
+        }
 
         return 0;
 }
@@ -1335,7 +1112,7 @@ static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpi
         rt = ip_route_output(&init_net, htonl(dst_ip), 0, 0, 0);
         if (IS_ERR(rt)) {
                 printk(KERN_ERR "%s: ip_route_output_key failed for 0x%08X\n",
-                       __func__, dst_ip);
+                                __func__, dst_ip);
                 return rc;
         }
 
@@ -1345,8 +1122,6 @@ static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpi
                 netdev = nesvnic->netdev;
 
         neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, netdev);
-
-        rcu_read_lock();
         if (neigh) {
                 if (neigh->nud_state & NUD_VALID) {
                         nes_debug(NES_DBG_CM, "Neighbor MAC address for 0x%08X"
@@ -1355,30 +1130,31 @@ static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpi
 
                         if (arpindex >= 0) {
                                 if (!memcmp(nesadapter->arp_table[arpindex].mac_addr,
-                                            neigh->ha, ETH_ALEN)) {
+                                                        neigh->ha, ETH_ALEN)){
                                         /* Mac address same as in nes_arp_table */
-                                        goto out;
+                                        neigh_release(neigh);
+                                        ip_rt_put(rt);
+                                        return rc;
                                 }
 
                                 nes_manage_arp_cache(nesvnic->netdev,
-                                                     nesadapter->arp_table[arpindex].mac_addr,
-                                                     dst_ip, NES_ARP_DELETE);
+                                                nesadapter->arp_table[arpindex].mac_addr,
+                                                dst_ip, NES_ARP_DELETE);
                         }
 
                         nes_manage_arp_cache(nesvnic->netdev, neigh->ha,
                                              dst_ip, NES_ARP_ADD);
                         rc = nes_arp_table(nesvnic->nesdev, dst_ip, NULL,
                                            NES_ARP_RESOLVE);
-                } else {
-                        neigh_event_send(neigh, NULL);
                 }
-        }
-out:
-        rcu_read_unlock();
-
-        if (neigh)
                 neigh_release(neigh);
+        }
 
+        if ((neigh == NULL) || (!(neigh->nud_state & NUD_VALID))) {
+                rcu_read_lock();
+                neigh_event_send(dst_get_neighbour(&rt->dst), NULL);
+                rcu_read_unlock();
+        }
         ip_rt_put(rt);
         return rc;
 }
@@ -1387,8 +1163,8 @@ out:
  * make_cm_node - create a new instance of a cm node
  */
 static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
-                                        struct nes_vnic *nesvnic, struct nes_cm_info *cm_info,
-                                        struct nes_cm_listener *listener)
+                struct nes_vnic *nesvnic, struct nes_cm_info *cm_info,
+                struct nes_cm_listener *listener)
 {
         struct nes_cm_node *cm_node;
         struct timespec ts;
@@ -1407,12 +1183,7 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         cm_node->rem_addr = cm_info->rem_addr;
         cm_node->loc_port = cm_info->loc_port;
         cm_node->rem_port = cm_info->rem_port;
-
-        cm_node->mpa_frame_rev = mpa_version;
-        cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
-        cm_node->ird_size = IETF_NO_IRD_ORD;
-        cm_node->ord_size = IETF_NO_IRD_ORD;
-
+        cm_node->send_write0 = send_first;
         nes_debug(NES_DBG_CM, "Make node addresses : loc = %pI4:%x, rem = %pI4:%x\n",
                   &cm_node->loc_addr, cm_node->loc_port,
                   &cm_node->rem_addr, cm_node->rem_port);
@@ -1422,7 +1193,7 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         memcpy(cm_node->loc_mac, nesvnic->netdev->dev_addr, ETH_ALEN);
 
         nes_debug(NES_DBG_CM, "listener=%p, cm_id=%p\n", cm_node->listener,
-                  cm_node->cm_id);
+                        cm_node->cm_id);
 
         spin_lock_init(&cm_node->retrans_list_lock);
 
@@ -1433,11 +1204,11 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         cm_node->tcp_cntxt.loc_id = NES_CM_DEF_LOCAL_ID;
         cm_node->tcp_cntxt.rcv_wscale = NES_CM_DEFAULT_RCV_WND_SCALE;
         cm_node->tcp_cntxt.rcv_wnd = NES_CM_DEFAULT_RCV_WND_SCALED >>
-                                     NES_CM_DEFAULT_RCV_WND_SCALE;
+                        NES_CM_DEFAULT_RCV_WND_SCALE;
         ts = current_kernel_time();
         cm_node->tcp_cntxt.loc_seq_num = htonl(ts.tv_nsec);
         cm_node->tcp_cntxt.mss = nesvnic->max_frame_size - sizeof(struct iphdr) -
-                                 sizeof(struct tcphdr) - ETH_HLEN - VLAN_HLEN;
+                        sizeof(struct tcphdr) - ETH_HLEN - VLAN_HLEN;
         cm_node->tcp_cntxt.rcv_nxt = 0;
         /* get a unique session ID , add thread_id to an upcounter to handle race */
         atomic_inc(&cm_core->node_cnt);
@@ -1453,8 +1224,13 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
         cm_node->loopbackpartner = NULL;
 
         /* get the mac addr for the remote node */
-        oldarpindex = nes_arp_table(nesdev, cm_node->rem_addr, NULL, NES_ARP_RESOLVE);
-        arpindex = nes_addr_resolve_neigh(nesvnic, cm_info->rem_addr, oldarpindex);
+        if (ipv4_is_loopback(htonl(cm_node->rem_addr)))
+                arpindex = nes_arp_table(nesdev, ntohl(nesvnic->local_ipaddr), NULL, NES_ARP_RESOLVE);
+        else {
+                oldarpindex = nes_arp_table(nesdev, cm_node->rem_addr, NULL, NES_ARP_RESOLVE);
+                arpindex = nes_addr_resolve_neigh(nesvnic, cm_info->rem_addr, oldarpindex);
+
+        }
         if (arpindex < 0) {
                 kfree(cm_node);
                 return NULL;
@@ -1486,7 +1262,7 @@ static int add_ref_cm_node(struct nes_cm_node *cm_node)
  * rem_ref_cm_node - destroy an instance of a cm node
  */
 static int rem_ref_cm_node(struct nes_cm_core *cm_core,
-                           struct nes_cm_node *cm_node)
+        struct nes_cm_node *cm_node)
 {
         unsigned long flags;
         struct nes_qp *nesqp;
@@ -1517,9 +1293,9 @@ static int rem_ref_cm_node(struct nes_cm_core *cm_core,
         } else {
                 if (cm_node->apbvt_set && cm_node->nesvnic) {
                         nes_manage_apbvt(cm_node->nesvnic, cm_node->loc_port,
-                                         PCI_FUNC(
-                                                 cm_node->nesvnic->nesdev->pcidev->devfn),
-                                         NES_MANAGE_APBVT_DEL);
+                                PCI_FUNC(
+                                cm_node->nesvnic->nesdev->pcidev->devfn),
+                                NES_MANAGE_APBVT_DEL);
                 }
         }
 
@@ -1540,7 +1316,7 @@ static int rem_ref_cm_node(struct nes_cm_core *cm_core,
  * process_options
  */
 static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc,
-                           u32 optionsize, u32 syn_packet)
+        u32 optionsize, u32 syn_packet)
 {
         u32 tmp;
         u32 offset = 0;
@@ -1558,15 +1334,15 @@ static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc,
                         continue;
                 case OPTION_NUMBER_MSS:
                         nes_debug(NES_DBG_CM, "%s: MSS Length: %d Offset: %d "
-                                  "Size: %d\n", __func__,
-                                  all_options->as_mss.length, offset, optionsize);
+                                "Size: %d\n", __func__,
+                                all_options->as_mss.length, offset, optionsize);
                         got_mss_option = 1;
                         if (all_options->as_mss.length != 4) {
                                 return 1;
                         } else {
                                 tmp = ntohs(all_options->as_mss.mss);
                                 if (tmp > 0 && tmp <
-                                    cm_node->tcp_cntxt.mss)
+                                        cm_node->tcp_cntxt.mss)
                                         cm_node->tcp_cntxt.mss = tmp;
                         }
                         break;
@@ -1574,9 +1350,12 @@ static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc,
                         cm_node->tcp_cntxt.snd_wscale =
                                 all_options->as_windowscale.shiftcount;
                         break;
+                case OPTION_NUMBER_WRITE0:
+                        cm_node->send_write0 = 1;
+                        break;
                 default:
                         nes_debug(NES_DBG_CM, "TCP Option not understood: %x\n",
-                                  all_options->as_base.optionnum);
+                                all_options->as_base.optionnum);
                         break;
                 }
                 offset += all_options->as_base.length;
@@ -1595,8 +1374,8 @@ static void drop_packet(struct sk_buff *skb)
 static void handle_fin_pkt(struct nes_cm_node *cm_node)
 {
         nes_debug(NES_DBG_CM, "Received FIN, cm_node = %p, state = %u. "
-                  "refcnt=%d\n", cm_node, cm_node->state,
-                  atomic_read(&cm_node->ref_count));
+                "refcnt=%d\n", cm_node, cm_node->state,
+                atomic_read(&cm_node->ref_count));
         switch (cm_node->state) {
         case NES_CM_STATE_SYN_RCVD:
         case NES_CM_STATE_SYN_SENT:
@@ -1662,20 +1441,7 @@ static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
                         "listener=%p state=%d\n", __func__, __LINE__, cm_node,
                         cm_node->listener, cm_node->state);
-                switch (cm_node->mpa_frame_rev) {
-                case IETF_MPA_V2:
-                        cm_node->mpa_frame_rev = IETF_MPA_V1;
-                        /* send a syn and goto syn sent state */
-                        cm_node->state = NES_CM_STATE_SYN_SENT;
-                        if (send_syn(cm_node, 0, NULL)) {
-                                active_open_err(cm_node, skb, reset);
-                        }
-                        break;
-                case IETF_MPA_V1:
-                default:
-                        active_open_err(cm_node, skb, reset);
-                        break;
-                }
+                active_open_err(cm_node, skb, reset);
                 break;
         case NES_CM_STATE_MPAREQ_RCVD:
                 atomic_inc(&cm_node->passive_state);
@@ -1711,21 +1477,21 @@ static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
 
 static void handle_rcv_mpa(struct nes_cm_node *cm_node, struct sk_buff *skb)
 {
-        int ret = 0;
+
+        int     ret = 0;
         int datasize = skb->len;
         u8 *dataloc = skb->data;
 
         enum nes_cm_event_type type = NES_CM_EVENT_UNKNOWN;
-        u32 res_type;
-
+        u32     res_type;
         ret = parse_mpa(cm_node, dataloc, &res_type, datasize);
         if (ret) {
                 nes_debug(NES_DBG_CM, "didn't like MPA Request\n");
                 if (cm_node->state == NES_CM_STATE_MPAREQ_SENT) {
                         nes_debug(NES_DBG_CM, "%s[%u] create abort for "
-                                  "cm_node=%p listener=%p state=%d\n", __func__,
-                                  __LINE__, cm_node, cm_node->listener,
-                                  cm_node->state);
+                                "cm_node=%p listener=%p state=%d\n", __func__,
+                                __LINE__, cm_node, cm_node->listener,
+                                cm_node->state);
                         active_open_err(cm_node, skb, 1);
                 } else {
                         passive_open_err(cm_node, skb, 1);
@@ -1735,15 +1501,16 @@ static void handle_rcv_mpa(struct nes_cm_node *cm_node, struct sk_buff *skb)
 
         switch (cm_node->state) {
         case NES_CM_STATE_ESTABLISHED:
-                if (res_type == NES_MPA_REQUEST_REJECT)
+                if (res_type == NES_MPA_REQUEST_REJECT) {
                         /*BIG problem as we are receiving the MPA.. So should
-                         * not be REJECT.. This is Passive Open.. We can
-                         * only receive it Reject for Active Open...*/
+                        * not be REJECT.. This is Passive Open.. We can
+                        * only receive it Reject for Active Open...*/
                         WARN_ON(1);
+                }
                 cm_node->state = NES_CM_STATE_MPAREQ_RCVD;
                 type = NES_CM_EVENT_MPA_REQ;
                 atomic_set(&cm_node->passive_state,
-                           NES_PASSIVE_STATE_INDICATED);
+                                NES_PASSIVE_STATE_INDICATED);
                 break;
         case NES_CM_STATE_MPAREQ_SENT:
                 cleanup_retrans_entry(cm_node);
@@ -1770,8 +1537,8 @@ static void indicate_pkt_err(struct nes_cm_node *cm_node, struct sk_buff *skb)
         case NES_CM_STATE_SYN_SENT:
         case NES_CM_STATE_MPAREQ_SENT:
                 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
-                          "listener=%p state=%d\n", __func__, __LINE__, cm_node,
-                          cm_node->listener, cm_node->state);
+                        "listener=%p state=%d\n", __func__, __LINE__, cm_node,
+                        cm_node->listener, cm_node->state);
                 active_open_err(cm_node, skb, 1);
                 break;
         case NES_CM_STATE_ESTABLISHED:
@@ -1785,11 +1552,11 @@ static void indicate_pkt_err(struct nes_cm_node *cm_node, struct sk_buff *skb)
 }
 
 static int check_syn(struct nes_cm_node *cm_node, struct tcphdr *tcph,
-                     struct sk_buff *skb)
+        struct sk_buff *skb)
 {
         int err;
 
-        err = ((ntohl(tcph->ack_seq) == cm_node->tcp_cntxt.loc_seq_num)) ? 0 : 1;
+        err = ((ntohl(tcph->ack_seq) == cm_node->tcp_cntxt.loc_seq_num))? 0 : 1;
         if (err)
                 active_open_err(cm_node, skb, 1);
 
@@ -1797,7 +1564,7 @@ static int check_syn(struct nes_cm_node *cm_node, struct tcphdr *tcph,
 }
 
 static int check_seq(struct nes_cm_node *cm_node, struct tcphdr *tcph,
-                     struct sk_buff *skb)
+        struct sk_buff *skb)
 {
         int err = 0;
         u32 seq;
@@ -1805,22 +1572,21 @@ static int check_seq(struct nes_cm_node *cm_node, struct tcphdr *tcph,
         u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num;
         u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
         u32 rcv_wnd;
-
         seq = ntohl(tcph->seq);
         ack_seq = ntohl(tcph->ack_seq);
         rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
         if (ack_seq != loc_seq_num)
                 err = 1;
-        else if (!between(seq, rcv_nxt, (rcv_nxt + rcv_wnd)))
+        else if (!between(seq, rcv_nxt, (rcv_nxt+rcv_wnd)))
                 err = 1;
         if (err) {
                 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
-                          "listener=%p state=%d\n", __func__, __LINE__, cm_node,
-                          cm_node->listener, cm_node->state);
+                        "listener=%p state=%d\n", __func__, __LINE__, cm_node,
+                        cm_node->listener, cm_node->state);
                 indicate_pkt_err(cm_node, skb);
                 nes_debug(NES_DBG_CM, "seq ERROR cm_node =%p seq=0x%08X "
-                          "rcv_nxt=0x%08X rcv_wnd=0x%x\n", cm_node, seq, rcv_nxt,
-                          rcv_wnd);
+                        "rcv_nxt=0x%08X rcv_wnd=0x%x\n", cm_node, seq, rcv_nxt,
+                        rcv_wnd);
         }
         return err;
 }
@@ -1830,8 +1596,9 @@ static int check_seq(struct nes_cm_node *cm_node, struct tcphdr *tcph,
  * is created with a listener or it may comein as rexmitted packet which in
  * that case will be just dropped.
  */
+
 static void handle_syn_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                           struct tcphdr *tcph)
+        struct tcphdr *tcph)
 {
         int ret;
         u32 inc_sequence;
@@ -1850,15 +1617,15 @@ static void handle_syn_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
         case NES_CM_STATE_LISTENING:
                 /* Passive OPEN */
                 if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
-                    cm_node->listener->backlog) {
+                                cm_node->listener->backlog) {
                         nes_debug(NES_DBG_CM, "drop syn due to backlog "
-                                  "pressure \n");
+                                "pressure \n");
                         cm_backlog_drops++;
                         passive_open_err(cm_node, skb, 0);
                         break;
                 }
                 ret = handle_tcp_options(cm_node, tcph, skb, optionsize,
-                                         1);
+                        1);
                 if (ret) {
                         passive_open_err(cm_node, skb, 0);
                         /* drop pkt */
@@ -1892,8 +1659,9 @@ static void handle_syn_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
 }
 
 static void handle_synack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                              struct tcphdr *tcph)
+        struct tcphdr *tcph)
 {
+
         int ret;
         u32 inc_sequence;
         int optionsize;
@@ -1912,7 +1680,7 @@ static void handle_synack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 0);
                 if (ret) {
                         nes_debug(NES_DBG_CM, "cm_node=%p tcp_options failed\n",
-                                  cm_node);
+                                cm_node);
                         break;
                 }
                 cleanup_retrans_entry(cm_node);
@@ -1951,13 +1719,12 @@ static void handle_synack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
 }
 
 static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                          struct tcphdr *tcph)
+        struct tcphdr *tcph)
 {
         int datasize = 0;
         u32 inc_sequence;
         int ret = 0;
         int optionsize;
-
         optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
 
         if (check_seq(cm_node, tcph, skb))
@@ -1978,9 +1745,8 @@ static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 if (datasize) {
                         cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
                         handle_rcv_mpa(cm_node, skb);
-                } else { /* rcvd ACK only */
+                } else  /* rcvd ACK only */
                         dev_kfree_skb_any(skb);
-                }
                 break;
         case NES_CM_STATE_ESTABLISHED:
                 /* Passive OPEN */
@@ -1988,18 +1754,16 @@ static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 if (datasize) {
                         cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
                         handle_rcv_mpa(cm_node, skb);
-                } else {
+                } else
                         drop_packet(skb);
-                }
                 break;
         case NES_CM_STATE_MPAREQ_SENT:
                 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
                 if (datasize) {
                         cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
                         handle_rcv_mpa(cm_node, skb);
-                } else { /* Could be just an ack pkt.. */
+                } else  /* Could be just an ack pkt.. */
                         dev_kfree_skb_any(skb);
-                }
                 break;
         case NES_CM_STATE_LISTENING:
                 cleanup_retrans_entry(cm_node);
@@ -2040,15 +1804,14 @@ static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
 
 
 static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph,
-                              struct sk_buff *skb, int optionsize, int passive)
+        struct sk_buff *skb, int optionsize, int passive)
 {
         u8 *optionsloc = (u8 *)&tcph[1];
-
         if (optionsize) {
                 if (process_options(cm_node, optionsloc, optionsize,
-                                    (u32)tcph->syn)) {
+                        (u32)tcph->syn)) {
                         nes_debug(NES_DBG_CM, "%s: Node %p, Sending RESET\n",
-                                  __func__, cm_node);
+                                __func__, cm_node);
                         if (passive)
                                 passive_open_err(cm_node, skb, 1);
                         else
@@ -2058,7 +1821,7 @@ static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph,
         }
 
         cm_node->tcp_cntxt.snd_wnd = ntohs(tcph->window) <<
-                                     cm_node->tcp_cntxt.snd_wscale;
+                        cm_node->tcp_cntxt.snd_wscale;
 
         if (cm_node->tcp_cntxt.snd_wnd > cm_node->tcp_cntxt.max_snd_wnd)
                 cm_node->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.snd_wnd;
@@ -2069,18 +1832,18 @@ static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph,
  * active_open_err() will send reset() if flag set..
  * It will also send ABORT event.
  */
+
 static void active_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                            int reset)
+        int reset)
 {
         cleanup_retrans_entry(cm_node);
         if (reset) {
                 nes_debug(NES_DBG_CM, "ERROR active err called for cm_node=%p, "
-                          "state=%d\n", cm_node, cm_node->state);
+                                "state=%d\n", cm_node, cm_node->state);
                 add_ref_cm_node(cm_node);
                 send_reset(cm_node, skb);
-        } else {
+        } else
                 dev_kfree_skb_any(skb);
-        }
 
         cm_node->state = NES_CM_STATE_CLOSED;
         create_event(cm_node, NES_CM_EVENT_ABORTED);
@@ -2090,14 +1853,15 @@ static void active_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb,
  * passive_open_err() will either do a reset() or will free up the skb and
  * remove the cm_node.
  */
+
 static void passive_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                             int reset)
+        int reset)
 {
         cleanup_retrans_entry(cm_node);
         cm_node->state = NES_CM_STATE_CLOSED;
         if (reset) {
                 nes_debug(NES_DBG_CM, "passive_open_err sending RST for "
-                          "cm_node=%p state =%d\n", cm_node, cm_node->state);
+                        "cm_node=%p state =%d\n", cm_node, cm_node->state);
                 send_reset(cm_node, skb);
         } else {
                 dev_kfree_skb_any(skb);
@@ -2112,7 +1876,6 @@ static void passive_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb,
 static void free_retrans_entry(struct nes_cm_node *cm_node)
 {
         struct nes_timer_entry *send_entry;
-
         send_entry = cm_node->send_entry;
         if (send_entry) {
                 cm_node->send_entry = NULL;
@@ -2136,28 +1899,26 @@ static void cleanup_retrans_entry(struct nes_cm_node *cm_node)
  * Returns skb if to be freed, else it will return NULL if already used..
  */
 static void process_packet(struct nes_cm_node *cm_node, struct sk_buff *skb,
-                           struct nes_cm_core *cm_core)
+        struct nes_cm_core *cm_core)
 {
-        enum nes_tcpip_pkt_type pkt_type = NES_PKT_TYPE_UNKNOWN;
+        enum nes_tcpip_pkt_type pkt_type = NES_PKT_TYPE_UNKNOWN;
         struct tcphdr *tcph = tcp_hdr(skb);
-        u32 fin_set = 0;
+        u32     fin_set = 0;
         int ret = 0;
-
         skb_pull(skb, ip_hdr(skb)->ihl << 2);
 
         nes_debug(NES_DBG_CM, "process_packet: cm_node=%p state =%d syn=%d "
-                  "ack=%d rst=%d fin=%d\n", cm_node, cm_node->state, tcph->syn,
-                  tcph->ack, tcph->rst, tcph->fin);
+                "ack=%d rst=%d fin=%d\n", cm_node, cm_node->state, tcph->syn,
+                tcph->ack, tcph->rst, tcph->fin);
 
-        if (tcph->rst) {
+        if (tcph->rst)
                 pkt_type = NES_PKT_TYPE_RST;
-        } else if (tcph->syn) {
+        else if (tcph->syn) {
                 pkt_type = NES_PKT_TYPE_SYN;
                 if (tcph->ack)
                         pkt_type = NES_PKT_TYPE_SYNACK;
-        } else if (tcph->ack) {
+        } else if (tcph->ack)
                 pkt_type = NES_PKT_TYPE_ACK;
-        }
         if (tcph->fin)
                 fin_set = 1;
 
@@ -2188,17 +1949,17 @@ static void process_packet(struct nes_cm_node *cm_node, struct sk_buff *skb,
  * mini_cm_listen - create a listen node with params
  */
 static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *cm_core,
-                                              struct nes_vnic *nesvnic, struct nes_cm_info *cm_info)
+        struct nes_vnic *nesvnic, struct nes_cm_info *cm_info)
 {
         struct nes_cm_listener *listener;
         unsigned long flags;
 
         nes_debug(NES_DBG_CM, "Search for 0x%08x : 0x%04x\n",
-                  cm_info->loc_addr, cm_info->loc_port);
+                cm_info->loc_addr, cm_info->loc_port);
 
         /* cannot have multiple matching listeners */
         listener = find_listener(cm_core, htonl(cm_info->loc_addr),
-                                 htons(cm_info->loc_port), NES_CM_LISTENER_EITHER_STATE);
+                        htons(cm_info->loc_port), NES_CM_LISTENER_EITHER_STATE);
         if (listener && listener->listener_state == NES_CM_LISTENER_ACTIVE_STATE) {
                 /* find automatically incs ref count ??? */
                 atomic_dec(&listener->ref_count);
@@ -2244,9 +2005,9 @@ static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *cm_core,
         }
 
         nes_debug(NES_DBG_CM, "Api - listen(): addr=0x%08X, port=0x%04x,"
-                  " listener = %p, backlog = %d, cm_id = %p.\n",
-                  cm_info->loc_addr, cm_info->loc_port,
-                  listener, listener->backlog, listener->cm_id);
+                        " listener = %p, backlog = %d, cm_id = %p.\n",
+                        cm_info->loc_addr, cm_info->loc_port,
+                        listener, listener->backlog, listener->cm_id);
 
         return listener;
 }
@@ -2256,20 +2017,26 @@ static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *cm_core,
  * mini_cm_connect - make a connection node with params
  */
 static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
-                                           struct nes_vnic *nesvnic, u16 private_data_len,
-                                           void *private_data, struct nes_cm_info *cm_info)
+        struct nes_vnic *nesvnic, u16 private_data_len,
+        void *private_data, struct nes_cm_info *cm_info)
 {
         int ret = 0;
         struct nes_cm_node *cm_node;
         struct nes_cm_listener *loopbackremotelistener;
         struct nes_cm_node *loopbackremotenode;
         struct nes_cm_info loopback_cm_info;
-        u8 *start_buff;
+        u16 mpa_frame_size = sizeof(struct ietf_mpa_frame) + private_data_len;
+        struct ietf_mpa_frame *mpa_frame = NULL;
 
         /* create a CM connection node */
         cm_node = make_cm_node(cm_core, nesvnic, cm_info, NULL);
         if (!cm_node)
                 return NULL;
+        mpa_frame = &cm_node->mpa_frame;
+        memcpy(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE);
+        mpa_frame->flags = IETF_MPA_FLAGS_CRC;
+        mpa_frame->rev =  IETF_MPA_VERSION;
+        mpa_frame->priv_data_len = htons(private_data_len);
 
         /* set our node side to client (active) side */
         cm_node->tcp_cntxt.client = 1;
@@ -2277,8 +2044,8 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
 
         if (cm_info->loc_addr == cm_info->rem_addr) {
                 loopbackremotelistener = find_listener(cm_core,
-                                                       ntohl(nesvnic->local_ipaddr), cm_node->rem_port,
-                                                       NES_CM_LISTENER_ACTIVE_STATE);
+                                ntohl(nesvnic->local_ipaddr), cm_node->rem_port,
+                                NES_CM_LISTENER_ACTIVE_STATE);
                 if (loopbackremotelistener == NULL) {
                         create_event(cm_node, NES_CM_EVENT_ABORTED);
                 } else {
@@ -2287,7 +2054,7 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
                         loopback_cm_info.rem_port = cm_info->loc_port;
                         loopback_cm_info.cm_id = loopbackremotelistener->cm_id;
                         loopbackremotenode = make_cm_node(cm_core, nesvnic,
-                                                          &loopback_cm_info, loopbackremotelistener);
+                                &loopback_cm_info, loopbackremotelistener);
                         if (!loopbackremotenode) {
                                 rem_ref_cm_node(cm_node->cm_core, cm_node);
                                 return NULL;
@@ -2298,7 +2065,7 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
                                 NES_CM_DEFAULT_RCV_WND_SCALE;
                         cm_node->loopbackpartner = loopbackremotenode;
                         memcpy(loopbackremotenode->mpa_frame_buf, private_data,
-                               private_data_len);
+                                private_data_len);
                         loopbackremotenode->mpa_frame_size = private_data_len;
 
                         /* we are done handling this state. */
@@ -2326,10 +2093,12 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
                 return cm_node;
         }
 
-        start_buff = &cm_node->mpa_frame_buf[0] + sizeof(struct ietf_mpa_v2);
-        cm_node->mpa_frame_size = private_data_len;
+        /* set our node side to client (active) side */
+        cm_node->tcp_cntxt.client = 1;
+        /* init our MPA frame ptr */
+        memcpy(mpa_frame->priv_data, private_data, private_data_len);
 
-        memcpy(start_buff, private_data, private_data_len);
+        cm_node->mpa_frame_size = mpa_frame_size;
 
         /* send a syn and goto syn sent state */
         cm_node->state = NES_CM_STATE_SYN_SENT;
@@ -2338,19 +2107,18 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
         if (ret) {
                 /* error in sending the syn free up the cm_node struct */
                 nes_debug(NES_DBG_CM, "Api - connect() FAILED: dest "
-                          "addr=0x%08X, port=0x%04x, cm_node=%p, cm_id = %p.\n",
-                          cm_node->rem_addr, cm_node->rem_port, cm_node,
-                          cm_node->cm_id);
+                        "addr=0x%08X, port=0x%04x, cm_node=%p, cm_id = %p.\n",
+                        cm_node->rem_addr, cm_node->rem_port, cm_node,
+                        cm_node->cm_id);
                 rem_ref_cm_node(cm_node->cm_core, cm_node);
                 cm_node = NULL;
         }
 
-        if (cm_node) {
+        if (cm_node)
                 nes_debug(NES_DBG_CM, "Api - connect(): dest addr=0x%08X,"
-                          "port=0x%04x, cm_node=%p, cm_id = %p.\n",
-                          cm_node->rem_addr, cm_node->rem_port, cm_node,
-                          cm_node->cm_id);
-        }
+                        "port=0x%04x, cm_node=%p, cm_id = %p.\n",
+                        cm_node->rem_addr, cm_node->rem_port, cm_node,
+                        cm_node->cm_id);
 
         return cm_node;
 }
@@ -2360,7 +2128,8 @@ static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core,
  * mini_cm_accept - accept a connection
  * This function is never called
  */
-static int mini_cm_accept(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node)
+static int mini_cm_accept(struct nes_cm_core *cm_core,
+        struct ietf_mpa_frame *mpa_frame, struct nes_cm_node *cm_node)
 {
         return 0;
 }
@@ -2369,7 +2138,8 @@ static int mini_cm_accept(struct nes_cm_core *cm_core, struct nes_cm_node *cm_no
 /**
  * mini_cm_reject - reject and teardown a connection
  */
-static int mini_cm_reject(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node)
+static int mini_cm_reject(struct nes_cm_core *cm_core,
+        struct ietf_mpa_frame *mpa_frame, struct nes_cm_node *cm_node)
 {
         int ret = 0;
         int err = 0;
@@ -2379,7 +2149,7 @@ static int mini_cm_reject(struct nes_cm_core *cm_core, struct nes_cm_node *cm_no
         struct nes_cm_node *loopback = cm_node->loopbackpartner;
 
         nes_debug(NES_DBG_CM, "%s cm_node=%p type=%d state=%d\n",
-                  __func__, cm_node, cm_node->tcp_cntxt.client, cm_node->state);
+                __func__, cm_node, cm_node->tcp_cntxt.client, cm_node->state);
 
         if (cm_node->tcp_cntxt.client)
                 return ret;
@@ -2400,9 +2170,8 @@ static int mini_cm_reject(struct nes_cm_core *cm_core, struct nes_cm_node *cm_no
                                         err = send_reset(cm_node, NULL);
                                         if (err)
                                                 WARN_ON(1);
-                                } else {
+                                } else
                                         cm_id->add_ref(cm_id);
-                                }
                         }
                 }
         } else {
@@ -2477,7 +2246,7 @@ static int mini_cm_close(struct nes_cm_core *cm_core, struct nes_cm_node *cm_nod
         case NES_CM_STATE_TSA:
                 if (cm_node->send_entry)
                         printk(KERN_ERR "ERROR Close got called from STATE_TSA "
-                               "send_entry=%p\n", cm_node->send_entry);
+                                "send_entry=%p\n", cm_node->send_entry);
                 ret = rem_ref_cm_node(cm_core, cm_node);
                 break;
         }
@@ -2490,7 +2259,7 @@ static int mini_cm_close(struct nes_cm_core *cm_core, struct nes_cm_node *cm_nod
  * node state machine
  */
 static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
-                            struct nes_vnic *nesvnic, struct sk_buff *skb)
+        struct nes_vnic *nesvnic, struct sk_buff *skb)
 {
         struct nes_cm_node *cm_node = NULL;
         struct nes_cm_listener *listener = NULL;
@@ -2502,8 +2271,9 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
 
         if (!skb)
                 return 0;
-        if (skb->len < sizeof(struct iphdr) + sizeof(struct tcphdr))
+        if (skb->len < sizeof(struct iphdr) + sizeof(struct tcphdr)) {
                 return 0;
+        }
 
         iph = (struct iphdr *)skb->data;
         tcph = (struct tcphdr *)(skb->data + sizeof(struct iphdr));
@@ -2521,8 +2291,8 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
 
         do {
                 cm_node = find_node(cm_core,
-                                    nfo.rem_port, nfo.rem_addr,
-                                    nfo.loc_port, nfo.loc_addr);
+                        nfo.rem_port, nfo.rem_addr,
+                        nfo.loc_port, nfo.loc_addr);
 
                 if (!cm_node) {
                         /* Only type of packet accepted are for */
@@ -2532,8 +2302,8 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
                                 break;
                         }
                         listener = find_listener(cm_core, nfo.loc_addr,
-                                                 nfo.loc_port,
-                                                 NES_CM_LISTENER_ACTIVE_STATE);
+                                nfo.loc_port,
+                                NES_CM_LISTENER_ACTIVE_STATE);
                         if (!listener) {
                                 nfo.cm_id = NULL;
                                 nfo.conn_type = 0;
@@ -2544,10 +2314,10 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
                         nfo.cm_id = listener->cm_id;
                         nfo.conn_type = listener->conn_type;
                         cm_node = make_cm_node(cm_core, nesvnic, &nfo,
-                                               listener);
+                                listener);
                         if (!cm_node) {
                                 nes_debug(NES_DBG_CM, "Unable to allocate "
-                                          "node\n");
+                                        "node\n");
                                 cm_packets_dropped++;
                                 atomic_dec(&listener->ref_count);
                                 dev_kfree_skb_any(skb);
@@ -2563,13 +2333,9 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
                         }
                         add_ref_cm_node(cm_node);
                 } else if (cm_node->state == NES_CM_STATE_TSA) {
-                        if (cm_node->nesqp->pau_mode)
-                                nes_queue_mgt_skbs(skb, nesvnic, cm_node->nesqp);
-                        else {
-                                rem_ref_cm_node(cm_core, cm_node);
-                                atomic_inc(&cm_accel_dropped_pkts);
-                                dev_kfree_skb_any(skb);
-                        }
+                        rem_ref_cm_node(cm_core, cm_node);
+                        atomic_inc(&cm_accel_dropped_pkts);
+                        dev_kfree_skb_any(skb);
                         break;
                 }
                 skb_reset_network_header(skb);
@@ -2599,7 +2365,7 @@ static struct nes_cm_core *nes_cm_alloc_core(void)
         init_timer(&cm_core->tcp_timer);
         cm_core->tcp_timer.function = nes_cm_timer_tick;
 
-        cm_core->mtu = NES_CM_DEFAULT_MTU;
+        cm_core->mtu   = NES_CM_DEFAULT_MTU;
         cm_core->state = NES_CM_STATE_INITED;
         cm_core->free_tx_pkt_max = NES_CM_DEFAULT_FREE_PKTS;
 
@@ -2637,8 +2403,9 @@ static int mini_cm_dealloc_core(struct nes_cm_core *cm_core)
 
         barrier();
 
-        if (timer_pending(&cm_core->tcp_timer))
+        if (timer_pending(&cm_core->tcp_timer)) {
                 del_timer(&cm_core->tcp_timer);
+        }
 
         destroy_workqueue(cm_core->event_wq);
         destroy_workqueue(cm_core->disconn_wq);
@@ -2693,8 +2460,8 @@ static int nes_cm_init_tsa_conn(struct nes_qp *nesqp, struct nes_cm_node *cm_nod
                 return -EINVAL;
 
         nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_IPV4 |
-                                                  NES_QPCONTEXT_MISC_NO_NAGLE | NES_QPCONTEXT_MISC_DO_NOT_FRAG |
-                                                  NES_QPCONTEXT_MISC_DROS);
+                        NES_QPCONTEXT_MISC_NO_NAGLE | NES_QPCONTEXT_MISC_DO_NOT_FRAG |
+                        NES_QPCONTEXT_MISC_DROS);
 
         if (cm_node->tcp_cntxt.snd_wscale || cm_node->tcp_cntxt.rcv_wscale)
                 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_WSCALE);
@@ -2704,15 +2471,15 @@ static int nes_cm_init_tsa_conn(struct nes_qp *nesqp, struct nes_cm_node *cm_nod
         nesqp->nesqp_context->mss |= cpu_to_le32(((u32)cm_node->tcp_cntxt.mss) << 16);
 
         nesqp->nesqp_context->tcp_state_flow_label |= cpu_to_le32(
-                (u32)NES_QPCONTEXT_TCPSTATE_EST << NES_QPCONTEXT_TCPFLOW_TCP_STATE_SHIFT);
+                        (u32)NES_QPCONTEXT_TCPSTATE_EST << NES_QPCONTEXT_TCPFLOW_TCP_STATE_SHIFT);
 
         nesqp->nesqp_context->pd_index_wscale |= cpu_to_le32(
-                (cm_node->tcp_cntxt.snd_wscale << NES_QPCONTEXT_PDWSCALE_SND_WSCALE_SHIFT) &
-                NES_QPCONTEXT_PDWSCALE_SND_WSCALE_MASK);
+                        (cm_node->tcp_cntxt.snd_wscale << NES_QPCONTEXT_PDWSCALE_SND_WSCALE_SHIFT) &
+                        NES_QPCONTEXT_PDWSCALE_SND_WSCALE_MASK);
 
         nesqp->nesqp_context->pd_index_wscale |= cpu_to_le32(
-                (cm_node->tcp_cntxt.rcv_wscale << NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_SHIFT) &
-                NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_MASK);
+                        (cm_node->tcp_cntxt.rcv_wscale << NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_SHIFT) &
+                        NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_MASK);
 
         nesqp->nesqp_context->keepalive = cpu_to_le32(0x80);
         nesqp->nesqp_context->ts_recent = 0;
@@ -2721,24 +2488,24 @@ static int nes_cm_init_tsa_conn(struct nes_qp *nesqp, struct nes_cm_node *cm_nod
         nesqp->nesqp_context->snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.snd_wnd);
         nesqp->nesqp_context->rcv_nxt = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
         nesqp->nesqp_context->rcv_wnd = cpu_to_le32(cm_node->tcp_cntxt.rcv_wnd <<
-                                                    cm_node->tcp_cntxt.rcv_wscale);
+                        cm_node->tcp_cntxt.rcv_wscale);
         nesqp->nesqp_context->snd_max = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
         nesqp->nesqp_context->snd_una = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
         nesqp->nesqp_context->srtt = 0;
         nesqp->nesqp_context->rttvar = cpu_to_le32(0x6);
         nesqp->nesqp_context->ssthresh = cpu_to_le32(0x3FFFC000);
-        nesqp->nesqp_context->cwnd = cpu_to_le32(2 * cm_node->tcp_cntxt.mss);
+        nesqp->nesqp_context->cwnd = cpu_to_le32(2*cm_node->tcp_cntxt.mss);
         nesqp->nesqp_context->snd_wl1 = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
         nesqp->nesqp_context->snd_wl2 = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
         nesqp->nesqp_context->max_snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.max_snd_wnd);
 
         nes_debug(NES_DBG_CM, "QP%u: rcv_nxt = 0x%08X, snd_nxt = 0x%08X,"
-                  " Setting MSS to %u, PDWscale = 0x%08X, rcv_wnd = %u, context misc = 0x%08X.\n",
-                  nesqp->hwqp.qp_id, le32_to_cpu(nesqp->nesqp_context->rcv_nxt),
-                  le32_to_cpu(nesqp->nesqp_context->snd_nxt),
-                  cm_node->tcp_cntxt.mss, le32_to_cpu(nesqp->nesqp_context->pd_index_wscale),
-                  le32_to_cpu(nesqp->nesqp_context->rcv_wnd),
-                  le32_to_cpu(nesqp->nesqp_context->misc));
+                        " Setting MSS to %u, PDWscale = 0x%08X, rcv_wnd = %u, context misc = 0x%08X.\n",
+                        nesqp->hwqp.qp_id, le32_to_cpu(nesqp->nesqp_context->rcv_nxt),
+                        le32_to_cpu(nesqp->nesqp_context->snd_nxt),
+                        cm_node->tcp_cntxt.mss, le32_to_cpu(nesqp->nesqp_context->pd_index_wscale),
+                        le32_to_cpu(nesqp->nesqp_context->rcv_wnd),
+                        le32_to_cpu(nesqp->nesqp_context->misc));
         nes_debug(NES_DBG_CM, "  snd_wnd  = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->snd_wnd));
         nes_debug(NES_DBG_CM, "  snd_cwnd = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->cwnd));
         nes_debug(NES_DBG_CM, "  max_swnd = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->max_snd_wnd));
@@ -2759,7 +2526,7 @@ int nes_cm_disconn(struct nes_qp *nesqp)
 
         work = kzalloc(sizeof *work, GFP_ATOMIC);
         if (!work)
-                return -ENOMEM;  /* Timer will clean up */
+                return -ENOMEM; /* Timer will clean up */
 
         nes_add_ref(&nesqp->ibqp);
         work->nesqp = nesqp;
@@ -2779,7 +2546,7 @@ static void nes_disconnect_worker(struct work_struct *work)
 
         kfree(dwork);
         nes_debug(NES_DBG_CM, "processing AEQE id 0x%04X for QP%u.\n",
-                  nesqp->last_aeq, nesqp->hwqp.qp_id);
+                        nesqp->last_aeq, nesqp->hwqp.qp_id);
         nes_cm_disconn_true(nesqp);
         nes_rem_ref(&nesqp->ibqp);
 }
@@ -2815,7 +2582,7 @@ static int nes_cm_disconn_true(struct nes_qp *nesqp)
         /* make sure we havent already closed this connection */
         if (!cm_id) {
                 nes_debug(NES_DBG_CM, "QP%u disconnect_worker cmid is NULL\n",
-                          nesqp->hwqp.qp_id);
+                                nesqp->hwqp.qp_id);
                 spin_unlock_irqrestore(&nesqp->lock, flags);
                 return -1;
         }
@@ -2824,14 +2591,13 @@ static int nes_cm_disconn_true(struct nes_qp *nesqp)
         nes_debug(NES_DBG_CM, "Disconnecting QP%u\n", nesqp->hwqp.qp_id);
 
         original_hw_tcp_state = nesqp->hw_tcp_state;
-        original_ibqp_state = nesqp->ibqp_state;
+        original_ibqp_state   = nesqp->ibqp_state;
         last_ae = nesqp->last_aeq;
 
         if (nesqp->term_flags) {
                 issue_disconn = 1;
                 issue_close = 1;
                 nesqp->cm_id = NULL;
-                del_timer(&nesqp->terminate_timer);
                 if (nesqp->flush_issued == 0) {
                         nesqp->flush_issued = 1;
                         issue_flush = 1;
@@ -2868,8 +2634,7 @@ static int nes_cm_disconn_true(struct nes_qp *nesqp)
                         ibevent.device = nesqp->ibqp.device;
                         ibevent.event = nesqp->terminate_eventtype;
                         ibevent.element.qp = &nesqp->ibqp;
-                        if (nesqp->ibqp.event_handler)
-                                nesqp->ibqp.event_handler(&ibevent, nesqp->ibqp.qp_context);
+                        nesqp->ibqp.event_handler(&ibevent, nesqp->ibqp.qp_context);
                 }
         }
 
@@ -2884,16 +2649,16 @@ static int nes_cm_disconn_true(struct nes_qp *nesqp)
                         cm_event.private_data_len = 0;
 
                         nes_debug(NES_DBG_CM, "Generating a CM Disconnect Event"
-                                  " for  QP%u, SQ Head = %u, SQ Tail = %u. "
-                                  "cm_id = %p, refcount = %u.\n",
-                                  nesqp->hwqp.qp_id, nesqp->hwqp.sq_head,
-                                  nesqp->hwqp.sq_tail, cm_id,
-                                  atomic_read(&nesqp->refcount));
+                                " for  QP%u, SQ Head = %u, SQ Tail = %u. "
+                                "cm_id = %p, refcount = %u.\n",
+                                nesqp->hwqp.qp_id, nesqp->hwqp.sq_head,
+                                nesqp->hwqp.sq_tail, cm_id,
+                                atomic_read(&nesqp->refcount));
 
                         ret = cm_id->event_handler(cm_id, &cm_event);
                         if (ret)
                                 nes_debug(NES_DBG_CM, "OFA CM event_handler "
-                                          "returned, ret=%d\n", ret);
+                                        "returned, ret=%d\n", ret);
                 }
 
                 if (issue_close) {
@@ -2911,8 +2676,9 @@ static int nes_cm_disconn_true(struct nes_qp *nesqp)
                         cm_event.private_data_len = 0;
 
                         ret = cm_id->event_handler(cm_id, &cm_event);
-                        if (ret)
+                        if (ret) {
                                 nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret);
+                        }
 
                         cm_id->rem_ref(cm_id);
                 }
@@ -2952,8 +2718,8 @@ static int nes_disconnect(struct nes_qp *nesqp, int abrupt)
                         if (nesqp->lsmm_mr)
                                 nesibdev->ibdev.dereg_mr(nesqp->lsmm_mr);
                         pci_free_consistent(nesdev->pcidev,
-                                            nesqp->private_data_len + nesqp->ietf_frame_size,
-                                            nesqp->ietf_frame, nesqp->ietf_frame_pbase);
+                                        nesqp->private_data_len+sizeof(struct ietf_mpa_frame),
+                                        nesqp->ietf_frame, nesqp->ietf_frame_pbase);
                 }
         }
 
@@ -2992,12 +2758,6 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         struct ib_phys_buf ibphysbuf;
         struct nes_pd *nespd;
         u64 tagged_offset;
-        u8 mpa_frame_offset = 0;
-        struct ietf_mpa_v2 *mpa_v2_frame;
-        u8 start_addr = 0;
-        u8 *start_ptr = &start_addr;
-        u8 **start_buff = &start_ptr;
-        u16 buff_len = 0;
 
         ibqp = nes_get_qp(cm_id->device, conn_param->qpn);
         if (!ibqp)
@@ -3038,49 +2798,53 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         nes_debug(NES_DBG_CM, "netdev refcnt = %u.\n",
                         netdev_refcnt_read(nesvnic->netdev));
 
-        nesqp->ietf_frame_size = sizeof(struct ietf_mpa_v2);
         /* allocate the ietf frame and space for private data */
         nesqp->ietf_frame = pci_alloc_consistent(nesdev->pcidev,
-                                                 nesqp->ietf_frame_size + conn_param->private_data_len,
-                                                 &nesqp->ietf_frame_pbase);
+                sizeof(struct ietf_mpa_frame) + conn_param->private_data_len,
+                &nesqp->ietf_frame_pbase);
 
         if (!nesqp->ietf_frame) {
-                nes_debug(NES_DBG_CM, "Unable to allocate memory for private data\n");
+                nes_debug(NES_DBG_CM, "Unable to allocate memory for private "
+                        "data\n");
                 return -ENOMEM;
         }
-        mpa_v2_frame = (struct ietf_mpa_v2 *)nesqp->ietf_frame;
-
-        if (cm_node->mpa_frame_rev == IETF_MPA_V1)
-                mpa_frame_offset = 4;
 
-        memcpy(mpa_v2_frame->priv_data, conn_param->private_data,
-               conn_param->private_data_len);
 
-        cm_build_mpa_frame(cm_node, start_buff, &buff_len, nesqp->ietf_frame, MPA_KEY_REPLY);
+        /* setup the MPA frame */
         nesqp->private_data_len = conn_param->private_data_len;
+        memcpy(nesqp->ietf_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE);
+
+        memcpy(nesqp->ietf_frame->priv_data, conn_param->private_data,
+                        conn_param->private_data_len);
+
+        nesqp->ietf_frame->priv_data_len =
+                cpu_to_be16(conn_param->private_data_len);
+        nesqp->ietf_frame->rev = mpa_version;
+        nesqp->ietf_frame->flags = IETF_MPA_FLAGS_CRC;
 
         /* setup our first outgoing iWarp send WQE (the IETF frame response) */
         wqe = &nesqp->hwqp.sq_vbase[0];
 
         if (cm_id->remote_addr.sin_addr.s_addr !=
-            cm_id->local_addr.sin_addr.s_addr) {
+                        cm_id->local_addr.sin_addr.s_addr) {
                 u64temp = (unsigned long)nesqp;
                 nesibdev = nesvnic->nesibdev;
                 nespd = nesqp->nespd;
-                ibphysbuf.addr = nesqp->ietf_frame_pbase + mpa_frame_offset;
-                ibphysbuf.size = buff_len;
-                tagged_offset = (u64)(unsigned long)*start_buff;
+                ibphysbuf.addr = nesqp->ietf_frame_pbase;
+                ibphysbuf.size = conn_param->private_data_len +
+                                        sizeof(struct ietf_mpa_frame);
+                tagged_offset = (u64)(unsigned long)nesqp->ietf_frame;
                 ibmr = nesibdev->ibdev.reg_phys_mr((struct ib_pd *)nespd,
-                                                   &ibphysbuf, 1,
-                                                   IB_ACCESS_LOCAL_WRITE,
-                                                   &tagged_offset);
+                                                &ibphysbuf, 1,
+                                                IB_ACCESS_LOCAL_WRITE,
+                                                &tagged_offset);
                 if (!ibmr) {
                         nes_debug(NES_DBG_CM, "Unable to register memory region"
-                                  "for lSMM for cm_node = %p \n",
-                                  cm_node);
+                                        "for lSMM for cm_node = %p \n",
+                                        cm_node);
                         pci_free_consistent(nesdev->pcidev,
-                                            nesqp->private_data_len + nesqp->ietf_frame_size,
-                                            nesqp->ietf_frame, nesqp->ietf_frame_pbase);
+                                nesqp->private_data_len+sizeof(struct ietf_mpa_frame),
+                                nesqp->ietf_frame, nesqp->ietf_frame_pbase);
                         return -ENOMEM;
                 }
 
@@ -3088,20 +2852,22 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 ibmr->device = nespd->ibpd.device;
                 nesqp->lsmm_mr = ibmr;
 
-                u64temp |= NES_SW_CONTEXT_ALIGN >> 1;
+                u64temp |= NES_SW_CONTEXT_ALIGN>>1;
                 set_wqe_64bit_value(wqe->wqe_words,
-                                    NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX,
-                                    u64temp);
+                        NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX,
+                        u64temp);
                 wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] =
                         cpu_to_le32(NES_IWARP_SQ_WQE_STREAMING |
-                                    NES_IWARP_SQ_WQE_WRPDU);
+                        NES_IWARP_SQ_WQE_WRPDU);
                 wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] =
-                        cpu_to_le32(buff_len);
+                        cpu_to_le32(conn_param->private_data_len +
+                        sizeof(struct ietf_mpa_frame));
                 set_wqe_64bit_value(wqe->wqe_words,
-                                    NES_IWARP_SQ_WQE_FRAG0_LOW_IDX,
-                                    (u64)(unsigned long)(*start_buff));
+                                        NES_IWARP_SQ_WQE_FRAG0_LOW_IDX,
+                                        (u64)(unsigned long)nesqp->ietf_frame);
                 wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] =
-                        cpu_to_le32(buff_len);
+                        cpu_to_le32(conn_param->private_data_len +
+                        sizeof(struct ietf_mpa_frame));
                 wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = ibmr->lkey;
                 if (nesqp->sq_kmapped) {
                         nesqp->sq_kmapped = 0;
@@ -3110,7 +2876,7 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 
                 nesqp->nesqp_context->ird_ord_sizes |=
                         cpu_to_le32(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT |
-                                    NES_QPCONTEXT_ORDIRD_WRPDU);
+                        NES_QPCONTEXT_ORDIRD_WRPDU);
         } else {
                 nesqp->nesqp_context->ird_ord_sizes |=
                         cpu_to_le32(NES_QPCONTEXT_ORDIRD_WRPDU);
@@ -3124,11 +2890,11 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 
         /*  nesqp->cm_node = (void *)cm_id->provider_data; */
         cm_id->provider_data = nesqp;
-        nesqp->active_conn = 0;
+        nesqp->active_conn   = 0;
 
         if (cm_node->state == NES_CM_STATE_TSA)
                 nes_debug(NES_DBG_CM, "Already state = TSA for cm_node=%p\n",
-                          cm_node);
+                        cm_node);
 
         nes_cm_init_tsa_conn(nesqp, cm_node);
 
@@ -3137,17 +2903,21 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         nesqp->nesqp_context->tcpPorts[1] =
                 cpu_to_le16(ntohs(cm_id->remote_addr.sin_port));
 
-        nesqp->nesqp_context->ip0 =
+        if (ipv4_is_loopback(cm_id->remote_addr.sin_addr.s_addr))
+                nesqp->nesqp_context->ip0 =
+                        cpu_to_le32(ntohl(nesvnic->local_ipaddr));
+        else
+                nesqp->nesqp_context->ip0 =
                         cpu_to_le32(ntohl(cm_id->remote_addr.sin_addr.s_addr));
 
         nesqp->nesqp_context->misc2 |= cpu_to_le32(
-                (u32)PCI_FUNC(nesdev->pcidev->devfn) <<
-                NES_QPCONTEXT_MISC2_SRC_IP_SHIFT);
+                        (u32)PCI_FUNC(nesdev->pcidev->devfn) <<
+                        NES_QPCONTEXT_MISC2_SRC_IP_SHIFT);
 
         nesqp->nesqp_context->arp_index_vlan |=
                 cpu_to_le32(nes_arp_table(nesdev,
-                                          le32_to_cpu(nesqp->nesqp_context->ip0), NULL,
-                                          NES_ARP_RESOLVE) << 16);
+                        le32_to_cpu(nesqp->nesqp_context->ip0), NULL,
+                        NES_ARP_RESOLVE) << 16);
 
         nesqp->nesqp_context->ts_val_delta = cpu_to_le32(
                 jiffies - nes_read_indexed(nesdev, NES_IDX_TCP_NOW));
@@ -3162,7 +2932,10 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         memset(&nes_quad, 0, sizeof(nes_quad));
         nes_quad.DstIpAdrIndex =
                 cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24);
-        nes_quad.SrcIpadr = cm_id->remote_addr.sin_addr.s_addr;
+        if (ipv4_is_loopback(cm_id->remote_addr.sin_addr.s_addr))
+                nes_quad.SrcIpadr = nesvnic->local_ipaddr;
+        else
+                nes_quad.SrcIpadr = cm_id->remote_addr.sin_addr.s_addr;
         nes_quad.TcpPorts[0] = cm_id->remote_addr.sin_port;
         nes_quad.TcpPorts[1] = cm_id->local_addr.sin_port;
 
@@ -3170,7 +2943,7 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         crc_value = get_crc_value(&nes_quad);
         nesqp->hte_index = cpu_to_be32(crc_value ^ 0xffffffff);
         nes_debug(NES_DBG_CM, "HTE Index = 0x%08X, CRC = 0x%08X\n",
-                  nesqp->hte_index, nesqp->hte_index & adapter->hte_index_mask);
+                nesqp->hte_index, nesqp->hte_index & adapter->hte_index_mask);
 
         nesqp->hte_index &= adapter->hte_index_mask;
         nesqp->nesqp_context->hte_index = cpu_to_le32(nesqp->hte_index);
@@ -3178,15 +2951,17 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         cm_node->cm_core->api->accelerated(cm_node->cm_core, cm_node);
 
         nes_debug(NES_DBG_CM, "QP%u, Destination IP = 0x%08X:0x%04X, local = "
-                  "0x%08X:0x%04X, rcv_nxt=0x%08X, snd_nxt=0x%08X, mpa + "
-                  "private data length=%u.\n", nesqp->hwqp.qp_id,
-                  ntohl(cm_id->remote_addr.sin_addr.s_addr),
-                  ntohs(cm_id->remote_addr.sin_port),
-                  ntohl(cm_id->local_addr.sin_addr.s_addr),
-                  ntohs(cm_id->local_addr.sin_port),
-                  le32_to_cpu(nesqp->nesqp_context->rcv_nxt),
-                  le32_to_cpu(nesqp->nesqp_context->snd_nxt),
-                  buff_len);
+                        "0x%08X:0x%04X, rcv_nxt=0x%08X, snd_nxt=0x%08X, mpa + "
+                        "private data length=%zu.\n", nesqp->hwqp.qp_id,
+                        ntohl(cm_id->remote_addr.sin_addr.s_addr),
+                        ntohs(cm_id->remote_addr.sin_port),
+                        ntohl(cm_id->local_addr.sin_addr.s_addr),
+                        ntohs(cm_id->local_addr.sin_port),
+                        le32_to_cpu(nesqp->nesqp_context->rcv_nxt),
+                        le32_to_cpu(nesqp->nesqp_context->snd_nxt),
+                        conn_param->private_data_len +
+                        sizeof(struct ietf_mpa_frame));
+
 
         /* notify OF layer that accept event was successful */
         cm_id->add_ref(cm_id);
@@ -3207,12 +2982,12 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                         nesqp->private_data_len;
                 /* copy entire MPA frame to our cm_node's frame */
                 memcpy(cm_node->loopbackpartner->mpa_frame_buf,
-                       conn_param->private_data, conn_param->private_data_len);
+                        nesqp->ietf_frame->priv_data, nesqp->private_data_len);
                 create_event(cm_node->loopbackpartner, NES_CM_EVENT_CONNECTED);
         }
         if (ret)
                 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, "
-                       "ret=%d\n", __func__, __LINE__, ret);
+                        "ret=%d\n", __func__, __LINE__, ret);
 
         return 0;
 }
@@ -3225,28 +3000,34 @@ int nes_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
 {
         struct nes_cm_node *cm_node;
         struct nes_cm_node *loopback;
+
         struct nes_cm_core *cm_core;
-        u8 *start_buff;
 
         atomic_inc(&cm_rejects);
-        cm_node = (struct nes_cm_node *)cm_id->provider_data;
+        cm_node = (struct nes_cm_node *) cm_id->provider_data;
         loopback = cm_node->loopbackpartner;
         cm_core = cm_node->cm_core;
         cm_node->cm_id = cm_id;
+        cm_node->mpa_frame_size = sizeof(struct ietf_mpa_frame) + pdata_len;
 
-        if (pdata_len + sizeof(struct ietf_mpa_v2) > MAX_CM_BUFFER)
+        if (cm_node->mpa_frame_size > MAX_CM_BUFFER)
                 return -EINVAL;
 
+        memcpy(&cm_node->mpa_frame.key[0], IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE);
         if (loopback) {
                 memcpy(&loopback->mpa_frame.priv_data, pdata, pdata_len);
                 loopback->mpa_frame.priv_data_len = pdata_len;
-                loopback->mpa_frame_size = pdata_len;
+                loopback->mpa_frame_size = sizeof(struct ietf_mpa_frame) +
+                                pdata_len;
         } else {
-                start_buff = &cm_node->mpa_frame_buf[0] + sizeof(struct ietf_mpa_v2);
-                cm_node->mpa_frame_size = pdata_len;
-                memcpy(start_buff, pdata, pdata_len);
+                memcpy(&cm_node->mpa_frame.priv_data, pdata, pdata_len);
+                cm_node->mpa_frame.priv_data_len = cpu_to_be16(pdata_len);
         }
-        return cm_core->api->reject(cm_core, cm_node);
+
+        cm_node->mpa_frame.rev = mpa_version;
+        cm_node->mpa_frame.flags = IETF_MPA_FLAGS_CRC | IETF_MPA_FLAGS_REJECT;
+
+        return cm_core->api->reject(cm_core, &cm_node->mpa_frame, cm_node);
 }
 
 
@@ -3273,7 +3054,7 @@ int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
         nesvnic = to_nesvnic(nesqp->ibqp.device);
         if (!nesvnic)
                 return -EINVAL;
-        nesdev = nesvnic->nesdev;
+        nesdev  = nesvnic->nesdev;
         if (!nesdev)
                 return -EINVAL;
 
@@ -3281,12 +3062,12 @@ int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 return -EINVAL;
 
         nes_debug(NES_DBG_CM, "QP%u, current IP = 0x%08X, Destination IP = "
-                  "0x%08X:0x%04X, local = 0x%08X:0x%04X.\n", nesqp->hwqp.qp_id,
-                  ntohl(nesvnic->local_ipaddr),
-                  ntohl(cm_id->remote_addr.sin_addr.s_addr),
-                  ntohs(cm_id->remote_addr.sin_port),
-                  ntohl(cm_id->local_addr.sin_addr.s_addr),
-                  ntohs(cm_id->local_addr.sin_port));
+                "0x%08X:0x%04X, local = 0x%08X:0x%04X.\n", nesqp->hwqp.qp_id,
+                ntohl(nesvnic->local_ipaddr),
+                ntohl(cm_id->remote_addr.sin_addr.s_addr),
+                ntohs(cm_id->remote_addr.sin_port),
+                ntohl(cm_id->local_addr.sin_addr.s_addr),
+                ntohs(cm_id->local_addr.sin_port));
 
         atomic_inc(&cm_connects);
         nesqp->active_conn = 1;
@@ -3298,18 +3079,14 @@ int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 
         nesqp->private_data_len = conn_param->private_data_len;
         nesqp->nesqp_context->ird_ord_sizes |= cpu_to_le32((u32)conn_param->ord);
-        /* space for rdma0 read msg */
-        if (conn_param->ord == 0)
-                nesqp->nesqp_context->ird_ord_sizes |= cpu_to_le32(1);
-
         nes_debug(NES_DBG_CM, "requested ord = 0x%08X.\n", (u32)conn_param->ord);
         nes_debug(NES_DBG_CM, "mpa private data len =%u\n",
-                  conn_param->private_data_len);
+                conn_param->private_data_len);
 
         if (cm_id->local_addr.sin_addr.s_addr !=
-            cm_id->remote_addr.sin_addr.s_addr) {
+                cm_id->remote_addr.sin_addr.s_addr) {
                 nes_manage_apbvt(nesvnic, ntohs(cm_id->local_addr.sin_port),
-                                 PCI_FUNC(nesdev->pcidev->devfn), NES_MANAGE_APBVT_ADD);
+                        PCI_FUNC(nesdev->pcidev->devfn), NES_MANAGE_APBVT_ADD);
                 apbvt_set = 1;
         }
 
@@ -3325,13 +3102,13 @@ int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
 
         /* create a connect CM node connection */
         cm_node = g_cm_core->api->connect(g_cm_core, nesvnic,
-                                          conn_param->private_data_len, (void *)conn_param->private_data,
-                                          &cm_info);
+                conn_param->private_data_len, (void *)conn_param->private_data,
+                &cm_info);
         if (!cm_node) {
                 if (apbvt_set)
                         nes_manage_apbvt(nesvnic, ntohs(cm_id->local_addr.sin_port),
-                                         PCI_FUNC(nesdev->pcidev->devfn),
-                                         NES_MANAGE_APBVT_DEL);
+                                PCI_FUNC(nesdev->pcidev->devfn),
+                                NES_MANAGE_APBVT_DEL);
 
                 cm_id->rem_ref(cm_id);
                 return -ENOMEM;
@@ -3381,7 +3158,7 @@ int nes_create_listen(struct iw_cm_id *cm_id, int backlog)
         cm_node = g_cm_core->api->listen(g_cm_core, nesvnic, &cm_info);
         if (!cm_node) {
                 printk(KERN_ERR "%s[%u] Error returned from listen API call\n",
-                       __func__, __LINE__);
+                                __func__, __LINE__);
                 return -ENOMEM;
         }
 
@@ -3389,12 +3166,12 @@ int nes_create_listen(struct iw_cm_id *cm_id, int backlog)
 
         if (!cm_node->reused_node) {
                 err = nes_manage_apbvt(nesvnic,
-                                       ntohs(cm_id->local_addr.sin_port),
-                                       PCI_FUNC(nesvnic->nesdev->pcidev->devfn),
-                                       NES_MANAGE_APBVT_ADD);
+                        ntohs(cm_id->local_addr.sin_port),
+                        PCI_FUNC(nesvnic->nesdev->pcidev->devfn),
+                        NES_MANAGE_APBVT_ADD);
                 if (err) {
                         printk(KERN_ERR "nes_manage_apbvt call returned %d.\n",
-                               err);
+                                err);
                         g_cm_core->api->stop_listener(g_cm_core, (void *)cm_node);
                         return err;
                 }
@@ -3431,13 +3208,13 @@ int nes_destroy_listen(struct iw_cm_id *cm_id)
 int nes_cm_recv(struct sk_buff *skb, struct net_device *netdevice)
 {
         int rc = 0;
-
         cm_packets_received++;
-        if ((g_cm_core) && (g_cm_core->api))
+        if ((g_cm_core) && (g_cm_core->api)) {
                 rc = g_cm_core->api->recv_pkt(g_cm_core, netdev_priv(netdevice), skb);
-        else
+        } else {
                 nes_debug(NES_DBG_CM, "Unable to process packet for CM,"
-                          " cm is not setup properly.\n");
+                                " cm is not setup properly.\n");
+        }
 
         return rc;
 }
@@ -3452,10 +3229,11 @@ int nes_cm_start(void)
         nes_debug(NES_DBG_CM, "\n");
         /* create the primary CM core, pass this handle to subsequent core inits */
         g_cm_core = nes_cm_alloc_core();
-        if (g_cm_core)
+        if (g_cm_core) {
                 return 0;
-        else
+        } else {
                 return -ENOMEM;
+        }
 }
 
 
@@ -3476,6 +3254,7 @@ int nes_cm_stop(void)
  */
 static void cm_event_connected(struct nes_cm_event *event)
 {
+        u64 u64temp;
         struct nes_qp *nesqp;
         struct nes_vnic *nesvnic;
         struct nes_device *nesdev;
@@ -3484,6 +3263,7 @@ static void cm_event_connected(struct nes_cm_event *event)
         struct ib_qp_attr attr;
         struct iw_cm_id *cm_id;
         struct iw_cm_event cm_event;
+        struct nes_hw_qp_wqe *wqe;
         struct nes_v4_quad nes_quad;
         u32 crc_value;
         int ret;
@@ -3497,16 +3277,17 @@ static void cm_event_connected(struct nes_cm_event *event)
         nesdev = nesvnic->nesdev;
         nesadapter = nesdev->nesadapter;
 
-        if (nesqp->destroyed)
+        if (nesqp->destroyed) {
                 return;
+        }
         atomic_inc(&cm_connecteds);
         nes_debug(NES_DBG_CM, "QP%u attempting to connect to  0x%08X:0x%04X on"
-                  " local port 0x%04X. jiffies = %lu.\n",
-                  nesqp->hwqp.qp_id,
-                  ntohl(cm_id->remote_addr.sin_addr.s_addr),
-                  ntohs(cm_id->remote_addr.sin_port),
-                  ntohs(cm_id->local_addr.sin_port),
-                  jiffies);
+                        " local port 0x%04X. jiffies = %lu.\n",
+                        nesqp->hwqp.qp_id,
+                        ntohl(cm_id->remote_addr.sin_addr.s_addr),
+                        ntohs(cm_id->remote_addr.sin_port),
+                        ntohs(cm_id->local_addr.sin_port),
+                        jiffies);
 
         nes_cm_init_tsa_conn(nesqp, cm_node);
 
@@ -3515,7 +3296,11 @@ static void cm_event_connected(struct nes_cm_event *event)
                 cpu_to_le16(ntohs(cm_id->local_addr.sin_port));
         nesqp->nesqp_context->tcpPorts[1] =
                 cpu_to_le16(ntohs(cm_id->remote_addr.sin_port));
-        nesqp->nesqp_context->ip0 =
+        if (ipv4_is_loopback(cm_id->remote_addr.sin_addr.s_addr))
+                nesqp->nesqp_context->ip0 =
+                        cpu_to_le32(ntohl(nesvnic->local_ipaddr));
+        else
+                nesqp->nesqp_context->ip0 =
                         cpu_to_le32(ntohl(cm_id->remote_addr.sin_addr.s_addr));
 
         nesqp->nesqp_context->misc2 |= cpu_to_le32(
@@ -3533,18 +3318,49 @@ static void cm_event_connected(struct nes_cm_event *event)
                         NES_QPCONTEXT_ORDIRD_IWARP_MODE_SHIFT);
 
         /* Adjust tail for not having a LSMM */
-        /*nesqp->hwqp.sq_tail = 1;*/
+        nesqp->hwqp.sq_tail = 1;
+
+#if defined(NES_SEND_FIRST_WRITE)
+        if (cm_node->send_write0) {
+                nes_debug(NES_DBG_CM, "Sending first write.\n");
+                wqe = &nesqp->hwqp.sq_vbase[0];
+                u64temp = (unsigned long)nesqp;
+                u64temp |= NES_SW_CONTEXT_ALIGN>>1;
+                set_wqe_64bit_value(wqe->wqe_words,
+                                NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX, u64temp);
+                wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] =
+                        cpu_to_le32(NES_IWARP_SQ_OP_RDMAW);
+                wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] = 0;
+                wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_LOW_IDX] = 0;
+                wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_HIGH_IDX] = 0;
+                wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] = 0;
+                wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 0;
 
-        build_rdma0_msg(cm_node, &nesqp);
+                if (nesqp->sq_kmapped) {
+                        nesqp->sq_kmapped = 0;
+                        kunmap(nesqp->page);
+                }
 
-        nes_write32(nesdev->regs + NES_WQE_ALLOC,
-                    (1 << 24) | 0x00800000 | nesqp->hwqp.qp_id);
+                /* use the reserved spot on the WQ for the extra first WQE */
+                nesqp->nesqp_context->ird_ord_sizes &=
+                        cpu_to_le32(~(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT |
+                                                NES_QPCONTEXT_ORDIRD_WRPDU |
+                                                NES_QPCONTEXT_ORDIRD_ALSMM));
+                nesqp->skip_lsmm = 1;
+                nesqp->hwqp.sq_tail = 0;
+                nes_write32(nesdev->regs + NES_WQE_ALLOC,
+                                (1 << 24) | 0x00800000 | nesqp->hwqp.qp_id);
+        }
+#endif
 
         memset(&nes_quad, 0, sizeof(nes_quad));
 
         nes_quad.DstIpAdrIndex =
                 cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24);
-        nes_quad.SrcIpadr = cm_id->remote_addr.sin_addr.s_addr;
+        if (ipv4_is_loopback(cm_id->remote_addr.sin_addr.s_addr))
+                nes_quad.SrcIpadr = nesvnic->local_ipaddr;
+        else
+                nes_quad.SrcIpadr = cm_id->remote_addr.sin_addr.s_addr;
         nes_quad.TcpPorts[0] = cm_id->remote_addr.sin_port;
         nes_quad.TcpPorts[1] = cm_id->local_addr.sin_port;
 
@@ -3552,13 +3368,13 @@ static void cm_event_connected(struct nes_cm_event *event)
         crc_value = get_crc_value(&nes_quad);
         nesqp->hte_index = cpu_to_be32(crc_value ^ 0xffffffff);
         nes_debug(NES_DBG_CM, "HTE Index = 0x%08X, After CRC = 0x%08X\n",
-                  nesqp->hte_index, nesqp->hte_index & nesadapter->hte_index_mask);
+                        nesqp->hte_index, nesqp->hte_index & nesadapter->hte_index_mask);
 
         nesqp->hte_index &= nesadapter->hte_index_mask;
         nesqp->nesqp_context->hte_index = cpu_to_le32(nesqp->hte_index);
 
         nesqp->ietf_frame = &cm_node->mpa_frame;
-        nesqp->private_data_len = (u8)cm_node->mpa_frame_size;
+        nesqp->private_data_len = (u8) cm_node->mpa_frame_size;
         cm_node->cm_core->api->accelerated(cm_node->cm_core, cm_node);
 
         /* notify OF layer we successfully created the requested connection */
@@ -3570,9 +3386,7 @@ static void cm_event_connected(struct nes_cm_event *event)
         cm_event.remote_addr = cm_id->remote_addr;
 
         cm_event.private_data = (void *)event->cm_node->mpa_frame_buf;
-        cm_event.private_data_len = (u8)event->cm_node->mpa_frame_size;
-        cm_event.ird = cm_node->ird_size;
-        cm_event.ord = cm_node->ord_size;
+        cm_event.private_data_len = (u8) event->cm_node->mpa_frame_size;
 
         cm_event.local_addr.sin_addr.s_addr = event->cm_info.rem_addr;
         ret = cm_id->event_handler(cm_id, &cm_event);
@@ -3580,12 +3394,12 @@ static void cm_event_connected(struct nes_cm_event *event)
 
         if (ret)
                 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, "
-                       "ret=%d\n", __func__, __LINE__, ret);
+                        "ret=%d\n", __func__, __LINE__, ret);
         attr.qp_state = IB_QPS_RTS;
         nes_modify_qp(&nesqp->ibqp, &attr, IB_QP_STATE, NULL);
 
         nes_debug(NES_DBG_CM, "Exiting connect thread for QP%u. jiffies = "
-                  "%lu\n", nesqp->hwqp.qp_id, jiffies);
+                "%lu\n", nesqp->hwqp.qp_id, jiffies);
 
         return;
 }
@@ -3606,14 +3420,16 @@ static void cm_event_connect_error(struct nes_cm_event *event)
                 return;
 
         cm_id = event->cm_node->cm_id;
-        if (!cm_id)
+        if (!cm_id) {
                 return;
+        }
 
         nes_debug(NES_DBG_CM, "cm_node=%p, cm_id=%p\n", event->cm_node, cm_id);
         nesqp = cm_id->provider_data;
 
-        if (!nesqp)
+        if (!nesqp) {
                 return;
+        }
 
         /* notify OF layer about this connection error event */
         /* cm_id->rem_ref(cm_id); */
@@ -3628,14 +3444,14 @@ static void cm_event_connect_error(struct nes_cm_event *event)
         cm_event.private_data_len = 0;
 
         nes_debug(NES_DBG_CM, "call CM_EVENT REJECTED, local_addr=%08x, "
-                  "remove_addr=%08x\n", cm_event.local_addr.sin_addr.s_addr,
-                  cm_event.remote_addr.sin_addr.s_addr);
+                "remove_addr=%08x\n", cm_event.local_addr.sin_addr.s_addr,
+                cm_event.remote_addr.sin_addr.s_addr);
 
         ret = cm_id->event_handler(cm_id, &cm_event);
         nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret);
         if (ret)
                 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, "
-                       "ret=%d\n", __func__, __LINE__, ret);
+                        "ret=%d\n", __func__, __LINE__, ret);
         cm_id->rem_ref(cm_id);
 
         rem_ref_cm_node(event->cm_node->cm_core, event->cm_node);
@@ -3705,7 +3521,7 @@ static void cm_event_reset(struct nes_cm_event *event)
  */
 static void cm_event_mpa_req(struct nes_cm_event *event)
 {
-        struct iw_cm_id *cm_id;
+        struct iw_cm_id   *cm_id;
         struct iw_cm_event cm_event;
         int ret;
         struct nes_cm_node *cm_node;
@@ -3717,7 +3533,7 @@ static void cm_event_mpa_req(struct nes_cm_event *event)
 
         atomic_inc(&cm_connect_reqs);
         nes_debug(NES_DBG_CM, "cm_node = %p - cm_id = %p, jiffies = %lu\n",
-                  cm_node, cm_id, jiffies);
+                        cm_node, cm_id, jiffies);
 
         cm_event.event = IW_CM_EVENT_CONNECT_REQUEST;
         cm_event.status = 0;
@@ -3731,21 +3547,19 @@ static void cm_event_mpa_req(struct nes_cm_event *event)
         cm_event.remote_addr.sin_port = htons(event->cm_info.rem_port);
         cm_event.remote_addr.sin_addr.s_addr = htonl(event->cm_info.rem_addr);
         cm_event.private_data = cm_node->mpa_frame_buf;
-        cm_event.private_data_len = (u8)cm_node->mpa_frame_size;
-        cm_event.ird = cm_node->ird_size;
-        cm_event.ord = cm_node->ord_size;
+        cm_event.private_data_len  = (u8) cm_node->mpa_frame_size;
 
         ret = cm_id->event_handler(cm_id, &cm_event);
         if (ret)
                 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, ret=%d\n",
-                       __func__, __LINE__, ret);
+                                __func__, __LINE__, ret);
         return;
 }
 
 
 static void cm_event_mpa_reject(struct nes_cm_event *event)
 {
-        struct iw_cm_id *cm_id;
+        struct iw_cm_id   *cm_id;
         struct iw_cm_event cm_event;
         struct nes_cm_node *cm_node;
         int ret;
@@ -3757,7 +3571,7 @@ static void cm_event_mpa_reject(struct nes_cm_event *event)
 
         atomic_inc(&cm_connect_reqs);
         nes_debug(NES_DBG_CM, "cm_node = %p - cm_id = %p, jiffies = %lu\n",
-                  cm_node, cm_id, jiffies);
+                        cm_node, cm_id, jiffies);
 
         cm_event.event = IW_CM_EVENT_CONNECT_REPLY;
         cm_event.status = -ECONNREFUSED;
@@ -3772,17 +3586,17 @@ static void cm_event_mpa_reject(struct nes_cm_event *event)
         cm_event.remote_addr.sin_addr.s_addr = htonl(event->cm_info.rem_addr);
 
         cm_event.private_data = cm_node->mpa_frame_buf;
-        cm_event.private_data_len = (u8)cm_node->mpa_frame_size;
+        cm_event.private_data_len = (u8) cm_node->mpa_frame_size;
 
         nes_debug(NES_DBG_CM, "call CM_EVENT_MPA_REJECTED, local_addr=%08x, "
-                  "remove_addr=%08x\n",
-                  cm_event.local_addr.sin_addr.s_addr,
-                  cm_event.remote_addr.sin_addr.s_addr);
+                        "remove_addr=%08x\n",
+                        cm_event.local_addr.sin_addr.s_addr,
+                        cm_event.remote_addr.sin_addr.s_addr);
 
         ret = cm_id->event_handler(cm_id, &cm_event);
         if (ret)
                 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, ret=%d\n",
-                       __func__, __LINE__, ret);
+                                __func__, __LINE__, ret);
 
         return;
 }
@@ -3801,7 +3615,7 @@ static int nes_cm_post_event(struct nes_cm_event *event)
         event->cm_info.cm_id->add_ref(event->cm_info.cm_id);
         INIT_WORK(&event->event_work, nes_cm_event_handler);
         nes_debug(NES_DBG_CM, "cm_node=%p queue_work, event=%p\n",
-                  event->cm_node, event);
+                event->cm_node, event);
 
         queue_work(event->cm_node->cm_core->event_wq, &event->event_work);
 
@@ -3818,7 +3632,7 @@ static int nes_cm_post_event(struct nes_cm_event *event)
 static void nes_cm_event_handler(struct work_struct *work)
 {
         struct nes_cm_event *event = container_of(work, struct nes_cm_event,
-                                                  event_work);
+                        event_work);
         struct nes_cm_core *cm_core;
 
         if ((!event) || (!event->cm_node) || (!event->cm_node->cm_core))
@@ -3826,29 +3640,29 @@ static void nes_cm_event_handler(struct work_struct *work)
 
         cm_core = event->cm_node->cm_core;
         nes_debug(NES_DBG_CM, "event=%p, event->type=%u, events posted=%u\n",
-                  event, event->type, atomic_read(&cm_core->events_posted));
+                event, event->type, atomic_read(&cm_core->events_posted));
 
         switch (event->type) {
         case NES_CM_EVENT_MPA_REQ:
                 cm_event_mpa_req(event);
                 nes_debug(NES_DBG_CM, "cm_node=%p CM Event: MPA REQUEST\n",
-                          event->cm_node);
+                        event->cm_node);
                 break;
         case NES_CM_EVENT_RESET:
                 nes_debug(NES_DBG_CM, "cm_node = %p CM Event: RESET\n",
-                          event->cm_node);
+                        event->cm_node);
                 cm_event_reset(event);
                 break;
         case NES_CM_EVENT_CONNECTED:
                 if ((!event->cm_node->cm_id) ||
-                    (event->cm_node->state != NES_CM_STATE_TSA))
+                        (event->cm_node->state != NES_CM_STATE_TSA))
                         break;
                 cm_event_connected(event);
                 nes_debug(NES_DBG_CM, "CM Event: CONNECTED\n");
                 break;
         case NES_CM_EVENT_MPA_REJECT:
                 if ((!event->cm_node->cm_id) ||
-                    (event->cm_node->state == NES_CM_STATE_TSA))
+                                (event->cm_node->state == NES_CM_STATE_TSA))
                         break;
                 cm_event_mpa_reject(event);
                 nes_debug(NES_DBG_CM, "CM Event: REJECT\n");
@@ -3856,7 +3670,7 @@ static void nes_cm_event_handler(struct work_struct *work)
 
         case NES_CM_EVENT_ABORTED:
                 if ((!event->cm_node->cm_id) ||
-                    (event->cm_node->state == NES_CM_STATE_TSA))
+                        (event->cm_node->state == NES_CM_STATE_TSA))
                         break;
                 cm_event_connect_error(event);
                 nes_debug(NES_DBG_CM, "CM Event: ABORTED\n");
diff --git a/drivers/infiniband/hw/nes/nes_cm.h b/drivers/infiniband/hw/nes/nes_cm.h
index 4646e666608..d9825fda70a 100644
--- a/drivers/infiniband/hw/nes/nes_cm.h
+++ b/drivers/infiniband/hw/nes/nes_cm.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -48,16 +48,7 @@
 #define IETF_MPA_KEY_SIZE 16
 #define IETF_MPA_VERSION  1
 #define IETF_MAX_PRIV_DATA_LEN 512
-#define IETF_MPA_FRAME_SIZE    20
-#define IETF_RTR_MSG_SIZE      4
-#define IETF_MPA_V2_FLAG       0x10
-
-/* IETF RTR MSG Fields               */
-#define IETF_PEER_TO_PEER       0x8000
-#define IETF_FLPDU_ZERO_LEN     0x4000
-#define IETF_RDMA0_WRITE        0x8000
-#define IETF_RDMA0_READ         0x4000
-#define IETF_NO_IRD_ORD         0x3FFF
+#define IETF_MPA_FRAME_SIZE     20
 
 enum ietf_mpa_flags {
         IETF_MPA_FLAGS_MARKERS = 0x80,  /* receive Markers */
@@ -65,7 +56,7 @@ enum ietf_mpa_flags {
         IETF_MPA_FLAGS_REJECT  = 0x20,  /* Reject */
 };
 
-struct ietf_mpa_v1 {
+struct ietf_mpa_frame {
         u8 key[IETF_MPA_KEY_SIZE];
         u8 flags;
         u8 rev;
@@ -75,20 +66,6 @@ struct ietf_mpa_v1 {
 
 #define ietf_mpa_req_resp_frame ietf_mpa_frame
 
-struct ietf_rtr_msg {
-        __be16 ctrl_ird;
-        __be16 ctrl_ord;
-};
-
-struct ietf_mpa_v2 {
-        u8 key[IETF_MPA_KEY_SIZE];
-        u8 flags;
-        u8 rev;
-         __be16 priv_data_len;
-        struct ietf_rtr_msg rtr_msg;
-        u8 priv_data[0];
-};
-
 struct nes_v4_quad {
         u32 rsvd0;
         __le32 DstIpAdrIndex;   /* Only most significant 5 bits are valid */
@@ -194,7 +171,8 @@ struct nes_timer_entry {
 
 #define NES_CM_DEF_SEQ2      0x18ed5740
 #define NES_CM_DEF_LOCAL_ID2 0xb807
-#define MAX_CM_BUFFER   (IETF_MPA_FRAME_SIZE + IETF_RTR_MSG_SIZE + IETF_MAX_PRIV_DATA_LEN)
+#define MAX_CM_BUFFER   (IETF_MPA_FRAME_SIZE + IETF_MAX_PRIV_DATA_LEN)
+
 
 typedef u32 nes_addr_t;
 
@@ -226,21 +204,6 @@ enum nes_cm_node_state {
         NES_CM_STATE_CLOSED
 };
 
-enum mpa_frame_version {
-        IETF_MPA_V1 = 1,
-        IETF_MPA_V2 = 2
-};
-
-enum mpa_frame_key {
-        MPA_KEY_REQUEST,
-        MPA_KEY_REPLY
-};
-
-enum send_rdma0 {
-        SEND_RDMA_READ_ZERO = 1,
-        SEND_RDMA_WRITE_ZERO = 2
-};
-
 enum nes_tcpip_pkt_type {
         NES_PKT_TYPE_UNKNOWN,
         NES_PKT_TYPE_SYN,
@@ -282,9 +245,9 @@ struct nes_cm_tcp_context {
 
 
 enum nes_cm_listener_state {
-        NES_CM_LISTENER_PASSIVE_STATE = 1,
-        NES_CM_LISTENER_ACTIVE_STATE = 2,
-        NES_CM_LISTENER_EITHER_STATE = 3
+        NES_CM_LISTENER_PASSIVE_STATE=1,
+        NES_CM_LISTENER_ACTIVE_STATE=2,
+        NES_CM_LISTENER_EITHER_STATE=3
 };
 
 struct nes_cm_listener {
@@ -320,20 +283,16 @@ struct nes_cm_node {
 
         struct nes_cm_node        *loopbackpartner;
 
-        struct nes_timer_entry    *send_entry;
-        struct nes_timer_entry    *recv_entry;
+        struct nes_timer_entry  *send_entry;
+
         spinlock_t                retrans_list_lock;
-        enum send_rdma0           send_rdma0_op;
+        struct nes_timer_entry  *recv_entry;
 
+        int                       send_write0;
         union {
-                struct ietf_mpa_v1 mpa_frame;
-                struct ietf_mpa_v2 mpa_v2_frame;
-                u8                 mpa_frame_buf[MAX_CM_BUFFER];
+                struct ietf_mpa_frame mpa_frame;
+                u8                    mpa_frame_buf[MAX_CM_BUFFER];
         };
-        enum mpa_frame_version    mpa_frame_rev;
-        u16                       ird_size;
-        u16                       ord_size;
-
         u16                       mpa_frame_size;
         struct iw_cm_id           *cm_id;
         struct list_head          list;
@@ -440,8 +399,10 @@ struct nes_cm_ops {
                         struct nes_vnic *, u16, void *,
                         struct nes_cm_info *);
         int (*close)(struct nes_cm_core *, struct nes_cm_node *);
-        int (*accept)(struct nes_cm_core *, struct nes_cm_node *);
-        int (*reject)(struct nes_cm_core *, struct nes_cm_node *);
+        int (*accept)(struct nes_cm_core *, struct ietf_mpa_frame *,
+                        struct nes_cm_node *);
+        int (*reject)(struct nes_cm_core *, struct ietf_mpa_frame *,
+                        struct nes_cm_node *);
         int (*recv_pkt)(struct nes_cm_core *, struct nes_vnic *,
                         struct sk_buff *);
         int (*destroy_cm_core)(struct nes_cm_core *);
@@ -461,7 +422,5 @@ int nes_destroy_listen(struct iw_cm_id *);
 int nes_cm_recv(struct sk_buff *, struct net_device *);
 int nes_cm_start(void);
 int nes_cm_stop(void);
-int nes_add_ref_cm_node(struct nes_cm_node *cm_node);
-int nes_rem_ref_cm_node(struct nes_cm_node *cm_node);
 
 #endif                  /* NES_CM_H */
diff --git a/drivers/infiniband/hw/nes/nes_context.h b/drivers/infiniband/hw/nes/nes_context.h
index a69eef16d72..b4393a16099 100644
--- a/drivers/infiniband/hw/nes/nes_context.h
+++ b/drivers/infiniband/hw/nes/nes_context.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c
index 67647e26461..be36cbeae63 100644
--- a/drivers/infiniband/hw/nes/nes_hw.c
+++ b/drivers/infiniband/hw/nes/nes_hw.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -75,6 +75,7 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
 static void process_critical_error(struct nes_device *nesdev);
 static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number);
 static unsigned int nes_reset_adapter_ne020(struct nes_device *nesdev, u8 *OneG_Mode);
+static void nes_terminate_timeout(unsigned long context);
 static void nes_terminate_start_timer(struct nes_qp *nesqp);
 
 #ifdef CONFIG_INFINIBAND_NES_DEBUG
@@ -109,14 +110,6 @@ static unsigned char *nes_tcp_state_str[] = {
 };
 #endif
 
-static inline void print_ip(struct nes_cm_node *cm_node)
-{
-        unsigned char *rem_addr;
-        if (cm_node) {
-                rem_addr = (unsigned char *)&cm_node->rem_addr;
-                printk(KERN_ERR PFX "Remote IP addr: %pI4\n", rem_addr);
-        }
-}
 
 /**
  * nes_nic_init_timer_defaults
@@ -1528,7 +1521,7 @@ int nes_init_phy(struct nes_device *nesdev)
         } else {
                 /* setup 10G MDIO operation */
                 tx_config &= 0xFFFFFFE3;
-                tx_config |= 0x1D;
+                tx_config |= 0x15;
         }
         nes_write_indexed(nesdev, NES_IDX_MAC_TX_CONFIG, tx_config);
 
@@ -1562,7 +1555,6 @@ static void nes_replenish_nic_rq(struct nes_vnic *nesvnic)
         struct nes_hw_nic_rq_wqe *nic_rqe;
         struct nes_hw_nic *nesnic;
         struct nes_device *nesdev;
-        struct nes_rskb_cb *cb;
         u32 rx_wqes_posted = 0;
 
         nesnic = &nesvnic->nic;
@@ -1588,9 +1580,6 @@ static void nes_replenish_nic_rq(struct nes_vnic *nesvnic)
 
                         bus_address = pci_map_single(nesdev->pcidev,
                                         skb->data, nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
-                        cb = (struct nes_rskb_cb *)&skb->cb[0];
-                        cb->busaddr = bus_address;
-                        cb->maplen = nesvnic->max_frame_size;
 
                         nic_rqe = &nesnic->rq_vbase[nesvnic->nic.rq_head];
                         nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX] =
@@ -1680,7 +1669,6 @@ int nes_init_nic_qp(struct nes_device *nesdev, struct net_device *netdev)
         u32 cqp_head;
         u32 counter;
         u32 wqe_count;
-        struct nes_rskb_cb *cb;
         u8 jumbomode=0;
 
         /* Allocate fragment, SQ, RQ, and CQ; Reuse CEQ based on the PCI function */
@@ -1857,9 +1845,6 @@ int nes_init_nic_qp(struct nes_device *nesdev, struct net_device *netdev)
 
                 pmem = pci_map_single(nesdev->pcidev, skb->data,
                                 nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
-                cb = (struct nes_rskb_cb *)&skb->cb[0];
-                cb->busaddr = pmem;
-                cb->maplen = nesvnic->max_frame_size;
 
                 nic_rqe = &nesvnic->nic.rq_vbase[counter];
                 nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX] = cpu_to_le32(nesvnic->max_frame_size);
@@ -1888,13 +1873,6 @@ int nes_init_nic_qp(struct nes_device *nesdev, struct net_device *netdev)
                         jumbomode = 1;
                 nes_nic_init_timer_defaults(nesdev, jumbomode);
         }
-        if ((nesdev->nesadapter->allow_unaligned_fpdus) &&
-                (nes_init_mgt_qp(nesdev, netdev, nesvnic))) {
-                        nes_debug(NES_DBG_INIT, "%s: Out of memory for pau nic\n", netdev->name);
-                        nes_destroy_nic_qp(nesvnic);
-                return -ENOMEM;
-        }
-
         nesvnic->lro_mgr.max_aggr       = nes_lro_max_aggr;
         nesvnic->lro_mgr.max_desc       = NES_MAX_LRO_DESCRIPTORS;
         nesvnic->lro_mgr.lro_arr        = nesvnic->lro_desc;
@@ -1917,29 +1895,28 @@ void nes_destroy_nic_qp(struct nes_vnic *nesvnic)
         struct nes_device *nesdev = nesvnic->nesdev;
         struct nes_hw_cqp_wqe *cqp_wqe;
         struct nes_hw_nic_sq_wqe *nic_sqe;
+        struct nes_hw_nic_rq_wqe *nic_rqe;
         __le16 *wqe_fragment_length;
         u16  wqe_fragment_index;
+        u64 wqe_frag;
         u32 cqp_head;
         u32 wqm_cfg0;
         unsigned long flags;
-        struct sk_buff *rx_skb;
-        struct nes_rskb_cb *cb;
         int ret;
 
-        if (nesdev->nesadapter->allow_unaligned_fpdus)
-                nes_destroy_mgt(nesvnic);
-
         /* clear wqe stall before destroying NIC QP */
         wqm_cfg0 = nes_read_indexed(nesdev, NES_IDX_WQM_CONFIG0);
         nes_write_indexed(nesdev, NES_IDX_WQM_CONFIG0, wqm_cfg0 & 0xFFFF7FFF);
 
         /* Free remaining NIC receive buffers */
         while (nesvnic->nic.rq_head != nesvnic->nic.rq_tail) {
-                rx_skb = nesvnic->nic.rx_skb[nesvnic->nic.rq_tail];
-                cb = (struct nes_rskb_cb *)&rx_skb->cb[0];
-                pci_unmap_single(nesdev->pcidev, cb->busaddr, cb->maplen,
-                        PCI_DMA_FROMDEVICE);
-
+                nic_rqe   = &nesvnic->nic.rq_vbase[nesvnic->nic.rq_tail];
+                wqe_frag  = (u64)le32_to_cpu(
+                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_LOW_IDX]);
+                wqe_frag |= ((u64)le32_to_cpu(
+                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_HIGH_IDX]))<<32;
+                pci_unmap_single(nesdev->pcidev, (dma_addr_t)wqe_frag,
+                                nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
                 dev_kfree_skb(nesvnic->nic.rx_skb[nesvnic->nic.rq_tail++]);
                 nesvnic->nic.rq_tail &= (nesvnic->nic.rq_size - 1);
         }
@@ -2678,9 +2655,11 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                         }
                 }
                 if (nesadapter->phy_type[mac_index] == NES_PHY_TYPE_SFP_D) {
+                        if (nesdev->link_recheck)
+                                cancel_delayed_work(&nesdev->work);
                         nesdev->link_recheck = 1;
-                        mod_delayed_work(system_wq, &nesdev->work,
-                                         NES_LINK_RECHECK_DELAY);
+                        schedule_delayed_work(&nesdev->work,
+                                              NES_LINK_RECHECK_DELAY);
                 }
         }
 
@@ -2796,7 +2775,6 @@ void nes_nic_ce_handler(struct nes_device *nesdev, struct nes_hw_nic_cq *cq)
         struct nes_hw_nic_sq_wqe *nic_sqe;
         struct sk_buff *skb;
         struct sk_buff *rx_skb;
-        struct nes_rskb_cb *cb;
         __le16 *wqe_fragment_length;
         u32 head;
         u32 cq_size;
@@ -2881,8 +2859,6 @@ void nes_nic_ce_handler(struct nes_device *nesdev, struct nes_hw_nic_cq *cq)
                                 bus_address += ((u64)le32_to_cpu(nic_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_HIGH_IDX])) << 32;
                                 pci_unmap_single(nesdev->pcidev, bus_address,
                                                 nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
-                                cb = (struct nes_rskb_cb *)&rx_skb->cb[0];
-                                cb->busaddr = 0;
                                 /* rx_skb->tail = rx_skb->data + rx_pkt_size; */
                                 /* rx_skb->len = rx_pkt_size; */
                                 rx_skb->len = 0;  /* TODO: see if this is necessary */
@@ -3007,7 +2983,6 @@ skip_rx_indicate0:
 }
 
 
-
 /**
  * nes_cqp_ce_handler
  */
@@ -3022,8 +2997,6 @@ static void nes_cqp_ce_handler(struct nes_device *nesdev, struct nes_hw_cq *cq)
         u32 cq_size;
         u32 cqe_count=0;
         u32 error_code;
-        u32 opcode;
-        u32 ctx_index;
         /* u32 counter; */
 
         head = cq->cq_head;
@@ -3034,9 +3007,12 @@ static void nes_cqp_ce_handler(struct nes_device *nesdev, struct nes_hw_cq *cq)
                 /* nes_debug(NES_DBG_CQP, "head=%u cqe_words=%08X\n", head,
                           le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX])); */
 
-                opcode = le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX]);
-                if (opcode & NES_CQE_VALID) {
-                        cqp = &nesdev->cqp;
+                if (le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX]) & NES_CQE_VALID) {
+                        u64temp = (((u64)(le32_to_cpu(cq->cq_vbase[head].
+                                        cqe_words[NES_CQE_COMP_COMP_CTX_HIGH_IDX]))) << 32) |
+                                        ((u64)(le32_to_cpu(cq->cq_vbase[head].
+                                        cqe_words[NES_CQE_COMP_COMP_CTX_LOW_IDX])));
+                        cqp = *((struct nes_hw_cqp **)&u64temp);
 
                         error_code = le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_CQE_ERROR_CODE_IDX]);
                         if (error_code) {
@@ -3045,14 +3021,15 @@ static void nes_cqp_ce_handler(struct nes_device *nesdev, struct nes_hw_cq *cq)
                                                 le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_CQE_OPCODE_IDX])&0x3f,
                                                 (u16)(error_code >> 16),
                                                 (u16)error_code);
+                                nes_debug(NES_DBG_CQP, "cqp: qp_id=%u, sq_head=%u, sq_tail=%u\n",
+                                                cqp->qp_id, cqp->sq_head, cqp->sq_tail);
                         }
 
-                        u64temp = (((u64)(le32_to_cpu(cq->cq_vbase[head].
-                                        cqe_words[NES_CQE_COMP_COMP_CTX_HIGH_IDX]))) << 32) |
-                                        ((u64)(le32_to_cpu(cq->cq_vbase[head].
-                                        cqe_words[NES_CQE_COMP_COMP_CTX_LOW_IDX])));
-
-                        cqp_request = (struct nes_cqp_request *)(unsigned long)u64temp;
+                        u64temp = (((u64)(le32_to_cpu(nesdev->cqp.sq_vbase[cqp->sq_tail].
+                                        wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX]))) << 32) |
+                                        ((u64)(le32_to_cpu(nesdev->cqp.sq_vbase[cqp->sq_tail].
+                                        wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX])));
+                        cqp_request = *((struct nes_cqp_request **)&u64temp);
                         if (cqp_request) {
                                 if (cqp_request->waiting) {
                                         /* nes_debug(NES_DBG_CQP, "%s: Waking up requestor\n"); */
@@ -3098,15 +3075,9 @@ static void nes_cqp_ce_handler(struct nes_device *nesdev, struct nes_hw_cq *cq)
                 cqp_wqe = &nesdev->cqp.sq_vbase[head];
                 memcpy(cqp_wqe, &cqp_request->cqp_wqe, sizeof(*cqp_wqe));
                 barrier();
-
-                opcode = cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX];
-                if ((opcode & NES_CQP_OPCODE_MASK) == NES_CQP_DOWNLOAD_SEGMENT)
-                        ctx_index = NES_CQP_WQE_DL_COMP_CTX_LOW_IDX;
-                else
-                        ctx_index = NES_CQP_WQE_COMP_CTX_LOW_IDX;
-                cqp_wqe->wqe_words[ctx_index] =
+                cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] =
                         cpu_to_le32((u32)((unsigned long)cqp_request));
-                cqp_wqe->wqe_words[ctx_index + 1] =
+                cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] =
                         cpu_to_le32((u32)(upper_32_bits((unsigned long)cqp_request)));
                 nes_debug(NES_DBG_CQP, "CQP request %p (opcode 0x%02X) put on CQPs SQ wqe%u.\n",
                                 cqp_request, le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX])&0x3f, head);
@@ -3122,6 +3093,7 @@ static void nes_cqp_ce_handler(struct nes_device *nesdev, struct nes_hw_cq *cq)
         nes_read32(nesdev->regs+NES_CQE_ALLOC);
 }
 
+
 static u8 *locate_mpa(u8 *pkt, u32 aeq_info)
 {
         if (aeq_info & NES_AEQE_Q2_DATA_ETHERNET) {
@@ -3519,7 +3491,7 @@ static void nes_terminate_received(struct nes_device *nesdev,
 }
 
 /* Timeout routine in case terminate fails to complete */
-void nes_terminate_timeout(unsigned long context)
+static void nes_terminate_timeout(unsigned long context)
 {
         struct nes_qp *nesqp = (struct nes_qp *)(unsigned long)context;
 
@@ -3529,7 +3501,11 @@ void nes_terminate_timeout(unsigned long context)
 /* Set a timer in case hw cannot complete the terminate sequence */
 static void nes_terminate_start_timer(struct nes_qp *nesqp)
 {
-        mod_timer(&nesqp->terminate_timer, (jiffies + HZ));
+        init_timer(&nesqp->terminate_timer);
+        nesqp->terminate_timer.function = nes_terminate_timeout;
+        nesqp->terminate_timer.expires = jiffies + HZ;
+        nesqp->terminate_timer.data = (unsigned long)nesqp;
+        add_timer(&nesqp->terminate_timer);
 }
 
 /**
@@ -3570,16 +3546,16 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
         tcp_state = (aeq_info & NES_AEQE_TCP_STATE_MASK) >> NES_AEQE_TCP_STATE_SHIFT;
         iwarp_state = (aeq_info & NES_AEQE_IWARP_STATE_MASK) >> NES_AEQE_IWARP_STATE_SHIFT;
         nes_debug(NES_DBG_AEQ, "aeid = 0x%04X, qp-cq id = %d, aeqe = %p,"
-                        " Tcp state = %d, iWARP state = %d\n",
+                        " Tcp state = %s, iWARP state = %s\n",
                         async_event_id,
                         le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]), aeqe,
-                        tcp_state, iwarp_state);
+                        nes_tcp_state_str[tcp_state], nes_iwarp_state_str[iwarp_state]);
 
         aeqe_cq_id = le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]);
         if (aeq_info & NES_AEQE_QP) {
-                if (!nes_is_resource_allocated(nesadapter,
-                                nesadapter->allocated_qps,
-                                aeqe_cq_id))
+                if ((!nes_is_resource_allocated(nesadapter, nesadapter->allocated_qps,
+                                aeqe_cq_id)) ||
+                                (atomic_read(&nesqp->close_timer_started)))
                         return;
         }
 
@@ -3590,7 +3566,8 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
 
                         if (atomic_inc_return(&nesqp->close_timer_started) == 1) {
                                 if ((tcp_state == NES_AEQE_TCP_STATE_CLOSE_WAIT) &&
-                                        (nesqp->ibqp_state == IB_QPS_RTS)) {
+                                        (nesqp->ibqp_state == IB_QPS_RTS) &&
+                                        ((nesadapter->eeprom_version >> 16) != NES_A0)) {
                                         spin_lock_irqsave(&nesqp->lock, flags);
                                         nesqp->hw_iwarp_state = iwarp_state;
                                         nesqp->hw_tcp_state = tcp_state;
@@ -3612,11 +3589,14 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
                         }
                         break;
                 case NES_AEQE_AEID_LLP_CLOSE_COMPLETE:
+                        if (nesqp->term_flags) {
+                                nes_terminate_done(nesqp, 0);
+                                return;
+                        }
                         spin_lock_irqsave(&nesqp->lock, flags);
-                        nesqp->hw_iwarp_state = iwarp_state;
-                        nesqp->hw_tcp_state = tcp_state;
-                        nesqp->last_aeq = async_event_id;
+                        nesqp->hw_iwarp_state = NES_AEQE_IWARP_STATE_CLOSING;
                         spin_unlock_irqrestore(&nesqp->lock, flags);
+                        nes_hw_modify_qp(nesdev, nesqp, NES_CQP_QP_IWARP_STATE_CLOSING, 0, 0);
                         nes_cm_disconn(nesqp);
                         break;
 
@@ -3714,9 +3694,7 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
                 case NES_AEQE_AEID_ROE_INVALID_RDMA_WRITE_OR_READ_RESP:
                         printk(KERN_ERR PFX "QP[%u] async_event_id=0x%04X IB_EVENT_QP_FATAL\n",
                                         nesqp->hwqp.qp_id, async_event_id);
-                        print_ip(nesqp->cm_node);
-                        if (!atomic_read(&nesqp->close_timer_started))
-                                nes_terminate_connection(nesdev, nesqp, aeqe, IB_EVENT_QP_FATAL);
+                        nes_terminate_connection(nesdev, nesqp, aeqe, IB_EVENT_QP_FATAL);
                         break;
 
                 case NES_AEQE_AEID_CQ_OPERATION_ERROR:
diff --git a/drivers/infiniband/hw/nes/nes_hw.h b/drivers/infiniband/hw/nes/nes_hw.h
index d748e4b31b8..c3241479ec0 100644
--- a/drivers/infiniband/hw/nes/nes_hw.h
+++ b/drivers/infiniband/hw/nes/nes_hw.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+* Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -47,11 +47,6 @@
 #define NES_MULTICAST_PF_MAX 8
 #define NES_A0 3
 
-#define NES_ENABLE_PAU 0x07000001
-#define NES_DISABLE_PAU 0x07000000
-#define NES_PAU_COUNTER 10
-#define NES_CQP_OPCODE_MASK 0x3f
-
 enum pci_regs {
         NES_INT_STAT = 0x0000,
         NES_INT_MASK = 0x0004,
@@ -78,10 +73,8 @@ enum indexed_regs {
         NES_IDX_QP_CONTROL = 0x0040,
         NES_IDX_FLM_CONTROL = 0x0080,
         NES_IDX_INT_CPU_STATUS = 0x00a0,
-        NES_IDX_GPR_TRIGGER = 0x00bc,
         NES_IDX_GPIO_CONTROL = 0x00f0,
         NES_IDX_GPIO_DATA = 0x00f4,
-        NES_IDX_GPR2 = 0x010c,
         NES_IDX_TCP_CONFIG0 = 0x01e4,
         NES_IDX_TCP_TIMER_CONFIG = 0x01ec,
         NES_IDX_TCP_NOW = 0x01f0,
@@ -209,7 +202,6 @@ enum nes_cqp_opcodes {
         NES_CQP_REGISTER_SHARED_STAG = 0x0c,
         NES_CQP_DEALLOCATE_STAG = 0x0d,
         NES_CQP_MANAGE_ARP_CACHE = 0x0f,
-        NES_CQP_DOWNLOAD_SEGMENT = 0x10,
         NES_CQP_SUSPEND_QPS = 0x11,
         NES_CQP_UPLOAD_CONTEXT = 0x13,
         NES_CQP_CREATE_CEQ = 0x16,
@@ -218,8 +210,7 @@ enum nes_cqp_opcodes {
         NES_CQP_DESTROY_AEQ = 0x1b,
         NES_CQP_LMI_ACCESS = 0x20,
         NES_CQP_FLUSH_WQES = 0x22,
-        NES_CQP_MANAGE_APBVT = 0x23,
-        NES_CQP_MANAGE_QUAD_HASH = 0x25
+        NES_CQP_MANAGE_APBVT = 0x23
 };
 
 enum nes_cqp_wqe_word_idx {
@@ -231,14 +222,6 @@ enum nes_cqp_wqe_word_idx {
         NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX = 5,
 };
 
-enum nes_cqp_wqe_word_download_idx { /* format differs from other cqp ops */
-        NES_CQP_WQE_DL_OPCODE_IDX = 0,
-        NES_CQP_WQE_DL_COMP_CTX_LOW_IDX = 1,
-        NES_CQP_WQE_DL_COMP_CTX_HIGH_IDX = 2,
-        NES_CQP_WQE_DL_LENGTH_0_TOTAL_IDX = 3
-        /* For index values 4-15 use NES_NIC_SQ_WQE_ values */
-};
-
 enum nes_cqp_cq_wqeword_idx {
         NES_CQP_CQ_WQE_PBL_LOW_IDX = 6,
         NES_CQP_CQ_WQE_PBL_HIGH_IDX = 7,
@@ -259,7 +242,6 @@ enum nes_cqp_stag_wqeword_idx {
         NES_CQP_STAG_WQE_PBL_LEN_IDX = 14
 };
 
-#define NES_CQP_OP_LOGICAL_PORT_SHIFT 26
 #define NES_CQP_OP_IWARP_STATE_SHIFT 28
 #define NES_CQP_OP_TERMLEN_SHIFT     28
 
@@ -617,7 +599,6 @@ enum nes_nic_sq_wqe_bits {
 
 enum nes_nic_cqe_word_idx {
         NES_NIC_CQE_ACCQP_ID_IDX = 0,
-        NES_NIC_CQE_HASH_RCVNXT = 1,
         NES_NIC_CQE_TAG_PKT_TYPE_IDX = 2,
         NES_NIC_CQE_MISC_IDX = 3,
 };
@@ -1024,11 +1005,6 @@ struct nes_arp_entry {
 #define NES_NIC_CQ_DOWNWARD_TREND   16
 #define NES_PFT_SIZE                48
 
-#define NES_MGT_WQ_COUNT 32
-#define NES_MGT_CTX_SIZE ((NES_NIC_CTX_RQ_SIZE_32) | (NES_NIC_CTX_SQ_SIZE_32))
-#define NES_MGT_QP_OFFSET 36
-#define NES_MGT_QP_COUNT 4
-
 struct nes_hw_tune_timer {
     /* u16 cq_count; */
     u16 threshold_low;
@@ -1142,7 +1118,6 @@ struct nes_adapter {
         u32 et_rate_sample_interval;
         u32 timer_int_limit;
         u32 wqm_quanta;
-        u8 allow_unaligned_fpdus;
 
         /* Adapter base MAC address */
         u32 mac_addr_low;
@@ -1276,14 +1251,6 @@ struct nes_vnic {
         enum ib_event_type delayed_event;
         enum ib_event_type last_dispatched_event;
         spinlock_t port_ibevent_lock;
-        u32 mgt_mem_size;
-        void *mgt_vbase;
-        dma_addr_t mgt_pbase;
-        struct nes_vnic_mgt *mgtvnic[NES_MGT_QP_COUNT];
-        struct task_struct *mgt_thread;
-        wait_queue_head_t mgt_wait_queue;
-        struct sk_buff_head mgt_skb_list;
-
 };
 
 struct nes_ib_device {
diff --git a/drivers/infiniband/hw/nes/nes_mgt.c b/drivers/infiniband/hw/nes/nes_mgt.c
deleted file mode 100644
index 416645259b0..00000000000
--- a/drivers/infiniband/hw/nes/nes_mgt.c
+++ /dev/null
@@ -1,1160 +0,0 @@
-/*
- * Copyright (c) 2006 - 2011 Intel-NE, 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/skbuff.h>
-#include <linux/etherdevice.h>
-#include <linux/kthread.h>
-#include <linux/ip.h>
-#include <linux/tcp.h>
-#include <net/tcp.h>
-#include "nes.h"
-#include "nes_mgt.h"
-
-atomic_t pau_qps_created;
-atomic_t pau_qps_destroyed;
-
-static void nes_replenish_mgt_rq(struct nes_vnic_mgt *mgtvnic)
-{
-        unsigned long flags;
-        dma_addr_t bus_address;
-        struct sk_buff *skb;
-        struct nes_hw_nic_rq_wqe *nic_rqe;
-        struct nes_hw_mgt *nesmgt;
-        struct nes_device *nesdev;
-        struct nes_rskb_cb *cb;
-        u32 rx_wqes_posted = 0;
-
-        nesmgt = &mgtvnic->mgt;
-        nesdev = mgtvnic->nesvnic->nesdev;
-        spin_lock_irqsave(&nesmgt->rq_lock, flags);
-        if (nesmgt->replenishing_rq != 0) {
-                if (((nesmgt->rq_size - 1) == atomic_read(&mgtvnic->rx_skbs_needed)) &&
-                    (atomic_read(&mgtvnic->rx_skb_timer_running) == 0)) {
-                        atomic_set(&mgtvnic->rx_skb_timer_running, 1);
-                        spin_unlock_irqrestore(&nesmgt->rq_lock, flags);
-                        mgtvnic->rq_wqes_timer.expires = jiffies + (HZ / 2);      /* 1/2 second */
-                        add_timer(&mgtvnic->rq_wqes_timer);
-                } else {
-                        spin_unlock_irqrestore(&nesmgt->rq_lock, flags);
-                }
-                return;
-        }
-        nesmgt->replenishing_rq = 1;
-        spin_unlock_irqrestore(&nesmgt->rq_lock, flags);
-        do {
-                skb = dev_alloc_skb(mgtvnic->nesvnic->max_frame_size);
-                if (skb) {
-                        skb->dev = mgtvnic->nesvnic->netdev;
-
-                        bus_address = pci_map_single(nesdev->pcidev,
-                                                     skb->data, mgtvnic->nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
-                        cb = (struct nes_rskb_cb *)&skb->cb[0];
-                        cb->busaddr = bus_address;
-                        cb->maplen = mgtvnic->nesvnic->max_frame_size;
-
-                        nic_rqe = &nesmgt->rq_vbase[mgtvnic->mgt.rq_head];
-                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX] =
-                                cpu_to_le32(mgtvnic->nesvnic->max_frame_size);
-                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_3_2_IDX] = 0;
-                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_LOW_IDX] =
-                                cpu_to_le32((u32)bus_address);
-                        nic_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_HIGH_IDX] =
-                                cpu_to_le32((u32)((u64)bus_address >> 32));
-                        nesmgt->rx_skb[nesmgt->rq_head] = skb;
-                        nesmgt->rq_head++;
-                        nesmgt->rq_head &= nesmgt->rq_size - 1;
-                        atomic_dec(&mgtvnic->rx_skbs_needed);
-                        barrier();
-                        if (++rx_wqes_posted == 255) {
-                                nes_write32(nesdev->regs + NES_WQE_ALLOC, (rx_wqes_posted << 24) | nesmgt->qp_id);
-                                rx_wqes_posted = 0;
-                        }
-                } else {
-                        spin_lock_irqsave(&nesmgt->rq_lock, flags);
-                        if (((nesmgt->rq_size - 1) == atomic_read(&mgtvnic->rx_skbs_needed)) &&
-                            (atomic_read(&mgtvnic->rx_skb_timer_running) == 0)) {
-                                atomic_set(&mgtvnic->rx_skb_timer_running, 1);
-                                spin_unlock_irqrestore(&nesmgt->rq_lock, flags);
-                                mgtvnic->rq_wqes_timer.expires = jiffies + (HZ / 2);      /* 1/2 second */
-                                add_timer(&mgtvnic->rq_wqes_timer);
-                        } else {
-                                spin_unlock_irqrestore(&nesmgt->rq_lock, flags);
-                        }
-                        break;
-                }
-        } while (atomic_read(&mgtvnic->rx_skbs_needed));
-        barrier();
-        if (rx_wqes_posted)
-                nes_write32(nesdev->regs + NES_WQE_ALLOC, (rx_wqes_posted << 24) | nesmgt->qp_id);
-        nesmgt->replenishing_rq = 0;
-}
-
-/**
- * nes_mgt_rq_wqes_timeout
- */
-static void nes_mgt_rq_wqes_timeout(unsigned long parm)
-{
-        struct nes_vnic_mgt *mgtvnic = (struct nes_vnic_mgt *)parm;
-
-        atomic_set(&mgtvnic->rx_skb_timer_running, 0);
-        if (atomic_read(&mgtvnic->rx_skbs_needed))
-                nes_replenish_mgt_rq(mgtvnic);
-}
-
-/**
- * nes_mgt_free_skb - unmap and free skb
- */
-static void nes_mgt_free_skb(struct nes_device *nesdev, struct sk_buff *skb, u32 dir)
-{
-        struct nes_rskb_cb *cb;
-
-        cb = (struct nes_rskb_cb *)&skb->cb[0];
-        pci_unmap_single(nesdev->pcidev, cb->busaddr, cb->maplen, dir);
-        cb->busaddr = 0;
-        dev_kfree_skb_any(skb);
-}
-
-/**
- * nes_download_callback - handle download completions
- */
-static void nes_download_callback(struct nes_device *nesdev, struct nes_cqp_request *cqp_request)
-{
-        struct pau_fpdu_info *fpdu_info = cqp_request->cqp_callback_pointer;
-        struct nes_qp *nesqp = fpdu_info->nesqp;
-        struct sk_buff *skb;
-        int i;
-
-        for (i = 0; i < fpdu_info->frag_cnt; i++) {
-                skb = fpdu_info->frags[i].skb;
-                if (fpdu_info->frags[i].cmplt) {
-                        nes_mgt_free_skb(nesdev, skb, PCI_DMA_TODEVICE);
-                        nes_rem_ref_cm_node(nesqp->cm_node);
-                }
-        }
-
-        if (fpdu_info->hdr_vbase)
-                pci_free_consistent(nesdev->pcidev, fpdu_info->hdr_len,
-                                    fpdu_info->hdr_vbase, fpdu_info->hdr_pbase);
-        kfree(fpdu_info);
-}
-
-/**
- * nes_get_seq - Get the seq, ack_seq and window from the packet
- */
-static u32 nes_get_seq(struct sk_buff *skb, u32 *ack, u16 *wnd, u32 *fin_rcvd, u32 *rst_rcvd)
-{
-        struct nes_rskb_cb *cb = (struct nes_rskb_cb *)&skb->cb[0];
-        struct iphdr *iph = (struct iphdr *)(cb->data_start + ETH_HLEN);
-        struct tcphdr *tcph = (struct tcphdr *)(((char *)iph) + (4 * iph->ihl));
-
-        *ack = be32_to_cpu(tcph->ack_seq);
-        *wnd = be16_to_cpu(tcph->window);
-        *fin_rcvd = tcph->fin;
-        *rst_rcvd = tcph->rst;
-        return be32_to_cpu(tcph->seq);
-}
-
-/**
- * nes_get_next_skb - Get the next skb based on where current skb is in the queue
- */
-static struct sk_buff *nes_get_next_skb(struct nes_device *nesdev, struct nes_qp *nesqp,
-                                        struct sk_buff *skb, u32 nextseq, u32 *ack,
-                                        u16 *wnd, u32 *fin_rcvd, u32 *rst_rcvd)
-{
-        u32 seq;
-        bool processacks;
-        struct sk_buff *old_skb;
-
-        if (skb) {
-                /* Continue processing fpdu */
-                if (skb->next == (struct sk_buff *)&nesqp->pau_list)
-                        goto out;
-                skb = skb->next;
-                processacks = false;
-        } else {
-                /* Starting a new one */
-                if (skb_queue_empty(&nesqp->pau_list))
-                        goto out;
-                skb = skb_peek(&nesqp->pau_list);
-                processacks = true;
-        }
-
-        while (1) {
-                if (skb_queue_empty(&nesqp->pau_list))
-                        goto out;
-
-                seq = nes_get_seq(skb, ack, wnd, fin_rcvd, rst_rcvd);
-                if (seq == nextseq) {
-                        if (skb->len || processacks)
-                                break;
-                } else if (after(seq, nextseq)) {
-                        goto out;
-                }
-
-                old_skb = skb;
-                skb = skb->next;
-                skb_unlink(old_skb, &nesqp->pau_list);
-                nes_mgt_free_skb(nesdev, old_skb, PCI_DMA_TODEVICE);
-                nes_rem_ref_cm_node(nesqp->cm_node);
-                if (skb == (struct sk_buff *)&nesqp->pau_list)
-                        goto out;
-        }
-        return skb;
-
-out:
-        return NULL;
-}
-
-/**
- * get_fpdu_info - Find the next complete fpdu and return its fragments.
- */
-static int get_fpdu_info(struct nes_device *nesdev, struct nes_qp *nesqp,
-                         struct pau_fpdu_info **pau_fpdu_info)
-{
-        struct sk_buff *skb;
-        struct iphdr *iph;
-        struct tcphdr *tcph;
-        struct nes_rskb_cb *cb;
-        struct pau_fpdu_info *fpdu_info = NULL;
-        struct pau_fpdu_frag frags[MAX_FPDU_FRAGS];
-        u32 fpdu_len = 0;
-        u32 tmp_len;
-        int frag_cnt = 0;
-        u32 tot_len;
-        u32 frag_tot;
-        u32 ack;
-        u32 fin_rcvd;
-        u32 rst_rcvd;
-        u16 wnd;
-        int i;
-        int rc = 0;
-
-        *pau_fpdu_info = NULL;
-
-        skb = nes_get_next_skb(nesdev, nesqp, NULL, nesqp->pau_rcv_nxt, &ack, &wnd, &fin_rcvd, &rst_rcvd);
-        if (!skb)
-                goto out;
-
-        cb = (struct nes_rskb_cb *)&skb->cb[0];
-        if (skb->len) {
-                fpdu_len = be16_to_cpu(*(__be16 *) skb->data) + MPA_FRAMING;
-                fpdu_len = (fpdu_len + 3) & 0xfffffffc;
-                tmp_len = fpdu_len;
-
-                /* See if we have all of the fpdu */
-                frag_tot = 0;
-                memset(&frags, 0, sizeof frags);
-                for (i = 0; i < MAX_FPDU_FRAGS; i++) {
-                        frags[i].physaddr = cb->busaddr;
-                        frags[i].physaddr += skb->data - cb->data_start;
-                        frags[i].frag_len = min(tmp_len, skb->len);
-                        frags[i].skb = skb;
-                        frags[i].cmplt = (skb->len == frags[i].frag_len);
-                        frag_tot += frags[i].frag_len;
-                        frag_cnt++;
-
-                        tmp_len -= frags[i].frag_len;
-                        if (tmp_len == 0)
-                                break;
-
-                        skb = nes_get_next_skb(nesdev, nesqp, skb,
-                                               nesqp->pau_rcv_nxt + frag_tot, &ack, &wnd, &fin_rcvd, &rst_rcvd);
-                        if (!skb)
-                                goto out;
-                        if (rst_rcvd) {
-                                /* rst received in the middle of fpdu */
-                                for (; i >= 0; i--) {
-                                        skb_unlink(frags[i].skb, &nesqp->pau_list);
-                                        nes_mgt_free_skb(nesdev, frags[i].skb, PCI_DMA_TODEVICE);
-                                }
-                                cb = (struct nes_rskb_cb *)&skb->cb[0];
-                                frags[0].physaddr = cb->busaddr;
-                                frags[0].physaddr += skb->data - cb->data_start;
-                                frags[0].frag_len = skb->len;
-                                frags[0].skb = skb;
-                                frags[0].cmplt = true;
-                                frag_cnt = 1;
-                                break;
-                        }
-
-                        cb = (struct nes_rskb_cb *)&skb->cb[0];
-                }
-        } else {
-                /* no data */
-                frags[0].physaddr = cb->busaddr;
-                frags[0].frag_len = 0;
-                frags[0].skb = skb;
-                frags[0].cmplt = true;
-                frag_cnt = 1;
-        }
-
-        /* Found one */
-        fpdu_info = kzalloc(sizeof(*fpdu_info), GFP_ATOMIC);
-        if (fpdu_info == NULL) {
-                nes_debug(NES_DBG_PAU, "Failed to alloc a fpdu_info.\n");
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        fpdu_info->cqp_request = nes_get_cqp_request(nesdev);
-        if (fpdu_info->cqp_request == NULL) {
-                nes_debug(NES_DBG_PAU, "Failed to get a cqp_request.\n");
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        cb = (struct nes_rskb_cb *)&frags[0].skb->cb[0];
-        iph = (struct iphdr *)(cb->data_start + ETH_HLEN);
-        tcph = (struct tcphdr *)(((char *)iph) + (4 * iph->ihl));
-        fpdu_info->hdr_len = (((unsigned char *)tcph) + 4 * (tcph->doff)) - cb->data_start;
-        fpdu_info->data_len = fpdu_len;
-        tot_len = fpdu_info->hdr_len + fpdu_len - ETH_HLEN;
-
-        if (frags[0].cmplt) {
-                fpdu_info->hdr_pbase = cb->busaddr;
-                fpdu_info->hdr_vbase = NULL;
-        } else {
-                fpdu_info->hdr_vbase = pci_alloc_consistent(nesdev->pcidev,
-                                                            fpdu_info->hdr_len, &fpdu_info->hdr_pbase);
-                if (!fpdu_info->hdr_vbase) {
-                        nes_debug(NES_DBG_PAU, "Unable to allocate memory for pau first frag\n");
-                        rc = -ENOMEM;
-                        goto out;
-                }
-
-                /* Copy hdrs, adjusting len and seqnum */
-                memcpy(fpdu_info->hdr_vbase, cb->data_start, fpdu_info->hdr_len);
-                iph = (struct iphdr *)(fpdu_info->hdr_vbase + ETH_HLEN);
-                tcph = (struct tcphdr *)(((char *)iph) + (4 * iph->ihl));
-        }
-
-        iph->tot_len = cpu_to_be16(tot_len);
-        iph->saddr = cpu_to_be32(0x7f000001);
-
-        tcph->seq = cpu_to_be32(nesqp->pau_rcv_nxt);
-        tcph->ack_seq = cpu_to_be32(ack);
-        tcph->window = cpu_to_be16(wnd);
-
-        nesqp->pau_rcv_nxt += fpdu_len + fin_rcvd;
-
-        memcpy(fpdu_info->frags, frags, sizeof(fpdu_info->frags));
-        fpdu_info->frag_cnt = frag_cnt;
-        fpdu_info->nesqp = nesqp;
-        *pau_fpdu_info = fpdu_info;
-
-        /* Update skb's for next pass */
-        for (i = 0; i < frag_cnt; i++) {
-                cb = (struct nes_rskb_cb *)&frags[i].skb->cb[0];
-                skb_pull(frags[i].skb, frags[i].frag_len);
-
-                if (frags[i].skb->len == 0) {
-                        /* Pull skb off the list - it will be freed in the callback */
-                        if (!skb_queue_empty(&nesqp->pau_list))
-                                skb_unlink(frags[i].skb, &nesqp->pau_list);
-                } else {
-                        /* Last skb still has data so update the seq */
-                        iph = (struct iphdr *)(cb->data_start + ETH_HLEN);
-                        tcph = (struct tcphdr *)(((char *)iph) + (4 * iph->ihl));
-                        tcph->seq = cpu_to_be32(nesqp->pau_rcv_nxt);
-                }
-        }
-
-out:
-        if (rc) {
-                if (fpdu_info) {
-                        if (fpdu_info->cqp_request)
-                                nes_put_cqp_request(nesdev, fpdu_info->cqp_request);
-                        kfree(fpdu_info);
-                }
-        }
-        return rc;
-}
-
-/**
- * forward_fpdu - send complete fpdus, one at a time
- */
-static int forward_fpdus(struct nes_vnic *nesvnic, struct nes_qp *nesqp)
-{
-        struct nes_device *nesdev = nesvnic->nesdev;
-        struct pau_fpdu_info *fpdu_info;
-        struct nes_hw_cqp_wqe *cqp_wqe;
-        struct nes_cqp_request *cqp_request;
-        unsigned long flags;
-        u64 u64tmp;
-        u32 u32tmp;
-        int rc;
-
-        while (1) {
-                spin_lock_irqsave(&nesqp->pau_lock, flags);
-                rc = get_fpdu_info(nesdev, nesqp, &fpdu_info);
-                if (rc || (fpdu_info == NULL)) {
-                        spin_unlock_irqrestore(&nesqp->pau_lock, flags);
-                        return rc;
-                }
-
-                cqp_request = fpdu_info->cqp_request;
-                cqp_wqe = &cqp_request->cqp_wqe;
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_DL_OPCODE_IDX,
-                                    NES_CQP_DOWNLOAD_SEGMENT |
-                                    (((u32)nesvnic->logical_port) << NES_CQP_OP_LOGICAL_PORT_SHIFT));
-
-                u32tmp = fpdu_info->hdr_len << 16;
-                u32tmp |= fpdu_info->hdr_len + (u32)fpdu_info->data_len;
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_DL_LENGTH_0_TOTAL_IDX,
-                                    u32tmp);
-
-                u32tmp = (fpdu_info->frags[1].frag_len << 16) | fpdu_info->frags[0].frag_len;
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_LENGTH_2_1_IDX,
-                                    u32tmp);
-
-                u32tmp = (fpdu_info->frags[3].frag_len << 16) | fpdu_info->frags[2].frag_len;
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_LENGTH_4_3_IDX,
-                                    u32tmp);
-
-                u64tmp = (u64)fpdu_info->hdr_pbase;
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX,
-                                    lower_32_bits(u64tmp));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_HIGH_IDX,
-                                    upper_32_bits(u64tmp));
-
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
-                                    lower_32_bits(fpdu_info->frags[0].physaddr));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_HIGH_IDX,
-                                    upper_32_bits(fpdu_info->frags[0].physaddr));
-
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG2_LOW_IDX,
-                                    lower_32_bits(fpdu_info->frags[1].physaddr));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG2_HIGH_IDX,
-                                    upper_32_bits(fpdu_info->frags[1].physaddr));
-
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG3_LOW_IDX,
-                                    lower_32_bits(fpdu_info->frags[2].physaddr));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG3_HIGH_IDX,
-                                    upper_32_bits(fpdu_info->frags[2].physaddr));
-
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG4_LOW_IDX,
-                                    lower_32_bits(fpdu_info->frags[3].physaddr));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_NIC_SQ_WQE_FRAG4_HIGH_IDX,
-                                    upper_32_bits(fpdu_info->frags[3].physaddr));
-
-                cqp_request->cqp_callback_pointer = fpdu_info;
-                cqp_request->callback = 1;
-                cqp_request->cqp_callback = nes_download_callback;
-
-                atomic_set(&cqp_request->refcount, 1);
-                nes_post_cqp_request(nesdev, cqp_request);
-                spin_unlock_irqrestore(&nesqp->pau_lock, flags);
-        }
-
-        return 0;
-}
-
-static void process_fpdus(struct nes_vnic *nesvnic, struct nes_qp *nesqp)
-{
-        int again = 1;
-        unsigned long flags;
-
-        do {
-                /* Ignore rc - if it failed, tcp retries will cause it to try again */
-                forward_fpdus(nesvnic, nesqp);
-
-                spin_lock_irqsave(&nesqp->pau_lock, flags);
-                if (nesqp->pau_pending) {
-                        nesqp->pau_pending = 0;
-                } else {
-                        nesqp->pau_busy = 0;
-                        again = 0;
-                }
-
-                spin_unlock_irqrestore(&nesqp->pau_lock, flags);
-        } while (again);
-}
-
-/**
- * queue_fpdus - Handle fpdu's that hw passed up to sw
- */
-static void queue_fpdus(struct sk_buff *skb, struct nes_vnic *nesvnic, struct nes_qp *nesqp)
-{
-        struct sk_buff *tmpskb;
-        struct nes_rskb_cb *cb;
-        struct iphdr *iph;
-        struct tcphdr *tcph;
-        unsigned char *tcph_end;
-        u32 rcv_nxt;
-        u32 rcv_wnd;
-        u32 seqnum;
-        u32 len;
-        bool process_it = false;
-        unsigned long flags;
-
-        /* Move data ptr to after tcp header */
-        iph = (struct iphdr *)skb->data;
-        tcph = (struct tcphdr *)(((char *)iph) + (4 * iph->ihl));
-        seqnum = be32_to_cpu(tcph->seq);
-        tcph_end = (((char *)tcph) + (4 * tcph->doff));
-
-        len = be16_to_cpu(iph->tot_len);
-        if (skb->len > len)
-                skb_trim(skb, len);
-        skb_pull(skb, tcph_end - skb->data);
-
-        /* Initialize tracking values */
-        cb = (struct nes_rskb_cb *)&skb->cb[0];
-        cb->seqnum = seqnum;
-
-        /* Make sure data is in the receive window */
-        rcv_nxt = nesqp->pau_rcv_nxt;
-        rcv_wnd = le32_to_cpu(nesqp->nesqp_context->rcv_wnd);
-        if (!between(seqnum, rcv_nxt, (rcv_nxt + rcv_wnd))) {
-                nes_mgt_free_skb(nesvnic->nesdev, skb, PCI_DMA_TODEVICE);
-                nes_rem_ref_cm_node(nesqp->cm_node);
-                return;
-        }
-
-        spin_lock_irqsave(&nesqp->pau_lock, flags);
-
-        if (nesqp->pau_busy)
-                nesqp->pau_pending = 1;
-        else
-                nesqp->pau_busy = 1;
-
-        /* Queue skb by sequence number */
-        if (skb_queue_len(&nesqp->pau_list) == 0) {
-                skb_queue_head(&nesqp->pau_list, skb);
-        } else {
-                tmpskb = nesqp->pau_list.next;
-                while (tmpskb != (struct sk_buff *)&nesqp->pau_list) {
-                        cb = (struct nes_rskb_cb *)&tmpskb->cb[0];
-                        if (before(seqnum, cb->seqnum))
-                                break;
-                        tmpskb = tmpskb->next;
-                }
-                skb_insert(tmpskb, skb, &nesqp->pau_list);
-        }
-        if (nesqp->pau_state == PAU_READY)
-                process_it = true;
-        spin_unlock_irqrestore(&nesqp->pau_lock, flags);
-
-        if (process_it)
-                process_fpdus(nesvnic, nesqp);
-
-        return;
-}
-
-/**
- * mgt_thread - Handle mgt skbs in a safe context
- */
-static int mgt_thread(void *context)
-{
-        struct nes_vnic *nesvnic = context;
-        struct sk_buff *skb;
-        struct nes_rskb_cb *cb;
-
-        while (!kthread_should_stop()) {
-                wait_event_interruptible(nesvnic->mgt_wait_queue,
-                                         skb_queue_len(&nesvnic->mgt_skb_list) || kthread_should_stop());
-                while ((skb_queue_len(&nesvnic->mgt_skb_list)) && !kthread_should_stop()) {
-                        skb = skb_dequeue(&nesvnic->mgt_skb_list);
-                        cb = (struct nes_rskb_cb *)&skb->cb[0];
-                        cb->data_start = skb->data - ETH_HLEN;
-                        cb->busaddr = pci_map_single(nesvnic->nesdev->pcidev, cb->data_start,
-                                                     nesvnic->max_frame_size, PCI_DMA_TODEVICE);
-                        queue_fpdus(skb, nesvnic, cb->nesqp);
-                }
-        }
-
-        /* Closing down so delete any entries on the queue */
-        while (skb_queue_len(&nesvnic->mgt_skb_list)) {
-                skb = skb_dequeue(&nesvnic->mgt_skb_list);
-                cb = (struct nes_rskb_cb *)&skb->cb[0];
-                nes_rem_ref_cm_node(cb->nesqp->cm_node);
-                dev_kfree_skb_any(skb);
-        }
-        return 0;
-}
-
-/**
- * nes_queue_skbs - Queue skb so it can be handled in a thread context
- */
-void nes_queue_mgt_skbs(struct sk_buff *skb, struct nes_vnic *nesvnic, struct nes_qp *nesqp)
-{
-        struct nes_rskb_cb *cb;
-
-        cb = (struct nes_rskb_cb *)&skb->cb[0];
-        cb->nesqp = nesqp;
-        skb_queue_tail(&nesvnic->mgt_skb_list, skb);
-        wake_up_interruptible(&nesvnic->mgt_wait_queue);
-}
-
-void nes_destroy_pau_qp(struct nes_device *nesdev, struct nes_qp *nesqp)
-{
-        struct sk_buff *skb;
-        unsigned long flags;
-        atomic_inc(&pau_qps_destroyed);
-
-        /* Free packets that have not yet been forwarded */
-        /* Lock is acquired by skb_dequeue when removing the skb */
-        spin_lock_irqsave(&nesqp->pau_lock, flags);
-        while (skb_queue_len(&nesqp->pau_list)) {
-                skb = skb_dequeue(&nesqp->pau_list);
-                nes_mgt_free_skb(nesdev, skb, PCI_DMA_TODEVICE);
-                nes_rem_ref_cm_node(nesqp->cm_node);
-        }
-        spin_unlock_irqrestore(&nesqp->pau_lock, flags);
-}
-
-static void nes_chg_qh_handler(struct nes_device *nesdev, struct nes_cqp_request *cqp_request)
-{
-        struct pau_qh_chg *qh_chg = cqp_request->cqp_callback_pointer;
-        struct nes_cqp_request *new_request;
-        struct nes_hw_cqp_wqe *cqp_wqe;
-        struct nes_adapter *nesadapter;
-        struct nes_qp *nesqp;
-        struct nes_v4_quad nes_quad;
-        u32 crc_value;
-        u64 u64temp;
-
-        nesadapter = nesdev->nesadapter;
-        nesqp = qh_chg->nesqp;
-
-        /* Should we handle the bad completion */
-        if (cqp_request->major_code)
-                WARN(1, PFX "Invalid cqp_request major_code=0x%x\n",
-                       cqp_request->major_code);
-
-        switch (nesqp->pau_state) {
-        case PAU_DEL_QH:
-                /* Old hash code deleted, now set the new one */
-                nesqp->pau_state = PAU_ADD_LB_QH;
-                new_request = nes_get_cqp_request(nesdev);
-                if (new_request == NULL) {
-                        nes_debug(NES_DBG_PAU, "Failed to get a new_request.\n");
-                        WARN_ON(1);
-                        return;
-                }
-
-                memset(&nes_quad, 0, sizeof(nes_quad));
-                nes_quad.DstIpAdrIndex =
-                        cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24);
-                nes_quad.SrcIpadr = cpu_to_be32(0x7f000001);
-                nes_quad.TcpPorts[0] = swab16(nesqp->nesqp_context->tcpPorts[1]);
-                nes_quad.TcpPorts[1] = swab16(nesqp->nesqp_context->tcpPorts[0]);
-
-                /* Produce hash key */
-                crc_value = get_crc_value(&nes_quad);
-                nesqp->hte_index = cpu_to_be32(crc_value ^ 0xffffffff);
-                nes_debug(NES_DBG_PAU, "new HTE Index = 0x%08X, CRC = 0x%08X\n",
-                          nesqp->hte_index, nesqp->hte_index & nesadapter->hte_index_mask);
-
-                nesqp->hte_index &= nesadapter->hte_index_mask;
-                nesqp->nesqp_context->hte_index = cpu_to_le32(nesqp->hte_index);
-                nesqp->nesqp_context->ip0 = cpu_to_le32(0x7f000001);
-                nesqp->nesqp_context->rcv_nxt = cpu_to_le32(nesqp->pau_rcv_nxt);
-
-                cqp_wqe = &new_request->cqp_wqe;
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-                set_wqe_32bit_value(cqp_wqe->wqe_words,
-                                    NES_CQP_WQE_OPCODE_IDX, NES_CQP_MANAGE_QUAD_HASH |
-                                    NES_CQP_QP_TYPE_IWARP | NES_CQP_QP_CONTEXT_VALID | NES_CQP_QP_IWARP_STATE_RTS);
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX, nesqp->hwqp.qp_id);
-                u64temp = (u64)nesqp->nesqp_context_pbase;
-                set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_QP_WQE_CONTEXT_LOW_IDX, u64temp);
-
-                nes_debug(NES_DBG_PAU, "Waiting for CQP completion for adding the quad hash.\n");
-
-                new_request->cqp_callback_pointer = qh_chg;
-                new_request->callback = 1;
-                new_request->cqp_callback = nes_chg_qh_handler;
-                atomic_set(&new_request->refcount, 1);
-                nes_post_cqp_request(nesdev, new_request);
-                break;
-
-        case PAU_ADD_LB_QH:
-                /* Start processing the queued fpdu's */
-                nesqp->pau_state = PAU_READY;
-                process_fpdus(qh_chg->nesvnic, qh_chg->nesqp);
-                kfree(qh_chg);
-                break;
-        }
-}
-
-/**
- * nes_change_quad_hash
- */
-static int nes_change_quad_hash(struct nes_device *nesdev,
-                                struct nes_vnic *nesvnic, struct nes_qp *nesqp)
-{
-        struct nes_cqp_request *cqp_request = NULL;
-        struct pau_qh_chg *qh_chg = NULL;
-        u64 u64temp;
-        struct nes_hw_cqp_wqe *cqp_wqe;
-        int ret = 0;
-
-        cqp_request = nes_get_cqp_request(nesdev);
-        if (cqp_request == NULL) {
-                nes_debug(NES_DBG_PAU, "Failed to get a cqp_request.\n");
-                ret = -ENOMEM;
-                goto chg_qh_err;
-        }
-
-        qh_chg = kmalloc(sizeof *qh_chg, GFP_ATOMIC);
-        if (qh_chg == NULL) {
-                nes_debug(NES_DBG_PAU, "Failed to get a cqp_request.\n");
-                ret = -ENOMEM;
-                goto chg_qh_err;
-        }
-        qh_chg->nesdev = nesdev;
-        qh_chg->nesvnic = nesvnic;
-        qh_chg->nesqp = nesqp;
-        nesqp->pau_state = PAU_DEL_QH;
-
-        cqp_wqe = &cqp_request->cqp_wqe;
-        nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-        set_wqe_32bit_value(cqp_wqe->wqe_words,
-                            NES_CQP_WQE_OPCODE_IDX, NES_CQP_MANAGE_QUAD_HASH | NES_CQP_QP_DEL_HTE |
-                            NES_CQP_QP_TYPE_IWARP | NES_CQP_QP_CONTEXT_VALID | NES_CQP_QP_IWARP_STATE_RTS);
-        set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX, nesqp->hwqp.qp_id);
-        u64temp = (u64)nesqp->nesqp_context_pbase;
-        set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_QP_WQE_CONTEXT_LOW_IDX, u64temp);
-
-        nes_debug(NES_DBG_PAU, "Waiting for CQP completion for deleting the quad hash.\n");
-
-        cqp_request->cqp_callback_pointer = qh_chg;
-        cqp_request->callback = 1;
-        cqp_request->cqp_callback = nes_chg_qh_handler;
-        atomic_set(&cqp_request->refcount, 1);
-        nes_post_cqp_request(nesdev, cqp_request);
-
-        return ret;
-
-chg_qh_err:
-        kfree(qh_chg);
-        if (cqp_request)
-                nes_put_cqp_request(nesdev, cqp_request);
-        return ret;
-}
-
-/**
- * nes_mgt_ce_handler
- * This management code deals with any packed and unaligned (pau) fpdu's
- * that the hardware cannot handle.
- */
-static void nes_mgt_ce_handler(struct nes_device *nesdev, struct nes_hw_nic_cq *cq)
-{
-        struct nes_vnic_mgt *mgtvnic = container_of(cq, struct nes_vnic_mgt, mgt_cq);
-        struct nes_adapter *nesadapter = nesdev->nesadapter;
-        u32 head;
-        u32 cq_size;
-        u32 cqe_count = 0;
-        u32 cqe_misc;
-        u32 qp_id = 0;
-        u32 skbs_needed;
-        unsigned long context;
-        struct nes_qp *nesqp;
-        struct sk_buff *rx_skb;
-        struct nes_rskb_cb *cb;
-
-        head = cq->cq_head;
-        cq_size = cq->cq_size;
-
-        while (1) {
-                cqe_misc = le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_NIC_CQE_MISC_IDX]);
-                if (!(cqe_misc & NES_NIC_CQE_VALID))
-                        break;
-
-                nesqp = NULL;
-                if (cqe_misc & NES_NIC_CQE_ACCQP_VALID) {
-                        qp_id = le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_NIC_CQE_ACCQP_ID_IDX]);
-                        qp_id &= 0x001fffff;
-                        if (qp_id < nesadapter->max_qp) {
-                                context = (unsigned long)nesadapter->qp_table[qp_id - NES_FIRST_QPN];
-                                nesqp = (struct nes_qp *)context;
-                        }
-                }
-
-                if (nesqp) {
-                        if (nesqp->pau_mode == false) {
-                                nesqp->pau_mode = true; /* First time for this qp */
-                                nesqp->pau_rcv_nxt = le32_to_cpu(
-                                        cq->cq_vbase[head].cqe_words[NES_NIC_CQE_HASH_RCVNXT]);
-                                skb_queue_head_init(&nesqp->pau_list);
-                                spin_lock_init(&nesqp->pau_lock);
-                                atomic_inc(&pau_qps_created);
-                                nes_change_quad_hash(nesdev, mgtvnic->nesvnic, nesqp);
-                        }
-
-                        rx_skb = mgtvnic->mgt.rx_skb[mgtvnic->mgt.rq_tail];
-                        rx_skb->len = 0;
-                        skb_put(rx_skb, cqe_misc & 0x0000ffff);
-                        rx_skb->protocol = eth_type_trans(rx_skb, mgtvnic->nesvnic->netdev);
-                        cb = (struct nes_rskb_cb *)&rx_skb->cb[0];
-                        pci_unmap_single(nesdev->pcidev, cb->busaddr, cb->maplen, PCI_DMA_FROMDEVICE);
-                        cb->busaddr = 0;
-                        mgtvnic->mgt.rq_tail++;
-                        mgtvnic->mgt.rq_tail &= mgtvnic->mgt.rq_size - 1;
-
-                        nes_add_ref_cm_node(nesqp->cm_node);
-                        nes_queue_mgt_skbs(rx_skb, mgtvnic->nesvnic, nesqp);
-                } else {
-                        printk(KERN_ERR PFX "Invalid QP %d for packed/unaligned handling\n", qp_id);
-                }
-
-                cq->cq_vbase[head].cqe_words[NES_NIC_CQE_MISC_IDX] = 0;
-                cqe_count++;
-                if (++head >= cq_size)
-                        head = 0;
-
-                if (cqe_count == 255) {
-                        /* Replenish mgt CQ */
-                        nes_write32(nesdev->regs + NES_CQE_ALLOC, cq->cq_number | (cqe_count << 16));
-                        nesdev->currcq_count += cqe_count;
-                        cqe_count = 0;
-                }
-
-                skbs_needed = atomic_inc_return(&mgtvnic->rx_skbs_needed);
-                if (skbs_needed > (mgtvnic->mgt.rq_size >> 1))
-                        nes_replenish_mgt_rq(mgtvnic);
-        }
-
-        cq->cq_head = head;
-        nes_write32(nesdev->regs + NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
-                    cq->cq_number | (cqe_count << 16));
-        nes_read32(nesdev->regs + NES_CQE_ALLOC);
-        nesdev->currcq_count += cqe_count;
-}
-
-/**
- * nes_init_mgt_qp
- */
-int nes_init_mgt_qp(struct nes_device *nesdev, struct net_device *netdev, struct nes_vnic *nesvnic)
-{
-        struct nes_vnic_mgt *mgtvnic;
-        u32 counter;
-        void *vmem;
-        dma_addr_t pmem;
-        struct nes_hw_cqp_wqe *cqp_wqe;
-        u32 cqp_head;
-        unsigned long flags;
-        struct nes_hw_nic_qp_context *mgt_context;
-        u64 u64temp;
-        struct nes_hw_nic_rq_wqe *mgt_rqe;
-        struct sk_buff *skb;
-        u32 wqe_count;
-        struct nes_rskb_cb *cb;
-        u32 mgt_mem_size;
-        void *mgt_vbase;
-        dma_addr_t mgt_pbase;
-        int i;
-        int ret;
-
-        /* Allocate space the all mgt QPs once */
-        mgtvnic = kzalloc(NES_MGT_QP_COUNT * sizeof(struct nes_vnic_mgt), GFP_KERNEL);
-        if (mgtvnic == NULL) {
-                nes_debug(NES_DBG_INIT, "Unable to allocate memory for mgt structure\n");
-                return -ENOMEM;
-        }
-
-        /* Allocate fragment, RQ, and CQ; Reuse CEQ based on the PCI function */
-        /* We are not sending from this NIC so sq is not allocated */
-        mgt_mem_size = 256 +
-                       (NES_MGT_WQ_COUNT * sizeof(struct nes_hw_nic_rq_wqe)) +
-                       (NES_MGT_WQ_COUNT * sizeof(struct nes_hw_nic_cqe)) +
-                       sizeof(struct nes_hw_nic_qp_context);
-        mgt_mem_size = (mgt_mem_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
-        mgt_vbase = pci_alloc_consistent(nesdev->pcidev, NES_MGT_QP_COUNT * mgt_mem_size, &mgt_pbase);
-        if (!mgt_vbase) {
-                kfree(mgtvnic);
-                nes_debug(NES_DBG_INIT, "Unable to allocate memory for mgt host descriptor rings\n");
-                return -ENOMEM;
-        }
-
-        nesvnic->mgt_mem_size = NES_MGT_QP_COUNT * mgt_mem_size;
-        nesvnic->mgt_vbase = mgt_vbase;
-        nesvnic->mgt_pbase = mgt_pbase;
-
-        skb_queue_head_init(&nesvnic->mgt_skb_list);
-        init_waitqueue_head(&nesvnic->mgt_wait_queue);
-        nesvnic->mgt_thread = kthread_run(mgt_thread, nesvnic, "nes_mgt_thread");
-
-        for (i = 0; i < NES_MGT_QP_COUNT; i++) {
-                mgtvnic->nesvnic = nesvnic;
-                mgtvnic->mgt.qp_id = nesdev->mac_index + NES_MGT_QP_OFFSET + i;
-                memset(mgt_vbase, 0, mgt_mem_size);
-                nes_debug(NES_DBG_INIT, "Allocated mgt QP structures at %p (phys = %016lX), size = %u.\n",
-                          mgt_vbase, (unsigned long)mgt_pbase, mgt_mem_size);
-
-                vmem = (void *)(((unsigned long)mgt_vbase + (256 - 1)) &
-                                ~(unsigned long)(256 - 1));
-                pmem = (dma_addr_t)(((unsigned long long)mgt_pbase + (256 - 1)) &
-                                    ~(unsigned long long)(256 - 1));
-
-                spin_lock_init(&mgtvnic->mgt.rq_lock);
-
-                /* setup the RQ */
-                mgtvnic->mgt.rq_vbase = vmem;
-                mgtvnic->mgt.rq_pbase = pmem;
-                mgtvnic->mgt.rq_head = 0;
-                mgtvnic->mgt.rq_tail = 0;
-                mgtvnic->mgt.rq_size = NES_MGT_WQ_COUNT;
-
-                /* setup the CQ */
-                vmem += (NES_MGT_WQ_COUNT * sizeof(struct nes_hw_nic_rq_wqe));
-                pmem += (NES_MGT_WQ_COUNT * sizeof(struct nes_hw_nic_rq_wqe));
-
-                mgtvnic->mgt_cq.cq_number = mgtvnic->mgt.qp_id;
-                mgtvnic->mgt_cq.cq_vbase = vmem;
-                mgtvnic->mgt_cq.cq_pbase = pmem;
-                mgtvnic->mgt_cq.cq_head = 0;
-                mgtvnic->mgt_cq.cq_size = NES_MGT_WQ_COUNT;
-
-                mgtvnic->mgt_cq.ce_handler = nes_mgt_ce_handler;
-
-                /* Send CreateCQ request to CQP */
-                spin_lock_irqsave(&nesdev->cqp.lock, flags);
-                cqp_head = nesdev->cqp.sq_head;
-
-                cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-
-                cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] = cpu_to_le32(
-                        NES_CQP_CREATE_CQ | NES_CQP_CQ_CEQ_VALID |
-                        ((u32)mgtvnic->mgt_cq.cq_size << 16));
-                cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(
-                        mgtvnic->mgt_cq.cq_number | ((u32)nesdev->ceq_index << 16));
-                u64temp = (u64)mgtvnic->mgt_cq.cq_pbase;
-                set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_CQ_WQE_PBL_LOW_IDX, u64temp);
-                cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_HIGH_IDX] = 0;
-                u64temp = (unsigned long)&mgtvnic->mgt_cq;
-                cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_LOW_IDX] = cpu_to_le32((u32)(u64temp >> 1));
-                cqp_wqe->wqe_words[NES_CQP_CQ_WQE_CQ_CONTEXT_HIGH_IDX] =
-                        cpu_to_le32(((u32)((u64temp) >> 33)) & 0x7FFFFFFF);
-                cqp_wqe->wqe_words[NES_CQP_CQ_WQE_DOORBELL_INDEX_HIGH_IDX] = 0;
-
-                if (++cqp_head >= nesdev->cqp.sq_size)
-                        cqp_head = 0;
-                cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-
-                /* Send CreateQP request to CQP */
-                mgt_context = (void *)(&mgtvnic->mgt_cq.cq_vbase[mgtvnic->mgt_cq.cq_size]);
-                mgt_context->context_words[NES_NIC_CTX_MISC_IDX] =
-                        cpu_to_le32((u32)NES_MGT_CTX_SIZE |
-                                    ((u32)PCI_FUNC(nesdev->pcidev->devfn) << 12));
-                nes_debug(NES_DBG_INIT, "RX_WINDOW_BUFFER_PAGE_TABLE_SIZE = 0x%08X, RX_WINDOW_BUFFER_SIZE = 0x%08X\n",
-                          nes_read_indexed(nesdev, NES_IDX_RX_WINDOW_BUFFER_PAGE_TABLE_SIZE),
-                          nes_read_indexed(nesdev, NES_IDX_RX_WINDOW_BUFFER_SIZE));
-                if (nes_read_indexed(nesdev, NES_IDX_RX_WINDOW_BUFFER_SIZE) != 0)
-                        mgt_context->context_words[NES_NIC_CTX_MISC_IDX] |= cpu_to_le32(NES_NIC_BACK_STORE);
-
-                u64temp = (u64)mgtvnic->mgt.rq_pbase;
-                mgt_context->context_words[NES_NIC_CTX_SQ_LOW_IDX] = cpu_to_le32((u32)u64temp);
-                mgt_context->context_words[NES_NIC_CTX_SQ_HIGH_IDX] = cpu_to_le32((u32)(u64temp >> 32));
-                u64temp = (u64)mgtvnic->mgt.rq_pbase;
-                mgt_context->context_words[NES_NIC_CTX_RQ_LOW_IDX] = cpu_to_le32((u32)u64temp);
-                mgt_context->context_words[NES_NIC_CTX_RQ_HIGH_IDX] = cpu_to_le32((u32)(u64temp >> 32));
-
-                cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] = cpu_to_le32(NES_CQP_CREATE_QP |
-                                                                         NES_CQP_QP_TYPE_NIC);
-                cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(mgtvnic->mgt.qp_id);
-                u64temp = (u64)mgtvnic->mgt_cq.cq_pbase +
-                          (mgtvnic->mgt_cq.cq_size * sizeof(struct nes_hw_nic_cqe));
-                set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_QP_WQE_CONTEXT_LOW_IDX, u64temp);
-
-                if (++cqp_head >= nesdev->cqp.sq_size)
-                        cqp_head = 0;
-                nesdev->cqp.sq_head = cqp_head;
-
-                barrier();
-
-                /* Ring doorbell (2 WQEs) */
-                nes_write32(nesdev->regs + NES_WQE_ALLOC, 0x02800000 | nesdev->cqp.qp_id);
-
-                spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
-                nes_debug(NES_DBG_INIT, "Waiting for create MGT QP%u to complete.\n",
-                          mgtvnic->mgt.qp_id);
-
-                ret = wait_event_timeout(nesdev->cqp.waitq, (nesdev->cqp.sq_tail == cqp_head),
-                                         NES_EVENT_TIMEOUT);
-                nes_debug(NES_DBG_INIT, "Create MGT QP%u completed, wait_event_timeout ret = %u.\n",
-                          mgtvnic->mgt.qp_id, ret);
-                if (!ret) {
-                        nes_debug(NES_DBG_INIT, "MGT QP%u create timeout expired\n", mgtvnic->mgt.qp_id);
-                        if (i == 0) {
-                                pci_free_consistent(nesdev->pcidev, nesvnic->mgt_mem_size, nesvnic->mgt_vbase,
-                                                    nesvnic->mgt_pbase);
-                                kfree(mgtvnic);
-                        } else {
-                                nes_destroy_mgt(nesvnic);
-                        }
-                        return -EIO;
-                }
-
-                /* Populate the RQ */
-                for (counter = 0; counter < (NES_MGT_WQ_COUNT - 1); counter++) {
-                        skb = dev_alloc_skb(nesvnic->max_frame_size);
-                        if (!skb) {
-                                nes_debug(NES_DBG_INIT, "%s: out of memory for receive skb\n", netdev->name);
-                                return -ENOMEM;
-                        }
-
-                        skb->dev = netdev;
-
-                        pmem = pci_map_single(nesdev->pcidev, skb->data,
-                                              nesvnic->max_frame_size, PCI_DMA_FROMDEVICE);
-                        cb = (struct nes_rskb_cb *)&skb->cb[0];
-                        cb->busaddr = pmem;
-                        cb->maplen = nesvnic->max_frame_size;
-
-                        mgt_rqe = &mgtvnic->mgt.rq_vbase[counter];
-                        mgt_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX] = cpu_to_le32((u32)nesvnic->max_frame_size);
-                        mgt_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_3_2_IDX] = 0;
-                        mgt_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_LOW_IDX] = cpu_to_le32((u32)pmem);
-                        mgt_rqe->wqe_words[NES_NIC_RQ_WQE_FRAG0_HIGH_IDX] = cpu_to_le32((u32)((u64)pmem >> 32));
-                        mgtvnic->mgt.rx_skb[counter] = skb;
-                }
-
-                init_timer(&mgtvnic->rq_wqes_timer);
-                mgtvnic->rq_wqes_timer.function = nes_mgt_rq_wqes_timeout;
-                mgtvnic->rq_wqes_timer.data = (unsigned long)mgtvnic;
-
-                wqe_count = NES_MGT_WQ_COUNT - 1;
-                mgtvnic->mgt.rq_head = wqe_count;
-                barrier();
-                do {
-                        counter = min(wqe_count, ((u32)255));
-                        wqe_count -= counter;
-                        nes_write32(nesdev->regs + NES_WQE_ALLOC, (counter << 24) | mgtvnic->mgt.qp_id);
-                } while (wqe_count);
-
-                nes_write32(nesdev->regs + NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
-                            mgtvnic->mgt_cq.cq_number);
-                nes_read32(nesdev->regs + NES_CQE_ALLOC);
-
-                mgt_vbase += mgt_mem_size;
-                mgt_pbase += mgt_mem_size;
-                nesvnic->mgtvnic[i] = mgtvnic++;
-        }
-        return 0;
-}
-
-
-void nes_destroy_mgt(struct nes_vnic *nesvnic)
-{
-        struct nes_device *nesdev = nesvnic->nesdev;
-        struct nes_vnic_mgt *mgtvnic;
-        struct nes_vnic_mgt *first_mgtvnic;
-        unsigned long flags;
-        struct nes_hw_cqp_wqe *cqp_wqe;
-        u32 cqp_head;
-        struct sk_buff *rx_skb;
-        int i;
-        int ret;
-
-        kthread_stop(nesvnic->mgt_thread);
-
-        /* Free remaining NIC receive buffers */
-        first_mgtvnic = nesvnic->mgtvnic[0];
-        for (i = 0; i < NES_MGT_QP_COUNT; i++) {
-                mgtvnic = nesvnic->mgtvnic[i];
-                if (mgtvnic == NULL)
-                        continue;
-
-                while (mgtvnic->mgt.rq_head != mgtvnic->mgt.rq_tail) {
-                        rx_skb = mgtvnic->mgt.rx_skb[mgtvnic->mgt.rq_tail];
-                        nes_mgt_free_skb(nesdev, rx_skb, PCI_DMA_FROMDEVICE);
-                        mgtvnic->mgt.rq_tail++;
-                        mgtvnic->mgt.rq_tail &= (mgtvnic->mgt.rq_size - 1);
-                }
-
-                spin_lock_irqsave(&nesdev->cqp.lock, flags);
-
-                /* Destroy NIC QP */
-                cqp_head = nesdev->cqp.sq_head;
-                cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX,
-                                    (NES_CQP_DESTROY_QP | NES_CQP_QP_TYPE_NIC));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX,
-                                    mgtvnic->mgt.qp_id);
-
-                if (++cqp_head >= nesdev->cqp.sq_size)
-                        cqp_head = 0;
-
-                cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
-
-                /* Destroy NIC CQ */
-                nes_fill_init_cqp_wqe(cqp_wqe, nesdev);
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_OPCODE_IDX,
-                                    (NES_CQP_DESTROY_CQ | ((u32)mgtvnic->mgt_cq.cq_size << 16)));
-                set_wqe_32bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_ID_IDX,
-                                    (mgtvnic->mgt_cq.cq_number | ((u32)nesdev->ceq_index << 16)));
-
-                if (++cqp_head >= nesdev->cqp.sq_size)
-                        cqp_head = 0;
-
-                nesdev->cqp.sq_head = cqp_head;
-                barrier();
-
-                /* Ring doorbell (2 WQEs) */
-                nes_write32(nesdev->regs + NES_WQE_ALLOC, 0x02800000 | nesdev->cqp.qp_id);
-
-                spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
-                nes_debug(NES_DBG_SHUTDOWN, "Waiting for CQP, cqp_head=%u, cqp.sq_head=%u,"
-                          " cqp.sq_tail=%u, cqp.sq_size=%u\n",
-                          cqp_head, nesdev->cqp.sq_head,
-                          nesdev->cqp.sq_tail, nesdev->cqp.sq_size);
-
-                ret = wait_event_timeout(nesdev->cqp.waitq, (nesdev->cqp.sq_tail == cqp_head),
-                                         NES_EVENT_TIMEOUT);
-
-                nes_debug(NES_DBG_SHUTDOWN, "Destroy MGT QP returned, wait_event_timeout ret = %u, cqp_head=%u,"
-                          " cqp.sq_head=%u, cqp.sq_tail=%u\n",
-                          ret, cqp_head, nesdev->cqp.sq_head, nesdev->cqp.sq_tail);
-                if (!ret)
-                        nes_debug(NES_DBG_SHUTDOWN, "MGT QP%u destroy timeout expired\n",
-                                  mgtvnic->mgt.qp_id);
-
-                nesvnic->mgtvnic[i] = NULL;
-        }
-
-        if (nesvnic->mgt_vbase) {
-                pci_free_consistent(nesdev->pcidev, nesvnic->mgt_mem_size, nesvnic->mgt_vbase,
-                                    nesvnic->mgt_pbase);
-                nesvnic->mgt_vbase = NULL;
-                nesvnic->mgt_pbase = 0;
-        }
-
-        kfree(first_mgtvnic);
-}
diff --git a/drivers/infiniband/hw/nes/nes_mgt.h b/drivers/infiniband/hw/nes/nes_mgt.h
deleted file mode 100644
index 4f7f701c4a8..00000000000
--- a/drivers/infiniband/hw/nes/nes_mgt.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-* Copyright (c) 2006 - 2011 Intel-NE, 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.
-*/
-
-#ifndef __NES_MGT_H
-#define __NES_MGT_H
-
-#define MPA_FRAMING 6   /* length is 2 bytes, crc is 4 bytes */
-
-int nes_init_mgt_qp(struct nes_device *nesdev, struct net_device *netdev, struct nes_vnic *nesvnic);
-void nes_queue_mgt_skbs(struct sk_buff *skb, struct nes_vnic *nesvnic, struct nes_qp *nesqp);
-void nes_destroy_mgt(struct nes_vnic *nesvnic);
-void nes_destroy_pau_qp(struct nes_device *nesdev, struct nes_qp *nesqp);
-
-struct nes_hw_mgt {
-        struct nes_hw_nic_rq_wqe *rq_vbase;     /* virtual address of rq */
-        dma_addr_t rq_pbase;                    /* PCI memory for host rings */
-        struct sk_buff *rx_skb[NES_NIC_WQ_SIZE];
-        u16 qp_id;
-        u16 sq_head;
-        u16 rq_head;
-        u16 rq_tail;
-        u16 rq_size;
-        u8 replenishing_rq;
-        u8 reserved;
-        spinlock_t rq_lock;
-};
-
-struct nes_vnic_mgt {
-        struct nes_vnic        *nesvnic;
-        struct nes_hw_mgt      mgt;
-        struct nes_hw_nic_cq   mgt_cq;
-        atomic_t               rx_skbs_needed;
-        struct timer_list      rq_wqes_timer;
-        atomic_t               rx_skb_timer_running;
-};
-
-#define MAX_FPDU_FRAGS 4
-struct pau_fpdu_frag {
-        struct sk_buff         *skb;
-        u64                    physaddr;
-        u32                    frag_len;
-        bool                   cmplt;
-};
-
-struct pau_fpdu_info {
-        struct nes_qp          *nesqp;
-        struct nes_cqp_request *cqp_request;
-        void                   *hdr_vbase;
-        dma_addr_t             hdr_pbase;
-        int                    hdr_len;
-        u16                    data_len;
-        u16                    frag_cnt;
-        struct pau_fpdu_frag   frags[MAX_FPDU_FRAGS];
-};
-
-enum pau_qh_state {
-        PAU_DEL_QH,
-        PAU_ADD_LB_QH,
-        PAU_READY
-};
-
-struct pau_qh_chg {
-        struct nes_device *nesdev;
-        struct nes_vnic *nesvnic;
-        struct nes_qp *nesqp;
-};
-
-#endif          /* __NES_MGT_H */
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index 9542e1644a5..9d7ffebff21 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -243,9 +243,10 @@ static int nes_netdev_open(struct net_device *netdev)
 
         spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
         if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_SFP_D) {
+                if (nesdev->link_recheck)
+                        cancel_delayed_work(&nesdev->work);
                 nesdev->link_recheck = 1;
-                mod_delayed_work(system_wq, &nesdev->work,
-                                 NES_LINK_RECHECK_DELAY);
+                schedule_delayed_work(&nesdev->work, NES_LINK_RECHECK_DELAY);
         }
         spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
 
@@ -384,20 +385,24 @@ static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
         /* bump past the vlan tag */
         wqe_fragment_length++;
         /*      wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
-        wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                if (skb_is_gso(skb)) {
-                        tcph = tcp_hdr(skb);
-                        /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... is_gso = %u seg size = %u\n",
-                                        netdev->name, skb_is_gso(skb), skb_shinfo(skb)->gso_size); */
-                        wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE | (u16)skb_shinfo(skb)->gso_size;
-                        set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
-                                        ((u32)tcph->doff) |
-                                        (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
+                tcph = tcp_hdr(skb);
+                if (1) {
+                        if (skb_is_gso(skb)) {
+                                /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
+                                                netdev->name, skb_is_gso(skb)); */
+                                wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE |
+                                                NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
+                                set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
+                                                ((u32)tcph->doff) |
+                                                (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
+                        } else {
+                                wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
+                        }
                 }
         } else {        /* CHECKSUM_HW */
-                wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
+                wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
         }
 
         set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
@@ -436,13 +441,13 @@ static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
                 nesnic->tx_skb[nesnic->sq_head] = skb;
                 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
                                 skb_fragment_index++) {
-                        skb_frag_t *frag =
-                                &skb_shinfo(skb)->frags[skb_fragment_index];
-                        bus_address = skb_frag_dma_map(&nesdev->pcidev->dev,
-                                                       frag, 0, skb_frag_size(frag),
-                                                       DMA_TO_DEVICE);
+                        bus_address = pci_map_page( nesdev->pcidev,
+                                        skb_shinfo(skb)->frags[skb_fragment_index].page,
+                                        skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
+                                        skb_shinfo(skb)->frags[skb_fragment_index].size,
+                                        PCI_DMA_TODEVICE);
                         wqe_fragment_length[wqe_fragment_index] =
-                                        cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[skb_fragment_index]));
+                                        cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
                         set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
                                 bus_address);
                         wqe_fragment_index++;
@@ -556,12 +561,11 @@ tso_sq_no_longer_full:
                         /* Map all the buffers */
                         for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
                                         tso_frag_count++) {
-                                skb_frag_t *frag =
-                                        &skb_shinfo(skb)->frags[tso_frag_count];
-                                tso_bus_address[tso_frag_count] =
-                                        skb_frag_dma_map(&nesdev->pcidev->dev,
-                                                         frag, 0, skb_frag_size(frag),
-                                                         DMA_TO_DEVICE);
+                                tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
+                                                skb_shinfo(skb)->frags[tso_frag_count].page,
+                                                skb_shinfo(skb)->frags[tso_frag_count].page_offset,
+                                                skb_shinfo(skb)->frags[tso_frag_count].size,
+                                                PCI_DMA_TODEVICE);
                         }
 
                         tso_frag_index = 0;
@@ -592,10 +596,10 @@ tso_sq_no_longer_full:
                                         nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
                                                         original_first_length, NES_FIRST_FRAG_SIZE);
                                         nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
-                                                        " (%u frags), is_gso = %u tso_size=%u\n",
+                                                        " (%u frags), tso_size=%u\n",
                                                         netdev->name,
                                                         skb->len, skb_headlen(skb),
-                                                        skb_shinfo(skb)->nr_frags, skb_is_gso(skb), skb_shinfo(skb)->gso_size);
+                                                        skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
                                 }
                                 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
                                                 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
@@ -632,11 +636,11 @@ tso_sq_no_longer_full:
                                 }
                                 while (wqe_fragment_index < 5) {
                                         wqe_fragment_length[wqe_fragment_index] =
-                                                        cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index]));
+                                                        cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
                                         set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
                                                 (u64)tso_bus_address[tso_frag_index]);
                                         wqe_fragment_index++;
-                                        tso_wqe_length += skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index++]);
+                                        tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
                                         if (wqe_fragment_index < 5)
                                                 wqe_fragment_length[wqe_fragment_index] = 0;
                                         if (tso_frag_index == tso_frag_count)
@@ -647,8 +651,8 @@ tso_sq_no_longer_full:
                                 } else {
                                         nesnic->tx_skb[nesnic->sq_head] = NULL;
                                 }
-                                wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_shinfo(skb)->gso_size;
-                                if ((tso_wqe_length + original_first_length) > skb_shinfo(skb)->gso_size) {
+                                wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
+                                if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
                                         wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
                                 } else {
                                         iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
@@ -944,13 +948,12 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
                                           addr,
                                           perfect_filter_register_address+(mc_index * 8),
                                           mc_nic_index);
-                                macaddr_high  = ((u8) addr[0]) << 8;
-                                macaddr_high += (u8) addr[1];
-                                macaddr_low   = ((u8) addr[2]) << 24;
-                                macaddr_low  += ((u8) addr[3]) << 16;
-                                macaddr_low  += ((u8) addr[4]) << 8;
-                                macaddr_low  += (u8) addr[5];
-
+                                macaddr_high  = ((u16) addr[0]) << 8;
+                                macaddr_high += (u16) addr[1];
+                                macaddr_low   = ((u32) addr[2]) << 24;
+                                macaddr_low  += ((u32) addr[3]) << 16;
+                                macaddr_low  += ((u32) addr[4]) << 8;
+                                macaddr_low  += (u32) addr[5];
                                 nes_write_indexed(nesdev,
                                                 perfect_filter_register_address+(mc_index * 8),
                                                 macaddr_low);
@@ -1087,8 +1090,6 @@ static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
         "LRO aggregated",
         "LRO flushed",
         "LRO no_desc",
-        "PAU CreateQPs",
-        "PAU DestroyQPs",
 };
 #define NES_ETHTOOL_STAT_COUNT  ARRAY_SIZE(nes_ethtool_stringset)
 
@@ -1304,8 +1305,6 @@ static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
         target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
         target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
         target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
-        target_stat_values[++index] = atomic_read(&pau_qps_created);
-        target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
 }
 
 /**
@@ -1585,7 +1584,7 @@ static const struct ethtool_ops nes_ethtool_ops = {
         .set_pauseparam = nes_netdev_set_pauseparam,
 };
 
-static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, netdev_features_t features)
+static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, u32 features)
 {
         struct nes_adapter *nesadapter = nesdev->nesadapter;
         u32 u32temp;
@@ -1606,7 +1605,7 @@ static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev,
         spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
 }
 
-static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_features_t features)
+static u32 nes_fix_features(struct net_device *netdev, u32 features)
 {
         /*
          * Since there is no support for separate rx/tx vlan accel
@@ -1620,7 +1619,7 @@ static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_feat
         return features;
 }
 
-static int nes_set_features(struct net_device *netdev, netdev_features_t features)
+static int nes_set_features(struct net_device *netdev, u32 features)
 {
         struct nes_vnic *nesvnic = netdev_priv(netdev);
         struct nes_device *nesdev = nesvnic->nesdev;
@@ -1639,7 +1638,7 @@ static const struct net_device_ops nes_netdev_ops = {
         .ndo_get_stats          = nes_netdev_get_stats,
         .ndo_tx_timeout         = nes_netdev_tx_timeout,
         .ndo_set_mac_address    = nes_netdev_set_mac_address,
-        .ndo_set_rx_mode        = nes_netdev_set_multicast_list,
+        .ndo_set_multicast_list = nes_netdev_set_multicast_list,
         .ndo_change_mtu         = nes_netdev_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_fix_features       = nes_fix_features,
@@ -1675,10 +1674,12 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev,
         netdev->hard_header_len = ETH_HLEN;
         netdev->addr_len = ETH_ALEN;
         netdev->type = ARPHRD_ETHER;
+        netdev->features = NETIF_F_HIGHDMA;
         netdev->netdev_ops = &nes_netdev_ops;
         netdev->ethtool_ops = &nes_ethtool_ops;
         netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
         nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
+        netdev->features |= NETIF_F_HW_VLAN_TX;
 
         /* Fill in the port structure */
         nesvnic->netdev = netdev;
@@ -1705,11 +1706,11 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev,
         netdev->dev_addr[5] = (u8)u64temp;
         memcpy(netdev->perm_addr, netdev->dev_addr, 6);
 
-        netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM | NETIF_F_HW_VLAN_RX;
+        netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_IP_CSUM |
+                              NETIF_F_HW_VLAN_RX;
         if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
                 netdev->hw_features |= NETIF_F_TSO;
-
-        netdev->features = netdev->hw_features | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_TX;
+        netdev->features |= netdev->hw_features;
         netdev->hw_features |= NETIF_F_LRO;
 
         nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
diff --git a/drivers/infiniband/hw/nes/nes_user.h b/drivers/infiniband/hw/nes/nes_user.h
index 4926de74448..71e133ab209 100644
--- a/drivers/infiniband/hw/nes/nes_user.h
+++ b/drivers/infiniband/hw/nes/nes_user.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  All rights reserved.
  * Copyright (c) 2005 Topspin Communications.  All rights reserved.
  * Copyright (c) 2005 Cisco Systems.  All rights reserved.
  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
diff --git a/drivers/infiniband/hw/nes/nes_utils.c b/drivers/infiniband/hw/nes/nes_utils.c
index 2042c0f2975..f9c417c6b3b 100644
--- a/drivers/infiniband/hw/nes/nes_utils.c
+++ b/drivers/infiniband/hw/nes/nes_utils.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -51,34 +51,13 @@
 
 #include "nes.h"
 
+
+
 static u16 nes_read16_eeprom(void __iomem *addr, u16 offset);
 
 u32 mh_detected;
 u32 mh_pauses_sent;
 
-static u32 nes_set_pau(struct nes_device *nesdev)
-{
-        u32 ret = 0;
-        u32 counter;
-
-        nes_write_indexed(nesdev, NES_IDX_GPR2, NES_ENABLE_PAU);
-        nes_write_indexed(nesdev, NES_IDX_GPR_TRIGGER, 1);
-
-        for (counter = 0; counter < NES_PAU_COUNTER; counter++) {
-                udelay(30);
-                if (!nes_read_indexed(nesdev, NES_IDX_GPR2)) {
-                        printk(KERN_INFO PFX "PAU is supported.\n");
-                        break;
-                }
-                nes_write_indexed(nesdev, NES_IDX_GPR_TRIGGER, 1);
-        }
-        if (counter == NES_PAU_COUNTER) {
-                printk(KERN_INFO PFX "PAU is not supported.\n");
-                return -EPERM;
-        }
-        return ret;
-}
-
 /**
  * nes_read_eeprom_values -
  */
@@ -208,11 +187,6 @@ int nes_read_eeprom_values(struct nes_device *nesdev, struct nes_adapter *nesada
                 if (((major_ver == 3) && (minor_ver >= 16)) || (major_ver > 3))
                         nesadapter->send_term_ok = 1;
 
-                if (nes_drv_opt & NES_DRV_OPT_ENABLE_PAU) {
-                        if (!nes_set_pau(nesdev))
-                                nesadapter->allow_unaligned_fpdus = 1;
-                }
-
                 nesadapter->firmware_version = (((u32)(u8)(eeprom_data>>8))  <<  16) +
                                 (u32)((u8)eeprom_data);
 
@@ -620,7 +594,6 @@ void nes_put_cqp_request(struct nes_device *nesdev,
                 nes_free_cqp_request(nesdev, cqp_request);
 }
 
-
 /**
  * nes_post_cqp_request
  */
@@ -631,8 +604,6 @@ void nes_post_cqp_request(struct nes_device *nesdev,
         unsigned long flags;
         u32 cqp_head;
         u64 u64temp;
-        u32 opcode;
-        int ctx_index = NES_CQP_WQE_COMP_CTX_LOW_IDX;
 
         spin_lock_irqsave(&nesdev->cqp.lock, flags);
 
@@ -643,20 +614,17 @@ void nes_post_cqp_request(struct nes_device *nesdev,
                 nesdev->cqp.sq_head &= nesdev->cqp.sq_size-1;
                 cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
                 memcpy(cqp_wqe, &cqp_request->cqp_wqe, sizeof(*cqp_wqe));
-                opcode = le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX]);
-                if ((opcode & NES_CQP_OPCODE_MASK) == NES_CQP_DOWNLOAD_SEGMENT)
-                        ctx_index = NES_CQP_WQE_DL_COMP_CTX_LOW_IDX;
                 barrier();
                 u64temp = (unsigned long)cqp_request;
-                set_wqe_64bit_value(cqp_wqe->wqe_words, ctx_index, u64temp);
+                set_wqe_64bit_value(cqp_wqe->wqe_words, NES_CQP_WQE_COMP_SCRATCH_LOW_IDX,
+                                    u64temp);
                 nes_debug(NES_DBG_CQP, "CQP request (opcode 0x%02X), line 1 = 0x%08X put on CQPs SQ,"
-                        " request = %p, cqp_head = %u, cqp_tail = %u, cqp_size = %u,"
-                        " waiting = %d, refcount = %d.\n",
-                        opcode & NES_CQP_OPCODE_MASK,
-                        le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX]), cqp_request,
-                        nesdev->cqp.sq_head, nesdev->cqp.sq_tail, nesdev->cqp.sq_size,
-                        cqp_request->waiting, atomic_read(&cqp_request->refcount));
-
+                                " request = %p, cqp_head = %u, cqp_tail = %u, cqp_size = %u,"
+                                " waiting = %d, refcount = %d.\n",
+                                le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX])&0x3f,
+                                le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX]), cqp_request,
+                                nesdev->cqp.sq_head, nesdev->cqp.sq_tail, nesdev->cqp.sq_size,
+                                cqp_request->waiting, atomic_read(&cqp_request->refcount));
                 barrier();
 
                 /* Ring doorbell (1 WQEs) */
@@ -677,6 +645,7 @@ void nes_post_cqp_request(struct nes_device *nesdev,
         return;
 }
 
+
 /**
  * nes_arp_table
  */
@@ -699,7 +668,7 @@ int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 acti
 
                 arp_index = 0;
                 err = nes_alloc_resource(nesadapter, nesadapter->allocated_arps,
-                                nesadapter->arp_table_size, (u32 *)&arp_index, &nesadapter->next_arp_index, NES_RESOURCE_ARP);
+                                nesadapter->arp_table_size, (u32 *)&arp_index, &nesadapter->next_arp_index);
                 if (err) {
                         nes_debug(NES_DBG_NETDEV, "nes_alloc_resource returned error = %u\n", err);
                         return err;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index 07e4fbad987..9f2f7d4b119 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  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
@@ -80,7 +80,7 @@ static struct ib_mw *nes_alloc_mw(struct ib_pd *ibpd) {
         next_stag_index %= nesadapter->max_mr;
 
         ret = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
-                        nesadapter->max_mr, &stag_index, &next_stag_index, NES_RESOURCE_MW);
+                        nesadapter->max_mr, &stag_index, &next_stag_index);
         if (ret) {
                 return ERR_PTR(ret);
         }
@@ -404,7 +404,7 @@ static struct ib_mr *nes_alloc_fast_reg_mr(struct ib_pd *ibpd, int max_page_list
 
         err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
                                  nesadapter->max_mr, &stag_index,
-                                 &next_stag_index, NES_RESOURCE_FAST_MR);
+                                 &next_stag_index);
         if (err)
                 return ERR_PTR(err);
 
@@ -597,7 +597,7 @@ static int nes_query_port(struct ib_device *ibdev, u8 port, struct ib_port_attr
         props->pkey_tbl_len = 1;
         props->qkey_viol_cntr = 0;
         props->active_width = IB_WIDTH_4X;
-        props->active_speed = IB_SPEED_SDR;
+        props->active_speed = 1;
         props->max_msg_sz = 0x80000000;
 
         return 0;
@@ -780,7 +780,7 @@ static struct ib_pd *nes_alloc_pd(struct ib_device *ibdev,
                         netdev_refcnt_read(nesvnic->netdev));
 
         err = nes_alloc_resource(nesadapter, nesadapter->allocated_pds,
-                        nesadapter->max_pd, &pd_num, &nesadapter->next_pd, NES_RESOURCE_PD);
+                        nesadapter->max_pd, &pd_num, &nesadapter->next_pd);
         if (err) {
                 return ERR_PTR(err);
         }
@@ -1157,7 +1157,7 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
                         nes_debug(NES_DBG_QP, "RQ size=%u, SQ Size=%u\n", rq_size, sq_size);
 
                         ret = nes_alloc_resource(nesadapter, nesadapter->allocated_qps,
-                                        nesadapter->max_qp, &qp_num, &nesadapter->next_qp, NES_RESOURCE_QP);
+                                        nesadapter->max_qp, &qp_num, &nesadapter->next_qp);
                         if (ret) {
                                 return ERR_PTR(ret);
                         }
@@ -1404,9 +1404,6 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
         }
 
         nesqp->sig_all = (init_attr->sq_sig_type == IB_SIGNAL_ALL_WR);
-        init_timer(&nesqp->terminate_timer);
-        nesqp->terminate_timer.function = nes_terminate_timeout;
-        nesqp->terminate_timer.data = (unsigned long)nesqp;
 
         /* update the QP table */
         nesdev->nesadapter->qp_table[nesqp->hwqp.qp_id-NES_FIRST_QPN] = nesqp;
@@ -1416,6 +1413,7 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
         return &nesqp->ibqp;
 }
 
+
 /**
  * nes_clean_cq
  */
@@ -1460,7 +1458,7 @@ static int nes_destroy_qp(struct ib_qp *ibqp)
         struct ib_qp_attr attr;
         struct iw_cm_id *cm_id;
         struct iw_cm_event cm_event;
-        int ret = 0;
+        int ret;
 
         atomic_inc(&sw_qps_destroyed);
         nesqp->destroyed = 1;
@@ -1513,6 +1511,7 @@ static int nes_destroy_qp(struct ib_qp *ibqp)
                 if ((nesqp->nesrcq) && (nesqp->nesrcq != nesqp->nesscq))
                         nes_clean_cq(nesqp, nesqp->nesrcq);
         }
+
         nes_rem_ref(&nesqp->ibqp);
         return 0;
 }
@@ -1548,7 +1547,7 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
                 return ERR_PTR(-EINVAL);
 
         err = nes_alloc_resource(nesadapter, nesadapter->allocated_cqs,
-                        nesadapter->max_cq, &cq_num, &nesadapter->next_cq, NES_RESOURCE_CQ);
+                        nesadapter->max_cq, &cq_num, &nesadapter->next_cq);
         if (err) {
                 return ERR_PTR(err);
         }
@@ -2131,7 +2130,7 @@ static struct ib_mr *nes_reg_phys_mr(struct ib_pd *ib_pd,
                 return ERR_PTR(-EINVAL);
 
         err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs, nesadapter->max_mr,
-                        &stag_index, &next_stag_index, NES_RESOURCE_PHYS_MR);
+                        &stag_index, &next_stag_index);
         if (err) {
                 return ERR_PTR(err);
         }
@@ -2339,10 +2338,8 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
 
         skip_pages = ((u32)region->offset) >> 12;
 
-        if (ib_copy_from_udata(&req, udata, sizeof(req))) {
-                ib_umem_release(region);
+        if (ib_copy_from_udata(&req, udata, sizeof(req)))
                 return ERR_PTR(-EFAULT);
-        }
         nes_debug(NES_DBG_MR, "Memory Registration type = %08X.\n", req.reg_type);
 
         switch (req.reg_type) {
@@ -2362,7 +2359,7 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                         next_stag_index %= nesadapter->max_mr;
 
                         err = nes_alloc_resource(nesadapter, nesadapter->allocated_mrs,
-                                        nesadapter->max_mr, &stag_index, &next_stag_index, NES_RESOURCE_USER_MR);
+                                        nesadapter->max_mr, &stag_index, &next_stag_index);
                         if (err) {
                                 ib_umem_release(region);
                                 return ERR_PTR(err);
@@ -2561,11 +2558,6 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                         return ibmr;
                 case IWNES_MEMREG_TYPE_QP:
                 case IWNES_MEMREG_TYPE_CQ:
-                        if (!region->length) {
-                                nes_debug(NES_DBG_MR, "Unable to register zero length region for CQ\n");
-                                ib_umem_release(region);
-                                return ERR_PTR(-EINVAL);
-                        }
                         nespbl = kzalloc(sizeof(*nespbl), GFP_KERNEL);
                         if (!nespbl) {
                                 nes_debug(NES_DBG_MR, "Unable to allocate PBL\n");
@@ -2639,7 +2631,6 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                         return &nesmr->ibmr;
         }
 
-        ib_umem_release(region);
         return ERR_PTR(-ENOSYS);
 }
 
@@ -3013,7 +3004,6 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                                         switch (nesqp->hw_iwarp_state) {
                                                 case NES_AEQE_IWARP_STATE_CLOSING:
                                                         next_iwarp_state = NES_CQP_QP_IWARP_STATE_CLOSING;
-                                                        break;
                                                 case NES_AEQE_IWARP_STATE_TERMINATE:
                                                         next_iwarp_state = NES_CQP_QP_IWARP_STATE_TERMINATE;
                                                         break;
@@ -3076,9 +3066,18 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                 }
 
                 nesqp->ibqp_state = attr->qp_state;
-                nesqp->iwarp_state = next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK;
-                nes_debug(NES_DBG_MOD_QP, "Change nesqp->iwarp_state=%08x\n",
-                                nesqp->iwarp_state);
+                if (((nesqp->iwarp_state & NES_CQP_QP_IWARP_STATE_MASK) ==
+                                (u32)NES_CQP_QP_IWARP_STATE_RTS) &&
+                                ((next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK) >
+                                (u32)NES_CQP_QP_IWARP_STATE_RTS)) {
+                        nesqp->iwarp_state = next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK;
+                        nes_debug(NES_DBG_MOD_QP, "Change nesqp->iwarp_state=%08x\n",
+                                        nesqp->iwarp_state);
+                } else {
+                        nesqp->iwarp_state = next_iwarp_state & NES_CQP_QP_IWARP_STATE_MASK;
+                        nes_debug(NES_DBG_MOD_QP, "Change nesqp->iwarp_state=%08x\n",
+                                        nesqp->iwarp_state);
+                }
         }
 
         if (attr_mask & IB_QP_ACCESS_FLAGS) {
@@ -3427,8 +3426,6 @@ static int nes_post_send(struct ib_qp *ibqp, struct ib_send_wr *ib_wr,
                                             NES_IWARP_SQ_FMR_WQE_LENGTH_LOW_IDX,
                                             ib_wr->wr.fast_reg.length);
                         set_wqe_32bit_value(wqe->wqe_words,
-                                            NES_IWARP_SQ_FMR_WQE_LENGTH_HIGH_IDX, 0);
-                        set_wqe_32bit_value(wqe->wqe_words,
                                             NES_IWARP_SQ_FMR_WQE_MR_STAG_IDX,
                                             ib_wr->wr.fast_reg.rkey);
                         /* Set page size: */
@@ -3725,7 +3722,7 @@ static int nes_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
                                                 entry->opcode = IB_WC_SEND;
                                                 break;
                                         case NES_IWARP_SQ_OP_LOCINV:
-                                                entry->opcode = IB_WC_LOCAL_INV;
+                                                entry->opcode = IB_WR_LOCAL_INV;
                                                 break;
                                         case NES_IWARP_SQ_OP_FAST_REG:
                                                 entry->opcode = IB_WC_FAST_REG_MR;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.h b/drivers/infiniband/hw/nes/nes_verbs.h
index 0eff7c44d76..2df9993e0ca 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.h
+++ b/drivers/infiniband/hw/nes/nes_verbs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 - 2011 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2009 Intel Corporation.  All rights reserved.
  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -139,8 +139,7 @@ struct nes_qp {
         struct nes_cq         *nesrcq;
         struct nes_pd         *nespd;
         void *cm_node; /* handle of the node this QP is associated with */
-        void                  *ietf_frame;
-        u8                    ietf_frame_size;
+        struct ietf_mpa_frame *ietf_frame;
         dma_addr_t            ietf_frame_pbase;
         struct ib_mr          *lsmm_mr;
         struct nes_hw_qp      hwqp;
@@ -155,7 +154,6 @@ struct nes_qp {
         u32                   mmap_sq_db_index;
         u32                   mmap_rq_db_index;
         spinlock_t            lock;
-        spinlock_t            pau_lock;
         struct nes_qp_context *nesqp_context;
         dma_addr_t            nesqp_context_pbase;
         void                  *pbl_vbase;
@@ -163,8 +161,6 @@ struct nes_qp {
         struct page           *page;
         struct timer_list     terminate_timer;
         enum ib_event_type    terminate_eventtype;
-        struct sk_buff_head   pau_list;
-        u32                   pau_rcv_nxt;
         u16                   active_conn:1;
         u16                   skip_lsmm:1;
         u16                   user_mode:1;
@@ -172,8 +168,7 @@ struct nes_qp {
         u16                   flush_issued:1;
         u16                   destroyed:1;
         u16                   sig_all:1;
-        u16                   pau_mode:1;
-        u16                   rsvd:8;
+        u16                   rsvd:9;
         u16                   private_data_len;
         u16                   term_sq_flush_code;
         u16                   term_rq_flush_code;
@@ -181,8 +176,5 @@ struct nes_qp {
         u8                    hw_tcp_state;
         u8                    term_flags;
         u8                    sq_kmapped;
-        u8                    pau_busy;
-        u8                    pau_pending;
-        u8                    pau_state;
 };
 #endif                  /* NES_VERBS_H */
diff --git a/drivers/infiniband/hw/ocrdma/Kconfig b/drivers/infiniband/hw/ocrdma/Kconfig
deleted file mode 100644
index b5b6056c851..00000000000
--- a/drivers/infiniband/hw/ocrdma/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-config INFINIBAND_OCRDMA
-        tristate "Emulex One Connect HCA support"
-        depends on ETHERNET && NETDEVICES && PCI && (IPV6 || IPV6=n)
-        select NET_VENDOR_EMULEX
-        select BE2NET
-        ---help---
-          This driver provides low-level InfiniBand over Ethernet
-          support for Emulex One Connect host channel adapters (HCAs).
diff --git a/drivers/infiniband/hw/ocrdma/Makefile b/drivers/infiniband/hw/ocrdma/Makefile
deleted file mode 100644
index 06a5bed12e4..00000000000
--- a/drivers/infiniband/hw/ocrdma/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-ccflags-y := -Idrivers/net/ethernet/emulex/benet
-
-obj-$(CONFIG_INFINIBAND_OCRDMA) += ocrdma.o
-
-ocrdma-y :=     ocrdma_main.o ocrdma_verbs.o ocrdma_hw.o ocrdma_ah.o
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma.h b/drivers/infiniband/hw/ocrdma/ocrdma.h
deleted file mode 100644
index 48970af2367..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_H__
-#define __OCRDMA_H__
-
-#include <linux/mutex.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/pci.h>
-
-#include <rdma/ib_verbs.h>
-#include <rdma/ib_user_verbs.h>
-
-#include <be_roce.h>
-#include "ocrdma_sli.h"
-
-#define OCRDMA_ROCE_DEV_VERSION "1.0.0"
-#define OCRDMA_NODE_DESC "Emulex OneConnect RoCE HCA"
-
-#define ocrdma_err(format, arg...) printk(KERN_ERR format, ##arg)
-
-#define OCRDMA_MAX_AH 512
-
-#define OCRDMA_UVERBS(CMD_NAME) (1ull << IB_USER_VERBS_CMD_##CMD_NAME)
-
-struct ocrdma_dev_attr {
-        u8 fw_ver[32];
-        u32 vendor_id;
-        u32 device_id;
-        u16 max_pd;
-        u16 max_cq;
-        u16 max_cqe;
-        u16 max_qp;
-        u16 max_wqe;
-        u16 max_rqe;
-        u32 max_inline_data;
-        int max_send_sge;
-        int max_recv_sge;
-        int max_srq_sge;
-        int max_mr;
-        u64 max_mr_size;
-        u32 max_num_mr_pbl;
-        int max_fmr;
-        int max_map_per_fmr;
-        int max_pages_per_frmr;
-        u16 max_ord_per_qp;
-        u16 max_ird_per_qp;
-
-        int device_cap_flags;
-        u8 cq_overflow_detect;
-        u8 srq_supported;
-
-        u32 wqe_size;
-        u32 rqe_size;
-        u32 ird_page_size;
-        u8 local_ca_ack_delay;
-        u8 ird;
-        u8 num_ird_pages;
-};
-
-struct ocrdma_pbl {
-        void *va;
-        dma_addr_t pa;
-};
-
-struct ocrdma_queue_info {
-        void *va;
-        dma_addr_t dma;
-        u32 size;
-        u16 len;
-        u16 entry_size;         /* Size of an element in the queue */
-        u16 id;                 /* qid, where to ring the doorbell. */
-        u16 head, tail;
-        bool created;
-        atomic_t used;          /* Number of valid elements in the queue */
-};
-
-struct ocrdma_eq {
-        struct ocrdma_queue_info q;
-        u32 vector;
-        int cq_cnt;
-        struct ocrdma_dev *dev;
-        char irq_name[32];
-};
-
-struct ocrdma_mq {
-        struct ocrdma_queue_info sq;
-        struct ocrdma_queue_info cq;
-        bool rearm_cq;
-};
-
-struct mqe_ctx {
-        struct mutex lock; /* for serializing mailbox commands on MQ */
-        wait_queue_head_t cmd_wait;
-        u32 tag;
-        u16 cqe_status;
-        u16 ext_status;
-        bool cmd_done;
-};
-
-struct ocrdma_dev {
-        struct ib_device ibdev;
-        struct ocrdma_dev_attr attr;
-
-        struct mutex dev_lock; /* provides syncronise access to device data */
-        spinlock_t flush_q_lock ____cacheline_aligned;
-
-        struct ocrdma_cq **cq_tbl;
-        struct ocrdma_qp **qp_tbl;
-
-        struct ocrdma_eq meq;
-        struct ocrdma_eq *qp_eq_tbl;
-        int eq_cnt;
-        u16 base_eqid;
-        u16 max_eq;
-
-        union ib_gid *sgid_tbl;
-        /* provided synchronization to sgid table for
-         * updating gid entries triggered by notifier.
-         */
-        spinlock_t sgid_lock;
-
-        int gsi_qp_created;
-        struct ocrdma_cq *gsi_sqcq;
-        struct ocrdma_cq *gsi_rqcq;
-
-        struct {
-                struct ocrdma_av *va;
-                dma_addr_t pa;
-                u32 size;
-                u32 num_ah;
-                /* provide synchronization for av
-                 * entry allocations.
-                 */
-                spinlock_t lock;
-                u32 ahid;
-                struct ocrdma_pbl pbl;
-        } av_tbl;
-
-        void *mbx_cmd;
-        struct ocrdma_mq mq;
-        struct mqe_ctx mqe_ctx;
-
-        struct be_dev_info nic_info;
-
-        struct list_head entry;
-        struct rcu_head rcu;
-        int id;
-};
-
-struct ocrdma_cq {
-        struct ib_cq ibcq;
-        struct ocrdma_dev *dev;
-        struct ocrdma_cqe *va;
-        u32 phase;
-        u32 getp;       /* pointer to pending wrs to
-                         * return to stack, wrap arounds
-                         * at max_hw_cqe
-                         */
-        u32 max_hw_cqe;
-        bool phase_change;
-        bool armed, solicited;
-        bool arm_needed;
-
-        spinlock_t cq_lock ____cacheline_aligned; /* provide synchronization
-                                                   * to cq polling
-                                                   */
-        /* syncronizes cq completion handler invoked from multiple context */
-        spinlock_t comp_handler_lock ____cacheline_aligned;
-        u16 id;
-        u16 eqn;
-
-        struct ocrdma_ucontext *ucontext;
-        dma_addr_t pa;
-        u32 len;
-        atomic_t use_cnt;
-
-        /* head of all qp's sq and rq for which cqes need to be flushed
-         * by the software.
-         */
-        struct list_head sq_head, rq_head;
-};
-
-struct ocrdma_pd {
-        struct ib_pd ibpd;
-        struct ocrdma_dev *dev;
-        struct ocrdma_ucontext *uctx;
-        atomic_t use_cnt;
-        u32 id;
-        int num_dpp_qp;
-        u32 dpp_page;
-        bool dpp_enabled;
-};
-
-struct ocrdma_ah {
-        struct ib_ah ibah;
-        struct ocrdma_dev *dev;
-        struct ocrdma_av *av;
-        u16 sgid_index;
-        u32 id;
-};
-
-struct ocrdma_qp_hwq_info {
-        u8 *va;                 /* virtual address */
-        u32 max_sges;
-        u32 head, tail;
-        u32 entry_size;
-        u32 max_cnt;
-        u32 max_wqe_idx;
-        u16 dbid;               /* qid, where to ring the doorbell. */
-        u32 len;
-        dma_addr_t pa;
-};
-
-struct ocrdma_srq {
-        struct ib_srq ibsrq;
-        struct ocrdma_dev *dev;
-        u8 __iomem *db;
-        /* provide synchronization to multiple context(s) posting rqe */
-        spinlock_t q_lock ____cacheline_aligned;
-
-        struct ocrdma_qp_hwq_info rq;
-        struct ocrdma_pd *pd;
-        atomic_t use_cnt;
-        u32 id;
-        u64 *rqe_wr_id_tbl;
-        u32 *idx_bit_fields;
-        u32 bit_fields_len;
-};
-
-struct ocrdma_qp {
-        struct ib_qp ibqp;
-        struct ocrdma_dev *dev;
-
-        u8 __iomem *sq_db;
-        /* provide synchronization to multiple context(s) posting wqe, rqe */
-        spinlock_t q_lock ____cacheline_aligned;
-        struct ocrdma_qp_hwq_info sq;
-        struct {
-                uint64_t wrid;
-                uint16_t dpp_wqe_idx;
-                uint16_t dpp_wqe;
-                uint8_t  signaled;
-                uint8_t  rsvd[3];
-        } *wqe_wr_id_tbl;
-        u32 max_inline_data;
-        struct ocrdma_cq *sq_cq;
-        /* list maintained per CQ to flush SQ errors */
-        struct list_head sq_entry;
-
-        u8 __iomem *rq_db;
-        struct ocrdma_qp_hwq_info rq;
-        u64 *rqe_wr_id_tbl;
-        struct ocrdma_cq *rq_cq;
-        struct ocrdma_srq *srq;
-        /* list maintained per CQ to flush RQ errors */
-        struct list_head rq_entry;
-
-        enum ocrdma_qp_state state;     /*  QP state */
-        int cap_flags;
-        u32 max_ord, max_ird;
-
-        u32 id;
-        struct ocrdma_pd *pd;
-
-        enum ib_qp_type qp_type;
-
-        int sgid_idx;
-        u32 qkey;
-        bool dpp_enabled;
-        u8 *ird_q_va;
-};
-
-#define OCRDMA_GET_NUM_POSTED_SHIFT_VAL(qp) \
-        (((qp->dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) && \
-                (qp->id < 64)) ? 24 : 16)
-
-struct ocrdma_hw_mr {
-        struct ocrdma_dev *dev;
-        u32 lkey;
-        u8 fr_mr;
-        u8 remote_atomic;
-        u8 remote_rd;
-        u8 remote_wr;
-        u8 local_rd;
-        u8 local_wr;
-        u8 mw_bind;
-        u8 rsvd;
-        u64 len;
-        struct ocrdma_pbl *pbl_table;
-        u32 num_pbls;
-        u32 num_pbes;
-        u32 pbl_size;
-        u32 pbe_size;
-        u64 fbo;
-        u64 va;
-};
-
-struct ocrdma_mr {
-        struct ib_mr ibmr;
-        struct ib_umem *umem;
-        struct ocrdma_hw_mr hwmr;
-        struct ocrdma_pd *pd;
-};
-
-struct ocrdma_ucontext {
-        struct ib_ucontext ibucontext;
-        struct ocrdma_dev *dev;
-
-        struct list_head mm_head;
-        struct mutex mm_list_lock; /* protects list entries of mm type */
-        struct {
-                u32 *va;
-                dma_addr_t pa;
-                u32 len;
-        } ah_tbl;
-};
-
-struct ocrdma_mm {
-        struct {
-                u64 phy_addr;
-                unsigned long len;
-        } key;
-        struct list_head entry;
-};
-
-static inline struct ocrdma_dev *get_ocrdma_dev(struct ib_device *ibdev)
-{
-        return container_of(ibdev, struct ocrdma_dev, ibdev);
-}
-
-static inline struct ocrdma_ucontext *get_ocrdma_ucontext(struct ib_ucontext
-                                                          *ibucontext)
-{
-        return container_of(ibucontext, struct ocrdma_ucontext, ibucontext);
-}
-
-static inline struct ocrdma_pd *get_ocrdma_pd(struct ib_pd *ibpd)
-{
-        return container_of(ibpd, struct ocrdma_pd, ibpd);
-}
-
-static inline struct ocrdma_cq *get_ocrdma_cq(struct ib_cq *ibcq)
-{
-        return container_of(ibcq, struct ocrdma_cq, ibcq);
-}
-
-static inline struct ocrdma_qp *get_ocrdma_qp(struct ib_qp *ibqp)
-{
-        return container_of(ibqp, struct ocrdma_qp, ibqp);
-}
-
-static inline struct ocrdma_mr *get_ocrdma_mr(struct ib_mr *ibmr)
-{
-        return container_of(ibmr, struct ocrdma_mr, ibmr);
-}
-
-static inline struct ocrdma_ah *get_ocrdma_ah(struct ib_ah *ibah)
-{
-        return container_of(ibah, struct ocrdma_ah, ibah);
-}
-
-static inline struct ocrdma_srq *get_ocrdma_srq(struct ib_srq *ibsrq)
-{
-        return container_of(ibsrq, struct ocrdma_srq, ibsrq);
-}
-
-#endif
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_abi.h b/drivers/infiniband/hw/ocrdma/ocrdma_abi.h
deleted file mode 100644
index 517ab20b727..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_abi.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_ABI_H__
-#define __OCRDMA_ABI_H__
-
-struct ocrdma_alloc_ucontext_resp {
-        u32 dev_id;
-        u32 wqe_size;
-        u32 max_inline_data;
-        u32 dpp_wqe_size;
-        u64 ah_tbl_page;
-        u32 ah_tbl_len;
-        u32 rsvd;
-        u8 fw_ver[32];
-        u32 rqe_size;
-        u64 rsvd1;
-} __packed;
-
-/* user kernel communication data structures. */
-struct ocrdma_alloc_pd_ureq {
-        u64 rsvd1;
-} __packed;
-
-struct ocrdma_alloc_pd_uresp {
-        u32 id;
-        u32 dpp_enabled;
-        u32 dpp_page_addr_hi;
-        u32 dpp_page_addr_lo;
-        u64 rsvd1;
-} __packed;
-
-struct ocrdma_create_cq_ureq {
-        u32 dpp_cq;
-        u32 rsvd;
-} __packed;
-
-#define MAX_CQ_PAGES 8
-struct ocrdma_create_cq_uresp {
-        u32 cq_id;
-        u32 page_size;
-        u32 num_pages;
-        u32 max_hw_cqe;
-        u64 page_addr[MAX_CQ_PAGES];
-        u64 db_page_addr;
-        u32 db_page_size;
-        u32 phase_change;
-        u64 rsvd1;
-        u64 rsvd2;
-} __packed;
-
-#define MAX_QP_PAGES 8
-#define MAX_UD_AV_PAGES 8
-
-struct ocrdma_create_qp_ureq {
-        u8 enable_dpp_cq;
-        u8 rsvd;
-        u16 dpp_cq_id;
-        u32 rsvd1;
-};
-
-struct ocrdma_create_qp_uresp {
-        u16 qp_id;
-        u16 sq_dbid;
-        u16 rq_dbid;
-        u16 resv0;
-        u32 sq_page_size;
-        u32 rq_page_size;
-        u32 num_sq_pages;
-        u32 num_rq_pages;
-        u64 sq_page_addr[MAX_QP_PAGES];
-        u64 rq_page_addr[MAX_QP_PAGES];
-        u64 db_page_addr;
-        u32 db_page_size;
-        u32 dpp_credit;
-        u32 dpp_offset;
-        u32 rsvd1;
-        u32 num_wqe_allocated;
-        u32 num_rqe_allocated;
-        u32 db_sq_offset;
-        u32 db_rq_offset;
-        u32 db_shift;
-        u64 rsvd2;
-        u64 rsvd3;
-} __packed;
-
-struct ocrdma_create_srq_uresp {
-        u16 rq_dbid;
-        u16 resv0;
-        u32 resv1;
-
-        u32 rq_page_size;
-        u32 num_rq_pages;
-
-        u64 rq_page_addr[MAX_QP_PAGES];
-        u64 db_page_addr;
-
-        u32 db_page_size;
-        u32 num_rqe_allocated;
-        u32 db_rq_offset;
-        u32 db_shift;
-
-        u64 rsvd2;
-        u64 rsvd3;
-} __packed;
-
-#endif                          /* __OCRDMA_ABI_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c b/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
deleted file mode 100644
index a877a8ed790..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#include <net/neighbour.h>
-#include <net/netevent.h>
-
-#include <rdma/ib_addr.h>
-#include <rdma/ib_cache.h>
-
-#include "ocrdma.h"
-#include "ocrdma_verbs.h"
-#include "ocrdma_ah.h"
-#include "ocrdma_hw.h"
-
-static inline int set_av_attr(struct ocrdma_ah *ah,
-                                struct ib_ah_attr *attr, int pdid)
-{
-        int status = 0;
-        u16 vlan_tag; bool vlan_enabled = false;
-        struct ocrdma_dev *dev = ah->dev;
-        struct ocrdma_eth_vlan eth;
-        struct ocrdma_grh grh;
-        int eth_sz;
-
-        memset(&eth, 0, sizeof(eth));
-        memset(&grh, 0, sizeof(grh));
-
-        ah->sgid_index = attr->grh.sgid_index;
-
-        vlan_tag = rdma_get_vlan_id(&attr->grh.dgid);
-        if (vlan_tag && (vlan_tag < 0x1000)) {
-                eth.eth_type = cpu_to_be16(0x8100);
-                eth.roce_eth_type = cpu_to_be16(OCRDMA_ROCE_ETH_TYPE);
-                vlan_tag |= (attr->sl & 7) << 13;
-                eth.vlan_tag = cpu_to_be16(vlan_tag);
-                eth_sz = sizeof(struct ocrdma_eth_vlan);
-                vlan_enabled = true;
-        } else {
-                eth.eth_type = cpu_to_be16(OCRDMA_ROCE_ETH_TYPE);
-                eth_sz = sizeof(struct ocrdma_eth_basic);
-        }
-        memcpy(&eth.smac[0], &dev->nic_info.mac_addr[0], ETH_ALEN);
-        status = ocrdma_resolve_dgid(dev, &attr->grh.dgid, &eth.dmac[0]);
-        if (status)
-                return status;
-        status = ocrdma_query_gid(&dev->ibdev, 1, attr->grh.sgid_index,
-                        (union ib_gid *)&grh.sgid[0]);
-        if (status)
-                return status;
-
-        grh.tclass_flow = cpu_to_be32((6 << 28) |
-                        (attr->grh.traffic_class << 24) |
-                        attr->grh.flow_label);
-        /* 0x1b is next header value in GRH */
-        grh.pdid_hoplimit = cpu_to_be32((pdid << 16) |
-                        (0x1b << 8) | attr->grh.hop_limit);
-
-        memcpy(&grh.dgid[0], attr->grh.dgid.raw, sizeof(attr->grh.dgid.raw));
-        memcpy(&ah->av->eth_hdr, &eth, eth_sz);
-        memcpy((u8 *)ah->av + eth_sz, &grh, sizeof(struct ocrdma_grh));
-        if (vlan_enabled)
-                ah->av->valid |= OCRDMA_AV_VLAN_VALID;
-        return status;
-}
-
-struct ib_ah *ocrdma_create_ah(struct ib_pd *ibpd, struct ib_ah_attr *attr)
-{
-        u32 *ahid_addr;
-        int status;
-        struct ocrdma_ah *ah;
-        struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
-        struct ocrdma_dev *dev = pd->dev;
-
-        if (!(attr->ah_flags & IB_AH_GRH))
-                return ERR_PTR(-EINVAL);
-
-        ah = kzalloc(sizeof *ah, GFP_ATOMIC);
-        if (!ah)
-                return ERR_PTR(-ENOMEM);
-        ah->dev = pd->dev;
-
-        status = ocrdma_alloc_av(dev, ah);
-        if (status)
-                goto av_err;
-        status = set_av_attr(ah, attr, pd->id);
-        if (status)
-                goto av_conf_err;
-
-        /* if pd is for the user process, pass the ah_id to user space */
-        if ((pd->uctx) && (pd->uctx->ah_tbl.va)) {
-                ahid_addr = pd->uctx->ah_tbl.va + attr->dlid;
-                *ahid_addr = ah->id;
-        }
-        return &ah->ibah;
-
-av_conf_err:
-        ocrdma_free_av(dev, ah);
-av_err:
-        kfree(ah);
-        return ERR_PTR(status);
-}
-
-int ocrdma_destroy_ah(struct ib_ah *ibah)
-{
-        struct ocrdma_ah *ah = get_ocrdma_ah(ibah);
-        ocrdma_free_av(ah->dev, ah);
-        kfree(ah);
-        return 0;
-}
-
-int ocrdma_query_ah(struct ib_ah *ibah, struct ib_ah_attr *attr)
-{
-        struct ocrdma_ah *ah = get_ocrdma_ah(ibah);
-        struct ocrdma_av *av = ah->av;
-        struct ocrdma_grh *grh;
-        attr->ah_flags |= IB_AH_GRH;
-        if (ah->av->valid & Bit(1)) {
-                grh = (struct ocrdma_grh *)((u8 *)ah->av +
-                                sizeof(struct ocrdma_eth_vlan));
-                attr->sl = be16_to_cpu(av->eth_hdr.vlan_tag) >> 13;
-        } else {
-                grh = (struct ocrdma_grh *)((u8 *)ah->av +
-                                        sizeof(struct ocrdma_eth_basic));
-                attr->sl = 0;
-        }
-        memcpy(&attr->grh.dgid.raw[0], &grh->dgid[0], sizeof(grh->dgid));
-        attr->grh.sgid_index = ah->sgid_index;
-        attr->grh.hop_limit = be32_to_cpu(grh->pdid_hoplimit) & 0xff;
-        attr->grh.traffic_class = be32_to_cpu(grh->tclass_flow) >> 24;
-        attr->grh.flow_label = be32_to_cpu(grh->tclass_flow) & 0x00ffffffff;
-        return 0;
-}
-
-int ocrdma_modify_ah(struct ib_ah *ibah, struct ib_ah_attr *attr)
-{
-        /* modify_ah is unsupported */
-        return -ENOSYS;
-}
-
-int ocrdma_process_mad(struct ib_device *ibdev,
-                       int process_mad_flags,
-                       u8 port_num,
-                       struct ib_wc *in_wc,
-                       struct ib_grh *in_grh,
-                       struct ib_mad *in_mad, struct ib_mad *out_mad)
-{
-        return IB_MAD_RESULT_SUCCESS;
-}
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h b/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
deleted file mode 100644
index 8ac49e7f96d..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_AH_H__
-#define __OCRDMA_AH_H__
-
-struct ib_ah *ocrdma_create_ah(struct ib_pd *, struct ib_ah_attr *);
-int ocrdma_destroy_ah(struct ib_ah *);
-int ocrdma_query_ah(struct ib_ah *, struct ib_ah_attr *);
-int ocrdma_modify_ah(struct ib_ah *, struct ib_ah_attr *);
-
-int ocrdma_process_mad(struct ib_device *,
-                       int process_mad_flags,
-                       u8 port_num,
-                       struct ib_wc *in_wc,
-                       struct ib_grh *in_grh,
-                       struct ib_mad *in_mad, struct ib_mad *out_mad);
-#endif                          /* __OCRDMA_AH_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
deleted file mode 100644
index 71942af4fce..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
+++ /dev/null
@@ -1,2631 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) CNA Adapters.              *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#include <linux/sched.h>
-#include <linux/interrupt.h>
-#include <linux/log2.h>
-#include <linux/dma-mapping.h>
-
-#include <rdma/ib_verbs.h>
-#include <rdma/ib_user_verbs.h>
-#include <rdma/ib_addr.h>
-
-#include "ocrdma.h"
-#include "ocrdma_hw.h"
-#include "ocrdma_verbs.h"
-#include "ocrdma_ah.h"
-
-enum mbx_status {
-        OCRDMA_MBX_STATUS_FAILED                = 1,
-        OCRDMA_MBX_STATUS_ILLEGAL_FIELD         = 3,
-        OCRDMA_MBX_STATUS_OOR                   = 100,
-        OCRDMA_MBX_STATUS_INVALID_PD            = 101,
-        OCRDMA_MBX_STATUS_PD_INUSE              = 102,
-        OCRDMA_MBX_STATUS_INVALID_CQ            = 103,
-        OCRDMA_MBX_STATUS_INVALID_QP            = 104,
-        OCRDMA_MBX_STATUS_INVALID_LKEY          = 105,
-        OCRDMA_MBX_STATUS_ORD_EXCEEDS           = 106,
-        OCRDMA_MBX_STATUS_IRD_EXCEEDS           = 107,
-        OCRDMA_MBX_STATUS_SENDQ_WQE_EXCEEDS     = 108,
-        OCRDMA_MBX_STATUS_RECVQ_RQE_EXCEEDS     = 109,
-        OCRDMA_MBX_STATUS_SGE_SEND_EXCEEDS      = 110,
-        OCRDMA_MBX_STATUS_SGE_WRITE_EXCEEDS     = 111,
-        OCRDMA_MBX_STATUS_SGE_RECV_EXCEEDS      = 112,
-        OCRDMA_MBX_STATUS_INVALID_STATE_CHANGE  = 113,
-        OCRDMA_MBX_STATUS_MW_BOUND              = 114,
-        OCRDMA_MBX_STATUS_INVALID_VA            = 115,
-        OCRDMA_MBX_STATUS_INVALID_LENGTH        = 116,
-        OCRDMA_MBX_STATUS_INVALID_FBO           = 117,
-        OCRDMA_MBX_STATUS_INVALID_ACC_RIGHTS    = 118,
-        OCRDMA_MBX_STATUS_INVALID_PBE_SIZE      = 119,
-        OCRDMA_MBX_STATUS_INVALID_PBL_ENTRY     = 120,
-        OCRDMA_MBX_STATUS_INVALID_PBL_SHIFT     = 121,
-        OCRDMA_MBX_STATUS_INVALID_SRQ_ID        = 129,
-        OCRDMA_MBX_STATUS_SRQ_ERROR             = 133,
-        OCRDMA_MBX_STATUS_RQE_EXCEEDS           = 134,
-        OCRDMA_MBX_STATUS_MTU_EXCEEDS           = 135,
-        OCRDMA_MBX_STATUS_MAX_QP_EXCEEDS        = 136,
-        OCRDMA_MBX_STATUS_SRQ_LIMIT_EXCEEDS     = 137,
-        OCRDMA_MBX_STATUS_SRQ_SIZE_UNDERUNS     = 138,
-        OCRDMA_MBX_STATUS_QP_BOUND              = 130,
-        OCRDMA_MBX_STATUS_INVALID_CHANGE        = 139,
-        OCRDMA_MBX_STATUS_ATOMIC_OPS_UNSUP      = 140,
-        OCRDMA_MBX_STATUS_INVALID_RNR_NAK_TIMER = 141,
-        OCRDMA_MBX_STATUS_MW_STILL_BOUND        = 142,
-        OCRDMA_MBX_STATUS_PKEY_INDEX_INVALID    = 143,
-        OCRDMA_MBX_STATUS_PKEY_INDEX_EXCEEDS    = 144
-};
-
-enum additional_status {
-        OCRDMA_MBX_ADDI_STATUS_INSUFFICIENT_RESOURCES = 22
-};
-
-enum cqe_status {
-        OCRDMA_MBX_CQE_STATUS_INSUFFICIENT_PRIVILEDGES  = 1,
-        OCRDMA_MBX_CQE_STATUS_INVALID_PARAMETER         = 2,
-        OCRDMA_MBX_CQE_STATUS_INSUFFICIENT_RESOURCES    = 3,
-        OCRDMA_MBX_CQE_STATUS_QUEUE_FLUSHING            = 4,
-        OCRDMA_MBX_CQE_STATUS_DMA_FAILED                = 5
-};
-
-static inline void *ocrdma_get_eqe(struct ocrdma_eq *eq)
-{
-        return (u8 *)eq->q.va + (eq->q.tail * sizeof(struct ocrdma_eqe));
-}
-
-static inline void ocrdma_eq_inc_tail(struct ocrdma_eq *eq)
-{
-        eq->q.tail = (eq->q.tail + 1) & (OCRDMA_EQ_LEN - 1);
-}
-
-static inline void *ocrdma_get_mcqe(struct ocrdma_dev *dev)
-{
-        struct ocrdma_mcqe *cqe = (struct ocrdma_mcqe *)
-            ((u8 *) dev->mq.cq.va +
-             (dev->mq.cq.tail * sizeof(struct ocrdma_mcqe)));
-
-        if (!(le32_to_cpu(cqe->valid_ae_cmpl_cons) & OCRDMA_MCQE_VALID_MASK))
-                return NULL;
-        return cqe;
-}
-
-static inline void ocrdma_mcq_inc_tail(struct ocrdma_dev *dev)
-{
-        dev->mq.cq.tail = (dev->mq.cq.tail + 1) & (OCRDMA_MQ_CQ_LEN - 1);
-}
-
-static inline struct ocrdma_mqe *ocrdma_get_mqe(struct ocrdma_dev *dev)
-{
-        return (struct ocrdma_mqe *)((u8 *) dev->mq.sq.va +
-                                     (dev->mq.sq.head *
-                                      sizeof(struct ocrdma_mqe)));
-}
-
-static inline void ocrdma_mq_inc_head(struct ocrdma_dev *dev)
-{
-        dev->mq.sq.head = (dev->mq.sq.head + 1) & (OCRDMA_MQ_LEN - 1);
-        atomic_inc(&dev->mq.sq.used);
-}
-
-static inline void *ocrdma_get_mqe_rsp(struct ocrdma_dev *dev)
-{
-        return (void *)((u8 *) dev->mq.sq.va +
-                        (dev->mqe_ctx.tag * sizeof(struct ocrdma_mqe)));
-}
-
-enum ib_qp_state get_ibqp_state(enum ocrdma_qp_state qps)
-{
-        switch (qps) {
-        case OCRDMA_QPS_RST:
-                return IB_QPS_RESET;
-        case OCRDMA_QPS_INIT:
-                return IB_QPS_INIT;
-        case OCRDMA_QPS_RTR:
-                return IB_QPS_RTR;
-        case OCRDMA_QPS_RTS:
-                return IB_QPS_RTS;
-        case OCRDMA_QPS_SQD:
-        case OCRDMA_QPS_SQ_DRAINING:
-                return IB_QPS_SQD;
-        case OCRDMA_QPS_SQE:
-                return IB_QPS_SQE;
-        case OCRDMA_QPS_ERR:
-                return IB_QPS_ERR;
-        };
-        return IB_QPS_ERR;
-}
-
-static enum ocrdma_qp_state get_ocrdma_qp_state(enum ib_qp_state qps)
-{
-        switch (qps) {
-        case IB_QPS_RESET:
-                return OCRDMA_QPS_RST;
-        case IB_QPS_INIT:
-                return OCRDMA_QPS_INIT;
-        case IB_QPS_RTR:
-                return OCRDMA_QPS_RTR;
-        case IB_QPS_RTS:
-                return OCRDMA_QPS_RTS;
-        case IB_QPS_SQD:
-                return OCRDMA_QPS_SQD;
-        case IB_QPS_SQE:
-                return OCRDMA_QPS_SQE;
-        case IB_QPS_ERR:
-                return OCRDMA_QPS_ERR;
-        };
-        return OCRDMA_QPS_ERR;
-}
-
-static int ocrdma_get_mbx_errno(u32 status)
-{
-        int err_num = -EFAULT;
-        u8 mbox_status = (status & OCRDMA_MBX_RSP_STATUS_MASK) >>
-                                        OCRDMA_MBX_RSP_STATUS_SHIFT;
-        u8 add_status = (status & OCRDMA_MBX_RSP_ASTATUS_MASK) >>
-                                        OCRDMA_MBX_RSP_ASTATUS_SHIFT;
-
-        switch (mbox_status) {
-        case OCRDMA_MBX_STATUS_OOR:
-        case OCRDMA_MBX_STATUS_MAX_QP_EXCEEDS:
-                err_num = -EAGAIN;
-                break;
-
-        case OCRDMA_MBX_STATUS_INVALID_PD:
-        case OCRDMA_MBX_STATUS_INVALID_CQ:
-        case OCRDMA_MBX_STATUS_INVALID_SRQ_ID:
-        case OCRDMA_MBX_STATUS_INVALID_QP:
-        case OCRDMA_MBX_STATUS_INVALID_CHANGE:
-        case OCRDMA_MBX_STATUS_MTU_EXCEEDS:
-        case OCRDMA_MBX_STATUS_INVALID_RNR_NAK_TIMER:
-        case OCRDMA_MBX_STATUS_PKEY_INDEX_INVALID:
-        case OCRDMA_MBX_STATUS_PKEY_INDEX_EXCEEDS:
-        case OCRDMA_MBX_STATUS_ILLEGAL_FIELD:
-        case OCRDMA_MBX_STATUS_INVALID_PBL_ENTRY:
-        case OCRDMA_MBX_STATUS_INVALID_LKEY:
-        case OCRDMA_MBX_STATUS_INVALID_VA:
-        case OCRDMA_MBX_STATUS_INVALID_LENGTH:
-        case OCRDMA_MBX_STATUS_INVALID_FBO:
-        case OCRDMA_MBX_STATUS_INVALID_ACC_RIGHTS:
-        case OCRDMA_MBX_STATUS_INVALID_PBE_SIZE:
-        case OCRDMA_MBX_STATUS_ATOMIC_OPS_UNSUP:
-        case OCRDMA_MBX_STATUS_SRQ_ERROR:
-        case OCRDMA_MBX_STATUS_SRQ_SIZE_UNDERUNS:
-                err_num = -EINVAL;
-                break;
-
-        case OCRDMA_MBX_STATUS_PD_INUSE:
-        case OCRDMA_MBX_STATUS_QP_BOUND:
-        case OCRDMA_MBX_STATUS_MW_STILL_BOUND:
-        case OCRDMA_MBX_STATUS_MW_BOUND:
-                err_num = -EBUSY;
-                break;
-
-        case OCRDMA_MBX_STATUS_RECVQ_RQE_EXCEEDS:
-        case OCRDMA_MBX_STATUS_SGE_RECV_EXCEEDS:
-        case OCRDMA_MBX_STATUS_RQE_EXCEEDS:
-        case OCRDMA_MBX_STATUS_SRQ_LIMIT_EXCEEDS:
-        case OCRDMA_MBX_STATUS_ORD_EXCEEDS:
-        case OCRDMA_MBX_STATUS_IRD_EXCEEDS:
-        case OCRDMA_MBX_STATUS_SENDQ_WQE_EXCEEDS:
-        case OCRDMA_MBX_STATUS_SGE_SEND_EXCEEDS:
-        case OCRDMA_MBX_STATUS_SGE_WRITE_EXCEEDS:
-                err_num = -ENOBUFS;
-                break;
-
-        case OCRDMA_MBX_STATUS_FAILED:
-                switch (add_status) {
-                case OCRDMA_MBX_ADDI_STATUS_INSUFFICIENT_RESOURCES:
-                        err_num = -EAGAIN;
-                        break;
-                }
-        default:
-                err_num = -EFAULT;
-        }
-        return err_num;
-}
-
-static int ocrdma_get_mbx_cqe_errno(u16 cqe_status)
-{
-        int err_num = -EINVAL;
-
-        switch (cqe_status) {
-        case OCRDMA_MBX_CQE_STATUS_INSUFFICIENT_PRIVILEDGES:
-                err_num = -EPERM;
-                break;
-        case OCRDMA_MBX_CQE_STATUS_INVALID_PARAMETER:
-                err_num = -EINVAL;
-                break;
-        case OCRDMA_MBX_CQE_STATUS_INSUFFICIENT_RESOURCES:
-        case OCRDMA_MBX_CQE_STATUS_QUEUE_FLUSHING:
-                err_num = -EAGAIN;
-                break;
-        case OCRDMA_MBX_CQE_STATUS_DMA_FAILED:
-                err_num = -EIO;
-                break;
-        }
-        return err_num;
-}
-
-void ocrdma_ring_cq_db(struct ocrdma_dev *dev, u16 cq_id, bool armed,
-                       bool solicited, u16 cqe_popped)
-{
-        u32 val = cq_id & OCRDMA_DB_CQ_RING_ID_MASK;
-
-        val |= ((cq_id & OCRDMA_DB_CQ_RING_ID_EXT_MASK) <<
-             OCRDMA_DB_CQ_RING_ID_EXT_MASK_SHIFT);
-
-        if (armed)
-                val |= (1 << OCRDMA_DB_CQ_REARM_SHIFT);
-        if (solicited)
-                val |= (1 << OCRDMA_DB_CQ_SOLICIT_SHIFT);
-        val |= (cqe_popped << OCRDMA_DB_CQ_NUM_POPPED_SHIFT);
-        iowrite32(val, dev->nic_info.db + OCRDMA_DB_CQ_OFFSET);
-}
-
-static void ocrdma_ring_mq_db(struct ocrdma_dev *dev)
-{
-        u32 val = 0;
-
-        val |= dev->mq.sq.id & OCRDMA_MQ_ID_MASK;
-        val |= 1 << OCRDMA_MQ_NUM_MQE_SHIFT;
-        iowrite32(val, dev->nic_info.db + OCRDMA_DB_MQ_OFFSET);
-}
-
-static void ocrdma_ring_eq_db(struct ocrdma_dev *dev, u16 eq_id,
-                              bool arm, bool clear_int, u16 num_eqe)
-{
-        u32 val = 0;
-
-        val |= eq_id & OCRDMA_EQ_ID_MASK;
-        val |= ((eq_id & OCRDMA_EQ_ID_EXT_MASK) << OCRDMA_EQ_ID_EXT_MASK_SHIFT);
-        if (arm)
-                val |= (1 << OCRDMA_REARM_SHIFT);
-        if (clear_int)
-                val |= (1 << OCRDMA_EQ_CLR_SHIFT);
-        val |= (1 << OCRDMA_EQ_TYPE_SHIFT);
-        val |= (num_eqe << OCRDMA_NUM_EQE_SHIFT);
-        iowrite32(val, dev->nic_info.db + OCRDMA_DB_EQ_OFFSET);
-}
-
-static void ocrdma_init_mch(struct ocrdma_mbx_hdr *cmd_hdr,
-                            u8 opcode, u8 subsys, u32 cmd_len)
-{
-        cmd_hdr->subsys_op = (opcode | (subsys << OCRDMA_MCH_SUBSYS_SHIFT));
-        cmd_hdr->timeout = 20; /* seconds */
-        cmd_hdr->cmd_len = cmd_len - sizeof(struct ocrdma_mbx_hdr);
-}
-
-static void *ocrdma_init_emb_mqe(u8 opcode, u32 cmd_len)
-{
-        struct ocrdma_mqe *mqe;
-
-        mqe = kzalloc(sizeof(struct ocrdma_mqe), GFP_KERNEL);
-        if (!mqe)
-                return NULL;
-        mqe->hdr.spcl_sge_cnt_emb |=
-                (OCRDMA_MQE_EMBEDDED << OCRDMA_MQE_HDR_EMB_SHIFT) &
-                                        OCRDMA_MQE_HDR_EMB_MASK;
-        mqe->hdr.pyld_len = cmd_len - sizeof(struct ocrdma_mqe_hdr);
-
-        ocrdma_init_mch(&mqe->u.emb_req.mch, opcode, OCRDMA_SUBSYS_ROCE,
-                        mqe->hdr.pyld_len);
-        return mqe;
-}
-
-static void ocrdma_free_q(struct ocrdma_dev *dev, struct ocrdma_queue_info *q)
-{
-        dma_free_coherent(&dev->nic_info.pdev->dev, q->size, q->va, q->dma);
-}
-
-static int ocrdma_alloc_q(struct ocrdma_dev *dev,
-                          struct ocrdma_queue_info *q, u16 len, u16 entry_size)
-{
-        memset(q, 0, sizeof(*q));
-        q->len = len;
-        q->entry_size = entry_size;
-        q->size = len * entry_size;
-        q->va = dma_alloc_coherent(&dev->nic_info.pdev->dev, q->size,
-                                   &q->dma, GFP_KERNEL);
-        if (!q->va)
-                return -ENOMEM;
-        memset(q->va, 0, q->size);
-        return 0;
-}
-
-static void ocrdma_build_q_pages(struct ocrdma_pa *q_pa, int cnt,
-                                        dma_addr_t host_pa, int hw_page_size)
-{
-        int i;
-
-        for (i = 0; i < cnt; i++) {
-                q_pa[i].lo = (u32) (host_pa & 0xffffffff);
-                q_pa[i].hi = (u32) upper_32_bits(host_pa);
-                host_pa += hw_page_size;
-        }
-}
-
-static void ocrdma_assign_eq_vect_gen2(struct ocrdma_dev *dev,
-                                       struct ocrdma_eq *eq)
-{
-        /* assign vector and update vector id for next EQ */
-        eq->vector = dev->nic_info.msix.start_vector;
-        dev->nic_info.msix.start_vector += 1;
-}
-
-static void ocrdma_free_eq_vect_gen2(struct ocrdma_dev *dev)
-{
-        /* this assumes that EQs are freed in exactly reverse order
-         * as its allocation.
-         */
-        dev->nic_info.msix.start_vector -= 1;
-}
-
-static int ocrdma_mbx_delete_q(struct ocrdma_dev *dev, struct ocrdma_queue_info *q,
-                               int queue_type)
-{
-        u8 opcode = 0;
-        int status;
-        struct ocrdma_delete_q_req *cmd = dev->mbx_cmd;
-
-        switch (queue_type) {
-        case QTYPE_MCCQ:
-                opcode = OCRDMA_CMD_DELETE_MQ;
-                break;
-        case QTYPE_CQ:
-                opcode = OCRDMA_CMD_DELETE_CQ;
-                break;
-        case QTYPE_EQ:
-                opcode = OCRDMA_CMD_DELETE_EQ;
-                break;
-        default:
-                BUG();
-        }
-        memset(cmd, 0, sizeof(*cmd));
-        ocrdma_init_mch(&cmd->req, opcode, OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-        cmd->id = q->id;
-
-        status = be_roce_mcc_cmd(dev->nic_info.netdev,
-                                 cmd, sizeof(*cmd), NULL, NULL);
-        if (!status)
-                q->created = false;
-        return status;
-}
-
-static int ocrdma_mbx_create_eq(struct ocrdma_dev *dev, struct ocrdma_eq *eq)
-{
-        int status;
-        struct ocrdma_create_eq_req *cmd = dev->mbx_cmd;
-        struct ocrdma_create_eq_rsp *rsp = dev->mbx_cmd;
-
-        memset(cmd, 0, sizeof(*cmd));
-        ocrdma_init_mch(&cmd->req, OCRDMA_CMD_CREATE_EQ, OCRDMA_SUBSYS_COMMON,
-                        sizeof(*cmd));
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY)
-                cmd->req.rsvd_version = 0;
-        else
-                cmd->req.rsvd_version = 2;
-
-        cmd->num_pages = 4;
-        cmd->valid = OCRDMA_CREATE_EQ_VALID;
-        cmd->cnt = 4 << OCRDMA_CREATE_EQ_CNT_SHIFT;
-
-        ocrdma_build_q_pages(&cmd->pa[0], cmd->num_pages, eq->q.dma,
-                             PAGE_SIZE_4K);
-        status = be_roce_mcc_cmd(dev->nic_info.netdev, cmd, sizeof(*cmd), NULL,
-                                 NULL);
-        if (!status) {
-                eq->q.id = rsp->vector_eqid & 0xffff;
-                if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY)
-                        ocrdma_assign_eq_vect_gen2(dev, eq);
-                else {
-                        eq->vector = (rsp->vector_eqid >> 16) & 0xffff;
-                        dev->nic_info.msix.start_vector += 1;
-                }
-                eq->q.created = true;
-        }
-        return status;
-}
-
-static int ocrdma_create_eq(struct ocrdma_dev *dev,
-                            struct ocrdma_eq *eq, u16 q_len)
-{
-        int status;
-
-        status = ocrdma_alloc_q(dev, &eq->q, OCRDMA_EQ_LEN,
-                                sizeof(struct ocrdma_eqe));
-        if (status)
-                return status;
-
-        status = ocrdma_mbx_create_eq(dev, eq);
-        if (status)
-                goto mbx_err;
-        eq->dev = dev;
-        ocrdma_ring_eq_db(dev, eq->q.id, true, true, 0);
-
-        return 0;
-mbx_err:
-        ocrdma_free_q(dev, &eq->q);
-        return status;
-}
-
-static int ocrdma_get_irq(struct ocrdma_dev *dev, struct ocrdma_eq *eq)
-{
-        int irq;
-
-        if (dev->nic_info.intr_mode == BE_INTERRUPT_MODE_INTX)
-                irq = dev->nic_info.pdev->irq;
-        else
-                irq = dev->nic_info.msix.vector_list[eq->vector];
-        return irq;
-}
-
-static void _ocrdma_destroy_eq(struct ocrdma_dev *dev, struct ocrdma_eq *eq)
-{
-        if (eq->q.created) {
-                ocrdma_mbx_delete_q(dev, &eq->q, QTYPE_EQ);
-                if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY)
-                        ocrdma_free_eq_vect_gen2(dev);
-                ocrdma_free_q(dev, &eq->q);
-        }
-}
-
-static void ocrdma_destroy_eq(struct ocrdma_dev *dev, struct ocrdma_eq *eq)
-{
-        int irq;
-
-        /* disarm EQ so that interrupts are not generated
-         * during freeing and EQ delete is in progress.
-         */
-        ocrdma_ring_eq_db(dev, eq->q.id, false, false, 0);
-
-        irq = ocrdma_get_irq(dev, eq);
-        free_irq(irq, eq);
-        _ocrdma_destroy_eq(dev, eq);
-}
-
-static void ocrdma_destroy_qp_eqs(struct ocrdma_dev *dev)
-{
-        int i;
-
-        /* deallocate the data path eqs */
-        for (i = 0; i < dev->eq_cnt; i++)
-                ocrdma_destroy_eq(dev, &dev->qp_eq_tbl[i]);
-}
-
-static int ocrdma_mbx_mq_cq_create(struct ocrdma_dev *dev,
-                                   struct ocrdma_queue_info *cq,
-                                   struct ocrdma_queue_info *eq)
-{
-        struct ocrdma_create_cq_cmd *cmd = dev->mbx_cmd;
-        struct ocrdma_create_cq_cmd_rsp *rsp = dev->mbx_cmd;
-        int status;
-
-        memset(cmd, 0, sizeof(*cmd));
-        ocrdma_init_mch(&cmd->req, OCRDMA_CMD_CREATE_CQ,
-                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-
-        cmd->pgsz_pgcnt = PAGES_4K_SPANNED(cq->va, cq->size);
-        cmd->ev_cnt_flags = OCRDMA_CREATE_CQ_DEF_FLAGS;
-        cmd->eqn = (eq->id << OCRDMA_CREATE_CQ_EQID_SHIFT);
-
-        ocrdma_build_q_pages(&cmd->pa[0], cmd->pgsz_pgcnt,
-                             cq->dma, PAGE_SIZE_4K);
-        status = be_roce_mcc_cmd(dev->nic_info.netdev,
-                                 cmd, sizeof(*cmd), NULL, NULL);
-        if (!status) {
-                cq->id = (rsp->cq_id & OCRDMA_CREATE_CQ_RSP_CQ_ID_MASK);
-                cq->created = true;
-        }
-        return status;
-}
-
-static u32 ocrdma_encoded_q_len(int q_len)
-{
-        u32 len_encoded = fls(q_len);   /* log2(len) + 1 */
-
-        if (len_encoded == 16)
-                len_encoded = 0;
-        return len_encoded;
-}
-
-static int ocrdma_mbx_create_mq(struct ocrdma_dev *dev,
-                                struct ocrdma_queue_info *mq,
-                                struct ocrdma_queue_info *cq)
-{
-        int num_pages, status;
-        struct ocrdma_create_mq_req *cmd = dev->mbx_cmd;
-        struct ocrdma_create_mq_rsp *rsp = dev->mbx_cmd;
-        struct ocrdma_pa *pa;
-
-        memset(cmd, 0, sizeof(*cmd));
-        num_pages = PAGES_4K_SPANNED(mq->va, mq->size);
-
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                ocrdma_init_mch(&cmd->req, OCRDMA_CMD_CREATE_MQ,
-                                OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-                cmd->v0.pages = num_pages;
-                cmd->v0.async_cqid_valid = OCRDMA_CREATE_MQ_ASYNC_CQ_VALID;
-                cmd->v0.async_cqid_valid = (cq->id << 1);
-                cmd->v0.cqid_ringsize |= (ocrdma_encoded_q_len(mq->len) <<
-                                             OCRDMA_CREATE_MQ_RING_SIZE_SHIFT);
-                cmd->v0.cqid_ringsize |=
-                        (cq->id << OCRDMA_CREATE_MQ_V0_CQ_ID_SHIFT);
-                cmd->v0.valid = OCRDMA_CREATE_MQ_VALID;
-                pa = &cmd->v0.pa[0];
-        } else {
-                ocrdma_init_mch(&cmd->req, OCRDMA_CMD_CREATE_MQ_EXT,
-                                OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-                cmd->req.rsvd_version = 1;
-                cmd->v1.cqid_pages = num_pages;
-                cmd->v1.cqid_pages |= (cq->id << OCRDMA_CREATE_MQ_CQ_ID_SHIFT);
-                cmd->v1.async_cqid_valid = OCRDMA_CREATE_MQ_ASYNC_CQ_VALID;
-                cmd->v1.async_event_bitmap = Bit(20);
-                cmd->v1.async_cqid_ringsize = cq->id;
-                cmd->v1.async_cqid_ringsize |= (ocrdma_encoded_q_len(mq->len) <<
-                                             OCRDMA_CREATE_MQ_RING_SIZE_SHIFT);
-                cmd->v1.valid = OCRDMA_CREATE_MQ_VALID;
-                pa = &cmd->v1.pa[0];
-        }
-        ocrdma_build_q_pages(pa, num_pages, mq->dma, PAGE_SIZE_4K);
-        status = be_roce_mcc_cmd(dev->nic_info.netdev,
-                                 cmd, sizeof(*cmd), NULL, NULL);
-        if (!status) {
-                mq->id = rsp->id;
-                mq->created = true;
-        }
-        return status;
-}
-
-static int ocrdma_create_mq(struct ocrdma_dev *dev)
-{
-        int status;
-
-        /* Alloc completion queue for Mailbox queue */
-        status = ocrdma_alloc_q(dev, &dev->mq.cq, OCRDMA_MQ_CQ_LEN,
-                                sizeof(struct ocrdma_mcqe));
-        if (status)
-                goto alloc_err;
-
-        status = ocrdma_mbx_mq_cq_create(dev, &dev->mq.cq, &dev->meq.q);
-        if (status)
-                goto mbx_cq_free;
-
-        memset(&dev->mqe_ctx, 0, sizeof(dev->mqe_ctx));
-        init_waitqueue_head(&dev->mqe_ctx.cmd_wait);
-        mutex_init(&dev->mqe_ctx.lock);
-
-        /* Alloc Mailbox queue */
-        status = ocrdma_alloc_q(dev, &dev->mq.sq, OCRDMA_MQ_LEN,
-                                sizeof(struct ocrdma_mqe));
-        if (status)
-                goto mbx_cq_destroy;
-        status = ocrdma_mbx_create_mq(dev, &dev->mq.sq, &dev->mq.cq);
-        if (status)
-                goto mbx_q_free;
-        ocrdma_ring_cq_db(dev, dev->mq.cq.id, true, false, 0);
-        return 0;
-
-mbx_q_free:
-        ocrdma_free_q(dev, &dev->mq.sq);
-mbx_cq_destroy:
-        ocrdma_mbx_delete_q(dev, &dev->mq.cq, QTYPE_CQ);
-mbx_cq_free:
-        ocrdma_free_q(dev, &dev->mq.cq);
-alloc_err:
-        return status;
-}
-
-static void ocrdma_destroy_mq(struct ocrdma_dev *dev)
-{
-        struct ocrdma_queue_info *mbxq, *cq;
-
-        /* mqe_ctx lock synchronizes with any other pending cmds. */
-        mutex_lock(&dev->mqe_ctx.lock);
-        mbxq = &dev->mq.sq;
-        if (mbxq->created) {
-                ocrdma_mbx_delete_q(dev, mbxq, QTYPE_MCCQ);
-                ocrdma_free_q(dev, mbxq);
-        }
-        mutex_unlock(&dev->mqe_ctx.lock);
-
-        cq = &dev->mq.cq;
-        if (cq->created) {
-                ocrdma_mbx_delete_q(dev, cq, QTYPE_CQ);
-                ocrdma_free_q(dev, cq);
-        }
-}
-
-static void ocrdma_process_qpcat_error(struct ocrdma_dev *dev,
-                                       struct ocrdma_qp *qp)
-{
-        enum ib_qp_state new_ib_qps = IB_QPS_ERR;
-        enum ib_qp_state old_ib_qps;
-
-        if (qp == NULL)
-                BUG();
-        ocrdma_qp_state_machine(qp, new_ib_qps, &old_ib_qps);
-}
-
-static void ocrdma_dispatch_ibevent(struct ocrdma_dev *dev,
-                                    struct ocrdma_ae_mcqe *cqe)
-{
-        struct ocrdma_qp *qp = NULL;
-        struct ocrdma_cq *cq = NULL;
-        struct ib_event ib_evt;
-        int cq_event = 0;
-        int qp_event = 1;
-        int srq_event = 0;
-        int dev_event = 0;
-        int type = (cqe->valid_ae_event & OCRDMA_AE_MCQE_EVENT_TYPE_MASK) >>
-            OCRDMA_AE_MCQE_EVENT_TYPE_SHIFT;
-
-        if (cqe->qpvalid_qpid & OCRDMA_AE_MCQE_QPVALID)
-                qp = dev->qp_tbl[cqe->qpvalid_qpid & OCRDMA_AE_MCQE_QPID_MASK];
-        if (cqe->cqvalid_cqid & OCRDMA_AE_MCQE_CQVALID)
-                cq = dev->cq_tbl[cqe->cqvalid_cqid & OCRDMA_AE_MCQE_CQID_MASK];
-
-        ib_evt.device = &dev->ibdev;
-
-        switch (type) {
-        case OCRDMA_CQ_ERROR:
-                ib_evt.element.cq = &cq->ibcq;
-                ib_evt.event = IB_EVENT_CQ_ERR;
-                cq_event = 1;
-                qp_event = 0;
-                break;
-        case OCRDMA_CQ_OVERRUN_ERROR:
-                ib_evt.element.cq = &cq->ibcq;
-                ib_evt.event = IB_EVENT_CQ_ERR;
-                break;
-        case OCRDMA_CQ_QPCAT_ERROR:
-                ib_evt.element.qp = &qp->ibqp;
-                ib_evt.event = IB_EVENT_QP_FATAL;
-                ocrdma_process_qpcat_error(dev, qp);
-                break;
-        case OCRDMA_QP_ACCESS_ERROR:
-                ib_evt.element.qp = &qp->ibqp;
-                ib_evt.event = IB_EVENT_QP_ACCESS_ERR;
-                break;
-        case OCRDMA_QP_COMM_EST_EVENT:
-                ib_evt.element.qp = &qp->ibqp;
-                ib_evt.event = IB_EVENT_COMM_EST;
-                break;
-        case OCRDMA_SQ_DRAINED_EVENT:
-                ib_evt.element.qp = &qp->ibqp;
-                ib_evt.event = IB_EVENT_SQ_DRAINED;
-                break;
-        case OCRDMA_DEVICE_FATAL_EVENT:
-                ib_evt.element.port_num = 1;
-                ib_evt.event = IB_EVENT_DEVICE_FATAL;
-                qp_event = 0;
-                dev_event = 1;
-                break;
-        case OCRDMA_SRQCAT_ERROR:
-                ib_evt.element.srq = &qp->srq->ibsrq;
-                ib_evt.event = IB_EVENT_SRQ_ERR;
-                srq_event = 1;
-                qp_event = 0;
-                break;
-        case OCRDMA_SRQ_LIMIT_EVENT:
-                ib_evt.element.srq = &qp->srq->ibsrq;
-                ib_evt.event = IB_EVENT_SRQ_LIMIT_REACHED;
-                srq_event = 1;
-                qp_event = 0;
-                break;
-        case OCRDMA_QP_LAST_WQE_EVENT:
-                ib_evt.element.qp = &qp->ibqp;
-                ib_evt.event = IB_EVENT_QP_LAST_WQE_REACHED;
-                break;
-        default:
-                cq_event = 0;
-                qp_event = 0;
-                srq_event = 0;
-                dev_event = 0;
-                ocrdma_err("%s() unknown type=0x%x\n", __func__, type);
-                break;
-        }
-
-        if (qp_event) {
-                if (qp->ibqp.event_handler)
-                        qp->ibqp.event_handler(&ib_evt, qp->ibqp.qp_context);
-        } else if (cq_event) {
-                if (cq->ibcq.event_handler)
-                        cq->ibcq.event_handler(&ib_evt, cq->ibcq.cq_context);
-        } else if (srq_event) {
-                if (qp->srq->ibsrq.event_handler)
-                        qp->srq->ibsrq.event_handler(&ib_evt,
-                                                     qp->srq->ibsrq.
-                                                     srq_context);
-        } else if (dev_event)
-                ib_dispatch_event(&ib_evt);
-
-}
-
-static void ocrdma_process_acqe(struct ocrdma_dev *dev, void *ae_cqe)
-{
-        /* async CQE processing */
-        struct ocrdma_ae_mcqe *cqe = ae_cqe;
-        u32 evt_code = (cqe->valid_ae_event & OCRDMA_AE_MCQE_EVENT_CODE_MASK) >>
-                        OCRDMA_AE_MCQE_EVENT_CODE_SHIFT;
-
-        if (evt_code == OCRDMA_ASYNC_EVE_CODE)
-                ocrdma_dispatch_ibevent(dev, cqe);
-        else
-                ocrdma_err("%s(%d) invalid evt code=0x%x\n",
-                           __func__, dev->id, evt_code);
-}
-
-static void ocrdma_process_mcqe(struct ocrdma_dev *dev, struct ocrdma_mcqe *cqe)
-{
-        if (dev->mqe_ctx.tag == cqe->tag_lo && dev->mqe_ctx.cmd_done == false) {
-                dev->mqe_ctx.cqe_status = (cqe->status &
-                     OCRDMA_MCQE_STATUS_MASK) >> OCRDMA_MCQE_STATUS_SHIFT;
-                dev->mqe_ctx.ext_status =
-                    (cqe->status & OCRDMA_MCQE_ESTATUS_MASK)
-                    >> OCRDMA_MCQE_ESTATUS_SHIFT;
-                dev->mqe_ctx.cmd_done = true;
-                wake_up(&dev->mqe_ctx.cmd_wait);
-        } else
-                ocrdma_err("%s() cqe for invalid tag0x%x.expected=0x%x\n",
-                           __func__, cqe->tag_lo, dev->mqe_ctx.tag);
-}
-
-static int ocrdma_mq_cq_handler(struct ocrdma_dev *dev, u16 cq_id)
-{
-        u16 cqe_popped = 0;
-        struct ocrdma_mcqe *cqe;
-
-        while (1) {
-                cqe = ocrdma_get_mcqe(dev);
-                if (cqe == NULL)
-                        break;
-                ocrdma_le32_to_cpu(cqe, sizeof(*cqe));
-                cqe_popped += 1;
-                if (cqe->valid_ae_cmpl_cons & OCRDMA_MCQE_AE_MASK)
-                        ocrdma_process_acqe(dev, cqe);
-                else if (cqe->valid_ae_cmpl_cons & OCRDMA_MCQE_CMPL_MASK)
-                        ocrdma_process_mcqe(dev, cqe);
-                else
-                        ocrdma_err("%s() cqe->compl is not set.\n", __func__);
-                memset(cqe, 0, sizeof(struct ocrdma_mcqe));
-                ocrdma_mcq_inc_tail(dev);
-        }
-        ocrdma_ring_cq_db(dev, dev->mq.cq.id, true, false, cqe_popped);
-        return 0;
-}
-
-static void ocrdma_qp_buddy_cq_handler(struct ocrdma_dev *dev,
-                                       struct ocrdma_cq *cq)
-{
-        unsigned long flags;
-        struct ocrdma_qp *qp;
-        bool buddy_cq_found = false;
-        /* Go through list of QPs in error state which are using this CQ
-         * and invoke its callback handler to trigger CQE processing for
-         * error/flushed CQE. It is rare to find more than few entries in
-         * this list as most consumers stops after getting error CQE.
-         * List is traversed only once when a matching buddy cq found for a QP.
-         */
-        spin_lock_irqsave(&dev->flush_q_lock, flags);
-        list_for_each_entry(qp, &cq->sq_head, sq_entry) {
-                if (qp->srq)
-                        continue;
-                /* if wq and rq share the same cq, than comp_handler
-                 * is already invoked.
-                 */
-                if (qp->sq_cq == qp->rq_cq)
-                        continue;
-                /* if completion came on sq, rq's cq is buddy cq.
-                 * if completion came on rq, sq's cq is buddy cq.
-                 */
-                if (qp->sq_cq == cq)
-                        cq = qp->rq_cq;
-                else
-                        cq = qp->sq_cq;
-                buddy_cq_found = true;
-                break;
-        }
-        spin_unlock_irqrestore(&dev->flush_q_lock, flags);
-        if (buddy_cq_found == false)
-                return;
-        if (cq->ibcq.comp_handler) {
-                spin_lock_irqsave(&cq->comp_handler_lock, flags);
-                (*cq->ibcq.comp_handler) (&cq->ibcq, cq->ibcq.cq_context);
-                spin_unlock_irqrestore(&cq->comp_handler_lock, flags);
-        }
-}
-
-static void ocrdma_qp_cq_handler(struct ocrdma_dev *dev, u16 cq_idx)
-{
-        unsigned long flags;
-        struct ocrdma_cq *cq;
-
-        if (cq_idx >= OCRDMA_MAX_CQ)
-                BUG();
-
-        cq = dev->cq_tbl[cq_idx];
-        if (cq == NULL) {
-                ocrdma_err("%s%d invalid id=0x%x\n", __func__, dev->id, cq_idx);
-                return;
-        }
-        spin_lock_irqsave(&cq->cq_lock, flags);
-        cq->armed = false;
-        cq->solicited = false;
-        spin_unlock_irqrestore(&cq->cq_lock, flags);
-
-        ocrdma_ring_cq_db(dev, cq->id, false, false, 0);
-
-        if (cq->ibcq.comp_handler) {
-                spin_lock_irqsave(&cq->comp_handler_lock, flags);
-                (*cq->ibcq.comp_handler) (&cq->ibcq, cq->ibcq.cq_context);
-                spin_unlock_irqrestore(&cq->comp_handler_lock, flags);
-        }
-        ocrdma_qp_buddy_cq_handler(dev, cq);
-}
-
-static void ocrdma_cq_handler(struct ocrdma_dev *dev, u16 cq_id)
-{
-        /* process the MQ-CQE. */
-        if (cq_id == dev->mq.cq.id)
-                ocrdma_mq_cq_handler(dev, cq_id);
-        else
-                ocrdma_qp_cq_handler(dev, cq_id);
-}
-
-static irqreturn_t ocrdma_irq_handler(int irq, void *handle)
-{
-        struct ocrdma_eq *eq = handle;
-        struct ocrdma_dev *dev = eq->dev;
-        struct ocrdma_eqe eqe;
-        struct ocrdma_eqe *ptr;
-        u16 eqe_popped = 0;
-        u16 cq_id;
-        while (1) {
-                ptr = ocrdma_get_eqe(eq);
-                eqe = *ptr;
-                ocrdma_le32_to_cpu(&eqe, sizeof(eqe));
-                if ((eqe.id_valid & OCRDMA_EQE_VALID_MASK) == 0)
-                        break;
-                eqe_popped += 1;
-                ptr->id_valid = 0;
-                /* check whether its CQE or not. */
-                if ((eqe.id_valid & OCRDMA_EQE_FOR_CQE_MASK) == 0) {
-                        cq_id = eqe.id_valid >> OCRDMA_EQE_RESOURCE_ID_SHIFT;
-                        ocrdma_cq_handler(dev, cq_id);
-                }
-                ocrdma_eq_inc_tail(eq);
-        }
-        ocrdma_ring_eq_db(dev, eq->q.id, true, true, eqe_popped);
-        /* Ring EQ doorbell with num_popped to 0 to enable interrupts again. */
-        if (dev->nic_info.intr_mode == BE_INTERRUPT_MODE_INTX)
-                ocrdma_ring_eq_db(dev, eq->q.id, true, true, 0);
-        return IRQ_HANDLED;
-}
-
-static void ocrdma_post_mqe(struct ocrdma_dev *dev, struct ocrdma_mqe *cmd)
-{
-        struct ocrdma_mqe *mqe;
-
-        dev->mqe_ctx.tag = dev->mq.sq.head;
-        dev->mqe_ctx.cmd_done = false;
-        mqe = ocrdma_get_mqe(dev);
-        cmd->hdr.tag_lo = dev->mq.sq.head;
-        ocrdma_copy_cpu_to_le32(mqe, cmd, sizeof(*mqe));
-        /* make sure descriptor is written before ringing doorbell */
-        wmb();
-        ocrdma_mq_inc_head(dev);
-        ocrdma_ring_mq_db(dev);
-}
-
-static int ocrdma_wait_mqe_cmpl(struct ocrdma_dev *dev)
-{
-        long status;
-        /* 30 sec timeout */
-        status = wait_event_timeout(dev->mqe_ctx.cmd_wait,
-                                    (dev->mqe_ctx.cmd_done != false),
-                                    msecs_to_jiffies(30000));
-        if (status)
-                return 0;
-        else
-                return -1;
-}
-
-/* issue a mailbox command on the MQ */
-static int ocrdma_mbx_cmd(struct ocrdma_dev *dev, struct ocrdma_mqe *mqe)
-{
-        int status = 0;
-        u16 cqe_status, ext_status;
-        struct ocrdma_mqe *rsp;
-
-        mutex_lock(&dev->mqe_ctx.lock);
-        ocrdma_post_mqe(dev, mqe);
-        status = ocrdma_wait_mqe_cmpl(dev);
-        if (status)
-                goto mbx_err;
-        cqe_status = dev->mqe_ctx.cqe_status;
-        ext_status = dev->mqe_ctx.ext_status;
-        rsp = ocrdma_get_mqe_rsp(dev);
-        ocrdma_copy_le32_to_cpu(mqe, rsp, (sizeof(*mqe)));
-        if (cqe_status || ext_status) {
-                ocrdma_err
-                    ("%s() opcode=0x%x, cqe_status=0x%x, ext_status=0x%x\n",
-                     __func__,
-                     (rsp->u.rsp.subsys_op & OCRDMA_MBX_RSP_OPCODE_MASK) >>
-                     OCRDMA_MBX_RSP_OPCODE_SHIFT, cqe_status, ext_status);
-                status = ocrdma_get_mbx_cqe_errno(cqe_status);
-                goto mbx_err;
-        }
-        if (mqe->u.rsp.status & OCRDMA_MBX_RSP_STATUS_MASK)
-                status = ocrdma_get_mbx_errno(mqe->u.rsp.status);
-mbx_err:
-        mutex_unlock(&dev->mqe_ctx.lock);
-        return status;
-}
-
-static void ocrdma_get_attr(struct ocrdma_dev *dev,
-                              struct ocrdma_dev_attr *attr,
-                              struct ocrdma_mbx_query_config *rsp)
-{
-        attr->max_pd =
-            (rsp->max_pd_ca_ack_delay & OCRDMA_MBX_QUERY_CFG_MAX_PD_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_PD_SHIFT;
-        attr->max_qp =
-            (rsp->qp_srq_cq_ird_ord & OCRDMA_MBX_QUERY_CFG_MAX_QP_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_QP_SHIFT;
-        attr->max_send_sge = ((rsp->max_write_send_sge &
-                               OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK) >>
-                              OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT);
-        attr->max_recv_sge = (rsp->max_write_send_sge &
-                              OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT;
-        attr->max_srq_sge = (rsp->max_srq_rqe_sge &
-                              OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET;
-        attr->max_ord_per_qp = (rsp->max_ird_ord_per_qp &
-                                OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_SHIFT;
-        attr->max_ird_per_qp = (rsp->max_ird_ord_per_qp &
-                                OCRDMA_MBX_QUERY_CFG_MAX_IRD_PER_QP_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_MAX_IRD_PER_QP_SHIFT;
-        attr->cq_overflow_detect = (rsp->qp_srq_cq_ird_ord &
-                                    OCRDMA_MBX_QUERY_CFG_CQ_OVERFLOW_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_CQ_OVERFLOW_SHIFT;
-        attr->srq_supported = (rsp->qp_srq_cq_ird_ord &
-                               OCRDMA_MBX_QUERY_CFG_SRQ_SUPPORTED_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_SRQ_SUPPORTED_SHIFT;
-        attr->local_ca_ack_delay = (rsp->max_pd_ca_ack_delay &
-                                    OCRDMA_MBX_QUERY_CFG_CA_ACK_DELAY_MASK) >>
-            OCRDMA_MBX_QUERY_CFG_CA_ACK_DELAY_SHIFT;
-        attr->max_mr = rsp->max_mr;
-        attr->max_mr_size = ~0ull;
-        attr->max_fmr = 0;
-        attr->max_pages_per_frmr = rsp->max_pages_per_frmr;
-        attr->max_num_mr_pbl = rsp->max_num_mr_pbl;
-        attr->max_cqe = rsp->max_cq_cqes_per_cq &
-                        OCRDMA_MBX_QUERY_CFG_MAX_CQES_PER_CQ_MASK;
-        attr->wqe_size = ((rsp->wqe_rqe_stride_max_dpp_cqs &
-                OCRDMA_MBX_QUERY_CFG_MAX_WQE_SIZE_MASK) >>
-                OCRDMA_MBX_QUERY_CFG_MAX_WQE_SIZE_OFFSET) *
-                OCRDMA_WQE_STRIDE;
-        attr->rqe_size = ((rsp->wqe_rqe_stride_max_dpp_cqs &
-                OCRDMA_MBX_QUERY_CFG_MAX_RQE_SIZE_MASK) >>
-                OCRDMA_MBX_QUERY_CFG_MAX_RQE_SIZE_OFFSET) *
-                OCRDMA_WQE_STRIDE;
-        attr->max_inline_data =
-            attr->wqe_size - (sizeof(struct ocrdma_hdr_wqe) +
-                              sizeof(struct ocrdma_sge));
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                attr->ird = 1;
-                attr->ird_page_size = OCRDMA_MIN_Q_PAGE_SIZE;
-                attr->num_ird_pages = MAX_OCRDMA_IRD_PAGES;
-        }
-        dev->attr.max_wqe = rsp->max_wqes_rqes_per_q >>
-                 OCRDMA_MBX_QUERY_CFG_MAX_WQES_PER_WQ_OFFSET;
-        dev->attr.max_rqe = rsp->max_wqes_rqes_per_q &
-                OCRDMA_MBX_QUERY_CFG_MAX_RQES_PER_RQ_MASK;
-}
-
-static int ocrdma_check_fw_config(struct ocrdma_dev *dev,
-                                   struct ocrdma_fw_conf_rsp *conf)
-{
-        u32 fn_mode;
-
-        fn_mode = conf->fn_mode & OCRDMA_FN_MODE_RDMA;
-        if (fn_mode != OCRDMA_FN_MODE_RDMA)
-                return -EINVAL;
-        dev->base_eqid = conf->base_eqid;
-        dev->max_eq = conf->max_eq;
-        dev->attr.max_cq = OCRDMA_MAX_CQ - 1;
-        return 0;
-}
-
-/* can be issued only during init time. */
-static int ocrdma_mbx_query_fw_ver(struct ocrdma_dev *dev)
-{
-        int status = -ENOMEM;
-        struct ocrdma_mqe *cmd;
-        struct ocrdma_fw_ver_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_GET_FW_VER, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        ocrdma_init_mch((struct ocrdma_mbx_hdr *)&cmd->u.cmd[0],
-                        OCRDMA_CMD_GET_FW_VER,
-                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_fw_ver_rsp *)cmd;
-        memset(&dev->attr.fw_ver[0], 0, sizeof(dev->attr.fw_ver));
-        memcpy(&dev->attr.fw_ver[0], &rsp->running_ver[0],
-               sizeof(rsp->running_ver));
-        ocrdma_le32_to_cpu(dev->attr.fw_ver, sizeof(rsp->running_ver));
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-/* can be issued only during init time. */
-static int ocrdma_mbx_query_fw_config(struct ocrdma_dev *dev)
-{
-        int status = -ENOMEM;
-        struct ocrdma_mqe *cmd;
-        struct ocrdma_fw_conf_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_GET_FW_CONFIG, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        ocrdma_init_mch((struct ocrdma_mbx_hdr *)&cmd->u.cmd[0],
-                        OCRDMA_CMD_GET_FW_CONFIG,
-                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_fw_conf_rsp *)cmd;
-        status = ocrdma_check_fw_config(dev, rsp);
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-static int ocrdma_mbx_query_dev(struct ocrdma_dev *dev)
-{
-        int status = -ENOMEM;
-        struct ocrdma_mbx_query_config *rsp;
-        struct ocrdma_mqe *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_QUERY_CONFIG, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_mbx_query_config *)cmd;
-        ocrdma_get_attr(dev, &dev->attr, rsp);
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_alloc_pd(struct ocrdma_dev *dev, struct ocrdma_pd *pd)
-{
-        int status = -ENOMEM;
-        struct ocrdma_alloc_pd *cmd;
-        struct ocrdma_alloc_pd_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_ALLOC_PD, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        if (pd->dpp_enabled)
-                cmd->enable_dpp_rsvd |= OCRDMA_ALLOC_PD_ENABLE_DPP;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_alloc_pd_rsp *)cmd;
-        pd->id = rsp->dpp_page_pdid & OCRDMA_ALLOC_PD_RSP_PDID_MASK;
-        if (rsp->dpp_page_pdid & OCRDMA_ALLOC_PD_RSP_DPP) {
-                pd->dpp_enabled = true;
-                pd->dpp_page = rsp->dpp_page_pdid >>
-                                OCRDMA_ALLOC_PD_RSP_DPP_PAGE_SHIFT;
-        } else {
-                pd->dpp_enabled = false;
-                pd->num_dpp_qp = 0;
-        }
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_dealloc_pd(struct ocrdma_dev *dev, struct ocrdma_pd *pd)
-{
-        int status = -ENOMEM;
-        struct ocrdma_dealloc_pd *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DEALLOC_PD, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->id = pd->id;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        kfree(cmd);
-        return status;
-}
-
-static int ocrdma_build_q_conf(u32 *num_entries, int entry_size,
-                               int *num_pages, int *page_size)
-{
-        int i;
-        int mem_size;
-
-        *num_entries = roundup_pow_of_two(*num_entries);
-        mem_size = *num_entries * entry_size;
-        /* find the possible lowest possible multiplier */
-        for (i = 0; i < OCRDMA_MAX_Q_PAGE_SIZE_CNT; i++) {
-                if (mem_size <= (OCRDMA_Q_PAGE_BASE_SIZE << i))
-                        break;
-        }
-        if (i >= OCRDMA_MAX_Q_PAGE_SIZE_CNT)
-                return -EINVAL;
-        mem_size = roundup(mem_size,
-                       ((OCRDMA_Q_PAGE_BASE_SIZE << i) / OCRDMA_MAX_Q_PAGES));
-        *num_pages =
-            mem_size / ((OCRDMA_Q_PAGE_BASE_SIZE << i) / OCRDMA_MAX_Q_PAGES);
-        *page_size = ((OCRDMA_Q_PAGE_BASE_SIZE << i) / OCRDMA_MAX_Q_PAGES);
-        *num_entries = mem_size / entry_size;
-        return 0;
-}
-
-static int ocrdma_mbx_create_ah_tbl(struct ocrdma_dev *dev)
-{
-        int i ;
-        int status = 0;
-        int max_ah;
-        struct ocrdma_create_ah_tbl *cmd;
-        struct ocrdma_create_ah_tbl_rsp *rsp;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        dma_addr_t pa;
-        struct ocrdma_pbe *pbes;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_AH_TBL, sizeof(*cmd));
-        if (!cmd)
-                return status;
-
-        max_ah = OCRDMA_MAX_AH;
-        dev->av_tbl.size = sizeof(struct ocrdma_av) * max_ah;
-
-        /* number of PBEs in PBL */
-        cmd->ah_conf = (OCRDMA_AH_TBL_PAGES <<
-                                OCRDMA_CREATE_AH_NUM_PAGES_SHIFT) &
-                                OCRDMA_CREATE_AH_NUM_PAGES_MASK;
-
-        /* page size */
-        for (i = 0; i < OCRDMA_MAX_Q_PAGE_SIZE_CNT; i++) {
-                if (PAGE_SIZE == (OCRDMA_MIN_Q_PAGE_SIZE << i))
-                        break;
-        }
-        cmd->ah_conf |= (i << OCRDMA_CREATE_AH_PAGE_SIZE_SHIFT) &
-                                OCRDMA_CREATE_AH_PAGE_SIZE_MASK;
-
-        /* ah_entry size */
-        cmd->ah_conf |= (sizeof(struct ocrdma_av) <<
-                                OCRDMA_CREATE_AH_ENTRY_SIZE_SHIFT) &
-                                OCRDMA_CREATE_AH_ENTRY_SIZE_MASK;
-
-        dev->av_tbl.pbl.va = dma_alloc_coherent(&pdev->dev, PAGE_SIZE,
-                                                &dev->av_tbl.pbl.pa,
-                                                GFP_KERNEL);
-        if (dev->av_tbl.pbl.va == NULL)
-                goto mem_err;
-
-        dev->av_tbl.va = dma_alloc_coherent(&pdev->dev, dev->av_tbl.size,
-                                            &pa, GFP_KERNEL);
-        if (dev->av_tbl.va == NULL)
-                goto mem_err_ah;
-        dev->av_tbl.pa = pa;
-        dev->av_tbl.num_ah = max_ah;
-        memset(dev->av_tbl.va, 0, dev->av_tbl.size);
-
-        pbes = (struct ocrdma_pbe *)dev->av_tbl.pbl.va;
-        for (i = 0; i < dev->av_tbl.size / OCRDMA_MIN_Q_PAGE_SIZE; i++) {
-                pbes[i].pa_lo = (u32) (pa & 0xffffffff);
-                pbes[i].pa_hi = (u32) upper_32_bits(pa);
-                pa += PAGE_SIZE;
-        }
-        cmd->tbl_addr[0].lo = (u32)(dev->av_tbl.pbl.pa & 0xFFFFFFFF);
-        cmd->tbl_addr[0].hi = (u32)upper_32_bits(dev->av_tbl.pbl.pa);
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_create_ah_tbl_rsp *)cmd;
-        dev->av_tbl.ahid = rsp->ahid & 0xFFFF;
-        kfree(cmd);
-        return 0;
-
-mbx_err:
-        dma_free_coherent(&pdev->dev, dev->av_tbl.size, dev->av_tbl.va,
-                          dev->av_tbl.pa);
-        dev->av_tbl.va = NULL;
-mem_err_ah:
-        dma_free_coherent(&pdev->dev, PAGE_SIZE, dev->av_tbl.pbl.va,
-                          dev->av_tbl.pbl.pa);
-        dev->av_tbl.pbl.va = NULL;
-        dev->av_tbl.size = 0;
-mem_err:
-        kfree(cmd);
-        return status;
-}
-
-static void ocrdma_mbx_delete_ah_tbl(struct ocrdma_dev *dev)
-{
-        struct ocrdma_delete_ah_tbl *cmd;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-
-        if (dev->av_tbl.va == NULL)
-                return;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DELETE_AH_TBL, sizeof(*cmd));
-        if (!cmd)
-                return;
-        cmd->ahid = dev->av_tbl.ahid;
-
-        ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        dma_free_coherent(&pdev->dev, dev->av_tbl.size, dev->av_tbl.va,
-                          dev->av_tbl.pa);
-        dma_free_coherent(&pdev->dev, PAGE_SIZE, dev->av_tbl.pbl.va,
-                          dev->av_tbl.pbl.pa);
-        kfree(cmd);
-}
-
-/* Multiple CQs uses the EQ. This routine returns least used
- * EQ to associate with CQ. This will distributes the interrupt
- * processing and CPU load to associated EQ, vector and so to that CPU.
- */
-static u16 ocrdma_bind_eq(struct ocrdma_dev *dev)
-{
-        int i, selected_eq = 0, cq_cnt = 0;
-        u16 eq_id;
-
-        mutex_lock(&dev->dev_lock);
-        cq_cnt = dev->qp_eq_tbl[0].cq_cnt;
-        eq_id = dev->qp_eq_tbl[0].q.id;
-        /* find the EQ which is has the least number of
-         * CQs associated with it.
-         */
-        for (i = 0; i < dev->eq_cnt; i++) {
-                if (dev->qp_eq_tbl[i].cq_cnt < cq_cnt) {
-                        cq_cnt = dev->qp_eq_tbl[i].cq_cnt;
-                        eq_id = dev->qp_eq_tbl[i].q.id;
-                        selected_eq = i;
-                }
-        }
-        dev->qp_eq_tbl[selected_eq].cq_cnt += 1;
-        mutex_unlock(&dev->dev_lock);
-        return eq_id;
-}
-
-static void ocrdma_unbind_eq(struct ocrdma_dev *dev, u16 eq_id)
-{
-        int i;
-
-        mutex_lock(&dev->dev_lock);
-        for (i = 0; i < dev->eq_cnt; i++) {
-                if (dev->qp_eq_tbl[i].q.id != eq_id)
-                        continue;
-                dev->qp_eq_tbl[i].cq_cnt -= 1;
-                break;
-        }
-        mutex_unlock(&dev->dev_lock);
-}
-
-int ocrdma_mbx_create_cq(struct ocrdma_dev *dev, struct ocrdma_cq *cq,
-                         int entries, int dpp_cq)
-{
-        int status = -ENOMEM; int max_hw_cqe;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        struct ocrdma_create_cq *cmd;
-        struct ocrdma_create_cq_rsp *rsp;
-        u32 hw_pages, cqe_size, page_size, cqe_count;
-
-        if (dpp_cq)
-                return -EINVAL;
-        if (entries > dev->attr.max_cqe) {
-                ocrdma_err("%s(%d) max_cqe=0x%x, requester_cqe=0x%x\n",
-                           __func__, dev->id, dev->attr.max_cqe, entries);
-                return -EINVAL;
-        }
-        if (dpp_cq && (dev->nic_info.dev_family != OCRDMA_GEN2_FAMILY))
-                return -EINVAL;
-
-        if (dpp_cq) {
-                cq->max_hw_cqe = 1;
-                max_hw_cqe = 1;
-                cqe_size = OCRDMA_DPP_CQE_SIZE;
-                hw_pages = 1;
-        } else {
-                cq->max_hw_cqe = dev->attr.max_cqe;
-                max_hw_cqe = dev->attr.max_cqe;
-                cqe_size = sizeof(struct ocrdma_cqe);
-                hw_pages = OCRDMA_CREATE_CQ_MAX_PAGES;
-        }
-
-        cq->len = roundup(max_hw_cqe * cqe_size, OCRDMA_MIN_Q_PAGE_SIZE);
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_CQ, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        ocrdma_init_mch(&cmd->cmd.req, OCRDMA_CMD_CREATE_CQ,
-                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-        cq->va = dma_alloc_coherent(&pdev->dev, cq->len, &cq->pa, GFP_KERNEL);
-        if (!cq->va) {
-                status = -ENOMEM;
-                goto mem_err;
-        }
-        memset(cq->va, 0, cq->len);
-        page_size = cq->len / hw_pages;
-        cmd->cmd.pgsz_pgcnt = (page_size / OCRDMA_MIN_Q_PAGE_SIZE) <<
-                                        OCRDMA_CREATE_CQ_PAGE_SIZE_SHIFT;
-        cmd->cmd.pgsz_pgcnt |= hw_pages;
-        cmd->cmd.ev_cnt_flags = OCRDMA_CREATE_CQ_DEF_FLAGS;
-
-        if (dev->eq_cnt < 0)
-                goto eq_err;
-        cq->eqn = ocrdma_bind_eq(dev);
-        cmd->cmd.req.rsvd_version = OCRDMA_CREATE_CQ_VER2;
-        cqe_count = cq->len / cqe_size;
-        if (cqe_count > 1024)
-                /* Set cnt to 3 to indicate more than 1024 cq entries */
-                cmd->cmd.ev_cnt_flags |= (0x3 << OCRDMA_CREATE_CQ_CNT_SHIFT);
-        else {
-                u8 count = 0;
-                switch (cqe_count) {
-                case 256:
-                        count = 0;
-                        break;
-                case 512:
-                        count = 1;
-                        break;
-                case 1024:
-                        count = 2;
-                        break;
-                default:
-                        goto mbx_err;
-                }
-                cmd->cmd.ev_cnt_flags |= (count << OCRDMA_CREATE_CQ_CNT_SHIFT);
-        }
-        /* shared eq between all the consumer cqs. */
-        cmd->cmd.eqn = cq->eqn;
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                if (dpp_cq)
-                        cmd->cmd.pgsz_pgcnt |= OCRDMA_CREATE_CQ_DPP <<
-                                OCRDMA_CREATE_CQ_TYPE_SHIFT;
-                cq->phase_change = false;
-                cmd->cmd.cqe_count = (cq->len / cqe_size);
-        } else {
-                cmd->cmd.cqe_count = (cq->len / cqe_size) - 1;
-                cmd->cmd.ev_cnt_flags |= OCRDMA_CREATE_CQ_FLAGS_AUTO_VALID;
-                cq->phase_change = true;
-        }
-
-        ocrdma_build_q_pages(&cmd->cmd.pa[0], hw_pages, cq->pa, page_size);
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-
-        rsp = (struct ocrdma_create_cq_rsp *)cmd;
-        cq->id = (u16) (rsp->rsp.cq_id & OCRDMA_CREATE_CQ_RSP_CQ_ID_MASK);
-        kfree(cmd);
-        return 0;
-mbx_err:
-        ocrdma_unbind_eq(dev, cq->eqn);
-eq_err:
-        dma_free_coherent(&pdev->dev, cq->len, cq->va, cq->pa);
-mem_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_destroy_cq(struct ocrdma_dev *dev, struct ocrdma_cq *cq)
-{
-        int status = -ENOMEM;
-        struct ocrdma_destroy_cq *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DELETE_CQ, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        ocrdma_init_mch(&cmd->req, OCRDMA_CMD_DELETE_CQ,
-                        OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-
-        cmd->bypass_flush_qid |=
-            (cq->id << OCRDMA_DESTROY_CQ_QID_SHIFT) &
-            OCRDMA_DESTROY_CQ_QID_MASK;
-
-        ocrdma_unbind_eq(dev, cq->eqn);
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        dma_free_coherent(&dev->nic_info.pdev->dev, cq->len, cq->va, cq->pa);
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_alloc_lkey(struct ocrdma_dev *dev, struct ocrdma_hw_mr *hwmr,
-                          u32 pdid, int addr_check)
-{
-        int status = -ENOMEM;
-        struct ocrdma_alloc_lkey *cmd;
-        struct ocrdma_alloc_lkey_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_ALLOC_LKEY, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->pdid = pdid;
-        cmd->pbl_sz_flags |= addr_check;
-        cmd->pbl_sz_flags |= (hwmr->fr_mr << OCRDMA_ALLOC_LKEY_FMR_SHIFT);
-        cmd->pbl_sz_flags |=
-            (hwmr->remote_wr << OCRDMA_ALLOC_LKEY_REMOTE_WR_SHIFT);
-        cmd->pbl_sz_flags |=
-            (hwmr->remote_rd << OCRDMA_ALLOC_LKEY_REMOTE_RD_SHIFT);
-        cmd->pbl_sz_flags |=
-            (hwmr->local_wr << OCRDMA_ALLOC_LKEY_LOCAL_WR_SHIFT);
-        cmd->pbl_sz_flags |=
-            (hwmr->remote_atomic << OCRDMA_ALLOC_LKEY_REMOTE_ATOMIC_SHIFT);
-        cmd->pbl_sz_flags |=
-            (hwmr->num_pbls << OCRDMA_ALLOC_LKEY_PBL_SIZE_SHIFT);
-
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_alloc_lkey_rsp *)cmd;
-        hwmr->lkey = rsp->lrkey;
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_dealloc_lkey(struct ocrdma_dev *dev, int fr_mr, u32 lkey)
-{
-        int status = -ENOMEM;
-        struct ocrdma_dealloc_lkey *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DEALLOC_LKEY, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        cmd->lkey = lkey;
-        cmd->rsvd_frmr = fr_mr ? 1 : 0;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-static int ocrdma_mbx_reg_mr(struct ocrdma_dev *dev, struct ocrdma_hw_mr *hwmr,
-                             u32 pdid, u32 pbl_cnt, u32 pbe_size, u32 last)
-{
-        int status = -ENOMEM;
-        int i;
-        struct ocrdma_reg_nsmr *cmd;
-        struct ocrdma_reg_nsmr_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_REGISTER_NSMR, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        cmd->num_pbl_pdid =
-            pdid | (hwmr->num_pbls << OCRDMA_REG_NSMR_NUM_PBL_SHIFT);
-
-        cmd->flags_hpage_pbe_sz |= (hwmr->remote_wr <<
-                                    OCRDMA_REG_NSMR_REMOTE_WR_SHIFT);
-        cmd->flags_hpage_pbe_sz |= (hwmr->remote_rd <<
-                                    OCRDMA_REG_NSMR_REMOTE_RD_SHIFT);
-        cmd->flags_hpage_pbe_sz |= (hwmr->local_wr <<
-                                    OCRDMA_REG_NSMR_LOCAL_WR_SHIFT);
-        cmd->flags_hpage_pbe_sz |= (hwmr->remote_atomic <<
-                                    OCRDMA_REG_NSMR_REMOTE_ATOMIC_SHIFT);
-        cmd->flags_hpage_pbe_sz |= (hwmr->mw_bind <<
-                                    OCRDMA_REG_NSMR_BIND_MEMWIN_SHIFT);
-        cmd->flags_hpage_pbe_sz |= (last << OCRDMA_REG_NSMR_LAST_SHIFT);
-
-        cmd->flags_hpage_pbe_sz |= (hwmr->pbe_size / OCRDMA_MIN_HPAGE_SIZE);
-        cmd->flags_hpage_pbe_sz |= (hwmr->pbl_size / OCRDMA_MIN_HPAGE_SIZE) <<
-                                        OCRDMA_REG_NSMR_HPAGE_SIZE_SHIFT;
-        cmd->totlen_low = hwmr->len;
-        cmd->totlen_high = upper_32_bits(hwmr->len);
-        cmd->fbo_low = (u32) (hwmr->fbo & 0xffffffff);
-        cmd->fbo_high = (u32) upper_32_bits(hwmr->fbo);
-        cmd->va_loaddr = (u32) hwmr->va;
-        cmd->va_hiaddr = (u32) upper_32_bits(hwmr->va);
-
-        for (i = 0; i < pbl_cnt; i++) {
-                cmd->pbl[i].lo = (u32) (hwmr->pbl_table[i].pa & 0xffffffff);
-                cmd->pbl[i].hi = upper_32_bits(hwmr->pbl_table[i].pa);
-        }
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_reg_nsmr_rsp *)cmd;
-        hwmr->lkey = rsp->lrkey;
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-static int ocrdma_mbx_reg_mr_cont(struct ocrdma_dev *dev,
-                                  struct ocrdma_hw_mr *hwmr, u32 pbl_cnt,
-                                  u32 pbl_offset, u32 last)
-{
-        int status = -ENOMEM;
-        int i;
-        struct ocrdma_reg_nsmr_cont *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_REGISTER_NSMR_CONT, sizeof(*cmd));
-        if (!cmd)
-                return -ENOMEM;
-        cmd->lrkey = hwmr->lkey;
-        cmd->num_pbl_offset = (pbl_cnt << OCRDMA_REG_NSMR_CONT_NUM_PBL_SHIFT) |
-            (pbl_offset & OCRDMA_REG_NSMR_CONT_PBL_SHIFT_MASK);
-        cmd->last = last << OCRDMA_REG_NSMR_CONT_LAST_SHIFT;
-
-        for (i = 0; i < pbl_cnt; i++) {
-                cmd->pbl[i].lo =
-                    (u32) (hwmr->pbl_table[i + pbl_offset].pa & 0xffffffff);
-                cmd->pbl[i].hi =
-                    upper_32_bits(hwmr->pbl_table[i + pbl_offset].pa);
-        }
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_reg_mr(struct ocrdma_dev *dev,
-                  struct ocrdma_hw_mr *hwmr, u32 pdid, int acc)
-{
-        int status;
-        u32 last = 0;
-        u32 cur_pbl_cnt, pbl_offset;
-        u32 pending_pbl_cnt = hwmr->num_pbls;
-
-        pbl_offset = 0;
-        cur_pbl_cnt = min(pending_pbl_cnt, MAX_OCRDMA_NSMR_PBL);
-        if (cur_pbl_cnt == pending_pbl_cnt)
-                last = 1;
-
-        status = ocrdma_mbx_reg_mr(dev, hwmr, pdid,
-                                   cur_pbl_cnt, hwmr->pbe_size, last);
-        if (status) {
-                ocrdma_err("%s() status=%d\n", __func__, status);
-                return status;
-        }
-        /* if there is no more pbls to register then exit. */
-        if (last)
-                return 0;
-
-        while (!last) {
-                pbl_offset += cur_pbl_cnt;
-                pending_pbl_cnt -= cur_pbl_cnt;
-                cur_pbl_cnt = min(pending_pbl_cnt, MAX_OCRDMA_NSMR_PBL);
-                /* if we reach the end of the pbls, then need to set the last
-                 * bit, indicating no more pbls to register for this memory key.
-                 */
-                if (cur_pbl_cnt == pending_pbl_cnt)
-                        last = 1;
-
-                status = ocrdma_mbx_reg_mr_cont(dev, hwmr, cur_pbl_cnt,
-                                                pbl_offset, last);
-                if (status)
-                        break;
-        }
-        if (status)
-                ocrdma_err("%s() err. status=%d\n", __func__, status);
-
-        return status;
-}
-
-bool ocrdma_is_qp_in_sq_flushlist(struct ocrdma_cq *cq, struct ocrdma_qp *qp)
-{
-        struct ocrdma_qp *tmp;
-        bool found = false;
-        list_for_each_entry(tmp, &cq->sq_head, sq_entry) {
-                if (qp == tmp) {
-                        found = true;
-                        break;
-                }
-        }
-        return found;
-}
-
-bool ocrdma_is_qp_in_rq_flushlist(struct ocrdma_cq *cq, struct ocrdma_qp *qp)
-{
-        struct ocrdma_qp *tmp;
-        bool found = false;
-        list_for_each_entry(tmp, &cq->rq_head, rq_entry) {
-                if (qp == tmp) {
-                        found = true;
-                        break;
-                }
-        }
-        return found;
-}
-
-void ocrdma_flush_qp(struct ocrdma_qp *qp)
-{
-        bool found;
-        unsigned long flags;
-
-        spin_lock_irqsave(&qp->dev->flush_q_lock, flags);
-        found = ocrdma_is_qp_in_sq_flushlist(qp->sq_cq, qp);
-        if (!found)
-                list_add_tail(&qp->sq_entry, &qp->sq_cq->sq_head);
-        if (!qp->srq) {
-                found = ocrdma_is_qp_in_rq_flushlist(qp->rq_cq, qp);
-                if (!found)
-                        list_add_tail(&qp->rq_entry, &qp->rq_cq->rq_head);
-        }
-        spin_unlock_irqrestore(&qp->dev->flush_q_lock, flags);
-}
-
-int ocrdma_qp_state_machine(struct ocrdma_qp *qp, enum ib_qp_state new_ib_state,
-                            enum ib_qp_state *old_ib_state)
-{
-        unsigned long flags;
-        int status = 0;
-        enum ocrdma_qp_state new_state;
-        new_state = get_ocrdma_qp_state(new_ib_state);
-
-        /* sync with wqe and rqe posting */
-        spin_lock_irqsave(&qp->q_lock, flags);
-
-        if (old_ib_state)
-                *old_ib_state = get_ibqp_state(qp->state);
-        if (new_state == qp->state) {
-                spin_unlock_irqrestore(&qp->q_lock, flags);
-                return 1;
-        }
-
-        switch (qp->state) {
-        case OCRDMA_QPS_RST:
-                switch (new_state) {
-                case OCRDMA_QPS_RST:
-                case OCRDMA_QPS_INIT:
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_INIT:
-                /* qps: INIT->XXX */
-                switch (new_state) {
-                case OCRDMA_QPS_INIT:
-                case OCRDMA_QPS_RTR:
-                        break;
-                case OCRDMA_QPS_ERR:
-                        ocrdma_flush_qp(qp);
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_RTR:
-                /* qps: RTS->XXX */
-                switch (new_state) {
-                case OCRDMA_QPS_RTS:
-                        break;
-                case OCRDMA_QPS_ERR:
-                        ocrdma_flush_qp(qp);
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_RTS:
-                /* qps: RTS->XXX */
-                switch (new_state) {
-                case OCRDMA_QPS_SQD:
-                case OCRDMA_QPS_SQE:
-                        break;
-                case OCRDMA_QPS_ERR:
-                        ocrdma_flush_qp(qp);
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_SQD:
-                /* qps: SQD->XXX */
-                switch (new_state) {
-                case OCRDMA_QPS_RTS:
-                case OCRDMA_QPS_SQE:
-                case OCRDMA_QPS_ERR:
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_SQE:
-                switch (new_state) {
-                case OCRDMA_QPS_RTS:
-                case OCRDMA_QPS_ERR:
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        case OCRDMA_QPS_ERR:
-                /* qps: ERR->XXX */
-                switch (new_state) {
-                case OCRDMA_QPS_RST:
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                };
-                break;
-        default:
-                status = -EINVAL;
-                break;
-        };
-        if (!status)
-                qp->state = new_state;
-
-        spin_unlock_irqrestore(&qp->q_lock, flags);
-        return status;
-}
-
-static u32 ocrdma_set_create_qp_mbx_access_flags(struct ocrdma_qp *qp)
-{
-        u32 flags = 0;
-        if (qp->cap_flags & OCRDMA_QP_INB_RD)
-                flags |= OCRDMA_CREATE_QP_REQ_INB_RDEN_MASK;
-        if (qp->cap_flags & OCRDMA_QP_INB_WR)
-                flags |= OCRDMA_CREATE_QP_REQ_INB_WREN_MASK;
-        if (qp->cap_flags & OCRDMA_QP_MW_BIND)
-                flags |= OCRDMA_CREATE_QP_REQ_BIND_MEMWIN_MASK;
-        if (qp->cap_flags & OCRDMA_QP_LKEY0)
-                flags |= OCRDMA_CREATE_QP_REQ_ZERO_LKEYEN_MASK;
-        if (qp->cap_flags & OCRDMA_QP_FAST_REG)
-                flags |= OCRDMA_CREATE_QP_REQ_FMR_EN_MASK;
-        return flags;
-}
-
-static int ocrdma_set_create_qp_sq_cmd(struct ocrdma_create_qp_req *cmd,
-                                        struct ib_qp_init_attr *attrs,
-                                        struct ocrdma_qp *qp)
-{
-        int status;
-        u32 len, hw_pages, hw_page_size;
-        dma_addr_t pa;
-        struct ocrdma_dev *dev = qp->dev;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        u32 max_wqe_allocated;
-        u32 max_sges = attrs->cap.max_send_sge;
-
-        max_wqe_allocated = attrs->cap.max_send_wr;
-        /* need to allocate one extra to for GEN1 family */
-        if (dev->nic_info.dev_family != OCRDMA_GEN2_FAMILY)
-                max_wqe_allocated += 1;
-
-        status = ocrdma_build_q_conf(&max_wqe_allocated,
-                dev->attr.wqe_size, &hw_pages, &hw_page_size);
-        if (status) {
-                ocrdma_err("%s() req. max_send_wr=0x%x\n", __func__,
-                           max_wqe_allocated);
-                return -EINVAL;
-        }
-        qp->sq.max_cnt = max_wqe_allocated;
-        len = (hw_pages * hw_page_size);
-
-        qp->sq.va = dma_alloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
-        if (!qp->sq.va)
-                return -EINVAL;
-        memset(qp->sq.va, 0, len);
-        qp->sq.len = len;
-        qp->sq.pa = pa;
-        qp->sq.entry_size = dev->attr.wqe_size;
-        ocrdma_build_q_pages(&cmd->wq_addr[0], hw_pages, pa, hw_page_size);
-
-        cmd->type_pgsz_pdn |= (ilog2(hw_page_size / OCRDMA_MIN_Q_PAGE_SIZE)
-                                << OCRDMA_CREATE_QP_REQ_SQ_PAGE_SIZE_SHIFT);
-        cmd->num_wq_rq_pages |= (hw_pages <<
-                                 OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_SHIFT) &
-            OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_MASK;
-        cmd->max_sge_send_write |= (max_sges <<
-                                    OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_SHIFT) &
-            OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_MASK;
-        cmd->max_sge_send_write |= (max_sges <<
-                                    OCRDMA_CREATE_QP_REQ_MAX_SGE_WRITE_SHIFT) &
-                                        OCRDMA_CREATE_QP_REQ_MAX_SGE_WRITE_MASK;
-        cmd->max_wqe_rqe |= (ilog2(qp->sq.max_cnt) <<
-                             OCRDMA_CREATE_QP_REQ_MAX_WQE_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_MAX_WQE_MASK;
-        cmd->wqe_rqe_size |= (dev->attr.wqe_size <<
-                              OCRDMA_CREATE_QP_REQ_WQE_SIZE_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_WQE_SIZE_MASK;
-        return 0;
-}
-
-static int ocrdma_set_create_qp_rq_cmd(struct ocrdma_create_qp_req *cmd,
-                                        struct ib_qp_init_attr *attrs,
-                                        struct ocrdma_qp *qp)
-{
-        int status;
-        u32 len, hw_pages, hw_page_size;
-        dma_addr_t pa = 0;
-        struct ocrdma_dev *dev = qp->dev;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        u32 max_rqe_allocated = attrs->cap.max_recv_wr + 1;
-
-        status = ocrdma_build_q_conf(&max_rqe_allocated, dev->attr.rqe_size,
-                                     &hw_pages, &hw_page_size);
-        if (status) {
-                ocrdma_err("%s() req. max_recv_wr=0x%x\n", __func__,
-                           attrs->cap.max_recv_wr + 1);
-                return status;
-        }
-        qp->rq.max_cnt = max_rqe_allocated;
-        len = (hw_pages * hw_page_size);
-
-        qp->rq.va = dma_alloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
-        if (!qp->rq.va)
-                return status;
-        memset(qp->rq.va, 0, len);
-        qp->rq.pa = pa;
-        qp->rq.len = len;
-        qp->rq.entry_size = dev->attr.rqe_size;
-
-        ocrdma_build_q_pages(&cmd->rq_addr[0], hw_pages, pa, hw_page_size);
-        cmd->type_pgsz_pdn |= (ilog2(hw_page_size / OCRDMA_MIN_Q_PAGE_SIZE) <<
-                OCRDMA_CREATE_QP_REQ_RQ_PAGE_SIZE_SHIFT);
-        cmd->num_wq_rq_pages |=
-            (hw_pages << OCRDMA_CREATE_QP_REQ_NUM_RQ_PAGES_SHIFT) &
-            OCRDMA_CREATE_QP_REQ_NUM_RQ_PAGES_MASK;
-        cmd->max_sge_recv_flags |= (attrs->cap.max_recv_sge <<
-                                OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_MASK;
-        cmd->max_wqe_rqe |= (ilog2(qp->rq.max_cnt) <<
-                                OCRDMA_CREATE_QP_REQ_MAX_RQE_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_MAX_RQE_MASK;
-        cmd->wqe_rqe_size |= (dev->attr.rqe_size <<
-                        OCRDMA_CREATE_QP_REQ_RQE_SIZE_SHIFT) &
-                        OCRDMA_CREATE_QP_REQ_RQE_SIZE_MASK;
-        return 0;
-}
-
-static void ocrdma_set_create_qp_dpp_cmd(struct ocrdma_create_qp_req *cmd,
-                                         struct ocrdma_pd *pd,
-                                         struct ocrdma_qp *qp,
-                                         u8 enable_dpp_cq, u16 dpp_cq_id)
-{
-        pd->num_dpp_qp--;
-        qp->dpp_enabled = true;
-        cmd->max_sge_recv_flags |= OCRDMA_CREATE_QP_REQ_ENABLE_DPP_MASK;
-        if (!enable_dpp_cq)
-                return;
-        cmd->max_sge_recv_flags |= OCRDMA_CREATE_QP_REQ_ENABLE_DPP_MASK;
-        cmd->dpp_credits_cqid = dpp_cq_id;
-        cmd->dpp_credits_cqid |= OCRDMA_CREATE_QP_REQ_DPP_CREDIT_LIMIT <<
-                                        OCRDMA_CREATE_QP_REQ_DPP_CREDIT_SHIFT;
-}
-
-static int ocrdma_set_create_qp_ird_cmd(struct ocrdma_create_qp_req *cmd,
-                                        struct ocrdma_qp *qp)
-{
-        struct ocrdma_dev *dev = qp->dev;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        dma_addr_t pa = 0;
-        int ird_page_size = dev->attr.ird_page_size;
-        int ird_q_len = dev->attr.num_ird_pages * ird_page_size;
-
-        if (dev->attr.ird == 0)
-                return 0;
-
-        qp->ird_q_va = dma_alloc_coherent(&pdev->dev, ird_q_len,
-                                        &pa, GFP_KERNEL);
-        if (!qp->ird_q_va)
-                return -ENOMEM;
-        memset(qp->ird_q_va, 0, ird_q_len);
-        ocrdma_build_q_pages(&cmd->ird_addr[0], dev->attr.num_ird_pages,
-                             pa, ird_page_size);
-        return 0;
-}
-
-static void ocrdma_get_create_qp_rsp(struct ocrdma_create_qp_rsp *rsp,
-                                     struct ocrdma_qp *qp,
-                                     struct ib_qp_init_attr *attrs,
-                                     u16 *dpp_offset, u16 *dpp_credit_lmt)
-{
-        u32 max_wqe_allocated, max_rqe_allocated;
-        qp->id = rsp->qp_id & OCRDMA_CREATE_QP_RSP_QP_ID_MASK;
-        qp->rq.dbid = rsp->sq_rq_id & OCRDMA_CREATE_QP_RSP_RQ_ID_MASK;
-        qp->sq.dbid = rsp->sq_rq_id >> OCRDMA_CREATE_QP_RSP_SQ_ID_SHIFT;
-        qp->max_ird = rsp->max_ord_ird & OCRDMA_CREATE_QP_RSP_MAX_IRD_MASK;
-        qp->max_ord = (rsp->max_ord_ird >> OCRDMA_CREATE_QP_RSP_MAX_ORD_SHIFT);
-        qp->dpp_enabled = false;
-        if (rsp->dpp_response & OCRDMA_CREATE_QP_RSP_DPP_ENABLED_MASK) {
-                qp->dpp_enabled = true;
-                *dpp_credit_lmt = (rsp->dpp_response &
-                                OCRDMA_CREATE_QP_RSP_DPP_CREDITS_MASK) >>
-                                OCRDMA_CREATE_QP_RSP_DPP_CREDITS_SHIFT;
-                *dpp_offset = (rsp->dpp_response &
-                                OCRDMA_CREATE_QP_RSP_DPP_PAGE_OFFSET_MASK) >>
-                                OCRDMA_CREATE_QP_RSP_DPP_PAGE_OFFSET_SHIFT;
-        }
-        max_wqe_allocated =
-                rsp->max_wqe_rqe >> OCRDMA_CREATE_QP_RSP_MAX_WQE_SHIFT;
-        max_wqe_allocated = 1 << max_wqe_allocated;
-        max_rqe_allocated = 1 << ((u16)rsp->max_wqe_rqe);
-
-        qp->sq.max_cnt = max_wqe_allocated;
-        qp->sq.max_wqe_idx = max_wqe_allocated - 1;
-
-        if (!attrs->srq) {
-                qp->rq.max_cnt = max_rqe_allocated;
-                qp->rq.max_wqe_idx = max_rqe_allocated - 1;
-        }
-}
-
-int ocrdma_mbx_create_qp(struct ocrdma_qp *qp, struct ib_qp_init_attr *attrs,
-                         u8 enable_dpp_cq, u16 dpp_cq_id, u16 *dpp_offset,
-                         u16 *dpp_credit_lmt)
-{
-        int status = -ENOMEM;
-        u32 flags = 0;
-        struct ocrdma_dev *dev = qp->dev;
-        struct ocrdma_pd *pd = qp->pd;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        struct ocrdma_cq *cq;
-        struct ocrdma_create_qp_req *cmd;
-        struct ocrdma_create_qp_rsp *rsp;
-        int qptype;
-
-        switch (attrs->qp_type) {
-        case IB_QPT_GSI:
-                qptype = OCRDMA_QPT_GSI;
-                break;
-        case IB_QPT_RC:
-                qptype = OCRDMA_QPT_RC;
-                break;
-        case IB_QPT_UD:
-                qptype = OCRDMA_QPT_UD;
-                break;
-        default:
-                return -EINVAL;
-        };
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_QP, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->type_pgsz_pdn |= (qptype << OCRDMA_CREATE_QP_REQ_QPT_SHIFT) &
-                                                OCRDMA_CREATE_QP_REQ_QPT_MASK;
-        status = ocrdma_set_create_qp_sq_cmd(cmd, attrs, qp);
-        if (status)
-                goto sq_err;
-
-        if (attrs->srq) {
-                struct ocrdma_srq *srq = get_ocrdma_srq(attrs->srq);
-                cmd->max_sge_recv_flags |= OCRDMA_CREATE_QP_REQ_USE_SRQ_MASK;
-                cmd->rq_addr[0].lo = srq->id;
-                qp->srq = srq;
-        } else {
-                status = ocrdma_set_create_qp_rq_cmd(cmd, attrs, qp);
-                if (status)
-                        goto rq_err;
-        }
-
-        status = ocrdma_set_create_qp_ird_cmd(cmd, qp);
-        if (status)
-                goto mbx_err;
-
-        cmd->type_pgsz_pdn |= (pd->id << OCRDMA_CREATE_QP_REQ_PD_ID_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_PD_ID_MASK;
-
-        flags = ocrdma_set_create_qp_mbx_access_flags(qp);
-
-        cmd->max_sge_recv_flags |= flags;
-        cmd->max_ord_ird |= (dev->attr.max_ord_per_qp <<
-                             OCRDMA_CREATE_QP_REQ_MAX_ORD_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_MAX_ORD_MASK;
-        cmd->max_ord_ird |= (dev->attr.max_ird_per_qp <<
-                             OCRDMA_CREATE_QP_REQ_MAX_IRD_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_MAX_IRD_MASK;
-        cq = get_ocrdma_cq(attrs->send_cq);
-        cmd->wq_rq_cqid |= (cq->id << OCRDMA_CREATE_QP_REQ_WQ_CQID_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_WQ_CQID_MASK;
-        qp->sq_cq = cq;
-        cq = get_ocrdma_cq(attrs->recv_cq);
-        cmd->wq_rq_cqid |= (cq->id << OCRDMA_CREATE_QP_REQ_RQ_CQID_SHIFT) &
-                                OCRDMA_CREATE_QP_REQ_RQ_CQID_MASK;
-        qp->rq_cq = cq;
-
-        if (pd->dpp_enabled && attrs->cap.max_inline_data && pd->num_dpp_qp &&
-            (attrs->cap.max_inline_data <= dev->attr.max_inline_data))
-                ocrdma_set_create_qp_dpp_cmd(cmd, pd, qp, enable_dpp_cq,
-                                             dpp_cq_id);
-
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_create_qp_rsp *)cmd;
-        ocrdma_get_create_qp_rsp(rsp, qp, attrs, dpp_offset, dpp_credit_lmt);
-        qp->state = OCRDMA_QPS_RST;
-        kfree(cmd);
-        return 0;
-mbx_err:
-        if (qp->rq.va)
-                dma_free_coherent(&pdev->dev, qp->rq.len, qp->rq.va, qp->rq.pa);
-rq_err:
-        ocrdma_err("%s(%d) rq_err\n", __func__, dev->id);
-        dma_free_coherent(&pdev->dev, qp->sq.len, qp->sq.va, qp->sq.pa);
-sq_err:
-        ocrdma_err("%s(%d) sq_err\n", __func__, dev->id);
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_query_qp(struct ocrdma_dev *dev, struct ocrdma_qp *qp,
-                        struct ocrdma_qp_params *param)
-{
-        int status = -ENOMEM;
-        struct ocrdma_query_qp *cmd;
-        struct ocrdma_query_qp_rsp *rsp;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_QUERY_QP, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->qp_id = qp->id;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_query_qp_rsp *)cmd;
-        memcpy(param, &rsp->params, sizeof(struct ocrdma_qp_params));
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_resolve_dgid(struct ocrdma_dev *dev, union ib_gid *dgid,
-                        u8 *mac_addr)
-{
-        struct in6_addr in6;
-
-        memcpy(&in6, dgid, sizeof in6);
-        if (rdma_is_multicast_addr(&in6))
-                rdma_get_mcast_mac(&in6, mac_addr);
-        else if (rdma_link_local_addr(&in6))
-                rdma_get_ll_mac(&in6, mac_addr);
-        else {
-                ocrdma_err("%s() fail to resolve mac_addr.\n", __func__);
-                return -EINVAL;
-        }
-        return 0;
-}
-
-static void ocrdma_set_av_params(struct ocrdma_qp *qp,
-                                struct ocrdma_modify_qp *cmd,
-                                struct ib_qp_attr *attrs)
-{
-        struct ib_ah_attr *ah_attr = &attrs->ah_attr;
-        union ib_gid sgid;
-        u32 vlan_id;
-        u8 mac_addr[6];
-        if ((ah_attr->ah_flags & IB_AH_GRH) == 0)
-                return;
-        cmd->params.tclass_sq_psn |=
-            (ah_attr->grh.traffic_class << OCRDMA_QP_PARAMS_TCLASS_SHIFT);
-        cmd->params.rnt_rc_sl_fl |=
-            (ah_attr->grh.flow_label & OCRDMA_QP_PARAMS_FLOW_LABEL_MASK);
-        cmd->params.hop_lmt_rq_psn |=
-            (ah_attr->grh.hop_limit << OCRDMA_QP_PARAMS_HOP_LMT_SHIFT);
-        cmd->flags |= OCRDMA_QP_PARA_FLOW_LBL_VALID;
-        memcpy(&cmd->params.dgid[0], &ah_attr->grh.dgid.raw[0],
-               sizeof(cmd->params.dgid));
-        ocrdma_query_gid(&qp->dev->ibdev, 1,
-                         ah_attr->grh.sgid_index, &sgid);
-        qp->sgid_idx = ah_attr->grh.sgid_index;
-        memcpy(&cmd->params.sgid[0], &sgid.raw[0], sizeof(cmd->params.sgid));
-        ocrdma_resolve_dgid(qp->dev, &ah_attr->grh.dgid, &mac_addr[0]);
-        cmd->params.dmac_b0_to_b3 = mac_addr[0] | (mac_addr[1] << 8) |
-                                (mac_addr[2] << 16) | (mac_addr[3] << 24);
-        /* convert them to LE format. */
-        ocrdma_cpu_to_le32(&cmd->params.dgid[0], sizeof(cmd->params.dgid));
-        ocrdma_cpu_to_le32(&cmd->params.sgid[0], sizeof(cmd->params.sgid));
-        cmd->params.vlan_dmac_b4_to_b5 = mac_addr[4] | (mac_addr[5] << 8);
-        vlan_id = rdma_get_vlan_id(&sgid);
-        if (vlan_id && (vlan_id < 0x1000)) {
-                cmd->params.vlan_dmac_b4_to_b5 |=
-                    vlan_id << OCRDMA_QP_PARAMS_VLAN_SHIFT;
-                cmd->flags |= OCRDMA_QP_PARA_VLAN_EN_VALID;
-        }
-}
-
-static int ocrdma_set_qp_params(struct ocrdma_qp *qp,
-                                struct ocrdma_modify_qp *cmd,
-                                struct ib_qp_attr *attrs, int attr_mask,
-                                enum ib_qp_state old_qps)
-{
-        int status = 0;
-        struct net_device *netdev = qp->dev->nic_info.netdev;
-        int eth_mtu = iboe_get_mtu(netdev->mtu);
-
-        if (attr_mask & IB_QP_PKEY_INDEX) {
-                cmd->params.path_mtu_pkey_indx |= (attrs->pkey_index &
-                                            OCRDMA_QP_PARAMS_PKEY_INDEX_MASK);
-                cmd->flags |= OCRDMA_QP_PARA_PKEY_VALID;
-        }
-        if (attr_mask & IB_QP_QKEY) {
-                qp->qkey = attrs->qkey;
-                cmd->params.qkey = attrs->qkey;
-                cmd->flags |= OCRDMA_QP_PARA_QKEY_VALID;
-        }
-        if (attr_mask & IB_QP_AV)
-                ocrdma_set_av_params(qp, cmd, attrs);
-        else if (qp->qp_type == IB_QPT_GSI || qp->qp_type == IB_QPT_UD) {
-                /* set the default mac address for UD, GSI QPs */
-                cmd->params.dmac_b0_to_b3 = qp->dev->nic_info.mac_addr[0] |
-                        (qp->dev->nic_info.mac_addr[1] << 8) |
-                        (qp->dev->nic_info.mac_addr[2] << 16) |
-                        (qp->dev->nic_info.mac_addr[3] << 24);
-                cmd->params.vlan_dmac_b4_to_b5 = qp->dev->nic_info.mac_addr[4] |
-                                        (qp->dev->nic_info.mac_addr[5] << 8);
-        }
-        if ((attr_mask & IB_QP_EN_SQD_ASYNC_NOTIFY) &&
-            attrs->en_sqd_async_notify) {
-                cmd->params.max_sge_recv_flags |=
-                        OCRDMA_QP_PARAMS_FLAGS_SQD_ASYNC;
-                cmd->flags |= OCRDMA_QP_PARA_DST_QPN_VALID;
-        }
-        if (attr_mask & IB_QP_DEST_QPN) {
-                cmd->params.ack_to_rnr_rtc_dest_qpn |= (attrs->dest_qp_num &
-                                OCRDMA_QP_PARAMS_DEST_QPN_MASK);
-                cmd->flags |= OCRDMA_QP_PARA_DST_QPN_VALID;
-        }
-        if (attr_mask & IB_QP_PATH_MTU) {
-                if (ib_mtu_enum_to_int(eth_mtu) <
-                    ib_mtu_enum_to_int(attrs->path_mtu)) {
-                        status = -EINVAL;
-                        goto pmtu_err;
-                }
-                cmd->params.path_mtu_pkey_indx |=
-                    (ib_mtu_enum_to_int(attrs->path_mtu) <<
-                     OCRDMA_QP_PARAMS_PATH_MTU_SHIFT) &
-                    OCRDMA_QP_PARAMS_PATH_MTU_MASK;
-                cmd->flags |= OCRDMA_QP_PARA_PMTU_VALID;
-        }
-        if (attr_mask & IB_QP_TIMEOUT) {
-                cmd->params.ack_to_rnr_rtc_dest_qpn |= attrs->timeout <<
-                    OCRDMA_QP_PARAMS_ACK_TIMEOUT_SHIFT;
-                cmd->flags |= OCRDMA_QP_PARA_ACK_TO_VALID;
-        }
-        if (attr_mask & IB_QP_RETRY_CNT) {
-                cmd->params.rnt_rc_sl_fl |= (attrs->retry_cnt <<
-                                      OCRDMA_QP_PARAMS_RETRY_CNT_SHIFT) &
-                    OCRDMA_QP_PARAMS_RETRY_CNT_MASK;
-                cmd->flags |= OCRDMA_QP_PARA_RETRY_CNT_VALID;
-        }
-        if (attr_mask & IB_QP_MIN_RNR_TIMER) {
-                cmd->params.rnt_rc_sl_fl |= (attrs->min_rnr_timer <<
-                                      OCRDMA_QP_PARAMS_RNR_NAK_TIMER_SHIFT) &
-                    OCRDMA_QP_PARAMS_RNR_NAK_TIMER_MASK;
-                cmd->flags |= OCRDMA_QP_PARA_RNT_VALID;
-        }
-        if (attr_mask & IB_QP_RNR_RETRY) {
-                cmd->params.ack_to_rnr_rtc_dest_qpn |= (attrs->rnr_retry <<
-                        OCRDMA_QP_PARAMS_RNR_RETRY_CNT_SHIFT)
-                        & OCRDMA_QP_PARAMS_RNR_RETRY_CNT_MASK;
-                cmd->flags |= OCRDMA_QP_PARA_RRC_VALID;
-        }
-        if (attr_mask & IB_QP_SQ_PSN) {
-                cmd->params.tclass_sq_psn |= (attrs->sq_psn & 0x00ffffff);
-                cmd->flags |= OCRDMA_QP_PARA_SQPSN_VALID;
-        }
-        if (attr_mask & IB_QP_RQ_PSN) {
-                cmd->params.hop_lmt_rq_psn |= (attrs->rq_psn & 0x00ffffff);
-                cmd->flags |= OCRDMA_QP_PARA_RQPSN_VALID;
-        }
-        if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC) {
-                if (attrs->max_rd_atomic > qp->dev->attr.max_ord_per_qp) {
-                        status = -EINVAL;
-                        goto pmtu_err;
-                }
-                qp->max_ord = attrs->max_rd_atomic;
-                cmd->flags |= OCRDMA_QP_PARA_MAX_ORD_VALID;
-        }
-        if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC) {
-                if (attrs->max_dest_rd_atomic > qp->dev->attr.max_ird_per_qp) {
-                        status = -EINVAL;
-                        goto pmtu_err;
-                }
-                qp->max_ird = attrs->max_dest_rd_atomic;
-                cmd->flags |= OCRDMA_QP_PARA_MAX_IRD_VALID;
-        }
-        cmd->params.max_ord_ird = (qp->max_ord <<
-                                OCRDMA_QP_PARAMS_MAX_ORD_SHIFT) |
-                                (qp->max_ird & OCRDMA_QP_PARAMS_MAX_IRD_MASK);
-pmtu_err:
-        return status;
-}
-
-int ocrdma_mbx_modify_qp(struct ocrdma_dev *dev, struct ocrdma_qp *qp,
-                         struct ib_qp_attr *attrs, int attr_mask,
-                         enum ib_qp_state old_qps)
-{
-        int status = -ENOMEM;
-        struct ocrdma_modify_qp *cmd;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_MODIFY_QP, sizeof(*cmd));
-        if (!cmd)
-                return status;
-
-        cmd->params.id = qp->id;
-        cmd->flags = 0;
-        if (attr_mask & IB_QP_STATE) {
-                cmd->params.max_sge_recv_flags |=
-                    (get_ocrdma_qp_state(attrs->qp_state) <<
-                     OCRDMA_QP_PARAMS_STATE_SHIFT) &
-                    OCRDMA_QP_PARAMS_STATE_MASK;
-                cmd->flags |= OCRDMA_QP_PARA_QPS_VALID;
-        } else
-                cmd->params.max_sge_recv_flags |=
-                    (qp->state << OCRDMA_QP_PARAMS_STATE_SHIFT) &
-                    OCRDMA_QP_PARAMS_STATE_MASK;
-        status = ocrdma_set_qp_params(qp, cmd, attrs, attr_mask, old_qps);
-        if (status)
-                goto mbx_err;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-
-mbx_err:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_destroy_qp(struct ocrdma_dev *dev, struct ocrdma_qp *qp)
-{
-        int status = -ENOMEM;
-        struct ocrdma_destroy_qp *cmd;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DELETE_QP, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->qp_id = qp->id;
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-
-mbx_err:
-        kfree(cmd);
-        if (qp->sq.va)
-                dma_free_coherent(&pdev->dev, qp->sq.len, qp->sq.va, qp->sq.pa);
-        if (!qp->srq && qp->rq.va)
-                dma_free_coherent(&pdev->dev, qp->rq.len, qp->rq.va, qp->rq.pa);
-        if (qp->dpp_enabled)
-                qp->pd->num_dpp_qp++;
-        return status;
-}
-
-int ocrdma_mbx_create_srq(struct ocrdma_srq *srq,
-                          struct ib_srq_init_attr *srq_attr,
-                          struct ocrdma_pd *pd)
-{
-        int status = -ENOMEM;
-        int hw_pages, hw_page_size;
-        int len;
-        struct ocrdma_create_srq_rsp *rsp;
-        struct ocrdma_create_srq *cmd;
-        dma_addr_t pa;
-        struct ocrdma_dev *dev = srq->dev;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        u32 max_rqe_allocated;
-
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_SRQ, sizeof(*cmd));
-        if (!cmd)
-                return status;
-
-        cmd->pgsz_pdid = pd->id & OCRDMA_CREATE_SRQ_PD_ID_MASK;
-        max_rqe_allocated = srq_attr->attr.max_wr + 1;
-        status = ocrdma_build_q_conf(&max_rqe_allocated,
-                                dev->attr.rqe_size,
-                                &hw_pages, &hw_page_size);
-        if (status) {
-                ocrdma_err("%s() req. max_wr=0x%x\n", __func__,
-                           srq_attr->attr.max_wr);
-                status = -EINVAL;
-                goto ret;
-        }
-        len = hw_pages * hw_page_size;
-        srq->rq.va = dma_alloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
-        if (!srq->rq.va) {
-                status = -ENOMEM;
-                goto ret;
-        }
-        ocrdma_build_q_pages(&cmd->rq_addr[0], hw_pages, pa, hw_page_size);
-
-        srq->rq.entry_size = dev->attr.rqe_size;
-        srq->rq.pa = pa;
-        srq->rq.len = len;
-        srq->rq.max_cnt = max_rqe_allocated;
-
-        cmd->max_sge_rqe = ilog2(max_rqe_allocated);
-        cmd->max_sge_rqe |= srq_attr->attr.max_sge <<
-                                OCRDMA_CREATE_SRQ_MAX_SGE_RECV_SHIFT;
-
-        cmd->pgsz_pdid |= (ilog2(hw_page_size / OCRDMA_MIN_Q_PAGE_SIZE)
-                << OCRDMA_CREATE_SRQ_PG_SZ_SHIFT);
-        cmd->pages_rqe_sz |= (dev->attr.rqe_size
-                << OCRDMA_CREATE_SRQ_RQE_SIZE_SHIFT)
-                & OCRDMA_CREATE_SRQ_RQE_SIZE_MASK;
-        cmd->pages_rqe_sz |= hw_pages << OCRDMA_CREATE_SRQ_NUM_RQ_PAGES_SHIFT;
-
-        status = ocrdma_mbx_cmd(dev, (struct ocrdma_mqe *)cmd);
-        if (status)
-                goto mbx_err;
-        rsp = (struct ocrdma_create_srq_rsp *)cmd;
-        srq->id = rsp->id;
-        srq->rq.dbid = rsp->id;
-        max_rqe_allocated = ((rsp->max_sge_rqe_allocated &
-                OCRDMA_CREATE_SRQ_RSP_MAX_RQE_ALLOCATED_MASK) >>
-                OCRDMA_CREATE_SRQ_RSP_MAX_RQE_ALLOCATED_SHIFT);
-        max_rqe_allocated = (1 << max_rqe_allocated);
-        srq->rq.max_cnt = max_rqe_allocated;
-        srq->rq.max_wqe_idx = max_rqe_allocated - 1;
-        srq->rq.max_sges = (rsp->max_sge_rqe_allocated &
-                OCRDMA_CREATE_SRQ_RSP_MAX_SGE_RECV_ALLOCATED_MASK) >>
-                OCRDMA_CREATE_SRQ_RSP_MAX_SGE_RECV_ALLOCATED_SHIFT;
-        goto ret;
-mbx_err:
-        dma_free_coherent(&pdev->dev, srq->rq.len, srq->rq.va, pa);
-ret:
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_modify_srq(struct ocrdma_srq *srq, struct ib_srq_attr *srq_attr)
-{
-        int status = -ENOMEM;
-        struct ocrdma_modify_srq *cmd;
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_SRQ, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->id = srq->id;
-        cmd->limit_max_rqe |= srq_attr->srq_limit <<
-            OCRDMA_MODIFY_SRQ_LIMIT_SHIFT;
-        status = ocrdma_mbx_cmd(srq->dev, (struct ocrdma_mqe *)cmd);
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_query_srq(struct ocrdma_srq *srq, struct ib_srq_attr *srq_attr)
-{
-        int status = -ENOMEM;
-        struct ocrdma_query_srq *cmd;
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_CREATE_SRQ, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->id = srq->rq.dbid;
-        status = ocrdma_mbx_cmd(srq->dev, (struct ocrdma_mqe *)cmd);
-        if (status == 0) {
-                struct ocrdma_query_srq_rsp *rsp =
-                    (struct ocrdma_query_srq_rsp *)cmd;
-                srq_attr->max_sge =
-                    rsp->srq_lmt_max_sge &
-                    OCRDMA_QUERY_SRQ_RSP_MAX_SGE_RECV_MASK;
-                srq_attr->max_wr =
-                    rsp->max_rqe_pdid >> OCRDMA_QUERY_SRQ_RSP_MAX_RQE_SHIFT;
-                srq_attr->srq_limit = rsp->srq_lmt_max_sge >>
-                    OCRDMA_QUERY_SRQ_RSP_SRQ_LIMIT_SHIFT;
-        }
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_mbx_destroy_srq(struct ocrdma_dev *dev, struct ocrdma_srq *srq)
-{
-        int status = -ENOMEM;
-        struct ocrdma_destroy_srq *cmd;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        cmd = ocrdma_init_emb_mqe(OCRDMA_CMD_DELETE_SRQ, sizeof(*cmd));
-        if (!cmd)
-                return status;
-        cmd->id = srq->id;
-        status = ocrdma_mbx_cmd(srq->dev, (struct ocrdma_mqe *)cmd);
-        if (srq->rq.va)
-                dma_free_coherent(&pdev->dev, srq->rq.len,
-                                  srq->rq.va, srq->rq.pa);
-        kfree(cmd);
-        return status;
-}
-
-int ocrdma_alloc_av(struct ocrdma_dev *dev, struct ocrdma_ah *ah)
-{
-        int i;
-        int status = -EINVAL;
-        struct ocrdma_av *av;
-        unsigned long flags;
-
-        av = dev->av_tbl.va;
-        spin_lock_irqsave(&dev->av_tbl.lock, flags);
-        for (i = 0; i < dev->av_tbl.num_ah; i++) {
-                if (av->valid == 0) {
-                        av->valid = OCRDMA_AV_VALID;
-                        ah->av = av;
-                        ah->id = i;
-                        status = 0;
-                        break;
-                }
-                av++;
-        }
-        if (i == dev->av_tbl.num_ah)
-                status = -EAGAIN;
-        spin_unlock_irqrestore(&dev->av_tbl.lock, flags);
-        return status;
-}
-
-int ocrdma_free_av(struct ocrdma_dev *dev, struct ocrdma_ah *ah)
-{
-        unsigned long flags;
-        spin_lock_irqsave(&dev->av_tbl.lock, flags);
-        ah->av->valid = 0;
-        spin_unlock_irqrestore(&dev->av_tbl.lock, flags);
-        return 0;
-}
-
-static int ocrdma_create_mq_eq(struct ocrdma_dev *dev)
-{
-        int status;
-        int irq;
-        unsigned long flags = 0;
-        int num_eq = 0;
-
-        if (dev->nic_info.intr_mode == BE_INTERRUPT_MODE_INTX)
-                flags = IRQF_SHARED;
-        else {
-                num_eq = dev->nic_info.msix.num_vectors -
-                                dev->nic_info.msix.start_vector;
-                /* minimum two vectors/eq are required for rdma to work.
-                 * one for control path and one for data path.
-                 */
-                if (num_eq < 2)
-                        return -EBUSY;
-        }
-
-        status = ocrdma_create_eq(dev, &dev->meq, OCRDMA_EQ_LEN);
-        if (status)
-                return status;
-        sprintf(dev->meq.irq_name, "ocrdma_mq%d", dev->id);
-        irq = ocrdma_get_irq(dev, &dev->meq);
-        status = request_irq(irq, ocrdma_irq_handler, flags, dev->meq.irq_name,
-                             &dev->meq);
-        if (status)
-                _ocrdma_destroy_eq(dev, &dev->meq);
-        return status;
-}
-
-static int ocrdma_create_qp_eqs(struct ocrdma_dev *dev)
-{
-        int num_eq, i, status = 0;
-        int irq;
-        unsigned long flags = 0;
-
-        num_eq = dev->nic_info.msix.num_vectors -
-                        dev->nic_info.msix.start_vector;
-        if (dev->nic_info.intr_mode == BE_INTERRUPT_MODE_INTX) {
-                num_eq = 1;
-                flags = IRQF_SHARED;
-        } else
-                num_eq = min_t(u32, num_eq, num_online_cpus());
-        dev->qp_eq_tbl = kzalloc(sizeof(struct ocrdma_eq) * num_eq, GFP_KERNEL);
-        if (!dev->qp_eq_tbl)
-                return -ENOMEM;
-
-        for (i = 0; i < num_eq; i++) {
-                status = ocrdma_create_eq(dev, &dev->qp_eq_tbl[i],
-                                          OCRDMA_EQ_LEN);
-                if (status) {
-                        status = -EINVAL;
-                        break;
-                }
-                sprintf(dev->qp_eq_tbl[i].irq_name, "ocrdma_qp%d-%d",
-                        dev->id, i);
-                irq = ocrdma_get_irq(dev, &dev->qp_eq_tbl[i]);
-                status = request_irq(irq, ocrdma_irq_handler, flags,
-                                     dev->qp_eq_tbl[i].irq_name,
-                                     &dev->qp_eq_tbl[i]);
-                if (status) {
-                        _ocrdma_destroy_eq(dev, &dev->qp_eq_tbl[i]);
-                        status = -EINVAL;
-                        break;
-                }
-                dev->eq_cnt += 1;
-        }
-        /* one eq is sufficient for data path to work */
-        if (dev->eq_cnt >= 1)
-                return 0;
-        if (status)
-                ocrdma_destroy_qp_eqs(dev);
-        return status;
-}
-
-int ocrdma_init_hw(struct ocrdma_dev *dev)
-{
-        int status;
-        /* set up control path eq */
-        status = ocrdma_create_mq_eq(dev);
-        if (status)
-                return status;
-        /* set up data path eq */
-        status = ocrdma_create_qp_eqs(dev);
-        if (status)
-                goto qpeq_err;
-        status = ocrdma_create_mq(dev);
-        if (status)
-                goto mq_err;
-        status = ocrdma_mbx_query_fw_config(dev);
-        if (status)
-                goto conf_err;
-        status = ocrdma_mbx_query_dev(dev);
-        if (status)
-                goto conf_err;
-        status = ocrdma_mbx_query_fw_ver(dev);
-        if (status)
-                goto conf_err;
-        status = ocrdma_mbx_create_ah_tbl(dev);
-        if (status)
-                goto conf_err;
-        return 0;
-
-conf_err:
-        ocrdma_destroy_mq(dev);
-mq_err:
-        ocrdma_destroy_qp_eqs(dev);
-qpeq_err:
-        ocrdma_destroy_eq(dev, &dev->meq);
-        ocrdma_err("%s() status=%d\n", __func__, status);
-        return status;
-}
-
-void ocrdma_cleanup_hw(struct ocrdma_dev *dev)
-{
-        ocrdma_mbx_delete_ah_tbl(dev);
-
-        /* cleanup the data path eqs */
-        ocrdma_destroy_qp_eqs(dev);
-
-        /* cleanup the control path */
-        ocrdma_destroy_mq(dev);
-        ocrdma_destroy_eq(dev, &dev->meq);
-}
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h b/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
deleted file mode 100644
index be5db77404d..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) CNA Adapters.              *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_HW_H__
-#define __OCRDMA_HW_H__
-
-#include "ocrdma_sli.h"
-
-static inline void ocrdma_cpu_to_le32(void *dst, u32 len)
-{
-#ifdef __BIG_ENDIAN
-        int i = 0;
-        u32 *src_ptr = dst;
-        u32 *dst_ptr = dst;
-        for (; i < (len / 4); i++)
-                *(dst_ptr + i) = cpu_to_le32p(src_ptr + i);
-#endif
-}
-
-static inline void ocrdma_le32_to_cpu(void *dst, u32 len)
-{
-#ifdef __BIG_ENDIAN
-        int i = 0;
-        u32 *src_ptr = dst;
-        u32 *dst_ptr = dst;
-        for (; i < (len / sizeof(u32)); i++)
-                *(dst_ptr + i) = le32_to_cpu(*(src_ptr + i));
-#endif
-}
-
-static inline void ocrdma_copy_cpu_to_le32(void *dst, void *src, u32 len)
-{
-#ifdef __BIG_ENDIAN
-        int i = 0;
-        u32 *src_ptr = src;
-        u32 *dst_ptr = dst;
-        for (; i < (len / sizeof(u32)); i++)
-                *(dst_ptr + i) = cpu_to_le32p(src_ptr + i);
-#else
-        memcpy(dst, src, len);
-#endif
-}
-
-static inline void ocrdma_copy_le32_to_cpu(void *dst, void *src, u32 len)
-{
-#ifdef __BIG_ENDIAN
-        int i = 0;
-        u32 *src_ptr = src;
-        u32 *dst_ptr = dst;
-        for (; i < len / sizeof(u32); i++)
-                *(dst_ptr + i) = le32_to_cpu(*(src_ptr + i));
-#else
-        memcpy(dst, src, len);
-#endif
-}
-
-int ocrdma_init_hw(struct ocrdma_dev *);
-void ocrdma_cleanup_hw(struct ocrdma_dev *);
-
-enum ib_qp_state get_ibqp_state(enum ocrdma_qp_state qps);
-void ocrdma_ring_cq_db(struct ocrdma_dev *, u16 cq_id, bool armed,
-                       bool solicited, u16 cqe_popped);
-
-/* verbs specific mailbox commands */
-int ocrdma_query_config(struct ocrdma_dev *,
-                        struct ocrdma_mbx_query_config *config);
-int ocrdma_resolve_dgid(struct ocrdma_dev *, union ib_gid *dgid, u8 *mac_addr);
-
-int ocrdma_mbx_alloc_pd(struct ocrdma_dev *, struct ocrdma_pd *);
-int ocrdma_mbx_dealloc_pd(struct ocrdma_dev *, struct ocrdma_pd *);
-
-int ocrdma_mbx_alloc_lkey(struct ocrdma_dev *, struct ocrdma_hw_mr *hwmr,
-                          u32 pd_id, int addr_check);
-int ocrdma_mbx_dealloc_lkey(struct ocrdma_dev *, int fmr, u32 lkey);
-
-int ocrdma_reg_mr(struct ocrdma_dev *, struct ocrdma_hw_mr *hwmr,
-                        u32 pd_id, int acc);
-int ocrdma_mbx_create_cq(struct ocrdma_dev *, struct ocrdma_cq *,
-                                int entries, int dpp_cq);
-int ocrdma_mbx_destroy_cq(struct ocrdma_dev *, struct ocrdma_cq *);
-
-int ocrdma_mbx_create_qp(struct ocrdma_qp *, struct ib_qp_init_attr *attrs,
-                         u8 enable_dpp_cq, u16 dpp_cq_id, u16 *dpp_offset,
-                         u16 *dpp_credit_lmt);
-int ocrdma_mbx_modify_qp(struct ocrdma_dev *, struct ocrdma_qp *,
-                         struct ib_qp_attr *attrs, int attr_mask,
-                         enum ib_qp_state old_qps);
-int ocrdma_mbx_query_qp(struct ocrdma_dev *, struct ocrdma_qp *,
-                        struct ocrdma_qp_params *param);
-int ocrdma_mbx_destroy_qp(struct ocrdma_dev *, struct ocrdma_qp *);
-
-int ocrdma_mbx_create_srq(struct ocrdma_srq *,
-                          struct ib_srq_init_attr *,
-                          struct ocrdma_pd *);
-int ocrdma_mbx_modify_srq(struct ocrdma_srq *, struct ib_srq_attr *);
-int ocrdma_mbx_query_srq(struct ocrdma_srq *, struct ib_srq_attr *);
-int ocrdma_mbx_destroy_srq(struct ocrdma_dev *, struct ocrdma_srq *);
-
-int ocrdma_alloc_av(struct ocrdma_dev *, struct ocrdma_ah *);
-int ocrdma_free_av(struct ocrdma_dev *, struct ocrdma_ah *);
-
-int ocrdma_qp_state_machine(struct ocrdma_qp *, enum ib_qp_state new_state,
-                            enum ib_qp_state *old_ib_state);
-bool ocrdma_is_qp_in_sq_flushlist(struct ocrdma_cq *, struct ocrdma_qp *);
-bool ocrdma_is_qp_in_rq_flushlist(struct ocrdma_cq *, struct ocrdma_qp *);
-void ocrdma_flush_qp(struct ocrdma_qp *);
-
-#endif                          /* __OCRDMA_HW_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_main.c b/drivers/infiniband/hw/ocrdma/ocrdma_main.c
deleted file mode 100644
index c4e0131f1b5..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_main.c
+++ /dev/null
@@ -1,580 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#include <linux/module.h>
-#include <linux/idr.h>
-#include <rdma/ib_verbs.h>
-#include <rdma/ib_user_verbs.h>
-#include <rdma/ib_addr.h>
-
-#include <linux/netdevice.h>
-#include <net/addrconf.h>
-
-#include "ocrdma.h"
-#include "ocrdma_verbs.h"
-#include "ocrdma_ah.h"
-#include "be_roce.h"
-#include "ocrdma_hw.h"
-
-MODULE_VERSION(OCRDMA_ROCE_DEV_VERSION);
-MODULE_DESCRIPTION("Emulex RoCE HCA Driver");
-MODULE_AUTHOR("Emulex Corporation");
-MODULE_LICENSE("GPL");
-
-static LIST_HEAD(ocrdma_dev_list);
-static DEFINE_SPINLOCK(ocrdma_devlist_lock);
-static DEFINE_IDR(ocrdma_dev_id);
-
-static union ib_gid ocrdma_zero_sgid;
-
-static int ocrdma_get_instance(void)
-{
-        int instance = 0;
-
-        /* Assign an unused number */
-        if (!idr_pre_get(&ocrdma_dev_id, GFP_KERNEL))
-                return -1;
-        if (idr_get_new(&ocrdma_dev_id, NULL, &instance))
-                return -1;
-        return instance;
-}
-
-void ocrdma_get_guid(struct ocrdma_dev *dev, u8 *guid)
-{
-        u8 mac_addr[6];
-
-        memcpy(&mac_addr[0], &dev->nic_info.mac_addr[0], ETH_ALEN);
-        guid[0] = mac_addr[0] ^ 2;
-        guid[1] = mac_addr[1];
-        guid[2] = mac_addr[2];
-        guid[3] = 0xff;
-        guid[4] = 0xfe;
-        guid[5] = mac_addr[3];
-        guid[6] = mac_addr[4];
-        guid[7] = mac_addr[5];
-}
-
-static void ocrdma_build_sgid_mac(union ib_gid *sgid, unsigned char *mac_addr,
-                                  bool is_vlan, u16 vlan_id)
-{
-        sgid->global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
-        sgid->raw[8] = mac_addr[0] ^ 2;
-        sgid->raw[9] = mac_addr[1];
-        sgid->raw[10] = mac_addr[2];
-        if (is_vlan) {
-                sgid->raw[11] = vlan_id >> 8;
-                sgid->raw[12] = vlan_id & 0xff;
-        } else {
-                sgid->raw[11] = 0xff;
-                sgid->raw[12] = 0xfe;
-        }
-        sgid->raw[13] = mac_addr[3];
-        sgid->raw[14] = mac_addr[4];
-        sgid->raw[15] = mac_addr[5];
-}
-
-static bool ocrdma_add_sgid(struct ocrdma_dev *dev, unsigned char *mac_addr,
-                            bool is_vlan, u16 vlan_id)
-{
-        int i;
-        union ib_gid new_sgid;
-        unsigned long flags;
-
-        memset(&ocrdma_zero_sgid, 0, sizeof(union ib_gid));
-
-        ocrdma_build_sgid_mac(&new_sgid, mac_addr, is_vlan, vlan_id);
-
-        spin_lock_irqsave(&dev->sgid_lock, flags);
-        for (i = 0; i < OCRDMA_MAX_SGID; i++) {
-                if (!memcmp(&dev->sgid_tbl[i], &ocrdma_zero_sgid,
-                            sizeof(union ib_gid))) {
-                        /* found free entry */
-                        memcpy(&dev->sgid_tbl[i], &new_sgid,
-                               sizeof(union ib_gid));
-                        spin_unlock_irqrestore(&dev->sgid_lock, flags);
-                        return true;
-                } else if (!memcmp(&dev->sgid_tbl[i], &new_sgid,
-                                   sizeof(union ib_gid))) {
-                        /* entry already present, no addition is required. */
-                        spin_unlock_irqrestore(&dev->sgid_lock, flags);
-                        return false;
-                }
-        }
-        spin_unlock_irqrestore(&dev->sgid_lock, flags);
-        return false;
-}
-
-static bool ocrdma_del_sgid(struct ocrdma_dev *dev, unsigned char *mac_addr,
-                            bool is_vlan, u16 vlan_id)
-{
-        int found = false;
-        int i;
-        union ib_gid sgid;
-        unsigned long flags;
-
-        ocrdma_build_sgid_mac(&sgid, mac_addr, is_vlan, vlan_id);
-
-        spin_lock_irqsave(&dev->sgid_lock, flags);
-        /* first is default sgid, which cannot be deleted. */
-        for (i = 1; i < OCRDMA_MAX_SGID; i++) {
-                if (!memcmp(&dev->sgid_tbl[i], &sgid, sizeof(union ib_gid))) {
-                        /* found matching entry */
-                        memset(&dev->sgid_tbl[i], 0, sizeof(union ib_gid));
-                        found = true;
-                        break;
-                }
-        }
-        spin_unlock_irqrestore(&dev->sgid_lock, flags);
-        return found;
-}
-
-static void ocrdma_add_default_sgid(struct ocrdma_dev *dev)
-{
-        /* GID Index 0 - Invariant manufacturer-assigned EUI-64 */
-        union ib_gid *sgid = &dev->sgid_tbl[0];
-
-        sgid->global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
-        ocrdma_get_guid(dev, &sgid->raw[8]);
-}
-
-#if IS_ENABLED(CONFIG_VLAN_8021Q)
-static void ocrdma_add_vlan_sgids(struct ocrdma_dev *dev)
-{
-        struct net_device *netdev, *tmp;
-        u16 vlan_id;
-        bool is_vlan;
-
-        netdev = dev->nic_info.netdev;
-
-        rcu_read_lock();
-        for_each_netdev_rcu(&init_net, tmp) {
-                if (netdev == tmp || vlan_dev_real_dev(tmp) == netdev) {
-                        if (!netif_running(tmp) || !netif_oper_up(tmp))
-                                continue;
-                        if (netdev != tmp) {
-                                vlan_id = vlan_dev_vlan_id(tmp);
-                                is_vlan = true;
-                        } else {
-                                is_vlan = false;
-                                vlan_id = 0;
-                                tmp = netdev;
-                        }
-                        ocrdma_add_sgid(dev, tmp->dev_addr, is_vlan, vlan_id);
-                }
-        }
-        rcu_read_unlock();
-}
-#else
-static void ocrdma_add_vlan_sgids(struct ocrdma_dev *dev)
-{
-
-}
-#endif /* VLAN */
-
-static int ocrdma_build_sgid_tbl(struct ocrdma_dev *dev)
-{
-        ocrdma_add_default_sgid(dev);
-        ocrdma_add_vlan_sgids(dev);
-        return 0;
-}
-
-#if IS_ENABLED(CONFIG_IPV6)
-
-static int ocrdma_inet6addr_event(struct notifier_block *notifier,
-                                  unsigned long event, void *ptr)
-{
-        struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
-        struct net_device *netdev = ifa->idev->dev;
-        struct ib_event gid_event;
-        struct ocrdma_dev *dev;
-        bool found = false;
-        bool updated = false;
-        bool is_vlan = false;
-        u16 vid = 0;
-
-        is_vlan = netdev->priv_flags & IFF_802_1Q_VLAN;
-        if (is_vlan) {
-                vid = vlan_dev_vlan_id(netdev);
-                netdev = vlan_dev_real_dev(netdev);
-        }
-
-        rcu_read_lock();
-        list_for_each_entry_rcu(dev, &ocrdma_dev_list, entry) {
-                if (dev->nic_info.netdev == netdev) {
-                        found = true;
-                        break;
-                }
-        }
-        rcu_read_unlock();
-
-        if (!found)
-                return NOTIFY_DONE;
-        if (!rdma_link_local_addr((struct in6_addr *)&ifa->addr))
-                return NOTIFY_DONE;
-
-        mutex_lock(&dev->dev_lock);
-        switch (event) {
-        case NETDEV_UP:
-                updated = ocrdma_add_sgid(dev, netdev->dev_addr, is_vlan, vid);
-                break;
-        case NETDEV_DOWN:
-                updated = ocrdma_del_sgid(dev, netdev->dev_addr, is_vlan, vid);
-                break;
-        default:
-                break;
-        }
-        if (updated) {
-                /* GID table updated, notify the consumers about it */
-                gid_event.device = &dev->ibdev;
-                gid_event.element.port_num = 1;
-                gid_event.event = IB_EVENT_GID_CHANGE;
-                ib_dispatch_event(&gid_event);
-        }
-        mutex_unlock(&dev->dev_lock);
-        return NOTIFY_OK;
-}
-
-static struct notifier_block ocrdma_inet6addr_notifier = {
-        .notifier_call = ocrdma_inet6addr_event
-};
-
-#endif /* IPV6 and VLAN */
-
-static enum rdma_link_layer ocrdma_link_layer(struct ib_device *device,
-                                              u8 port_num)
-{
-        return IB_LINK_LAYER_ETHERNET;
-}
-
-static int ocrdma_register_device(struct ocrdma_dev *dev)
-{
-        strlcpy(dev->ibdev.name, "ocrdma%d", IB_DEVICE_NAME_MAX);
-        ocrdma_get_guid(dev, (u8 *)&dev->ibdev.node_guid);
-        memcpy(dev->ibdev.node_desc, OCRDMA_NODE_DESC,
-               sizeof(OCRDMA_NODE_DESC));
-        dev->ibdev.owner = THIS_MODULE;
-        dev->ibdev.uverbs_cmd_mask =
-            OCRDMA_UVERBS(GET_CONTEXT) |
-            OCRDMA_UVERBS(QUERY_DEVICE) |
-            OCRDMA_UVERBS(QUERY_PORT) |
-            OCRDMA_UVERBS(ALLOC_PD) |
-            OCRDMA_UVERBS(DEALLOC_PD) |
-            OCRDMA_UVERBS(REG_MR) |
-            OCRDMA_UVERBS(DEREG_MR) |
-            OCRDMA_UVERBS(CREATE_COMP_CHANNEL) |
-            OCRDMA_UVERBS(CREATE_CQ) |
-            OCRDMA_UVERBS(RESIZE_CQ) |
-            OCRDMA_UVERBS(DESTROY_CQ) |
-            OCRDMA_UVERBS(REQ_NOTIFY_CQ) |
-            OCRDMA_UVERBS(CREATE_QP) |
-            OCRDMA_UVERBS(MODIFY_QP) |
-            OCRDMA_UVERBS(QUERY_QP) |
-            OCRDMA_UVERBS(DESTROY_QP) |
-            OCRDMA_UVERBS(POLL_CQ) |
-            OCRDMA_UVERBS(POST_SEND) |
-            OCRDMA_UVERBS(POST_RECV);
-
-        dev->ibdev.uverbs_cmd_mask |=
-            OCRDMA_UVERBS(CREATE_AH) |
-             OCRDMA_UVERBS(MODIFY_AH) |
-             OCRDMA_UVERBS(QUERY_AH) |
-             OCRDMA_UVERBS(DESTROY_AH);
-
-        dev->ibdev.node_type = RDMA_NODE_IB_CA;
-        dev->ibdev.phys_port_cnt = 1;
-        dev->ibdev.num_comp_vectors = 1;
-
-        /* mandatory verbs. */
-        dev->ibdev.query_device = ocrdma_query_device;
-        dev->ibdev.query_port = ocrdma_query_port;
-        dev->ibdev.modify_port = ocrdma_modify_port;
-        dev->ibdev.query_gid = ocrdma_query_gid;
-        dev->ibdev.get_link_layer = ocrdma_link_layer;
-        dev->ibdev.alloc_pd = ocrdma_alloc_pd;
-        dev->ibdev.dealloc_pd = ocrdma_dealloc_pd;
-
-        dev->ibdev.create_cq = ocrdma_create_cq;
-        dev->ibdev.destroy_cq = ocrdma_destroy_cq;
-        dev->ibdev.resize_cq = ocrdma_resize_cq;
-
-        dev->ibdev.create_qp = ocrdma_create_qp;
-        dev->ibdev.modify_qp = ocrdma_modify_qp;
-        dev->ibdev.query_qp = ocrdma_query_qp;
-        dev->ibdev.destroy_qp = ocrdma_destroy_qp;
-
-        dev->ibdev.query_pkey = ocrdma_query_pkey;
-        dev->ibdev.create_ah = ocrdma_create_ah;
-        dev->ibdev.destroy_ah = ocrdma_destroy_ah;
-        dev->ibdev.query_ah = ocrdma_query_ah;
-        dev->ibdev.modify_ah = ocrdma_modify_ah;
-
-        dev->ibdev.poll_cq = ocrdma_poll_cq;
-        dev->ibdev.post_send = ocrdma_post_send;
-        dev->ibdev.post_recv = ocrdma_post_recv;
-        dev->ibdev.req_notify_cq = ocrdma_arm_cq;
-
-        dev->ibdev.get_dma_mr = ocrdma_get_dma_mr;
-        dev->ibdev.dereg_mr = ocrdma_dereg_mr;
-        dev->ibdev.reg_user_mr = ocrdma_reg_user_mr;
-
-        /* mandatory to support user space verbs consumer. */
-        dev->ibdev.alloc_ucontext = ocrdma_alloc_ucontext;
-        dev->ibdev.dealloc_ucontext = ocrdma_dealloc_ucontext;
-        dev->ibdev.mmap = ocrdma_mmap;
-        dev->ibdev.dma_device = &dev->nic_info.pdev->dev;
-
-        dev->ibdev.process_mad = ocrdma_process_mad;
-
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                dev->ibdev.uverbs_cmd_mask |=
-                     OCRDMA_UVERBS(CREATE_SRQ) |
-                     OCRDMA_UVERBS(MODIFY_SRQ) |
-                     OCRDMA_UVERBS(QUERY_SRQ) |
-                     OCRDMA_UVERBS(DESTROY_SRQ) |
-                     OCRDMA_UVERBS(POST_SRQ_RECV);
-
-                dev->ibdev.create_srq = ocrdma_create_srq;
-                dev->ibdev.modify_srq = ocrdma_modify_srq;
-                dev->ibdev.query_srq = ocrdma_query_srq;
-                dev->ibdev.destroy_srq = ocrdma_destroy_srq;
-                dev->ibdev.post_srq_recv = ocrdma_post_srq_recv;
-        }
-        return ib_register_device(&dev->ibdev, NULL);
-}
-
-static int ocrdma_alloc_resources(struct ocrdma_dev *dev)
-{
-        mutex_init(&dev->dev_lock);
-        dev->sgid_tbl = kzalloc(sizeof(union ib_gid) *
-                                OCRDMA_MAX_SGID, GFP_KERNEL);
-        if (!dev->sgid_tbl)
-                goto alloc_err;
-        spin_lock_init(&dev->sgid_lock);
-
-        dev->cq_tbl = kzalloc(sizeof(struct ocrdma_cq *) *
-                              OCRDMA_MAX_CQ, GFP_KERNEL);
-        if (!dev->cq_tbl)
-                goto alloc_err;
-
-        if (dev->attr.max_qp) {
-                dev->qp_tbl = kzalloc(sizeof(struct ocrdma_qp *) *
-                                      OCRDMA_MAX_QP, GFP_KERNEL);
-                if (!dev->qp_tbl)
-                        goto alloc_err;
-        }
-        spin_lock_init(&dev->av_tbl.lock);
-        spin_lock_init(&dev->flush_q_lock);
-        return 0;
-alloc_err:
-        ocrdma_err("%s(%d) error.\n", __func__, dev->id);
-        return -ENOMEM;
-}
-
-static void ocrdma_free_resources(struct ocrdma_dev *dev)
-{
-        kfree(dev->qp_tbl);
-        kfree(dev->cq_tbl);
-        kfree(dev->sgid_tbl);
-}
-
-static struct ocrdma_dev *ocrdma_add(struct be_dev_info *dev_info)
-{
-        int status = 0;
-        struct ocrdma_dev *dev;
-
-        dev = (struct ocrdma_dev *)ib_alloc_device(sizeof(struct ocrdma_dev));
-        if (!dev) {
-                ocrdma_err("Unable to allocate ib device\n");
-                return NULL;
-        }
-        dev->mbx_cmd = kzalloc(sizeof(struct ocrdma_mqe_emb_cmd), GFP_KERNEL);
-        if (!dev->mbx_cmd)
-                goto idr_err;
-
-        memcpy(&dev->nic_info, dev_info, sizeof(*dev_info));
-        dev->id = ocrdma_get_instance();
-        if (dev->id < 0)
-                goto idr_err;
-
-        status = ocrdma_init_hw(dev);
-        if (status)
-                goto init_err;
-
-        status = ocrdma_alloc_resources(dev);
-        if (status)
-                goto alloc_err;
-
-        status = ocrdma_build_sgid_tbl(dev);
-        if (status)
-                goto alloc_err;
-
-        status = ocrdma_register_device(dev);
-        if (status)
-                goto alloc_err;
-
-        spin_lock(&ocrdma_devlist_lock);
-        list_add_tail_rcu(&dev->entry, &ocrdma_dev_list);
-        spin_unlock(&ocrdma_devlist_lock);
-        return dev;
-
-alloc_err:
-        ocrdma_free_resources(dev);
-        ocrdma_cleanup_hw(dev);
-init_err:
-        idr_remove(&ocrdma_dev_id, dev->id);
-idr_err:
-        kfree(dev->mbx_cmd);
-        ib_dealloc_device(&dev->ibdev);
-        ocrdma_err("%s() leaving. ret=%d\n", __func__, status);
-        return NULL;
-}
-
-static void ocrdma_remove_free(struct rcu_head *rcu)
-{
-        struct ocrdma_dev *dev = container_of(rcu, struct ocrdma_dev, rcu);
-
-        ocrdma_free_resources(dev);
-        ocrdma_cleanup_hw(dev);
-
-        idr_remove(&ocrdma_dev_id, dev->id);
-        kfree(dev->mbx_cmd);
-        ib_dealloc_device(&dev->ibdev);
-}
-
-static void ocrdma_remove(struct ocrdma_dev *dev)
-{
-        /* first unregister with stack to stop all the active traffic
-         * of the registered clients.
-         */
-        ib_unregister_device(&dev->ibdev);
-
-        spin_lock(&ocrdma_devlist_lock);
-        list_del_rcu(&dev->entry);
-        spin_unlock(&ocrdma_devlist_lock);
-        call_rcu(&dev->rcu, ocrdma_remove_free);
-}
-
-static int ocrdma_open(struct ocrdma_dev *dev)
-{
-        struct ib_event port_event;
-
-        port_event.event = IB_EVENT_PORT_ACTIVE;
-        port_event.element.port_num = 1;
-        port_event.device = &dev->ibdev;
-        ib_dispatch_event(&port_event);
-        return 0;
-}
-
-static int ocrdma_close(struct ocrdma_dev *dev)
-{
-        int i;
-        struct ocrdma_qp *qp, **cur_qp;
-        struct ib_event err_event;
-        struct ib_qp_attr attrs;
-        int attr_mask = IB_QP_STATE;
-
-        attrs.qp_state = IB_QPS_ERR;
-        mutex_lock(&dev->dev_lock);
-        if (dev->qp_tbl) {
-                cur_qp = dev->qp_tbl;
-                for (i = 0; i < OCRDMA_MAX_QP; i++) {
-                        qp = cur_qp[i];
-                        if (qp) {
-                                /* change the QP state to ERROR */
-                                _ocrdma_modify_qp(&qp->ibqp, &attrs, attr_mask);
-
-                                err_event.event = IB_EVENT_QP_FATAL;
-                                err_event.element.qp = &qp->ibqp;
-                                err_event.device = &dev->ibdev;
-                                ib_dispatch_event(&err_event);
-                        }
-                }
-        }
-        mutex_unlock(&dev->dev_lock);
-
-        err_event.event = IB_EVENT_PORT_ERR;
-        err_event.element.port_num = 1;
-        err_event.device = &dev->ibdev;
-        ib_dispatch_event(&err_event);
-        return 0;
-}
-
-/* event handling via NIC driver ensures that all the NIC specific
- * initialization done before RoCE driver notifies
- * event to stack.
- */
-static void ocrdma_event_handler(struct ocrdma_dev *dev, u32 event)
-{
-        switch (event) {
-        case BE_DEV_UP:
-                ocrdma_open(dev);
-                break;
-        case BE_DEV_DOWN:
-                ocrdma_close(dev);
-                break;
-        };
-}
-
-static struct ocrdma_driver ocrdma_drv = {
-        .name                   = "ocrdma_driver",
-        .add                    = ocrdma_add,
-        .remove                 = ocrdma_remove,
-        .state_change_handler   = ocrdma_event_handler,
-};
-
-static void ocrdma_unregister_inet6addr_notifier(void)
-{
-#if IS_ENABLED(CONFIG_IPV6)
-        unregister_inet6addr_notifier(&ocrdma_inet6addr_notifier);
-#endif
-}
-
-static int __init ocrdma_init_module(void)
-{
-        int status;
-
-#if IS_ENABLED(CONFIG_IPV6)
-        status = register_inet6addr_notifier(&ocrdma_inet6addr_notifier);
-        if (status)
-                return status;
-#endif
-
-        status = be_roce_register_driver(&ocrdma_drv);
-        if (status)
-                ocrdma_unregister_inet6addr_notifier();
-
-        return status;
-}
-
-static void __exit ocrdma_exit_module(void)
-{
-        be_roce_unregister_driver(&ocrdma_drv);
-        ocrdma_unregister_inet6addr_notifier();
-}
-
-module_init(ocrdma_init_module);
-module_exit(ocrdma_exit_module);
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h b/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
deleted file mode 100644
index c75cbdfa87e..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
+++ /dev/null
@@ -1,1675 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_SLI_H__
-#define __OCRDMA_SLI_H__
-
-#define Bit(_b) (1 << (_b))
-
-#define OCRDMA_GEN1_FAMILY      0xB
-#define OCRDMA_GEN2_FAMILY      0x2
-
-#define OCRDMA_SUBSYS_ROCE 10
-enum {
-        OCRDMA_CMD_QUERY_CONFIG = 1,
-        OCRDMA_CMD_ALLOC_PD,
-        OCRDMA_CMD_DEALLOC_PD,
-
-        OCRDMA_CMD_CREATE_AH_TBL,
-        OCRDMA_CMD_DELETE_AH_TBL,
-
-        OCRDMA_CMD_CREATE_QP,
-        OCRDMA_CMD_QUERY_QP,
-        OCRDMA_CMD_MODIFY_QP,
-        OCRDMA_CMD_DELETE_QP,
-
-        OCRDMA_CMD_RSVD1,
-        OCRDMA_CMD_ALLOC_LKEY,
-        OCRDMA_CMD_DEALLOC_LKEY,
-        OCRDMA_CMD_REGISTER_NSMR,
-        OCRDMA_CMD_REREGISTER_NSMR,
-        OCRDMA_CMD_REGISTER_NSMR_CONT,
-        OCRDMA_CMD_QUERY_NSMR,
-        OCRDMA_CMD_ALLOC_MW,
-        OCRDMA_CMD_QUERY_MW,
-
-        OCRDMA_CMD_CREATE_SRQ,
-        OCRDMA_CMD_QUERY_SRQ,
-        OCRDMA_CMD_MODIFY_SRQ,
-        OCRDMA_CMD_DELETE_SRQ,
-
-        OCRDMA_CMD_ATTACH_MCAST,
-        OCRDMA_CMD_DETACH_MCAST,
-
-        OCRDMA_CMD_MAX
-};
-
-#define OCRDMA_SUBSYS_COMMON 1
-enum {
-        OCRDMA_CMD_CREATE_CQ            = 12,
-        OCRDMA_CMD_CREATE_EQ            = 13,
-        OCRDMA_CMD_CREATE_MQ            = 21,
-        OCRDMA_CMD_GET_FW_VER           = 35,
-        OCRDMA_CMD_DELETE_MQ            = 53,
-        OCRDMA_CMD_DELETE_CQ            = 54,
-        OCRDMA_CMD_DELETE_EQ            = 55,
-        OCRDMA_CMD_GET_FW_CONFIG        = 58,
-        OCRDMA_CMD_CREATE_MQ_EXT        = 90
-};
-
-enum {
-        QTYPE_EQ        = 1,
-        QTYPE_CQ        = 2,
-        QTYPE_MCCQ      = 3
-};
-
-#define OCRDMA_MAX_SGID (8)
-
-#define OCRDMA_MAX_QP    2048
-#define OCRDMA_MAX_CQ    2048
-
-enum {
-        OCRDMA_DB_RQ_OFFSET             = 0xE0,
-        OCRDMA_DB_GEN2_RQ1_OFFSET       = 0x100,
-        OCRDMA_DB_GEN2_RQ2_OFFSET       = 0xC0,
-        OCRDMA_DB_SQ_OFFSET             = 0x60,
-        OCRDMA_DB_GEN2_SQ_OFFSET        = 0x1C0,
-        OCRDMA_DB_SRQ_OFFSET            = OCRDMA_DB_RQ_OFFSET,
-        OCRDMA_DB_GEN2_SRQ_OFFSET       = OCRDMA_DB_GEN2_RQ1_OFFSET,
-        OCRDMA_DB_CQ_OFFSET             = 0x120,
-        OCRDMA_DB_EQ_OFFSET             = OCRDMA_DB_CQ_OFFSET,
-        OCRDMA_DB_MQ_OFFSET             = 0x140
-};
-
-#define OCRDMA_DB_CQ_RING_ID_MASK       0x3FF   /* bits 0 - 9 */
-#define OCRDMA_DB_CQ_RING_ID_EXT_MASK  0x0C00   /* bits 10-11 of qid at 12-11 */
-/* qid #2 msbits at 12-11 */
-#define OCRDMA_DB_CQ_RING_ID_EXT_MASK_SHIFT  0x1
-#define OCRDMA_DB_CQ_NUM_POPPED_SHIFT       (16)        /* bits 16 - 28 */
-/* Rearm bit */
-#define OCRDMA_DB_CQ_REARM_SHIFT        (29)    /* bit 29 */
-/* solicited bit */
-#define OCRDMA_DB_CQ_SOLICIT_SHIFT   (31)       /* bit 31 */
-
-#define OCRDMA_EQ_ID_MASK               0x1FF   /* bits 0 - 8 */
-#define OCRDMA_EQ_ID_EXT_MASK           0x3e00  /* bits 9-13 */
-#define OCRDMA_EQ_ID_EXT_MASK_SHIFT     (2)     /* qid bits 9-13 at 11-15 */
-
-/* Clear the interrupt for this eq */
-#define OCRDMA_EQ_CLR_SHIFT                     (9)     /* bit 9 */
-/* Must be 1 */
-#define OCRDMA_EQ_TYPE_SHIFT            (10)    /* bit 10 */
-/* Number of event entries processed */
-#define OCRDMA_NUM_EQE_SHIFT            (16)    /* bits 16 - 28 */
-/* Rearm bit */
-#define OCRDMA_REARM_SHIFT              (29)    /* bit 29 */
-
-#define OCRDMA_MQ_ID_MASK               0x7FF   /* bits 0 - 10 */
-/* Number of entries posted */
-#define OCRDMA_MQ_NUM_MQE_SHIFT (16)    /* bits 16 - 29 */
-
-#define OCRDMA_MIN_HPAGE_SIZE (4096)
-
-#define OCRDMA_MIN_Q_PAGE_SIZE (4096)
-#define OCRDMA_MAX_Q_PAGES     (8)
-
-/*
-# 0: 4K Bytes
-# 1: 8K Bytes
-# 2: 16K Bytes
-# 3: 32K Bytes
-# 4: 64K Bytes
-*/
-#define OCRDMA_MAX_Q_PAGE_SIZE_CNT (5)
-#define OCRDMA_Q_PAGE_BASE_SIZE (OCRDMA_MIN_Q_PAGE_SIZE * OCRDMA_MAX_Q_PAGES)
-
-#define MAX_OCRDMA_QP_PAGES      (8)
-#define OCRDMA_MAX_WQE_MEM_SIZE (MAX_OCRDMA_QP_PAGES * OCRDMA_MIN_HQ_PAGE_SIZE)
-
-#define OCRDMA_CREATE_CQ_MAX_PAGES (4)
-#define OCRDMA_DPP_CQE_SIZE (4)
-
-#define OCRDMA_GEN2_MAX_CQE 1024
-#define OCRDMA_GEN2_CQ_PAGE_SIZE 4096
-#define OCRDMA_GEN2_WQE_SIZE 256
-#define OCRDMA_MAX_CQE  4095
-#define OCRDMA_CQ_PAGE_SIZE 16384
-#define OCRDMA_WQE_SIZE 128
-#define OCRDMA_WQE_STRIDE 8
-#define OCRDMA_WQE_ALIGN_BYTES 16
-
-#define MAX_OCRDMA_SRQ_PAGES MAX_OCRDMA_QP_PAGES
-
-enum {
-        OCRDMA_MCH_OPCODE_SHIFT = 0,
-        OCRDMA_MCH_OPCODE_MASK  = 0xFF,
-        OCRDMA_MCH_SUBSYS_SHIFT = 8,
-        OCRDMA_MCH_SUBSYS_MASK  = 0xFF00
-};
-
-/* mailbox cmd header */
-struct ocrdma_mbx_hdr {
-        u32 subsys_op;
-        u32 timeout;            /* in seconds */
-        u32 cmd_len;
-        u32 rsvd_version;
-} __packed;
-
-enum {
-        OCRDMA_MBX_RSP_OPCODE_SHIFT     = 0,
-        OCRDMA_MBX_RSP_OPCODE_MASK      = 0xFF,
-        OCRDMA_MBX_RSP_SUBSYS_SHIFT     = 8,
-        OCRDMA_MBX_RSP_SUBSYS_MASK      = 0xFF << OCRDMA_MBX_RSP_SUBSYS_SHIFT,
-
-        OCRDMA_MBX_RSP_STATUS_SHIFT     = 0,
-        OCRDMA_MBX_RSP_STATUS_MASK      = 0xFF,
-        OCRDMA_MBX_RSP_ASTATUS_SHIFT    = 8,
-        OCRDMA_MBX_RSP_ASTATUS_MASK     = 0xFF << OCRDMA_MBX_RSP_ASTATUS_SHIFT
-};
-
-/* mailbox cmd response */
-struct ocrdma_mbx_rsp {
-        u32 subsys_op;
-        u32 status;
-        u32 rsp_len;
-        u32 add_rsp_len;
-} __packed;
-
-enum {
-        OCRDMA_MQE_EMBEDDED     = 1,
-        OCRDMA_MQE_NONEMBEDDED  = 0
-};
-
-struct ocrdma_mqe_sge {
-        u32 pa_lo;
-        u32 pa_hi;
-        u32 len;
-} __packed;
-
-enum {
-        OCRDMA_MQE_HDR_EMB_SHIFT        = 0,
-        OCRDMA_MQE_HDR_EMB_MASK         = Bit(0),
-        OCRDMA_MQE_HDR_SGE_CNT_SHIFT    = 3,
-        OCRDMA_MQE_HDR_SGE_CNT_MASK     = 0x1F << OCRDMA_MQE_HDR_SGE_CNT_SHIFT,
-        OCRDMA_MQE_HDR_SPECIAL_SHIFT    = 24,
-        OCRDMA_MQE_HDR_SPECIAL_MASK     = 0xFF << OCRDMA_MQE_HDR_SPECIAL_SHIFT
-};
-
-struct ocrdma_mqe_hdr {
-        u32 spcl_sge_cnt_emb;
-        u32 pyld_len;
-        u32 tag_lo;
-        u32 tag_hi;
-        u32 rsvd3;
-} __packed;
-
-struct ocrdma_mqe_emb_cmd {
-        struct ocrdma_mbx_hdr mch;
-        u8 pyld[220];
-} __packed;
-
-struct ocrdma_mqe {
-        struct ocrdma_mqe_hdr hdr;
-        union {
-                struct ocrdma_mqe_emb_cmd emb_req;
-                struct {
-                        struct ocrdma_mqe_sge sge[19];
-                } nonemb_req;
-                u8 cmd[236];
-                struct ocrdma_mbx_rsp rsp;
-        } u;
-} __packed;
-
-#define OCRDMA_EQ_LEN       4096
-#define OCRDMA_MQ_CQ_LEN    256
-#define OCRDMA_MQ_LEN       128
-
-#define PAGE_SHIFT_4K           12
-#define PAGE_SIZE_4K            (1 << PAGE_SHIFT_4K)
-
-/* Returns number of pages spanned by the data starting at the given addr */
-#define PAGES_4K_SPANNED(_address, size) \
-        ((u32)((((size_t)(_address) & (PAGE_SIZE_4K - 1)) +     \
-                        (size) + (PAGE_SIZE_4K - 1)) >> PAGE_SHIFT_4K))
-
-struct ocrdma_delete_q_req {
-        struct ocrdma_mbx_hdr req;
-        u32 id;
-} __packed;
-
-struct ocrdma_pa {
-        u32 lo;
-        u32 hi;
-} __packed;
-
-#define MAX_OCRDMA_EQ_PAGES (8)
-struct ocrdma_create_eq_req {
-        struct ocrdma_mbx_hdr req;
-        u32 num_pages;
-        u32 valid;
-        u32 cnt;
-        u32 delay;
-        u32 rsvd;
-        struct ocrdma_pa pa[MAX_OCRDMA_EQ_PAGES];
-} __packed;
-
-enum {
-        OCRDMA_CREATE_EQ_VALID  = Bit(29),
-        OCRDMA_CREATE_EQ_CNT_SHIFT      = 26,
-        OCRDMA_CREATE_CQ_DELAY_SHIFT    = 13,
-};
-
-struct ocrdma_create_eq_rsp {
-        struct ocrdma_mbx_rsp rsp;
-        u32 vector_eqid;
-};
-
-#define OCRDMA_EQ_MINOR_OTHER (0x1)
-
-enum {
-        OCRDMA_MCQE_STATUS_SHIFT        = 0,
-        OCRDMA_MCQE_STATUS_MASK         = 0xFFFF,
-        OCRDMA_MCQE_ESTATUS_SHIFT       = 16,
-        OCRDMA_MCQE_ESTATUS_MASK        = 0xFFFF << OCRDMA_MCQE_ESTATUS_SHIFT,
-        OCRDMA_MCQE_CONS_SHIFT          = 27,
-        OCRDMA_MCQE_CONS_MASK           = Bit(27),
-        OCRDMA_MCQE_CMPL_SHIFT          = 28,
-        OCRDMA_MCQE_CMPL_MASK           = Bit(28),
-        OCRDMA_MCQE_AE_SHIFT            = 30,
-        OCRDMA_MCQE_AE_MASK             = Bit(30),
-        OCRDMA_MCQE_VALID_SHIFT         = 31,
-        OCRDMA_MCQE_VALID_MASK          = Bit(31)
-};
-
-struct ocrdma_mcqe {
-        u32 status;
-        u32 tag_lo;
-        u32 tag_hi;
-        u32 valid_ae_cmpl_cons;
-} __packed;
-
-enum {
-        OCRDMA_AE_MCQE_QPVALID          = Bit(31),
-        OCRDMA_AE_MCQE_QPID_MASK        = 0xFFFF,
-
-        OCRDMA_AE_MCQE_CQVALID          = Bit(31),
-        OCRDMA_AE_MCQE_CQID_MASK        = 0xFFFF,
-        OCRDMA_AE_MCQE_VALID            = Bit(31),
-        OCRDMA_AE_MCQE_AE               = Bit(30),
-        OCRDMA_AE_MCQE_EVENT_TYPE_SHIFT = 16,
-        OCRDMA_AE_MCQE_EVENT_TYPE_MASK  =
-                                        0xFF << OCRDMA_AE_MCQE_EVENT_TYPE_SHIFT,
-        OCRDMA_AE_MCQE_EVENT_CODE_SHIFT = 8,
-        OCRDMA_AE_MCQE_EVENT_CODE_MASK  =
-                                        0xFF << OCRDMA_AE_MCQE_EVENT_CODE_SHIFT
-};
-struct ocrdma_ae_mcqe {
-        u32 qpvalid_qpid;
-        u32 cqvalid_cqid;
-        u32 evt_tag;
-        u32 valid_ae_event;
-} __packed;
-
-enum {
-        OCRDMA_AE_MPA_MCQE_REQ_ID_SHIFT         = 16,
-        OCRDMA_AE_MPA_MCQE_REQ_ID_MASK          = 0xFFFF <<
-                                        OCRDMA_AE_MPA_MCQE_REQ_ID_SHIFT,
-
-        OCRDMA_AE_MPA_MCQE_EVENT_CODE_SHIFT     = 8,
-        OCRDMA_AE_MPA_MCQE_EVENT_CODE_MASK      = 0xFF <<
-                                        OCRDMA_AE_MPA_MCQE_EVENT_CODE_SHIFT,
-        OCRDMA_AE_MPA_MCQE_EVENT_TYPE_SHIFT     = 16,
-        OCRDMA_AE_MPA_MCQE_EVENT_TYPE_MASK      = 0xFF <<
-                                        OCRDMA_AE_MPA_MCQE_EVENT_TYPE_SHIFT,
-        OCRDMA_AE_MPA_MCQE_EVENT_AE_SHIFT       = 30,
-        OCRDMA_AE_MPA_MCQE_EVENT_AE_MASK        = Bit(30),
-        OCRDMA_AE_MPA_MCQE_EVENT_VALID_SHIFT    = 31,
-        OCRDMA_AE_MPA_MCQE_EVENT_VALID_MASK     = Bit(31)
-};
-
-struct ocrdma_ae_mpa_mcqe {
-        u32 req_id;
-        u32 w1;
-        u32 w2;
-        u32 valid_ae_event;
-} __packed;
-
-enum {
-        OCRDMA_AE_QP_MCQE_NEW_QP_STATE_SHIFT    = 0,
-        OCRDMA_AE_QP_MCQE_NEW_QP_STATE_MASK     = 0xFFFF,
-        OCRDMA_AE_QP_MCQE_QP_ID_SHIFT           = 16,
-        OCRDMA_AE_QP_MCQE_QP_ID_MASK            = 0xFFFF <<
-                                                OCRDMA_AE_QP_MCQE_QP_ID_SHIFT,
-
-        OCRDMA_AE_QP_MCQE_EVENT_CODE_SHIFT      = 8,
-        OCRDMA_AE_QP_MCQE_EVENT_CODE_MASK       = 0xFF <<
-                                OCRDMA_AE_QP_MCQE_EVENT_CODE_SHIFT,
-        OCRDMA_AE_QP_MCQE_EVENT_TYPE_SHIFT      = 16,
-        OCRDMA_AE_QP_MCQE_EVENT_TYPE_MASK       = 0xFF <<
-                                OCRDMA_AE_QP_MCQE_EVENT_TYPE_SHIFT,
-        OCRDMA_AE_QP_MCQE_EVENT_AE_SHIFT        = 30,
-        OCRDMA_AE_QP_MCQE_EVENT_AE_MASK         = Bit(30),
-        OCRDMA_AE_QP_MCQE_EVENT_VALID_SHIFT     = 31,
-        OCRDMA_AE_QP_MCQE_EVENT_VALID_MASK      = Bit(31)
-};
-
-struct ocrdma_ae_qp_mcqe {
-        u32 qp_id_state;
-        u32 w1;
-        u32 w2;
-        u32 valid_ae_event;
-} __packed;
-
-#define OCRDMA_ASYNC_EVE_CODE 0x14
-
-enum OCRDMA_ASYNC_EVENT_TYPE {
-        OCRDMA_CQ_ERROR                 = 0x00,
-        OCRDMA_CQ_OVERRUN_ERROR         = 0x01,
-        OCRDMA_CQ_QPCAT_ERROR           = 0x02,
-        OCRDMA_QP_ACCESS_ERROR          = 0x03,
-        OCRDMA_QP_COMM_EST_EVENT        = 0x04,
-        OCRDMA_SQ_DRAINED_EVENT         = 0x05,
-        OCRDMA_DEVICE_FATAL_EVENT       = 0x08,
-        OCRDMA_SRQCAT_ERROR             = 0x0E,
-        OCRDMA_SRQ_LIMIT_EVENT          = 0x0F,
-        OCRDMA_QP_LAST_WQE_EVENT        = 0x10
-};
-
-/* mailbox command request and responses */
-enum {
-        OCRDMA_MBX_QUERY_CFG_CQ_OVERFLOW_SHIFT          = 2,
-        OCRDMA_MBX_QUERY_CFG_CQ_OVERFLOW_MASK           = Bit(2),
-        OCRDMA_MBX_QUERY_CFG_SRQ_SUPPORTED_SHIFT        = 3,
-        OCRDMA_MBX_QUERY_CFG_SRQ_SUPPORTED_MASK         = Bit(3),
-        OCRDMA_MBX_QUERY_CFG_MAX_QP_SHIFT               = 8,
-        OCRDMA_MBX_QUERY_CFG_MAX_QP_MASK                = 0xFFFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_QP_SHIFT,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_PD_SHIFT               = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_PD_MASK                = 0xFFFF <<
-                                        OCRDMA_MBX_QUERY_CFG_MAX_PD_SHIFT,
-        OCRDMA_MBX_QUERY_CFG_CA_ACK_DELAY_SHIFT         = 8,
-        OCRDMA_MBX_QUERY_CFG_CA_ACK_DELAY_MASK          = 0xFF <<
-                                OCRDMA_MBX_QUERY_CFG_CA_ACK_DELAY_SHIFT,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_SHIFT         = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_SEND_SGE_MASK          = 0xFFFF,
-        OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_SHIFT        = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_MASK         = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_WRITE_SGE_SHIFT,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_SHIFT       = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_ORD_PER_QP_MASK        = 0xFFFF,
-        OCRDMA_MBX_QUERY_CFG_MAX_IRD_PER_QP_SHIFT       = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_IRD_PER_QP_MASK        = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_IRD_PER_QP_SHIFT,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_WQE_SIZE_OFFSET        = 24,
-        OCRDMA_MBX_QUERY_CFG_MAX_WQE_SIZE_MASK          = 0xFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_WQE_SIZE_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_RQE_SIZE_OFFSET        = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_RQE_SIZE_MASK          = 0xFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_RQE_SIZE_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_CQES_OFFSET        = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_CQES_MASK          = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_DPP_CQES_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_OFFSET             = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_MASK               = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_SRQ_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_RPIR_QPS_OFFSET        = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_RPIR_QPS_MASK          = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_RPIR_QPS_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_PDS_OFFSET         = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_PDS_MASK           = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_DPP_PDS_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_CREDITS_OFFSET     = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_CREDITS_MASK       = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_DPP_CREDITS_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_QPS_OFFSET         = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_DPP_QPS_MASK           = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_DPP_QPS_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_WQES_PER_WQ_OFFSET     = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_WQES_PER_WQ_MASK       = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_WQES_PER_WQ_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_RQES_PER_RQ_OFFSET     = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_RQES_PER_RQ_MASK       = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_RQES_PER_RQ_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_CQ_OFFSET              = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_CQ_MASK                = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_CQ_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_CQES_PER_CQ_OFFSET     = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_CQES_PER_CQ_MASK       = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_CQES_PER_CQ_OFFSET,
-
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_RQE_OFFSET         = 16,
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_RQE_MASK           = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_SRQ_RQE_OFFSET,
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET         = 0,
-        OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_MASK           = 0xFFFF <<
-                                OCRDMA_MBX_QUERY_CFG_MAX_SRQ_SGE_OFFSET,
-};
-
-struct ocrdma_mbx_query_config {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-        u32 qp_srq_cq_ird_ord;
-        u32 max_pd_ca_ack_delay;
-        u32 max_write_send_sge;
-        u32 max_ird_ord_per_qp;
-        u32 max_shared_ird_ord;
-        u32 max_mr;
-        u64 max_mr_size;
-        u32 max_num_mr_pbl;
-        u32 max_mw;
-        u32 max_fmr;
-        u32 max_pages_per_frmr;
-        u32 max_mcast_group;
-        u32 max_mcast_qp_attach;
-        u32 max_total_mcast_qp_attach;
-        u32 wqe_rqe_stride_max_dpp_cqs;
-        u32 max_srq_rpir_qps;
-        u32 max_dpp_pds_credits;
-        u32 max_dpp_credits_pds_per_pd;
-        u32 max_wqes_rqes_per_q;
-        u32 max_cq_cqes_per_cq;
-        u32 max_srq_rqe_sge;
-} __packed;
-
-struct ocrdma_fw_ver_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u8 running_ver[32];
-} __packed;
-
-struct ocrdma_fw_conf_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 config_num;
-        u32 asic_revision;
-        u32 phy_port;
-        u32 fn_mode;
-        struct {
-                u32 mode;
-                u32 nic_wqid_base;
-                u32 nic_wq_tot;
-                u32 prot_wqid_base;
-                u32 prot_wq_tot;
-                u32 prot_rqid_base;
-                u32 prot_rqid_tot;
-                u32 rsvd[6];
-        } ulp[2];
-        u32 fn_capabilities;
-        u32 rsvd1;
-        u32 rsvd2;
-        u32 base_eqid;
-        u32 max_eq;
-
-} __packed;
-
-enum {
-        OCRDMA_FN_MODE_RDMA     = 0x4
-};
-
-enum {
-        OCRDMA_CREATE_CQ_VER2                   = 2,
-
-        OCRDMA_CREATE_CQ_PAGE_CNT_MASK          = 0xFFFF,
-        OCRDMA_CREATE_CQ_PAGE_SIZE_SHIFT        = 16,
-        OCRDMA_CREATE_CQ_PAGE_SIZE_MASK         = 0xFF,
-
-        OCRDMA_CREATE_CQ_COALESCWM_SHIFT        = 12,
-        OCRDMA_CREATE_CQ_COALESCWM_MASK         = Bit(13) | Bit(12),
-        OCRDMA_CREATE_CQ_FLAGS_NODELAY          = Bit(14),
-        OCRDMA_CREATE_CQ_FLAGS_AUTO_VALID       = Bit(15),
-
-        OCRDMA_CREATE_CQ_EQ_ID_MASK             = 0xFFFF,
-        OCRDMA_CREATE_CQ_CQE_COUNT_MASK         = 0xFFFF
-};
-
-enum {
-        OCRDMA_CREATE_CQ_VER0                   = 0,
-        OCRDMA_CREATE_CQ_DPP                    = 1,
-        OCRDMA_CREATE_CQ_TYPE_SHIFT             = 24,
-        OCRDMA_CREATE_CQ_EQID_SHIFT             = 22,
-
-        OCRDMA_CREATE_CQ_CNT_SHIFT              = 27,
-        OCRDMA_CREATE_CQ_FLAGS_VALID            = Bit(29),
-        OCRDMA_CREATE_CQ_FLAGS_EVENTABLE        = Bit(31),
-        OCRDMA_CREATE_CQ_DEF_FLAGS              = OCRDMA_CREATE_CQ_FLAGS_VALID |
-                                        OCRDMA_CREATE_CQ_FLAGS_EVENTABLE |
-                                        OCRDMA_CREATE_CQ_FLAGS_NODELAY
-};
-
-struct ocrdma_create_cq_cmd {
-        struct ocrdma_mbx_hdr req;
-        u32 pgsz_pgcnt;
-        u32 ev_cnt_flags;
-        u32 eqn;
-        u32 cqe_count;
-        u32 rsvd6;
-        struct ocrdma_pa pa[OCRDMA_CREATE_CQ_MAX_PAGES];
-};
-
-struct ocrdma_create_cq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_create_cq_cmd cmd;
-} __packed;
-
-enum {
-        OCRDMA_CREATE_CQ_RSP_CQ_ID_MASK = 0xFFFF
-};
-
-struct ocrdma_create_cq_cmd_rsp {
-        struct ocrdma_mbx_rsp rsp;
-        u32 cq_id;
-} __packed;
-
-struct ocrdma_create_cq_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_create_cq_cmd_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_CREATE_MQ_V0_CQ_ID_SHIFT         = 22,
-        OCRDMA_CREATE_MQ_CQ_ID_SHIFT            = 16,
-        OCRDMA_CREATE_MQ_RING_SIZE_SHIFT        = 16,
-        OCRDMA_CREATE_MQ_VALID                  = Bit(31),
-        OCRDMA_CREATE_MQ_ASYNC_CQ_VALID         = Bit(0)
-};
-
-struct ocrdma_create_mq_v0 {
-        u32 pages;
-        u32 cqid_ringsize;
-        u32 valid;
-        u32 async_cqid_valid;
-        u32 rsvd;
-        struct ocrdma_pa pa[8];
-} __packed;
-
-struct ocrdma_create_mq_v1 {
-        u32 cqid_pages;
-        u32 async_event_bitmap;
-        u32 async_cqid_ringsize;
-        u32 valid;
-        u32 async_cqid_valid;
-        u32 rsvd;
-        struct ocrdma_pa pa[8];
-} __packed;
-
-struct ocrdma_create_mq_req {
-        struct ocrdma_mbx_hdr req;
-        union {
-                struct ocrdma_create_mq_v0 v0;
-                struct ocrdma_create_mq_v1 v1;
-        };
-} __packed;
-
-struct ocrdma_create_mq_rsp {
-        struct ocrdma_mbx_rsp rsp;
-        u32 id;
-} __packed;
-
-enum {
-        OCRDMA_DESTROY_CQ_QID_SHIFT                     = 0,
-        OCRDMA_DESTROY_CQ_QID_MASK                      = 0xFFFF,
-        OCRDMA_DESTROY_CQ_QID_BYPASS_FLUSH_SHIFT        = 16,
-        OCRDMA_DESTROY_CQ_QID_BYPASS_FLUSH_MASK         = 0xFFFF <<
-                                OCRDMA_DESTROY_CQ_QID_BYPASS_FLUSH_SHIFT
-};
-
-struct ocrdma_destroy_cq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 bypass_flush_qid;
-} __packed;
-
-struct ocrdma_destroy_cq_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_QPT_GSI  = 1,
-        OCRDMA_QPT_RC   = 2,
-        OCRDMA_QPT_UD   = 4,
-};
-
-enum {
-        OCRDMA_CREATE_QP_REQ_PD_ID_SHIFT        = 0,
-        OCRDMA_CREATE_QP_REQ_PD_ID_MASK         = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_SQ_PAGE_SIZE_SHIFT = 16,
-        OCRDMA_CREATE_QP_REQ_RQ_PAGE_SIZE_SHIFT = 19,
-        OCRDMA_CREATE_QP_REQ_QPT_SHIFT          = 29,
-        OCRDMA_CREATE_QP_REQ_QPT_MASK           = Bit(31) | Bit(30) | Bit(29),
-
-        OCRDMA_CREATE_QP_REQ_MAX_RQE_SHIFT      = 0,
-        OCRDMA_CREATE_QP_REQ_MAX_RQE_MASK       = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_MAX_WQE_SHIFT      = 16,
-        OCRDMA_CREATE_QP_REQ_MAX_WQE_MASK       = 0xFFFF <<
-                                        OCRDMA_CREATE_QP_REQ_MAX_WQE_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_WRITE_SHIFT        = 0,
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_WRITE_MASK         = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_SHIFT         = 16,
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_MASK          = 0xFFFF <<
-                                        OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_FMR_EN_SHIFT               = 0,
-        OCRDMA_CREATE_QP_REQ_FMR_EN_MASK                = Bit(0),
-        OCRDMA_CREATE_QP_REQ_ZERO_LKEYEN_SHIFT          = 1,
-        OCRDMA_CREATE_QP_REQ_ZERO_LKEYEN_MASK           = Bit(1),
-        OCRDMA_CREATE_QP_REQ_BIND_MEMWIN_SHIFT          = 2,
-        OCRDMA_CREATE_QP_REQ_BIND_MEMWIN_MASK           = Bit(2),
-        OCRDMA_CREATE_QP_REQ_INB_WREN_SHIFT             = 3,
-        OCRDMA_CREATE_QP_REQ_INB_WREN_MASK              = Bit(3),
-        OCRDMA_CREATE_QP_REQ_INB_RDEN_SHIFT             = 4,
-        OCRDMA_CREATE_QP_REQ_INB_RDEN_MASK              = Bit(4),
-        OCRDMA_CREATE_QP_REQ_USE_SRQ_SHIFT              = 5,
-        OCRDMA_CREATE_QP_REQ_USE_SRQ_MASK               = Bit(5),
-        OCRDMA_CREATE_QP_REQ_ENABLE_RPIR_SHIFT          = 6,
-        OCRDMA_CREATE_QP_REQ_ENABLE_RPIR_MASK           = Bit(6),
-        OCRDMA_CREATE_QP_REQ_ENABLE_DPP_SHIFT           = 7,
-        OCRDMA_CREATE_QP_REQ_ENABLE_DPP_MASK            = Bit(7),
-        OCRDMA_CREATE_QP_REQ_ENABLE_DPP_CQ_SHIFT        = 8,
-        OCRDMA_CREATE_QP_REQ_ENABLE_DPP_CQ_MASK         = Bit(8),
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_SHIFT         = 16,
-        OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_MASK          = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_MAX_IRD_SHIFT              = 0,
-        OCRDMA_CREATE_QP_REQ_MAX_IRD_MASK               = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_MAX_ORD_SHIFT              = 16,
-        OCRDMA_CREATE_QP_REQ_MAX_ORD_MASK               = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_MAX_ORD_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_NUM_RQ_PAGES_SHIFT         = 0,
-        OCRDMA_CREATE_QP_REQ_NUM_RQ_PAGES_MASK          = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_SHIFT         = 16,
-        OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_MASK          = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_RQE_SIZE_SHIFT             = 0,
-        OCRDMA_CREATE_QP_REQ_RQE_SIZE_MASK              = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_WQE_SIZE_SHIFT             = 16,
-        OCRDMA_CREATE_QP_REQ_WQE_SIZE_MASK              = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_WQE_SIZE_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_RQ_CQID_SHIFT              = 0,
-        OCRDMA_CREATE_QP_REQ_RQ_CQID_MASK               = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_WQ_CQID_SHIFT              = 16,
-        OCRDMA_CREATE_QP_REQ_WQ_CQID_MASK               = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_WQ_CQID_SHIFT,
-
-        OCRDMA_CREATE_QP_REQ_DPP_CQPID_SHIFT            = 0,
-        OCRDMA_CREATE_QP_REQ_DPP_CQPID_MASK             = 0xFFFF,
-        OCRDMA_CREATE_QP_REQ_DPP_CREDIT_SHIFT           = 16,
-        OCRDMA_CREATE_QP_REQ_DPP_CREDIT_MASK            = 0xFFFF <<
-                                OCRDMA_CREATE_QP_REQ_DPP_CREDIT_SHIFT
-};
-
-enum {
-        OCRDMA_CREATE_QP_REQ_DPP_CREDIT_LIMIT   = 16,
-        OCRDMA_CREATE_QP_RSP_DPP_PAGE_SHIFT     = 1
-};
-
-#define MAX_OCRDMA_IRD_PAGES 4
-
-enum ocrdma_qp_flags {
-        OCRDMA_QP_MW_BIND       = 1,
-        OCRDMA_QP_LKEY0         = (1 << 1),
-        OCRDMA_QP_FAST_REG      = (1 << 2),
-        OCRDMA_QP_INB_RD        = (1 << 6),
-        OCRDMA_QP_INB_WR        = (1 << 7),
-};
-
-enum ocrdma_qp_state {
-        OCRDMA_QPS_RST          = 0,
-        OCRDMA_QPS_INIT         = 1,
-        OCRDMA_QPS_RTR          = 2,
-        OCRDMA_QPS_RTS          = 3,
-        OCRDMA_QPS_SQE          = 4,
-        OCRDMA_QPS_SQ_DRAINING  = 5,
-        OCRDMA_QPS_ERR          = 6,
-        OCRDMA_QPS_SQD          = 7
-};
-
-struct ocrdma_create_qp_req {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 type_pgsz_pdn;
-        u32 max_wqe_rqe;
-        u32 max_sge_send_write;
-        u32 max_sge_recv_flags;
-        u32 max_ord_ird;
-        u32 num_wq_rq_pages;
-        u32 wqe_rqe_size;
-        u32 wq_rq_cqid;
-        struct ocrdma_pa wq_addr[MAX_OCRDMA_QP_PAGES];
-        struct ocrdma_pa rq_addr[MAX_OCRDMA_QP_PAGES];
-        u32 dpp_credits_cqid;
-        u32 rpir_lkey;
-        struct ocrdma_pa ird_addr[MAX_OCRDMA_IRD_PAGES];
-} __packed;
-
-enum {
-        OCRDMA_CREATE_QP_RSP_QP_ID_SHIFT                = 0,
-        OCRDMA_CREATE_QP_RSP_QP_ID_MASK                 = 0xFFFF,
-
-        OCRDMA_CREATE_QP_RSP_MAX_RQE_SHIFT              = 0,
-        OCRDMA_CREATE_QP_RSP_MAX_RQE_MASK               = 0xFFFF,
-        OCRDMA_CREATE_QP_RSP_MAX_WQE_SHIFT              = 16,
-        OCRDMA_CREATE_QP_RSP_MAX_WQE_MASK               = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_MAX_WQE_SHIFT,
-
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_WRITE_SHIFT        = 0,
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_WRITE_MASK         = 0xFFFF,
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_SEND_SHIFT         = 16,
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_SEND_MASK          = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_MAX_SGE_SEND_SHIFT,
-
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_RECV_SHIFT         = 16,
-        OCRDMA_CREATE_QP_RSP_MAX_SGE_RECV_MASK          = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_MAX_SGE_RECV_SHIFT,
-
-        OCRDMA_CREATE_QP_RSP_MAX_IRD_SHIFT              = 0,
-        OCRDMA_CREATE_QP_RSP_MAX_IRD_MASK               = 0xFFFF,
-        OCRDMA_CREATE_QP_RSP_MAX_ORD_SHIFT              = 16,
-        OCRDMA_CREATE_QP_RSP_MAX_ORD_MASK               = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_MAX_ORD_SHIFT,
-
-        OCRDMA_CREATE_QP_RSP_RQ_ID_SHIFT                = 0,
-        OCRDMA_CREATE_QP_RSP_RQ_ID_MASK                 = 0xFFFF,
-        OCRDMA_CREATE_QP_RSP_SQ_ID_SHIFT                = 16,
-        OCRDMA_CREATE_QP_RSP_SQ_ID_MASK                 = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_SQ_ID_SHIFT,
-
-        OCRDMA_CREATE_QP_RSP_DPP_ENABLED_MASK           = Bit(0),
-        OCRDMA_CREATE_QP_RSP_DPP_PAGE_OFFSET_SHIFT      = 1,
-        OCRDMA_CREATE_QP_RSP_DPP_PAGE_OFFSET_MASK       = 0x7FFF <<
-                                OCRDMA_CREATE_QP_RSP_DPP_PAGE_OFFSET_SHIFT,
-        OCRDMA_CREATE_QP_RSP_DPP_CREDITS_SHIFT          = 16,
-        OCRDMA_CREATE_QP_RSP_DPP_CREDITS_MASK           = 0xFFFF <<
-                                OCRDMA_CREATE_QP_RSP_DPP_CREDITS_SHIFT,
-};
-
-struct ocrdma_create_qp_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 qp_id;
-        u32 max_wqe_rqe;
-        u32 max_sge_send_write;
-        u32 max_sge_recv;
-        u32 max_ord_ird;
-        u32 sq_rq_id;
-        u32 dpp_response;
-} __packed;
-
-struct ocrdma_destroy_qp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 qp_id;
-} __packed;
-
-struct ocrdma_destroy_qp_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_MODIFY_QP_ID_SHIFT       = 0,
-        OCRDMA_MODIFY_QP_ID_MASK        = 0xFFFF,
-
-        OCRDMA_QP_PARA_QPS_VALID        = Bit(0),
-        OCRDMA_QP_PARA_SQD_ASYNC_VALID  = Bit(1),
-        OCRDMA_QP_PARA_PKEY_VALID       = Bit(2),
-        OCRDMA_QP_PARA_QKEY_VALID       = Bit(3),
-        OCRDMA_QP_PARA_PMTU_VALID       = Bit(4),
-        OCRDMA_QP_PARA_ACK_TO_VALID     = Bit(5),
-        OCRDMA_QP_PARA_RETRY_CNT_VALID  = Bit(6),
-        OCRDMA_QP_PARA_RRC_VALID        = Bit(7),
-        OCRDMA_QP_PARA_RQPSN_VALID      = Bit(8),
-        OCRDMA_QP_PARA_MAX_IRD_VALID    = Bit(9),
-        OCRDMA_QP_PARA_MAX_ORD_VALID    = Bit(10),
-        OCRDMA_QP_PARA_RNT_VALID        = Bit(11),
-        OCRDMA_QP_PARA_SQPSN_VALID      = Bit(12),
-        OCRDMA_QP_PARA_DST_QPN_VALID    = Bit(13),
-        OCRDMA_QP_PARA_MAX_WQE_VALID    = Bit(14),
-        OCRDMA_QP_PARA_MAX_RQE_VALID    = Bit(15),
-        OCRDMA_QP_PARA_SGE_SEND_VALID   = Bit(16),
-        OCRDMA_QP_PARA_SGE_RECV_VALID   = Bit(17),
-        OCRDMA_QP_PARA_SGE_WR_VALID     = Bit(18),
-        OCRDMA_QP_PARA_INB_RDEN_VALID   = Bit(19),
-        OCRDMA_QP_PARA_INB_WREN_VALID   = Bit(20),
-        OCRDMA_QP_PARA_FLOW_LBL_VALID   = Bit(21),
-        OCRDMA_QP_PARA_BIND_EN_VALID    = Bit(22),
-        OCRDMA_QP_PARA_ZLKEY_EN_VALID   = Bit(23),
-        OCRDMA_QP_PARA_FMR_EN_VALID     = Bit(24),
-        OCRDMA_QP_PARA_INBAT_EN_VALID   = Bit(25),
-        OCRDMA_QP_PARA_VLAN_EN_VALID    = Bit(26),
-
-        OCRDMA_MODIFY_QP_FLAGS_RD       = Bit(0),
-        OCRDMA_MODIFY_QP_FLAGS_WR       = Bit(1),
-        OCRDMA_MODIFY_QP_FLAGS_SEND     = Bit(2),
-        OCRDMA_MODIFY_QP_FLAGS_ATOMIC   = Bit(3)
-};
-
-enum {
-        OCRDMA_QP_PARAMS_SRQ_ID_SHIFT           = 0,
-        OCRDMA_QP_PARAMS_SRQ_ID_MASK            = 0xFFFF,
-
-        OCRDMA_QP_PARAMS_MAX_RQE_SHIFT          = 0,
-        OCRDMA_QP_PARAMS_MAX_RQE_MASK           = 0xFFFF,
-        OCRDMA_QP_PARAMS_MAX_WQE_SHIFT          = 16,
-        OCRDMA_QP_PARAMS_MAX_WQE_MASK           = 0xFFFF <<
-            OCRDMA_QP_PARAMS_MAX_WQE_SHIFT,
-
-        OCRDMA_QP_PARAMS_MAX_SGE_WRITE_SHIFT    = 0,
-        OCRDMA_QP_PARAMS_MAX_SGE_WRITE_MASK     = 0xFFFF,
-        OCRDMA_QP_PARAMS_MAX_SGE_SEND_SHIFT     = 16,
-        OCRDMA_QP_PARAMS_MAX_SGE_SEND_MASK      = 0xFFFF <<
-                                        OCRDMA_QP_PARAMS_MAX_SGE_SEND_SHIFT,
-
-        OCRDMA_QP_PARAMS_FLAGS_FMR_EN           = Bit(0),
-        OCRDMA_QP_PARAMS_FLAGS_LKEY_0_EN        = Bit(1),
-        OCRDMA_QP_PARAMS_FLAGS_BIND_MW_EN       = Bit(2),
-        OCRDMA_QP_PARAMS_FLAGS_INBWR_EN         = Bit(3),
-        OCRDMA_QP_PARAMS_FLAGS_INBRD_EN         = Bit(4),
-        OCRDMA_QP_PARAMS_STATE_SHIFT            = 5,
-        OCRDMA_QP_PARAMS_STATE_MASK             = Bit(5) | Bit(6) | Bit(7),
-        OCRDMA_QP_PARAMS_FLAGS_SQD_ASYNC        = Bit(8),
-        OCRDMA_QP_PARAMS_FLAGS_INB_ATEN         = Bit(9),
-        OCRDMA_QP_PARAMS_MAX_SGE_RECV_SHIFT     = 16,
-        OCRDMA_QP_PARAMS_MAX_SGE_RECV_MASK      = 0xFFFF <<
-                                        OCRDMA_QP_PARAMS_MAX_SGE_RECV_SHIFT,
-
-        OCRDMA_QP_PARAMS_MAX_IRD_SHIFT          = 0,
-        OCRDMA_QP_PARAMS_MAX_IRD_MASK           = 0xFFFF,
-        OCRDMA_QP_PARAMS_MAX_ORD_SHIFT          = 16,
-        OCRDMA_QP_PARAMS_MAX_ORD_MASK           = 0xFFFF <<
-                                        OCRDMA_QP_PARAMS_MAX_ORD_SHIFT,
-
-        OCRDMA_QP_PARAMS_RQ_CQID_SHIFT          = 0,
-        OCRDMA_QP_PARAMS_RQ_CQID_MASK           = 0xFFFF,
-        OCRDMA_QP_PARAMS_WQ_CQID_SHIFT          = 16,
-        OCRDMA_QP_PARAMS_WQ_CQID_MASK           = 0xFFFF <<
-                                        OCRDMA_QP_PARAMS_WQ_CQID_SHIFT,
-
-        OCRDMA_QP_PARAMS_RQ_PSN_SHIFT           = 0,
-        OCRDMA_QP_PARAMS_RQ_PSN_MASK            = 0xFFFFFF,
-        OCRDMA_QP_PARAMS_HOP_LMT_SHIFT          = 24,
-        OCRDMA_QP_PARAMS_HOP_LMT_MASK           = 0xFF <<
-                                        OCRDMA_QP_PARAMS_HOP_LMT_SHIFT,
-
-        OCRDMA_QP_PARAMS_SQ_PSN_SHIFT           = 0,
-        OCRDMA_QP_PARAMS_SQ_PSN_MASK            = 0xFFFFFF,
-        OCRDMA_QP_PARAMS_TCLASS_SHIFT           = 24,
-        OCRDMA_QP_PARAMS_TCLASS_MASK            = 0xFF <<
-                                        OCRDMA_QP_PARAMS_TCLASS_SHIFT,
-
-        OCRDMA_QP_PARAMS_DEST_QPN_SHIFT         = 0,
-        OCRDMA_QP_PARAMS_DEST_QPN_MASK          = 0xFFFFFF,
-        OCRDMA_QP_PARAMS_RNR_RETRY_CNT_SHIFT    = 24,
-        OCRDMA_QP_PARAMS_RNR_RETRY_CNT_MASK     = 0x7 <<
-                                        OCRDMA_QP_PARAMS_RNR_RETRY_CNT_SHIFT,
-        OCRDMA_QP_PARAMS_ACK_TIMEOUT_SHIFT      = 27,
-        OCRDMA_QP_PARAMS_ACK_TIMEOUT_MASK       = 0x1F <<
-                                        OCRDMA_QP_PARAMS_ACK_TIMEOUT_SHIFT,
-
-        OCRDMA_QP_PARAMS_PKEY_IDNEX_SHIFT       = 0,
-        OCRDMA_QP_PARAMS_PKEY_INDEX_MASK        = 0xFFFF,
-        OCRDMA_QP_PARAMS_PATH_MTU_SHIFT         = 18,
-        OCRDMA_QP_PARAMS_PATH_MTU_MASK          = 0x3FFF <<
-                                        OCRDMA_QP_PARAMS_PATH_MTU_SHIFT,
-
-        OCRDMA_QP_PARAMS_FLOW_LABEL_SHIFT       = 0,
-        OCRDMA_QP_PARAMS_FLOW_LABEL_MASK        = 0xFFFFF,
-        OCRDMA_QP_PARAMS_SL_SHIFT               = 20,
-        OCRDMA_QP_PARAMS_SL_MASK                = 0xF <<
-                                        OCRDMA_QP_PARAMS_SL_SHIFT,
-        OCRDMA_QP_PARAMS_RETRY_CNT_SHIFT        = 24,
-        OCRDMA_QP_PARAMS_RETRY_CNT_MASK         = 0x7 <<
-                                        OCRDMA_QP_PARAMS_RETRY_CNT_SHIFT,
-        OCRDMA_QP_PARAMS_RNR_NAK_TIMER_SHIFT    = 27,
-        OCRDMA_QP_PARAMS_RNR_NAK_TIMER_MASK     = 0x1F <<
-                                        OCRDMA_QP_PARAMS_RNR_NAK_TIMER_SHIFT,
-
-        OCRDMA_QP_PARAMS_DMAC_B4_TO_B5_SHIFT    = 0,
-        OCRDMA_QP_PARAMS_DMAC_B4_TO_B5_MASK     = 0xFFFF,
-        OCRDMA_QP_PARAMS_VLAN_SHIFT             = 16,
-        OCRDMA_QP_PARAMS_VLAN_MASK              = 0xFFFF <<
-                                        OCRDMA_QP_PARAMS_VLAN_SHIFT
-};
-
-struct ocrdma_qp_params {
-        u32 id;
-        u32 max_wqe_rqe;
-        u32 max_sge_send_write;
-        u32 max_sge_recv_flags;
-        u32 max_ord_ird;
-        u32 wq_rq_cqid;
-        u32 hop_lmt_rq_psn;
-        u32 tclass_sq_psn;
-        u32 ack_to_rnr_rtc_dest_qpn;
-        u32 path_mtu_pkey_indx;
-        u32 rnt_rc_sl_fl;
-        u8 sgid[16];
-        u8 dgid[16];
-        u32 dmac_b0_to_b3;
-        u32 vlan_dmac_b4_to_b5;
-        u32 qkey;
-} __packed;
-
-
-struct ocrdma_modify_qp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        struct ocrdma_qp_params params;
-        u32 flags;
-        u32 rdma_flags;
-        u32 num_outstanding_atomic_rd;
-} __packed;
-
-enum {
-        OCRDMA_MODIFY_QP_RSP_MAX_RQE_SHIFT      = 0,
-        OCRDMA_MODIFY_QP_RSP_MAX_RQE_MASK       = 0xFFFF,
-        OCRDMA_MODIFY_QP_RSP_MAX_WQE_SHIFT      = 16,
-        OCRDMA_MODIFY_QP_RSP_MAX_WQE_MASK       = 0xFFFF <<
-                                        OCRDMA_MODIFY_QP_RSP_MAX_WQE_SHIFT,
-
-        OCRDMA_MODIFY_QP_RSP_MAX_IRD_SHIFT      = 0,
-        OCRDMA_MODIFY_QP_RSP_MAX_IRD_MASK       = 0xFFFF,
-        OCRDMA_MODIFY_QP_RSP_MAX_ORD_SHIFT      = 16,
-        OCRDMA_MODIFY_QP_RSP_MAX_ORD_MASK       = 0xFFFF <<
-                                        OCRDMA_MODIFY_QP_RSP_MAX_ORD_SHIFT
-};
-struct ocrdma_modify_qp_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 max_wqe_rqe;
-        u32 max_ord_ird;
-} __packed;
-
-struct ocrdma_query_qp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-#define OCRDMA_QUERY_UP_QP_ID_SHIFT 0
-#define OCRDMA_QUERY_UP_QP_ID_MASK   0xFFFFFF
-        u32 qp_id;
-} __packed;
-
-struct ocrdma_query_qp_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-        struct ocrdma_qp_params params;
-} __packed;
-
-enum {
-        OCRDMA_CREATE_SRQ_PD_ID_SHIFT           = 0,
-        OCRDMA_CREATE_SRQ_PD_ID_MASK            = 0xFFFF,
-        OCRDMA_CREATE_SRQ_PG_SZ_SHIFT           = 16,
-        OCRDMA_CREATE_SRQ_PG_SZ_MASK            = 0x3 <<
-                                        OCRDMA_CREATE_SRQ_PG_SZ_SHIFT,
-
-        OCRDMA_CREATE_SRQ_MAX_RQE_SHIFT         = 0,
-        OCRDMA_CREATE_SRQ_MAX_SGE_RECV_SHIFT    = 16,
-        OCRDMA_CREATE_SRQ_MAX_SGE_RECV_MASK     = 0xFFFF <<
-                                        OCRDMA_CREATE_SRQ_MAX_SGE_RECV_SHIFT,
-
-        OCRDMA_CREATE_SRQ_RQE_SIZE_SHIFT        = 0,
-        OCRDMA_CREATE_SRQ_RQE_SIZE_MASK         = 0xFFFF,
-        OCRDMA_CREATE_SRQ_NUM_RQ_PAGES_SHIFT    = 16,
-        OCRDMA_CREATE_SRQ_NUM_RQ_PAGES_MASK     = 0xFFFF <<
-                                        OCRDMA_CREATE_SRQ_NUM_RQ_PAGES_SHIFT
-};
-
-struct ocrdma_create_srq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 pgsz_pdid;
-        u32 max_sge_rqe;
-        u32 pages_rqe_sz;
-        struct ocrdma_pa rq_addr[MAX_OCRDMA_SRQ_PAGES];
-} __packed;
-
-enum {
-        OCRDMA_CREATE_SRQ_RSP_SRQ_ID_SHIFT                      = 0,
-        OCRDMA_CREATE_SRQ_RSP_SRQ_ID_MASK                       = 0xFFFFFF,
-
-        OCRDMA_CREATE_SRQ_RSP_MAX_RQE_ALLOCATED_SHIFT           = 0,
-        OCRDMA_CREATE_SRQ_RSP_MAX_RQE_ALLOCATED_MASK            = 0xFFFF,
-        OCRDMA_CREATE_SRQ_RSP_MAX_SGE_RECV_ALLOCATED_SHIFT      = 16,
-        OCRDMA_CREATE_SRQ_RSP_MAX_SGE_RECV_ALLOCATED_MASK       = 0xFFFF <<
-                        OCRDMA_CREATE_SRQ_RSP_MAX_SGE_RECV_ALLOCATED_SHIFT
-};
-
-struct ocrdma_create_srq_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 id;
-        u32 max_sge_rqe_allocated;
-} __packed;
-
-enum {
-        OCRDMA_MODIFY_SRQ_ID_SHIFT      = 0,
-        OCRDMA_MODIFY_SRQ_ID_MASK       = 0xFFFFFF,
-
-        OCRDMA_MODIFY_SRQ_MAX_RQE_SHIFT = 0,
-        OCRDMA_MODIFY_SRQ_MAX_RQE_MASK  = 0xFFFF,
-        OCRDMA_MODIFY_SRQ_LIMIT_SHIFT   = 16,
-        OCRDMA_MODIFY_SRQ__LIMIT_MASK   = 0xFFFF <<
-                                        OCRDMA_MODIFY_SRQ_LIMIT_SHIFT
-};
-
-struct ocrdma_modify_srq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rep;
-
-        u32 id;
-        u32 limit_max_rqe;
-} __packed;
-
-enum {
-        OCRDMA_QUERY_SRQ_ID_SHIFT       = 0,
-        OCRDMA_QUERY_SRQ_ID_MASK        = 0xFFFFFF
-};
-
-struct ocrdma_query_srq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp req;
-
-        u32 id;
-} __packed;
-
-enum {
-        OCRDMA_QUERY_SRQ_RSP_PD_ID_SHIFT        = 0,
-        OCRDMA_QUERY_SRQ_RSP_PD_ID_MASK         = 0xFFFF,
-        OCRDMA_QUERY_SRQ_RSP_MAX_RQE_SHIFT      = 16,
-        OCRDMA_QUERY_SRQ_RSP_MAX_RQE_MASK       = 0xFFFF <<
-                                        OCRDMA_QUERY_SRQ_RSP_MAX_RQE_SHIFT,
-
-        OCRDMA_QUERY_SRQ_RSP_MAX_SGE_RECV_SHIFT = 0,
-        OCRDMA_QUERY_SRQ_RSP_MAX_SGE_RECV_MASK  = 0xFFFF,
-        OCRDMA_QUERY_SRQ_RSP_SRQ_LIMIT_SHIFT    = 16,
-        OCRDMA_QUERY_SRQ_RSP_SRQ_LIMIT_MASK     = 0xFFFF <<
-                                        OCRDMA_QUERY_SRQ_RSP_SRQ_LIMIT_SHIFT
-};
-
-struct ocrdma_query_srq_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp req;
-
-        u32 max_rqe_pdid;
-        u32 srq_lmt_max_sge;
-} __packed;
-
-enum {
-        OCRDMA_DESTROY_SRQ_ID_SHIFT     = 0,
-        OCRDMA_DESTROY_SRQ_ID_MASK      = 0xFFFFFF
-};
-
-struct ocrdma_destroy_srq {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp req;
-
-        u32 id;
-} __packed;
-
-enum {
-        OCRDMA_ALLOC_PD_ENABLE_DPP      = BIT(16),
-        OCRDMA_PD_MAX_DPP_ENABLED_QP    = 8,
-        OCRDMA_DPP_PAGE_SIZE            = 4096
-};
-
-struct ocrdma_alloc_pd {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 enable_dpp_rsvd;
-} __packed;
-
-enum {
-        OCRDMA_ALLOC_PD_RSP_DPP                 = Bit(16),
-        OCRDMA_ALLOC_PD_RSP_DPP_PAGE_SHIFT      = 20,
-        OCRDMA_ALLOC_PD_RSP_PDID_MASK           = 0xFFFF,
-};
-
-struct ocrdma_alloc_pd_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-        u32 dpp_page_pdid;
-} __packed;
-
-struct ocrdma_dealloc_pd {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 id;
-} __packed;
-
-struct ocrdma_dealloc_pd_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_ADDR_CHECK_ENABLE        = 1,
-        OCRDMA_ADDR_CHECK_DISABLE       = 0
-};
-
-enum {
-        OCRDMA_ALLOC_LKEY_PD_ID_SHIFT           = 0,
-        OCRDMA_ALLOC_LKEY_PD_ID_MASK            = 0xFFFF,
-
-        OCRDMA_ALLOC_LKEY_ADDR_CHECK_SHIFT      = 0,
-        OCRDMA_ALLOC_LKEY_ADDR_CHECK_MASK       = Bit(0),
-        OCRDMA_ALLOC_LKEY_FMR_SHIFT             = 1,
-        OCRDMA_ALLOC_LKEY_FMR_MASK              = Bit(1),
-        OCRDMA_ALLOC_LKEY_REMOTE_INV_SHIFT      = 2,
-        OCRDMA_ALLOC_LKEY_REMOTE_INV_MASK       = Bit(2),
-        OCRDMA_ALLOC_LKEY_REMOTE_WR_SHIFT       = 3,
-        OCRDMA_ALLOC_LKEY_REMOTE_WR_MASK        = Bit(3),
-        OCRDMA_ALLOC_LKEY_REMOTE_RD_SHIFT       = 4,
-        OCRDMA_ALLOC_LKEY_REMOTE_RD_MASK        = Bit(4),
-        OCRDMA_ALLOC_LKEY_LOCAL_WR_SHIFT        = 5,
-        OCRDMA_ALLOC_LKEY_LOCAL_WR_MASK         = Bit(5),
-        OCRDMA_ALLOC_LKEY_REMOTE_ATOMIC_MASK    = Bit(6),
-        OCRDMA_ALLOC_LKEY_REMOTE_ATOMIC_SHIFT   = 6,
-        OCRDMA_ALLOC_LKEY_PBL_SIZE_SHIFT        = 16,
-        OCRDMA_ALLOC_LKEY_PBL_SIZE_MASK         = 0xFFFF <<
-                                                OCRDMA_ALLOC_LKEY_PBL_SIZE_SHIFT
-};
-
-struct ocrdma_alloc_lkey {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 pdid;
-        u32 pbl_sz_flags;
-} __packed;
-
-struct ocrdma_alloc_lkey_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 lrkey;
-        u32 num_pbl_rsvd;
-} __packed;
-
-struct ocrdma_dealloc_lkey {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 lkey;
-        u32 rsvd_frmr;
-} __packed;
-
-struct ocrdma_dealloc_lkey_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-#define MAX_OCRDMA_NSMR_PBL    (u32)22
-#define MAX_OCRDMA_PBL_SIZE     65536
-#define MAX_OCRDMA_PBL_PER_LKEY 32767
-
-enum {
-        OCRDMA_REG_NSMR_LRKEY_INDEX_SHIFT       = 0,
-        OCRDMA_REG_NSMR_LRKEY_INDEX_MASK        = 0xFFFFFF,
-        OCRDMA_REG_NSMR_LRKEY_SHIFT             = 24,
-        OCRDMA_REG_NSMR_LRKEY_MASK              = 0xFF <<
-                                        OCRDMA_REG_NSMR_LRKEY_SHIFT,
-
-        OCRDMA_REG_NSMR_PD_ID_SHIFT             = 0,
-        OCRDMA_REG_NSMR_PD_ID_MASK              = 0xFFFF,
-        OCRDMA_REG_NSMR_NUM_PBL_SHIFT           = 16,
-        OCRDMA_REG_NSMR_NUM_PBL_MASK            = 0xFFFF <<
-                                        OCRDMA_REG_NSMR_NUM_PBL_SHIFT,
-
-        OCRDMA_REG_NSMR_PBE_SIZE_SHIFT          = 0,
-        OCRDMA_REG_NSMR_PBE_SIZE_MASK           = 0xFFFF,
-        OCRDMA_REG_NSMR_HPAGE_SIZE_SHIFT        = 16,
-        OCRDMA_REG_NSMR_HPAGE_SIZE_MASK         = 0xFF <<
-                                        OCRDMA_REG_NSMR_HPAGE_SIZE_SHIFT,
-        OCRDMA_REG_NSMR_BIND_MEMWIN_SHIFT       = 24,
-        OCRDMA_REG_NSMR_BIND_MEMWIN_MASK        = Bit(24),
-        OCRDMA_REG_NSMR_ZB_SHIFT                = 25,
-        OCRDMA_REG_NSMR_ZB_SHIFT_MASK           = Bit(25),
-        OCRDMA_REG_NSMR_REMOTE_INV_SHIFT        = 26,
-        OCRDMA_REG_NSMR_REMOTE_INV_MASK         = Bit(26),
-        OCRDMA_REG_NSMR_REMOTE_WR_SHIFT         = 27,
-        OCRDMA_REG_NSMR_REMOTE_WR_MASK          = Bit(27),
-        OCRDMA_REG_NSMR_REMOTE_RD_SHIFT         = 28,
-        OCRDMA_REG_NSMR_REMOTE_RD_MASK          = Bit(28),
-        OCRDMA_REG_NSMR_LOCAL_WR_SHIFT          = 29,
-        OCRDMA_REG_NSMR_LOCAL_WR_MASK           = Bit(29),
-        OCRDMA_REG_NSMR_REMOTE_ATOMIC_SHIFT     = 30,
-        OCRDMA_REG_NSMR_REMOTE_ATOMIC_MASK      = Bit(30),
-        OCRDMA_REG_NSMR_LAST_SHIFT              = 31,
-        OCRDMA_REG_NSMR_LAST_MASK               = Bit(31)
-};
-
-struct ocrdma_reg_nsmr {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr cmd;
-
-        u32 lrkey_key_index;
-        u32 num_pbl_pdid;
-        u32 flags_hpage_pbe_sz;
-        u32 totlen_low;
-        u32 totlen_high;
-        u32 fbo_low;
-        u32 fbo_high;
-        u32 va_loaddr;
-        u32 va_hiaddr;
-        struct ocrdma_pa pbl[MAX_OCRDMA_NSMR_PBL];
-} __packed;
-
-enum {
-        OCRDMA_REG_NSMR_CONT_PBL_SHIFT          = 0,
-        OCRDMA_REG_NSMR_CONT_PBL_SHIFT_MASK     = 0xFFFF,
-        OCRDMA_REG_NSMR_CONT_NUM_PBL_SHIFT      = 16,
-        OCRDMA_REG_NSMR_CONT_NUM_PBL_MASK       = 0xFFFF <<
-                                        OCRDMA_REG_NSMR_CONT_NUM_PBL_SHIFT,
-
-        OCRDMA_REG_NSMR_CONT_LAST_SHIFT         = 31,
-        OCRDMA_REG_NSMR_CONT_LAST_MASK          = Bit(31)
-};
-
-struct ocrdma_reg_nsmr_cont {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr cmd;
-
-        u32 lrkey;
-        u32 num_pbl_offset;
-        u32 last;
-
-        struct ocrdma_pa pbl[MAX_OCRDMA_NSMR_PBL];
-} __packed;
-
-struct ocrdma_pbe {
-        u32 pa_hi;
-        u32 pa_lo;
-} __packed;
-
-enum {
-        OCRDMA_REG_NSMR_RSP_NUM_PBL_SHIFT       = 16,
-        OCRDMA_REG_NSMR_RSP_NUM_PBL_MASK        = 0xFFFF0000
-};
-struct ocrdma_reg_nsmr_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 lrkey;
-        u32 num_pbl;
-} __packed;
-
-enum {
-        OCRDMA_REG_NSMR_CONT_RSP_LRKEY_INDEX_SHIFT      = 0,
-        OCRDMA_REG_NSMR_CONT_RSP_LRKEY_INDEX_MASK       = 0xFFFFFF,
-        OCRDMA_REG_NSMR_CONT_RSP_LRKEY_SHIFT            = 24,
-        OCRDMA_REG_NSMR_CONT_RSP_LRKEY_MASK             = 0xFF <<
-                                        OCRDMA_REG_NSMR_CONT_RSP_LRKEY_SHIFT,
-
-        OCRDMA_REG_NSMR_CONT_RSP_NUM_PBL_SHIFT          = 16,
-        OCRDMA_REG_NSMR_CONT_RSP_NUM_PBL_MASK           = 0xFFFF <<
-                                        OCRDMA_REG_NSMR_CONT_RSP_NUM_PBL_SHIFT
-};
-
-struct ocrdma_reg_nsmr_cont_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 lrkey_key_index;
-        u32 num_pbl;
-} __packed;
-
-enum {
-        OCRDMA_ALLOC_MW_PD_ID_SHIFT     = 0,
-        OCRDMA_ALLOC_MW_PD_ID_MASK      = 0xFFFF
-};
-
-struct ocrdma_alloc_mw {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 pdid;
-} __packed;
-
-enum {
-        OCRDMA_ALLOC_MW_RSP_LRKEY_INDEX_SHIFT   = 0,
-        OCRDMA_ALLOC_MW_RSP_LRKEY_INDEX_MASK    = 0xFFFFFF
-};
-
-struct ocrdma_alloc_mw_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-
-        u32 lrkey_index;
-} __packed;
-
-struct ocrdma_attach_mcast {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 qp_id;
-        u8 mgid[16];
-        u32 mac_b0_to_b3;
-        u32 vlan_mac_b4_to_b5;
-} __packed;
-
-struct ocrdma_attach_mcast_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-struct ocrdma_detach_mcast {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 qp_id;
-        u8 mgid[16];
-        u32 mac_b0_to_b3;
-        u32 vlan_mac_b4_to_b5;
-} __packed;
-
-struct ocrdma_detach_mcast_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_CREATE_AH_NUM_PAGES_SHIFT        = 19,
-        OCRDMA_CREATE_AH_NUM_PAGES_MASK         = 0xF <<
-                                        OCRDMA_CREATE_AH_NUM_PAGES_SHIFT,
-
-        OCRDMA_CREATE_AH_PAGE_SIZE_SHIFT        = 16,
-        OCRDMA_CREATE_AH_PAGE_SIZE_MASK         = 0x7 <<
-                                        OCRDMA_CREATE_AH_PAGE_SIZE_SHIFT,
-
-        OCRDMA_CREATE_AH_ENTRY_SIZE_SHIFT       = 23,
-        OCRDMA_CREATE_AH_ENTRY_SIZE_MASK        = 0x1FF <<
-                                        OCRDMA_CREATE_AH_ENTRY_SIZE_SHIFT,
-};
-
-#define OCRDMA_AH_TBL_PAGES 8
-
-struct ocrdma_create_ah_tbl {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-
-        u32 ah_conf;
-        struct ocrdma_pa tbl_addr[8];
-} __packed;
-
-struct ocrdma_create_ah_tbl_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-        u32 ahid;
-} __packed;
-
-struct ocrdma_delete_ah_tbl {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_hdr req;
-        u32 ahid;
-} __packed;
-
-struct ocrdma_delete_ah_tbl_rsp {
-        struct ocrdma_mqe_hdr hdr;
-        struct ocrdma_mbx_rsp rsp;
-} __packed;
-
-enum {
-        OCRDMA_EQE_VALID_SHIFT          = 0,
-        OCRDMA_EQE_VALID_MASK           = Bit(0),
-        OCRDMA_EQE_FOR_CQE_MASK         = 0xFFFE,
-        OCRDMA_EQE_RESOURCE_ID_SHIFT    = 16,
-        OCRDMA_EQE_RESOURCE_ID_MASK     = 0xFFFF <<
-                                OCRDMA_EQE_RESOURCE_ID_SHIFT,
-};
-
-struct ocrdma_eqe {
-        u32 id_valid;
-} __packed;
-
-enum OCRDMA_CQE_STATUS {
-        OCRDMA_CQE_SUCCESS = 0,
-        OCRDMA_CQE_LOC_LEN_ERR,
-        OCRDMA_CQE_LOC_QP_OP_ERR,
-        OCRDMA_CQE_LOC_EEC_OP_ERR,
-        OCRDMA_CQE_LOC_PROT_ERR,
-        OCRDMA_CQE_WR_FLUSH_ERR,
-        OCRDMA_CQE_MW_BIND_ERR,
-        OCRDMA_CQE_BAD_RESP_ERR,
-        OCRDMA_CQE_LOC_ACCESS_ERR,
-        OCRDMA_CQE_REM_INV_REQ_ERR,
-        OCRDMA_CQE_REM_ACCESS_ERR,
-        OCRDMA_CQE_REM_OP_ERR,
-        OCRDMA_CQE_RETRY_EXC_ERR,
-        OCRDMA_CQE_RNR_RETRY_EXC_ERR,
-        OCRDMA_CQE_LOC_RDD_VIOL_ERR,
-        OCRDMA_CQE_REM_INV_RD_REQ_ERR,
-        OCRDMA_CQE_REM_ABORT_ERR,
-        OCRDMA_CQE_INV_EECN_ERR,
-        OCRDMA_CQE_INV_EEC_STATE_ERR,
-        OCRDMA_CQE_FATAL_ERR,
-        OCRDMA_CQE_RESP_TIMEOUT_ERR,
-        OCRDMA_CQE_GENERAL_ERR
-};
-
-enum {
-        /* w0 */
-        OCRDMA_CQE_WQEIDX_SHIFT         = 0,
-        OCRDMA_CQE_WQEIDX_MASK          = 0xFFFF,
-
-        /* w1 */
-        OCRDMA_CQE_UD_XFER_LEN_SHIFT    = 16,
-        OCRDMA_CQE_PKEY_SHIFT           = 0,
-        OCRDMA_CQE_PKEY_MASK            = 0xFFFF,
-
-        /* w2 */
-        OCRDMA_CQE_QPN_SHIFT            = 0,
-        OCRDMA_CQE_QPN_MASK             = 0x0000FFFF,
-
-        OCRDMA_CQE_BUFTAG_SHIFT         = 16,
-        OCRDMA_CQE_BUFTAG_MASK          = 0xFFFF << OCRDMA_CQE_BUFTAG_SHIFT,
-
-        /* w3 */
-        OCRDMA_CQE_UD_STATUS_SHIFT      = 24,
-        OCRDMA_CQE_UD_STATUS_MASK       = 0x7 << OCRDMA_CQE_UD_STATUS_SHIFT,
-        OCRDMA_CQE_STATUS_SHIFT         = 16,
-        OCRDMA_CQE_STATUS_MASK          = 0xFF << OCRDMA_CQE_STATUS_SHIFT,
-        OCRDMA_CQE_VALID                = Bit(31),
-        OCRDMA_CQE_INVALIDATE           = Bit(30),
-        OCRDMA_CQE_QTYPE                = Bit(29),
-        OCRDMA_CQE_IMM                  = Bit(28),
-        OCRDMA_CQE_WRITE_IMM            = Bit(27),
-        OCRDMA_CQE_QTYPE_SQ             = 0,
-        OCRDMA_CQE_QTYPE_RQ             = 1,
-        OCRDMA_CQE_SRCQP_MASK           = 0xFFFFFF
-};
-
-struct ocrdma_cqe {
-        union {
-                /* w0 to w2 */
-                struct {
-                        u32 wqeidx;
-                        u32 bytes_xfered;
-                        u32 qpn;
-                } wq;
-                struct {
-                        u32 lkey_immdt;
-                        u32 rxlen;
-                        u32 buftag_qpn;
-                } rq;
-                struct {
-                        u32 lkey_immdt;
-                        u32 rxlen_pkey;
-                        u32 buftag_qpn;
-                } ud;
-                struct {
-                        u32 word_0;
-                        u32 word_1;
-                        u32 qpn;
-                } cmn;
-        };
-        u32 flags_status_srcqpn;        /* w3 */
-} __packed;
-
-#define is_cqe_valid(cq, cqe) \
-        (((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_VALID)\
-        == cq->phase) ? 1 : 0)
-#define is_cqe_for_sq(cqe) \
-        ((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_QTYPE) ? 0 : 1)
-#define is_cqe_for_rq(cqe) \
-        ((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_QTYPE) ? 1 : 0)
-#define is_cqe_invalidated(cqe) \
-        ((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_INVALIDATE) ? \
-        1 : 0)
-#define is_cqe_imm(cqe) \
-        ((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_IMM) ? 1 : 0)
-#define is_cqe_wr_imm(cqe) \
-        ((le32_to_cpu(cqe->flags_status_srcqpn) & OCRDMA_CQE_WRITE_IMM) ? 1 : 0)
-
-struct ocrdma_sge {
-        u32 addr_hi;
-        u32 addr_lo;
-        u32 lrkey;
-        u32 len;
-} __packed;
-
-enum {
-        OCRDMA_FLAG_SIG         = 0x1,
-        OCRDMA_FLAG_INV         = 0x2,
-        OCRDMA_FLAG_FENCE_L     = 0x4,
-        OCRDMA_FLAG_FENCE_R     = 0x8,
-        OCRDMA_FLAG_SOLICIT     = 0x10,
-        OCRDMA_FLAG_IMM         = 0x20,
-
-        /* Stag flags */
-        OCRDMA_LKEY_FLAG_LOCAL_WR       = 0x1,
-        OCRDMA_LKEY_FLAG_REMOTE_RD      = 0x2,
-        OCRDMA_LKEY_FLAG_REMOTE_WR      = 0x4,
-        OCRDMA_LKEY_FLAG_VATO           = 0x8,
-};
-
-enum OCRDMA_WQE_OPCODE {
-        OCRDMA_WRITE            = 0x06,
-        OCRDMA_READ             = 0x0C,
-        OCRDMA_RESV0            = 0x02,
-        OCRDMA_SEND             = 0x00,
-        OCRDMA_CMP_SWP          = 0x14,
-        OCRDMA_BIND_MW          = 0x10,
-        OCRDMA_RESV1            = 0x0A,
-        OCRDMA_LKEY_INV         = 0x15,
-        OCRDMA_FETCH_ADD        = 0x13,
-        OCRDMA_POST_RQ          = 0x12
-};
-
-enum {
-        OCRDMA_TYPE_INLINE      = 0x0,
-        OCRDMA_TYPE_LKEY        = 0x1,
-};
-
-enum {
-        OCRDMA_WQE_OPCODE_SHIFT         = 0,
-        OCRDMA_WQE_OPCODE_MASK          = 0x0000001F,
-        OCRDMA_WQE_FLAGS_SHIFT          = 5,
-        OCRDMA_WQE_TYPE_SHIFT           = 16,
-        OCRDMA_WQE_TYPE_MASK            = 0x00030000,
-        OCRDMA_WQE_SIZE_SHIFT           = 18,
-        OCRDMA_WQE_SIZE_MASK            = 0xFF,
-        OCRDMA_WQE_NXT_WQE_SIZE_SHIFT   = 25,
-
-        OCRDMA_WQE_LKEY_FLAGS_SHIFT     = 0,
-        OCRDMA_WQE_LKEY_FLAGS_MASK      = 0xF
-};
-
-/* header WQE for all the SQ and RQ operations */
-struct ocrdma_hdr_wqe {
-        u32 cw;
-        union {
-                u32 rsvd_tag;
-                u32 rsvd_lkey_flags;
-        };
-        union {
-                u32 immdt;
-                u32 lkey;
-        };
-        u32 total_len;
-} __packed;
-
-struct ocrdma_ewqe_ud_hdr {
-        u32 rsvd_dest_qpn;
-        u32 qkey;
-        u32 rsvd_ahid;
-        u32 rsvd;
-} __packed;
-
-struct ocrdma_eth_basic {
-        u8 dmac[6];
-        u8 smac[6];
-        __be16 eth_type;
-} __packed;
-
-struct ocrdma_eth_vlan {
-        u8 dmac[6];
-        u8 smac[6];
-        __be16 eth_type;
-        __be16 vlan_tag;
-#define OCRDMA_ROCE_ETH_TYPE 0x8915
-        __be16 roce_eth_type;
-} __packed;
-
-struct ocrdma_grh {
-        __be32  tclass_flow;
-        __be32  pdid_hoplimit;
-        u8      sgid[16];
-        u8      dgid[16];
-        u16     rsvd;
-} __packed;
-
-#define OCRDMA_AV_VALID         Bit(0)
-#define OCRDMA_AV_VLAN_VALID    Bit(1)
-
-struct ocrdma_av {
-        struct ocrdma_eth_vlan eth_hdr;
-        struct ocrdma_grh grh;
-        u32 valid;
-} __packed;
-
-#endif                          /* __OCRDMA_SLI_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
deleted file mode 100644
index b29a4246ef4..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+++ /dev/null
@@ -1,2536 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#include <linux/dma-mapping.h>
-#include <rdma/ib_verbs.h>
-#include <rdma/ib_user_verbs.h>
-#include <rdma/iw_cm.h>
-#include <rdma/ib_umem.h>
-#include <rdma/ib_addr.h>
-
-#include "ocrdma.h"
-#include "ocrdma_hw.h"
-#include "ocrdma_verbs.h"
-#include "ocrdma_abi.h"
-
-int ocrdma_query_pkey(struct ib_device *ibdev, u8 port, u16 index, u16 *pkey)
-{
-        if (index > 1)
-                return -EINVAL;
-
-        *pkey = 0xffff;
-        return 0;
-}
-
-int ocrdma_query_gid(struct ib_device *ibdev, u8 port,
-                     int index, union ib_gid *sgid)
-{
-        struct ocrdma_dev *dev;
-
-        dev = get_ocrdma_dev(ibdev);
-        memset(sgid, 0, sizeof(*sgid));
-        if (index >= OCRDMA_MAX_SGID)
-                return -EINVAL;
-
-        memcpy(sgid, &dev->sgid_tbl[index], sizeof(*sgid));
-
-        return 0;
-}
-
-int ocrdma_query_device(struct ib_device *ibdev, struct ib_device_attr *attr)
-{
-        struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
-
-        memset(attr, 0, sizeof *attr);
-        memcpy(&attr->fw_ver, &dev->attr.fw_ver[0],
-               min(sizeof(dev->attr.fw_ver), sizeof(attr->fw_ver)));
-        ocrdma_get_guid(dev, (u8 *)&attr->sys_image_guid);
-        attr->max_mr_size = ~0ull;
-        attr->page_size_cap = 0xffff000;
-        attr->vendor_id = dev->nic_info.pdev->vendor;
-        attr->vendor_part_id = dev->nic_info.pdev->device;
-        attr->hw_ver = 0;
-        attr->max_qp = dev->attr.max_qp;
-        attr->max_ah = dev->attr.max_qp;
-        attr->max_qp_wr = dev->attr.max_wqe;
-
-        attr->device_cap_flags = IB_DEVICE_CURR_QP_STATE_MOD |
-                                        IB_DEVICE_RC_RNR_NAK_GEN |
-                                        IB_DEVICE_SHUTDOWN_PORT |
-                                        IB_DEVICE_SYS_IMAGE_GUID |
-                                        IB_DEVICE_LOCAL_DMA_LKEY;
-        attr->max_sge = min(dev->attr.max_send_sge, dev->attr.max_srq_sge);
-        attr->max_sge_rd = 0;
-        attr->max_cq = dev->attr.max_cq;
-        attr->max_cqe = dev->attr.max_cqe;
-        attr->max_mr = dev->attr.max_mr;
-        attr->max_mw = 0;
-        attr->max_pd = dev->attr.max_pd;
-        attr->atomic_cap = 0;
-        attr->max_fmr = 0;
-        attr->max_map_per_fmr = 0;
-        attr->max_qp_rd_atom =
-            min(dev->attr.max_ord_per_qp, dev->attr.max_ird_per_qp);
-        attr->max_qp_init_rd_atom = dev->attr.max_ord_per_qp;
-        attr->max_srq = (dev->attr.max_qp - 1);
-        attr->max_srq_sge = dev->attr.max_srq_sge;
-        attr->max_srq_wr = dev->attr.max_rqe;
-        attr->local_ca_ack_delay = dev->attr.local_ca_ack_delay;
-        attr->max_fast_reg_page_list_len = 0;
-        attr->max_pkeys = 1;
-        return 0;
-}
-
-int ocrdma_query_port(struct ib_device *ibdev,
-                      u8 port, struct ib_port_attr *props)
-{
-        enum ib_port_state port_state;
-        struct ocrdma_dev *dev;
-        struct net_device *netdev;
-
-        dev = get_ocrdma_dev(ibdev);
-        if (port > 1) {
-                ocrdma_err("%s(%d) invalid_port=0x%x\n", __func__,
-                           dev->id, port);
-                return -EINVAL;
-        }
-        netdev = dev->nic_info.netdev;
-        if (netif_running(netdev) && netif_oper_up(netdev)) {
-                port_state = IB_PORT_ACTIVE;
-                props->phys_state = 5;
-        } else {
-                port_state = IB_PORT_DOWN;
-                props->phys_state = 3;
-        }
-        props->max_mtu = IB_MTU_4096;
-        props->active_mtu = iboe_get_mtu(netdev->mtu);
-        props->lid = 0;
-        props->lmc = 0;
-        props->sm_lid = 0;
-        props->sm_sl = 0;
-        props->state = port_state;
-        props->port_cap_flags =
-            IB_PORT_CM_SUP |
-            IB_PORT_REINIT_SUP |
-            IB_PORT_DEVICE_MGMT_SUP | IB_PORT_VENDOR_CLASS_SUP;
-        props->gid_tbl_len = OCRDMA_MAX_SGID;
-        props->pkey_tbl_len = 1;
-        props->bad_pkey_cntr = 0;
-        props->qkey_viol_cntr = 0;
-        props->active_width = IB_WIDTH_1X;
-        props->active_speed = 4;
-        props->max_msg_sz = 0x80000000;
-        props->max_vl_num = 4;
-        return 0;
-}
-
-int ocrdma_modify_port(struct ib_device *ibdev, u8 port, int mask,
-                       struct ib_port_modify *props)
-{
-        struct ocrdma_dev *dev;
-
-        dev = get_ocrdma_dev(ibdev);
-        if (port > 1) {
-                ocrdma_err("%s(%d) invalid_port=0x%x\n", __func__,
-                           dev->id, port);
-                return -EINVAL;
-        }
-        return 0;
-}
-
-static int ocrdma_add_mmap(struct ocrdma_ucontext *uctx, u64 phy_addr,
-                           unsigned long len)
-{
-        struct ocrdma_mm *mm;
-
-        mm = kzalloc(sizeof(*mm), GFP_KERNEL);
-        if (mm == NULL)
-                return -ENOMEM;
-        mm->key.phy_addr = phy_addr;
-        mm->key.len = len;
-        INIT_LIST_HEAD(&mm->entry);
-
-        mutex_lock(&uctx->mm_list_lock);
-        list_add_tail(&mm->entry, &uctx->mm_head);
-        mutex_unlock(&uctx->mm_list_lock);
-        return 0;
-}
-
-static void ocrdma_del_mmap(struct ocrdma_ucontext *uctx, u64 phy_addr,
-                            unsigned long len)
-{
-        struct ocrdma_mm *mm, *tmp;
-
-        mutex_lock(&uctx->mm_list_lock);
-        list_for_each_entry_safe(mm, tmp, &uctx->mm_head, entry) {
-                if (len != mm->key.len || phy_addr != mm->key.phy_addr)
-                        continue;
-
-                list_del(&mm->entry);
-                kfree(mm);
-                break;
-        }
-        mutex_unlock(&uctx->mm_list_lock);
-}
-
-static bool ocrdma_search_mmap(struct ocrdma_ucontext *uctx, u64 phy_addr,
-                              unsigned long len)
-{
-        bool found = false;
-        struct ocrdma_mm *mm;
-
-        mutex_lock(&uctx->mm_list_lock);
-        list_for_each_entry(mm, &uctx->mm_head, entry) {
-                if (len != mm->key.len || phy_addr != mm->key.phy_addr)
-                        continue;
-
-                found = true;
-                break;
-        }
-        mutex_unlock(&uctx->mm_list_lock);
-        return found;
-}
-
-struct ib_ucontext *ocrdma_alloc_ucontext(struct ib_device *ibdev,
-                                          struct ib_udata *udata)
-{
-        int status;
-        struct ocrdma_ucontext *ctx;
-        struct ocrdma_alloc_ucontext_resp resp;
-        struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        u32 map_len = roundup(sizeof(u32) * 2048, PAGE_SIZE);
-
-        if (!udata)
-                return ERR_PTR(-EFAULT);
-        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
-        if (!ctx)
-                return ERR_PTR(-ENOMEM);
-        ctx->dev = dev;
-        INIT_LIST_HEAD(&ctx->mm_head);
-        mutex_init(&ctx->mm_list_lock);
-
-        ctx->ah_tbl.va = dma_alloc_coherent(&pdev->dev, map_len,
-                                            &ctx->ah_tbl.pa, GFP_KERNEL);
-        if (!ctx->ah_tbl.va) {
-                kfree(ctx);
-                return ERR_PTR(-ENOMEM);
-        }
-        memset(ctx->ah_tbl.va, 0, map_len);
-        ctx->ah_tbl.len = map_len;
-
-        resp.ah_tbl_len = ctx->ah_tbl.len;
-        resp.ah_tbl_page = ctx->ah_tbl.pa;
-
-        status = ocrdma_add_mmap(ctx, resp.ah_tbl_page, resp.ah_tbl_len);
-        if (status)
-                goto map_err;
-        resp.dev_id = dev->id;
-        resp.max_inline_data = dev->attr.max_inline_data;
-        resp.wqe_size = dev->attr.wqe_size;
-        resp.rqe_size = dev->attr.rqe_size;
-        resp.dpp_wqe_size = dev->attr.wqe_size;
-        resp.rsvd = 0;
-
-        memcpy(resp.fw_ver, dev->attr.fw_ver, sizeof(resp.fw_ver));
-        status = ib_copy_to_udata(udata, &resp, sizeof(resp));
-        if (status)
-                goto cpy_err;
-        return &ctx->ibucontext;
-
-cpy_err:
-        ocrdma_del_mmap(ctx, ctx->ah_tbl.pa, ctx->ah_tbl.len);
-map_err:
-        dma_free_coherent(&pdev->dev, ctx->ah_tbl.len, ctx->ah_tbl.va,
-                          ctx->ah_tbl.pa);
-        kfree(ctx);
-        return ERR_PTR(status);
-}
-
-int ocrdma_dealloc_ucontext(struct ib_ucontext *ibctx)
-{
-        struct ocrdma_mm *mm, *tmp;
-        struct ocrdma_ucontext *uctx = get_ocrdma_ucontext(ibctx);
-        struct pci_dev *pdev = uctx->dev->nic_info.pdev;
-
-        ocrdma_del_mmap(uctx, uctx->ah_tbl.pa, uctx->ah_tbl.len);
-        dma_free_coherent(&pdev->dev, uctx->ah_tbl.len, uctx->ah_tbl.va,
-                          uctx->ah_tbl.pa);
-
-        list_for_each_entry_safe(mm, tmp, &uctx->mm_head, entry) {
-                list_del(&mm->entry);
-                kfree(mm);
-        }
-        kfree(uctx);
-        return 0;
-}
-
-int ocrdma_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
-{
-        struct ocrdma_ucontext *ucontext = get_ocrdma_ucontext(context);
-        struct ocrdma_dev *dev = ucontext->dev;
-        unsigned long vm_page = vma->vm_pgoff << PAGE_SHIFT;
-        u64 unmapped_db = (u64) dev->nic_info.unmapped_db;
-        unsigned long len = (vma->vm_end - vma->vm_start);
-        int status = 0;
-        bool found;
-
-        if (vma->vm_start & (PAGE_SIZE - 1))
-                return -EINVAL;
-        found = ocrdma_search_mmap(ucontext, vma->vm_pgoff << PAGE_SHIFT, len);
-        if (!found)
-                return -EINVAL;
-
-        if ((vm_page >= unmapped_db) && (vm_page <= (unmapped_db +
-                dev->nic_info.db_total_size)) &&
-                (len <= dev->nic_info.db_page_size)) {
-                /* doorbell mapping */
-                status = io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
-                                            len, vma->vm_page_prot);
-        } else if (dev->nic_info.dpp_unmapped_len &&
-                (vm_page >= (u64) dev->nic_info.dpp_unmapped_addr) &&
-                (vm_page <= (u64) (dev->nic_info.dpp_unmapped_addr +
-                        dev->nic_info.dpp_unmapped_len)) &&
-                (len <= dev->nic_info.dpp_unmapped_len)) {
-                /* dpp area mapping */
-                vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
-                status = io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
-                                            len, vma->vm_page_prot);
-        } else {
-                /* queue memory mapping */
-                status = remap_pfn_range(vma, vma->vm_start,
-                                         vma->vm_pgoff, len, vma->vm_page_prot);
-        }
-        return status;
-}
-
-static int ocrdma_copy_pd_uresp(struct ocrdma_pd *pd,
-                                struct ib_ucontext *ib_ctx,
-                                struct ib_udata *udata)
-{
-        int status;
-        u64 db_page_addr;
-        u64 dpp_page_addr = 0;
-        u32 db_page_size;
-        struct ocrdma_alloc_pd_uresp rsp;
-        struct ocrdma_ucontext *uctx = get_ocrdma_ucontext(ib_ctx);
-
-        rsp.id = pd->id;
-        rsp.dpp_enabled = pd->dpp_enabled;
-        db_page_addr = pd->dev->nic_info.unmapped_db +
-                        (pd->id * pd->dev->nic_info.db_page_size);
-        db_page_size = pd->dev->nic_info.db_page_size;
-
-        status = ocrdma_add_mmap(uctx, db_page_addr, db_page_size);
-        if (status)
-                return status;
-
-        if (pd->dpp_enabled) {
-                dpp_page_addr = pd->dev->nic_info.dpp_unmapped_addr +
-                                (pd->id * OCRDMA_DPP_PAGE_SIZE);
-                status = ocrdma_add_mmap(uctx, dpp_page_addr,
-                                 OCRDMA_DPP_PAGE_SIZE);
-                if (status)
-                        goto dpp_map_err;
-                rsp.dpp_page_addr_hi = upper_32_bits(dpp_page_addr);
-                rsp.dpp_page_addr_lo = dpp_page_addr;
-        }
-
-        status = ib_copy_to_udata(udata, &rsp, sizeof(rsp));
-        if (status)
-                goto ucopy_err;
-
-        pd->uctx = uctx;
-        return 0;
-
-ucopy_err:
-        if (pd->dpp_enabled)
-                ocrdma_del_mmap(pd->uctx, dpp_page_addr, OCRDMA_DPP_PAGE_SIZE);
-dpp_map_err:
-        ocrdma_del_mmap(pd->uctx, db_page_addr, db_page_size);
-        return status;
-}
-
-struct ib_pd *ocrdma_alloc_pd(struct ib_device *ibdev,
-                              struct ib_ucontext *context,
-                              struct ib_udata *udata)
-{
-        struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
-        struct ocrdma_pd *pd;
-        int status;
-
-        pd = kzalloc(sizeof(*pd), GFP_KERNEL);
-        if (!pd)
-                return ERR_PTR(-ENOMEM);
-        pd->dev = dev;
-        if (udata && context) {
-                pd->dpp_enabled = (dev->nic_info.dev_family ==
-                                        OCRDMA_GEN2_FAMILY) ? true : false;
-                pd->num_dpp_qp =
-                        pd->dpp_enabled ? OCRDMA_PD_MAX_DPP_ENABLED_QP : 0;
-        }
-        status = ocrdma_mbx_alloc_pd(dev, pd);
-        if (status) {
-                kfree(pd);
-                return ERR_PTR(status);
-        }
-        atomic_set(&pd->use_cnt, 0);
-
-        if (udata && context) {
-                status = ocrdma_copy_pd_uresp(pd, context, udata);
-                if (status)
-                        goto err;
-        }
-        return &pd->ibpd;
-
-err:
-        ocrdma_dealloc_pd(&pd->ibpd);
-        return ERR_PTR(status);
-}
-
-int ocrdma_dealloc_pd(struct ib_pd *ibpd)
-{
-        struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
-        struct ocrdma_dev *dev = pd->dev;
-        int status;
-        u64 usr_db;
-
-        if (atomic_read(&pd->use_cnt)) {
-                ocrdma_err("%s(%d) pd=0x%x is in use.\n",
-                           __func__, dev->id, pd->id);
-                status = -EFAULT;
-                goto dealloc_err;
-        }
-        status = ocrdma_mbx_dealloc_pd(dev, pd);
-        if (pd->uctx) {
-                u64 dpp_db = dev->nic_info.dpp_unmapped_addr +
-                    (pd->id * OCRDMA_DPP_PAGE_SIZE);
-                if (pd->dpp_enabled)
-                        ocrdma_del_mmap(pd->uctx, dpp_db, OCRDMA_DPP_PAGE_SIZE);
-                usr_db = dev->nic_info.unmapped_db +
-                    (pd->id * dev->nic_info.db_page_size);
-                ocrdma_del_mmap(pd->uctx, usr_db, dev->nic_info.db_page_size);
-        }
-        kfree(pd);
-dealloc_err:
-        return status;
-}
-
-static struct ocrdma_mr *ocrdma_alloc_lkey(struct ib_pd *ibpd,
-                                           int acc, u32 num_pbls,
-                                           u32 addr_check)
-{
-        int status;
-        struct ocrdma_mr *mr;
-        struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
-        struct ocrdma_dev *dev = pd->dev;
-
-        if (acc & IB_ACCESS_REMOTE_WRITE && !(acc & IB_ACCESS_LOCAL_WRITE)) {
-                ocrdma_err("%s(%d) leaving err, invalid access rights\n",
-                           __func__, dev->id);
-                return ERR_PTR(-EINVAL);
-        }
-
-        mr = kzalloc(sizeof(*mr), GFP_KERNEL);
-        if (!mr)
-                return ERR_PTR(-ENOMEM);
-        mr->hwmr.dev = dev;
-        mr->hwmr.fr_mr = 0;
-        mr->hwmr.local_rd = 1;
-        mr->hwmr.remote_rd = (acc & IB_ACCESS_REMOTE_READ) ? 1 : 0;
-        mr->hwmr.remote_wr = (acc & IB_ACCESS_REMOTE_WRITE) ? 1 : 0;
-        mr->hwmr.local_wr = (acc & IB_ACCESS_LOCAL_WRITE) ? 1 : 0;
-        mr->hwmr.mw_bind = (acc & IB_ACCESS_MW_BIND) ? 1 : 0;
-        mr->hwmr.remote_atomic = (acc & IB_ACCESS_REMOTE_ATOMIC) ? 1 : 0;
-        mr->hwmr.num_pbls = num_pbls;
-
-        status = ocrdma_mbx_alloc_lkey(dev, &mr->hwmr, pd->id, addr_check);
-        if (status) {
-                kfree(mr);
-                return ERR_PTR(-ENOMEM);
-        }
-        mr->pd = pd;
-        atomic_inc(&pd->use_cnt);
-        mr->ibmr.lkey = mr->hwmr.lkey;
-        if (mr->hwmr.remote_wr || mr->hwmr.remote_rd)
-                mr->ibmr.rkey = mr->hwmr.lkey;
-        return mr;
-}
-
-struct ib_mr *ocrdma_get_dma_mr(struct ib_pd *ibpd, int acc)
-{
-        struct ocrdma_mr *mr;
-
-        mr = ocrdma_alloc_lkey(ibpd, acc, 0, OCRDMA_ADDR_CHECK_DISABLE);
-        if (IS_ERR(mr))
-                return ERR_CAST(mr);
-
-        return &mr->ibmr;
-}
-
-static void ocrdma_free_mr_pbl_tbl(struct ocrdma_dev *dev,
-                                   struct ocrdma_hw_mr *mr)
-{
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        int i = 0;
-
-        if (mr->pbl_table) {
-                for (i = 0; i < mr->num_pbls; i++) {
-                        if (!mr->pbl_table[i].va)
-                                continue;
-                        dma_free_coherent(&pdev->dev, mr->pbl_size,
-                                          mr->pbl_table[i].va,
-                                          mr->pbl_table[i].pa);
-                }
-                kfree(mr->pbl_table);
-                mr->pbl_table = NULL;
-        }
-}
-
-static int ocrdma_get_pbl_info(struct ocrdma_mr *mr, u32 num_pbes)
-{
-        u32 num_pbls = 0;
-        u32 idx = 0;
-        int status = 0;
-        u32 pbl_size;
-
-        do {
-                pbl_size = OCRDMA_MIN_HPAGE_SIZE * (1 << idx);
-                if (pbl_size > MAX_OCRDMA_PBL_SIZE) {
-                        status = -EFAULT;
-                        break;
-                }
-                num_pbls = roundup(num_pbes, (pbl_size / sizeof(u64)));
-                num_pbls = num_pbls / (pbl_size / sizeof(u64));
-                idx++;
-        } while (num_pbls >= mr->hwmr.dev->attr.max_num_mr_pbl);
-
-        mr->hwmr.num_pbes = num_pbes;
-        mr->hwmr.num_pbls = num_pbls;
-        mr->hwmr.pbl_size = pbl_size;
-        return status;
-}
-
-static int ocrdma_build_pbl_tbl(struct ocrdma_dev *dev, struct ocrdma_hw_mr *mr)
-{
-        int status = 0;
-        int i;
-        u32 dma_len = mr->pbl_size;
-        struct pci_dev *pdev = dev->nic_info.pdev;
-        void *va;
-        dma_addr_t pa;
-
-        mr->pbl_table = kzalloc(sizeof(struct ocrdma_pbl) *
-                                mr->num_pbls, GFP_KERNEL);
-
-        if (!mr->pbl_table)
-                return -ENOMEM;
-
-        for (i = 0; i < mr->num_pbls; i++) {
-                va = dma_alloc_coherent(&pdev->dev, dma_len, &pa, GFP_KERNEL);
-                if (!va) {
-                        ocrdma_free_mr_pbl_tbl(dev, mr);
-                        status = -ENOMEM;
-                        break;
-                }
-                memset(va, 0, dma_len);
-                mr->pbl_table[i].va = va;
-                mr->pbl_table[i].pa = pa;
-        }
-        return status;
-}
-
-static void build_user_pbes(struct ocrdma_dev *dev, struct ocrdma_mr *mr,
-                            u32 num_pbes)
-{
-        struct ocrdma_pbe *pbe;
-        struct ib_umem_chunk *chunk;
-        struct ocrdma_pbl *pbl_tbl = mr->hwmr.pbl_table;
-        struct ib_umem *umem = mr->umem;
-        int i, shift, pg_cnt, pages, pbe_cnt, total_num_pbes = 0;
-
-        if (!mr->hwmr.num_pbes)
-                return;
-
-        pbe = (struct ocrdma_pbe *)pbl_tbl->va;
-        pbe_cnt = 0;
-
-        shift = ilog2(umem->page_size);
-
-        list_for_each_entry(chunk, &umem->chunk_list, list) {
-                /* get all the dma regions from the chunk. */
-                for (i = 0; i < chunk->nmap; i++) {
-                        pages = sg_dma_len(&chunk->page_list[i]) >> shift;
-                        for (pg_cnt = 0; pg_cnt < pages; pg_cnt++) {
-                                /* store the page address in pbe */
-                                pbe->pa_lo =
-                                    cpu_to_le32(sg_dma_address
-                                                (&chunk->page_list[i]) +
-                                                (umem->page_size * pg_cnt));
-                                pbe->pa_hi =
-                                    cpu_to_le32(upper_32_bits
-                                                ((sg_dma_address
-                                                  (&chunk->page_list[i]) +
-                                                  umem->page_size * pg_cnt)));
-                                pbe_cnt += 1;
-                                total_num_pbes += 1;
-                                pbe++;
-
-                                /* if done building pbes, issue the mbx cmd. */
-                                if (total_num_pbes == num_pbes)
-                                        return;
-
-                                /* if the given pbl is full storing the pbes,
-                                 * move to next pbl.
-                                 */
-                                if (pbe_cnt ==
-                                        (mr->hwmr.pbl_size / sizeof(u64))) {
-                                        pbl_tbl++;
-                                        pbe = (struct ocrdma_pbe *)pbl_tbl->va;
-                                        pbe_cnt = 0;
-                                }
-                        }
-                }
-        }
-}
-
-struct ib_mr *ocrdma_reg_user_mr(struct ib_pd *ibpd, u64 start, u64 len,
-                                 u64 usr_addr, int acc, struct ib_udata *udata)
-{
-        int status = -ENOMEM;
-        struct ocrdma_dev *dev;
-        struct ocrdma_mr *mr;
-        struct ocrdma_pd *pd;
-        u32 num_pbes;
-
-        pd = get_ocrdma_pd(ibpd);
-        dev = pd->dev;
-
-        if (acc & IB_ACCESS_REMOTE_WRITE && !(acc & IB_ACCESS_LOCAL_WRITE))
-                return ERR_PTR(-EINVAL);
-
-        mr = kzalloc(sizeof(*mr), GFP_KERNEL);
-        if (!mr)
-                return ERR_PTR(status);
-        mr->hwmr.dev = dev;
-        mr->umem = ib_umem_get(ibpd->uobject->context, start, len, acc, 0);
-        if (IS_ERR(mr->umem)) {
-                status = -EFAULT;
-                goto umem_err;
-        }
-        num_pbes = ib_umem_page_count(mr->umem);
-        status = ocrdma_get_pbl_info(mr, num_pbes);
-        if (status)
-                goto umem_err;
-
-        mr->hwmr.pbe_size = mr->umem->page_size;
-        mr->hwmr.fbo = mr->umem->offset;
-        mr->hwmr.va = usr_addr;
-        mr->hwmr.len = len;
-        mr->hwmr.remote_wr = (acc & IB_ACCESS_REMOTE_WRITE) ? 1 : 0;
-        mr->hwmr.remote_rd = (acc & IB_ACCESS_REMOTE_READ) ? 1 : 0;
-        mr->hwmr.local_wr = (acc & IB_ACCESS_LOCAL_WRITE) ? 1 : 0;
-        mr->hwmr.local_rd = 1;
-        mr->hwmr.remote_atomic = (acc & IB_ACCESS_REMOTE_ATOMIC) ? 1 : 0;
-        status = ocrdma_build_pbl_tbl(dev, &mr->hwmr);
-        if (status)
-                goto umem_err;
-        build_user_pbes(dev, mr, num_pbes);
-        status = ocrdma_reg_mr(dev, &mr->hwmr, pd->id, acc);
-        if (status)
-                goto mbx_err;
-        mr->pd = pd;
-        atomic_inc(&pd->use_cnt);
-        mr->ibmr.lkey = mr->hwmr.lkey;
-        if (mr->hwmr.remote_wr || mr->hwmr.remote_rd)
-                mr->ibmr.rkey = mr->hwmr.lkey;
-
-        return &mr->ibmr;
-
-mbx_err:
-        ocrdma_free_mr_pbl_tbl(dev, &mr->hwmr);
-umem_err:
-        kfree(mr);
-        return ERR_PTR(status);
-}
-
-int ocrdma_dereg_mr(struct ib_mr *ib_mr)
-{
-        struct ocrdma_mr *mr = get_ocrdma_mr(ib_mr);
-        struct ocrdma_dev *dev = mr->hwmr.dev;
-        int status;
-
-        status = ocrdma_mbx_dealloc_lkey(dev, mr->hwmr.fr_mr, mr->hwmr.lkey);
-
-        if (mr->hwmr.fr_mr == 0)
-                ocrdma_free_mr_pbl_tbl(dev, &mr->hwmr);
-
-        atomic_dec(&mr->pd->use_cnt);
-        /* it could be user registered memory. */
-        if (mr->umem)
-                ib_umem_release(mr->umem);
-        kfree(mr);
-        return status;
-}
-
-static int ocrdma_copy_cq_uresp(struct ocrdma_cq *cq, struct ib_udata *udata,
-                                struct ib_ucontext *ib_ctx)
-{
-        int status;
-        struct ocrdma_ucontext *uctx;
-        struct ocrdma_create_cq_uresp uresp;
-
-        uresp.cq_id = cq->id;
-        uresp.page_size = cq->len;
-        uresp.num_pages = 1;
-        uresp.max_hw_cqe = cq->max_hw_cqe;
-        uresp.page_addr[0] = cq->pa;
-        uresp.db_page_addr = cq->dev->nic_info.unmapped_db;
-        uresp.db_page_size = cq->dev->nic_info.db_page_size;
-        uresp.phase_change = cq->phase_change ? 1 : 0;
-        status = ib_copy_to_udata(udata, &uresp, sizeof(uresp));
-        if (status) {
-                ocrdma_err("%s(%d) copy error cqid=0x%x.\n",
-                           __func__, cq->dev->id, cq->id);
-                goto err;
-        }
-        uctx = get_ocrdma_ucontext(ib_ctx);
-        status = ocrdma_add_mmap(uctx, uresp.db_page_addr, uresp.db_page_size);
-        if (status)
-                goto err;
-        status = ocrdma_add_mmap(uctx, uresp.page_addr[0], uresp.page_size);
-        if (status) {
-                ocrdma_del_mmap(uctx, uresp.db_page_addr, uresp.db_page_size);
-                goto err;
-        }
-        cq->ucontext = uctx;
-err:
-        return status;
-}
-
-struct ib_cq *ocrdma_create_cq(struct ib_device *ibdev, int entries, int vector,
-                               struct ib_ucontext *ib_ctx,
-                               struct ib_udata *udata)
-{
-        struct ocrdma_cq *cq;
-        struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
-        int status;
-        struct ocrdma_create_cq_ureq ureq;
-
-        if (udata) {
-                if (ib_copy_from_udata(&ureq, udata, sizeof(ureq)))
-                        return ERR_PTR(-EFAULT);
-        } else
-                ureq.dpp_cq = 0;
-        cq = kzalloc(sizeof(*cq), GFP_KERNEL);
-        if (!cq)
-                return ERR_PTR(-ENOMEM);
-
-        spin_lock_init(&cq->cq_lock);
-        spin_lock_init(&cq->comp_handler_lock);
-        atomic_set(&cq->use_cnt, 0);
-        INIT_LIST_HEAD(&cq->sq_head);
-        INIT_LIST_HEAD(&cq->rq_head);
-        cq->dev = dev;
-
-        status = ocrdma_mbx_create_cq(dev, cq, entries, ureq.dpp_cq);
-        if (status) {
-                kfree(cq);
-                return ERR_PTR(status);
-        }
-        if (ib_ctx) {
-                status = ocrdma_copy_cq_uresp(cq, udata, ib_ctx);
-                if (status)
-                        goto ctx_err;
-        }
-        cq->phase = OCRDMA_CQE_VALID;
-        cq->arm_needed = true;
-        dev->cq_tbl[cq->id] = cq;
-
-        return &cq->ibcq;
-
-ctx_err:
-        ocrdma_mbx_destroy_cq(dev, cq);
-        kfree(cq);
-        return ERR_PTR(status);
-}
-
-int ocrdma_resize_cq(struct ib_cq *ibcq, int new_cnt,
-                     struct ib_udata *udata)
-{
-        int status = 0;
-        struct ocrdma_cq *cq = get_ocrdma_cq(ibcq);
-
-        if (new_cnt < 1 || new_cnt > cq->max_hw_cqe) {
-                status = -EINVAL;
-                return status;
-        }
-        ibcq->cqe = new_cnt;
-        return status;
-}
-
-int ocrdma_destroy_cq(struct ib_cq *ibcq)
-{
-        int status;
-        struct ocrdma_cq *cq = get_ocrdma_cq(ibcq);
-        struct ocrdma_dev *dev = cq->dev;
-
-        if (atomic_read(&cq->use_cnt))
-                return -EINVAL;
-
-        status = ocrdma_mbx_destroy_cq(dev, cq);
-
-        if (cq->ucontext) {
-                ocrdma_del_mmap(cq->ucontext, (u64) cq->pa, cq->len);
-                ocrdma_del_mmap(cq->ucontext, dev->nic_info.unmapped_db,
-                                dev->nic_info.db_page_size);
-        }
-        dev->cq_tbl[cq->id] = NULL;
-
-        kfree(cq);
-        return status;
-}
-
-static int ocrdma_add_qpn_map(struct ocrdma_dev *dev, struct ocrdma_qp *qp)
-{
-        int status = -EINVAL;
-
-        if (qp->id < OCRDMA_MAX_QP && dev->qp_tbl[qp->id] == NULL) {
-                dev->qp_tbl[qp->id] = qp;
-                status = 0;
-        }
-        return status;
-}
-
-static void ocrdma_del_qpn_map(struct ocrdma_dev *dev, struct ocrdma_qp *qp)
-{
-        dev->qp_tbl[qp->id] = NULL;
-}
-
-static int ocrdma_check_qp_params(struct ib_pd *ibpd, struct ocrdma_dev *dev,
-                                  struct ib_qp_init_attr *attrs)
-{
-        if (attrs->qp_type != IB_QPT_GSI &&
-            attrs->qp_type != IB_QPT_RC &&
-            attrs->qp_type != IB_QPT_UD) {
-                ocrdma_err("%s(%d) unsupported qp type=0x%x requested\n",
-                           __func__, dev->id, attrs->qp_type);
-                return -EINVAL;
-        }
-        if (attrs->cap.max_send_wr > dev->attr.max_wqe) {
-                ocrdma_err("%s(%d) unsupported send_wr=0x%x requested\n",
-                           __func__, dev->id, attrs->cap.max_send_wr);
-                ocrdma_err("%s(%d) supported send_wr=0x%x\n",
-                           __func__, dev->id, dev->attr.max_wqe);
-                return -EINVAL;
-        }
-        if (!attrs->srq && (attrs->cap.max_recv_wr > dev->attr.max_rqe)) {
-                ocrdma_err("%s(%d) unsupported recv_wr=0x%x requested\n",
-                           __func__, dev->id, attrs->cap.max_recv_wr);
-                ocrdma_err("%s(%d) supported recv_wr=0x%x\n",
-                           __func__, dev->id, dev->attr.max_rqe);
-                return -EINVAL;
-        }
-        if (attrs->cap.max_inline_data > dev->attr.max_inline_data) {
-                ocrdma_err("%s(%d) unsupported inline data size=0x%x"
-                           " requested\n", __func__, dev->id,
-                           attrs->cap.max_inline_data);
-                ocrdma_err("%s(%d) supported inline data size=0x%x\n",
-                           __func__, dev->id, dev->attr.max_inline_data);
-                return -EINVAL;
-        }
-        if (attrs->cap.max_send_sge > dev->attr.max_send_sge) {
-                ocrdma_err("%s(%d) unsupported send_sge=0x%x requested\n",
-                           __func__, dev->id, attrs->cap.max_send_sge);
-                ocrdma_err("%s(%d) supported send_sge=0x%x\n",
-                           __func__, dev->id, dev->attr.max_send_sge);
-                return -EINVAL;
-        }
-        if (attrs->cap.max_recv_sge > dev->attr.max_recv_sge) {
-                ocrdma_err("%s(%d) unsupported recv_sge=0x%x requested\n",
-                           __func__, dev->id, attrs->cap.max_recv_sge);
-                ocrdma_err("%s(%d) supported recv_sge=0x%x\n",
-                           __func__, dev->id, dev->attr.max_recv_sge);
-                return -EINVAL;
-        }
-        /* unprivileged user space cannot create special QP */
-        if (ibpd->uobject && attrs->qp_type == IB_QPT_GSI) {
-                ocrdma_err
-                    ("%s(%d) Userspace can't create special QPs of type=0x%x\n",
-                     __func__, dev->id, attrs->qp_type);
-                return -EINVAL;
-        }
-        /* allow creating only one GSI type of QP */
-        if (attrs->qp_type == IB_QPT_GSI && dev->gsi_qp_created) {
-                ocrdma_err("%s(%d) GSI special QPs already created.\n",
-                           __func__, dev->id);
-                return -EINVAL;
-        }
-        /* verify consumer QPs are not trying to use GSI QP's CQ */
-        if ((attrs->qp_type != IB_QPT_GSI) && (dev->gsi_qp_created)) {
-                if ((dev->gsi_sqcq == get_ocrdma_cq(attrs->send_cq)) ||
-                    (dev->gsi_sqcq == get_ocrdma_cq(attrs->recv_cq)) ||
-                    (dev->gsi_rqcq == get_ocrdma_cq(attrs->send_cq)) ||
-                    (dev->gsi_rqcq == get_ocrdma_cq(attrs->recv_cq))) {
-                        ocrdma_err("%s(%d) Consumer QP cannot use GSI CQs.\n",
-                                   __func__, dev->id);
-                        return -EINVAL;
-                }
-        }
-        return 0;
-}
-
-static int ocrdma_copy_qp_uresp(struct ocrdma_qp *qp,
-                                struct ib_udata *udata, int dpp_offset,
-                                int dpp_credit_lmt, int srq)
-{
-        int status = 0;
-        u64 usr_db;
-        struct ocrdma_create_qp_uresp uresp;
-        struct ocrdma_dev *dev = qp->dev;
-        struct ocrdma_pd *pd = qp->pd;
-
-        memset(&uresp, 0, sizeof(uresp));
-        usr_db = dev->nic_info.unmapped_db +
-                        (pd->id * dev->nic_info.db_page_size);
-        uresp.qp_id = qp->id;
-        uresp.sq_dbid = qp->sq.dbid;
-        uresp.num_sq_pages = 1;
-        uresp.sq_page_size = qp->sq.len;
-        uresp.sq_page_addr[0] = qp->sq.pa;
-        uresp.num_wqe_allocated = qp->sq.max_cnt;
-        if (!srq) {
-                uresp.rq_dbid = qp->rq.dbid;
-                uresp.num_rq_pages = 1;
-                uresp.rq_page_size = qp->rq.len;
-                uresp.rq_page_addr[0] = qp->rq.pa;
-                uresp.num_rqe_allocated = qp->rq.max_cnt;
-        }
-        uresp.db_page_addr = usr_db;
-        uresp.db_page_size = dev->nic_info.db_page_size;
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                uresp.db_sq_offset = OCRDMA_DB_GEN2_SQ_OFFSET;
-                uresp.db_rq_offset = ((qp->id & 0xFFFF) < 128) ?
-                        OCRDMA_DB_GEN2_RQ1_OFFSET : OCRDMA_DB_GEN2_RQ2_OFFSET;
-                uresp.db_shift = (qp->id < 128) ? 24 : 16;
-        } else {
-                uresp.db_sq_offset = OCRDMA_DB_SQ_OFFSET;
-                uresp.db_rq_offset = OCRDMA_DB_RQ_OFFSET;
-                uresp.db_shift = 16;
-        }
-
-        if (qp->dpp_enabled) {
-                uresp.dpp_credit = dpp_credit_lmt;
-                uresp.dpp_offset = dpp_offset;
-        }
-        status = ib_copy_to_udata(udata, &uresp, sizeof(uresp));
-        if (status) {
-                ocrdma_err("%s(%d) user copy error.\n", __func__, dev->id);
-                goto err;
-        }
-        status = ocrdma_add_mmap(pd->uctx, uresp.sq_page_addr[0],
-                                 uresp.sq_page_size);
-        if (status)
-                goto err;
-
-        if (!srq) {
-                status = ocrdma_add_mmap(pd->uctx, uresp.rq_page_addr[0],
-                                         uresp.rq_page_size);
-                if (status)
-                        goto rq_map_err;
-        }
-        return status;
-rq_map_err:
-        ocrdma_del_mmap(pd->uctx, uresp.sq_page_addr[0], uresp.sq_page_size);
-err:
-        return status;
-}
-
-static void ocrdma_set_qp_db(struct ocrdma_dev *dev, struct ocrdma_qp *qp,
-                             struct ocrdma_pd *pd)
-{
-        if (dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                qp->sq_db = dev->nic_info.db +
-                        (pd->id * dev->nic_info.db_page_size) +
-                        OCRDMA_DB_GEN2_SQ_OFFSET;
-                qp->rq_db = dev->nic_info.db +
-                        (pd->id * dev->nic_info.db_page_size) +
-                        ((qp->id < 128) ?
-                        OCRDMA_DB_GEN2_RQ1_OFFSET : OCRDMA_DB_GEN2_RQ2_OFFSET);
-        } else {
-                qp->sq_db = dev->nic_info.db +
-                        (pd->id * dev->nic_info.db_page_size) +
-                        OCRDMA_DB_SQ_OFFSET;
-                qp->rq_db = dev->nic_info.db +
-                        (pd->id * dev->nic_info.db_page_size) +
-                        OCRDMA_DB_RQ_OFFSET;
-        }
-}
-
-static int ocrdma_alloc_wr_id_tbl(struct ocrdma_qp *qp)
-{
-        qp->wqe_wr_id_tbl =
-            kzalloc(sizeof(*(qp->wqe_wr_id_tbl)) * qp->sq.max_cnt,
-                    GFP_KERNEL);
-        if (qp->wqe_wr_id_tbl == NULL)
-                return -ENOMEM;
-        qp->rqe_wr_id_tbl =
-            kzalloc(sizeof(u64) * qp->rq.max_cnt, GFP_KERNEL);
-        if (qp->rqe_wr_id_tbl == NULL)
-                return -ENOMEM;
-
-        return 0;
-}
-
-static void ocrdma_set_qp_init_params(struct ocrdma_qp *qp,
-                                      struct ocrdma_pd *pd,
-                                      struct ib_qp_init_attr *attrs)
-{
-        qp->pd = pd;
-        spin_lock_init(&qp->q_lock);
-        INIT_LIST_HEAD(&qp->sq_entry);
-        INIT_LIST_HEAD(&qp->rq_entry);
-
-        qp->qp_type = attrs->qp_type;
-        qp->cap_flags = OCRDMA_QP_INB_RD | OCRDMA_QP_INB_WR;
-        qp->max_inline_data = attrs->cap.max_inline_data;
-        qp->sq.max_sges = attrs->cap.max_send_sge;
-        qp->rq.max_sges = attrs->cap.max_recv_sge;
-        qp->state = OCRDMA_QPS_RST;
-}
-
-static void ocrdma_set_qp_use_cnt(struct ocrdma_qp *qp, struct ocrdma_pd *pd)
-{
-        atomic_inc(&pd->use_cnt);
-        atomic_inc(&qp->sq_cq->use_cnt);
-        atomic_inc(&qp->rq_cq->use_cnt);
-        if (qp->srq)
-                atomic_inc(&qp->srq->use_cnt);
-        qp->ibqp.qp_num = qp->id;
-}
-
-static void ocrdma_store_gsi_qp_cq(struct ocrdma_dev *dev,
-                                   struct ib_qp_init_attr *attrs)
-{
-        if (attrs->qp_type == IB_QPT_GSI) {
-                dev->gsi_qp_created = 1;
-                dev->gsi_sqcq = get_ocrdma_cq(attrs->send_cq);
-                dev->gsi_rqcq = get_ocrdma_cq(attrs->recv_cq);
-        }
-}
-
-struct ib_qp *ocrdma_create_qp(struct ib_pd *ibpd,
-                               struct ib_qp_init_attr *attrs,
-                               struct ib_udata *udata)
-{
-        int status;
-        struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
-        struct ocrdma_qp *qp;
-        struct ocrdma_dev *dev = pd->dev;
-        struct ocrdma_create_qp_ureq ureq;
-        u16 dpp_credit_lmt, dpp_offset;
-
-        status = ocrdma_check_qp_params(ibpd, dev, attrs);
-        if (status)
-                goto gen_err;
-
-        memset(&ureq, 0, sizeof(ureq));
-        if (udata) {
-                if (ib_copy_from_udata(&ureq, udata, sizeof(ureq)))
-                        return ERR_PTR(-EFAULT);
-        }
-        qp = kzalloc(sizeof(*qp), GFP_KERNEL);
-        if (!qp) {
-                status = -ENOMEM;
-                goto gen_err;
-        }
-        qp->dev = dev;
-        ocrdma_set_qp_init_params(qp, pd, attrs);
-
-        mutex_lock(&dev->dev_lock);
-        status = ocrdma_mbx_create_qp(qp, attrs, ureq.enable_dpp_cq,
-                                        ureq.dpp_cq_id,
-                                        &dpp_offset, &dpp_credit_lmt);
-        if (status)
-                goto mbx_err;
-
-        /* user space QP's wr_id table are managed in library */
-        if (udata == NULL) {
-                qp->cap_flags |= (OCRDMA_QP_MW_BIND | OCRDMA_QP_LKEY0 |
-                                  OCRDMA_QP_FAST_REG);
-                status = ocrdma_alloc_wr_id_tbl(qp);
-                if (status)
-                        goto map_err;
-        }
-
-        status = ocrdma_add_qpn_map(dev, qp);
-        if (status)
-                goto map_err;
-        ocrdma_set_qp_db(dev, qp, pd);
-        if (udata) {
-                status = ocrdma_copy_qp_uresp(qp, udata, dpp_offset,
-                                              dpp_credit_lmt,
-                                              (attrs->srq != NULL));
-                if (status)
-                        goto cpy_err;
-        }
-        ocrdma_store_gsi_qp_cq(dev, attrs);
-        ocrdma_set_qp_use_cnt(qp, pd);
-        mutex_unlock(&dev->dev_lock);
-        return &qp->ibqp;
-
-cpy_err:
-        ocrdma_del_qpn_map(dev, qp);
-map_err:
-        ocrdma_mbx_destroy_qp(dev, qp);
-mbx_err:
-        mutex_unlock(&dev->dev_lock);
-        kfree(qp->wqe_wr_id_tbl);
-        kfree(qp->rqe_wr_id_tbl);
-        kfree(qp);
-        ocrdma_err("%s(%d) error=%d\n", __func__, dev->id, status);
-gen_err:
-        return ERR_PTR(status);
-}
-
-int _ocrdma_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
-                      int attr_mask)
-{
-        int status = 0;
-        struct ocrdma_qp *qp;
-        struct ocrdma_dev *dev;
-        enum ib_qp_state old_qps;
-
-        qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
-        if (attr_mask & IB_QP_STATE)
-                status = ocrdma_qp_state_machine(qp, attr->qp_state, &old_qps);
-        /* if new and previous states are same hw doesn't need to
-         * know about it.
-         */
-        if (status < 0)
-                return status;
-        status = ocrdma_mbx_modify_qp(dev, qp, attr, attr_mask, old_qps);
-        return status;
-}
-
-int ocrdma_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
-                     int attr_mask, struct ib_udata *udata)
-{
-        unsigned long flags;
-        int status = -EINVAL;
-        struct ocrdma_qp *qp;
-        struct ocrdma_dev *dev;
-        enum ib_qp_state old_qps, new_qps;
-
-        qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
-
-        /* syncronize with multiple context trying to change, retrive qps */
-        mutex_lock(&dev->dev_lock);
-        /* syncronize with wqe, rqe posting and cqe processing contexts */
-        spin_lock_irqsave(&qp->q_lock, flags);
-        old_qps = get_ibqp_state(qp->state);
-        if (attr_mask & IB_QP_STATE)
-                new_qps = attr->qp_state;
-        else
-                new_qps = old_qps;
-        spin_unlock_irqrestore(&qp->q_lock, flags);
-
-        if (!ib_modify_qp_is_ok(old_qps, new_qps, ibqp->qp_type, attr_mask)) {
-                ocrdma_err("%s(%d) invalid attribute mask=0x%x specified for "
-                           "qpn=0x%x of type=0x%x old_qps=0x%x, new_qps=0x%x\n",
-                           __func__, dev->id, attr_mask, qp->id, ibqp->qp_type,
-                           old_qps, new_qps);
-                goto param_err;
-        }
-
-        status = _ocrdma_modify_qp(ibqp, attr, attr_mask);
-        if (status > 0)
-                status = 0;
-param_err:
-        mutex_unlock(&dev->dev_lock);
-        return status;
-}
-
-static enum ib_mtu ocrdma_mtu_int_to_enum(u16 mtu)
-{
-        switch (mtu) {
-        case 256:
-                return IB_MTU_256;
-        case 512:
-                return IB_MTU_512;
-        case 1024:
-                return IB_MTU_1024;
-        case 2048:
-                return IB_MTU_2048;
-        case 4096:
-                return IB_MTU_4096;
-        default:
-                return IB_MTU_1024;
-        }
-}
-
-static int ocrdma_to_ib_qp_acc_flags(int qp_cap_flags)
-{
-        int ib_qp_acc_flags = 0;
-
-        if (qp_cap_flags & OCRDMA_QP_INB_WR)
-                ib_qp_acc_flags |= IB_ACCESS_REMOTE_WRITE;
-        if (qp_cap_flags & OCRDMA_QP_INB_RD)
-                ib_qp_acc_flags |= IB_ACCESS_LOCAL_WRITE;
-        return ib_qp_acc_flags;
-}
-
-int ocrdma_query_qp(struct ib_qp *ibqp,
-                    struct ib_qp_attr *qp_attr,
-                    int attr_mask, struct ib_qp_init_attr *qp_init_attr)
-{
-        int status;
-        u32 qp_state;
-        struct ocrdma_qp_params params;
-        struct ocrdma_qp *qp = get_ocrdma_qp(ibqp);
-        struct ocrdma_dev *dev = qp->dev;
-
-        memset(&params, 0, sizeof(params));
-        mutex_lock(&dev->dev_lock);
-        status = ocrdma_mbx_query_qp(dev, qp, &params);
-        mutex_unlock(&dev->dev_lock);
-        if (status)
-                goto mbx_err;
-        qp_attr->qp_state = get_ibqp_state(IB_QPS_INIT);
-        qp_attr->cur_qp_state = get_ibqp_state(IB_QPS_INIT);
-        qp_attr->path_mtu =
-                ocrdma_mtu_int_to_enum(params.path_mtu_pkey_indx &
-                                OCRDMA_QP_PARAMS_PATH_MTU_MASK) >>
-                                OCRDMA_QP_PARAMS_PATH_MTU_SHIFT;
-        qp_attr->path_mig_state = IB_MIG_MIGRATED;
-        qp_attr->rq_psn = params.hop_lmt_rq_psn & OCRDMA_QP_PARAMS_RQ_PSN_MASK;
-        qp_attr->sq_psn = params.tclass_sq_psn & OCRDMA_QP_PARAMS_SQ_PSN_MASK;
-        qp_attr->dest_qp_num =
-            params.ack_to_rnr_rtc_dest_qpn & OCRDMA_QP_PARAMS_DEST_QPN_MASK;
-
-        qp_attr->qp_access_flags = ocrdma_to_ib_qp_acc_flags(qp->cap_flags);
-        qp_attr->cap.max_send_wr = qp->sq.max_cnt - 1;
-        qp_attr->cap.max_recv_wr = qp->rq.max_cnt - 1;
-        qp_attr->cap.max_send_sge = qp->sq.max_sges;
-        qp_attr->cap.max_recv_sge = qp->rq.max_sges;
-        qp_attr->cap.max_inline_data = dev->attr.max_inline_data;
-        qp_init_attr->cap = qp_attr->cap;
-        memcpy(&qp_attr->ah_attr.grh.dgid, &params.dgid[0],
-               sizeof(params.dgid));
-        qp_attr->ah_attr.grh.flow_label = params.rnt_rc_sl_fl &
-            OCRDMA_QP_PARAMS_FLOW_LABEL_MASK;
-        qp_attr->ah_attr.grh.sgid_index = qp->sgid_idx;
-        qp_attr->ah_attr.grh.hop_limit = (params.hop_lmt_rq_psn &
-                                          OCRDMA_QP_PARAMS_HOP_LMT_MASK) >>
-                                                OCRDMA_QP_PARAMS_HOP_LMT_SHIFT;
-        qp_attr->ah_attr.grh.traffic_class = (params.tclass_sq_psn &
-                                              OCRDMA_QP_PARAMS_SQ_PSN_MASK) >>
-                                                OCRDMA_QP_PARAMS_TCLASS_SHIFT;
-
-        qp_attr->ah_attr.ah_flags = IB_AH_GRH;
-        qp_attr->ah_attr.port_num = 1;
-        qp_attr->ah_attr.sl = (params.rnt_rc_sl_fl &
-                               OCRDMA_QP_PARAMS_SL_MASK) >>
-                                OCRDMA_QP_PARAMS_SL_SHIFT;
-        qp_attr->timeout = (params.ack_to_rnr_rtc_dest_qpn &
-                            OCRDMA_QP_PARAMS_ACK_TIMEOUT_MASK) >>
-                                OCRDMA_QP_PARAMS_ACK_TIMEOUT_SHIFT;
-        qp_attr->rnr_retry = (params.ack_to_rnr_rtc_dest_qpn &
-                              OCRDMA_QP_PARAMS_RNR_RETRY_CNT_MASK) >>
-                                OCRDMA_QP_PARAMS_RNR_RETRY_CNT_SHIFT;
-        qp_attr->retry_cnt =
-            (params.rnt_rc_sl_fl & OCRDMA_QP_PARAMS_RETRY_CNT_MASK) >>
-                OCRDMA_QP_PARAMS_RETRY_CNT_SHIFT;
-        qp_attr->min_rnr_timer = 0;
-        qp_attr->pkey_index = 0;
-        qp_attr->port_num = 1;
-        qp_attr->ah_attr.src_path_bits = 0;
-        qp_attr->ah_attr.static_rate = 0;
-        qp_attr->alt_pkey_index = 0;
-        qp_attr->alt_port_num = 0;
-        qp_attr->alt_timeout = 0;
-        memset(&qp_attr->alt_ah_attr, 0, sizeof(qp_attr->alt_ah_attr));
-        qp_state = (params.max_sge_recv_flags & OCRDMA_QP_PARAMS_STATE_MASK) >>
-                    OCRDMA_QP_PARAMS_STATE_SHIFT;
-        qp_attr->sq_draining = (qp_state == OCRDMA_QPS_SQ_DRAINING) ? 1 : 0;
-        qp_attr->max_dest_rd_atomic =
-            params.max_ord_ird >> OCRDMA_QP_PARAMS_MAX_ORD_SHIFT;
-        qp_attr->max_rd_atomic =
-            params.max_ord_ird & OCRDMA_QP_PARAMS_MAX_IRD_MASK;
-        qp_attr->en_sqd_async_notify = (params.max_sge_recv_flags &
-                                OCRDMA_QP_PARAMS_FLAGS_SQD_ASYNC) ? 1 : 0;
-mbx_err:
-        return status;
-}
-
-static void ocrdma_srq_toggle_bit(struct ocrdma_srq *srq, int idx)
-{
-        int i = idx / 32;
-        unsigned int mask = (1 << (idx % 32));
-
-        if (srq->idx_bit_fields[i] & mask)
-                srq->idx_bit_fields[i] &= ~mask;
-        else
-                srq->idx_bit_fields[i] |= mask;
-}
-
-static int ocrdma_hwq_free_cnt(struct ocrdma_qp_hwq_info *q)
-{
-        int free_cnt;
-        if (q->head >= q->tail)
-                free_cnt = (q->max_cnt - q->head) + q->tail;
-        else
-                free_cnt = q->tail - q->head;
-        return free_cnt;
-}
-
-static int is_hw_sq_empty(struct ocrdma_qp *qp)
-{
-        return (qp->sq.tail == qp->sq.head &&
-                ocrdma_hwq_free_cnt(&qp->sq) ? 1 : 0);
-}
-
-static int is_hw_rq_empty(struct ocrdma_qp *qp)
-{
-        return (qp->rq.tail == qp->rq.head) ? 1 : 0;
-}
-
-static void *ocrdma_hwq_head(struct ocrdma_qp_hwq_info *q)
-{
-        return q->va + (q->head * q->entry_size);
-}
-
-static void *ocrdma_hwq_head_from_idx(struct ocrdma_qp_hwq_info *q,
-                                      u32 idx)
-{
-        return q->va + (idx * q->entry_size);
-}
-
-static void ocrdma_hwq_inc_head(struct ocrdma_qp_hwq_info *q)
-{
-        q->head = (q->head + 1) & q->max_wqe_idx;
-}
-
-static void ocrdma_hwq_inc_tail(struct ocrdma_qp_hwq_info *q)
-{
-        q->tail = (q->tail + 1) & q->max_wqe_idx;
-}
-
-/* discard the cqe for a given QP */
-static void ocrdma_discard_cqes(struct ocrdma_qp *qp, struct ocrdma_cq *cq)
-{
-        unsigned long cq_flags;
-        unsigned long flags;
-        int discard_cnt = 0;
-        u32 cur_getp, stop_getp;
-        struct ocrdma_cqe *cqe;
-        u32 qpn = 0;
-
-        spin_lock_irqsave(&cq->cq_lock, cq_flags);
-
-        /* traverse through the CQEs in the hw CQ,
-         * find the matching CQE for a given qp,
-         * mark the matching one discarded by clearing qpn.
-         * ring the doorbell in the poll_cq() as
-         * we don't complete out of order cqe.
-         */
-
-        cur_getp = cq->getp;
-        /* find upto when do we reap the cq. */
-        stop_getp = cur_getp;
-        do {
-                if (is_hw_sq_empty(qp) && (!qp->srq && is_hw_rq_empty(qp)))
-                        break;
-
-                cqe = cq->va + cur_getp;
-                /* if (a) done reaping whole hw cq, or
-                 *    (b) qp_xq becomes empty.
-                 * then exit
-                 */
-                qpn = cqe->cmn.qpn & OCRDMA_CQE_QPN_MASK;
-                /* if previously discarded cqe found, skip that too. */
-                /* check for matching qp */
-                if (qpn == 0 || qpn != qp->id)
-                        goto skip_cqe;
-
-                /* mark cqe discarded so that it is not picked up later
-                 * in the poll_cq().
-                 */
-                discard_cnt += 1;
-                cqe->cmn.qpn = 0;
-                if (is_cqe_for_sq(cqe))
-                        ocrdma_hwq_inc_tail(&qp->sq);
-                else {
-                        if (qp->srq) {
-                                spin_lock_irqsave(&qp->srq->q_lock, flags);
-                                ocrdma_hwq_inc_tail(&qp->srq->rq);
-                                ocrdma_srq_toggle_bit(qp->srq, cur_getp);
-                                spin_unlock_irqrestore(&qp->srq->q_lock, flags);
-
-                        } else
-                                ocrdma_hwq_inc_tail(&qp->rq);
-                }
-skip_cqe:
-                cur_getp = (cur_getp + 1) % cq->max_hw_cqe;
-        } while (cur_getp != stop_getp);
-        spin_unlock_irqrestore(&cq->cq_lock, cq_flags);
-}
-
-static void ocrdma_del_flush_qp(struct ocrdma_qp *qp)
-{
-        int found = false;
-        unsigned long flags;
-        struct ocrdma_dev *dev = qp->dev;
-        /* sync with any active CQ poll */
-
-        spin_lock_irqsave(&dev->flush_q_lock, flags);
-        found = ocrdma_is_qp_in_sq_flushlist(qp->sq_cq, qp);
-        if (found)
-                list_del(&qp->sq_entry);
-        if (!qp->srq) {
-                found = ocrdma_is_qp_in_rq_flushlist(qp->rq_cq, qp);
-                if (found)
-                        list_del(&qp->rq_entry);
-        }
-        spin_unlock_irqrestore(&dev->flush_q_lock, flags);
-}
-
-int ocrdma_destroy_qp(struct ib_qp *ibqp)
-{
-        int status;
-        struct ocrdma_pd *pd;
-        struct ocrdma_qp *qp;
-        struct ocrdma_dev *dev;
-        struct ib_qp_attr attrs;
-        int attr_mask = IB_QP_STATE;
-        unsigned long flags;
-
-        qp = get_ocrdma_qp(ibqp);
-        dev = qp->dev;
-
-        attrs.qp_state = IB_QPS_ERR;
-        pd = qp->pd;
-
-        /* change the QP state to ERROR */
-        _ocrdma_modify_qp(ibqp, &attrs, attr_mask);
-
-        /* ensure that CQEs for newly created QP (whose id may be same with
-         * one which just getting destroyed are same), dont get
-         * discarded until the old CQEs are discarded.
-         */
-        mutex_lock(&dev->dev_lock);
-        status = ocrdma_mbx_destroy_qp(dev, qp);
-
-        /*
-         * acquire CQ lock while destroy is in progress, in order to
-         * protect against proessing in-flight CQEs for this QP.
-         */
-        spin_lock_irqsave(&qp->sq_cq->cq_lock, flags);
-        if (qp->rq_cq && (qp->rq_cq != qp->sq_cq))
-                spin_lock(&qp->rq_cq->cq_lock);
-
-        ocrdma_del_qpn_map(dev, qp);
-
-        if (qp->rq_cq && (qp->rq_cq != qp->sq_cq))
-                spin_unlock(&qp->rq_cq->cq_lock);
-        spin_unlock_irqrestore(&qp->sq_cq->cq_lock, flags);
-
-        if (!pd->uctx) {
-                ocrdma_discard_cqes(qp, qp->sq_cq);
-                ocrdma_discard_cqes(qp, qp->rq_cq);
-        }
-        mutex_unlock(&dev->dev_lock);
-
-        if (pd->uctx) {
-                ocrdma_del_mmap(pd->uctx, (u64) qp->sq.pa, qp->sq.len);
-                if (!qp->srq)
-                        ocrdma_del_mmap(pd->uctx, (u64) qp->rq.pa, qp->rq.len);
-        }
-
-        ocrdma_del_flush_qp(qp);
-
-        atomic_dec(&qp->pd->use_cnt);
-        atomic_dec(&qp->sq_cq->use_cnt);
-        atomic_dec(&qp->rq_cq->use_cnt);
-        if (qp->srq)
-                atomic_dec(&qp->srq->use_cnt);
-        kfree(qp->wqe_wr_id_tbl);
-        kfree(qp->rqe_wr_id_tbl);
-        kfree(qp);
-        return status;
-}
-
-static int ocrdma_copy_srq_uresp(struct ocrdma_srq *srq, struct ib_udata *udata)
-{
-        int status;
-        struct ocrdma_create_srq_uresp uresp;
-
-        uresp.rq_dbid = srq->rq.dbid;
-        uresp.num_rq_pages = 1;
-        uresp.rq_page_addr[0] = srq->rq.pa;
-        uresp.rq_page_size = srq->rq.len;
-        uresp.db_page_addr = srq->dev->nic_info.unmapped_db +
-            (srq->pd->id * srq->dev->nic_info.db_page_size);
-        uresp.db_page_size = srq->dev->nic_info.db_page_size;
-        uresp.num_rqe_allocated = srq->rq.max_cnt;
-        if (srq->dev->nic_info.dev_family == OCRDMA_GEN2_FAMILY) {
-                uresp.db_rq_offset = OCRDMA_DB_GEN2_RQ1_OFFSET;
-                uresp.db_shift = 24;
-        } else {
-                uresp.db_rq_offset = OCRDMA_DB_RQ_OFFSET;
-                uresp.db_shift = 16;
-        }
-
-        status = ib_copy_to_udata(udata, &uresp, sizeof(uresp));
-        if (status)
-                return status;
-        status = ocrdma_add_mmap(srq->pd->uctx, uresp.rq_page_addr[0],
-                                 uresp.rq_page_size);
-        if (status)
-                return status;
-        return status;
-}
-
-struct ib_srq *ocrdma_create_srq(struct ib_pd *ibpd,
-                                 struct ib_srq_init_attr *init_attr,
-                                 struct ib_udata *udata)
-{
-        int status = -ENOMEM;
-        struct ocrdma_pd *pd = get_ocrdma_pd(ibpd);
-        struct ocrdma_dev *dev = pd->dev;
-        struct ocrdma_srq *srq;
-
-        if (init_attr->attr.max_sge > dev->attr.max_recv_sge)
-                return ERR_PTR(-EINVAL);
-        if (init_attr->attr.max_wr > dev->attr.max_rqe)
-                return ERR_PTR(-EINVAL);
-
-        srq = kzalloc(sizeof(*srq), GFP_KERNEL);
-        if (!srq)
-                return ERR_PTR(status);
-
-        spin_lock_init(&srq->q_lock);
-        srq->dev = dev;
-        srq->pd = pd;
-        srq->db = dev->nic_info.db + (pd->id * dev->nic_info.db_page_size);
-        status = ocrdma_mbx_create_srq(srq, init_attr, pd);
-        if (status)
-                goto err;
-
-        if (udata == NULL) {
-                srq->rqe_wr_id_tbl = kzalloc(sizeof(u64) * srq->rq.max_cnt,
-                            GFP_KERNEL);
-                if (srq->rqe_wr_id_tbl == NULL)
-                        goto arm_err;
-
-                srq->bit_fields_len = (srq->rq.max_cnt / 32) +
-                    (srq->rq.max_cnt % 32 ? 1 : 0);
-                srq->idx_bit_fields =
-                    kmalloc(srq->bit_fields_len * sizeof(u32), GFP_KERNEL);
-                if (srq->idx_bit_fields == NULL)
-                        goto arm_err;
-                memset(srq->idx_bit_fields, 0xff,
-                       srq->bit_fields_len * sizeof(u32));
-        }
-
-        if (init_attr->attr.srq_limit) {
-                status = ocrdma_mbx_modify_srq(srq, &init_attr->attr);
-                if (status)
-                        goto arm_err;
-        }
-
-        atomic_set(&srq->use_cnt, 0);
-        if (udata) {
-                status = ocrdma_copy_srq_uresp(srq, udata);
-                if (status)
-                        goto arm_err;
-        }
-
-        atomic_inc(&pd->use_cnt);
-        return &srq->ibsrq;
-
-arm_err:
-        ocrdma_mbx_destroy_srq(dev, srq);
-err:
-        kfree(srq->rqe_wr_id_tbl);
-        kfree(srq->idx_bit_fields);
-        kfree(srq);
-        return ERR_PTR(status);
-}
-
-int ocrdma_modify_srq(struct ib_srq *ibsrq,
-                      struct ib_srq_attr *srq_attr,
-                      enum ib_srq_attr_mask srq_attr_mask,
-                      struct ib_udata *udata)
-{
-        int status = 0;
-        struct ocrdma_srq *srq;
-
-        srq = get_ocrdma_srq(ibsrq);
-        if (srq_attr_mask & IB_SRQ_MAX_WR)
-                status = -EINVAL;
-        else
-                status = ocrdma_mbx_modify_srq(srq, srq_attr);
-        return status;
-}
-
-int ocrdma_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *srq_attr)
-{
-        int status;
-        struct ocrdma_srq *srq;
-
-        srq = get_ocrdma_srq(ibsrq);
-        status = ocrdma_mbx_query_srq(srq, srq_attr);
-        return status;
-}
-
-int ocrdma_destroy_srq(struct ib_srq *ibsrq)
-{
-        int status;
-        struct ocrdma_srq *srq;
-        struct ocrdma_dev *dev;
-
-        srq = get_ocrdma_srq(ibsrq);
-        dev = srq->dev;
-        if (atomic_read(&srq->use_cnt)) {
-                ocrdma_err("%s(%d) err, srq=0x%x in use\n",
-                           __func__, dev->id, srq->id);
-                return -EAGAIN;
-        }
-
-        status = ocrdma_mbx_destroy_srq(dev, srq);
-
-        if (srq->pd->uctx)
-                ocrdma_del_mmap(srq->pd->uctx, (u64) srq->rq.pa, srq->rq.len);
-
-        atomic_dec(&srq->pd->use_cnt);
-        kfree(srq->idx_bit_fields);
-        kfree(srq->rqe_wr_id_tbl);
-        kfree(srq);
-        return status;
-}
-
-/* unprivileged verbs and their support functions. */
-static void ocrdma_build_ud_hdr(struct ocrdma_qp *qp,
-                                struct ocrdma_hdr_wqe *hdr,
-                                struct ib_send_wr *wr)
-{
-        struct ocrdma_ewqe_ud_hdr *ud_hdr =
-                (struct ocrdma_ewqe_ud_hdr *)(hdr + 1);
-        struct ocrdma_ah *ah = get_ocrdma_ah(wr->wr.ud.ah);
-
-        ud_hdr->rsvd_dest_qpn = wr->wr.ud.remote_qpn;
-        if (qp->qp_type == IB_QPT_GSI)
-                ud_hdr->qkey = qp->qkey;
-        else
-                ud_hdr->qkey = wr->wr.ud.remote_qkey;
-        ud_hdr->rsvd_ahid = ah->id;
-}
-
-static void ocrdma_build_sges(struct ocrdma_hdr_wqe *hdr,
-                              struct ocrdma_sge *sge, int num_sge,
-                              struct ib_sge *sg_list)
-{
-        int i;
-
-        for (i = 0; i < num_sge; i++) {
-                sge[i].lrkey = sg_list[i].lkey;
-                sge[i].addr_lo = sg_list[i].addr;
-                sge[i].addr_hi = upper_32_bits(sg_list[i].addr);
-                sge[i].len = sg_list[i].length;
-                hdr->total_len += sg_list[i].length;
-        }
-        if (num_sge == 0)
-                memset(sge, 0, sizeof(*sge));
-}
-
-static int ocrdma_build_inline_sges(struct ocrdma_qp *qp,
-                                    struct ocrdma_hdr_wqe *hdr,
-                                    struct ocrdma_sge *sge,
-                                    struct ib_send_wr *wr, u32 wqe_size)
-{
-        if (wr->send_flags & IB_SEND_INLINE) {
-                if (wr->sg_list[0].length > qp->max_inline_data) {
-                        ocrdma_err("%s() supported_len=0x%x,"
-                                " unspported len req=0x%x\n", __func__,
-                                qp->max_inline_data, wr->sg_list[0].length);
-                        return -EINVAL;
-                }
-                memcpy(sge,
-                       (void *)(unsigned long)wr->sg_list[0].addr,
-                       wr->sg_list[0].length);
-                hdr->total_len = wr->sg_list[0].length;
-                wqe_size += roundup(hdr->total_len, OCRDMA_WQE_ALIGN_BYTES);
-                hdr->cw |= (OCRDMA_TYPE_INLINE << OCRDMA_WQE_TYPE_SHIFT);
-        } else {
-                ocrdma_build_sges(hdr, sge, wr->num_sge, wr->sg_list);
-                if (wr->num_sge)
-                        wqe_size += (wr->num_sge * sizeof(struct ocrdma_sge));
-                else
-                        wqe_size += sizeof(struct ocrdma_sge);
-                hdr->cw |= (OCRDMA_TYPE_LKEY << OCRDMA_WQE_TYPE_SHIFT);
-        }
-        hdr->cw |= ((wqe_size / OCRDMA_WQE_STRIDE) << OCRDMA_WQE_SIZE_SHIFT);
-        return 0;
-}
-
-static int ocrdma_build_send(struct ocrdma_qp *qp, struct ocrdma_hdr_wqe *hdr,
-                             struct ib_send_wr *wr)
-{
-        int status;
-        struct ocrdma_sge *sge;
-        u32 wqe_size = sizeof(*hdr);
-
-        if (qp->qp_type == IB_QPT_UD || qp->qp_type == IB_QPT_GSI) {
-                ocrdma_build_ud_hdr(qp, hdr, wr);
-                sge = (struct ocrdma_sge *)(hdr + 2);
-                wqe_size += sizeof(struct ocrdma_ewqe_ud_hdr);
-        } else
-                sge = (struct ocrdma_sge *)(hdr + 1);
-
-        status = ocrdma_build_inline_sges(qp, hdr, sge, wr, wqe_size);
-        return status;
-}
-
-static int ocrdma_build_write(struct ocrdma_qp *qp, struct ocrdma_hdr_wqe *hdr,
-                              struct ib_send_wr *wr)
-{
-        int status;
-        struct ocrdma_sge *ext_rw = (struct ocrdma_sge *)(hdr + 1);
-        struct ocrdma_sge *sge = ext_rw + 1;
-        u32 wqe_size = sizeof(*hdr) + sizeof(*ext_rw);
-
-        status = ocrdma_build_inline_sges(qp, hdr, sge, wr, wqe_size);
-        if (status)
-                return status;
-        ext_rw->addr_lo = wr->wr.rdma.remote_addr;
-        ext_rw->addr_hi = upper_32_bits(wr->wr.rdma.remote_addr);
-        ext_rw->lrkey = wr->wr.rdma.rkey;
-        ext_rw->len = hdr->total_len;
-        return 0;
-}
-
-static void ocrdma_build_read(struct ocrdma_qp *qp, struct ocrdma_hdr_wqe *hdr,
-                              struct ib_send_wr *wr)
-{
-        struct ocrdma_sge *ext_rw = (struct ocrdma_sge *)(hdr + 1);
-        struct ocrdma_sge *sge = ext_rw + 1;
-        u32 wqe_size = ((wr->num_sge + 1) * sizeof(struct ocrdma_sge)) +
-            sizeof(struct ocrdma_hdr_wqe);
-
-        ocrdma_build_sges(hdr, sge, wr->num_sge, wr->sg_list);
-        hdr->cw |= ((wqe_size / OCRDMA_WQE_STRIDE) << OCRDMA_WQE_SIZE_SHIFT);
-        hdr->cw |= (OCRDMA_READ << OCRDMA_WQE_OPCODE_SHIFT);
-        hdr->cw |= (OCRDMA_TYPE_LKEY << OCRDMA_WQE_TYPE_SHIFT);
-
-        ext_rw->addr_lo = wr->wr.rdma.remote_addr;
-        ext_rw->addr_hi = upper_32_bits(wr->wr.rdma.remote_addr);
-        ext_rw->lrkey = wr->wr.rdma.rkey;
-        ext_rw->len = hdr->total_len;
-}
-
-static void ocrdma_ring_sq_db(struct ocrdma_qp *qp)
-{
-        u32 val = qp->sq.dbid | (1 << 16);
-
-        iowrite32(val, qp->sq_db);
-}
-
-int ocrdma_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
-                     struct ib_send_wr **bad_wr)
-{
-        int status = 0;
-        struct ocrdma_qp *qp = get_ocrdma_qp(ibqp);
-        struct ocrdma_hdr_wqe *hdr;
-        unsigned long flags;
-
-        spin_lock_irqsave(&qp->q_lock, flags);
-        if (qp->state != OCRDMA_QPS_RTS && qp->state != OCRDMA_QPS_SQD) {
-                spin_unlock_irqrestore(&qp->q_lock, flags);
-                return -EINVAL;
-        }
-
-        while (wr) {
-                if (ocrdma_hwq_free_cnt(&qp->sq) == 0 ||
-                    wr->num_sge > qp->sq.max_sges) {
-                        status = -ENOMEM;
-                        break;
-                }
-                hdr = ocrdma_hwq_head(&qp->sq);
-                hdr->cw = 0;
-                if (wr->send_flags & IB_SEND_SIGNALED)
-                        hdr->cw |= (OCRDMA_FLAG_SIG << OCRDMA_WQE_FLAGS_SHIFT);
-                if (wr->send_flags & IB_SEND_FENCE)
-                        hdr->cw |=
-                            (OCRDMA_FLAG_FENCE_L << OCRDMA_WQE_FLAGS_SHIFT);
-                if (wr->send_flags & IB_SEND_SOLICITED)
-                        hdr->cw |=
-                            (OCRDMA_FLAG_SOLICIT << OCRDMA_WQE_FLAGS_SHIFT);
-                hdr->total_len = 0;
-                switch (wr->opcode) {
-                case IB_WR_SEND_WITH_IMM:
-                        hdr->cw |= (OCRDMA_FLAG_IMM << OCRDMA_WQE_FLAGS_SHIFT);
-                        hdr->immdt = ntohl(wr->ex.imm_data);
-                case IB_WR_SEND:
-                        hdr->cw |= (OCRDMA_SEND << OCRDMA_WQE_OPCODE_SHIFT);
-                        ocrdma_build_send(qp, hdr, wr);
-                        break;
-                case IB_WR_SEND_WITH_INV:
-                        hdr->cw |= (OCRDMA_FLAG_INV << OCRDMA_WQE_FLAGS_SHIFT);
-                        hdr->cw |= (OCRDMA_SEND << OCRDMA_WQE_OPCODE_SHIFT);
-                        hdr->lkey = wr->ex.invalidate_rkey;
-                        status = ocrdma_build_send(qp, hdr, wr);
-                        break;
-                case IB_WR_RDMA_WRITE_WITH_IMM:
-                        hdr->cw |= (OCRDMA_FLAG_IMM << OCRDMA_WQE_FLAGS_SHIFT);
-                        hdr->immdt = ntohl(wr->ex.imm_data);
-                case IB_WR_RDMA_WRITE:
-                        hdr->cw |= (OCRDMA_WRITE << OCRDMA_WQE_OPCODE_SHIFT);
-                        status = ocrdma_build_write(qp, hdr, wr);
-                        break;
-                case IB_WR_RDMA_READ_WITH_INV:
-                        hdr->cw |= (OCRDMA_FLAG_INV << OCRDMA_WQE_FLAGS_SHIFT);
-                case IB_WR_RDMA_READ:
-                        ocrdma_build_read(qp, hdr, wr);
-                        break;
-                case IB_WR_LOCAL_INV:
-                        hdr->cw |=
-                            (OCRDMA_LKEY_INV << OCRDMA_WQE_OPCODE_SHIFT);
-                        hdr->cw |= (sizeof(struct ocrdma_hdr_wqe) /
-                                OCRDMA_WQE_STRIDE) << OCRDMA_WQE_SIZE_SHIFT;
-                        hdr->lkey = wr->ex.invalidate_rkey;
-                        break;
-                default:
-                        status = -EINVAL;
-                        break;
-                }
-                if (status) {
-                        *bad_wr = wr;
-                        break;
-                }
-                if (wr->send_flags & IB_SEND_SIGNALED)
-                        qp->wqe_wr_id_tbl[qp->sq.head].signaled = 1;
-                else
-                        qp->wqe_wr_id_tbl[qp->sq.head].signaled = 0;
-                qp->wqe_wr_id_tbl[qp->sq.head].wrid = wr->wr_id;
-                ocrdma_cpu_to_le32(hdr, ((hdr->cw >> OCRDMA_WQE_SIZE_SHIFT) &
-                                   OCRDMA_WQE_SIZE_MASK) * OCRDMA_WQE_STRIDE);
-                /* make sure wqe is written before adapter can access it */
-                wmb();
-                /* inform hw to start processing it */
-                ocrdma_ring_sq_db(qp);
-
-                /* update pointer, counter for next wr */
-                ocrdma_hwq_inc_head(&qp->sq);
-                wr = wr->next;
-        }
-        spin_unlock_irqrestore(&qp->q_lock, flags);
-        return status;
-}
-
-static void ocrdma_ring_rq_db(struct ocrdma_qp *qp)
-{
-        u32 val = qp->rq.dbid | (1 << OCRDMA_GET_NUM_POSTED_SHIFT_VAL(qp));
-
-        iowrite32(val, qp->rq_db);
-}
-
-static void ocrdma_build_rqe(struct ocrdma_hdr_wqe *rqe, struct ib_recv_wr *wr,
-                             u16 tag)
-{
-        u32 wqe_size = 0;
-        struct ocrdma_sge *sge;
-        if (wr->num_sge)
-                wqe_size = (wr->num_sge * sizeof(*sge)) + sizeof(*rqe);
-        else
-                wqe_size = sizeof(*sge) + sizeof(*rqe);
-
-        rqe->cw = ((wqe_size / OCRDMA_WQE_STRIDE) <<
-                                OCRDMA_WQE_SIZE_SHIFT);
-        rqe->cw |= (OCRDMA_FLAG_SIG << OCRDMA_WQE_FLAGS_SHIFT);
-        rqe->cw |= (OCRDMA_TYPE_LKEY << OCRDMA_WQE_TYPE_SHIFT);
-        rqe->total_len = 0;
-        rqe->rsvd_tag = tag;
-        sge = (struct ocrdma_sge *)(rqe + 1);
-        ocrdma_build_sges(rqe, sge, wr->num_sge, wr->sg_list);
-        ocrdma_cpu_to_le32(rqe, wqe_size);
-}
-
-int ocrdma_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *wr,
-                     struct ib_recv_wr **bad_wr)
-{
-        int status = 0;
-        unsigned long flags;
-        struct ocrdma_qp *qp = get_ocrdma_qp(ibqp);
-        struct ocrdma_hdr_wqe *rqe;
-
-        spin_lock_irqsave(&qp->q_lock, flags);
-        if (qp->state == OCRDMA_QPS_RST || qp->state == OCRDMA_QPS_ERR) {
-                spin_unlock_irqrestore(&qp->q_lock, flags);
-                *bad_wr = wr;
-                return -EINVAL;
-        }
-        while (wr) {
-                if (ocrdma_hwq_free_cnt(&qp->rq) == 0 ||
-                    wr->num_sge > qp->rq.max_sges) {
-                        *bad_wr = wr;
-                        status = -ENOMEM;
-                        break;
-                }
-                rqe = ocrdma_hwq_head(&qp->rq);
-                ocrdma_build_rqe(rqe, wr, 0);
-
-                qp->rqe_wr_id_tbl[qp->rq.head] = wr->wr_id;
-                /* make sure rqe is written before adapter can access it */
-                wmb();
-
-                /* inform hw to start processing it */
-                ocrdma_ring_rq_db(qp);
-
-                /* update pointer, counter for next wr */
-                ocrdma_hwq_inc_head(&qp->rq);
-                wr = wr->next;
-        }
-        spin_unlock_irqrestore(&qp->q_lock, flags);
-        return status;
-}
-
-/* cqe for srq's rqe can potentially arrive out of order.
- * index gives the entry in the shadow table where to store
- * the wr_id. tag/index is returned in cqe to reference back
- * for a given rqe.
- */
-static int ocrdma_srq_get_idx(struct ocrdma_srq *srq)
-{
-        int row = 0;
-        int indx = 0;
-
-        for (row = 0; row < srq->bit_fields_len; row++) {
-                if (srq->idx_bit_fields[row]) {
-                        indx = ffs(srq->idx_bit_fields[row]);
-                        indx = (row * 32) + (indx - 1);
-                        if (indx >= srq->rq.max_cnt)
-                                BUG();
-                        ocrdma_srq_toggle_bit(srq, indx);
-                        break;
-                }
-        }
-
-        if (row == srq->bit_fields_len)
-                BUG();
-        return indx;
-}
-
-static void ocrdma_ring_srq_db(struct ocrdma_srq *srq)
-{
-        u32 val = srq->rq.dbid | (1 << 16);
-
-        iowrite32(val, srq->db + OCRDMA_DB_GEN2_SRQ_OFFSET);
-}
-
-int ocrdma_post_srq_recv(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
-                         struct ib_recv_wr **bad_wr)
-{
-        int status = 0;
-        unsigned long flags;
-        struct ocrdma_srq *srq;
-        struct ocrdma_hdr_wqe *rqe;
-        u16 tag;
-
-        srq = get_ocrdma_srq(ibsrq);
-
-        spin_lock_irqsave(&srq->q_lock, flags);
-        while (wr) {
-                if (ocrdma_hwq_free_cnt(&srq->rq) == 0 ||
-                    wr->num_sge > srq->rq.max_sges) {
-                        status = -ENOMEM;
-                        *bad_wr = wr;
-                        break;
-                }
-                tag = ocrdma_srq_get_idx(srq);
-                rqe = ocrdma_hwq_head(&srq->rq);
-                ocrdma_build_rqe(rqe, wr, tag);
-
-                srq->rqe_wr_id_tbl[tag] = wr->wr_id;
-                /* make sure rqe is written before adapter can perform DMA */
-                wmb();
-                /* inform hw to start processing it */
-                ocrdma_ring_srq_db(srq);
-                /* update pointer, counter for next wr */
-                ocrdma_hwq_inc_head(&srq->rq);
-                wr = wr->next;
-        }
-        spin_unlock_irqrestore(&srq->q_lock, flags);
-        return status;
-}
-
-static enum ib_wc_status ocrdma_to_ibwc_err(u16 status)
-{
-        enum ib_wc_status ibwc_status = IB_WC_GENERAL_ERR;
-
-        switch (status) {
-        case OCRDMA_CQE_GENERAL_ERR:
-                ibwc_status = IB_WC_GENERAL_ERR;
-                break;
-        case OCRDMA_CQE_LOC_LEN_ERR:
-                ibwc_status = IB_WC_LOC_LEN_ERR;
-                break;
-        case OCRDMA_CQE_LOC_QP_OP_ERR:
-                ibwc_status = IB_WC_LOC_QP_OP_ERR;
-                break;
-        case OCRDMA_CQE_LOC_EEC_OP_ERR:
-                ibwc_status = IB_WC_LOC_EEC_OP_ERR;
-                break;
-        case OCRDMA_CQE_LOC_PROT_ERR:
-                ibwc_status = IB_WC_LOC_PROT_ERR;
-                break;
-        case OCRDMA_CQE_WR_FLUSH_ERR:
-                ibwc_status = IB_WC_WR_FLUSH_ERR;
-                break;
-        case OCRDMA_CQE_MW_BIND_ERR:
-                ibwc_status = IB_WC_MW_BIND_ERR;
-                break;
-        case OCRDMA_CQE_BAD_RESP_ERR:
-                ibwc_status = IB_WC_BAD_RESP_ERR;
-                break;
-        case OCRDMA_CQE_LOC_ACCESS_ERR:
-                ibwc_status = IB_WC_LOC_ACCESS_ERR;
-                break;
-        case OCRDMA_CQE_REM_INV_REQ_ERR:
-                ibwc_status = IB_WC_REM_INV_REQ_ERR;
-                break;
-        case OCRDMA_CQE_REM_ACCESS_ERR:
-                ibwc_status = IB_WC_REM_ACCESS_ERR;
-                break;
-        case OCRDMA_CQE_REM_OP_ERR:
-                ibwc_status = IB_WC_REM_OP_ERR;
-                break;
-        case OCRDMA_CQE_RETRY_EXC_ERR:
-                ibwc_status = IB_WC_RETRY_EXC_ERR;
-                break;
-        case OCRDMA_CQE_RNR_RETRY_EXC_ERR:
-                ibwc_status = IB_WC_RNR_RETRY_EXC_ERR;
-                break;
-        case OCRDMA_CQE_LOC_RDD_VIOL_ERR:
-                ibwc_status = IB_WC_LOC_RDD_VIOL_ERR;
-                break;
-        case OCRDMA_CQE_REM_INV_RD_REQ_ERR:
-                ibwc_status = IB_WC_REM_INV_RD_REQ_ERR;
-                break;
-        case OCRDMA_CQE_REM_ABORT_ERR:
-                ibwc_status = IB_WC_REM_ABORT_ERR;
-                break;
-        case OCRDMA_CQE_INV_EECN_ERR:
-                ibwc_status = IB_WC_INV_EECN_ERR;
-                break;
-        case OCRDMA_CQE_INV_EEC_STATE_ERR:
-                ibwc_status = IB_WC_INV_EEC_STATE_ERR;
-                break;
-        case OCRDMA_CQE_FATAL_ERR:
-                ibwc_status = IB_WC_FATAL_ERR;
-                break;
-        case OCRDMA_CQE_RESP_TIMEOUT_ERR:
-                ibwc_status = IB_WC_RESP_TIMEOUT_ERR;
-                break;
-        default:
-                ibwc_status = IB_WC_GENERAL_ERR;
-                break;
-        };
-        return ibwc_status;
-}
-
-static void ocrdma_update_wc(struct ocrdma_qp *qp, struct ib_wc *ibwc,
-                      u32 wqe_idx)
-{
-        struct ocrdma_hdr_wqe *hdr;
-        struct ocrdma_sge *rw;
-        int opcode;
-
-        hdr = ocrdma_hwq_head_from_idx(&qp->sq, wqe_idx);
-
-        ibwc->wr_id = qp->wqe_wr_id_tbl[wqe_idx].wrid;
-        /* Undo the hdr->cw swap */
-        opcode = le32_to_cpu(hdr->cw) & OCRDMA_WQE_OPCODE_MASK;
-        switch (opcode) {
-        case OCRDMA_WRITE:
-                ibwc->opcode = IB_WC_RDMA_WRITE;
-                break;
-        case OCRDMA_READ:
-                rw = (struct ocrdma_sge *)(hdr + 1);
-                ibwc->opcode = IB_WC_RDMA_READ;
-                ibwc->byte_len = rw->len;
-                break;
-        case OCRDMA_SEND:
-                ibwc->opcode = IB_WC_SEND;
-                break;
-        case OCRDMA_LKEY_INV:
-                ibwc->opcode = IB_WC_LOCAL_INV;
-                break;
-        default:
-                ibwc->status = IB_WC_GENERAL_ERR;
-                ocrdma_err("%s() invalid opcode received = 0x%x\n",
-                           __func__, hdr->cw & OCRDMA_WQE_OPCODE_MASK);
-                break;
-        };
-}
-
-static void ocrdma_set_cqe_status_flushed(struct ocrdma_qp *qp,
-                                                struct ocrdma_cqe *cqe)
-{
-        if (is_cqe_for_sq(cqe)) {
-                cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                cqe->flags_status_srcqpn) &
-                                        ~OCRDMA_CQE_STATUS_MASK);
-                cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                cqe->flags_status_srcqpn) |
-                                (OCRDMA_CQE_WR_FLUSH_ERR <<
-                                        OCRDMA_CQE_STATUS_SHIFT));
-        } else {
-                if (qp->qp_type == IB_QPT_UD || qp->qp_type == IB_QPT_GSI) {
-                        cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                        cqe->flags_status_srcqpn) &
-                                                ~OCRDMA_CQE_UD_STATUS_MASK);
-                        cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                        cqe->flags_status_srcqpn) |
-                                        (OCRDMA_CQE_WR_FLUSH_ERR <<
-                                                OCRDMA_CQE_UD_STATUS_SHIFT));
-                } else {
-                        cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                        cqe->flags_status_srcqpn) &
-                                                ~OCRDMA_CQE_STATUS_MASK);
-                        cqe->flags_status_srcqpn = cpu_to_le32(le32_to_cpu(
-                                        cqe->flags_status_srcqpn) |
-                                        (OCRDMA_CQE_WR_FLUSH_ERR <<
-                                                OCRDMA_CQE_STATUS_SHIFT));
-                }
-        }
-}
-
-static bool ocrdma_update_err_cqe(struct ib_wc *ibwc, struct ocrdma_cqe *cqe,
-                                  struct ocrdma_qp *qp, int status)
-{
-        bool expand = false;
-
-        ibwc->byte_len = 0;
-        ibwc->qp = &qp->ibqp;
-        ibwc->status = ocrdma_to_ibwc_err(status);
-
-        ocrdma_flush_qp(qp);
-        ocrdma_qp_state_machine(qp, IB_QPS_ERR, NULL);
-
-        /* if wqe/rqe pending for which cqe needs to be returned,
-         * trigger inflating it.
-         */
-        if (!is_hw_rq_empty(qp) || !is_hw_sq_empty(qp)) {
-                expand = true;
-                ocrdma_set_cqe_status_flushed(qp, cqe);
-        }
-        return expand;
-}
-
-static int ocrdma_update_err_rcqe(struct ib_wc *ibwc, struct ocrdma_cqe *cqe,
-                                  struct ocrdma_qp *qp, int status)
-{
-        ibwc->opcode = IB_WC_RECV;
-        ibwc->wr_id = qp->rqe_wr_id_tbl[qp->rq.tail];
-        ocrdma_hwq_inc_tail(&qp->rq);
-
-        return ocrdma_update_err_cqe(ibwc, cqe, qp, status);
-}
-
-static int ocrdma_update_err_scqe(struct ib_wc *ibwc, struct ocrdma_cqe *cqe,
-                                  struct ocrdma_qp *qp, int status)
-{
-        ocrdma_update_wc(qp, ibwc, qp->sq.tail);
-        ocrdma_hwq_inc_tail(&qp->sq);
-
-        return ocrdma_update_err_cqe(ibwc, cqe, qp, status);
-}
-
-
-static bool ocrdma_poll_err_scqe(struct ocrdma_qp *qp,
-                                 struct ocrdma_cqe *cqe, struct ib_wc *ibwc,
-                                 bool *polled, bool *stop)
-{
-        bool expand;
-        int status = (le32_to_cpu(cqe->flags_status_srcqpn) &
-                OCRDMA_CQE_STATUS_MASK) >> OCRDMA_CQE_STATUS_SHIFT;
-
-        /* when hw sq is empty, but rq is not empty, so we continue
-         * to keep the cqe in order to get the cq event again.
-         */
-        if (is_hw_sq_empty(qp) && !is_hw_rq_empty(qp)) {
-                /* when cq for rq and sq is same, it is safe to return
-                 * flush cqe for RQEs.
-                 */
-                if (!qp->srq && (qp->sq_cq == qp->rq_cq)) {
-                        *polled = true;
-                        status = OCRDMA_CQE_WR_FLUSH_ERR;
-                        expand = ocrdma_update_err_rcqe(ibwc, cqe, qp, status);
-                } else {
-                        /* stop processing further cqe as this cqe is used for
-                         * triggering cq event on buddy cq of RQ.
-                         * When QP is destroyed, this cqe will be removed
-                         * from the cq's hardware q.
-                         */
-                        *polled = false;
-                        *stop = true;
-                        expand = false;
-                }
-        } else {
-                *polled = true;
-                expand = ocrdma_update_err_scqe(ibwc, cqe, qp, status);
-        }
-        return expand;
-}
-
-static bool ocrdma_poll_success_scqe(struct ocrdma_qp *qp,
-                                     struct ocrdma_cqe *cqe,
-                                     struct ib_wc *ibwc, bool *polled)
-{
-        bool expand = false;
-        int tail = qp->sq.tail;
-        u32 wqe_idx;
-
-        if (!qp->wqe_wr_id_tbl[tail].signaled) {
-                *polled = false;    /* WC cannot be consumed yet */
-        } else {
-                ibwc->status = IB_WC_SUCCESS;
-                ibwc->wc_flags = 0;
-                ibwc->qp = &qp->ibqp;
-                ocrdma_update_wc(qp, ibwc, tail);
-                *polled = true;
-        }
-        wqe_idx = le32_to_cpu(cqe->wq.wqeidx) & OCRDMA_CQE_WQEIDX_MASK;
-        if (tail != wqe_idx)
-                expand = true; /* Coalesced CQE can't be consumed yet */
-
-        ocrdma_hwq_inc_tail(&qp->sq);
-        return expand;
-}
-
-static bool ocrdma_poll_scqe(struct ocrdma_qp *qp, struct ocrdma_cqe *cqe,
-                             struct ib_wc *ibwc, bool *polled, bool *stop)
-{
-        int status;
-        bool expand;
-
-        status = (le32_to_cpu(cqe->flags_status_srcqpn) &
-                OCRDMA_CQE_STATUS_MASK) >> OCRDMA_CQE_STATUS_SHIFT;
-
-        if (status == OCRDMA_CQE_SUCCESS)
-                expand = ocrdma_poll_success_scqe(qp, cqe, ibwc, polled);
-        else
-                expand = ocrdma_poll_err_scqe(qp, cqe, ibwc, polled, stop);
-        return expand;
-}
-
-static int ocrdma_update_ud_rcqe(struct ib_wc *ibwc, struct ocrdma_cqe *cqe)
-{
-        int status;
-
-        status = (le32_to_cpu(cqe->flags_status_srcqpn) &
-                OCRDMA_CQE_UD_STATUS_MASK) >> OCRDMA_CQE_UD_STATUS_SHIFT;
-        ibwc->src_qp = le32_to_cpu(cqe->flags_status_srcqpn) &
-                                                OCRDMA_CQE_SRCQP_MASK;
-        ibwc->pkey_index = le32_to_cpu(cqe->ud.rxlen_pkey) &
-                                                OCRDMA_CQE_PKEY_MASK;
-        ibwc->wc_flags = IB_WC_GRH;
-        ibwc->byte_len = (le32_to_cpu(cqe->ud.rxlen_pkey) >>
-                                        OCRDMA_CQE_UD_XFER_LEN_SHIFT);
-        return status;
-}
-
-static void ocrdma_update_free_srq_cqe(struct ib_wc *ibwc,
-                                       struct ocrdma_cqe *cqe,
-                                       struct ocrdma_qp *qp)
-{
-        unsigned long flags;
-        struct ocrdma_srq *srq;
-        u32 wqe_idx;
-
-        srq = get_ocrdma_srq(qp->ibqp.srq);
-        wqe_idx = le32_to_cpu(cqe->rq.buftag_qpn) >> OCRDMA_CQE_BUFTAG_SHIFT;
-        ibwc->wr_id = srq->rqe_wr_id_tbl[wqe_idx];
-        spin_lock_irqsave(&srq->q_lock, flags);
-        ocrdma_srq_toggle_bit(srq, wqe_idx);
-        spin_unlock_irqrestore(&srq->q_lock, flags);
-        ocrdma_hwq_inc_tail(&srq->rq);
-}
-
-static bool ocrdma_poll_err_rcqe(struct ocrdma_qp *qp, struct ocrdma_cqe *cqe,
-                                struct ib_wc *ibwc, bool *polled, bool *stop,
-                                int status)
-{
-        bool expand;
-
-        /* when hw_rq is empty, but wq is not empty, so continue
-         * to keep the cqe to get the cq event again.
-         */
-        if (is_hw_rq_empty(qp) && !is_hw_sq_empty(qp)) {
-                if (!qp->srq && (qp->sq_cq == qp->rq_cq)) {
-                        *polled = true;
-                        status = OCRDMA_CQE_WR_FLUSH_ERR;
-                        expand = ocrdma_update_err_scqe(ibwc, cqe, qp, status);
-                } else {
-                        *polled = false;
-                        *stop = true;
-                        expand = false;
-                }
-        } else {
-                *polled = true;
-                expand = ocrdma_update_err_rcqe(ibwc, cqe, qp, status);
-        }
-        return expand;
-}
-
-static void ocrdma_poll_success_rcqe(struct ocrdma_qp *qp,
-                                     struct ocrdma_cqe *cqe, struct ib_wc *ibwc)
-{
-        ibwc->opcode = IB_WC_RECV;
-        ibwc->qp = &qp->ibqp;
-        ibwc->status = IB_WC_SUCCESS;
-
-        if (qp->qp_type == IB_QPT_UD || qp->qp_type == IB_QPT_GSI)
-                ocrdma_update_ud_rcqe(ibwc, cqe);
-        else
-                ibwc->byte_len = le32_to_cpu(cqe->rq.rxlen);
-
-        if (is_cqe_imm(cqe)) {
-                ibwc->ex.imm_data = htonl(le32_to_cpu(cqe->rq.lkey_immdt));
-                ibwc->wc_flags |= IB_WC_WITH_IMM;
-        } else if (is_cqe_wr_imm(cqe)) {
-                ibwc->opcode = IB_WC_RECV_RDMA_WITH_IMM;
-                ibwc->ex.imm_data = htonl(le32_to_cpu(cqe->rq.lkey_immdt));
-                ibwc->wc_flags |= IB_WC_WITH_IMM;
-        } else if (is_cqe_invalidated(cqe)) {
-                ibwc->ex.invalidate_rkey = le32_to_cpu(cqe->rq.lkey_immdt);
-                ibwc->wc_flags |= IB_WC_WITH_INVALIDATE;
-        }
-        if (qp->ibqp.srq)
-                ocrdma_update_free_srq_cqe(ibwc, cqe, qp);
-        else {
-                ibwc->wr_id = qp->rqe_wr_id_tbl[qp->rq.tail];
-                ocrdma_hwq_inc_tail(&qp->rq);
-        }
-}
-
-static bool ocrdma_poll_rcqe(struct ocrdma_qp *qp, struct ocrdma_cqe *cqe,
-                             struct ib_wc *ibwc, bool *polled, bool *stop)
-{
-        int status;
-        bool expand = false;
-
-        ibwc->wc_flags = 0;
-        if (qp->qp_type == IB_QPT_UD || qp->qp_type == IB_QPT_GSI)
-                status = (le32_to_cpu(cqe->flags_status_srcqpn) &
-                                        OCRDMA_CQE_UD_STATUS_MASK) >>
-                                        OCRDMA_CQE_UD_STATUS_SHIFT;
-        else
-                status = (le32_to_cpu(cqe->flags_status_srcqpn) &
-                             OCRDMA_CQE_STATUS_MASK) >> OCRDMA_CQE_STATUS_SHIFT;
-
-        if (status == OCRDMA_CQE_SUCCESS) {
-                *polled = true;
-                ocrdma_poll_success_rcqe(qp, cqe, ibwc);
-        } else {
-                expand = ocrdma_poll_err_rcqe(qp, cqe, ibwc, polled, stop,
-                                              status);
-        }
-        return expand;
-}
-
-static void ocrdma_change_cq_phase(struct ocrdma_cq *cq, struct ocrdma_cqe *cqe,
-                                   u16 cur_getp)
-{
-        if (cq->phase_change) {
-                if (cur_getp == 0)
-                        cq->phase = (~cq->phase & OCRDMA_CQE_VALID);
-        } else
-                /* clear valid bit */
-                cqe->flags_status_srcqpn = 0;
-}
-
-static int ocrdma_poll_hwcq(struct ocrdma_cq *cq, int num_entries,
-                            struct ib_wc *ibwc)
-{
-        u16 qpn = 0;
-        int i = 0;
-        bool expand = false;
-        int polled_hw_cqes = 0;
-        struct ocrdma_qp *qp = NULL;
-        struct ocrdma_dev *dev = cq->dev;
-        struct ocrdma_cqe *cqe;
-        u16 cur_getp; bool polled = false; bool stop = false;
-
-        cur_getp = cq->getp;
-        while (num_entries) {
-                cqe = cq->va + cur_getp;
-                /* check whether valid cqe or not */
-                if (!is_cqe_valid(cq, cqe))
-                        break;
-                qpn = (le32_to_cpu(cqe->cmn.qpn) & OCRDMA_CQE_QPN_MASK);
-                /* ignore discarded cqe */
-                if (qpn == 0)
-                        goto skip_cqe;
-                qp = dev->qp_tbl[qpn];
-                BUG_ON(qp == NULL);
-
-                if (is_cqe_for_sq(cqe)) {
-                        expand = ocrdma_poll_scqe(qp, cqe, ibwc, &polled,
-                                                  &stop);
-                } else {
-                        expand = ocrdma_poll_rcqe(qp, cqe, ibwc, &polled,
-                                                  &stop);
-                }
-                if (expand)
-                        goto expand_cqe;
-                if (stop)
-                        goto stop_cqe;
-                /* clear qpn to avoid duplicate processing by discard_cqe() */
-                cqe->cmn.qpn = 0;
-skip_cqe:
-                polled_hw_cqes += 1;
-                cur_getp = (cur_getp + 1) % cq->max_hw_cqe;
-                ocrdma_change_cq_phase(cq, cqe, cur_getp);
-expand_cqe:
-                if (polled) {
-                        num_entries -= 1;
-                        i += 1;
-                        ibwc = ibwc + 1;
-                        polled = false;
-                }
-        }
-stop_cqe:
-        cq->getp = cur_getp;
-        if (polled_hw_cqes || expand || stop) {
-                ocrdma_ring_cq_db(dev, cq->id, cq->armed, cq->solicited,
-                                  polled_hw_cqes);
-        }
-        return i;
-}
-
-/* insert error cqe if the QP's SQ or RQ's CQ matches the CQ under poll. */
-static int ocrdma_add_err_cqe(struct ocrdma_cq *cq, int num_entries,
-                              struct ocrdma_qp *qp, struct ib_wc *ibwc)
-{
-        int err_cqes = 0;
-
-        while (num_entries) {
-                if (is_hw_sq_empty(qp) && is_hw_rq_empty(qp))
-                        break;
-                if (!is_hw_sq_empty(qp) && qp->sq_cq == cq) {
-                        ocrdma_update_wc(qp, ibwc, qp->sq.tail);
-                        ocrdma_hwq_inc_tail(&qp->sq);
-                } else if (!is_hw_rq_empty(qp) && qp->rq_cq == cq) {
-                        ibwc->wr_id = qp->rqe_wr_id_tbl[qp->rq.tail];
-                        ocrdma_hwq_inc_tail(&qp->rq);
-                } else
-                        return err_cqes;
-                ibwc->byte_len = 0;
-                ibwc->status = IB_WC_WR_FLUSH_ERR;
-                ibwc = ibwc + 1;
-                err_cqes += 1;
-                num_entries -= 1;
-        }
-        return err_cqes;
-}
-
-int ocrdma_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc)
-{
-        int cqes_to_poll = num_entries;
-        struct ocrdma_cq *cq = NULL;
-        unsigned long flags;
-        struct ocrdma_dev *dev;
-        int num_os_cqe = 0, err_cqes = 0;
-        struct ocrdma_qp *qp;
-
-        cq = get_ocrdma_cq(ibcq);
-        dev = cq->dev;
-
-        /* poll cqes from adapter CQ */
-        spin_lock_irqsave(&cq->cq_lock, flags);
-        num_os_cqe = ocrdma_poll_hwcq(cq, cqes_to_poll, wc);
-        spin_unlock_irqrestore(&cq->cq_lock, flags);
-        cqes_to_poll -= num_os_cqe;
-
-        if (cqes_to_poll) {
-                wc = wc + num_os_cqe;
-                /* adapter returns single error cqe when qp moves to
-                 * error state. So insert error cqes with wc_status as
-                 * FLUSHED for pending WQEs and RQEs of QP's SQ and RQ
-                 * respectively which uses this CQ.
-                 */
-                spin_lock_irqsave(&dev->flush_q_lock, flags);
-                list_for_each_entry(qp, &cq->sq_head, sq_entry) {
-                        if (cqes_to_poll == 0)
-                                break;
-                        err_cqes = ocrdma_add_err_cqe(cq, cqes_to_poll, qp, wc);
-                        cqes_to_poll -= err_cqes;
-                        num_os_cqe += err_cqes;
-                        wc = wc + err_cqes;
-                }
-                spin_unlock_irqrestore(&dev->flush_q_lock, flags);
-        }
-        return num_os_cqe;
-}
-
-int ocrdma_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags cq_flags)
-{
-        struct ocrdma_cq *cq;
-        unsigned long flags;
-        struct ocrdma_dev *dev;
-        u16 cq_id;
-        u16 cur_getp;
-        struct ocrdma_cqe *cqe;
-
-        cq = get_ocrdma_cq(ibcq);
-        cq_id = cq->id;
-        dev = cq->dev;
-
-        spin_lock_irqsave(&cq->cq_lock, flags);
-        if (cq_flags & IB_CQ_NEXT_COMP || cq_flags & IB_CQ_SOLICITED)
-                cq->armed = true;
-        if (cq_flags & IB_CQ_SOLICITED)
-                cq->solicited = true;
-
-        cur_getp = cq->getp;
-        cqe = cq->va + cur_getp;
-
-        /* check whether any valid cqe exist or not, if not then safe to
-         * arm. If cqe is not yet consumed, then let it get consumed and then
-         * we arm it to avoid false interrupts.
-         */
-        if (!is_cqe_valid(cq, cqe) || cq->arm_needed) {
-                cq->arm_needed = false;
-                ocrdma_ring_cq_db(dev, cq_id, cq->armed, cq->solicited, 0);
-        }
-        spin_unlock_irqrestore(&cq->cq_lock, flags);
-        return 0;
-}
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h
deleted file mode 100644
index 633f03d8027..00000000000
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2012 Emulex. All rights reserved.            *
- * EMULEX and SLI are trademarks of Emulex.                        *
- * www.emulex.com                                                  *
- *                                                                 *
- * This program is free software; you can redistribute it and/or   *
- * modify it under the terms of version 2 of the GNU General       *
- * Public License as published by the Free Software Foundation.    *
- * This program is distributed in the hope that it will be useful. *
- * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
- * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
- * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
- * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
- * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
- * more details, a copy of which can be found in the file COPYING  *
- * included with this package.                                     *
- *
- * Contact Information:
- * linux-drivers@emulex.com
- *
- * Emulex
- * 3333 Susan Street
- * Costa Mesa, CA 92626
- *******************************************************************/
-
-#ifndef __OCRDMA_VERBS_H__
-#define __OCRDMA_VERBS_H__
-
-int ocrdma_post_send(struct ib_qp *, struct ib_send_wr *,
-                     struct ib_send_wr **bad_wr);
-int ocrdma_post_recv(struct ib_qp *, struct ib_recv_wr *,
-                     struct ib_recv_wr **bad_wr);
-
-int ocrdma_poll_cq(struct ib_cq *, int num_entries, struct ib_wc *wc);
-int ocrdma_arm_cq(struct ib_cq *, enum ib_cq_notify_flags flags);
-
-int ocrdma_query_device(struct ib_device *, struct ib_device_attr *props);
-int ocrdma_query_port(struct ib_device *, u8 port, struct ib_port_attr *props);
-int ocrdma_modify_port(struct ib_device *, u8 port, int mask,
-                       struct ib_port_modify *props);
-
-void ocrdma_get_guid(struct ocrdma_dev *, u8 *guid);
-int ocrdma_query_gid(struct ib_device *, u8 port,
-                     int index, union ib_gid *gid);
-int ocrdma_query_pkey(struct ib_device *, u8 port, u16 index, u16 *pkey);
-
-struct ib_ucontext *ocrdma_alloc_ucontext(struct ib_device *,
-                                          struct ib_udata *);
-int ocrdma_dealloc_ucontext(struct ib_ucontext *);
-
-int ocrdma_mmap(struct ib_ucontext *, struct vm_area_struct *vma);
-
-struct ib_pd *ocrdma_alloc_pd(struct ib_device *,
-                              struct ib_ucontext *, struct ib_udata *);
-int ocrdma_dealloc_pd(struct ib_pd *pd);
-
-struct ib_cq *ocrdma_create_cq(struct ib_device *, int entries, int vector,
-                               struct ib_ucontext *, struct ib_udata *);
-int ocrdma_resize_cq(struct ib_cq *, int cqe, struct ib_udata *);
-int ocrdma_destroy_cq(struct ib_cq *);
-
-struct ib_qp *ocrdma_create_qp(struct ib_pd *,
-                               struct ib_qp_init_attr *attrs,
-                               struct ib_udata *);
-int _ocrdma_modify_qp(struct ib_qp *, struct ib_qp_attr *attr,
-                      int attr_mask);
-int ocrdma_modify_qp(struct ib_qp *, struct ib_qp_attr *attr,
-                     int attr_mask, struct ib_udata *udata);
-int ocrdma_query_qp(struct ib_qp *,
-                    struct ib_qp_attr *qp_attr,
-                    int qp_attr_mask, struct ib_qp_init_attr *);
-int ocrdma_destroy_qp(struct ib_qp *);
-
-struct ib_srq *ocrdma_create_srq(struct ib_pd *, struct ib_srq_init_attr *,
-                                 struct ib_udata *);
-int ocrdma_modify_srq(struct ib_srq *, struct ib_srq_attr *,
-                      enum ib_srq_attr_mask, struct ib_udata *);
-int ocrdma_query_srq(struct ib_srq *, struct ib_srq_attr *);
-int ocrdma_destroy_srq(struct ib_srq *);
-int ocrdma_post_srq_recv(struct ib_srq *, struct ib_recv_wr *,
-                         struct ib_recv_wr **bad_recv_wr);
-
-int ocrdma_dereg_mr(struct ib_mr *);
-struct ib_mr *ocrdma_get_dma_mr(struct ib_pd *, int acc);
-struct ib_mr *ocrdma_reg_kernel_mr(struct ib_pd *,
-                                   struct ib_phys_buf *buffer_list,
-                                   int num_phys_buf, int acc, u64 *iova_start);
-struct ib_mr *ocrdma_reg_user_mr(struct ib_pd *, u64 start, u64 length,
-                                 u64 virt, int acc, struct ib_udata *);
-
-#endif                          /* __OCRDMA_VERBS_H__ */
diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h
index 4d11575c201..c9624ea8720 100644
--- a/drivers/infiniband/hw/qib/qib.h
+++ b/drivers/infiniband/hw/qib/qib.h
@@ -1,8 +1,8 @@
 #ifndef _QIB_KERNEL_H
 #define _QIB_KERNEL_H
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -87,7 +87,7 @@ struct qlogic_ib_stats {
 };
 
 extern struct qlogic_ib_stats qib_stats;
-extern const struct pci_error_handlers qib_pci_err_handler;
+extern struct pci_error_handlers qib_pci_err_handler;
 extern struct pci_driver qib_driver;
 
 #define QIB_CHIP_SWVERSION QIB_CHIP_VERS_MAJ
@@ -171,9 +171,7 @@ struct qib_ctxtdata {
         /* how many alloc_pages() chunks in rcvegrbuf_pages */
         u32 rcvegrbuf_chunks;
         /* how many egrbufs per chunk */
-        u16 rcvegrbufs_perchunk;
-        /* ilog2 of above */
-        u16 rcvegrbufs_perchunk_shift;
+        u32 rcvegrbufs_perchunk;
         /* order for rcvegrbuf_pages */
         size_t rcvegrbuf_size;
         /* rcvhdrq size (for freeing) */
@@ -223,9 +221,6 @@ struct qib_ctxtdata {
         /* ctxt rcvhdrq head offset */
         u32 head;
         u32 pkt_count;
-        /* lookaside fields */
-        struct qib_qp *lookaside_qp;
-        u32 lookaside_qpn;
         /* QPs waiting for context processing */
         struct list_head qp_wait_list;
 };
@@ -427,14 +422,6 @@ struct qib_verbs_txreq {
 /* how often we check for packet activity for "power on hours (in seconds) */
 #define ACTIVITY_TIMER 5
 
-#define MAX_NAME_SIZE 64
-struct qib_msix_entry {
-        struct msix_entry msix;
-        void *arg;
-        char name[MAX_NAME_SIZE];
-        cpumask_var_t mask;
-};
-
 /* Below is an opaque struct. Each chip (device) can maintain
  * private data needed for its operation, but not germane to the
  * rest of the driver.  For convenience, we define another that
@@ -519,7 +506,6 @@ struct qib_pportdata {
         struct qib_devdata *dd;
         struct qib_chippport_specific *cpspec; /* chip-specific per-port */
         struct kobject pport_kobj;
-        struct kobject pport_cc_kobj;
         struct kobject sl2vl_kobj;
         struct kobject diagc_kobj;
 
@@ -531,6 +517,8 @@ struct qib_pportdata {
         /* qib_lflags driver is waiting for */
         u32 state_wanted;
         spinlock_t lflags_lock;
+        /* number of (port-specific) interrupts for this port -- saturates... */
+        u32 int_counter;
 
         /* ref count for each pkey */
         atomic_t pkeyrefs[4];
@@ -542,27 +530,24 @@ struct qib_pportdata {
         u64 *statusp;
 
         /* SendDMA related entries */
-
-        /* read mostly */
-        struct qib_sdma_desc *sdma_descq;
-        struct workqueue_struct *qib_wq;
+        spinlock_t            sdma_lock;
         struct qib_sdma_state sdma_state;
-        dma_addr_t       sdma_descq_phys;
-        volatile __le64 *sdma_head_dma; /* DMA'ed by chip */
-        dma_addr_t       sdma_head_phys;
-        u16                   sdma_descq_cnt;
-
-        /* read/write using lock */
-        spinlock_t            sdma_lock ____cacheline_aligned_in_smp;
-        struct list_head      sdma_activelist;
+        unsigned long         sdma_buf_jiffies;
+        struct qib_sdma_desc *sdma_descq;
         u64                   sdma_descq_added;
         u64                   sdma_descq_removed;
+        u16                   sdma_descq_cnt;
         u16                   sdma_descq_tail;
         u16                   sdma_descq_head;
+        u16                   sdma_next_intr;
+        u16                   sdma_reset_wait;
         u8                    sdma_generation;
+        struct tasklet_struct sdma_sw_clean_up_task;
+        struct list_head      sdma_activelist;
 
-        struct tasklet_struct sdma_sw_clean_up_task
-                ____cacheline_aligned_in_smp;
+        dma_addr_t       sdma_descq_phys;
+        volatile __le64 *sdma_head_dma; /* DMA'ed by chip */
+        dma_addr_t       sdma_head_phys;
 
         wait_queue_head_t state_wait; /* for state_wanted */
 
@@ -639,39 +624,6 @@ struct qib_pportdata {
         struct timer_list led_override_timer;
         struct xmit_wait cong_stats;
         struct timer_list symerr_clear_timer;
-
-        /* Synchronize access between driver writes and sysfs reads */
-        spinlock_t cc_shadow_lock
-                ____cacheline_aligned_in_smp;
-
-        /* Shadow copy of the congestion control table */
-        struct cc_table_shadow *ccti_entries_shadow;
-
-        /* Shadow copy of the congestion control entries */
-        struct ib_cc_congestion_setting_attr_shadow *congestion_entries_shadow;
-
-        /* List of congestion control table entries */
-        struct ib_cc_table_entry_shadow *ccti_entries;
-
-        /* 16 congestion entries with each entry corresponding to a SL */
-        struct ib_cc_congestion_entry_shadow *congestion_entries;
-
-        /* Maximum number of congestion control entries that the agent expects
-         * the manager to send.
-         */
-        u16 cc_supported_table_entries;
-
-        /* Total number of congestion control table entries */
-        u16 total_cct_entry;
-
-        /* Bit map identifying service level */
-        u16 cc_sl_control_map;
-
-        /* maximum congestion control table index */
-        u16 ccti_limit;
-
-        /* CA's max number of 64 entry units in the congestion control table */
-        u8 cc_max_table_entries;
 };
 
 /* Observers. Not to be taken lightly, possibly not to ship. */
@@ -855,10 +807,6 @@ struct qib_devdata {
          * supports, less gives more pio bufs/ctxt, etc.
          */
         u32 cfgctxts;
-        /*
-         * number of ctxts available for PSM open
-         */
-        u32 freectxts;
 
         /*
          * hint that we should update pioavailshadow before
@@ -908,14 +856,7 @@ struct qib_devdata {
          * pio_writing.
          */
         spinlock_t pioavail_lock;
-        /*
-         * index of last buffer to optimize search for next
-         */
-        u32 last_pio;
-        /*
-         * min kernel pio buffer to optimize search
-         */
-        u32 min_kernel_pio;
+
         /*
          * Shadow copies of registers; size indicates read access size.
          * Most of them are readonly, but some are write-only register,
@@ -995,9 +936,7 @@ struct qib_devdata {
         /* chip address space used by 4k pio buffers */
         u32 align4k;
         /* size of each rcvegrbuffer */
-        u16 rcvegrbufsize;
-        /* log2 of above */
-        u16 rcvegrbufsize_shift;
+        u32 rcvegrbufsize;
         /* localbus width (1, 2,4,8,16,32) from config space  */
         u32 lbus_width;
         /* localbus speed in MHz */
@@ -1112,7 +1051,6 @@ extern u32 qib_cpulist_count;
 extern unsigned long *qib_cpulist;
 
 extern unsigned qib_wc_pat;
-extern unsigned qib_cc_table_size;
 int qib_init(struct qib_devdata *, int);
 int init_chip_wc_pat(struct qib_devdata *dd, u32);
 int qib_enable_wc(struct qib_devdata *dd);
@@ -1303,11 +1241,6 @@ int qib_sdma_verbs_send(struct qib_pportdata *, struct qib_sge_state *,
 /* ppd->sdma_lock should be locked before calling this. */
 int qib_sdma_make_progress(struct qib_pportdata *dd);
 
-static inline int qib_sdma_empty(const struct qib_pportdata *ppd)
-{
-        return ppd->sdma_descq_added == ppd->sdma_descq_removed;
-}
-
 /* must be called under qib_sdma_lock */
 static inline u16 qib_sdma_descq_freecnt(const struct qib_pportdata *ppd)
 {
@@ -1411,7 +1344,7 @@ int qib_pcie_init(struct pci_dev *, const struct pci_device_id *);
 int qib_pcie_ddinit(struct qib_devdata *, struct pci_dev *,
                     const struct pci_device_id *);
 void qib_pcie_ddcleanup(struct qib_devdata *);
-int qib_pcie_params(struct qib_devdata *, u32, u32 *, struct qib_msix_entry *);
+int qib_pcie_params(struct qib_devdata *, u32, u32 *, struct msix_entry *);
 int qib_reinit_intr(struct qib_devdata *);
 void qib_enable_intx(struct pci_dev *);
 void qib_nomsi(struct qib_devdata *);
diff --git a/drivers/infiniband/hw/qib/qib_7220.h b/drivers/infiniband/hw/qib/qib_7220.h
index a5356cb4252..21f374aa063 100644
--- a/drivers/infiniband/hw/qib/qib_7220.h
+++ b/drivers/infiniband/hw/qib/qib_7220.h
@@ -97,7 +97,7 @@ struct qib_chippport_specific {
         u64 iblnkerrsnap;
         u64 ibcctrl; /* kr_ibcctrl shadow */
         u64 ibcddrctrl; /* kr_ibcddrctrl shadow */
-        unsigned long chase_end;
+        u64 chase_end;
         u32 last_delay_mult;
 };
 
diff --git a/drivers/infiniband/hw/qib/qib_common.h b/drivers/infiniband/hw/qib/qib_common.h
index d39e0183ff8..145da404088 100644
--- a/drivers/infiniband/hw/qib/qib_common.h
+++ b/drivers/infiniband/hw/qib/qib_common.h
@@ -285,6 +285,7 @@ struct qib_base_info {
 
 #ifndef QIB_KERN_TYPE
 #define QIB_KERN_TYPE 0
+#define QIB_IDSTR "QLogic kernel.org driver"
 #endif
 
 /*
@@ -301,19 +302,6 @@ struct qib_base_info {
 #define QIB_KERN_SWVERSION ((QIB_KERN_TYPE << 31) | QIB_USER_SWVERSION)
 
 /*
- * Define the driver version number.  This is something that refers only
- * to the driver itself, not the software interfaces it supports.
- */
-#define QIB_DRIVER_VERSION_BASE "1.11"
-
-/* create the final driver version string */
-#ifdef QIB_IDSTR
-#define QIB_DRIVER_VERSION QIB_DRIVER_VERSION_BASE " " QIB_IDSTR
-#else
-#define QIB_DRIVER_VERSION QIB_DRIVER_VERSION_BASE
-#endif
-
-/*
  * If the unit is specified via open, HCA choice is fixed.  If port is
  * specified, it's also fixed.  Otherwise we try to spread contexts
  * across ports and HCAs, using different algorithims.  WITHIN is
diff --git a/drivers/infiniband/hw/qib/qib_diag.c b/drivers/infiniband/hw/qib/qib_diag.c
index 1686fd4bda8..204c4dd9dce 100644
--- a/drivers/infiniband/hw/qib/qib_diag.c
+++ b/drivers/infiniband/hw/qib/qib_diag.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2010 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -46,16 +46,12 @@
 #include <linux/pci.h>
 #include <linux/poll.h>
 #include <linux/vmalloc.h>
-#include <linux/export.h>
 #include <linux/fs.h>
 #include <linux/uaccess.h>
 
 #include "qib.h"
 #include "qib_common.h"
 
-#undef pr_fmt
-#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
-
 /*
  * Each client that opens the diag device must read then write
  * offset 0, to prevent lossage from random cat or od. diag_state
@@ -601,8 +597,8 @@ static ssize_t qib_diagpkt_write(struct file *fp,
         }
         tmpbuf = vmalloc(plen);
         if (!tmpbuf) {
-                qib_devinfo(dd->pcidev,
-                        "Unable to allocate tmp buffer, failing\n");
+                qib_devinfo(dd->pcidev, "Unable to allocate tmp buffer, "
+                         "failing\n");
                 ret = -ENOMEM;
                 goto bail;
         }
@@ -696,7 +692,7 @@ int qib_register_observer(struct qib_devdata *dd,
         ret = -ENOMEM;
         olp = vmalloc(sizeof *olp);
         if (!olp) {
-                pr_err("vmalloc for observer failed\n");
+                printk(KERN_ERR QIB_DRV_NAME ": vmalloc for observer failed\n");
                 goto bail;
         }
         if (olp) {
diff --git a/drivers/infiniband/hw/qib/qib_driver.c b/drivers/infiniband/hw/qib/qib_driver.c
index 5423edcab51..23e584f4c36 100644
--- a/drivers/infiniband/hw/qib/qib_driver.c
+++ b/drivers/infiniband/hw/qib/qib_driver.c
@@ -37,8 +37,6 @@
 #include <linux/delay.h>
 #include <linux/netdevice.h>
 #include <linux/vmalloc.h>
-#include <linux/module.h>
-#include <linux/prefetch.h>
 
 #include "qib.h"
 
@@ -46,7 +44,7 @@
  * The size has to be longer than this string, so we can append
  * board/chip information to it in the init code.
  */
-const char ib_qib_version[] = QIB_DRIVER_VERSION "\n";
+const char ib_qib_version[] = QIB_IDSTR "\n";
 
 DEFINE_SPINLOCK(qib_devs_lock);
 LIST_HEAD(qib_dev_list);
@@ -65,7 +63,6 @@ MODULE_PARM_DESC(compat_ddr_negotiate,
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("QLogic <support@qlogic.com>");
 MODULE_DESCRIPTION("QLogic IB driver");
-MODULE_VERSION(QIB_DRIVER_VERSION);
 
 /*
  * QIB_PIO_MAXIBHDR is the max IB header size allowed for in our
@@ -282,10 +279,10 @@ bail:
  */
 static inline void *qib_get_egrbuf(const struct qib_ctxtdata *rcd, u32 etail)
 {
-        const u32 chunk = etail >> rcd->rcvegrbufs_perchunk_shift;
-        const u32 idx =  etail & ((u32)rcd->rcvegrbufs_perchunk - 1);
+        const u32 chunk = etail / rcd->rcvegrbufs_perchunk;
+        const u32 idx =  etail % rcd->rcvegrbufs_perchunk;
 
-        return rcd->rcvegrbuf[chunk] + (idx << rcd->dd->rcvegrbufsize_shift);
+        return rcd->rcvegrbuf[chunk] + idx * rcd->dd->rcvegrbufsize;
 }
 
 /*
@@ -313,6 +310,7 @@ static u32 qib_rcv_hdrerr(struct qib_ctxtdata *rcd, struct qib_pportdata *ppd,
                 u32 opcode;
                 u32 psn;
                 int diff;
+                unsigned long flags;
 
                 /* Sanity check packet */
                 if (tlen < 24)
@@ -367,14 +365,19 @@ static u32 qib_rcv_hdrerr(struct qib_ctxtdata *rcd, struct qib_pportdata *ppd,
 
                         switch (qp->ibqp.qp_type) {
                         case IB_QPT_RC:
+                                spin_lock_irqsave(&qp->s_lock, flags);
                                 ruc_res =
                                         qib_ruc_check_hdr(
                                                 ibp, hdr,
                                                 lnh == QIB_LRH_GRH,
                                                 qp,
                                                 be32_to_cpu(ohdr->bth[0]));
-                                if (ruc_res)
+                                if (ruc_res) {
+                                        spin_unlock_irqrestore(&qp->s_lock,
+                                                               flags);
                                         goto unlock;
+                                }
+                                spin_unlock_irqrestore(&qp->s_lock, flags);
 
                                 /* Only deal with RDMA Writes for now */
                                 if (opcode <
@@ -483,10 +486,8 @@ u32 qib_kreceive(struct qib_ctxtdata *rcd, u32 *llic, u32 *npkts)
                         etail = qib_hdrget_index(rhf_addr);
                         updegr = 1;
                         if (tlen > sizeof(*hdr) ||
-                            etype >= RCVHQ_RCV_TYPE_NON_KD) {
+                            etype >= RCVHQ_RCV_TYPE_NON_KD)
                                 ebuf = qib_get_egrbuf(rcd, etail);
-                                prefetch_range(ebuf, tlen - sizeof(*hdr));
-                        }
                 }
                 if (!eflags) {
                         u16 lrh_len = be16_to_cpu(hdr->lrh[2]) << 2;
@@ -546,15 +547,6 @@ move_along:
                         updegr = 0;
                 }
         }
-        /*
-         * Notify qib_destroy_qp() if it is waiting
-         * for lookaside_qp to finish.
-         */
-        if (rcd->lookaside_qp) {
-                if (atomic_dec_and_test(&rcd->lookaside_qp->refcount))
-                        wake_up(&rcd->lookaside_qp->wait);
-                rcd->lookaside_qp = NULL;
-        }
 
         rcd->head = l;
         rcd->pkt_count += i;
@@ -765,9 +757,8 @@ int qib_reset_device(int unit)
         qib_devinfo(dd->pcidev, "Reset on unit %u requested\n", unit);
 
         if (!dd->kregbase || !(dd->flags & QIB_PRESENT)) {
-                qib_devinfo(dd->pcidev,
-                        "Invalid unit number %u or not initialized or not present\n",
-                        unit);
+                qib_devinfo(dd->pcidev, "Invalid unit number %u or "
+                            "not initialized or not present\n", unit);
                 ret = -ENXIO;
                 goto bail;
         }
@@ -804,13 +795,11 @@ int qib_reset_device(int unit)
         else
                 ret = -EAGAIN;
         if (ret)
-                qib_dev_err(dd,
-                        "Reinitialize unit %u after reset failed with %d\n",
-                        unit, ret);
+                qib_dev_err(dd, "Reinitialize unit %u after "
+                            "reset failed with %d\n", unit, ret);
         else
-                qib_devinfo(dd->pcidev,
-                        "Reinitialized unit %u after resetting\n",
-                        unit);
+                qib_devinfo(dd->pcidev, "Reinitialized unit %u after "
+                            "resetting\n", unit);
 
 bail:
         return ret;
diff --git a/drivers/infiniband/hw/qib/qib_eeprom.c b/drivers/infiniband/hw/qib/qib_eeprom.c
index 4d5d71aaa2b..92d9cfe98a6 100644
--- a/drivers/infiniband/hw/qib/qib_eeprom.c
+++ b/drivers/infiniband/hw/qib/qib_eeprom.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -161,9 +160,10 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
                 if (oguid > bguid[7]) {
                         if (bguid[6] == 0xff) {
                                 if (bguid[5] == 0xff) {
-                                        qib_dev_err(dd,
-                                                "Can't set %s GUID from base, wraps to OUI!\n",
-                                                qib_get_unit_name(t));
+                                        qib_dev_err(dd, "Can't set %s GUID"
+                                                    " from base, wraps to"
+                                                    " OUI!\n",
+                                                    qib_get_unit_name(t));
                                         dd->base_guid = 0;
                                         goto bail;
                                 }
@@ -182,9 +182,8 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
         len = sizeof(struct qib_flash);
         buf = vmalloc(len);
         if (!buf) {
-                qib_dev_err(dd,
-                        "Couldn't allocate memory to read %u bytes from eeprom for GUID\n",
-                        len);
+                qib_dev_err(dd, "Couldn't allocate memory to read %u "
+                            "bytes from eeprom for GUID\n", len);
                 goto bail;
         }
 
@@ -202,25 +201,23 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
 
         csum = flash_csum(ifp, 0);
         if (csum != ifp->if_csum) {
-                qib_devinfo(dd->pcidev,
-                        "Bad I2C flash checksum: 0x%x, not 0x%x\n",
-                        csum, ifp->if_csum);
+                qib_devinfo(dd->pcidev, "Bad I2C flash checksum: "
+                         "0x%x, not 0x%x\n", csum, ifp->if_csum);
                 goto done;
         }
         if (*(__be64 *) ifp->if_guid == cpu_to_be64(0) ||
             *(__be64 *) ifp->if_guid == ~cpu_to_be64(0)) {
-                qib_dev_err(dd,
-                        "Invalid GUID %llx from flash; ignoring\n",
-                        *(unsigned long long *) ifp->if_guid);
+                qib_dev_err(dd, "Invalid GUID %llx from flash; ignoring\n",
+                            *(unsigned long long *) ifp->if_guid);
                 /* don't allow GUID if all 0 or all 1's */
                 goto done;
         }
 
         /* complain, but allow it */
         if (*(u64 *) ifp->if_guid == 0x100007511000000ULL)
-                qib_devinfo(dd->pcidev,
-                        "Warning, GUID %llx is default, probably not correct!\n",
-                        *(unsigned long long *) ifp->if_guid);
+                qib_devinfo(dd->pcidev, "Warning, GUID %llx is "
+                         "default, probably not correct!\n",
+                         *(unsigned long long *) ifp->if_guid);
 
         bguid = ifp->if_guid;
         if (!bguid[0] && !bguid[1] && !bguid[2]) {
@@ -263,9 +260,8 @@ void qib_get_eeprom_info(struct qib_devdata *dd)
                 memcpy(dd->serial, ifp->if_serial,
                        sizeof ifp->if_serial);
         if (!strstr(ifp->if_comment, "Tested successfully"))
-                qib_dev_err(dd,
-                        "Board SN %s did not pass functional test: %s\n",
-                        dd->serial, ifp->if_comment);
+                qib_dev_err(dd, "Board SN %s did not pass functional "
+                            "test: %s\n", dd->serial, ifp->if_comment);
 
         memcpy(&dd->eep_st_errs, &ifp->if_errcntp, QIB_EEP_LOG_CNT);
         /*
@@ -327,9 +323,8 @@ int qib_update_eeprom_log(struct qib_devdata *dd)
         buf = vmalloc(len);
         ret = 1;
         if (!buf) {
-                qib_dev_err(dd,
-                        "Couldn't allocate memory to read %u bytes from eeprom for logging\n",
-                        len);
+                qib_dev_err(dd, "Couldn't allocate memory to read %u "
+                            "bytes from eeprom for logging\n", len);
                 goto bail;
         }
 
diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c
index 959a5c4ff81..26253039d2c 100644
--- a/drivers/infiniband/hw/qib/qib_file_ops.c
+++ b/drivers/infiniband/hw/qib/qib_file_ops.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -43,15 +43,11 @@
 #include <linux/jiffies.h>
 #include <asm/pgtable.h>
 #include <linux/delay.h>
-#include <linux/export.h>
 
 #include "qib.h"
 #include "qib_common.h"
 #include "qib_user_sdma.h"
 
-#undef pr_fmt
-#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
-
 static int qib_open(struct inode *, struct file *);
 static int qib_close(struct inode *, struct file *);
 static ssize_t qib_write(struct file *, const char __user *, size_t, loff_t *);
@@ -318,9 +314,8 @@ static int qib_tid_update(struct qib_ctxtdata *rcd, struct file *fp,
         }
         if (cnt > tidcnt) {
                 /* make sure it all fits in tid_pg_list */
-                qib_devinfo(dd->pcidev,
-                        "Process tried to allocate %u TIDs, only trying max (%u)\n",
-                        cnt, tidcnt);
+                qib_devinfo(dd->pcidev, "Process tried to allocate %u "
+                         "TIDs, only trying max (%u)\n", cnt, tidcnt);
                 cnt = tidcnt;
         }
         pagep = (struct page **) rcd->tid_pg_list;
@@ -754,9 +749,9 @@ static int qib_mmap_mem(struct vm_area_struct *vma, struct qib_ctxtdata *rcd,
         ret = remap_pfn_range(vma, vma->vm_start, pfn,
                               len, vma->vm_page_prot);
         if (ret)
-                qib_devinfo(dd->pcidev,
-                        "%s ctxt%u mmap of %lx, %x bytes failed: %d\n",
-                        what, rcd->ctxt, pfn, len, ret);
+                qib_devinfo(dd->pcidev, "%s ctxt%u mmap of %lx, %x "
+                         "bytes failed: %d\n", what, rcd->ctxt,
+                         pfn, len, ret);
 bail:
         return ret;
 }
@@ -775,9 +770,8 @@ static int mmap_ureg(struct vm_area_struct *vma, struct qib_devdata *dd,
          */
         sz = dd->flags & QIB_HAS_HDRSUPP ? 2 * PAGE_SIZE : PAGE_SIZE;
         if ((vma->vm_end - vma->vm_start) > sz) {
-                qib_devinfo(dd->pcidev,
-                        "FAIL mmap userreg: reqlen %lx > PAGE\n",
-                        vma->vm_end - vma->vm_start);
+                qib_devinfo(dd->pcidev, "FAIL mmap userreg: reqlen "
+                         "%lx > PAGE\n", vma->vm_end - vma->vm_start);
                 ret = -EFAULT;
         } else {
                 phys = dd->physaddr + ureg;
@@ -807,8 +801,8 @@ static int mmap_piobufs(struct vm_area_struct *vma,
          * for it.
          */
         if ((vma->vm_end - vma->vm_start) > (piocnt * dd->palign)) {
-                qib_devinfo(dd->pcidev,
-                        "FAIL mmap piobufs: reqlen %lx > PAGE\n",
+                qib_devinfo(dd->pcidev, "FAIL mmap piobufs: "
+                         "reqlen %lx > PAGE\n",
                          vma->vm_end - vma->vm_start);
                 ret = -EINVAL;
                 goto bail;
@@ -852,8 +846,8 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
         size = rcd->rcvegrbuf_size;
         total_size = rcd->rcvegrbuf_chunks * size;
         if ((vma->vm_end - vma->vm_start) > total_size) {
-                qib_devinfo(dd->pcidev,
-                        "FAIL on egr bufs: reqlen %lx > actual %lx\n",
+                qib_devinfo(dd->pcidev, "FAIL on egr bufs: "
+                         "reqlen %lx > actual %lx\n",
                          vma->vm_end - vma->vm_start,
                          (unsigned long) total_size);
                 ret = -EINVAL;
@@ -861,9 +855,8 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
         }
 
         if (vma->vm_flags & VM_WRITE) {
-                qib_devinfo(dd->pcidev,
-                        "Can't map eager buffers as writable (flags=%lx)\n",
-                        vma->vm_flags);
+                qib_devinfo(dd->pcidev, "Can't map eager buffers as "
+                         "writable (flags=%lx)\n", vma->vm_flags);
                 ret = -EPERM;
                 goto bail;
         }
@@ -971,7 +964,7 @@ static int mmap_kvaddr(struct vm_area_struct *vma, u64 pgaddr,
 
         vma->vm_pgoff = (unsigned long) addr >> PAGE_SHIFT;
         vma->vm_ops = &qib_file_vm_ops;
-        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= VM_RESERVED | VM_DONTEXPAND;
         ret = 1;
 
 bail:
@@ -1276,8 +1269,8 @@ static int setup_ctxt(struct qib_pportdata *ppd, int ctxt,
                                GFP_KERNEL);
 
         if (!rcd || !ptmp) {
-                qib_dev_err(dd,
-                        "Unable to allocate ctxtdata memory, failing open\n");
+                qib_dev_err(dd, "Unable to allocate ctxtdata "
+                            "memory, failing open\n");
                 ret = -ENOMEM;
                 goto bailerr;
         }
@@ -1291,7 +1284,6 @@ static int setup_ctxt(struct qib_pportdata *ppd, int ctxt,
         strlcpy(rcd->comm, current->comm, sizeof(rcd->comm));
         ctxt_fp(fp) = rcd;
         qib_stats.sps_ctxts++;
-        dd->freectxts--;
         ret = 0;
         goto bail;
 
@@ -1566,10 +1558,10 @@ done_chk_sdma:
                 } else if (weight == 1 &&
                         test_bit(cpumask_first(tsk_cpus_allowed(current)),
                                  qib_cpulist))
-                        qib_devinfo(dd->pcidev,
-                                "%s PID %u affinity set to cpu %d; already allocated\n",
-                                current->comm, current->pid,
-                                cpumask_first(tsk_cpus_allowed(current)));
+                        qib_devinfo(dd->pcidev, "%s PID %u affinity "
+                                    "set to cpu %d; already allocated\n",
+                                    current->comm, current->pid,
+                                    cpumask_first(tsk_cpus_allowed(current)));
         }
 
         mutex_unlock(&qib_mutex);
@@ -1800,7 +1792,6 @@ static int qib_close(struct inode *in, struct file *fp)
                 if (dd->pageshadow)
                         unlock_expected_tids(rcd);
                 qib_stats.sps_ctxts--;
-                dd->freectxts++;
         }
 
         mutex_unlock(&qib_mutex);
@@ -2191,7 +2182,8 @@ int qib_cdev_init(int minor, const char *name,
 
         cdev = cdev_alloc();
         if (!cdev) {
-                pr_err("Could not allocate cdev for minor %d, %s\n",
+                printk(KERN_ERR QIB_DRV_NAME
+                       ": Could not allocate cdev for minor %d, %s\n",
                        minor, name);
                 ret = -ENOMEM;
                 goto done;
@@ -2203,7 +2195,8 @@ int qib_cdev_init(int minor, const char *name,
 
         ret = cdev_add(cdev, dev, 1);
         if (ret < 0) {
-                pr_err("Could not add cdev for minor %d, %s (err %d)\n",
+                printk(KERN_ERR QIB_DRV_NAME
+                       ": Could not add cdev for minor %d, %s (err %d)\n",
                        minor, name, -ret);
                 goto err_cdev;
         }
@@ -2213,7 +2206,8 @@ int qib_cdev_init(int minor, const char *name,
                 goto done;
         ret = PTR_ERR(device);
         device = NULL;
-        pr_err("Could not create device for minor %d, %s (err %d)\n",
+        printk(KERN_ERR QIB_DRV_NAME ": Could not create "
+               "device for minor %d, %s (err %d)\n",
                minor, name, -ret);
 err_cdev:
         cdev_del(cdev);
@@ -2248,14 +2242,16 @@ int __init qib_dev_init(void)
 
         ret = alloc_chrdev_region(&qib_dev, 0, QIB_NMINORS, QIB_DRV_NAME);
         if (ret < 0) {
-                pr_err("Could not allocate chrdev region (err %d)\n", -ret);
+                printk(KERN_ERR QIB_DRV_NAME ": Could not allocate "
+                       "chrdev region (err %d)\n", -ret);
                 goto done;
         }
 
         qib_class = class_create(THIS_MODULE, "ipath");
         if (IS_ERR(qib_class)) {
                 ret = PTR_ERR(qib_class);
-                pr_err("Could not create device class (err %d)\n", -ret);
+                printk(KERN_ERR QIB_DRV_NAME ": Could not create "
+                       "device class (err %d)\n", -ret);
                 unregister_chrdev_region(qib_dev, QIB_NMINORS);
         }
 
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 65a2a23f6f8..df7fa251dcd 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -48,7 +47,7 @@ static struct super_block *qib_super;
 #define private2dd(file) ((file)->f_dentry->d_inode->i_private)
 
 static int qibfs_mknod(struct inode *dir, struct dentry *dentry,
-                       umode_t mode, const struct file_operations *fops,
+                       int mode, const struct file_operations *fops,
                        void *data)
 {
         int error;
@@ -61,14 +60,14 @@ static int qibfs_mknod(struct inode *dir, struct dentry *dentry,
 
         inode->i_ino = get_next_ino();
         inode->i_mode = mode;
-        inode->i_uid = GLOBAL_ROOT_UID;
-        inode->i_gid = GLOBAL_ROOT_GID;
+        inode->i_uid = 0;
+        inode->i_gid = 0;
         inode->i_blocks = 0;
         inode->i_atime = CURRENT_TIME;
         inode->i_mtime = inode->i_atime;
         inode->i_ctime = inode->i_atime;
         inode->i_private = data;
-        if (S_ISDIR(mode)) {
+        if ((mode & S_IFMT) == S_IFDIR) {
                 inode->i_op = &simple_dir_inode_operations;
                 inc_nlink(inode);
                 inc_nlink(dir);
@@ -83,7 +82,7 @@ bail:
         return error;
 }
 
-static int create_file(const char *name, umode_t mode,
+static int create_file(const char *name, mode_t mode,
                        struct dentry *parent, struct dentry **dentry,
                        const struct file_operations *fops, void *data)
 {
@@ -383,7 +382,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
         ret = create_file(unit, S_IFDIR|S_IRUGO|S_IXUGO, sb->s_root, &dir,
                           &simple_dir_operations, dd);
         if (ret) {
-                pr_err("create_file(%s) failed: %d\n", unit, ret);
+                printk(KERN_ERR "create_file(%s) failed: %d\n", unit, ret);
                 goto bail;
         }
 
@@ -391,21 +390,21 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
         ret = create_file("counters", S_IFREG|S_IRUGO, dir, &tmp,
                           &cntr_ops[0], dd);
         if (ret) {
-                pr_err("create_file(%s/counters) failed: %d\n",
+                printk(KERN_ERR "create_file(%s/counters) failed: %d\n",
                        unit, ret);
                 goto bail;
         }
         ret = create_file("counter_names", S_IFREG|S_IRUGO, dir, &tmp,
                           &cntr_ops[1], dd);
         if (ret) {
-                pr_err("create_file(%s/counter_names) failed: %d\n",
+                printk(KERN_ERR "create_file(%s/counter_names) failed: %d\n",
                        unit, ret);
                 goto bail;
         }
         ret = create_file("portcounter_names", S_IFREG|S_IRUGO, dir, &tmp,
                           &portcntr_ops[0], dd);
         if (ret) {
-                pr_err("create_file(%s/%s) failed: %d\n",
+                printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
                        unit, "portcounter_names", ret);
                 goto bail;
         }
@@ -417,7 +416,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
                 ret = create_file(fname, S_IFREG|S_IRUGO, dir, &tmp,
                                   &portcntr_ops[i], dd);
                 if (ret) {
-                        pr_err("create_file(%s/%s) failed: %d\n",
+                        printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
                                 unit, fname, ret);
                         goto bail;
                 }
@@ -427,7 +426,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
                 ret = create_file(fname, S_IFREG|S_IRUGO, dir, &tmp,
                                   &qsfp_ops[i - 1], dd);
                 if (ret) {
-                        pr_err("create_file(%s/%s) failed: %d\n",
+                        printk(KERN_ERR "create_file(%s/%s) failed: %d\n",
                                 unit, fname, ret);
                         goto bail;
                 }
@@ -436,7 +435,7 @@ static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
         ret = create_file("flash", S_IFREG|S_IWUSR|S_IRUGO, dir, &tmp,
                           &flash_ops, dd);
         if (ret)
-                pr_err("create_file(%s/flash) failed: %d\n",
+                printk(KERN_ERR "create_file(%s/flash) failed: %d\n",
                         unit, ret);
 bail:
         return ret;
@@ -487,7 +486,7 @@ static int remove_device_files(struct super_block *sb,
 
         if (IS_ERR(dir)) {
                 ret = PTR_ERR(dir);
-                pr_err("Lookup of %s failed\n", unit);
+                printk(KERN_ERR "Lookup of %s failed\n", unit);
                 goto bail;
         }
 
@@ -533,7 +532,7 @@ static int qibfs_fill_super(struct super_block *sb, void *data, int silent)
 
         ret = simple_fill_super(sb, QIBFS_MAGIC, files);
         if (ret) {
-                pr_err("simple_fill_super failed: %d\n", ret);
+                printk(KERN_ERR "simple_fill_super failed: %d\n", ret);
                 goto bail;
         }
 
diff --git a/drivers/infiniband/hw/qib/qib_iba6120.c b/drivers/infiniband/hw/qib/qib_iba6120.c
index a099ac171e2..65df26ce538 100644
--- a/drivers/infiniband/hw/qib/qib_iba6120.c
+++ b/drivers/infiniband/hw/qib/qib_iba6120.c
@@ -753,8 +753,8 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
         if (!hwerrs)
                 return;
         if (hwerrs == ~0ULL) {
-                qib_dev_err(dd,
-                        "Read of hardware error status failed (all bits set); ignoring\n");
+                qib_dev_err(dd, "Read of hardware error status failed "
+                            "(all bits set); ignoring\n");
                 return;
         }
         qib_stats.sps_hwerrs++;
@@ -779,14 +779,13 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
          * or it's occurred within the last 5 seconds.
          */
         if (hwerrs & ~(TXE_PIO_PARITY | RXEMEMPARITYERR_EAGERTID))
-                qib_devinfo(dd->pcidev,
-                        "Hardware error: hwerr=0x%llx (cleared)\n",
-                        (unsigned long long) hwerrs);
+                qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
+                         "(cleared)\n", (unsigned long long) hwerrs);
 
         if (hwerrs & ~IB_HWE_BITSEXTANT)
-                qib_dev_err(dd,
-                        "hwerror interrupt with unknown errors %llx set\n",
-                        (unsigned long long)(hwerrs & ~IB_HWE_BITSEXTANT));
+                qib_dev_err(dd, "hwerror interrupt with unknown errors "
+                            "%llx set\n", (unsigned long long)
+                            (hwerrs & ~IB_HWE_BITSEXTANT));
 
         ctrl = qib_read_kreg32(dd, kr_control);
         if ((ctrl & QLOGIC_IB_C_FREEZEMODE) && !dd->diag_client) {
@@ -816,9 +815,8 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
 
         if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                 isfatal = 1;
-                strlcat(msg,
-                        "[Memory BIST test failed, InfiniPath hardware unusable]",
-                        msgl);
+                strlcat(msg, "[Memory BIST test failed, InfiniPath hardware"
+                        " unusable]", msgl);
                 /* ignore from now on, so disable until driver reloaded */
                 dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                 qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -870,9 +868,8 @@ static void qib_handle_6120_hwerrors(struct qib_devdata *dd, char *msg,
                 *msg = 0; /* recovered from all of them */
 
         if (isfatal && !dd->diag_client) {
-                qib_dev_err(dd,
-                        "Fatal Hardware Error, no longer usable, SN %.16s\n",
-                        dd->serial);
+                qib_dev_err(dd, "Fatal Hardware Error, no longer"
+                            " usable, SN %.16s\n", dd->serial);
                 /*
                  * for /sys status file and user programs to print; if no
                  * trailing brace is copied, we'll know it was truncated.
@@ -1020,9 +1017,9 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
                                 qib_inc_eeprom_err(dd, log_idx, 1);
 
         if (errs & ~IB_E_BITSEXTANT)
-                qib_dev_err(dd,
-                        "error interrupt with unknown errors %llx set\n",
-                        (unsigned long long) (errs & ~IB_E_BITSEXTANT));
+                qib_dev_err(dd, "error interrupt with unknown errors "
+                            "%llx set\n",
+                            (unsigned long long) (errs & ~IB_E_BITSEXTANT));
 
         if (errs & E_SUM_ERRS) {
                 qib_disarm_6120_senderrbufs(ppd);
@@ -1092,8 +1089,8 @@ static void handle_6120_errors(struct qib_devdata *dd, u64 errs)
         }
 
         if (errs & ERR_MASK(ResetNegated)) {
-                qib_dev_err(dd,
-                        "Got reset, requires re-init (unload and reload driver)\n");
+                qib_dev_err(dd, "Got reset, requires re-init "
+                              "(unload and reload driver)\n");
                 dd->flags &= ~QIB_INITTED;  /* needs re-init */
                 /* mark as having had error */
                 *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1544,9 +1541,8 @@ static noinline void unlikely_6120_intr(struct qib_devdata *dd, u64 istat)
                 qib_stats.sps_errints++;
                 estat = qib_read_kreg64(dd, kr_errstatus);
                 if (!estat)
-                        qib_devinfo(dd->pcidev,
-                                "error interrupt (%Lx), but no error bits set!\n",
-                                istat);
+                        qib_devinfo(dd->pcidev, "error interrupt (%Lx), "
+                                 "but no error bits set!\n", istat);
                 handle_6120_errors(dd, estat);
         }
 
@@ -1719,16 +1715,16 @@ static void qib_setup_6120_interrupt(struct qib_devdata *dd)
         }
 
         if (!dd->cspec->irq)
-                qib_dev_err(dd,
-                        "irq is 0, BIOS error?  Interrupts won't work\n");
+                qib_dev_err(dd, "irq is 0, BIOS error?  Interrupts won't "
+                            "work\n");
         else {
                 int ret;
                 ret = request_irq(dd->cspec->irq, qib_6120intr, 0,
                                   QIB_DRV_NAME, dd);
                 if (ret)
-                        qib_dev_err(dd,
-                                "Couldn't setup interrupt (irq=%d): %d\n",
-                                dd->cspec->irq, ret);
+                        qib_dev_err(dd, "Couldn't setup interrupt "
+                                    "(irq=%d): %d\n", dd->cspec->irq,
+                                    ret);
         }
 }
 
@@ -1763,9 +1759,8 @@ static void pe_boardname(struct qib_devdata *dd)
                 snprintf(dd->boardname, namelen, "%s", n);
 
         if (dd->majrev != 4 || !dd->minrev || dd->minrev > 2)
-                qib_dev_err(dd,
-                        "Unsupported InfiniPath hardware revision %u.%u!\n",
-                        dd->majrev, dd->minrev);
+                qib_dev_err(dd, "Unsupported InfiniPath hardware revision "
+                            "%u.%u!\n", dd->majrev, dd->minrev);
 
         snprintf(dd->boardversion, sizeof(dd->boardversion),
                  "ChipABI %u.%u, %s, InfiniPath%u %u.%u, SW Compat %u\n",
@@ -1838,8 +1833,8 @@ static int qib_6120_setup_reset(struct qib_devdata *dd)
 bail:
         if (ret) {
                 if (qib_pcie_params(dd, dd->lbus_width, NULL, NULL))
-                        qib_dev_err(dd,
-                                "Reset failed to setup PCIe or interrupts; continuing anyway\n");
+                        qib_dev_err(dd, "Reset failed to setup PCIe or "
+                                    "interrupts; continuing anyway\n");
                 /* clear the reset error, init error/hwerror mask */
                 qib_6120_init_hwerrors(dd);
                 /* for Rev2 error interrupts; nop for rev 1 */
@@ -1881,9 +1876,8 @@ static void qib_6120_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                 }
                 pa >>= 11;
                 if (pa & ~QLOGIC_IB_RT_ADDR_MASK) {
-                        qib_dev_err(dd,
-                                "Physical page address 0x%lx larger than supported\n",
-                                pa);
+                        qib_dev_err(dd, "Physical page address 0x%lx "
+                                    "larger than supported\n", pa);
                         return;
                 }
 
@@ -1947,9 +1941,8 @@ static void qib_6120_put_tid_2(struct qib_devdata *dd, u64 __iomem *tidptr,
                 }
                 pa >>= 11;
                 if (pa & ~QLOGIC_IB_RT_ADDR_MASK) {
-                        qib_dev_err(dd,
-                                "Physical page address 0x%lx larger than supported\n",
-                                pa);
+                        qib_dev_err(dd, "Physical page address 0x%lx "
+                                    "larger than supported\n", pa);
                         return;
                 }
 
@@ -2112,7 +2105,7 @@ static void alloc_dummy_hdrq(struct qib_devdata *dd)
         dd->cspec->dummy_hdrq = dma_alloc_coherent(&dd->pcidev->dev,
                                         dd->rcd[0]->rcvhdrq_size,
                                         &dd->cspec->dummy_hdrq_phys,
-                                        GFP_ATOMIC | __GFP_COMP);
+                                        GFP_KERNEL | __GFP_COMP);
         if (!dd->cspec->dummy_hdrq) {
                 qib_devinfo(dd->pcidev, "Couldn't allocate dummy hdrq\n");
                 /* fallback to just 0'ing */
@@ -2935,9 +2928,8 @@ static int qib_6120_set_loopback(struct qib_pportdata *ppd, const char *what)
                          ppd->dd->unit, ppd->port);
         } else if (!strncmp(what, "off", 3)) {
                 ppd->dd->cspec->ibcctrl &= ~SYM_MASK(IBCCtrl, Loopback);
-                qib_devinfo(ppd->dd->pcidev,
-                        "Disabling IB%u:%u IBC loopback (normal)\n",
-                        ppd->dd->unit, ppd->port);
+                qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
+                            "(normal)\n", ppd->dd->unit, ppd->port);
         } else
                 ret = -EINVAL;
         if (!ret) {
@@ -3140,7 +3132,6 @@ static void get_6120_chip_params(struct qib_devdata *dd)
         val = qib_read_kreg64(dd, kr_sendpiobufcnt);
         dd->piobcnt2k = val & ~0U;
         dd->piobcnt4k = val >> 32;
-        dd->last_pio = dd->piobcnt4k + dd->piobcnt2k - 1;
         /* these may be adjusted in init_chip_wc_pat() */
         dd->pio2kbase = (u32 __iomem *)
                 (((char __iomem *)dd->kregbase) + dd->pio2k_bufbase);
@@ -3194,10 +3185,11 @@ static int qib_late_6120_initreg(struct qib_devdata *dd)
         qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
         val = qib_read_kreg64(dd, kr_sendpioavailaddr);
         if (val != dd->pioavailregs_phys) {
-                qib_dev_err(dd,
-                        "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
-                        (unsigned long) dd->pioavailregs_phys,
-                        (unsigned long long) val);
+                qib_dev_err(dd, "Catastrophic software error, "
+                            "SendPIOAvailAddr written as %lx, "
+                            "read back as %llx\n",
+                            (unsigned long) dd->pioavailregs_phys,
+                            (unsigned long long) val);
                 ret = -EINVAL;
         }
         return ret;
@@ -3225,8 +3217,8 @@ static int init_6120_variables(struct qib_devdata *dd)
         dd->revision = readq(&dd->kregbase[kr_revision]);
 
         if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-                qib_dev_err(dd,
-                        "Revision register read failure, giving up initialization\n");
+                qib_dev_err(dd, "Revision register read failure, "
+                            "giving up initialization\n");
                 ret = -ENODEV;
                 goto bail;
         }
@@ -3283,8 +3275,6 @@ static int init_6120_variables(struct qib_devdata *dd)
         /* we always allocate at least 2048 bytes for eager buffers */
         ret = ib_mtu_enum_to_int(qib_ibmtu);
         dd->rcvegrbufsize = ret != -1 ? max(ret, 2048) : QIB_DEFAULT_MTU;
-        BUG_ON(!is_power_of_2(dd->rcvegrbufsize));
-        dd->rcvegrbufsize_shift = ilog2(dd->rcvegrbufsize);
 
         qib_6120_tidtemplate(dd);
 
@@ -3558,8 +3548,8 @@ struct qib_devdata *qib_init_iba6120_funcs(struct pci_dev *pdev,
                 goto bail;
 
         if (qib_pcie_params(dd, 8, NULL, NULL))
-                qib_dev_err(dd,
-                        "Failed to setup PCIe or interrupts; continuing anyway\n");
+                qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
+                            "continuing anyway\n");
         dd->cspec->irq = pdev->irq; /* save IRQ */
 
         /* clear diagctrl register, in case diags were running and crashed */
diff --git a/drivers/infiniband/hw/qib/qib_iba7220.c b/drivers/infiniband/hw/qib/qib_iba7220.c
index 64d0ecb90cd..4250c05a14f 100644
--- a/drivers/infiniband/hw/qib/qib_iba7220.c
+++ b/drivers/infiniband/hw/qib/qib_iba7220.c
@@ -39,7 +39,6 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
-#include <linux/module.h>
 #include <linux/io.h>
 #include <rdma/ib_verbs.h>
 
@@ -1051,7 +1050,7 @@ static void reenable_7220_chase(unsigned long opaque)
 static void handle_7220_chase(struct qib_pportdata *ppd, u64 ibcst)
 {
         u8 ibclt;
-        unsigned long tnow;
+        u64 tnow;
 
         ibclt = (u8)SYM_FIELD(ibcst, IBCStatus, LinkTrainingState);
 
@@ -1066,9 +1065,9 @@ static void handle_7220_chase(struct qib_pportdata *ppd, u64 ibcst)
         case IB_7220_LT_STATE_CFGWAITRMT:
         case IB_7220_LT_STATE_TXREVLANES:
         case IB_7220_LT_STATE_CFGENH:
-                tnow = jiffies;
+                tnow = get_jiffies_64();
                 if (ppd->cpspec->chase_end &&
-                    time_after(tnow, ppd->cpspec->chase_end)) {
+                    time_after64(tnow, ppd->cpspec->chase_end)) {
                         ppd->cpspec->chase_end = 0;
                         qib_set_ib_7220_lstate(ppd,
                                 QLOGIC_IB_IBCC_LINKCMD_DOWN,
@@ -1111,9 +1110,9 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
                 sdma_7220_errors(ppd, errs);
 
         if (errs & ~IB_E_BITSEXTANT)
-                qib_dev_err(dd,
-                        "error interrupt with unknown errors %llx set\n",
-                        (unsigned long long) (errs & ~IB_E_BITSEXTANT));
+                qib_dev_err(dd, "error interrupt with unknown errors "
+                            "%llx set\n", (unsigned long long)
+                            (errs & ~IB_E_BITSEXTANT));
 
         if (errs & E_SUM_ERRS) {
                 qib_disarm_7220_senderrbufs(ppd);
@@ -1192,8 +1191,8 @@ static void handle_7220_errors(struct qib_devdata *dd, u64 errs)
         }
 
         if (errs & ERR_MASK(ResetNegated)) {
-                qib_dev_err(dd,
-                        "Got reset, requires re-init (unload and reload driver)\n");
+                qib_dev_err(dd, "Got reset, requires re-init "
+                            "(unload and reload driver)\n");
                 dd->flags &= ~QIB_INITTED;  /* needs re-init */
                 /* mark as having had error */
                 *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1305,8 +1304,8 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
         if (!hwerrs)
                 goto bail;
         if (hwerrs == ~0ULL) {
-                qib_dev_err(dd,
-                        "Read of hardware error status failed (all bits set); ignoring\n");
+                qib_dev_err(dd, "Read of hardware error status failed "
+                            "(all bits set); ignoring\n");
                 goto bail;
         }
         qib_stats.sps_hwerrs++;
@@ -1329,14 +1328,13 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
                         qib_inc_eeprom_err(dd, log_idx, 1);
         if (hwerrs & ~(TXEMEMPARITYERR_PIOBUF | TXEMEMPARITYERR_PIOPBC |
                        RXE_PARITY))
-                qib_devinfo(dd->pcidev,
-                        "Hardware error: hwerr=0x%llx (cleared)\n",
-                        (unsigned long long) hwerrs);
+                qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
+                         "(cleared)\n", (unsigned long long) hwerrs);
 
         if (hwerrs & ~IB_HWE_BITSEXTANT)
-                qib_dev_err(dd,
-                        "hwerror interrupt with unknown errors %llx set\n",
-                        (unsigned long long) (hwerrs & ~IB_HWE_BITSEXTANT));
+                qib_dev_err(dd, "hwerror interrupt with unknown errors "
+                            "%llx set\n", (unsigned long long)
+                            (hwerrs & ~IB_HWE_BITSEXTANT));
 
         if (hwerrs & QLOGIC_IB_HWE_IB_UC_MEMORYPARITYERR)
                 qib_sd7220_clr_ibpar(dd);
@@ -1363,9 +1361,8 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
 
         if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                 isfatal = 1;
-                strlcat(msg,
-                        "[Memory BIST test failed, InfiniPath hardware unusable]",
-                        msgl);
+                strlcat(msg, "[Memory BIST test failed, "
+                        "InfiniPath hardware unusable]", msgl);
                 /* ignore from now on, so disable until driver reloaded */
                 dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                 qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -1411,9 +1408,8 @@ static void qib_7220_handle_hwerrors(struct qib_devdata *dd, char *msg,
         qib_dev_err(dd, "%s hardware error\n", msg);
 
         if (isfatal && !dd->diag_client) {
-                qib_dev_err(dd,
-                        "Fatal Hardware Error, no longer usable, SN %.16s\n",
-                        dd->serial);
+                qib_dev_err(dd, "Fatal Hardware Error, no longer"
+                            " usable, SN %.16s\n", dd->serial);
                 /*
                  * For /sys status file and user programs to print; if no
                  * trailing brace is copied, we'll know it was truncated.
@@ -1921,9 +1917,8 @@ static noinline void unlikely_7220_intr(struct qib_devdata *dd, u64 istat)
                 qib_stats.sps_errints++;
                 estat = qib_read_kreg64(dd, kr_errstatus);
                 if (!estat)
-                        qib_devinfo(dd->pcidev,
-                                "error interrupt (%Lx), but no error bits set!\n",
-                                istat);
+                        qib_devinfo(dd->pcidev, "error interrupt (%Lx), "
+                                 "but no error bits set!\n", istat);
                 else
                         handle_7220_errors(dd, estat);
         }
@@ -2027,18 +2022,17 @@ bail:
 static void qib_setup_7220_interrupt(struct qib_devdata *dd)
 {
         if (!dd->cspec->irq)
-                qib_dev_err(dd,
-                        "irq is 0, BIOS error?  Interrupts won't work\n");
+                qib_dev_err(dd, "irq is 0, BIOS error?  Interrupts won't "
+                            "work\n");
         else {
                 int ret = request_irq(dd->cspec->irq, qib_7220intr,
                         dd->msi_lo ? 0 : IRQF_SHARED,
                         QIB_DRV_NAME, dd);
 
                 if (ret)
-                        qib_dev_err(dd,
-                                "Couldn't setup %s interrupt (irq=%d): %d\n",
-                                dd->msi_lo ?  "MSI" : "INTx",
-                                dd->cspec->irq, ret);
+                        qib_dev_err(dd, "Couldn't setup %s interrupt "
+                                    "(irq=%d): %d\n", dd->msi_lo ?
+                                    "MSI" : "INTx", dd->cspec->irq, ret);
         }
 }
 
@@ -2077,9 +2071,9 @@ static void qib_7220_boardname(struct qib_devdata *dd)
                 snprintf(dd->boardname, namelen, "%s", n);
 
         if (dd->majrev != 5 || !dd->minrev || dd->minrev > 2)
-                qib_dev_err(dd,
-                        "Unsupported InfiniPath hardware revision %u.%u!\n",
-                        dd->majrev, dd->minrev);
+                qib_dev_err(dd, "Unsupported InfiniPath hardware "
+                            "revision %u.%u!\n",
+                            dd->majrev, dd->minrev);
 
         snprintf(dd->boardversion, sizeof(dd->boardversion),
                  "ChipABI %u.%u, %s, InfiniPath%u %u.%u, SW Compat %u\n",
@@ -2151,8 +2145,8 @@ static int qib_setup_7220_reset(struct qib_devdata *dd)
 bail:
         if (ret) {
                 if (qib_pcie_params(dd, dd->lbus_width, NULL, NULL))
-                        qib_dev_err(dd,
-                                "Reset failed to setup PCIe or interrupts; continuing anyway\n");
+                        qib_dev_err(dd, "Reset failed to setup PCIe or "
+                                    "interrupts; continuing anyway\n");
 
                 /* hold IBC in reset, no sends, etc till later */
                 qib_write_kreg(dd, kr_control, 0ULL);
@@ -2192,9 +2186,8 @@ static void qib_7220_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                         return;
                 }
                 if (chippa >= (1UL << IBA7220_TID_SZ_SHIFT)) {
-                        qib_dev_err(dd,
-                                "Physical page address 0x%lx larger than supported\n",
-                                pa);
+                        qib_dev_err(dd, "Physical page address 0x%lx "
+                                "larger than supported\n", pa);
                         return;
                 }
 
@@ -2712,9 +2705,8 @@ static int qib_7220_set_loopback(struct qib_pportdata *ppd, const char *what)
                 ppd->cpspec->ibcctrl &= ~SYM_MASK(IBCCtrl, Loopback);
                 /* enable heart beat again */
                 val = IBA7220_IBC_HRTBT_MASK << IBA7220_IBC_HRTBT_SHIFT;
-                qib_devinfo(ppd->dd->pcidev,
-                        "Disabling IB%u:%u IBC loopback (normal)\n",
-                        ppd->dd->unit, ppd->port);
+                qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
+                            "(normal)\n", ppd->dd->unit, ppd->port);
         } else
                 ret = -EINVAL;
         if (!ret) {
@@ -3314,8 +3306,8 @@ static int qib_7220_intr_fallback(struct qib_devdata *dd)
         if (!dd->msi_lo)
                 return 0;
 
-        qib_devinfo(dd->pcidev,
-                "MSI interrupt not detected, trying INTx interrupts\n");
+        qib_devinfo(dd->pcidev, "MSI interrupt not detected,"
+                 " trying INTx interrupts\n");
         qib_7220_free_irq(dd);
         qib_enable_intx(dd->pcidev);
         /*
@@ -3987,10 +3979,11 @@ static int qib_late_7220_initreg(struct qib_devdata *dd)
         qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
         val = qib_read_kreg64(dd, kr_sendpioavailaddr);
         if (val != dd->pioavailregs_phys) {
-                qib_dev_err(dd,
-                        "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
-                        (unsigned long) dd->pioavailregs_phys,
-                        (unsigned long long) val);
+                qib_dev_err(dd, "Catastrophic software error, "
+                            "SendPIOAvailAddr written as %lx, "
+                            "read back as %llx\n",
+                            (unsigned long) dd->pioavailregs_phys,
+                            (unsigned long long) val);
                 ret = -EINVAL;
         }
         qib_register_observer(dd, &sendctrl_observer);
@@ -4020,8 +4013,8 @@ static int qib_init_7220_variables(struct qib_devdata *dd)
         dd->revision = readq(&dd->kregbase[kr_revision]);
 
         if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-                qib_dev_err(dd,
-                        "Revision register read failure, giving up initialization\n");
+                qib_dev_err(dd, "Revision register read failure, "
+                            "giving up initialization\n");
                 ret = -ENODEV;
                 goto bail;
         }
@@ -4094,8 +4087,6 @@ static int qib_init_7220_variables(struct qib_devdata *dd)
         /* we always allocate at least 2048 bytes for eager buffers */
         ret = ib_mtu_enum_to_int(qib_ibmtu);
         dd->rcvegrbufsize = ret != -1 ? max(ret, 2048) : QIB_DEFAULT_MTU;
-        BUG_ON(!is_power_of_2(dd->rcvegrbufsize));
-        dd->rcvegrbufsize_shift = ilog2(dd->rcvegrbufsize);
 
         qib_7220_tidtemplate(dd);
 
@@ -4163,7 +4154,6 @@ static int qib_init_7220_variables(struct qib_devdata *dd)
                 dd->cspec->sdmabufcnt;
         dd->lastctxt_piobuf = dd->cspec->lastbuf_for_pio - sbufs;
         dd->cspec->lastbuf_for_pio--; /* range is <= , not < */
-        dd->last_pio = dd->cspec->lastbuf_for_pio;
         dd->pbufsctxt = dd->lastctxt_piobuf /
                 (dd->cfgctxts - dd->first_user_ctxt);
 
@@ -4619,8 +4609,8 @@ struct qib_devdata *qib_init_iba7220_funcs(struct pci_dev *pdev,
                 break;
         }
         if (qib_pcie_params(dd, minwidth, NULL, NULL))
-                qib_dev_err(dd,
-                        "Failed to setup PCIe or interrupts; continuing anyway\n");
+                qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
+                            "continuing anyway\n");
 
         /* save IRQ for possible later use */
         dd->cspec->irq = pdev->irq;
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index 3f6b21e9dc1..b7c3c7df268 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2008 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2008, 2009, 2010 QLogic Corporation. 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
@@ -41,7 +40,6 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/jiffies.h>
-#include <linux/module.h>
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_smi.h>
 
@@ -50,10 +48,6 @@
 #include "qib_qsfp.h"
 
 #include "qib_mad.h"
-#include "qib_verbs.h"
-
-#undef pr_fmt
-#define pr_fmt(fmt) QIB_DRV_NAME " " fmt
 
 static void qib_setup_7322_setextled(struct qib_pportdata *, u32);
 static void qib_7322_handle_hwerrors(struct qib_devdata *, char *, size_t);
@@ -546,7 +540,8 @@ struct qib_chip_specific {
         u32 lastbuf_for_pio;
         u32 stay_in_freeze;
         u32 recovery_ports_initted;
-        struct qib_msix_entry *msix_entries;
+        struct msix_entry *msix_entries;
+        void  **msix_arg;
         unsigned long *sendchkenable;
         unsigned long *sendgrhchk;
         unsigned long *sendibchk;
@@ -619,8 +614,8 @@ struct qib_chippport_specific {
         u64 ibmalfsnap;
         u64 ibcctrl_a; /* krp_ibcctrl_a shadow */
         u64 ibcctrl_b; /* krp_ibcctrl_b shadow */
-        unsigned long qdr_dfe_time;
-        unsigned long chase_end;
+        u64 qdr_dfe_time;
+        u64 chase_end;
         u32 autoneg_tries;
         u32 recovery_init;
         u32 qdr_dfe_on;
@@ -643,24 +638,24 @@ static struct {
         int lsb;
         int port; /* 0 if not port-specific, else port # */
 } irq_table[] = {
-        { "", qib_7322intr, -1, 0 },
-        { " (buf avail)", qib_7322bufavail,
+        { QIB_DRV_NAME, qib_7322intr, -1, 0 },
+        { QIB_DRV_NAME " (buf avail)", qib_7322bufavail,
                 SYM_LSB(IntStatus, SendBufAvail), 0 },
-        { " (sdma 0)", sdma_intr,
+        { QIB_DRV_NAME " (sdma 0)", sdma_intr,
                 SYM_LSB(IntStatus, SDmaInt_0), 1 },
-        { " (sdma 1)", sdma_intr,
+        { QIB_DRV_NAME " (sdma 1)", sdma_intr,
                 SYM_LSB(IntStatus, SDmaInt_1), 2 },
-        { " (sdmaI 0)", sdma_idle_intr,
+        { QIB_DRV_NAME " (sdmaI 0)", sdma_idle_intr,
                 SYM_LSB(IntStatus, SDmaIdleInt_0), 1 },
-        { " (sdmaI 1)", sdma_idle_intr,
+        { QIB_DRV_NAME " (sdmaI 1)", sdma_idle_intr,
                 SYM_LSB(IntStatus, SDmaIdleInt_1), 2 },
-        { " (sdmaP 0)", sdma_progress_intr,
+        { QIB_DRV_NAME " (sdmaP 0)", sdma_progress_intr,
                 SYM_LSB(IntStatus, SDmaProgressInt_0), 1 },
-        { " (sdmaP 1)", sdma_progress_intr,
+        { QIB_DRV_NAME " (sdmaP 1)", sdma_progress_intr,
                 SYM_LSB(IntStatus, SDmaProgressInt_1), 2 },
-        { " (sdmaC 0)", sdma_cleanup_intr,
+        { QIB_DRV_NAME " (sdmaC 0)", sdma_cleanup_intr,
                 SYM_LSB(IntStatus, SDmaCleanupDone_0), 1 },
-        { " (sdmaC 1)", sdma_cleanup_intr,
+        { QIB_DRV_NAME " (sdmaC 1)", sdma_cleanup_intr,
                 SYM_LSB(IntStatus, SDmaCleanupDone_1), 2 },
 };
 
@@ -1580,8 +1575,8 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
         qib_stats.sps_errints++;
         errs = qib_read_kreg64(dd, kr_errstatus);
         if (!errs) {
-                qib_devinfo(dd->pcidev,
-                        "device error interrupt, but no error bits set!\n");
+                qib_devinfo(dd->pcidev, "device error interrupt, "
+                         "but no error bits set!\n");
                 goto done;
         }
 
@@ -1627,8 +1622,8 @@ static noinline void handle_7322_errors(struct qib_devdata *dd)
         if (errs & QIB_E_RESET) {
                 int pidx;
 
-                qib_dev_err(dd,
-                        "Got reset, requires re-init (unload and reload driver)\n");
+                qib_dev_err(dd, "Got reset, requires re-init "
+                            "(unload and reload driver)\n");
                 dd->flags &= ~QIB_INITTED;  /* needs re-init */
                 /* mark as having had error */
                 *dd->devstatusp |= QIB_STATUS_HWERROR;
@@ -1676,8 +1671,7 @@ static void reenable_chase(unsigned long opaque)
                 QLOGIC_IB_IBCC_LINKINITCMD_POLL);
 }
 
-static void disable_chase(struct qib_pportdata *ppd, unsigned long tnow,
-                u8 ibclt)
+static void disable_chase(struct qib_pportdata *ppd, u64 tnow, u8 ibclt)
 {
         ppd->cpspec->chase_end = 0;
 
@@ -1693,7 +1687,7 @@ static void disable_chase(struct qib_pportdata *ppd, unsigned long tnow,
 static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
 {
         u8 ibclt;
-        unsigned long tnow;
+        u64 tnow;
 
         ibclt = (u8)SYM_FIELD(ibcst, IBCStatusA_0, LinkTrainingState);
 
@@ -1708,9 +1702,9 @@ static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
         case IB_7322_LT_STATE_CFGWAITRMT:
         case IB_7322_LT_STATE_TXREVLANES:
         case IB_7322_LT_STATE_CFGENH:
-                tnow = jiffies;
+                tnow = get_jiffies_64();
                 if (ppd->cpspec->chase_end &&
-                     time_after(tnow, ppd->cpspec->chase_end))
+                     time_after64(tnow, ppd->cpspec->chase_end))
                         disable_chase(ppd, tnow, ibclt);
                 else if (!ppd->cpspec->chase_end)
                         ppd->cpspec->chase_end = tnow + QIB_CHASE_TIME;
@@ -1765,9 +1759,9 @@ static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
                                             ppd->dd->cspec->r1 ?
                                             QDR_STATIC_ADAPT_DOWN_R1 :
                                             QDR_STATIC_ADAPT_DOWN);
-                        pr_info(
-                                "IB%u:%u re-enabled QDR adaptation ibclt %x\n",
-                                ppd->dd->unit, ppd->port, ibclt);
+                        printk(KERN_INFO QIB_DRV_NAME
+                                " IB%u:%u re-enabled QDR adaptation "
+                                "ibclt %x\n", ppd->dd->unit, ppd->port, ibclt);
                 }
         }
 }
@@ -1809,9 +1803,9 @@ static noinline void handle_7322_p_errors(struct qib_pportdata *ppd)
                 if (!*msg)
                         snprintf(msg, sizeof ppd->cpspec->epmsgbuf,
                                  "no others");
-                qib_dev_porterr(dd, ppd->port,
-                        "error interrupt with unknown errors 0x%016Lx set (and %s)\n",
-                        (errs & ~QIB_E_P_BITSEXTANT), msg);
+                qib_dev_porterr(dd, ppd->port, "error interrupt with unknown"
+                                " errors 0x%016Lx set (and %s)\n",
+                                (errs & ~QIB_E_P_BITSEXTANT), msg);
                 *msg = '\0';
         }
 
@@ -2029,8 +2023,8 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
         if (!hwerrs)
                 goto bail;
         if (hwerrs == ~0ULL) {
-                qib_dev_err(dd,
-                        "Read of hardware error status failed (all bits set); ignoring\n");
+                qib_dev_err(dd, "Read of hardware error status failed "
+                            "(all bits set); ignoring\n");
                 goto bail;
         }
         qib_stats.sps_hwerrs++;
@@ -2044,9 +2038,8 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
         /* no EEPROM logging, yet */
 
         if (hwerrs)
-                qib_devinfo(dd->pcidev,
-                        "Hardware error: hwerr=0x%llx (cleared)\n",
-                        (unsigned long long) hwerrs);
+                qib_devinfo(dd->pcidev, "Hardware error: hwerr=0x%llx "
+                            "(cleared)\n", (unsigned long long) hwerrs);
 
         ctrl = qib_read_kreg32(dd, kr_control);
         if ((ctrl & SYM_MASK(Control, FreezeMode)) && !dd->diag_client) {
@@ -2070,9 +2063,8 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
 
         if (hwerrs & HWE_MASK(PowerOnBISTFailed)) {
                 isfatal = 1;
-                strlcpy(msg,
-                        "[Memory BIST test failed, InfiniPath hardware unusable]",
-                        msgl);
+                strlcpy(msg, "[Memory BIST test failed, "
+                        "InfiniPath hardware unusable]", msgl);
                 /* ignore from now on, so disable until driver reloaded */
                 dd->cspec->hwerrmask &= ~HWE_MASK(PowerOnBISTFailed);
                 qib_write_kreg(dd, kr_hwerrmask, dd->cspec->hwerrmask);
@@ -2085,9 +2077,8 @@ static void qib_7322_handle_hwerrors(struct qib_devdata *dd, char *msg,
         qib_dev_err(dd, "%s hardware error\n", msg);
 
         if (isfatal && !dd->diag_client) {
-                qib_dev_err(dd,
-                        "Fatal Hardware Error, no longer usable, SN %.16s\n",
-                        dd->serial);
+                qib_dev_err(dd, "Fatal Hardware Error, no longer"
+                            " usable, SN %.16s\n", dd->serial);
                 /*
                  * for /sys status file and user programs to print; if no
                  * trailing brace is copied, we'll know it was truncated.
@@ -2315,11 +2306,16 @@ static int qib_7322_bringup_serdes(struct qib_pportdata *ppd)
                 SYM_LSB(IBCCtrlA_0, MaxPktLen);
         ppd->cpspec->ibcctrl_a = ibc; /* without linkcmd or linkinitcmd! */
 
+        /* initially come up waiting for TS1, without sending anything. */
+        val = ppd->cpspec->ibcctrl_a | (QLOGIC_IB_IBCC_LINKINITCMD_DISABLE <<
+                QLOGIC_IB_IBCC_LINKINITCMD_SHIFT);
+
         /*
          * Reset the PCS interface to the serdes (and also ibc, which is still
          * in reset from above).  Writes new value of ibcctrl_a as last step.
          */
         qib_7322_mini_pcs_reset(ppd);
+        qib_write_kreg(dd, kr_scratch, 0ULL);
 
         if (!ppd->cpspec->ibcctrl_b) {
                 unsigned lse = ppd->link_speed_enabled;
@@ -2385,20 +2381,17 @@ static int qib_7322_bringup_serdes(struct qib_pportdata *ppd)
         ppd->cpspec->ibcctrl_a |= SYM_MASK(IBCCtrlA_0, IBLinkEn);
         set_vls(ppd);
 
-        /* initially come up DISABLED, without sending anything. */
-        val = ppd->cpspec->ibcctrl_a | (QLOGIC_IB_IBCC_LINKINITCMD_DISABLE <<
-                                        QLOGIC_IB_IBCC_LINKINITCMD_SHIFT);
-        qib_write_kreg_port(ppd, krp_ibcctrl_a, val);
-        qib_write_kreg(dd, kr_scratch, 0ULL);
-        /* clear the linkinit cmds */
-        ppd->cpspec->ibcctrl_a = val & ~SYM_MASK(IBCCtrlA_0, LinkInitCmd);
-
         /* be paranoid against later code motion, etc. */
         spin_lock_irqsave(&dd->cspec->rcvmod_lock, flags);
         ppd->p_rcvctrl |= SYM_MASK(RcvCtrl_0, RcvIBPortEnable);
         qib_write_kreg_port(ppd, krp_rcvctrl, ppd->p_rcvctrl);
         spin_unlock_irqrestore(&dd->cspec->rcvmod_lock, flags);
 
+        /* Hold the link state machine for mezz boards */
+        if (IS_QMH(dd) || IS_QME(dd))
+                qib_set_ib_7322_lstate(ppd, 0,
+                                       QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
+
         /* Also enable IBSTATUSCHG interrupt.  */
         val = qib_read_kreg_port(ppd, krp_errmask);
         qib_write_kreg_port(ppd, krp_errmask,
@@ -2574,13 +2567,9 @@ static void qib_7322_nomsix(struct qib_devdata *dd)
                 int i;
 
                 dd->cspec->num_msix_entries = 0;
-                for (i = 0; i < n; i++) {
-                        irq_set_affinity_hint(
-                          dd->cspec->msix_entries[i].msix.vector, NULL);
-                        free_cpumask_var(dd->cspec->msix_entries[i].mask);
-                        free_irq(dd->cspec->msix_entries[i].msix.vector,
-                           dd->cspec->msix_entries[i].arg);
-                }
+                for (i = 0; i < n; i++)
+                        free_irq(dd->cspec->msix_entries[i].vector,
+                                 dd->cspec->msix_arg[i]);
                 qib_nomsix(dd);
         }
         /* make sure no MSIx interrupts are left pending */
@@ -2608,6 +2597,7 @@ static void qib_setup_7322_cleanup(struct qib_devdata *dd)
         kfree(dd->cspec->sendgrhchk);
         kfree(dd->cspec->sendibchk);
         kfree(dd->cspec->msix_entries);
+        kfree(dd->cspec->msix_arg);
         for (i = 0; i < dd->num_pports; i++) {
                 unsigned long flags;
                 u32 mask = QSFP_GPIO_MOD_PRS_N |
@@ -2675,9 +2665,8 @@ static noinline void unknown_7322_ibits(struct qib_devdata *dd, u64 istat)
         char msg[128];
 
         kills = istat & ~QIB_I_BITSEXTANT;
-        qib_dev_err(dd,
-                "Clearing reserved interrupt(s) 0x%016llx: %s\n",
-                (unsigned long long) kills, msg);
+        qib_dev_err(dd, "Clearing reserved interrupt(s) 0x%016llx:"
+                    " %s\n", (unsigned long long) kills, msg);
         qib_write_kreg(dd, kr_intmask, (dd->cspec->int_enable_mask & ~kills));
 }
 
@@ -2726,7 +2715,7 @@ static noinline void unknown_7322_gpio_intr(struct qib_devdata *dd)
                         pins >>= SYM_LSB(EXTStatus, GPIOIn);
                         if (!(pins & mask)) {
                                 ++handled;
-                                qd->t_insert = jiffies;
+                                qd->t_insert = get_jiffies_64();
                                 queue_work(ib_wq, &qd->work);
                         }
                 }
@@ -2864,8 +2853,9 @@ static irqreturn_t qib_7322intr(int irq, void *data)
                 for (i = 0; i < dd->first_user_ctxt; i++) {
                         if (ctxtrbits & rmask) {
                                 ctxtrbits &= ~rmask;
-                                if (dd->rcd[i])
+                                if (dd->rcd[i]) {
                                         qib_kreceive(dd->rcd[i], NULL, &npkts);
+                                }
                         }
                         rmask <<= 1;
                 }
@@ -3081,8 +3071,6 @@ static void qib_setup_7322_interrupt(struct qib_devdata *dd, int clearpend)
         int ret, i, msixnum;
         u64 redirect[6];
         u64 mask;
-        const struct cpumask *local_mask;
-        int firstcpu, secondcpu = 0, currrcvcpu = 0;
 
         if (!dd->num_pports)
                 return;
@@ -3110,16 +3098,16 @@ static void qib_setup_7322_interrupt(struct qib_devdata *dd, int clearpend)
                 /* Try to get INTx interrupt */
 try_intx:
                 if (!dd->pcidev->irq) {
-                        qib_dev_err(dd,
-                                "irq is 0, BIOS error?  Interrupts won't work\n");
+                        qib_dev_err(dd, "irq is 0, BIOS error?  "
+                                    "Interrupts won't work\n");
                         goto bail;
                 }
                 ret = request_irq(dd->pcidev->irq, qib_7322intr,
                                   IRQF_SHARED, QIB_DRV_NAME, dd);
                 if (ret) {
-                        qib_dev_err(dd,
-                                "Couldn't setup INTx interrupt (irq=%d): %d\n",
-                                dd->pcidev->irq, ret);
+                        qib_dev_err(dd, "Couldn't setup INTx "
+                                    "interrupt (irq=%d): %d\n",
+                                    dd->pcidev->irq, ret);
                         goto bail;
                 }
                 dd->cspec->irq = dd->pcidev->irq;
@@ -3131,28 +3119,13 @@ try_intx:
         memset(redirect, 0, sizeof redirect);
         mask = ~0ULL;
         msixnum = 0;
-        local_mask = cpumask_of_pcibus(dd->pcidev->bus);
-        firstcpu = cpumask_first(local_mask);
-        if (firstcpu >= nr_cpu_ids ||
-                        cpumask_weight(local_mask) == num_online_cpus()) {
-                local_mask = topology_core_cpumask(0);
-                firstcpu = cpumask_first(local_mask);
-        }
-        if (firstcpu < nr_cpu_ids) {
-                secondcpu = cpumask_next(firstcpu, local_mask);
-                if (secondcpu >= nr_cpu_ids)
-                        secondcpu = firstcpu;
-                currrcvcpu = secondcpu;
-        }
         for (i = 0; msixnum < dd->cspec->num_msix_entries; i++) {
                 irq_handler_t handler;
+                const char *name;
                 void *arg;
                 u64 val;
                 int lsb, reg, sh;
 
-                dd->cspec->msix_entries[msixnum].
-                        name[sizeof(dd->cspec->msix_entries[msixnum].name) - 1]
-                        = '\0';
                 if (i < ARRAY_SIZE(irq_table)) {
                         if (irq_table[i].port) {
                                 /* skip if for a non-configured port */
@@ -3163,11 +3136,7 @@ try_intx:
                                 arg = dd;
                         lsb = irq_table[i].lsb;
                         handler = irq_table[i].handler;
-                        snprintf(dd->cspec->msix_entries[msixnum].name,
-                                sizeof(dd->cspec->msix_entries[msixnum].name)
-                                 - 1,
-                                QIB_DRV_NAME "%d%s", dd->unit,
-                                irq_table[i].name);
+                        name = irq_table[i].name;
                 } else {
                         unsigned ctxt;
 
@@ -3180,29 +3149,23 @@ try_intx:
                                 continue;
                         lsb = QIB_I_RCVAVAIL_LSB + ctxt;
                         handler = qib_7322pintr;
-                        snprintf(dd->cspec->msix_entries[msixnum].name,
-                                sizeof(dd->cspec->msix_entries[msixnum].name)
-                                 - 1,
-                                QIB_DRV_NAME "%d (kctx)", dd->unit);
+                        name = QIB_DRV_NAME " (kctx)";
                 }
-                ret = request_irq(
-                        dd->cspec->msix_entries[msixnum].msix.vector,
-                        handler, 0, dd->cspec->msix_entries[msixnum].name,
-                        arg);
+                ret = request_irq(dd->cspec->msix_entries[msixnum].vector,
+                                  handler, 0, name, arg);
                 if (ret) {
                         /*
                          * Shouldn't happen since the enable said we could
                          * have as many as we are trying to setup here.
                          */
-                        qib_dev_err(dd,
-                                "Couldn't setup MSIx interrupt (vec=%d, irq=%d): %d\n",
-                                msixnum,
-                                dd->cspec->msix_entries[msixnum].msix.vector,
-                                ret);
+                        qib_dev_err(dd, "Couldn't setup MSIx "
+                                    "interrupt (vec=%d, irq=%d): %d\n", msixnum,
+                                    dd->cspec->msix_entries[msixnum].vector,
+                                    ret);
                         qib_7322_nomsix(dd);
                         goto try_intx;
                 }
-                dd->cspec->msix_entries[msixnum].arg = arg;
+                dd->cspec->msix_arg[msixnum] = arg;
                 if (lsb >= 0) {
                         reg = lsb / IBA7322_REDIRECT_VEC_PER_REG;
                         sh = (lsb % IBA7322_REDIRECT_VEC_PER_REG) *
@@ -3212,25 +3175,6 @@ try_intx:
                 }
                 val = qib_read_kreg64(dd, 2 * msixnum + 1 +
                         (QIB_7322_MsixTable_OFFS / sizeof(u64)));
-                if (firstcpu < nr_cpu_ids &&
-                        zalloc_cpumask_var(
-                                &dd->cspec->msix_entries[msixnum].mask,
-                                GFP_KERNEL)) {
-                        if (handler == qib_7322pintr) {
-                                cpumask_set_cpu(currrcvcpu,
-                                        dd->cspec->msix_entries[msixnum].mask);
-                                currrcvcpu = cpumask_next(currrcvcpu,
-                                        local_mask);
-                                if (currrcvcpu >= nr_cpu_ids)
-                                        currrcvcpu = secondcpu;
-                        } else {
-                                cpumask_set_cpu(firstcpu,
-                                        dd->cspec->msix_entries[msixnum].mask);
-                        }
-                        irq_set_affinity_hint(
-                                dd->cspec->msix_entries[msixnum].msix.vector,
-                                dd->cspec->msix_entries[msixnum].mask);
-                }
                 msixnum++;
         }
         /* Initialize the vector mapping */
@@ -3315,9 +3259,8 @@ static unsigned qib_7322_boardname(struct qib_devdata *dd)
                  (unsigned)SYM_FIELD(dd->revision, Revision_R, SW));
 
         if (qib_singleport && (features >> PORT_SPD_CAP_SHIFT) & PORT_SPD_CAP) {
-                qib_devinfo(dd->pcidev,
-                        "IB%u: Forced to single port mode by module parameter\n",
-                        dd->unit);
+                qib_devinfo(dd->pcidev, "IB%u: Forced to single port mode"
+                            " by module parameter\n", dd->unit);
                 features &= PORT_SPD_CAP;
         }
 
@@ -3411,8 +3354,8 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
                 if (val == dd->revision)
                         break;
                 if (i == 5) {
-                        qib_dev_err(dd,
-                                "Failed to initialize after reset, unusable\n");
+                        qib_dev_err(dd, "Failed to initialize after reset, "
+                                    "unusable\n");
                         ret = 0;
                         goto  bail;
                 }
@@ -3423,7 +3366,7 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
         if (msix_entries) {
                 /* restore the MSIx vector address and data if saved above */
                 for (i = 0; i < msix_entries; i++) {
-                        dd->cspec->msix_entries[i].msix.entry = i;
+                        dd->cspec->msix_entries[i].entry = i;
                         if (!msix_vecsave || !msix_vecsave[2 * i])
                                 continue;
                         qib_write_kreg(dd, 2 * i +
@@ -3443,8 +3386,8 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
         if (qib_pcie_params(dd, dd->lbus_width,
                             &dd->cspec->num_msix_entries,
                             dd->cspec->msix_entries))
-                qib_dev_err(dd,
-                        "Reset failed to setup PCIe or interrupts; continuing anyway\n");
+                qib_dev_err(dd, "Reset failed to setup PCIe or interrupts; "
+                                "continuing anyway\n");
 
         qib_setup_7322_interrupt(dd, 1);
 
@@ -3485,9 +3428,8 @@ static void qib_7322_put_tid(struct qib_devdata *dd, u64 __iomem *tidptr,
                         return;
                 }
                 if (chippa >= (1UL << IBA7322_TID_SZ_SHIFT)) {
-                        qib_dev_err(dd,
-                                "Physical page address 0x%lx larger than supported\n",
-                                pa);
+                        qib_dev_err(dd, "Physical page address 0x%lx "
+                                "larger than supported\n", pa);
                         return;
                 }
 
@@ -3662,7 +3604,7 @@ static void qib_7322_config_ctxts(struct qib_devdata *dd)
         if (qib_rcvhdrcnt)
                 dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt, qib_rcvhdrcnt);
         else
-                dd->rcvhdrcnt = 2 * max(dd->cspec->rcvegrcnt,
+                dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt,
                                     dd->num_pports > 1 ? 1024U : 2048U);
 }
 
@@ -4041,9 +3983,8 @@ static int qib_7322_set_loopback(struct qib_pportdata *ppd, const char *what)
                                                         Loopback);
                 /* enable heart beat again */
                 val = IBA7322_IBC_HRTBT_RMASK << IBA7322_IBC_HRTBT_LSB;
-                qib_devinfo(ppd->dd->pcidev,
-                        "Disabling IB%u:%u IBC loopback (normal)\n",
-                        ppd->dd->unit, ppd->port);
+                qib_devinfo(ppd->dd->pcidev, "Disabling IB%u:%u IBC loopback "
+                            "(normal)\n", ppd->dd->unit, ppd->port);
         } else
                 ret = -EINVAL;
         if (!ret) {
@@ -4727,8 +4668,8 @@ static void init_7322_cntrnames(struct qib_devdata *dd)
                 dd->pport[i].cpspec->portcntrs = kmalloc(dd->cspec->nportcntrs
                         * sizeof(u64), GFP_KERNEL);
                 if (!dd->pport[i].cpspec->portcntrs)
-                        qib_dev_err(dd,
-                                "Failed allocation for portcounters\n");
+                        qib_dev_err(dd, "Failed allocation for"
+                                    " portcounters\n");
         }
 }
 
@@ -4857,7 +4798,7 @@ static void qib_get_7322_faststats(unsigned long opaque)
                     (ppd->lflags & (QIBL_LINKINIT | QIBL_LINKARMED |
                                     QIBL_LINKACTIVE)) &&
                     ppd->cpspec->qdr_dfe_time &&
-                    time_is_before_jiffies(ppd->cpspec->qdr_dfe_time)) {
+                    time_after64(get_jiffies_64(), ppd->cpspec->qdr_dfe_time)) {
                         ppd->cpspec->qdr_dfe_on = 0;
 
                         qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
@@ -4878,8 +4819,8 @@ static int qib_7322_intr_fallback(struct qib_devdata *dd)
         if (!dd->cspec->num_msix_entries)
                 return 0; /* already using INTx */
 
-        qib_devinfo(dd->pcidev,
-                "MSIx interrupt not detected, trying INTx interrupts\n");
+        qib_devinfo(dd->pcidev, "MSIx interrupt not detected,"
+                 " trying INTx interrupts\n");
         qib_7322_nomsix(dd);
         qib_enable_intx(dd->pcidev);
         qib_setup_7322_interrupt(dd, 0);
@@ -5164,11 +5105,15 @@ static void try_7322_ipg(struct qib_pportdata *ppd)
                 goto retry;
 
         if (!ibp->smi_ah) {
+                struct ib_ah_attr attr;
                 struct ib_ah *ah;
 
-                ah = qib_create_qp0_ah(ibp, be16_to_cpu(IB_LID_PERMISSIVE));
+                memset(&attr, 0, sizeof attr);
+                attr.dlid = be16_to_cpu(IB_LID_PERMISSIVE);
+                attr.port_num = ppd->port;
+                ah = ib_create_ah(ibp->qp0->ibqp.pd, &attr);
                 if (IS_ERR(ah))
-                        ret = PTR_ERR(ah);
+                        ret = -EINVAL;
                 else {
                         send_buf->ah = ah;
                         ibp->smi_ah = to_iah(ah);
@@ -5287,8 +5232,6 @@ static int qib_7322_ib_updown(struct qib_pportdata *ppd, int ibup, u64 ibcs)
                                      QIBL_IB_AUTONEG_INPROG)))
                         set_7322_ibspeed_fast(ppd, ppd->link_speed_enabled);
                 if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG)) {
-                        struct qib_qsfp_data *qd =
-                                &ppd->cpspec->qsfp_data;
                         /* unlock the Tx settings, speed may change */
                         qib_write_kreg_port(ppd, krp_tx_deemph_override,
                                 SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
@@ -5296,12 +5239,6 @@ static int qib_7322_ib_updown(struct qib_pportdata *ppd, int ibup, u64 ibcs)
                         qib_cancel_sends(ppd);
                         /* on link down, ensure sane pcs state */
                         qib_7322_mini_pcs_reset(ppd);
-                        /* schedule the qsfp refresh which should turn the link
-                           off */
-                        if (ppd->dd->flags & QIB_HAS_QSFP) {
-                                qd->t_insert = jiffies;
-                                queue_work(ib_wq, &qd->work);
-                        }
                         spin_lock_irqsave(&ppd->sdma_lock, flags);
                         if (__qib_sdma_running(ppd))
                                 __qib_sdma_process_event(ppd,
@@ -5651,79 +5588,44 @@ static void qsfp_7322_event(struct work_struct *work)
 {
         struct qib_qsfp_data *qd;
         struct qib_pportdata *ppd;
-        unsigned long pwrup;
-        unsigned long flags;
+        u64 pwrup;
         int ret;
         u32 le2;
 
         qd = container_of(work, struct qib_qsfp_data, work);
         ppd = qd->ppd;
-        pwrup = qd->t_insert +
-                msecs_to_jiffies(QSFP_PWR_LAG_MSEC - QSFP_MODPRS_LAG_MSEC);
+        pwrup = qd->t_insert + msecs_to_jiffies(QSFP_PWR_LAG_MSEC);
 
-        /* Delay for 20 msecs to allow ModPrs resistor to setup */
-        mdelay(QSFP_MODPRS_LAG_MSEC);
-
-        if (!qib_qsfp_mod_present(ppd)) {
-                ppd->cpspec->qsfp_data.modpresent = 0;
-                /* Set the physical link to disabled */
-                qib_set_ib_7322_lstate(ppd, 0,
-                                       QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
-                spin_lock_irqsave(&ppd->lflags_lock, flags);
-                ppd->lflags &= ~QIBL_LINKV;
-                spin_unlock_irqrestore(&ppd->lflags_lock, flags);
-        } else {
-                /*
-                 * Some QSFP's not only do not respond until the full power-up
-                 * time, but may behave badly if we try. So hold off responding
-                 * to insertion.
-                 */
-                while (1) {
-                        if (time_is_before_jiffies(pwrup))
-                                break;
-                        msleep(20);
-                }
-
-                ret = qib_refresh_qsfp_cache(ppd, &qd->cache);
-
-                /*
-                 * Need to change LE2 back to defaults if we couldn't
-                 * read the cable type (to handle cable swaps), so do this
-                 * even on failure to read cable information.  We don't
-                 * get here for QME, so IS_QME check not needed here.
-                 */
-                if (!ret && !ppd->dd->cspec->r1) {
-                        if (QSFP_IS_ACTIVE_FAR(qd->cache.tech))
-                                le2 = LE2_QME;
-                        else if (qd->cache.atten[1] >= qib_long_atten &&
-                                 QSFP_IS_CU(qd->cache.tech))
-                                le2 = LE2_5m;
-                        else
-                                le2 = LE2_DEFAULT;
-                } else
-                        le2 = LE2_DEFAULT;
-                ibsd_wr_allchans(ppd, 13, (le2 << 7), BMASK(9, 7));
-                /*
-                 * We always change parameteters, since we can choose
-                 * values for cables without eeproms, and the cable may have
-                 * changed from a cable with full or partial eeprom content
-                 * to one with partial or no content.
-                 */
-                init_txdds_table(ppd, 0);
-                /* The physical link is being re-enabled only when the
-                 * previous state was DISABLED and the VALID bit is not
-                 * set. This should only happen when  the cable has been
-                 * physically pulled. */
-                if (!ppd->cpspec->qsfp_data.modpresent &&
-                    (ppd->lflags & (QIBL_LINKV | QIBL_IB_LINK_DISABLED))) {
-                        ppd->cpspec->qsfp_data.modpresent = 1;
-                        qib_set_ib_7322_lstate(ppd, 0,
-                                QLOGIC_IB_IBCC_LINKINITCMD_SLEEP);
-                        spin_lock_irqsave(&ppd->lflags_lock, flags);
-                        ppd->lflags |= QIBL_LINKV;
-                        spin_unlock_irqrestore(&ppd->lflags_lock, flags);
-                }
+        /*
+         * Some QSFP's not only do not respond until the full power-up
+         * time, but may behave badly if we try. So hold off responding
+         * to insertion.
+         */
+        while (1) {
+                u64 now = get_jiffies_64();
+                if (time_after64(now, pwrup))
+                        break;
+                msleep(20);
         }
+        ret = qib_refresh_qsfp_cache(ppd, &qd->cache);
+        /*
+         * Need to change LE2 back to defaults if we couldn't
+         * read the cable type (to handle cable swaps), so do this
+         * even on failure to read cable information.  We don't
+         * get here for QME, so IS_QME check not needed here.
+         */
+        if (!ret && !ppd->dd->cspec->r1) {
+                if (QSFP_IS_ACTIVE_FAR(qd->cache.tech))
+                        le2 = LE2_QME;
+                else if (qd->cache.atten[1] >= qib_long_atten &&
+                         QSFP_IS_CU(qd->cache.tech))
+                        le2 = LE2_5m;
+                else
+                        le2 = LE2_DEFAULT;
+        } else
+                le2 = LE2_DEFAULT;
+        ibsd_wr_allchans(ppd, 13, (le2 << 7), BMASK(9, 7));
+        init_txdds_table(ppd, 0);
 }
 
 /*
@@ -5827,8 +5729,7 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                         /* now change the IBC and serdes, overriding generic */
                         init_txdds_table(ppd, 1);
                         /* Re-enable the physical state machine on mezz boards
-                         * now that the correct settings have been set.
-                         * QSFP boards are handles by the QSFP event handler */
+                         * now that the correct settings have been set. */
                         if (IS_QMH(dd) || IS_QME(dd))
                                 qib_set_ib_7322_lstate(ppd, 0,
                                             QLOGIC_IB_IBCC_LINKINITCMD_SLEEP);
@@ -5853,21 +5754,22 @@ static int setup_txselect(const char *str, struct kernel_param *kp)
 {
         struct qib_devdata *dd;
         unsigned long val;
-        int ret;
-
+        char *n;
         if (strlen(str) >= MAX_ATTEN_LEN) {
-                pr_info("txselect_values string too long\n");
+                printk(KERN_INFO QIB_DRV_NAME " txselect_values string "
+                       "too long\n");
                 return -ENOSPC;
         }
-        ret = kstrtoul(str, 0, &val);
-        if (ret || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
+        val = simple_strtoul(str, &n, 0);
+        if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
                                 TXDDS_MFG_SZ)) {
-                pr_info("txselect_values must start with a number < %d\n",
+                printk(KERN_INFO QIB_DRV_NAME
+                       "txselect_values must start with a number < %d\n",
                         TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ + TXDDS_MFG_SZ);
-                return ret ? ret : -EINVAL;
+                return -EINVAL;
         }
-
         strcpy(txselect_list, str);
+
         list_for_each_entry(dd, &qib_dev_list, list)
                 if (dd->deviceid == PCI_DEVICE_ID_QLOGIC_IB_7322)
                         set_no_qsfp_atten(dd, 1);
@@ -5890,10 +5792,11 @@ static int qib_late_7322_initreg(struct qib_devdata *dd)
         qib_write_kreg(dd, kr_sendpioavailaddr, dd->pioavailregs_phys);
         val = qib_read_kreg64(dd, kr_sendpioavailaddr);
         if (val != dd->pioavailregs_phys) {
-                qib_dev_err(dd,
-                        "Catastrophic software error, SendPIOAvailAddr written as %lx, read back as %llx\n",
-                        (unsigned long) dd->pioavailregs_phys,
-                        (unsigned long long) val);
+                qib_dev_err(dd, "Catastrophic software error, "
+                            "SendPIOAvailAddr written as %lx, "
+                            "read back as %llx\n",
+                            (unsigned long) dd->pioavailregs_phys,
+                            (unsigned long long) val);
                 ret = -EINVAL;
         }
 
@@ -6105,8 +6008,8 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
         dd->revision = readq(&dd->kregbase[kr_revision]);
 
         if ((dd->revision & 0xffffffffU) == 0xffffffffU) {
-                qib_dev_err(dd,
-                        "Revision register read failure, giving up initialization\n");
+                qib_dev_err(dd, "Revision register read failure, "
+                            "giving up initialization\n");
                 ret = -ENODEV;
                 goto bail;
         }
@@ -6272,9 +6175,9 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                  */
                 if (!(dd->flags & QIB_HAS_QSFP)) {
                         if (!IS_QMH(dd) && !IS_QME(dd))
-                                qib_devinfo(dd->pcidev,
-                                        "IB%u:%u: Unknown mezzanine card type\n",
-                                        dd->unit, ppd->port);
+                                qib_devinfo(dd->pcidev, "IB%u:%u: "
+                                            "Unknown mezzanine card type\n",
+                                            dd->unit, ppd->port);
                         cp->h1_val = IS_QMH(dd) ? H1_FORCE_QMH : H1_FORCE_QME;
                         /*
                          * Choose center value as default tx serdes setting
@@ -6304,8 +6207,6 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
 
         /* we always allocate at least 2048 bytes for eager buffers */
         dd->rcvegrbufsize = max(mtu, 2048);
-        BUG_ON(!is_power_of_2(dd->rcvegrbufsize));
-        dd->rcvegrbufsize_shift = ilog2(dd->rcvegrbufsize);
 
         qib_7322_tidtemplate(dd);
 
@@ -6346,10 +6247,8 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                         dd->piobcnt4k * dd->align4k;
                 dd->piovl15base = ioremap_nocache(vl15off,
                                                   NUM_VL15_BUFS * dd->align4k);
-                if (!dd->piovl15base) {
-                        ret = -ENOMEM;
+                if (!dd->piovl15base)
                         goto bail;
-                }
         }
         qib_7322_set_baseaddrs(dd); /* set chip access pointers now */
 
@@ -6388,7 +6287,6 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                 dd->cspec->sdmabufcnt;
         dd->lastctxt_piobuf = dd->cspec->lastbuf_for_pio - sbufs;
         dd->cspec->lastbuf_for_pio--; /* range is <= , not < */
-        dd->last_pio = dd->cspec->lastbuf_for_pio;
         dd->pbufsctxt = (dd->cfgctxts > dd->first_user_ctxt) ?
                 dd->lastctxt_piobuf / (dd->cfgctxts - dd->first_user_ctxt) : 0;
 
@@ -6922,17 +6820,19 @@ struct qib_devdata *qib_init_iba7322_funcs(struct pci_dev *pdev,
 
         tabsize = actual_cnt;
         dd->cspec->msix_entries = kmalloc(tabsize *
-                        sizeof(struct qib_msix_entry), GFP_KERNEL);
-        if (!dd->cspec->msix_entries) {
+                        sizeof(struct msix_entry), GFP_KERNEL);
+        dd->cspec->msix_arg = kmalloc(tabsize *
+                        sizeof(void *), GFP_KERNEL);
+        if (!dd->cspec->msix_entries || !dd->cspec->msix_arg) {
                 qib_dev_err(dd, "No memory for MSIx table\n");
                 tabsize = 0;
         }
         for (i = 0; i < tabsize; i++)
-                dd->cspec->msix_entries[i].msix.entry = i;
+                dd->cspec->msix_entries[i].entry = i;
 
         if (qib_pcie_params(dd, 8, &tabsize, dd->cspec->msix_entries))
-                qib_dev_err(dd,
-                        "Failed to setup PCIe or interrupts; continuing anyway\n");
+                qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
+                            "continuing anyway\n");
         /* may be less than we wanted, if not enough available */
         dd->cspec->num_msix_entries = tabsize;
 
@@ -7249,8 +7149,7 @@ static void find_best_ent(struct qib_pportdata *ppd,
                 }
         }
 
-        /* Active cables don't have attenuation so we only set SERDES
-         * settings to account for the attenuation of the board traces. */
+        /* Lookup serdes setting by cable type and attenuation */
         if (!override && QSFP_IS_ACTIVE(qd->tech)) {
                 *sdr_dds = txdds_sdr + ppd->dd->board_atten;
                 *ddr_dds = txdds_ddr + ppd->dd->board_atten;
@@ -7285,7 +7184,8 @@ static void find_best_ent(struct qib_pportdata *ppd,
                    ppd->cpspec->no_eep < (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
                                           TXDDS_MFG_SZ)) {
                 idx = ppd->cpspec->no_eep - (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ);
-                pr_info("IB%u:%u use idx %u into txdds_mfg\n",
+                printk(KERN_INFO QIB_DRV_NAME
+                        " IB%u:%u use idx %u into txdds_mfg\n",
                         ppd->dd->unit, ppd->port, idx);
                 *sdr_dds = &txdds_extra_mfg[idx];
                 *ddr_dds = &txdds_extra_mfg[idx];
@@ -7440,11 +7340,11 @@ static void serdes_7322_los_enable(struct qib_pportdata *ppd, int enable)
         u8 state = SYM_FIELD(data, IBSerdesCtrl_0, RXLOSEN);
 
         if (enable && !state) {
-                pr_info("IB%u:%u Turning LOS on\n",
+                printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS on\n",
                         ppd->dd->unit, ppd->port);
                 data |= SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
         } else if (!enable && state) {
-                pr_info("IB%u:%u Turning LOS off\n",
+                printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS off\n",
                         ppd->dd->unit, ppd->port);
                 data &= ~SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
         }
@@ -7562,10 +7462,16 @@ static int serdes_7322_init_old(struct qib_pportdata *ppd)
 
 static int serdes_7322_init_new(struct qib_pportdata *ppd)
 {
-        unsigned long tend;
+        u64 tstart;
         u32 le_val, rxcaldone;
         int chan, chan_done = (1 << SERDES_CHANS) - 1;
 
+        /*
+         * Initialize the Tx DDS tables.  Also done every QSFP event,
+         * for adapters with QSFP
+         */
+        init_txdds_table(ppd, 0);
+
         /* Clear cmode-override, may be set from older driver */
         ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 10, 0 << 14, 1 << 14);
 
@@ -7667,8 +7573,10 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
         msleep(20);
         /*       Start Calibration */
         ibsd_wr_allchans(ppd, 4, (1 << 10), BMASK(10, 10));
-        tend = jiffies + msecs_to_jiffies(500);
-        while (chan_done && !time_is_before_jiffies(tend)) {
+        tstart = get_jiffies_64();
+        while (chan_done &&
+               !time_after64(get_jiffies_64(),
+                        tstart + msecs_to_jiffies(500))) {
                 msleep(20);
                 for (chan = 0; chan < SERDES_CHANS; ++chan) {
                         rxcaldone = ahb_mod(ppd->dd, IBSD(ppd->hw_pidx),
@@ -7680,7 +7588,8 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
                 }
         }
         if (chan_done) {
-                pr_info("Serdes %d calibration not done after .5 sec: 0x%x\n",
+                printk(KERN_INFO QIB_DRV_NAME
+                         " Serdes %d calibration not done after .5 sec: 0x%x\n",
                          IBSD(ppd->hw_pidx), chan_done);
         } else {
                 for (chan = 0; chan < SERDES_CHANS; ++chan) {
@@ -7688,8 +7597,9 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
                                             (chan + (chan >> 1)),
                                             25, 0, 0);
                         if ((~rxcaldone & (u32)BMASK(10, 10)) == 0)
-                                pr_info("Serdes %d chan %d calibration failed\n",
-                                        IBSD(ppd->hw_pidx), chan);
+                                printk(KERN_INFO QIB_DRV_NAME
+                                         " Serdes %d chan %d calibration "
+                                         "failed\n", IBSD(ppd->hw_pidx), chan);
                 }
         }
 
@@ -7715,7 +7625,7 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
         ibsd_wr_allchans(ppd, 5, 0, BMASK(0, 0));
         msleep(20);
         /*       Set Frequency Loop Bandwidth */
-        ibsd_wr_allchans(ppd, 2, (15 << 5), BMASK(8, 5));
+        ibsd_wr_allchans(ppd, 2, (7 << 5), BMASK(8, 5));
         /*       Enable Frequency Loop */
         ibsd_wr_allchans(ppd, 2, (1 << 4), BMASK(4, 4));
         /*       Set Timing Loop Bandwidth */
@@ -7747,12 +7657,6 @@ static int serdes_7322_init_new(struct qib_pportdata *ppd)
         /* VGA output common mode */
         ibsd_wr_allchans(ppd, 12, (3 << 2), BMASK(3, 2));
 
-        /*
-         * Initialize the Tx DDS tables.  Also done every QSFP event,
-         * for adapters with QSFP
-         */
-        init_txdds_table(ppd, 0);
-
         return 0;
 }
 
diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index ddf066d9abb..a01f3fce8eb 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -37,15 +37,9 @@
 #include <linux/vmalloc.h>
 #include <linux/delay.h>
 #include <linux/idr.h>
-#include <linux/module.h>
-#include <linux/printk.h>
 
 #include "qib.h"
 #include "qib_common.h"
-#include "qib_mad.h"
-
-#undef pr_fmt
-#define pr_fmt(fmt) QIB_DRV_NAME ": " fmt
 
 /*
  * min buffers we want to have per context, after driver
@@ -76,9 +70,6 @@ unsigned qib_n_krcv_queues;
 module_param_named(krcvqs, qib_n_krcv_queues, uint, S_IRUGO);
 MODULE_PARM_DESC(krcvqs, "number of kernel receive queues per IB port");
 
-unsigned qib_cc_table_size;
-module_param_named(cc_table_size, qib_cc_table_size, uint, S_IRUGO);
-MODULE_PARM_DESC(cc_table_size, "Congestion control table entries 0 (CCA disabled - default), min = 128, max = 1984");
 /*
  * qib_wc_pat parameter:
  *      0 is WC via MTRR
@@ -110,8 +101,6 @@ void qib_set_ctxtcnt(struct qib_devdata *dd)
                 dd->cfgctxts = qib_cfgctxts;
         else
                 dd->cfgctxts = dd->ctxtcnt;
-        dd->freectxts = (dd->first_user_ctxt > dd->cfgctxts) ? 0 :
-                dd->cfgctxts - dd->first_user_ctxt;
 }
 
 /*
@@ -128,8 +117,8 @@ int qib_create_ctxts(struct qib_devdata *dd)
          */
         dd->rcd = kzalloc(sizeof(*dd->rcd) * dd->ctxtcnt, GFP_KERNEL);
         if (!dd->rcd) {
-                qib_dev_err(dd,
-                        "Unable to allocate ctxtdata array, failing\n");
+                qib_dev_err(dd, "Unable to allocate ctxtdata array, "
+                            "failing\n");
                 ret = -ENOMEM;
                 goto done;
         }
@@ -145,8 +134,8 @@ int qib_create_ctxts(struct qib_devdata *dd)
                 ppd = dd->pport + (i % dd->num_pports);
                 rcd = qib_create_ctxtdata(ppd, i);
                 if (!rcd) {
-                        qib_dev_err(dd,
-                                "Unable to allocate ctxtdata for Kernel ctxt, failing\n");
+                        qib_dev_err(dd, "Unable to allocate ctxtdata"
+                                    " for Kernel ctxt, failing\n");
                         ret = -ENOMEM;
                         goto done;
                 }
@@ -194,9 +183,6 @@ struct qib_ctxtdata *qib_create_ctxtdata(struct qib_pportdata *ppd, u32 ctxt)
                 rcd->rcvegrbuf_chunks = (rcd->rcvegrcnt +
                         rcd->rcvegrbufs_perchunk - 1) /
                         rcd->rcvegrbufs_perchunk;
-                BUG_ON(!is_power_of_2(rcd->rcvegrbufs_perchunk));
-                rcd->rcvegrbufs_perchunk_shift =
-                        ilog2(rcd->rcvegrbufs_perchunk);
         }
         return rcd;
 }
@@ -207,7 +193,6 @@ struct qib_ctxtdata *qib_create_ctxtdata(struct qib_pportdata *ppd, u32 ctxt)
 void qib_init_pportdata(struct qib_pportdata *ppd, struct qib_devdata *dd,
                         u8 hw_pidx, u8 port)
 {
-        int size;
         ppd->dd = dd;
         ppd->hw_pidx = hw_pidx;
         ppd->port = port; /* IB port number, not index */
@@ -219,83 +204,6 @@ void qib_init_pportdata(struct qib_pportdata *ppd, struct qib_devdata *dd,
         init_timer(&ppd->symerr_clear_timer);
         ppd->symerr_clear_timer.function = qib_clear_symerror_on_linkup;
         ppd->symerr_clear_timer.data = (unsigned long)ppd;
-
-        ppd->qib_wq = NULL;
-
-        spin_lock_init(&ppd->cc_shadow_lock);
-
-        if (qib_cc_table_size < IB_CCT_MIN_ENTRIES)
-                goto bail;
-
-        ppd->cc_supported_table_entries = min(max_t(int, qib_cc_table_size,
-                IB_CCT_MIN_ENTRIES), IB_CCT_ENTRIES*IB_CC_TABLE_CAP_DEFAULT);
-
-        ppd->cc_max_table_entries =
-                ppd->cc_supported_table_entries/IB_CCT_ENTRIES;
-
-        size = IB_CC_TABLE_CAP_DEFAULT * sizeof(struct ib_cc_table_entry)
-                * IB_CCT_ENTRIES;
-        ppd->ccti_entries = kzalloc(size, GFP_KERNEL);
-        if (!ppd->ccti_entries) {
-                qib_dev_err(dd,
-                  "failed to allocate congestion control table for port %d!\n",
-                  port);
-                goto bail;
-        }
-
-        size = IB_CC_CCS_ENTRIES * sizeof(struct ib_cc_congestion_entry);
-        ppd->congestion_entries = kzalloc(size, GFP_KERNEL);
-        if (!ppd->congestion_entries) {
-                qib_dev_err(dd,
-                 "failed to allocate congestion setting list for port %d!\n",
-                 port);
-                goto bail_1;
-        }
-
-        size = sizeof(struct cc_table_shadow);
-        ppd->ccti_entries_shadow = kzalloc(size, GFP_KERNEL);
-        if (!ppd->ccti_entries_shadow) {
-                qib_dev_err(dd,
-                 "failed to allocate shadow ccti list for port %d!\n",
-                 port);
-                goto bail_2;
-        }
-
-        size = sizeof(struct ib_cc_congestion_setting_attr);
-        ppd->congestion_entries_shadow = kzalloc(size, GFP_KERNEL);
-        if (!ppd->congestion_entries_shadow) {
-                qib_dev_err(dd,
-                 "failed to allocate shadow congestion setting list for port %d!\n",
-                 port);
-                goto bail_3;
-        }
-
-        return;
-
-bail_3:
-        kfree(ppd->ccti_entries_shadow);
-        ppd->ccti_entries_shadow = NULL;
-bail_2:
-        kfree(ppd->congestion_entries);
-        ppd->congestion_entries = NULL;
-bail_1:
-        kfree(ppd->ccti_entries);
-        ppd->ccti_entries = NULL;
-bail:
-        /* User is intentionally disabling the congestion control agent */
-        if (!qib_cc_table_size)
-                return;
-
-        if (qib_cc_table_size < IB_CCT_MIN_ENTRIES) {
-                qib_cc_table_size = 0;
-                qib_dev_err(dd,
-                 "Congestion Control table size %d less than minimum %d for port %d\n",
-                 qib_cc_table_size, IB_CCT_MIN_ENTRIES, port);
-        }
-
-        qib_dev_err(dd, "Congestion Control Agent disabled for port %d\n",
-                port);
-        return;
 }
 
 static int init_pioavailregs(struct qib_devdata *dd)
@@ -307,8 +215,8 @@ static int init_pioavailregs(struct qib_devdata *dd)
                 &dd->pcidev->dev, PAGE_SIZE, &dd->pioavailregs_phys,
                 GFP_KERNEL);
         if (!dd->pioavailregs_dma) {
-                qib_dev_err(dd,
-                        "failed to allocate PIOavail reg area in memory\n");
+                qib_dev_err(dd, "failed to allocate PIOavail reg area "
+                            "in memory\n");
                 ret = -ENOMEM;
                 goto done;
         }
@@ -363,15 +271,15 @@ static void init_shadow_tids(struct qib_devdata *dd)
 
         pages = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *));
         if (!pages) {
-                qib_dev_err(dd,
-                        "failed to allocate shadow page * array, no expected sends!\n");
+                qib_dev_err(dd, "failed to allocate shadow page * "
+                            "array, no expected sends!\n");
                 goto bail;
         }
 
         addrs = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t));
         if (!addrs) {
-                qib_dev_err(dd,
-                        "failed to allocate shadow dma handle array, no expected sends!\n");
+                qib_dev_err(dd, "failed to allocate shadow dma handle "
+                            "array, no expected sends!\n");
                 goto bail_free;
         }
 
@@ -395,13 +303,13 @@ static int loadtime_init(struct qib_devdata *dd)
 
         if (((dd->revision >> QLOGIC_IB_R_SOFTWARE_SHIFT) &
              QLOGIC_IB_R_SOFTWARE_MASK) != QIB_CHIP_SWVERSION) {
-                qib_dev_err(dd,
-                        "Driver only handles version %d, chip swversion is %d (%llx), failng\n",
-                        QIB_CHIP_SWVERSION,
-                        (int)(dd->revision >>
+                qib_dev_err(dd, "Driver only handles version %d, "
+                            "chip swversion is %d (%llx), failng\n",
+                            QIB_CHIP_SWVERSION,
+                            (int)(dd->revision >>
                                 QLOGIC_IB_R_SOFTWARE_SHIFT) &
-                                QLOGIC_IB_R_SOFTWARE_MASK,
-                        (unsigned long long) dd->revision);
+                            QLOGIC_IB_R_SOFTWARE_MASK,
+                            (unsigned long long) dd->revision);
                 ret = -ENOSYS;
                 goto done;
         }
@@ -505,8 +413,8 @@ static void verify_interrupt(unsigned long opaque)
          */
         if (dd->int_counter == 0) {
                 if (!dd->f_intr_fallback(dd))
-                        dev_err(&dd->pcidev->dev,
-                                "No interrupts detected, not usable.\n");
+                        dev_err(&dd->pcidev->dev, "No interrupts detected, "
+                                "not usable.\n");
                 else /* re-arm the timer to see if fallback works */
                         mod_timer(&dd->intrchk_timer, jiffies + HZ/2);
         }
@@ -569,41 +477,6 @@ static void init_piobuf_state(struct qib_devdata *dd)
 }
 
 /**
- * qib_create_workqueues - create per port workqueues
- * @dd: the qlogic_ib device
- */
-static int qib_create_workqueues(struct qib_devdata *dd)
-{
-        int pidx;
-        struct qib_pportdata *ppd;
-
-        for (pidx = 0; pidx < dd->num_pports; ++pidx) {
-                ppd = dd->pport + pidx;
-                if (!ppd->qib_wq) {
-                        char wq_name[8]; /* 3 + 2 + 1 + 1 + 1 */
-                        snprintf(wq_name, sizeof(wq_name), "qib%d_%d",
-                                dd->unit, pidx);
-                        ppd->qib_wq =
-                                create_singlethread_workqueue(wq_name);
-                        if (!ppd->qib_wq)
-                                goto wq_error;
-                }
-        }
-        return 0;
-wq_error:
-        pr_err("create_singlethread_workqueue failed for port %d\n",
-                pidx + 1);
-        for (pidx = 0; pidx < dd->num_pports; ++pidx) {
-                ppd = dd->pport + pidx;
-                if (ppd->qib_wq) {
-                        destroy_workqueue(ppd->qib_wq);
-                        ppd->qib_wq = NULL;
-                }
-        }
-        return -ENOMEM;
-}
-
-/**
  * qib_init - do the actual initialization sequence on the chip
  * @dd: the qlogic_ib device
  * @reinit: reinitializing, so don't allocate new memory
@@ -668,8 +541,8 @@ int qib_init(struct qib_devdata *dd, int reinit)
                 if (!lastfail)
                         lastfail = qib_setup_eagerbufs(rcd);
                 if (lastfail) {
-                        qib_dev_err(dd,
-                                "failed to allocate kernel ctxt's rcvhdrq and/or egr bufs\n");
+                        qib_dev_err(dd, "failed to allocate kernel ctxt's "
+                                    "rcvhdrq and/or egr bufs\n");
                         continue;
                 }
         }
@@ -708,6 +581,10 @@ int qib_init(struct qib_devdata *dd, int reinit)
                         continue;
                 }
 
+                /* let link come up, and enable IBC */
+                spin_lock_irqsave(&ppd->lflags_lock, flags);
+                ppd->lflags &= ~QIBL_IB_LINK_DISABLED;
+                spin_unlock_irqrestore(&ppd->lflags_lock, flags);
                 portok++;
         }
 
@@ -885,11 +762,6 @@ static void qib_shutdown_device(struct qib_devdata *dd)
                  * We can't count on interrupts since we are stopping.
                  */
                 dd->f_quiet_serdes(ppd);
-
-                if (ppd->qib_wq) {
-                        destroy_workqueue(ppd->qib_wq);
-                        ppd->qib_wq = NULL;
-                }
         }
 
         qib_update_eeprom_log(dd);
@@ -1019,7 +891,8 @@ static void qib_verify_pioperf(struct qib_devdata *dd)
         /* 1 GiB/sec, slightly over IB SDR line rate */
         if (lcnt < (emsecs * 1024U))
                 qib_dev_err(dd,
-                            "Performance problem: bandwidth to PIO buffers is only %u MiB/sec\n",
+                            "Performance problem: bandwidth to PIO buffers is "
+                            "only %u MiB/sec\n",
                             lcnt / (u32) emsecs);
 
         preempt_enable();
@@ -1092,8 +965,8 @@ struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra)
                 if (qib_cpulist)
                         qib_cpulist_count = count;
                 else
-                        qib_early_err(&pdev->dev,
-                                "Could not alloc cpulist info, cpu affinity might be wrong\n");
+                        qib_early_err(&pdev->dev, "Could not alloc cpulist "
+                                      "info, cpu affinity might be wrong\n");
         }
 
 bail:
@@ -1134,13 +1007,14 @@ void qib_disable_after_error(struct qib_devdata *dd)
                 *dd->devstatusp |= QIB_STATUS_HWERROR;
 }
 
-static void qib_remove_one(struct pci_dev *);
-static int qib_init_one(struct pci_dev *, const struct pci_device_id *);
+static void __devexit qib_remove_one(struct pci_dev *);
+static int __devinit qib_init_one(struct pci_dev *,
+                                  const struct pci_device_id *);
 
 #define DRIVER_LOAD_MSG "QLogic " QIB_DRV_NAME " loaded: "
 #define PFX QIB_DRV_NAME ": "
 
-static DEFINE_PCI_DEVICE_TABLE(qib_pci_tbl) = {
+static const struct pci_device_id qib_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE, PCI_DEVICE_ID_QLOGIC_IB_6120) },
         { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_IB_7220) },
         { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_IB_7322) },
@@ -1152,7 +1026,7 @@ MODULE_DEVICE_TABLE(pci, qib_pci_tbl);
 struct pci_driver qib_driver = {
         .name = QIB_DRV_NAME,
         .probe = qib_init_one,
-        .remove = qib_remove_one,
+        .remove = __devexit_p(qib_remove_one),
         .id_table = qib_pci_tbl,
         .err_handler = &qib_pci_err_handler,
 };
@@ -1181,20 +1055,21 @@ static int __init qlogic_ib_init(void)
          */
         idr_init(&qib_unit_table);
         if (!idr_pre_get(&qib_unit_table, GFP_KERNEL)) {
-                pr_err("idr_pre_get() failed\n");
+                printk(KERN_ERR QIB_DRV_NAME ": idr_pre_get() failed\n");
                 ret = -ENOMEM;
                 goto bail_cq_wq;
         }
 
         ret = pci_register_driver(&qib_driver);
         if (ret < 0) {
-                pr_err("Unable to register driver: error %d\n", -ret);
+                printk(KERN_ERR QIB_DRV_NAME
+                       ": Unable to register driver: error %d\n", -ret);
                 goto bail_unit;
         }
 
         /* not fatal if it doesn't work */
         if (qib_init_qibfs())
-                pr_err("Unable to register ipathfs\n");
+                printk(KERN_ERR QIB_DRV_NAME ": Unable to register ipathfs\n");
         goto bail; /* all OK */
 
 bail_unit:
@@ -1218,9 +1093,9 @@ static void __exit qlogic_ib_cleanup(void)
 
         ret = qib_exit_qibfs();
         if (ret)
-                pr_err(
-                        "Unable to cleanup counter filesystem: error %d\n",
-                        -ret);
+                printk(KERN_ERR QIB_DRV_NAME ": "
+                        "Unable to cleanup counter filesystem: "
+                        "error %d\n", -ret);
 
         pci_unregister_driver(&qib_driver);
 
@@ -1244,24 +1119,10 @@ static void cleanup_device_data(struct qib_devdata *dd)
         unsigned long flags;
 
         /* users can't do anything more with chip */
-        for (pidx = 0; pidx < dd->num_pports; ++pidx) {
+        for (pidx = 0; pidx < dd->num_pports; ++pidx)
                 if (dd->pport[pidx].statusp)
                         *dd->pport[pidx].statusp &= ~QIB_STATUS_CHIP_PRESENT;
 
-                spin_lock(&dd->pport[pidx].cc_shadow_lock);
-
-                kfree(dd->pport[pidx].congestion_entries);
-                dd->pport[pidx].congestion_entries = NULL;
-                kfree(dd->pport[pidx].ccti_entries);
-                dd->pport[pidx].ccti_entries = NULL;
-                kfree(dd->pport[pidx].ccti_entries_shadow);
-                dd->pport[pidx].ccti_entries_shadow = NULL;
-                kfree(dd->pport[pidx].congestion_entries_shadow);
-                dd->pport[pidx].congestion_entries_shadow = NULL;
-
-                spin_unlock(&dd->pport[pidx].cc_shadow_lock);
-        }
-
         if (!qib_wc_pat)
                 qib_disable_wc(dd);
 
@@ -1341,7 +1202,8 @@ static void qib_postinit_cleanup(struct qib_devdata *dd)
         qib_free_devdata(dd);
 }
 
-static int qib_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int __devinit qib_init_one(struct pci_dev *pdev,
+                                  const struct pci_device_id *ent)
 {
         int ret, j, pidx, initfail;
         struct qib_devdata *dd = NULL;
@@ -1359,9 +1221,9 @@ static int qib_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 #ifdef CONFIG_PCI_MSI
                 dd = qib_init_iba6120_funcs(pdev, ent);
 #else
-                qib_early_err(&pdev->dev,
-                        "QLogic PCIE device 0x%x cannot work if CONFIG_PCI_MSI is not enabled\n",
-                        ent->device);
+                qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot "
+                      "work if CONFIG_PCI_MSI is not enabled\n",
+                      ent->device);
                 dd = ERR_PTR(-ENODEV);
 #endif
                 break;
@@ -1375,9 +1237,8 @@ static int qib_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 break;
 
         default:
-                qib_early_err(&pdev->dev,
-                        "Failing on unknown QLogic deviceid 0x%x\n",
-                        ent->device);
+                qib_early_err(&pdev->dev, "Failing on unknown QLogic "
+                              "deviceid 0x%x\n", ent->device);
                 ret = -ENODEV;
         }
 
@@ -1386,10 +1247,6 @@ static int qib_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (ret)
                 goto bail; /* error already printed */
 
-        ret = qib_create_workqueues(dd);
-        if (ret)
-                goto bail;
-
         /* do the generic initialization */
         initfail = qib_init(dd, 0);
 
@@ -1434,9 +1291,9 @@ static int qib_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (!qib_wc_pat) {
                 ret = qib_enable_wc(dd);
                 if (ret) {
-                        qib_dev_err(dd,
-                                "Write combining not enabled (err %d): performance may be poor\n",
-                                -ret);
+                        qib_dev_err(dd, "Write combining not enabled "
+                                    "(err %d): performance may be poor\n",
+                                    -ret);
                         ret = 0;
                 }
         }
@@ -1446,7 +1303,7 @@ bail:
         return ret;
 }
 
-static void qib_remove_one(struct pci_dev *pdev)
+static void __devexit qib_remove_one(struct pci_dev *pdev)
 {
         struct qib_devdata *dd = pci_get_drvdata(pdev);
         int ret;
@@ -1502,9 +1359,9 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
                         gfp_flags | __GFP_COMP);
 
                 if (!rcd->rcvhdrq) {
-                        qib_dev_err(dd,
-                                "attempt to allocate %d bytes for ctxt %u rcvhdrq failed\n",
-                                amt, rcd->ctxt);
+                        qib_dev_err(dd, "attempt to allocate %d bytes "
+                                    "for ctxt %u rcvhdrq failed\n",
+                                    amt, rcd->ctxt);
                         goto bail;
                 }
 
@@ -1533,9 +1390,8 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd)
         return 0;
 
 bail_free:
-        qib_dev_err(dd,
-                "attempt to allocate 1 page for ctxt %u rcvhdrqtailaddr failed\n",
-                rcd->ctxt);
+        qib_dev_err(dd, "attempt to allocate 1 page for ctxt %u "
+                    "rcvhdrqtailaddr failed\n", rcd->ctxt);
         vfree(rcd->user_event_mask);
         rcd->user_event_mask = NULL;
 bail_free_hdrq:
diff --git a/drivers/infiniband/hw/qib/qib_intr.c b/drivers/infiniband/hw/qib/qib_intr.c
index f4918f2165e..6ae57d23004 100644
--- a/drivers/infiniband/hw/qib/qib_intr.c
+++ b/drivers/infiniband/hw/qib/qib_intr.c
@@ -224,15 +224,15 @@ void qib_bad_intrstatus(struct qib_devdata *dd)
          * We print the message and disable interrupts, in hope of
          * having a better chance of debugging the problem.
          */
-        qib_dev_err(dd,
-                "Read of chip interrupt status failed disabling interrupts\n");
+        qib_dev_err(dd, "Read of chip interrupt status failed"
+                    " disabling interrupts\n");
         if (allbits++) {
                 /* disable interrupt delivery, something is very wrong */
                 if (allbits == 2)
                         dd->f_set_intr_state(dd, 0);
                 if (allbits == 3) {
-                        qib_dev_err(dd,
-                                "2nd bad interrupt status, unregistering interrupts\n");
+                        qib_dev_err(dd, "2nd bad interrupt status, "
+                                    "unregistering interrupts\n");
                         dd->flags |= QIB_BADINTR;
                         dd->flags &= ~QIB_INITTED;
                         dd->f_free_irq(dd);
diff --git a/drivers/infiniband/hw/qib/qib_keys.c b/drivers/infiniband/hw/qib/qib_keys.c
index 81c7b73695d..8fd19a47df0 100644
--- a/drivers/infiniband/hw/qib/qib_keys.c
+++ b/drivers/infiniband/hw/qib/qib_keys.c
@@ -35,41 +35,21 @@
 
 /**
  * qib_alloc_lkey - allocate an lkey
+ * @rkt: lkey table in which to allocate the lkey
  * @mr: memory region that this lkey protects
- * @dma_region: 0->normal key, 1->restricted DMA key
- *
- * Returns 0 if successful, otherwise returns -errno.
- *
- * Increments mr reference count as required.
- *
- * Sets the lkey field mr for non-dma regions.
  *
+ * Returns 1 if successful, otherwise returns 0.
  */
 
-int qib_alloc_lkey(struct qib_mregion *mr, int dma_region)
+int qib_alloc_lkey(struct qib_lkey_table *rkt, struct qib_mregion *mr)
 {
         unsigned long flags;
         u32 r;
         u32 n;
-        int ret = 0;
-        struct qib_ibdev *dev = to_idev(mr->pd->device);
-        struct qib_lkey_table *rkt = &dev->lk_table;
+        int ret;
 
         spin_lock_irqsave(&rkt->lock, flags);
 
-        /* special case for dma_mr lkey == 0 */
-        if (dma_region) {
-                struct qib_mregion *tmr;
-
-                tmr = rcu_dereference(dev->dma_mr);
-                if (!tmr) {
-                        qib_get_mr(mr);
-                        rcu_assign_pointer(dev->dma_mr, mr);
-                        mr->lkey_published = 1;
-                }
-                goto success;
-        }
-
         /* Find the next available LKEY */
         r = rkt->next;
         n = r;
@@ -77,8 +57,11 @@ int qib_alloc_lkey(struct qib_mregion *mr, int dma_region)
                 if (rkt->table[r] == NULL)
                         break;
                 r = (r + 1) & (rkt->max - 1);
-                if (r == n)
+                if (r == n) {
+                        spin_unlock_irqrestore(&rkt->lock, flags);
+                        ret = 0;
                         goto bail;
+                }
         }
         rkt->next = (r + 1) & (rkt->max - 1);
         /*
@@ -93,58 +76,57 @@ int qib_alloc_lkey(struct qib_mregion *mr, int dma_region)
                 mr->lkey |= 1 << 8;
                 rkt->gen++;
         }
-        qib_get_mr(mr);
-        rcu_assign_pointer(rkt->table[r], mr);
-        mr->lkey_published = 1;
-success:
+        rkt->table[r] = mr;
         spin_unlock_irqrestore(&rkt->lock, flags);
-out:
-        return ret;
+
+        ret = 1;
+
 bail:
-        spin_unlock_irqrestore(&rkt->lock, flags);
-        ret = -ENOMEM;
-        goto out;
+        return ret;
 }
 
 /**
  * qib_free_lkey - free an lkey
- * @mr: mr to free from tables
+ * @rkt: table from which to free the lkey
+ * @lkey: lkey id to free
  */
-void qib_free_lkey(struct qib_mregion *mr)
+int qib_free_lkey(struct qib_ibdev *dev, struct qib_mregion *mr)
 {
         unsigned long flags;
         u32 lkey = mr->lkey;
         u32 r;
-        struct qib_ibdev *dev = to_idev(mr->pd->device);
-        struct qib_lkey_table *rkt = &dev->lk_table;
+        int ret;
 
-        spin_lock_irqsave(&rkt->lock, flags);
-        if (!mr->lkey_published)
-                goto out;
-        if (lkey == 0)
-                rcu_assign_pointer(dev->dma_mr, NULL);
-        else {
+        spin_lock_irqsave(&dev->lk_table.lock, flags);
+        if (lkey == 0) {
+                if (dev->dma_mr && dev->dma_mr == mr) {
+                        ret = atomic_read(&dev->dma_mr->refcount);
+                        if (!ret)
+                                dev->dma_mr = NULL;
+                } else
+                        ret = 0;
+        } else {
                 r = lkey >> (32 - ib_qib_lkey_table_size);
-                rcu_assign_pointer(rkt->table[r], NULL);
+                ret = atomic_read(&dev->lk_table.table[r]->refcount);
+                if (!ret)
+                        dev->lk_table.table[r] = NULL;
         }
-        qib_put_mr(mr);
-        mr->lkey_published = 0;
-out:
-        spin_unlock_irqrestore(&rkt->lock, flags);
+        spin_unlock_irqrestore(&dev->lk_table.lock, flags);
+
+        if (ret)
+                ret = -EBUSY;
+        return ret;
 }
 
 /**
  * qib_lkey_ok - check IB SGE for validity and initialize
  * @rkt: table containing lkey to check SGE against
- * @pd: protection domain
  * @isge: outgoing internal SGE
  * @sge: SGE to check
  * @acc: access flags
  *
  * Return 1 if valid and successful, otherwise returns 0.
  *
- * increments the reference count upon success
- *
  * Check the IB SGE for validity and initialize our internal version
  * of it.
  */
@@ -154,25 +136,24 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
         struct qib_mregion *mr;
         unsigned n, m;
         size_t off;
+        unsigned long flags;
 
         /*
          * We use LKEY == zero for kernel virtual addresses
          * (see qib_get_dma_mr and qib_dma.c).
          */
-        rcu_read_lock();
+        spin_lock_irqsave(&rkt->lock, flags);
         if (sge->lkey == 0) {
                 struct qib_ibdev *dev = to_idev(pd->ibpd.device);
 
                 if (pd->user)
                         goto bail;
-                mr = rcu_dereference(dev->dma_mr);
-                if (!mr)
-                        goto bail;
-                if (unlikely(!atomic_inc_not_zero(&mr->refcount)))
+                if (!dev->dma_mr)
                         goto bail;
-                rcu_read_unlock();
+                atomic_inc(&dev->dma_mr->refcount);
+                spin_unlock_irqrestore(&rkt->lock, flags);
 
-                isge->mr = mr;
+                isge->mr = dev->dma_mr;
                 isge->vaddr = (void *) sge->addr;
                 isge->length = sge->length;
                 isge->sge_length = sge->length;
@@ -180,9 +161,9 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
                 isge->n = 0;
                 goto ok;
         }
-        mr = rcu_dereference(
-                rkt->table[(sge->lkey >> (32 - ib_qib_lkey_table_size))]);
-        if (unlikely(!mr || mr->lkey != sge->lkey || mr->pd != &pd->ibpd))
+        mr = rkt->table[(sge->lkey >> (32 - ib_qib_lkey_table_size))];
+        if (unlikely(mr == NULL || mr->lkey != sge->lkey ||
+                     mr->pd != &pd->ibpd))
                 goto bail;
 
         off = sge->addr - mr->user_base;
@@ -190,9 +171,8 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
                      off + sge->length > mr->length ||
                      (mr->access_flags & acc) != acc))
                 goto bail;
-        if (unlikely(!atomic_inc_not_zero(&mr->refcount)))
-                goto bail;
-        rcu_read_unlock();
+        atomic_inc(&mr->refcount);
+        spin_unlock_irqrestore(&rkt->lock, flags);
 
         off += mr->offset;
         if (mr->page_shift) {
@@ -228,22 +208,20 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
 ok:
         return 1;
 bail:
-        rcu_read_unlock();
+        spin_unlock_irqrestore(&rkt->lock, flags);
         return 0;
 }
 
 /**
  * qib_rkey_ok - check the IB virtual address, length, and RKEY
- * @qp: qp for validation
- * @sge: SGE state
+ * @dev: infiniband device
+ * @ss: SGE state
  * @len: length of data
  * @vaddr: virtual address to place data
  * @rkey: rkey to check
  * @acc: access flags
  *
  * Return 1 if successful, otherwise 0.
- *
- * increments the reference count upon success
  */
 int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
                 u32 len, u64 vaddr, u32 rkey, int acc)
@@ -252,26 +230,25 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
         struct qib_mregion *mr;
         unsigned n, m;
         size_t off;
+        unsigned long flags;
 
         /*
          * We use RKEY == zero for kernel virtual addresses
          * (see qib_get_dma_mr and qib_dma.c).
          */
-        rcu_read_lock();
+        spin_lock_irqsave(&rkt->lock, flags);
         if (rkey == 0) {
                 struct qib_pd *pd = to_ipd(qp->ibqp.pd);
                 struct qib_ibdev *dev = to_idev(pd->ibpd.device);
 
                 if (pd->user)
                         goto bail;
-                mr = rcu_dereference(dev->dma_mr);
-                if (!mr)
+                if (!dev->dma_mr)
                         goto bail;
-                if (unlikely(!atomic_inc_not_zero(&mr->refcount)))
-                        goto bail;
-                rcu_read_unlock();
+                atomic_inc(&dev->dma_mr->refcount);
+                spin_unlock_irqrestore(&rkt->lock, flags);
 
-                sge->mr = mr;
+                sge->mr = dev->dma_mr;
                 sge->vaddr = (void *) vaddr;
                 sge->length = len;
                 sge->sge_length = len;
@@ -280,18 +257,16 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
                 goto ok;
         }
 
-        mr = rcu_dereference(
-                rkt->table[(rkey >> (32 - ib_qib_lkey_table_size))]);
-        if (unlikely(!mr || mr->lkey != rkey || qp->ibqp.pd != mr->pd))
+        mr = rkt->table[(rkey >> (32 - ib_qib_lkey_table_size))];
+        if (unlikely(mr == NULL || mr->lkey != rkey || qp->ibqp.pd != mr->pd))
                 goto bail;
 
         off = vaddr - mr->iova;
         if (unlikely(vaddr < mr->iova || off + len > mr->length ||
                      (mr->access_flags & acc) == 0))
                 goto bail;
-        if (unlikely(!atomic_inc_not_zero(&mr->refcount)))
-                goto bail;
-        rcu_read_unlock();
+        atomic_inc(&mr->refcount);
+        spin_unlock_irqrestore(&rkt->lock, flags);
 
         off += mr->offset;
         if (mr->page_shift) {
@@ -327,7 +302,7 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
 ok:
         return 1;
 bail:
-        rcu_read_unlock();
+        spin_unlock_irqrestore(&rkt->lock, flags);
         return 0;
 }
 
@@ -350,9 +325,7 @@ int qib_fast_reg_mr(struct qib_qp *qp, struct ib_send_wr *wr)
         if (pd->user || rkey == 0)
                 goto bail;
 
-        mr = rcu_dereference_protected(
-                rkt->table[(rkey >> (32 - ib_qib_lkey_table_size))],
-                lockdep_is_held(&rkt->lock));
+        mr = rkt->table[(rkey >> (32 - ib_qib_lkey_table_size))];
         if (unlikely(mr == NULL || qp->ibqp.pd != mr->pd))
                 goto bail;
 
diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
index ccb119143d2..3b3745f261f 100644
--- a/drivers/infiniband/hw/qib/qib_mad.c
+++ b/drivers/infiniband/hw/qib/qib_mad.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -49,18 +49,6 @@ static int reply(struct ib_smp *smp)
         return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
 }
 
-static int reply_failure(struct ib_smp *smp)
-{
-        /*
-         * The verbs framework will handle the directed/LID route
-         * packet changes.
-         */
-        smp->method = IB_MGMT_METHOD_GET_RESP;
-        if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
-                smp->status |= IB_SMP_DIRECTION;
-        return IB_MAD_RESULT_FAILURE | IB_MAD_RESULT_REPLY;
-}
-
 static void qib_send_trap(struct qib_ibport *ibp, void *data, unsigned len)
 {
         struct ib_mad_send_buf *send_buf;
@@ -102,10 +90,14 @@ static void qib_send_trap(struct qib_ibport *ibp, void *data, unsigned len)
         if (!ibp->sm_ah) {
                 if (ibp->sm_lid != be16_to_cpu(IB_LID_PERMISSIVE)) {
                         struct ib_ah *ah;
+                        struct ib_ah_attr attr;
 
-                        ah = qib_create_qp0_ah(ibp, ibp->sm_lid);
+                        memset(&attr, 0, sizeof attr);
+                        attr.dlid = ibp->sm_lid;
+                        attr.port_num = ppd_from_ibp(ibp)->port;
+                        ah = ib_create_ah(ibp->qp0->ibqp.pd, &attr);
                         if (IS_ERR(ah))
-                                ret = PTR_ERR(ah);
+                                ret = -EINVAL;
                         else {
                                 send_buf->ah = ah;
                                 ibp->sm_ah = to_iah(ah);
@@ -404,7 +396,6 @@ static int get_linkdowndefaultstate(struct qib_pportdata *ppd)
 
 static int check_mkey(struct qib_ibport *ibp, struct ib_smp *smp, int mad_flags)
 {
-        int valid_mkey = 0;
         int ret = 0;
 
         /* Is the mkey in the process of expiring? */
@@ -415,36 +406,23 @@ static int check_mkey(struct qib_ibport *ibp, struct ib_smp *smp, int mad_flags)
                 ibp->mkeyprot = 0;
         }
 
-        if ((mad_flags & IB_MAD_IGNORE_MKEY) ||  ibp->mkey == 0 ||
-            ibp->mkey == smp->mkey)
-                valid_mkey = 1;
-
-        /* Unset lease timeout on any valid Get/Set/TrapRepress */
-        if (valid_mkey && ibp->mkey_lease_timeout &&
-            (smp->method == IB_MGMT_METHOD_GET ||
-             smp->method == IB_MGMT_METHOD_SET ||
-             smp->method == IB_MGMT_METHOD_TRAP_REPRESS))
+        /* M_Key checking depends on Portinfo:M_Key_protect_bits */
+        if ((mad_flags & IB_MAD_IGNORE_MKEY) == 0 && ibp->mkey != 0 &&
+            ibp->mkey != smp->mkey &&
+            (smp->method == IB_MGMT_METHOD_SET ||
+             smp->method == IB_MGMT_METHOD_TRAP_REPRESS ||
+             (smp->method == IB_MGMT_METHOD_GET && ibp->mkeyprot >= 2))) {
+                if (ibp->mkey_violations != 0xFFFF)
+                        ++ibp->mkey_violations;
+                if (!ibp->mkey_lease_timeout && ibp->mkey_lease_period)
+                        ibp->mkey_lease_timeout = jiffies +
+                                ibp->mkey_lease_period * HZ;
+                /* Generate a trap notice. */
+                qib_bad_mkey(ibp, smp);
+                ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
+        } else if (ibp->mkey_lease_timeout)
                 ibp->mkey_lease_timeout = 0;
 
-        if (!valid_mkey) {
-                switch (smp->method) {
-                case IB_MGMT_METHOD_GET:
-                        /* Bad mkey not a violation below level 2 */
-                        if (ibp->mkeyprot < 2)
-                                break;
-                case IB_MGMT_METHOD_SET:
-                case IB_MGMT_METHOD_TRAP_REPRESS:
-                        if (ibp->mkey_violations != 0xFFFF)
-                                ++ibp->mkey_violations;
-                        if (!ibp->mkey_lease_timeout && ibp->mkey_lease_period)
-                                ibp->mkey_lease_timeout = jiffies +
-                                        ibp->mkey_lease_period * HZ;
-                        /* Generate a trap notice. */
-                        qib_bad_mkey(ibp, smp);
-                        ret = 1;
-                }
-        }
-
         return ret;
 }
 
@@ -455,6 +433,7 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         struct qib_pportdata *ppd;
         struct qib_ibport *ibp;
         struct ib_port_info *pip = (struct ib_port_info *)smp->data;
+        u16 lid;
         u8 mtu;
         int ret;
         u32 state;
@@ -471,10 +450,8 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                 if (port_num != port) {
                         ibp = to_iport(ibdev, port_num);
                         ret = check_mkey(ibp, smp, 0);
-                        if (ret) {
-                                ret = IB_MAD_RESULT_FAILURE;
+                        if (ret)
                                 goto bail;
-                        }
                 }
         }
 
@@ -492,7 +469,8 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
               ibp->mkeyprot == 1))
                 pip->mkey = ibp->mkey;
         pip->gid_prefix = ibp->gid_prefix;
-        pip->lid = cpu_to_be16(ppd->lid);
+        lid = ppd->lid;
+        pip->lid = lid ? cpu_to_be16(lid) : IB_LID_PERMISSIVE;
         pip->sm_lid = cpu_to_be16(ibp->sm_lid);
         pip->cap_mask = cpu_to_be32(ibp->port_cap_flags);
         /* pip->diag_code; */
@@ -655,7 +633,7 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         struct qib_devdata *dd;
         struct qib_pportdata *ppd;
         struct qib_ibport *ibp;
-        u8 clientrereg = (pip->clientrereg_resv_subnetto & 0x80);
+        char clientrereg = 0;
         unsigned long flags;
         u16 lid, smlid;
         u8 lwe;
@@ -805,6 +783,12 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
 
         ibp->subnet_timeout = pip->clientrereg_resv_subnetto & 0x1F;
 
+        if (pip->clientrereg_resv_subnetto & 0x80) {
+                clientrereg = 1;
+                event.event = IB_EVENT_CLIENT_REREGISTER;
+                ib_dispatch_event(&event);
+        }
+
         /*
          * Do the port state change now that the other link parameters
          * have been set.
@@ -862,15 +846,10 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                 smp->status |= IB_SMP_INVALID_FIELD;
         }
 
-        if (clientrereg) {
-                event.event = IB_EVENT_CLIENT_REREGISTER;
-                ib_dispatch_event(&event);
-        }
-
         ret = subn_get_portinfo(smp, ibdev, port);
 
-        /* restore re-reg bit per o14-12.2.1 */
-        pip->clientrereg_resv_subnetto |= clientrereg;
+        if (clientrereg)
+                pip->clientrereg_resv_subnetto |= 0x80;
 
         goto get_only;
 
@@ -1858,7 +1837,6 @@ static int process_subn(struct ib_device *ibdev, int mad_flags,
                     port_num && port_num <= ibdev->phys_port_cnt &&
                     port != port_num)
                         (void) check_mkey(to_iport(ibdev, port_num), smp, 0);
-                ret = IB_MAD_RESULT_FAILURE;
                 goto bail;
         }
 
@@ -2060,298 +2038,6 @@ bail:
         return ret;
 }
 
-static int cc_get_classportinfo(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev)
-{
-        struct ib_cc_classportinfo_attr *p =
-                (struct ib_cc_classportinfo_attr *)ccp->mgmt_data;
-
-        memset(ccp->mgmt_data, 0, sizeof(ccp->mgmt_data));
-
-        p->base_version = 1;
-        p->class_version = 1;
-        p->cap_mask = 0;
-
-        /*
-         * Expected response time is 4.096 usec. * 2^18 == 1.073741824 sec.
-         */
-        p->resp_time_value = 18;
-
-        return reply((struct ib_smp *) ccp);
-}
-
-static int cc_get_congestion_info(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev, u8 port)
-{
-        struct ib_cc_info_attr *p =
-                (struct ib_cc_info_attr *)ccp->mgmt_data;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-
-        memset(ccp->mgmt_data, 0, sizeof(ccp->mgmt_data));
-
-        p->congestion_info = 0;
-        p->control_table_cap = ppd->cc_max_table_entries;
-
-        return reply((struct ib_smp *) ccp);
-}
-
-static int cc_get_congestion_setting(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev, u8 port)
-{
-        int i;
-        struct ib_cc_congestion_setting_attr *p =
-                (struct ib_cc_congestion_setting_attr *)ccp->mgmt_data;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-        struct ib_cc_congestion_entry_shadow *entries;
-
-        memset(ccp->mgmt_data, 0, sizeof(ccp->mgmt_data));
-
-        spin_lock(&ppd->cc_shadow_lock);
-
-        entries = ppd->congestion_entries_shadow->entries;
-        p->port_control = cpu_to_be16(
-                ppd->congestion_entries_shadow->port_control);
-        p->control_map = cpu_to_be16(
-                ppd->congestion_entries_shadow->control_map);
-        for (i = 0; i < IB_CC_CCS_ENTRIES; i++) {
-                p->entries[i].ccti_increase = entries[i].ccti_increase;
-                p->entries[i].ccti_timer = cpu_to_be16(entries[i].ccti_timer);
-                p->entries[i].trigger_threshold = entries[i].trigger_threshold;
-                p->entries[i].ccti_min = entries[i].ccti_min;
-        }
-
-        spin_unlock(&ppd->cc_shadow_lock);
-
-        return reply((struct ib_smp *) ccp);
-}
-
-static int cc_get_congestion_control_table(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev, u8 port)
-{
-        struct ib_cc_table_attr *p =
-                (struct ib_cc_table_attr *)ccp->mgmt_data;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-        u32 cct_block_index = be32_to_cpu(ccp->attr_mod);
-        u32 max_cct_block;
-        u32 cct_entry;
-        struct ib_cc_table_entry_shadow *entries;
-        int i;
-
-        /* Is the table index more than what is supported? */
-        if (cct_block_index > IB_CC_TABLE_CAP_DEFAULT - 1)
-                goto bail;
-
-        memset(ccp->mgmt_data, 0, sizeof(ccp->mgmt_data));
-
-        spin_lock(&ppd->cc_shadow_lock);
-
-        max_cct_block =
-                (ppd->ccti_entries_shadow->ccti_last_entry + 1)/IB_CCT_ENTRIES;
-        max_cct_block = max_cct_block ? max_cct_block - 1 : 0;
-
-        if (cct_block_index > max_cct_block) {
-                spin_unlock(&ppd->cc_shadow_lock);
-                goto bail;
-        }
-
-        ccp->attr_mod = cpu_to_be32(cct_block_index);
-
-        cct_entry = IB_CCT_ENTRIES * (cct_block_index + 1);
-
-        cct_entry--;
-
-        p->ccti_limit = cpu_to_be16(cct_entry);
-
-        entries = &ppd->ccti_entries_shadow->
-                        entries[IB_CCT_ENTRIES * cct_block_index];
-        cct_entry %= IB_CCT_ENTRIES;
-
-        for (i = 0; i <= cct_entry; i++)
-                p->ccti_entries[i].entry = cpu_to_be16(entries[i].entry);
-
-        spin_unlock(&ppd->cc_shadow_lock);
-
-        return reply((struct ib_smp *) ccp);
-
-bail:
-        return reply_failure((struct ib_smp *) ccp);
-}
-
-static int cc_set_congestion_setting(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev, u8 port)
-{
-        struct ib_cc_congestion_setting_attr *p =
-                (struct ib_cc_congestion_setting_attr *)ccp->mgmt_data;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-        int i;
-
-        ppd->cc_sl_control_map = be16_to_cpu(p->control_map);
-
-        for (i = 0; i < IB_CC_CCS_ENTRIES; i++) {
-                ppd->congestion_entries[i].ccti_increase =
-                        p->entries[i].ccti_increase;
-
-                ppd->congestion_entries[i].ccti_timer =
-                        be16_to_cpu(p->entries[i].ccti_timer);
-
-                ppd->congestion_entries[i].trigger_threshold =
-                        p->entries[i].trigger_threshold;
-
-                ppd->congestion_entries[i].ccti_min =
-                        p->entries[i].ccti_min;
-        }
-
-        return reply((struct ib_smp *) ccp);
-}
-
-static int cc_set_congestion_control_table(struct ib_cc_mad *ccp,
-                                struct ib_device *ibdev, u8 port)
-{
-        struct ib_cc_table_attr *p =
-                (struct ib_cc_table_attr *)ccp->mgmt_data;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-        u32 cct_block_index = be32_to_cpu(ccp->attr_mod);
-        u32 cct_entry;
-        struct ib_cc_table_entry_shadow *entries;
-        int i;
-
-        /* Is the table index more than what is supported? */
-        if (cct_block_index > IB_CC_TABLE_CAP_DEFAULT - 1)
-                goto bail;
-
-        /* If this packet is the first in the sequence then
-         * zero the total table entry count.
-         */
-        if (be16_to_cpu(p->ccti_limit) < IB_CCT_ENTRIES)
-                ppd->total_cct_entry = 0;
-
-        cct_entry = (be16_to_cpu(p->ccti_limit))%IB_CCT_ENTRIES;
-
-        /* ccti_limit is 0 to 63 */
-        ppd->total_cct_entry += (cct_entry + 1);
-
-        if (ppd->total_cct_entry > ppd->cc_supported_table_entries)
-                goto bail;
-
-        ppd->ccti_limit = be16_to_cpu(p->ccti_limit);
-
-        entries = ppd->ccti_entries + (IB_CCT_ENTRIES * cct_block_index);
-
-        for (i = 0; i <= cct_entry; i++)
-                entries[i].entry = be16_to_cpu(p->ccti_entries[i].entry);
-
-        spin_lock(&ppd->cc_shadow_lock);
-
-        ppd->ccti_entries_shadow->ccti_last_entry = ppd->total_cct_entry - 1;
-        memcpy(ppd->ccti_entries_shadow->entries, ppd->ccti_entries,
-                (ppd->total_cct_entry * sizeof(struct ib_cc_table_entry)));
-
-        ppd->congestion_entries_shadow->port_control = IB_CC_CCS_PC_SL_BASED;
-        ppd->congestion_entries_shadow->control_map = ppd->cc_sl_control_map;
-        memcpy(ppd->congestion_entries_shadow->entries, ppd->congestion_entries,
-                IB_CC_CCS_ENTRIES * sizeof(struct ib_cc_congestion_entry));
-
-        spin_unlock(&ppd->cc_shadow_lock);
-
-        return reply((struct ib_smp *) ccp);
-
-bail:
-        return reply_failure((struct ib_smp *) ccp);
-}
-
-static int check_cc_key(struct qib_ibport *ibp,
-                        struct ib_cc_mad *ccp, int mad_flags)
-{
-        return 0;
-}
-
-static int process_cc(struct ib_device *ibdev, int mad_flags,
-                        u8 port, struct ib_mad *in_mad,
-                        struct ib_mad *out_mad)
-{
-        struct ib_cc_mad *ccp = (struct ib_cc_mad *)out_mad;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        int ret;
-
-        *out_mad = *in_mad;
-
-        if (ccp->class_version != 2) {
-                ccp->status |= IB_SMP_UNSUP_VERSION;
-                ret = reply((struct ib_smp *)ccp);
-                goto bail;
-        }
-
-        ret = check_cc_key(ibp, ccp, mad_flags);
-        if (ret)
-                goto bail;
-
-        switch (ccp->method) {
-        case IB_MGMT_METHOD_GET:
-                switch (ccp->attr_id) {
-                case IB_CC_ATTR_CLASSPORTINFO:
-                        ret = cc_get_classportinfo(ccp, ibdev);
-                        goto bail;
-
-                case IB_CC_ATTR_CONGESTION_INFO:
-                        ret = cc_get_congestion_info(ccp, ibdev, port);
-                        goto bail;
-
-                case IB_CC_ATTR_CA_CONGESTION_SETTING:
-                        ret = cc_get_congestion_setting(ccp, ibdev, port);
-                        goto bail;
-
-                case IB_CC_ATTR_CONGESTION_CONTROL_TABLE:
-                        ret = cc_get_congestion_control_table(ccp, ibdev, port);
-                        goto bail;
-
-                        /* FALLTHROUGH */
-                default:
-                        ccp->status |= IB_SMP_UNSUP_METH_ATTR;
-                        ret = reply((struct ib_smp *) ccp);
-                        goto bail;
-                }
-
-        case IB_MGMT_METHOD_SET:
-                switch (ccp->attr_id) {
-                case IB_CC_ATTR_CA_CONGESTION_SETTING:
-                        ret = cc_set_congestion_setting(ccp, ibdev, port);
-                        goto bail;
-
-                case IB_CC_ATTR_CONGESTION_CONTROL_TABLE:
-                        ret = cc_set_congestion_control_table(ccp, ibdev, port);
-                        goto bail;
-
-                        /* FALLTHROUGH */
-                default:
-                        ccp->status |= IB_SMP_UNSUP_METH_ATTR;
-                        ret = reply((struct ib_smp *) ccp);
-                        goto bail;
-                }
-
-        case IB_MGMT_METHOD_GET_RESP:
-                /*
-                 * The ib_mad module will call us to process responses
-                 * before checking for other consumers.
-                 * Just tell the caller to process it normally.
-                 */
-                ret = IB_MAD_RESULT_SUCCESS;
-                goto bail;
-
-        case IB_MGMT_METHOD_TRAP:
-        default:
-                ccp->status |= IB_SMP_UNSUP_METHOD;
-                ret = reply((struct ib_smp *) ccp);
-        }
-
-bail:
-        return ret;
-}
-
 /**
  * qib_process_mad - process an incoming MAD packet
  * @ibdev: the infiniband device this packet came in on
@@ -2376,8 +2062,6 @@ int qib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port,
                     struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
         int ret;
-        struct qib_ibport *ibp = to_iport(ibdev, port);
-        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
 
         switch (in_mad->mad_hdr.mgmt_class) {
         case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
@@ -2389,15 +2073,6 @@ int qib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port,
                 ret = process_perf(ibdev, port, in_mad, out_mad);
                 goto bail;
 
-        case IB_MGMT_CLASS_CONG_MGMT:
-                if (!ppd->congestion_entries_shadow ||
-                         !qib_cc_table_size) {
-                        ret = IB_MAD_RESULT_SUCCESS;
-                        goto bail;
-                }
-                ret = process_cc(ibdev, mad_flags, port, in_mad, out_mad);
-                goto bail;
-
         default:
                 ret = IB_MAD_RESULT_SUCCESS;
         }
diff --git a/drivers/infiniband/hw/qib/qib_mad.h b/drivers/infiniband/hw/qib/qib_mad.h
index 57bd3fa016b..ecc416cdbaa 100644
--- a/drivers/infiniband/hw/qib/qib_mad.h
+++ b/drivers/infiniband/hw/qib/qib_mad.h
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -31,8 +31,6 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#ifndef _QIB_MAD_H
-#define _QIB_MAD_H
 
 #include <rdma/ib_pma.h>
 
@@ -225,198 +223,6 @@ struct ib_pma_portcounters_cong {
 #define IB_PMA_SEL_CONG_ROUTING                 0x08
 
 /*
- * Congestion control class attributes
- */
-#define IB_CC_ATTR_CLASSPORTINFO                        cpu_to_be16(0x0001)
-#define IB_CC_ATTR_NOTICE                               cpu_to_be16(0x0002)
-#define IB_CC_ATTR_CONGESTION_INFO                      cpu_to_be16(0x0011)
-#define IB_CC_ATTR_CONGESTION_KEY_INFO                  cpu_to_be16(0x0012)
-#define IB_CC_ATTR_CONGESTION_LOG                       cpu_to_be16(0x0013)
-#define IB_CC_ATTR_SWITCH_CONGESTION_SETTING            cpu_to_be16(0x0014)
-#define IB_CC_ATTR_SWITCH_PORT_CONGESTION_SETTING       cpu_to_be16(0x0015)
-#define IB_CC_ATTR_CA_CONGESTION_SETTING                cpu_to_be16(0x0016)
-#define IB_CC_ATTR_CONGESTION_CONTROL_TABLE             cpu_to_be16(0x0017)
-#define IB_CC_ATTR_TIME_STAMP                           cpu_to_be16(0x0018)
-
-/* generalizations for threshold values */
-#define IB_CC_THRESHOLD_NONE 0x0
-#define IB_CC_THRESHOLD_MIN  0x1
-#define IB_CC_THRESHOLD_MAX  0xf
-
-/* CCA MAD header constants */
-#define IB_CC_MAD_LOGDATA_LEN 32
-#define IB_CC_MAD_MGMTDATA_LEN 192
-
-struct ib_cc_mad {
-        u8      base_version;
-        u8      mgmt_class;
-        u8      class_version;
-        u8      method;
-        __be16  status;
-        __be16  class_specific;
-        __be64  tid;
-        __be16  attr_id;
-        __be16  resv;
-        __be32  attr_mod;
-        __be64 cckey;
-
-        /* For CongestionLog attribute only */
-        u8 log_data[IB_CC_MAD_LOGDATA_LEN];
-
-        u8 mgmt_data[IB_CC_MAD_MGMTDATA_LEN];
-} __packed;
-
-/*
- * Congestion Control class portinfo capability mask bits
- */
-#define IB_CC_CPI_CM_TRAP_GEN           cpu_to_be16(1 << 0)
-#define IB_CC_CPI_CM_GET_SET_NOTICE     cpu_to_be16(1 << 1)
-#define IB_CC_CPI_CM_CAP2               cpu_to_be16(1 << 2)
-#define IB_CC_CPI_CM_ENHANCEDPORT0_CC   cpu_to_be16(1 << 8)
-
-struct ib_cc_classportinfo_attr {
-        u8 base_version;
-        u8 class_version;
-        __be16 cap_mask;
-        u8 reserved[3];
-        u8 resp_time_value;     /* only lower 5 bits */
-        union ib_gid redirect_gid;
-        __be32 redirect_tc_sl_fl;       /* 8, 4, 20 bits respectively */
-        __be16 redirect_lid;
-        __be16 redirect_pkey;
-        __be32 redirect_qp;     /* only lower 24 bits */
-        __be32 redirect_qkey;
-        union ib_gid trap_gid;
-        __be32 trap_tc_sl_fl;   /* 8, 4, 20 bits respectively */
-        __be16 trap_lid;
-        __be16 trap_pkey;
-        __be32 trap_hl_qp;      /* 8, 24 bits respectively */
-        __be32 trap_qkey;
-} __packed;
-
-/* Congestion control traps */
-#define IB_CC_TRAP_KEY_VIOLATION 0x0000
-
-struct ib_cc_trap_key_violation_attr {
-        __be16 source_lid;
-        u8 method;
-        u8 reserved1;
-        __be16 attrib_id;
-        __be32 attrib_mod;
-        __be32 qp;
-        __be64 cckey;
-        u8 sgid[16];
-        u8 padding[24];
-} __packed;
-
-/* Congestion info flags */
-#define IB_CC_CI_FLAGS_CREDIT_STARVATION 0x1
-#define IB_CC_TABLE_CAP_DEFAULT 31
-
-struct ib_cc_info_attr {
-        __be16 congestion_info;
-        u8  control_table_cap; /* Multiple of 64 entry unit CCTs */
-} __packed;
-
-struct ib_cc_key_info_attr {
-        __be64 cckey;
-        u8  protect;
-        __be16 lease_period;
-        __be16 violations;
-} __packed;
-
-#define IB_CC_CL_CA_LOGEVENTS_LEN 208
-
-struct ib_cc_log_attr {
-        u8 log_type;
-        u8 congestion_flags;
-        __be16 threshold_event_counter;
-        __be16 threshold_congestion_event_map;
-        __be16 current_time_stamp;
-        u8 log_events[IB_CC_CL_CA_LOGEVENTS_LEN];
-} __packed;
-
-#define IB_CC_CLEC_SERVICETYPE_RC 0x0
-#define IB_CC_CLEC_SERVICETYPE_UC 0x1
-#define IB_CC_CLEC_SERVICETYPE_RD 0x2
-#define IB_CC_CLEC_SERVICETYPE_UD 0x3
-
-struct ib_cc_log_event {
-        u8 local_qp_cn_entry;
-        u8 remote_qp_number_cn_entry[3];
-        u8  sl_cn_entry:4;
-        u8  service_type_cn_entry:4;
-        __be32 remote_lid_cn_entry;
-        __be32 timestamp_cn_entry;
-} __packed;
-
-/* Sixteen congestion entries */
-#define IB_CC_CCS_ENTRIES 16
-
-/* Port control flags */
-#define IB_CC_CCS_PC_SL_BASED 0x01
-
-struct ib_cc_congestion_entry {
-        u8 ccti_increase;
-        __be16 ccti_timer;
-        u8 trigger_threshold;
-        u8 ccti_min; /* min CCTI for cc table */
-} __packed;
-
-struct ib_cc_congestion_entry_shadow {
-        u8 ccti_increase;
-        u16 ccti_timer;
-        u8 trigger_threshold;
-        u8 ccti_min; /* min CCTI for cc table */
-} __packed;
-
-struct ib_cc_congestion_setting_attr {
-        __be16 port_control;
-        __be16 control_map;
-        struct ib_cc_congestion_entry entries[IB_CC_CCS_ENTRIES];
-} __packed;
-
-struct ib_cc_congestion_setting_attr_shadow {
-        u16 port_control;
-        u16 control_map;
-        struct ib_cc_congestion_entry_shadow entries[IB_CC_CCS_ENTRIES];
-} __packed;
-
-#define IB_CC_TABLE_ENTRY_INCREASE_DEFAULT 1
-#define IB_CC_TABLE_ENTRY_TIMER_DEFAULT 1
-
-/* 64 Congestion Control table entries in a single MAD */
-#define IB_CCT_ENTRIES 64
-#define IB_CCT_MIN_ENTRIES (IB_CCT_ENTRIES * 2)
-
-struct ib_cc_table_entry {
-        __be16 entry; /* shift:2, multiplier:14 */
-};
-
-struct ib_cc_table_entry_shadow {
-        u16 entry; /* shift:2, multiplier:14 */
-};
-
-struct ib_cc_table_attr {
-        __be16 ccti_limit; /* max CCTI for cc table */
-        struct ib_cc_table_entry ccti_entries[IB_CCT_ENTRIES];
-} __packed;
-
-struct ib_cc_table_attr_shadow {
-        u16 ccti_limit; /* max CCTI for cc table */
-        struct ib_cc_table_entry_shadow ccti_entries[IB_CCT_ENTRIES];
-} __packed;
-
-#define CC_TABLE_SHADOW_MAX \
-        (IB_CC_TABLE_CAP_DEFAULT * IB_CCT_ENTRIES)
-
-struct cc_table_shadow {
-        u16 ccti_last_entry;
-        struct ib_cc_table_entry_shadow entries[CC_TABLE_SHADOW_MAX];
-} __packed;
-
-#endif                          /* _QIB_MAD_H */
-/*
  * The PortSamplesControl.CounterMasks field is an array of 3 bit fields
  * which specify the N'th counter's capabilities. See ch. 16.1.3.2.
  * We support 5 counters which only count the mandatory quantities.
diff --git a/drivers/infiniband/hw/qib/qib_mr.c b/drivers/infiniband/hw/qib/qib_mr.c
index e6687ded821..08944e2ee33 100644
--- a/drivers/infiniband/hw/qib/qib_mr.c
+++ b/drivers/infiniband/hw/qib/qib_mr.c
@@ -47,43 +47,6 @@ static inline struct qib_fmr *to_ifmr(struct ib_fmr *ibfmr)
         return container_of(ibfmr, struct qib_fmr, ibfmr);
 }
 
-static int init_qib_mregion(struct qib_mregion *mr, struct ib_pd *pd,
-        int count)
-{
-        int m, i = 0;
-        int rval = 0;
-
-        m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
-        for (; i < m; i++) {
-                mr->map[i] = kzalloc(sizeof *mr->map[0], GFP_KERNEL);
-                if (!mr->map[i])
-                        goto bail;
-        }
-        mr->mapsz = m;
-        init_completion(&mr->comp);
-        /* count returning the ptr to user */
-        atomic_set(&mr->refcount, 1);
-        mr->pd = pd;
-        mr->max_segs = count;
-out:
-        return rval;
-bail:
-        while (i)
-                kfree(mr->map[--i]);
-        rval = -ENOMEM;
-        goto out;
-}
-
-static void deinit_qib_mregion(struct qib_mregion *mr)
-{
-        int i = mr->mapsz;
-
-        mr->mapsz = 0;
-        while (i)
-                kfree(mr->map[--i]);
-}
-
-
 /**
  * qib_get_dma_mr - get a DMA memory region
  * @pd: protection domain for this memory region
@@ -95,9 +58,10 @@ static void deinit_qib_mregion(struct qib_mregion *mr)
  */
 struct ib_mr *qib_get_dma_mr(struct ib_pd *pd, int acc)
 {
-        struct qib_mr *mr = NULL;
+        struct qib_ibdev *dev = to_idev(pd->device);
+        struct qib_mr *mr;
         struct ib_mr *ret;
-        int rval;
+        unsigned long flags;
 
         if (to_ipd(pd)->user) {
                 ret = ERR_PTR(-EPERM);
@@ -110,64 +74,61 @@ struct ib_mr *qib_get_dma_mr(struct ib_pd *pd, int acc)
                 goto bail;
         }
 
-        rval = init_qib_mregion(&mr->mr, pd, 0);
-        if (rval) {
-                ret = ERR_PTR(rval);
-                goto bail;
-        }
-
+        mr->mr.access_flags = acc;
+        atomic_set(&mr->mr.refcount, 0);
 
-        rval = qib_alloc_lkey(&mr->mr, 1);
-        if (rval) {
-                ret = ERR_PTR(rval);
-                goto bail_mregion;
-        }
+        spin_lock_irqsave(&dev->lk_table.lock, flags);
+        if (!dev->dma_mr)
+                dev->dma_mr = &mr->mr;
+        spin_unlock_irqrestore(&dev->lk_table.lock, flags);
 
-        mr->mr.access_flags = acc;
         ret = &mr->ibmr;
-done:
-        return ret;
 
-bail_mregion:
-        deinit_qib_mregion(&mr->mr);
 bail:
-        kfree(mr);
-        goto done;
+        return ret;
 }
 
-static struct qib_mr *alloc_mr(int count, struct ib_pd *pd)
+static struct qib_mr *alloc_mr(int count, struct qib_lkey_table *lk_table)
 {
         struct qib_mr *mr;
-        int rval = -ENOMEM;
-        int m;
+        int m, i = 0;
 
         /* Allocate struct plus pointers to first level page tables. */
         m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
-        mr = kzalloc(sizeof *mr + m * sizeof mr->mr.map[0], GFP_KERNEL);
+        mr = kmalloc(sizeof *mr + m * sizeof mr->mr.map[0], GFP_KERNEL);
         if (!mr)
-                goto bail;
+                goto done;
+
+        /* Allocate first level page tables. */
+        for (; i < m; i++) {
+                mr->mr.map[i] = kmalloc(sizeof *mr->mr.map[0], GFP_KERNEL);
+                if (!mr->mr.map[i])
+                        goto bail;
+        }
+        mr->mr.mapsz = m;
+        mr->mr.page_shift = 0;
+        mr->mr.max_segs = count;
 
-        rval = init_qib_mregion(&mr->mr, pd, count);
-        if (rval)
-                goto bail;
         /*
          * ib_reg_phys_mr() will initialize mr->ibmr except for
          * lkey and rkey.
          */
-        rval = qib_alloc_lkey(&mr->mr, 0);
-        if (rval)
-                goto bail_mregion;
+        if (!qib_alloc_lkey(lk_table, &mr->mr))
+                goto bail;
         mr->ibmr.lkey = mr->mr.lkey;
         mr->ibmr.rkey = mr->mr.lkey;
-done:
-        return mr;
 
-bail_mregion:
-        deinit_qib_mregion(&mr->mr);
+        atomic_set(&mr->mr.refcount, 0);
+        goto done;
+
 bail:
+        while (i)
+                kfree(mr->mr.map[--i]);
         kfree(mr);
-        mr = ERR_PTR(rval);
-        goto done;
+        mr = NULL;
+
+done:
+        return mr;
 }
 
 /**
@@ -187,15 +148,19 @@ struct ib_mr *qib_reg_phys_mr(struct ib_pd *pd,
         int n, m, i;
         struct ib_mr *ret;
 
-        mr = alloc_mr(num_phys_buf, pd);
-        if (IS_ERR(mr)) {
-                ret = (struct ib_mr *)mr;
+        mr = alloc_mr(num_phys_buf, &to_idev(pd->device)->lk_table);
+        if (mr == NULL) {
+                ret = ERR_PTR(-ENOMEM);
                 goto bail;
         }
 
+        mr->mr.pd = pd;
         mr->mr.user_base = *iova_start;
         mr->mr.iova = *iova_start;
+        mr->mr.length = 0;
+        mr->mr.offset = 0;
         mr->mr.access_flags = acc;
+        mr->umem = NULL;
 
         m = 0;
         n = 0;
@@ -221,6 +186,7 @@ bail:
  * @pd: protection domain for this memory region
  * @start: starting userspace address
  * @length: length of region to register
+ * @virt_addr: virtual address to use (from HCA's point of view)
  * @mr_access_flags: access flags for this memory region
  * @udata: unused by the QLogic_IB driver
  *
@@ -250,13 +216,14 @@ struct ib_mr *qib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         list_for_each_entry(chunk, &umem->chunk_list, list)
                 n += chunk->nents;
 
-        mr = alloc_mr(n, pd);
-        if (IS_ERR(mr)) {
-                ret = (struct ib_mr *)mr;
+        mr = alloc_mr(n, &to_idev(pd->device)->lk_table);
+        if (!mr) {
+                ret = ERR_PTR(-ENOMEM);
                 ib_umem_release(umem);
                 goto bail;
         }
 
+        mr->mr.pd = pd;
         mr->mr.user_base = start;
         mr->mr.iova = virt_addr;
         mr->mr.length = length;
@@ -304,25 +271,21 @@ bail:
 int qib_dereg_mr(struct ib_mr *ibmr)
 {
         struct qib_mr *mr = to_imr(ibmr);
-        int ret = 0;
-        unsigned long timeout;
-
-        qib_free_lkey(&mr->mr);
-
-        qib_put_mr(&mr->mr); /* will set completion if last */
-        timeout = wait_for_completion_timeout(&mr->mr.comp,
-                5 * HZ);
-        if (!timeout) {
-                qib_get_mr(&mr->mr);
-                ret = -EBUSY;
-                goto out;
-        }
-        deinit_qib_mregion(&mr->mr);
+        struct qib_ibdev *dev = to_idev(ibmr->device);
+        int ret;
+        int i;
+
+        ret = qib_free_lkey(dev, &mr->mr);
+        if (ret)
+                return ret;
+
+        i = mr->mr.mapsz;
+        while (i)
+                kfree(mr->mr.map[--i]);
         if (mr->umem)
                 ib_umem_release(mr->umem);
         kfree(mr);
-out:
-        return ret;
+        return 0;
 }
 
 /*
@@ -335,9 +298,17 @@ struct ib_mr *qib_alloc_fast_reg_mr(struct ib_pd *pd, int max_page_list_len)
 {
         struct qib_mr *mr;
 
-        mr = alloc_mr(max_page_list_len, pd);
-        if (IS_ERR(mr))
-                return (struct ib_mr *)mr;
+        mr = alloc_mr(max_page_list_len, &to_idev(pd->device)->lk_table);
+        if (mr == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        mr->mr.pd = pd;
+        mr->mr.user_base = 0;
+        mr->mr.iova = 0;
+        mr->mr.length = 0;
+        mr->mr.offset = 0;
+        mr->mr.access_flags = 0;
+        mr->umem = NULL;
 
         return &mr->ibmr;
 }
@@ -351,11 +322,11 @@ qib_alloc_fast_reg_page_list(struct ib_device *ibdev, int page_list_len)
         if (size > PAGE_SIZE)
                 return ERR_PTR(-EINVAL);
 
-        pl = kzalloc(sizeof *pl, GFP_KERNEL);
+        pl = kmalloc(sizeof *pl, GFP_KERNEL);
         if (!pl)
                 return ERR_PTR(-ENOMEM);
 
-        pl->page_list = kzalloc(size, GFP_KERNEL);
+        pl->page_list = kmalloc(size, GFP_KERNEL);
         if (!pl->page_list)
                 goto err_free;
 
@@ -384,47 +355,57 @@ struct ib_fmr *qib_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
                              struct ib_fmr_attr *fmr_attr)
 {
         struct qib_fmr *fmr;
-        int m;
+        int m, i = 0;
         struct ib_fmr *ret;
-        int rval = -ENOMEM;
 
         /* Allocate struct plus pointers to first level page tables. */
         m = (fmr_attr->max_pages + QIB_SEGSZ - 1) / QIB_SEGSZ;
-        fmr = kzalloc(sizeof *fmr + m * sizeof fmr->mr.map[0], GFP_KERNEL);
+        fmr = kmalloc(sizeof *fmr + m * sizeof fmr->mr.map[0], GFP_KERNEL);
         if (!fmr)
                 goto bail;
 
-        rval = init_qib_mregion(&fmr->mr, pd, fmr_attr->max_pages);
-        if (rval)
-                goto bail;
+        /* Allocate first level page tables. */
+        for (; i < m; i++) {
+                fmr->mr.map[i] = kmalloc(sizeof *fmr->mr.map[0],
+                                         GFP_KERNEL);
+                if (!fmr->mr.map[i])
+                        goto bail;
+        }
+        fmr->mr.mapsz = m;
 
         /*
          * ib_alloc_fmr() will initialize fmr->ibfmr except for lkey &
          * rkey.
          */
-        rval = qib_alloc_lkey(&fmr->mr, 0);
-        if (rval)
-                goto bail_mregion;
+        if (!qib_alloc_lkey(&to_idev(pd->device)->lk_table, &fmr->mr))
+                goto bail;
         fmr->ibfmr.rkey = fmr->mr.lkey;
         fmr->ibfmr.lkey = fmr->mr.lkey;
         /*
          * Resources are allocated but no valid mapping (RKEY can't be
          * used).
          */
+        fmr->mr.pd = pd;
+        fmr->mr.user_base = 0;
+        fmr->mr.iova = 0;
+        fmr->mr.length = 0;
+        fmr->mr.offset = 0;
         fmr->mr.access_flags = mr_access_flags;
         fmr->mr.max_segs = fmr_attr->max_pages;
         fmr->mr.page_shift = fmr_attr->page_shift;
 
+        atomic_set(&fmr->mr.refcount, 0);
         ret = &fmr->ibfmr;
-done:
-        return ret;
+        goto done;
 
-bail_mregion:
-        deinit_qib_mregion(&fmr->mr);
 bail:
+        while (i)
+                kfree(fmr->mr.map[--i]);
         kfree(fmr);
-        ret = ERR_PTR(rval);
-        goto done;
+        ret = ERR_PTR(-ENOMEM);
+
+done:
+        return ret;
 }
 
 /**
@@ -447,8 +428,7 @@ int qib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
         u32 ps;
         int ret;
 
-        i = atomic_read(&fmr->mr.refcount);
-        if (i > 2)
+        if (atomic_read(&fmr->mr.refcount))
                 return -EBUSY;
 
         if (list_len > fmr->mr.max_segs) {
@@ -510,27 +490,16 @@ int qib_unmap_fmr(struct list_head *fmr_list)
 int qib_dealloc_fmr(struct ib_fmr *ibfmr)
 {
         struct qib_fmr *fmr = to_ifmr(ibfmr);
-        int ret = 0;
-        unsigned long timeout;
-
-        qib_free_lkey(&fmr->mr);
-        qib_put_mr(&fmr->mr); /* will set completion if last */
-        timeout = wait_for_completion_timeout(&fmr->mr.comp,
-                5 * HZ);
-        if (!timeout) {
-                qib_get_mr(&fmr->mr);
-                ret = -EBUSY;
-                goto out;
-        }
-        deinit_qib_mregion(&fmr->mr);
-        kfree(fmr);
-out:
-        return ret;
-}
+        int ret;
+        int i;
 
-void mr_rcu_callback(struct rcu_head *list)
-{
-        struct qib_mregion *mr = container_of(list, struct qib_mregion, list);
+        ret = qib_free_lkey(to_idev(ibfmr->device), &fmr->mr);
+        if (ret)
+                return ret;
 
-        complete(&mr->comp);
+        i = fmr->mr.mapsz;
+        while (i)
+                kfree(fmr->mr.map[--i]);
+        kfree(fmr);
+        return 0;
 }
diff --git a/drivers/infiniband/hw/qib/qib_pcie.c b/drivers/infiniband/hw/qib/qib_pcie.c
index c574ec7c85e..4426782ad28 100644
--- a/drivers/infiniband/hw/qib/qib_pcie.c
+++ b/drivers/infiniband/hw/qib/qib_pcie.c
@@ -35,7 +35,6 @@
 #include <linux/delay.h>
 #include <linux/vmalloc.h>
 #include <linux/aer.h>
-#include <linux/module.h>
 
 #include "qib.h"
 
@@ -194,24 +193,11 @@ void qib_pcie_ddcleanup(struct qib_devdata *dd)
 }
 
 static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
-                           struct qib_msix_entry *qib_msix_entry)
+                           struct msix_entry *msix_entry)
 {
         int ret;
         u32 tabsize = 0;
         u16 msix_flags;
-        struct msix_entry *msix_entry;
-        int i;
-
-        /* We can't pass qib_msix_entry array to qib_msix_setup
-         * so use a dummy msix_entry array and copy the allocated
-         * irq back to the qib_msix_entry array. */
-        msix_entry = kmalloc(*msixcnt * sizeof(*msix_entry), GFP_KERNEL);
-        if (!msix_entry) {
-                ret = -ENOMEM;
-                goto do_intx;
-        }
-        for (i = 0; i < *msixcnt; i++)
-                msix_entry[i] = qib_msix_entry[i].msix;
 
         pci_read_config_word(dd->pcidev, pos + PCI_MSIX_FLAGS, &msix_flags);
         tabsize = 1 + (msix_flags & PCI_MSIX_FLAGS_QSIZE);
@@ -222,16 +208,11 @@ static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
                 tabsize = ret;
                 ret = pci_enable_msix(dd->pcidev, msix_entry, tabsize);
         }
-do_intx:
         if (ret) {
-                qib_dev_err(dd,
-                        "pci_enable_msix %d vectors failed: %d, falling back to INTx\n",
-                        tabsize, ret);
+                qib_dev_err(dd, "pci_enable_msix %d vectors failed: %d, "
+                            "falling back to INTx\n", tabsize, ret);
                 tabsize = 0;
         }
-        for (i = 0; i < tabsize; i++)
-                qib_msix_entry[i].msix = msix_entry[i];
-        kfree(msix_entry);
         *msixcnt = tabsize;
 
         if (ret)
@@ -252,9 +233,8 @@ static int qib_msi_setup(struct qib_devdata *dd, int pos)
 
         ret = pci_enable_msi(pdev);
         if (ret)
-                qib_dev_err(dd,
-                        "pci_enable_msi failed: %d, interrupts may not work\n",
-                        ret);
+                qib_dev_err(dd, "pci_enable_msi failed: %d, "
+                            "interrupts may not work\n", ret);
         /* continue even if it fails, we may still be OK... */
 
         pci_read_config_dword(pdev, pos + PCI_MSI_ADDRESS_LO,
@@ -270,12 +250,13 @@ static int qib_msi_setup(struct qib_devdata *dd, int pos)
 }
 
 int qib_pcie_params(struct qib_devdata *dd, u32 minw, u32 *nent,
-                    struct qib_msix_entry *entry)
+                    struct msix_entry *entry)
 {
         u16 linkstat, speed;
-        int pos = 0, ret = 1;
+        int pos = 0, pose, ret = 1;
 
-        if (!pci_is_pcie(dd->pcidev)) {
+        pose = pci_pcie_cap(dd->pcidev);
+        if (!pose) {
                 qib_dev_err(dd, "Can't find PCI Express capability!\n");
                 /* set up something... */
                 dd->lbus_width = 1;
@@ -297,7 +278,7 @@ int qib_pcie_params(struct qib_devdata *dd, u32 minw, u32 *nent,
         if (!pos)
                 qib_enable_intx(dd->pcidev);
 
-        pcie_capability_read_word(dd->pcidev, PCI_EXP_LNKSTA, &linkstat);
+        pci_read_config_word(dd->pcidev, pose + PCI_EXP_LNKSTA, &linkstat);
         /*
          * speed is bits 0-3, linkwidth is bits 4-8
          * no defines for them in headers
@@ -359,8 +340,8 @@ int qib_reinit_intr(struct qib_devdata *dd)
 
         pos = pci_find_capability(dd->pcidev, PCI_CAP_ID_MSI);
         if (!pos) {
-                qib_dev_err(dd,
-                        "Can't find MSI capability, can't restore MSI settings\n");
+                qib_dev_err(dd, "Can't find MSI capability, "
+                            "can't restore MSI settings\n");
                 ret = 0;
                 /* nothing special for MSIx, just MSI */
                 goto bail;
@@ -472,8 +453,8 @@ void qib_pcie_reenable(struct qib_devdata *dd, u16 cmd, u8 iline, u8 cline)
         pci_write_config_byte(dd->pcidev, PCI_CACHE_LINE_SIZE, cline);
         r = pci_enable_device(dd->pcidev);
         if (r)
-                qib_dev_err(dd,
-                        "pci_enable_device failed after reset: %d\n", r);
+                qib_dev_err(dd, "pci_enable_device failed after "
+                            "reset: %d\n", r);
 }
 
 /* code to adjust PCIe capabilities. */
@@ -515,6 +496,7 @@ static int qib_tune_pcie_coalesce(struct qib_devdata *dd)
 {
         int r;
         struct pci_dev *parent;
+        int ppos;
         u16 devid;
         u32 mask, bits, val;
 
@@ -527,7 +509,8 @@ static int qib_tune_pcie_coalesce(struct qib_devdata *dd)
                 qib_devinfo(dd->pcidev, "Parent not root\n");
                 return 1;
         }
-        if (!pci_is_pcie(parent))
+        ppos = pci_pcie_cap(parent);
+        if (!ppos)
                 return 1;
         if (parent->vendor != 0x8086)
                 return 1;
@@ -578,12 +561,13 @@ static int qib_tune_pcie_coalesce(struct qib_devdata *dd)
  */
 static int qib_pcie_caps;
 module_param_named(pcie_caps, qib_pcie_caps, int, S_IRUGO);
-MODULE_PARM_DESC(pcie_caps, "Max PCIe tuning: Payload (0..3), ReadReq (4..7)");
+MODULE_PARM_DESC(pcie_caps, "Max PCIe tuning: Payload (4lsb), ReadReq (D4..7)");
 
 static int qib_tune_pcie_caps(struct qib_devdata *dd)
 {
         int ret = 1; /* Assume the worst */
         struct pci_dev *parent;
+        int ppos, epos;
         u16 pcaps, pctl, ecaps, ectl;
         int rc_sup, ep_sup;
         int rc_cur, ep_cur;
@@ -594,15 +578,19 @@ static int qib_tune_pcie_caps(struct qib_devdata *dd)
                 qib_devinfo(dd->pcidev, "Parent not root\n");
                 goto bail;
         }
-
-        if (!pci_is_pcie(parent) || !pci_is_pcie(dd->pcidev))
+        ppos = pci_pcie_cap(parent);
+        if (ppos) {
+                pci_read_config_word(parent, ppos + PCI_EXP_DEVCAP, &pcaps);
+                pci_read_config_word(parent, ppos + PCI_EXP_DEVCTL, &pctl);
+        } else
                 goto bail;
-        pcie_capability_read_word(parent, PCI_EXP_DEVCAP, &pcaps);
-        pcie_capability_read_word(parent, PCI_EXP_DEVCTL, &pctl);
         /* Find out supported and configured values for endpoint (us) */
-        pcie_capability_read_word(dd->pcidev, PCI_EXP_DEVCAP, &ecaps);
-        pcie_capability_read_word(dd->pcidev, PCI_EXP_DEVCTL, &ectl);
-
+        epos = pci_pcie_cap(dd->pcidev);
+        if (epos) {
+                pci_read_config_word(dd->pcidev, epos + PCI_EXP_DEVCAP, &ecaps);
+                pci_read_config_word(dd->pcidev, epos + PCI_EXP_DEVCTL, &ectl);
+        } else
+                goto bail;
         ret = 0;
         /* Find max payload supported by root, endpoint */
         rc_sup = fld2val(pcaps, PCI_EXP_DEVCAP_PAYLOAD);
@@ -621,14 +609,14 @@ static int qib_tune_pcie_caps(struct qib_devdata *dd)
                 rc_cur = rc_sup;
                 pctl = (pctl & ~PCI_EXP_DEVCTL_PAYLOAD) |
                         val2fld(rc_cur, PCI_EXP_DEVCTL_PAYLOAD);
-                pcie_capability_write_word(parent, PCI_EXP_DEVCTL, pctl);
+                pci_write_config_word(parent, ppos + PCI_EXP_DEVCTL, pctl);
         }
         /* If less than (allowed, supported), bump endpoint payload */
         if (rc_sup > ep_cur) {
                 ep_cur = rc_sup;
                 ectl = (ectl & ~PCI_EXP_DEVCTL_PAYLOAD) |
                         val2fld(ep_cur, PCI_EXP_DEVCTL_PAYLOAD);
-                pcie_capability_write_word(dd->pcidev, PCI_EXP_DEVCTL, ectl);
+                pci_write_config_word(dd->pcidev, epos + PCI_EXP_DEVCTL, ectl);
         }
 
         /*
@@ -646,13 +634,13 @@ static int qib_tune_pcie_caps(struct qib_devdata *dd)
                 rc_cur = rc_sup;
                 pctl = (pctl & ~PCI_EXP_DEVCTL_READRQ) |
                         val2fld(rc_cur, PCI_EXP_DEVCTL_READRQ);
-                pcie_capability_write_word(parent, PCI_EXP_DEVCTL, pctl);
+                pci_write_config_word(parent, ppos + PCI_EXP_DEVCTL, pctl);
         }
         if (rc_sup > ep_cur) {
                 ep_cur = rc_sup;
                 ectl = (ectl & ~PCI_EXP_DEVCTL_READRQ) |
                         val2fld(ep_cur, PCI_EXP_DEVCTL_READRQ);
-                pcie_capability_write_word(dd->pcidev, PCI_EXP_DEVCTL, ectl);
+                pci_write_config_word(dd->pcidev, epos + PCI_EXP_DEVCTL, ectl);
         }
 bail:
         return ret;
@@ -711,16 +699,15 @@ qib_pci_mmio_enabled(struct pci_dev *pdev)
                 if (words == ~0ULL)
                         ret = PCI_ERS_RESULT_NEED_RESET;
         }
-        qib_devinfo(pdev,
-                "QIB mmio_enabled function called, read wordscntr %Lx, returning %d\n",
-                words, ret);
+        qib_devinfo(pdev, "QIB mmio_enabled function called, "
+                 "read wordscntr %Lx, returning %d\n", words, ret);
         return  ret;
 }
 
 static pci_ers_result_t
 qib_pci_slot_reset(struct pci_dev *pdev)
 {
-        qib_devinfo(pdev, "QIB slot_reset function called, ignored\n");
+        qib_devinfo(pdev, "QIB link_reset function called, ignored\n");
         return PCI_ERS_RESULT_CAN_RECOVER;
 }
 
@@ -745,7 +732,7 @@ qib_pci_resume(struct pci_dev *pdev)
         qib_init(dd, 1); /* same as re-init after reset */
 }
 
-const struct pci_error_handlers qib_pci_err_handler = {
+struct pci_error_handlers qib_pci_err_handler = {
         .error_detected = qib_pci_error_detected,
         .mmio_enabled = qib_pci_mmio_enabled,
         .link_reset = qib_pci_link_reset,
diff --git a/drivers/infiniband/hw/qib/qib_qp.c b/drivers/infiniband/hw/qib/qib_qp.c
index 4850d03870c..e16751f8639 100644
--- a/drivers/infiniband/hw/qib/qib_qp.c
+++ b/drivers/infiniband/hw/qib/qib_qp.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation.  * All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -34,7 +34,6 @@
 
 #include <linux/err.h>
 #include <linux/vmalloc.h>
-#include <linux/jhash.h>
 
 #include "qib.h"
 
@@ -205,13 +204,6 @@ static void free_qpn(struct qib_qpn_table *qpt, u32 qpn)
                 clear_bit(qpn & BITS_PER_PAGE_MASK, map->page);
 }
 
-static inline unsigned qpn_hash(struct qib_ibdev *dev, u32 qpn)
-{
-        return jhash_1word(qpn, dev->qp_rnd) &
-                (dev->qp_table_size - 1);
-}
-
-
 /*
  * Put the QP into the hash table.
  * The hash table holds a reference to the QP.
@@ -219,23 +211,22 @@ static inline unsigned qpn_hash(struct qib_ibdev *dev, u32 qpn)
 static void insert_qp(struct qib_ibdev *dev, struct qib_qp *qp)
 {
         struct qib_ibport *ibp = to_iport(qp->ibqp.device, qp->port_num);
+        unsigned n = qp->ibqp.qp_num % dev->qp_table_size;
         unsigned long flags;
-        unsigned n = qpn_hash(dev, qp->ibqp.qp_num);
 
         spin_lock_irqsave(&dev->qpt_lock, flags);
-        atomic_inc(&qp->refcount);
 
         if (qp->ibqp.qp_num == 0)
-                rcu_assign_pointer(ibp->qp0, qp);
+                ibp->qp0 = qp;
         else if (qp->ibqp.qp_num == 1)
-                rcu_assign_pointer(ibp->qp1, qp);
+                ibp->qp1 = qp;
         else {
                 qp->next = dev->qp_table[n];
-                rcu_assign_pointer(dev->qp_table[n], qp);
+                dev->qp_table[n] = qp;
         }
+        atomic_inc(&qp->refcount);
 
         spin_unlock_irqrestore(&dev->qpt_lock, flags);
-        synchronize_rcu();
 }
 
 /*
@@ -245,42 +236,29 @@ static void insert_qp(struct qib_ibdev *dev, struct qib_qp *qp)
 static void remove_qp(struct qib_ibdev *dev, struct qib_qp *qp)
 {
         struct qib_ibport *ibp = to_iport(qp->ibqp.device, qp->port_num);
-        unsigned n = qpn_hash(dev, qp->ibqp.qp_num);
+        struct qib_qp *q, **qpp;
         unsigned long flags;
 
+        qpp = &dev->qp_table[qp->ibqp.qp_num % dev->qp_table_size];
+
         spin_lock_irqsave(&dev->qpt_lock, flags);
 
-        if (rcu_dereference_protected(ibp->qp0,
-                        lockdep_is_held(&dev->qpt_lock)) == qp) {
+        if (ibp->qp0 == qp) {
+                ibp->qp0 = NULL;
                 atomic_dec(&qp->refcount);
-                rcu_assign_pointer(ibp->qp0, NULL);
-        } else if (rcu_dereference_protected(ibp->qp1,
-                        lockdep_is_held(&dev->qpt_lock)) == qp) {
+        } else if (ibp->qp1 == qp) {
+                ibp->qp1 = NULL;
                 atomic_dec(&qp->refcount);
-                rcu_assign_pointer(ibp->qp1, NULL);
-        } else {
-                struct qib_qp *q;
-                struct qib_qp __rcu **qpp;
-
-                qpp = &dev->qp_table[n];
-                q = rcu_dereference_protected(*qpp,
-                        lockdep_is_held(&dev->qpt_lock));
-                for (; q; qpp = &q->next) {
+        } else
+                for (; (q = *qpp) != NULL; qpp = &q->next)
                         if (q == qp) {
-                                atomic_dec(&qp->refcount);
                                 *qpp = qp->next;
-                                rcu_assign_pointer(qp->next, NULL);
-                                q = rcu_dereference_protected(*qpp,
-                                        lockdep_is_held(&dev->qpt_lock));
+                                qp->next = NULL;
+                                atomic_dec(&qp->refcount);
                                 break;
                         }
-                        q = rcu_dereference_protected(*qpp,
-                                lockdep_is_held(&dev->qpt_lock));
-                }
-        }
 
         spin_unlock_irqrestore(&dev->qpt_lock, flags);
-        synchronize_rcu();
 }
 
 /**
@@ -302,26 +280,21 @@ unsigned qib_free_all_qps(struct qib_devdata *dd)
 
                 if (!qib_mcast_tree_empty(ibp))
                         qp_inuse++;
-                rcu_read_lock();
-                if (rcu_dereference(ibp->qp0))
+                if (ibp->qp0)
                         qp_inuse++;
-                if (rcu_dereference(ibp->qp1))
+                if (ibp->qp1)
                         qp_inuse++;
-                rcu_read_unlock();
         }
 
         spin_lock_irqsave(&dev->qpt_lock, flags);
         for (n = 0; n < dev->qp_table_size; n++) {
-                qp = rcu_dereference_protected(dev->qp_table[n],
-                        lockdep_is_held(&dev->qpt_lock));
-                rcu_assign_pointer(dev->qp_table[n], NULL);
+                qp = dev->qp_table[n];
+                dev->qp_table[n] = NULL;
 
-                for (; qp; qp = rcu_dereference_protected(qp->next,
-                                        lockdep_is_held(&dev->qpt_lock)))
+                for (; qp; qp = qp->next)
                         qp_inuse++;
         }
         spin_unlock_irqrestore(&dev->qpt_lock, flags);
-        synchronize_rcu();
 
         return qp_inuse;
 }
@@ -336,29 +309,25 @@ unsigned qib_free_all_qps(struct qib_devdata *dd)
  */
 struct qib_qp *qib_lookup_qpn(struct qib_ibport *ibp, u32 qpn)
 {
-        struct qib_qp *qp = NULL;
+        struct qib_ibdev *dev = &ppd_from_ibp(ibp)->dd->verbs_dev;
+        unsigned long flags;
+        struct qib_qp *qp;
 
-        if (unlikely(qpn <= 1)) {
-                rcu_read_lock();
-                if (qpn == 0)
-                        qp = rcu_dereference(ibp->qp0);
-                else
-                        qp = rcu_dereference(ibp->qp1);
-        } else {
-                struct qib_ibdev *dev = &ppd_from_ibp(ibp)->dd->verbs_dev;
-                unsigned n = qpn_hash(dev, qpn);
+        spin_lock_irqsave(&dev->qpt_lock, flags);
 
-                rcu_read_lock();
-                for (qp = rcu_dereference(dev->qp_table[n]); qp;
-                        qp = rcu_dereference(qp->next))
+        if (qpn == 0)
+                qp = ibp->qp0;
+        else if (qpn == 1)
+                qp = ibp->qp1;
+        else
+                for (qp = dev->qp_table[qpn % dev->qp_table_size]; qp;
+                     qp = qp->next)
                         if (qp->ibqp.qp_num == qpn)
                                 break;
-        }
         if (qp)
-                if (unlikely(!atomic_inc_not_zero(&qp->refcount)))
-                        qp = NULL;
+                atomic_inc(&qp->refcount);
 
-        rcu_read_unlock();
+        spin_unlock_irqrestore(&dev->qpt_lock, flags);
         return qp;
 }
 
@@ -419,9 +388,18 @@ static void clear_mr_refs(struct qib_qp *qp, int clr_sends)
         unsigned n;
 
         if (test_and_clear_bit(QIB_R_REWIND_SGE, &qp->r_aflags))
-                qib_put_ss(&qp->s_rdma_read_sge);
+                while (qp->s_rdma_read_sge.num_sge) {
+                        atomic_dec(&qp->s_rdma_read_sge.sge.mr->refcount);
+                        if (--qp->s_rdma_read_sge.num_sge)
+                                qp->s_rdma_read_sge.sge =
+                                        *qp->s_rdma_read_sge.sg_list++;
+                }
 
-        qib_put_ss(&qp->r_sge);
+        while (qp->r_sge.num_sge) {
+                atomic_dec(&qp->r_sge.sge.mr->refcount);
+                if (--qp->r_sge.num_sge)
+                        qp->r_sge.sge = *qp->r_sge.sg_list++;
+        }
 
         if (clr_sends) {
                 while (qp->s_last != qp->s_head) {
@@ -431,7 +409,7 @@ static void clear_mr_refs(struct qib_qp *qp, int clr_sends)
                         for (i = 0; i < wqe->wr.num_sge; i++) {
                                 struct qib_sge *sge = &wqe->sg_list[i];
 
-                                qib_put_mr(sge->mr);
+                                atomic_dec(&sge->mr->refcount);
                         }
                         if (qp->ibqp.qp_type == IB_QPT_UD ||
                             qp->ibqp.qp_type == IB_QPT_SMI ||
@@ -441,7 +419,7 @@ static void clear_mr_refs(struct qib_qp *qp, int clr_sends)
                                 qp->s_last = 0;
                 }
                 if (qp->s_rdma_mr) {
-                        qib_put_mr(qp->s_rdma_mr);
+                        atomic_dec(&qp->s_rdma_mr->refcount);
                         qp->s_rdma_mr = NULL;
                 }
         }
@@ -454,7 +432,7 @@ static void clear_mr_refs(struct qib_qp *qp, int clr_sends)
 
                 if (e->opcode == IB_OPCODE_RC_RDMA_READ_REQUEST &&
                     e->rdma_sge.mr) {
-                        qib_put_mr(e->rdma_sge.mr);
+                        atomic_dec(&e->rdma_sge.mr->refcount);
                         e->rdma_sge.mr = NULL;
                 }
         }
@@ -499,7 +477,7 @@ int qib_error_qp(struct qib_qp *qp, enum ib_wc_status err)
         if (!(qp->s_flags & QIB_S_BUSY)) {
                 qp->s_hdrwords = 0;
                 if (qp->s_rdma_mr) {
-                        qib_put_mr(qp->s_rdma_mr);
+                        atomic_dec(&qp->s_rdma_mr->refcount);
                         qp->s_rdma_mr = NULL;
                 }
                 if (qp->s_tx) {
@@ -787,10 +765,8 @@ int qib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                 }
         }
 
-        if (attr_mask & IB_QP_PATH_MTU) {
+        if (attr_mask & IB_QP_PATH_MTU)
                 qp->path_mtu = pmtu;
-                qp->pmtu = ib_mtu_enum_to_int(pmtu);
-        }
 
         if (attr_mask & IB_QP_RETRY_CNT) {
                 qp->s_retry_cnt = attr->retry_cnt;
@@ -805,12 +781,8 @@ int qib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         if (attr_mask & IB_QP_MIN_RNR_TIMER)
                 qp->r_min_rnr_timer = attr->min_rnr_timer;
 
-        if (attr_mask & IB_QP_TIMEOUT) {
+        if (attr_mask & IB_QP_TIMEOUT)
                 qp->timeout = attr->timeout;
-                qp->timeout_jiffies =
-                        usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
-                                1000UL);
-        }
 
         if (attr_mask & IB_QP_QKEY)
                 qp->qkey = attr->qkey;
@@ -1041,15 +1013,6 @@ struct ib_qp *qib_create_qp(struct ib_pd *ibpd,
                         ret = ERR_PTR(-ENOMEM);
                         goto bail_swq;
                 }
-                RCU_INIT_POINTER(qp->next, NULL);
-                qp->s_hdr = kzalloc(sizeof(*qp->s_hdr), GFP_KERNEL);
-                if (!qp->s_hdr) {
-                        ret = ERR_PTR(-ENOMEM);
-                        goto bail_qp;
-                }
-                qp->timeout_jiffies =
-                        usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
-                                1000UL);
                 if (init_attr->srq)
                         sz = 0;
                 else {
@@ -1168,7 +1131,6 @@ bail_ip:
                 vfree(qp->r_rq.wq);
         free_qpn(&dev->qpn_table, qp->ibqp.qp_num);
 bail_qp:
-        kfree(qp->s_hdr);
         kfree(qp);
 bail_swq:
         vfree(swq);
@@ -1224,7 +1186,6 @@ int qib_destroy_qp(struct ib_qp *ibqp)
         else
                 vfree(qp->r_rq.wq);
         vfree(qp->s_wq);
-        kfree(qp->s_hdr);
         kfree(qp);
         return 0;
 }
diff --git a/drivers/infiniband/hw/qib/qib_qsfp.c b/drivers/infiniband/hw/qib/qib_qsfp.c
index fa71b1e666c..3374a52232c 100644
--- a/drivers/infiniband/hw/qib/qib_qsfp.c
+++ b/drivers/infiniband/hw/qib/qib_qsfp.c
@@ -273,12 +273,18 @@ int qib_refresh_qsfp_cache(struct qib_pportdata *ppd, struct qib_qsfp_cache *cp)
         int ret;
         int idx;
         u16 cks;
+        u32 mask;
         u8 peek[4];
 
         /* ensure sane contents on invalid reads, for cable swaps */
         memset(cp, 0, sizeof(*cp));
 
-        if (!qib_qsfp_mod_present(ppd)) {
+        mask = QSFP_GPIO_MOD_PRS_N;
+        if (ppd->hw_pidx)
+                mask <<= QSFP_GPIO_PORT2_SHIFT;
+
+        ret = ppd->dd->f_gpio_mod(ppd->dd, 0, 0, 0);
+        if (ret & mask) {
                 ret = -ENODEV;
                 goto bail;
         }
@@ -438,19 +444,6 @@ const char * const qib_qsfp_devtech[16] = {
 
 static const char *pwr_codes = "1.5W2.0W2.5W3.5W";
 
-int qib_qsfp_mod_present(struct qib_pportdata *ppd)
-{
-        u32 mask;
-        int ret;
-
-        mask = QSFP_GPIO_MOD_PRS_N <<
-                (ppd->hw_pidx * QSFP_GPIO_PORT2_SHIFT);
-        ret = ppd->dd->f_gpio_mod(ppd->dd, 0, 0, 0);
-
-        return !((ret & mask) >>
-                 ((ppd->hw_pidx * QSFP_GPIO_PORT2_SHIFT) + 3));
-}
-
 /*
  * Initialize structures that control access to QSFP. Called once per port
  * on cards that support QSFP.
@@ -459,6 +452,7 @@ void qib_qsfp_init(struct qib_qsfp_data *qd,
                    void (*fevent)(struct work_struct *))
 {
         u32 mask, highs;
+        int pins;
 
         struct qib_devdata *dd = qd->ppd->dd;
 
@@ -480,6 +474,19 @@ void qib_qsfp_init(struct qib_qsfp_data *qd,
         udelay(20); /* Generous RST dwell */
 
         dd->f_gpio_mod(dd, mask, mask, mask);
+        /* Spec says module can take up to two seconds! */
+        mask = QSFP_GPIO_MOD_PRS_N;
+        if (qd->ppd->hw_pidx)
+                mask <<= QSFP_GPIO_PORT2_SHIFT;
+
+        /* Do not try to wait here. Better to let event handle it */
+        pins = dd->f_gpio_mod(dd, 0, 0, 0);
+        if (pins & mask)
+                goto bail;
+        /* We see a module, but it may be unwise to look yet. Just schedule */
+        qd->t_insert = get_jiffies_64();
+        queue_work(ib_wq, &qd->work);
+bail:
         return;
 }
 
diff --git a/drivers/infiniband/hw/qib/qib_qsfp.h b/drivers/infiniband/hw/qib/qib_qsfp.h
index 91908f533a2..c109bbdc90a 100644
--- a/drivers/infiniband/hw/qib/qib_qsfp.h
+++ b/drivers/infiniband/hw/qib/qib_qsfp.h
@@ -34,7 +34,6 @@
 
 #define QSFP_DEV 0xA0
 #define QSFP_PWR_LAG_MSEC 2000
-#define QSFP_MODPRS_LAG_MSEC 20
 
 /*
  * Below are masks for various QSFP signals, for Port 1.
@@ -177,13 +176,11 @@ struct qib_qsfp_data {
         struct qib_pportdata *ppd;
         struct work_struct work;
         struct qib_qsfp_cache cache;
-        unsigned long t_insert;
-        u8 modpresent;
+        u64 t_insert;
 };
 
 extern int qib_refresh_qsfp_cache(struct qib_pportdata *ppd,
                                   struct qib_qsfp_cache *cp);
-extern int qib_qsfp_mod_present(struct qib_pportdata *ppd);
 extern void qib_qsfp_init(struct qib_qsfp_data *qd,
                           void (*fevent)(struct work_struct *));
 extern void qib_qsfp_deinit(struct qib_qsfp_data *qd);
diff --git a/drivers/infiniband/hw/qib/qib_rc.c b/drivers/infiniband/hw/qib/qib_rc.c
index 3ab341320ea..eca0c41f122 100644
--- a/drivers/infiniband/hw/qib/qib_rc.c
+++ b/drivers/infiniband/hw/qib/qib_rc.c
@@ -59,7 +59,8 @@ static void start_timer(struct qib_qp *qp)
         qp->s_flags |= QIB_S_TIMER;
         qp->s_timer.function = rc_timeout;
         /* 4.096 usec. * (1 << qp->timeout) */
-        qp->s_timer.expires = jiffies + qp->timeout_jiffies;
+        qp->s_timer.expires = jiffies +
+                usecs_to_jiffies((4096UL * (1UL << qp->timeout)) / 1000UL);
         add_timer(&qp->s_timer);
 }
 
@@ -95,7 +96,7 @@ static int qib_make_rc_ack(struct qib_ibdev *dev, struct qib_qp *qp,
         case OP(RDMA_READ_RESPONSE_ONLY):
                 e = &qp->s_ack_queue[qp->s_tail_ack_queue];
                 if (e->rdma_sge.mr) {
-                        qib_put_mr(e->rdma_sge.mr);
+                        atomic_dec(&e->rdma_sge.mr->refcount);
                         e->rdma_sge.mr = NULL;
                 }
                 /* FALLTHROUGH */
@@ -133,7 +134,7 @@ static int qib_make_rc_ack(struct qib_ibdev *dev, struct qib_qp *qp,
                         /* Copy SGE state in case we need to resend */
                         qp->s_rdma_mr = e->rdma_sge.mr;
                         if (qp->s_rdma_mr)
-                                qib_get_mr(qp->s_rdma_mr);
+                                atomic_inc(&qp->s_rdma_mr->refcount);
                         qp->s_ack_rdma_sge.sge = e->rdma_sge;
                         qp->s_ack_rdma_sge.num_sge = 1;
                         qp->s_cur_sge = &qp->s_ack_rdma_sge;
@@ -172,7 +173,7 @@ static int qib_make_rc_ack(struct qib_ibdev *dev, struct qib_qp *qp,
                 qp->s_cur_sge = &qp->s_ack_rdma_sge;
                 qp->s_rdma_mr = qp->s_ack_rdma_sge.sge.mr;
                 if (qp->s_rdma_mr)
-                        qib_get_mr(qp->s_rdma_mr);
+                        atomic_inc(&qp->s_rdma_mr->refcount);
                 len = qp->s_ack_rdma_sge.sge.sge_length;
                 if (len > pmtu)
                         len = pmtu;
@@ -238,15 +239,15 @@ int qib_make_rc_req(struct qib_qp *qp)
         u32 len;
         u32 bth0;
         u32 bth2;
-        u32 pmtu = qp->pmtu;
+        u32 pmtu = ib_mtu_enum_to_int(qp->path_mtu);
         char newreq;
         unsigned long flags;
         int ret = 0;
         int delta;
 
-        ohdr = &qp->s_hdr->u.oth;
+        ohdr = &qp->s_hdr.u.oth;
         if (qp->remote_ah_attr.ah_flags & IB_AH_GRH)
-                ohdr = &qp->s_hdr->u.l.oth;
+                ohdr = &qp->s_hdr.u.l.oth;
 
         /*
          * The lock is needed to synchronize between the sending tasklet,
@@ -271,9 +272,13 @@ int qib_make_rc_req(struct qib_qp *qp)
                         goto bail;
                 }
                 wqe = get_swqe_ptr(qp, qp->s_last);
-                qib_send_complete(qp, wqe, qp->s_last != qp->s_acked ?
-                        IB_WC_SUCCESS : IB_WC_WR_FLUSH_ERR);
-                /* will get called again */
+                while (qp->s_last != qp->s_acked) {
+                        qib_send_complete(qp, wqe, IB_WC_SUCCESS);
+                        if (++qp->s_last >= qp->s_size)
+                                qp->s_last = 0;
+                        wqe = get_swqe_ptr(qp, qp->s_last);
+                }
+                qib_send_complete(qp, wqe, IB_WC_WR_FLUSH_ERR);
                 goto done;
         }
 
@@ -1012,7 +1017,7 @@ void qib_rc_send_complete(struct qib_qp *qp, struct qib_ib_header *hdr)
                 for (i = 0; i < wqe->wr.num_sge; i++) {
                         struct qib_sge *sge = &wqe->sg_list[i];
 
-                        qib_put_mr(sge->mr);
+                        atomic_dec(&sge->mr->refcount);
                 }
                 /* Post a send completion queue entry if requested. */
                 if (!(qp->s_flags & QIB_S_SIGNAL_REQ_WR) ||
@@ -1068,7 +1073,7 @@ static struct qib_swqe *do_rc_completion(struct qib_qp *qp,
                 for (i = 0; i < wqe->wr.num_sge; i++) {
                         struct qib_sge *sge = &wqe->sg_list[i];
 
-                        qib_put_mr(sge->mr);
+                        atomic_dec(&sge->mr->refcount);
                 }
                 /* Post a send completion queue entry if requested. */
                 if (!(qp->s_flags & QIB_S_SIGNAL_REQ_WR) ||
@@ -1514,7 +1519,9 @@ read_middle:
                  * 4.096 usec. * (1 << qp->timeout)
                  */
                 qp->s_flags |= QIB_S_TIMER;
-                mod_timer(&qp->s_timer, jiffies + qp->timeout_jiffies);
+                mod_timer(&qp->s_timer, jiffies +
+                        usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
+                                         1000UL));
                 if (qp->s_flags & QIB_S_WAIT_ACK) {
                         qp->s_flags &= ~QIB_S_WAIT_ACK;
                         qib_schedule_send(qp);
@@ -1725,12 +1732,12 @@ static int qib_rc_rcv_error(struct qib_other_headers *ohdr,
                  * same request.
                  */
                 offset = ((psn - e->psn) & QIB_PSN_MASK) *
-                        qp->pmtu;
+                        ib_mtu_enum_to_int(qp->path_mtu);
                 len = be32_to_cpu(reth->length);
                 if (unlikely(offset + len != e->rdma_sge.sge_length))
                         goto unlock_done;
                 if (e->rdma_sge.mr) {
-                        qib_put_mr(e->rdma_sge.mr);
+                        atomic_dec(&e->rdma_sge.mr->refcount);
                         e->rdma_sge.mr = NULL;
                 }
                 if (len != 0) {
@@ -1869,7 +1876,7 @@ void qib_rc_rcv(struct qib_ctxtdata *rcd, struct qib_ib_header *hdr,
         u32 psn;
         u32 pad;
         struct ib_wc wc;
-        u32 pmtu = qp->pmtu;
+        u32 pmtu = ib_mtu_enum_to_int(qp->path_mtu);
         int diff;
         struct ib_reth *reth;
         unsigned long flags;
@@ -1885,8 +1892,10 @@ void qib_rc_rcv(struct qib_ctxtdata *rcd, struct qib_ib_header *hdr,
         }
 
         opcode = be32_to_cpu(ohdr->bth[0]);
+        spin_lock_irqsave(&qp->s_lock, flags);
         if (qib_ruc_check_hdr(ibp, hdr, has_grh, qp, opcode))
-                return;
+                goto sunlock;
+        spin_unlock_irqrestore(&qp->s_lock, flags);
 
         psn = be32_to_cpu(ohdr->bth[2]);
         opcode >>= 24;
@@ -1946,6 +1955,8 @@ void qib_rc_rcv(struct qib_ctxtdata *rcd, struct qib_ib_header *hdr,
                 break;
         }
 
+        memset(&wc, 0, sizeof wc);
+
         if (qp->state == IB_QPS_RTR && !(qp->r_flags & QIB_R_COMM_EST)) {
                 qp->r_flags |= QIB_R_COMM_EST;
                 if (qp->ibqp.event_handler) {
@@ -1998,19 +2009,16 @@ send_middle:
                         goto rnr_nak;
                 qp->r_rcv_len = 0;
                 if (opcode == OP(SEND_ONLY))
-                        goto no_immediate_data;
-                /* FALLTHROUGH for SEND_ONLY_WITH_IMMEDIATE */
+                        goto send_last;
+                /* FALLTHROUGH */
         case OP(SEND_LAST_WITH_IMMEDIATE):
 send_last_imm:
                 wc.ex.imm_data = ohdr->u.imm_data;
                 hdrsize += 4;
                 wc.wc_flags = IB_WC_WITH_IMM;
-                goto send_last;
+                /* FALLTHROUGH */
         case OP(SEND_LAST):
         case OP(RDMA_WRITE_LAST):
-no_immediate_data:
-                wc.wc_flags = 0;
-                wc.ex.imm_data = 0;
 send_last:
                 /* Get the number of bytes the message was padded by. */
                 pad = (be32_to_cpu(ohdr->bth[0]) >> 20) & 3;
@@ -2024,7 +2032,11 @@ send_last:
                 if (unlikely(wc.byte_len > qp->r_len))
                         goto nack_inv;
                 qib_copy_sge(&qp->r_sge, data, tlen, 1);
-                qib_put_ss(&qp->r_sge);
+                while (qp->r_sge.num_sge) {
+                        atomic_dec(&qp->r_sge.sge.mr->refcount);
+                        if (--qp->r_sge.num_sge)
+                                qp->r_sge.sge = *qp->r_sge.sg_list++;
+                }
                 qp->r_msn++;
                 if (!test_and_clear_bit(QIB_R_WRID_VALID, &qp->r_aflags))
                         break;
@@ -2039,11 +2051,6 @@ send_last:
                 wc.src_qp = qp->remote_qpn;
                 wc.slid = qp->remote_ah_attr.dlid;
                 wc.sl = qp->remote_ah_attr.sl;
-                /* zero fields that are N/A */
-                wc.vendor_err = 0;
-                wc.pkey_index = 0;
-                wc.dlid_path_bits = 0;
-                wc.port_num = 0;
                 /* Signal completion event if the solicited bit is set. */
                 qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
                              (ohdr->bth[0] &
@@ -2082,7 +2089,7 @@ send_last:
                 if (opcode == OP(RDMA_WRITE_FIRST))
                         goto send_middle;
                 else if (opcode == OP(RDMA_WRITE_ONLY))
-                        goto no_immediate_data;
+                        goto send_last;
                 ret = qib_get_rwqe(qp, 1);
                 if (ret < 0)
                         goto nack_op_err;
@@ -2112,7 +2119,7 @@ send_last:
                 }
                 e = &qp->s_ack_queue[qp->r_head_ack_queue];
                 if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {
-                        qib_put_mr(e->rdma_sge.mr);
+                        atomic_dec(&e->rdma_sge.mr->refcount);
                         e->rdma_sge.mr = NULL;
                 }
                 reth = &ohdr->u.rc.reth;
@@ -2184,7 +2191,7 @@ send_last:
                 }
                 e = &qp->s_ack_queue[qp->r_head_ack_queue];
                 if (e->opcode == OP(RDMA_READ_REQUEST) && e->rdma_sge.mr) {
-                        qib_put_mr(e->rdma_sge.mr);
+                        atomic_dec(&e->rdma_sge.mr->refcount);
                         e->rdma_sge.mr = NULL;
                 }
                 ateth = &ohdr->u.atomic_eth;
@@ -2206,7 +2213,7 @@ send_last:
                         (u64) cmpxchg((u64 *) qp->r_sge.sge.vaddr,
                                       be64_to_cpu(ateth->compare_data),
                                       sdata);
-                qib_put_mr(qp->r_sge.sge.mr);
+                atomic_dec(&qp->r_sge.sge.mr->refcount);
                 qp->r_sge.num_sge = 0;
                 e->opcode = opcode;
                 e->sent = 0;
diff --git a/drivers/infiniband/hw/qib/qib_ruc.c b/drivers/infiniband/hw/qib/qib_ruc.c
index 357b6cfcd46..eb78d9367f0 100644
--- a/drivers/infiniband/hw/qib/qib_ruc.c
+++ b/drivers/infiniband/hw/qib/qib_ruc.c
@@ -110,7 +110,7 @@ bad_lkey:
         while (j) {
                 struct qib_sge *sge = --j ? &ss->sg_list[j - 1] : &ss->sge;
 
-                qib_put_mr(sge->mr);
+                atomic_dec(&sge->mr->refcount);
         }
         ss->num_sge = 0;
         memset(&wc, 0, sizeof(wc));
@@ -260,15 +260,12 @@ static int gid_ok(union ib_gid *gid, __be64 gid_prefix, __be64 id)
 
 /*
  *
- * This should be called with the QP r_lock held.
- *
- * The s_lock will be acquired around the qib_migrate_qp() call.
+ * This should be called with the QP s_lock held.
  */
 int qib_ruc_check_hdr(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                       int has_grh, struct qib_qp *qp, u32 bth0)
 {
         __be64 guid;
-        unsigned long flags;
 
         if (qp->s_mig_state == IB_MIG_ARMED && (bth0 & IB_BTH_MIG_REQ)) {
                 if (!has_grh) {
@@ -298,9 +295,7 @@ int qib_ruc_check_hdr(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                 if (be16_to_cpu(hdr->lrh[3]) != qp->alt_ah_attr.dlid ||
                     ppd_from_ibp(ibp)->port != qp->alt_ah_attr.port_num)
                         goto err;
-                spin_lock_irqsave(&qp->s_lock, flags);
                 qib_migrate_qp(qp);
-                spin_unlock_irqrestore(&qp->s_lock, flags);
         } else {
                 if (!has_grh) {
                         if (qp->remote_ah_attr.ah_flags & IB_AH_GRH)
@@ -501,7 +496,7 @@ again:
                         (u64) atomic64_add_return(sdata, maddr) - sdata :
                         (u64) cmpxchg((u64 *) qp->r_sge.sge.vaddr,
                                       sdata, wqe->wr.wr.atomic.swap);
-                qib_put_mr(qp->r_sge.sge.mr);
+                atomic_dec(&qp->r_sge.sge.mr->refcount);
                 qp->r_sge.num_sge = 0;
                 goto send_comp;
 
@@ -525,7 +520,7 @@ again:
                 sge->sge_length -= len;
                 if (sge->sge_length == 0) {
                         if (!release)
-                                qib_put_mr(sge->mr);
+                                atomic_dec(&sge->mr->refcount);
                         if (--sqp->s_sge.num_sge)
                                 *sge = *sqp->s_sge.sg_list++;
                 } else if (sge->length == 0 && sge->mr->lkey) {
@@ -542,7 +537,11 @@ again:
                 sqp->s_len -= len;
         }
         if (release)
-                qib_put_ss(&qp->r_sge);
+                while (qp->r_sge.num_sge) {
+                        atomic_dec(&qp->r_sge.sge.mr->refcount);
+                        if (--qp->r_sge.num_sge)
+                                qp->r_sge.sge = *qp->r_sge.sg_list++;
+                }
 
         if (!test_and_clear_bit(QIB_R_WRID_VALID, &qp->r_aflags))
                 goto send_comp;
@@ -684,17 +683,17 @@ void qib_make_ruc_header(struct qib_qp *qp, struct qib_other_headers *ohdr,
         nwords = (qp->s_cur_size + extra_bytes) >> 2;
         lrh0 = QIB_LRH_BTH;
         if (unlikely(qp->remote_ah_attr.ah_flags & IB_AH_GRH)) {
-                qp->s_hdrwords += qib_make_grh(ibp, &qp->s_hdr->u.l.grh,
+                qp->s_hdrwords += qib_make_grh(ibp, &qp->s_hdr.u.l.grh,
                                                &qp->remote_ah_attr.grh,
                                                qp->s_hdrwords, nwords);
                 lrh0 = QIB_LRH_GRH;
         }
         lrh0 |= ibp->sl_to_vl[qp->remote_ah_attr.sl] << 12 |
                 qp->remote_ah_attr.sl << 4;
-        qp->s_hdr->lrh[0] = cpu_to_be16(lrh0);
-        qp->s_hdr->lrh[1] = cpu_to_be16(qp->remote_ah_attr.dlid);
-        qp->s_hdr->lrh[2] = cpu_to_be16(qp->s_hdrwords + nwords + SIZE_OF_CRC);
-        qp->s_hdr->lrh[3] = cpu_to_be16(ppd_from_ibp(ibp)->lid |
+        qp->s_hdr.lrh[0] = cpu_to_be16(lrh0);
+        qp->s_hdr.lrh[1] = cpu_to_be16(qp->remote_ah_attr.dlid);
+        qp->s_hdr.lrh[2] = cpu_to_be16(qp->s_hdrwords + nwords + SIZE_OF_CRC);
+        qp->s_hdr.lrh[3] = cpu_to_be16(ppd_from_ibp(ibp)->lid |
                                        qp->remote_ah_attr.src_path_bits);
         bth0 |= qib_get_pkey(ibp, qp->s_pkey_index);
         bth0 |= extra_bytes << 20;
@@ -754,7 +753,7 @@ void qib_do_send(struct work_struct *work)
                          * If the packet cannot be sent now, return and
                          * the send tasklet will be woken up later.
                          */
-                        if (qib_verbs_send(qp, qp->s_hdr, qp->s_hdrwords,
+                        if (qib_verbs_send(qp, &qp->s_hdr, qp->s_hdrwords,
                                            qp->s_cur_sge, qp->s_cur_size))
                                 break;
                         /* Record that s_hdr is empty. */
@@ -778,7 +777,7 @@ void qib_send_complete(struct qib_qp *qp, struct qib_swqe *wqe,
         for (i = 0; i < wqe->wr.num_sge; i++) {
                 struct qib_sge *sge = &wqe->sg_list[i];
 
-                qib_put_mr(sge->mr);
+                atomic_dec(&sge->mr->refcount);
         }
         if (qp->ibqp.qp_type == IB_QPT_UD ||
             qp->ibqp.qp_type == IB_QPT_SMI ||
diff --git a/drivers/infiniband/hw/qib/qib_sd7220.c b/drivers/infiniband/hw/qib/qib_sd7220.c
index 50a8a0d4fe6..e9f9f8bc320 100644
--- a/drivers/infiniband/hw/qib/qib_sd7220.c
+++ b/drivers/infiniband/hw/qib/qib_sd7220.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -38,7 +38,6 @@
 
 #include <linux/pci.h>
 #include <linux/delay.h>
-#include <linux/module.h>
 #include <linux/firmware.h>
 
 #include "qib.h"
@@ -300,7 +299,7 @@ bail:
 }
 
 static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
-        const char *where)
+       const char *where)
 {
         int ret, chn, baduns;
         u64 val;
@@ -342,17 +341,15 @@ static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
                 ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                         IB_CTRL2(chn), 0, 0);
                 if (ret < 0)
-                        qib_dev_err(dd,
-                                "Failed checking TRIMDONE, chn %d (%s)\n",
-                                chn, where);
+                        qib_dev_err(dd, "Failed checking TRIMDONE, chn %d"
+                                    " (%s)\n", chn, where);
 
                 if (!(ret & 0x10)) {
                         int probe;
 
                         baduns |= (1 << chn);
-                        qib_dev_err(dd,
-                                "TRIMDONE cleared on chn %d (%02X). (%s)\n",
-                                chn, ret, where);
+                        qib_dev_err(dd, "TRIMDONE cleared on chn %d (%02X)."
+                                " (%s)\n", chn, ret, where);
                         probe = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                                 IB_PGUDP(0), 0, 0);
                         qib_dev_err(dd, "probe is %d (%02X)\n",
@@ -372,13 +369,13 @@ static void qib_sd_trimdone_monitor(struct qib_devdata *dd,
                 /* Read CTRL reg for each channel to check TRIMDONE */
                 if (baduns & (1 << chn)) {
                         qib_dev_err(dd,
-                                "Resetting TRIMDONE on chn %d (%s)\n",
+                                "Reseting TRIMDONE on chn %d (%s)\n",
                                 chn, where);
                         ret = qib_sd7220_reg_mod(dd, IB_7220_SERDES,
                                 IB_CTRL2(chn), 0x10, 0x10);
                         if (ret < 0)
-                                qib_dev_err(dd,
-                                        "Failed re-setting TRIMDONE, chn %d (%s)\n",
+                                qib_dev_err(dd, "Failed re-setting "
+                                        "TRIMDONE, chn %d (%s)\n",
                                         chn, where);
                 }
         }
@@ -1146,10 +1143,10 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                         if (ret < 0) {
                                 int sloc = loc >> EPB_ADDR_SHF;
 
-                                qib_dev_err(dd,
-                                        "pre-read failed: elt %d, addr 0x%X, chnl %d\n",
-                                        (sloc & 0xF),
-                                        (sloc >> 9) & 0x3f, chnl);
+                                qib_dev_err(dd, "pre-read failed: elt %d,"
+                                            " addr 0x%X, chnl %d\n",
+                                            (sloc & 0xF),
+                                            (sloc >> 9) & 0x3f, chnl);
                                 return ret;
                         }
                         val = (ret & ~mask) | (val & mask);
@@ -1159,9 +1156,9 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                 if (ret < 0) {
                         int sloc = loc >> EPB_ADDR_SHF;
 
-                        qib_dev_err(dd,
-                                "Global WR failed: elt %d, addr 0x%X, val %02X\n",
-                                (sloc & 0xF), (sloc >> 9) & 0x3f, val);
+                        qib_dev_err(dd, "Global WR failed: elt %d,"
+                                    " addr 0x%X, val %02X\n",
+                                    (sloc & 0xF), (sloc >> 9) & 0x3f, val);
                 }
                 return ret;
         }
@@ -1175,10 +1172,11 @@ static int ibsd_mod_allchnls(struct qib_devdata *dd, int loc, int val,
                 if (ret < 0) {
                         int sloc = loc >> EPB_ADDR_SHF;
 
-                        qib_dev_err(dd,
-                                "Write failed: elt %d, addr 0x%X, chnl %d, val 0x%02X, mask 0x%02X\n",
-                                (sloc & 0xF), (sloc >> 9) & 0x3f, chnl,
-                                val & 0xFF, mask & 0xFF);
+                        qib_dev_err(dd, "Write failed: elt %d,"
+                                    " addr 0x%X, chnl %d, val 0x%02X,"
+                                    " mask 0x%02X\n",
+                                    (sloc & 0xF), (sloc >> 9) & 0x3f, chnl,
+                                    val & 0xFF, mask & 0xFF);
                         break;
                 }
         }
diff --git a/drivers/infiniband/hw/qib/qib_sdma.c b/drivers/infiniband/hw/qib/qib_sdma.c
index 3fc51443121..cad44491320 100644
--- a/drivers/infiniband/hw/qib/qib_sdma.c
+++ b/drivers/infiniband/hw/qib/qib_sdma.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2007 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2007, 2008, 2009, 2010 QLogic Corporation. 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
@@ -33,7 +32,6 @@
 
 #include <linux/spinlock.h>
 #include <linux/netdevice.h>
-#include <linux/moduleparam.h>
 
 #include "qib.h"
 #include "qib_common.h"
@@ -277,8 +275,8 @@ static int alloc_sdma(struct qib_pportdata *ppd)
                 GFP_KERNEL);
 
         if (!ppd->sdma_descq) {
-                qib_dev_err(ppd->dd,
-                        "failed to allocate SendDMA descriptor FIFO memory\n");
+                qib_dev_err(ppd->dd, "failed to allocate SendDMA descriptor "
+                            "FIFO memory\n");
                 goto bail;
         }
 
@@ -286,8 +284,8 @@ static int alloc_sdma(struct qib_pportdata *ppd)
         ppd->sdma_head_dma = dma_alloc_coherent(&ppd->dd->pcidev->dev,
                 PAGE_SIZE, &ppd->sdma_head_phys, GFP_KERNEL);
         if (!ppd->sdma_head_dma) {
-                qib_dev_err(ppd->dd,
-                        "failed to allocate SendDMA head memory\n");
+                qib_dev_err(ppd->dd, "failed to allocate SendDMA "
+                            "head memory\n");
                 goto cleanup_descq;
         }
         ppd->sdma_head_dma[0] = 0;
diff --git a/drivers/infiniband/hw/qib/qib_srq.c b/drivers/infiniband/hw/qib/qib_srq.c
index d6235931a1b..c3ec8efc2ed 100644
--- a/drivers/infiniband/hw/qib/qib_srq.c
+++ b/drivers/infiniband/hw/qib/qib_srq.c
@@ -107,11 +107,6 @@ struct ib_srq *qib_create_srq(struct ib_pd *ibpd,
         u32 sz;
         struct ib_srq *ret;
 
-        if (srq_init_attr->srq_type != IB_SRQT_BASIC) {
-                ret = ERR_PTR(-ENOSYS);
-                goto done;
-        }
-
         if (srq_init_attr->attr.max_sge == 0 ||
             srq_init_attr->attr.max_sge > ib_qib_max_srq_sges ||
             srq_init_attr->attr.max_wr == 0 ||
diff --git a/drivers/infiniband/hw/qib/qib_sysfs.c b/drivers/infiniband/hw/qib/qib_sysfs.c
index 034cc821de5..14d129de432 100644
--- a/drivers/infiniband/hw/qib/qib_sysfs.c
+++ b/drivers/infiniband/hw/qib/qib_sysfs.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -34,7 +33,41 @@
 #include <linux/ctype.h>
 
 #include "qib.h"
-#include "qib_mad.h"
+
+/**
+ * qib_parse_ushort - parse an unsigned short value in an arbitrary base
+ * @str: the string containing the number
+ * @valp: where to put the result
+ *
+ * Returns the number of bytes consumed, or negative value on error.
+ */
+static int qib_parse_ushort(const char *str, unsigned short *valp)
+{
+        unsigned long val;
+        char *end;
+        int ret;
+
+        if (!isdigit(str[0])) {
+                ret = -EINVAL;
+                goto bail;
+        }
+
+        val = simple_strtoul(str, &end, 0);
+
+        if (val > 0xffff) {
+                ret = -EINVAL;
+                goto bail;
+        }
+
+        *valp = val;
+
+        ret = end + 1 - str;
+        if (ret == 0)
+                ret = -EINVAL;
+
+bail:
+        return ret;
+}
 
 /* start of per-port functions */
 /*
@@ -57,11 +90,7 @@ static ssize_t store_hrtbt_enb(struct qib_pportdata *ppd, const char *buf,
         int ret;
         u16 val;
 
-        ret = kstrtou16(buf, 0, &val);
-        if (ret) {
-                qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
-                return ret;
-        }
+        ret = qib_parse_ushort(buf, &val);
 
         /*
          * Set the "intentional" heartbeat enable per either of
@@ -70,7 +99,10 @@ static ssize_t store_hrtbt_enb(struct qib_pportdata *ppd, const char *buf,
          * because entering loopback mode overrides it and automatically
          * disables heartbeat.
          */
-        ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val);
+        if (ret >= 0)
+                ret = dd->f_set_ib_cfg(ppd, QIB_IB_CFG_HRTBT, val);
+        if (ret < 0)
+                qib_dev_err(dd, "attempt to set invalid Heartbeat enable\n");
         return ret < 0 ? ret : count;
 }
 
@@ -94,14 +126,12 @@ static ssize_t store_led_override(struct qib_pportdata *ppd, const char *buf,
         int ret;
         u16 val;
 
-        ret = kstrtou16(buf, 0, &val);
-        if (ret) {
+        ret = qib_parse_ushort(buf, &val);
+        if (ret > 0)
+                qib_set_led_override(ppd, val);
+        else
                 qib_dev_err(dd, "attempt to set invalid LED override\n");
-                return ret;
-        }
-
-        qib_set_led_override(ppd, val);
-        return count;
+        return ret < 0 ? ret : count;
 }
 
 static ssize_t show_status(struct qib_pportdata *ppd, char *buf)
@@ -120,7 +150,7 @@ static ssize_t show_status(struct qib_pportdata *ppd, char *buf)
  * For userland compatibility, these offsets must remain fixed.
  * They are strings for QIB_STATUS_*
  */
-static const char * const qib_status_str[] = {
+static const char *qib_status_str[] = {
         "Initted",
         "",
         "",
@@ -201,98 +231,6 @@ static struct attribute *port_default_attributes[] = {
         NULL
 };
 
-/*
- * Start of per-port congestion control structures and support code
- */
-
-/*
- * Congestion control table size followed by table entries
- */
-static ssize_t read_cc_table_bin(struct file *filp, struct kobject *kobj,
-                struct bin_attribute *bin_attr,
-                char *buf, loff_t pos, size_t count)
-{
-        int ret;
-        struct qib_pportdata *ppd =
-                container_of(kobj, struct qib_pportdata, pport_cc_kobj);
-
-        if (!qib_cc_table_size || !ppd->ccti_entries_shadow)
-                return -EINVAL;
-
-        ret = ppd->total_cct_entry * sizeof(struct ib_cc_table_entry_shadow)
-                 + sizeof(__be16);
-
-        if (pos > ret)
-                return -EINVAL;
-
-        if (count > ret - pos)
-                count = ret - pos;
-
-        if (!count)
-                return count;
-
-        spin_lock(&ppd->cc_shadow_lock);
-        memcpy(buf, ppd->ccti_entries_shadow, count);
-        spin_unlock(&ppd->cc_shadow_lock);
-
-        return count;
-}
-
-static void qib_port_release(struct kobject *kobj)
-{
-        /* nothing to do since memory is freed by qib_free_devdata() */
-}
-
-static struct kobj_type qib_port_cc_ktype = {
-        .release = qib_port_release,
-};
-
-static struct bin_attribute cc_table_bin_attr = {
-        .attr = {.name = "cc_table_bin", .mode = 0444},
-        .read = read_cc_table_bin,
-        .size = PAGE_SIZE,
-};
-
-/*
- * Congestion settings: port control, control map and an array of 16
- * entries for the congestion entries - increase, timer, event log
- * trigger threshold and the minimum injection rate delay.
- */
-static ssize_t read_cc_setting_bin(struct file *filp, struct kobject *kobj,
-                struct bin_attribute *bin_attr,
-                char *buf, loff_t pos, size_t count)
-{
-        int ret;
-        struct qib_pportdata *ppd =
-                container_of(kobj, struct qib_pportdata, pport_cc_kobj);
-
-        if (!qib_cc_table_size || !ppd->congestion_entries_shadow)
-                return -EINVAL;
-
-        ret = sizeof(struct ib_cc_congestion_setting_attr_shadow);
-
-        if (pos > ret)
-                return -EINVAL;
-        if (count > ret - pos)
-                count = ret - pos;
-
-        if (!count)
-                return count;
-
-        spin_lock(&ppd->cc_shadow_lock);
-        memcpy(buf, ppd->congestion_entries_shadow, count);
-        spin_unlock(&ppd->cc_shadow_lock);
-
-        return count;
-}
-
-static struct bin_attribute cc_setting_bin_attr = {
-        .attr = {.name = "cc_settings_bin", .mode = 0444},
-        .read = read_cc_setting_bin,
-        .size = PAGE_SIZE,
-};
-
-
 static ssize_t qib_portattr_show(struct kobject *kobj,
         struct attribute *attr, char *buf)
 {
@@ -315,6 +253,10 @@ static ssize_t qib_portattr_store(struct kobject *kobj,
         return pattr->store(ppd, buf, len);
 }
 
+static void qib_port_release(struct kobject *kobj)
+{
+        /* nothing to do since memory is freed by qib_free_devdata() */
+}
 
 static const struct sysfs_ops qib_port_ops = {
         .show = qib_portattr_show,
@@ -469,12 +411,12 @@ static ssize_t diagc_attr_store(struct kobject *kobj, struct attribute *attr,
         struct qib_pportdata *ppd =
                 container_of(kobj, struct qib_pportdata, diagc_kobj);
         struct qib_ibport *qibp = &ppd->ibport_data;
-        u32 val;
-        int ret;
+        char *endp;
+        long val = simple_strtol(buf, &endp, 0);
+
+        if (val < 0 || endp == buf)
+                return -EINVAL;
 
-        ret = kstrtou32(buf, 0, &val);
-        if (ret)
-                return ret;
         *(u32 *)((char *) qibp + dattr->counter) = val;
         return size;
 }
@@ -561,11 +503,8 @@ static ssize_t show_nctxts(struct device *device,
         struct qib_devdata *dd = dd_from_dev(dev);
 
         /* Return the number of user ports (contexts) available. */
-        /* The calculation below deals with a special case where
-         * cfgctxts is set to 1 on a single-port board. */
-        return scnprintf(buf, PAGE_SIZE, "%u\n",
-                        (dd->first_user_ctxt > dd->cfgctxts) ? 0 :
-                        (dd->cfgctxts - dd->first_user_ctxt));
+        return scnprintf(buf, PAGE_SIZE, "%u\n", dd->cfgctxts -
+                dd->first_user_ctxt);
 }
 
 static ssize_t show_nfreectxts(struct device *device,
@@ -576,7 +515,8 @@ static ssize_t show_nfreectxts(struct device *device,
         struct qib_devdata *dd = dd_from_dev(dev);
 
         /* Return the number of free user ports (contexts) available. */
-        return scnprintf(buf, PAGE_SIZE, "%u\n", dd->freectxts);
+        return scnprintf(buf, PAGE_SIZE, "%u\n", dd->cfgctxts -
+                dd->first_user_ctxt - (u32)qib_stats.sps_ctxts);
 }
 
 static ssize_t show_serial(struct device *device,
@@ -707,9 +647,8 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
         int ret;
 
         if (!port_num || port_num > dd->num_pports) {
-                qib_dev_err(dd,
-                        "Skipping infiniband class with invalid port %u\n",
-                        port_num);
+                qib_dev_err(dd, "Skipping infiniband class with "
+                            "invalid port %u\n", port_num);
                 ret = -ENODEV;
                 goto bail;
         }
@@ -718,9 +657,8 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
         ret = kobject_init_and_add(&ppd->pport_kobj, &qib_port_ktype, kobj,
                                    "linkcontrol");
         if (ret) {
-                qib_dev_err(dd,
-                        "Skipping linkcontrol sysfs info, (err %d) port %u\n",
-                        ret, port_num);
+                qib_dev_err(dd, "Skipping linkcontrol sysfs info, "
+                            "(err %d) port %u\n", ret, port_num);
                 goto bail;
         }
         kobject_uevent(&ppd->pport_kobj, KOBJ_ADD);
@@ -728,70 +666,26 @@ int qib_create_port_files(struct ib_device *ibdev, u8 port_num,
         ret = kobject_init_and_add(&ppd->sl2vl_kobj, &qib_sl2vl_ktype, kobj,
                                    "sl2vl");
         if (ret) {
-                qib_dev_err(dd,
-                        "Skipping sl2vl sysfs info, (err %d) port %u\n",
-                        ret, port_num);
-                goto bail_link;
+                qib_dev_err(dd, "Skipping sl2vl sysfs info, "
+                            "(err %d) port %u\n", ret, port_num);
+                goto bail_sl;
         }
         kobject_uevent(&ppd->sl2vl_kobj, KOBJ_ADD);
 
         ret = kobject_init_and_add(&ppd->diagc_kobj, &qib_diagc_ktype, kobj,
                                    "diag_counters");
         if (ret) {
-                qib_dev_err(dd,
-                        "Skipping diag_counters sysfs info, (err %d) port %u\n",
-                        ret, port_num);
-                goto bail_sl;
-        }
-        kobject_uevent(&ppd->diagc_kobj, KOBJ_ADD);
-
-        if (!qib_cc_table_size || !ppd->congestion_entries_shadow)
-                return 0;
-
-        ret = kobject_init_and_add(&ppd->pport_cc_kobj, &qib_port_cc_ktype,
-                                kobj, "CCMgtA");
-        if (ret) {
-                qib_dev_err(dd,
-                 "Skipping Congestion Control sysfs info, (err %d) port %u\n",
-                 ret, port_num);
+                qib_dev_err(dd, "Skipping diag_counters sysfs info, "
+                            "(err %d) port %u\n", ret, port_num);
                 goto bail_diagc;
         }
-
-        kobject_uevent(&ppd->pport_cc_kobj, KOBJ_ADD);
-
-        ret = sysfs_create_bin_file(&ppd->pport_cc_kobj,
-                                &cc_setting_bin_attr);
-        if (ret) {
-                qib_dev_err(dd,
-                 "Skipping Congestion Control setting sysfs info, (err %d) port %u\n",
-                 ret, port_num);
-                goto bail_cc;
-        }
-
-        ret = sysfs_create_bin_file(&ppd->pport_cc_kobj,
-                                &cc_table_bin_attr);
-        if (ret) {
-                qib_dev_err(dd,
-                 "Skipping Congestion Control table sysfs info, (err %d) port %u\n",
-                 ret, port_num);
-                goto bail_cc_entry_bin;
-        }
-
-        qib_devinfo(dd->pcidev,
-                "IB%u: Congestion Control Agent enabled for port %d\n",
-                dd->unit, port_num);
+        kobject_uevent(&ppd->diagc_kobj, KOBJ_ADD);
 
         return 0;
 
-bail_cc_entry_bin:
-        sysfs_remove_bin_file(&ppd->pport_cc_kobj, &cc_setting_bin_attr);
-bail_cc:
-        kobject_put(&ppd->pport_cc_kobj);
 bail_diagc:
-        kobject_put(&ppd->diagc_kobj);
-bail_sl:
         kobject_put(&ppd->sl2vl_kobj);
-bail_link:
+bail_sl:
         kobject_put(&ppd->pport_kobj);
 bail:
         return ret;
@@ -824,15 +718,7 @@ void qib_verbs_unregister_sysfs(struct qib_devdata *dd)
 
         for (i = 0; i < dd->num_pports; i++) {
                 ppd = &dd->pport[i];
-                if (qib_cc_table_size &&
-                        ppd->congestion_entries_shadow) {
-                        sysfs_remove_bin_file(&ppd->pport_cc_kobj,
-                                &cc_setting_bin_attr);
-                        sysfs_remove_bin_file(&ppd->pport_cc_kobj,
-                                &cc_table_bin_attr);
-                        kobject_put(&ppd->pport_cc_kobj);
-                }
-                kobject_put(&ppd->sl2vl_kobj);
                 kobject_put(&ppd->pport_kobj);
+                kobject_put(&ppd->sl2vl_kobj);
         }
 }
diff --git a/drivers/infiniband/hw/qib/qib_twsi.c b/drivers/infiniband/hw/qib/qib_twsi.c
index 647f7beb1b0..ddde72e11ed 100644
--- a/drivers/infiniband/hw/qib/qib_twsi.c
+++ b/drivers/infiniband/hw/qib/qib_twsi.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -450,9 +449,8 @@ int qib_twsi_blk_wr(struct qib_devdata *dd, int dev, int addr,
                                 goto failed_write;
                         ret = qib_twsi_wr(dd, addr, 0);
                         if (ret) {
-                                qib_dev_err(dd,
-                                        "Failed to write interface write addr %02X\n",
-                                        addr);
+                                qib_dev_err(dd, "Failed to write interface"
+                                            " write addr %02X\n", addr);
                                 goto failed_write;
                         }
                 }
diff --git a/drivers/infiniband/hw/qib/qib_tx.c b/drivers/infiniband/hw/qib/qib_tx.c
index 31d3561400a..7f36454c225 100644
--- a/drivers/infiniband/hw/qib/qib_tx.c
+++ b/drivers/infiniband/hw/qib/qib_tx.c
@@ -36,7 +36,6 @@
 #include <linux/delay.h>
 #include <linux/netdevice.h>
 #include <linux/vmalloc.h>
-#include <linux/moduleparam.h>
 
 #include "qib.h"
 
@@ -295,7 +294,6 @@ u32 __iomem *qib_getsendbuf_range(struct qib_devdata *dd, u32 *pbufnum,
 
         nbufs = last - first + 1; /* number in range to check */
         if (dd->upd_pio_shadow) {
-update_shadow:
                 /*
                  * Minor optimization.  If we had no buffers on last call,
                  * start out by doing the update; continue and do scan even
@@ -305,39 +303,37 @@ update_shadow:
                 updated++;
         }
         i = first;
+rescan:
         /*
          * While test_and_set_bit() is atomic, we do that and then the
          * change_bit(), and the pair is not.  See if this is the cause
          * of the remaining armlaunch errors.
          */
         spin_lock_irqsave(&dd->pioavail_lock, flags);
-        if (dd->last_pio >= first && dd->last_pio <= last)
-                i = dd->last_pio + 1;
-        if (!first)
-                /* adjust to min possible  */
-                nbufs = last - dd->min_kernel_pio + 1;
         for (j = 0; j < nbufs; j++, i++) {
                 if (i > last)
-                        i = !first ? dd->min_kernel_pio : first;
+                        i = first;
                 if (__test_and_set_bit((2 * i) + 1, shadow))
                         continue;
                 /* flip generation bit */
                 __change_bit(2 * i, shadow);
                 /* remember that the buffer can be written to now */
                 __set_bit(i, dd->pio_writing);
-                if (!first && first != last) /* first == last on VL15, avoid */
-                        dd->last_pio = i;
                 break;
         }
         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 
         if (j == nbufs) {
-                if (!updated)
+                if (!updated) {
                         /*
                          * First time through; shadow exhausted, but may be
                          * buffers available, try an update and then rescan.
                          */
-                        goto update_shadow;
+                        update_send_bufs(dd);
+                        updated++;
+                        i = first;
+                        goto rescan;
+                }
                 no_send_bufs(dd);
                 buf = NULL;
         } else {
@@ -425,20 +421,14 @@ void qib_chg_pioavailkernel(struct qib_devdata *dd, unsigned start,
                                 __clear_bit(QLOGIC_IB_SENDPIOAVAIL_CHECK_SHIFT
                                             + start, dd->pioavailshadow);
                         __set_bit(start, dd->pioavailkernel);
-                        if ((start >> 1) < dd->min_kernel_pio)
-                                dd->min_kernel_pio = start >> 1;
                 } else {
                         __set_bit(start + QLOGIC_IB_SENDPIOAVAIL_BUSY_SHIFT,
                                   dd->pioavailshadow);
                         __clear_bit(start, dd->pioavailkernel);
-                        if ((start >> 1) > dd->min_kernel_pio)
-                                dd->min_kernel_pio = start >> 1;
                 }
                 start += 2;
         }
 
-        if (dd->min_kernel_pio > 0 && dd->last_pio < dd->min_kernel_pio - 1)
-                dd->last_pio = dd->min_kernel_pio - 1;
         spin_unlock_irqrestore(&dd->pioavail_lock, flags);
 
         dd->f_txchk_change(dd, ostart, len, avail, rcd);
diff --git a/drivers/infiniband/hw/qib/qib_uc.c b/drivers/infiniband/hw/qib/qib_uc.c
index aa3a8035bb6..32ccf3c824c 100644
--- a/drivers/infiniband/hw/qib/qib_uc.c
+++ b/drivers/infiniband/hw/qib/qib_uc.c
@@ -51,7 +51,7 @@ int qib_make_uc_req(struct qib_qp *qp)
         u32 hwords;
         u32 bth0;
         u32 len;
-        u32 pmtu = qp->pmtu;
+        u32 pmtu = ib_mtu_enum_to_int(qp->path_mtu);
         int ret = 0;
 
         spin_lock_irqsave(&qp->s_lock, flags);
@@ -72,9 +72,9 @@ int qib_make_uc_req(struct qib_qp *qp)
                 goto done;
         }
 
-        ohdr = &qp->s_hdr->u.oth;
+        ohdr = &qp->s_hdr.u.oth;
         if (qp->remote_ah_attr.ah_flags & IB_AH_GRH)
-                ohdr = &qp->s_hdr->u.l.oth;
+                ohdr = &qp->s_hdr.u.l.oth;
 
         /* header size in 32-bit words LRH+BTH = (8+12)/4. */
         hwords = 5;
@@ -243,12 +243,13 @@ void qib_uc_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                 int has_grh, void *data, u32 tlen, struct qib_qp *qp)
 {
         struct qib_other_headers *ohdr;
+        unsigned long flags;
         u32 opcode;
         u32 hdrsize;
         u32 psn;
         u32 pad;
         struct ib_wc wc;
-        u32 pmtu = qp->pmtu;
+        u32 pmtu = ib_mtu_enum_to_int(qp->path_mtu);
         struct ib_reth *reth;
         int ret;
 
@@ -262,11 +263,14 @@ void qib_uc_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
         }
 
         opcode = be32_to_cpu(ohdr->bth[0]);
+        spin_lock_irqsave(&qp->s_lock, flags);
         if (qib_ruc_check_hdr(ibp, hdr, has_grh, qp, opcode))
-                return;
+                goto sunlock;
+        spin_unlock_irqrestore(&qp->s_lock, flags);
 
         psn = be32_to_cpu(ohdr->bth[2]);
         opcode >>= 24;
+        memset(&wc, 0, sizeof wc);
 
         /* Compare the PSN verses the expected PSN. */
         if (unlikely(qib_cmp24(psn, qp->r_psn) != 0)) {
@@ -281,7 +285,11 @@ inv:
                         set_bit(QIB_R_REWIND_SGE, &qp->r_aflags);
                         qp->r_sge.num_sge = 0;
                 } else
-                        qib_put_ss(&qp->r_sge);
+                        while (qp->r_sge.num_sge) {
+                                atomic_dec(&qp->r_sge.sge.mr->refcount);
+                                if (--qp->r_sge.num_sge)
+                                        qp->r_sge.sge = *qp->r_sge.sg_list++;
+                        }
                 qp->r_state = OP(SEND_LAST);
                 switch (opcode) {
                 case OP(SEND_FIRST):
@@ -362,7 +370,7 @@ send_first:
                 }
                 qp->r_rcv_len = 0;
                 if (opcode == OP(SEND_ONLY))
-                        goto no_immediate_data;
+                        goto send_last;
                 else if (opcode == OP(SEND_ONLY_WITH_IMMEDIATE))
                         goto send_last_imm;
                 /* FALLTHROUGH */
@@ -381,11 +389,8 @@ send_last_imm:
                 wc.ex.imm_data = ohdr->u.imm_data;
                 hdrsize += 4;
                 wc.wc_flags = IB_WC_WITH_IMM;
-                goto send_last;
+                /* FALLTHROUGH */
         case OP(SEND_LAST):
-no_immediate_data:
-                wc.ex.imm_data = 0;
-                wc.wc_flags = 0;
 send_last:
                 /* Get the number of bytes the message was padded by. */
                 pad = (be32_to_cpu(ohdr->bth[0]) >> 20) & 3;
@@ -399,20 +404,20 @@ send_last:
                 if (unlikely(wc.byte_len > qp->r_len))
                         goto rewind;
                 wc.opcode = IB_WC_RECV;
-                qib_copy_sge(&qp->r_sge, data, tlen, 0);
-                qib_put_ss(&qp->s_rdma_read_sge);
 last_imm:
+                qib_copy_sge(&qp->r_sge, data, tlen, 0);
+                while (qp->s_rdma_read_sge.num_sge) {
+                        atomic_dec(&qp->s_rdma_read_sge.sge.mr->refcount);
+                        if (--qp->s_rdma_read_sge.num_sge)
+                                qp->s_rdma_read_sge.sge =
+                                        *qp->s_rdma_read_sge.sg_list++;
+                }
                 wc.wr_id = qp->r_wr_id;
                 wc.status = IB_WC_SUCCESS;
                 wc.qp = &qp->ibqp;
                 wc.src_qp = qp->remote_qpn;
                 wc.slid = qp->remote_ah_attr.dlid;
                 wc.sl = qp->remote_ah_attr.sl;
-                /* zero fields that are N/A */
-                wc.vendor_err = 0;
-                wc.pkey_index = 0;
-                wc.dlid_path_bits = 0;
-                wc.port_num = 0;
                 /* Signal completion event if the solicited bit is set. */
                 qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
                              (ohdr->bth[0] &
@@ -484,7 +489,13 @@ rdma_last_imm:
                 if (unlikely(tlen + qp->r_rcv_len != qp->r_len))
                         goto drop;
                 if (test_and_clear_bit(QIB_R_REWIND_SGE, &qp->r_aflags))
-                        qib_put_ss(&qp->s_rdma_read_sge);
+                        while (qp->s_rdma_read_sge.num_sge) {
+                                atomic_dec(&qp->s_rdma_read_sge.sge.mr->
+                                           refcount);
+                                if (--qp->s_rdma_read_sge.num_sge)
+                                        qp->s_rdma_read_sge.sge =
+                                                *qp->s_rdma_read_sge.sg_list++;
+                        }
                 else {
                         ret = qib_get_rwqe(qp, 1);
                         if (ret < 0)
@@ -494,8 +505,6 @@ rdma_last_imm:
                 }
                 wc.byte_len = qp->r_len;
                 wc.opcode = IB_WC_RECV_RDMA_WITH_IMM;
-                qib_copy_sge(&qp->r_sge, data, tlen, 1);
-                qib_put_ss(&qp->r_sge);
                 goto last_imm;
 
         case OP(RDMA_WRITE_LAST):
@@ -511,7 +520,11 @@ rdma_last:
                 if (unlikely(tlen + qp->r_rcv_len != qp->r_len))
                         goto drop;
                 qib_copy_sge(&qp->r_sge, data, tlen, 1);
-                qib_put_ss(&qp->r_sge);
+                while (qp->r_sge.num_sge) {
+                        atomic_dec(&qp->r_sge.sge.mr->refcount);
+                        if (--qp->r_sge.num_sge)
+                                qp->r_sge.sge = *qp->r_sge.sg_list++;
+                }
                 break;
 
         default:
@@ -533,4 +546,6 @@ op_err:
         qib_rc_error(qp, IB_WC_LOC_QP_OP_ERR);
         return;
 
+sunlock:
+        spin_unlock_irqrestore(&qp->s_lock, flags);
 }
diff --git a/drivers/infiniband/hw/qib/qib_ud.c b/drivers/infiniband/hw/qib/qib_ud.c
index d6c7fe7f88d..828609fa4d2 100644
--- a/drivers/infiniband/hw/qib/qib_ud.c
+++ b/drivers/infiniband/hw/qib/qib_ud.c
@@ -194,7 +194,11 @@ static void qib_ud_loopback(struct qib_qp *sqp, struct qib_swqe *swqe)
                 }
                 length -= len;
         }
-        qib_put_ss(&qp->r_sge);
+        while (qp->r_sge.num_sge) {
+                atomic_dec(&qp->r_sge.sge.mr->refcount);
+                if (--qp->r_sge.num_sge)
+                        qp->r_sge.sge = *qp->r_sge.sg_list++;
+        }
         if (!test_and_clear_bit(QIB_R_WRID_VALID, &qp->r_aflags))
                 goto bail_unlock;
         wc.wr_id = qp->r_wr_id;
@@ -317,11 +321,11 @@ int qib_make_ud_req(struct qib_qp *qp)
 
         if (ah_attr->ah_flags & IB_AH_GRH) {
                 /* Header size in 32-bit words. */
-                qp->s_hdrwords += qib_make_grh(ibp, &qp->s_hdr->u.l.grh,
+                qp->s_hdrwords += qib_make_grh(ibp, &qp->s_hdr.u.l.grh,
                                                &ah_attr->grh,
                                                qp->s_hdrwords, nwords);
                 lrh0 = QIB_LRH_GRH;
-                ohdr = &qp->s_hdr->u.l.oth;
+                ohdr = &qp->s_hdr.u.l.oth;
                 /*
                  * Don't worry about sending to locally attached multicast
                  * QPs.  It is unspecified by the spec. what happens.
@@ -329,7 +333,7 @@ int qib_make_ud_req(struct qib_qp *qp)
         } else {
                 /* Header size in 32-bit words. */
                 lrh0 = QIB_LRH_BTH;
-                ohdr = &qp->s_hdr->u.oth;
+                ohdr = &qp->s_hdr.u.oth;
         }
         if (wqe->wr.opcode == IB_WR_SEND_WITH_IMM) {
                 qp->s_hdrwords++;
@@ -342,15 +346,15 @@ int qib_make_ud_req(struct qib_qp *qp)
                 lrh0 |= 0xF000; /* Set VL (see ch. 13.5.3.1) */
         else
                 lrh0 |= ibp->sl_to_vl[ah_attr->sl] << 12;
-        qp->s_hdr->lrh[0] = cpu_to_be16(lrh0);
-        qp->s_hdr->lrh[1] = cpu_to_be16(ah_attr->dlid);  /* DEST LID */
-        qp->s_hdr->lrh[2] = cpu_to_be16(qp->s_hdrwords + nwords + SIZE_OF_CRC);
+        qp->s_hdr.lrh[0] = cpu_to_be16(lrh0);
+        qp->s_hdr.lrh[1] = cpu_to_be16(ah_attr->dlid);  /* DEST LID */
+        qp->s_hdr.lrh[2] = cpu_to_be16(qp->s_hdrwords + nwords + SIZE_OF_CRC);
         lid = ppd->lid;
         if (lid) {
                 lid |= ah_attr->src_path_bits & ((1 << ppd->lmc) - 1);
-                qp->s_hdr->lrh[3] = cpu_to_be16(lid);
+                qp->s_hdr.lrh[3] = cpu_to_be16(lid);
         } else
-                qp->s_hdr->lrh[3] = IB_LID_PERMISSIVE;
+                qp->s_hdr.lrh[3] = IB_LID_PERMISSIVE;
         if (wqe->wr.send_flags & IB_SEND_SOLICITED)
                 bth0 |= IB_BTH_SOLICITED;
         bth0 |= extra_bytes << 20;
@@ -552,7 +556,11 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
         } else
                 qib_skip_sge(&qp->r_sge, sizeof(struct ib_grh), 1);
         qib_copy_sge(&qp->r_sge, data, wc.byte_len - sizeof(struct ib_grh), 1);
-        qib_put_ss(&qp->r_sge);
+        while (qp->r_sge.num_sge) {
+                atomic_dec(&qp->r_sge.sge.mr->refcount);
+                if (--qp->r_sge.num_sge)
+                        qp->r_sge.sge = *qp->r_sge.sg_list++;
+        }
         if (!test_and_clear_bit(QIB_R_WRID_VALID, &qp->r_aflags))
                 return;
         wc.wr_id = qp->r_wr_id;
diff --git a/drivers/infiniband/hw/qib/qib_user_pages.c b/drivers/infiniband/hw/qib/qib_user_pages.c
index 2bc1d2b9629..7689e49c13c 100644
--- a/drivers/infiniband/hw/qib/qib_user_pages.c
+++ b/drivers/infiniband/hw/qib/qib_user_pages.c
@@ -74,7 +74,7 @@ static int __qib_get_user_pages(unsigned long start_page, size_t num_pages,
                         goto bail_release;
         }
 
-        current->mm->pinned_vm += num_pages;
+        current->mm->locked_vm += num_pages;
 
         ret = 0;
         goto bail;
@@ -151,7 +151,7 @@ void qib_release_user_pages(struct page **p, size_t num_pages)
         __qib_release_user_pages(p, num_pages, 1);
 
         if (current->mm) {
-                current->mm->pinned_vm -= num_pages;
+                current->mm->locked_vm -= num_pages;
                 up_write(&current->mm->mmap_sem);
         }
 }
diff --git a/drivers/infiniband/hw/qib/qib_verbs.c b/drivers/infiniband/hw/qib/qib_verbs.c
index ba51a4715a1..9fab4048885 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.c
+++ b/drivers/infiniband/hw/qib/qib_verbs.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -35,16 +35,14 @@
 #include <rdma/ib_mad.h>
 #include <rdma/ib_user_verbs.h>
 #include <linux/io.h>
-#include <linux/module.h>
 #include <linux/utsname.h>
 #include <linux/rculist.h>
 #include <linux/mm.h>
-#include <linux/random.h>
 
 #include "qib.h"
 #include "qib_common.h"
 
-static unsigned int ib_qib_qp_table_size = 256;
+static unsigned int ib_qib_qp_table_size = 251;
 module_param_named(qp_table_size, ib_qib_qp_table_size, uint, S_IRUGO);
 MODULE_PARM_DESC(qp_table_size, "QP table size");
 
@@ -183,7 +181,7 @@ void qib_copy_sge(struct qib_sge_state *ss, void *data, u32 length, int release)
                 sge->sge_length -= len;
                 if (sge->sge_length == 0) {
                         if (release)
-                                qib_put_mr(sge->mr);
+                                atomic_dec(&sge->mr->refcount);
                         if (--ss->num_sge)
                                 *sge = *ss->sg_list++;
                 } else if (sge->length == 0 && sge->mr->lkey) {
@@ -224,7 +222,7 @@ void qib_skip_sge(struct qib_sge_state *ss, u32 length, int release)
                 sge->sge_length -= len;
                 if (sge->sge_length == 0) {
                         if (release)
-                                qib_put_mr(sge->mr);
+                                atomic_dec(&sge->mr->refcount);
                         if (--ss->num_sge)
                                 *sge = *ss->sg_list++;
                 } else if (sge->length == 0 && sge->mr->lkey) {
@@ -333,8 +331,7 @@ static void qib_copy_from_sge(void *data, struct qib_sge_state *ss, u32 length)
  * @qp: the QP to post on
  * @wr: the work request to send
  */
-static int qib_post_one_send(struct qib_qp *qp, struct ib_send_wr *wr,
-        int *scheduled)
+static int qib_post_one_send(struct qib_qp *qp, struct ib_send_wr *wr)
 {
         struct qib_swqe *wqe;
         u32 next;
@@ -436,17 +433,11 @@ bail_inval_free:
         while (j) {
                 struct qib_sge *sge = &wqe->sg_list[--j];
 
-                qib_put_mr(sge->mr);
+                atomic_dec(&sge->mr->refcount);
         }
 bail_inval:
         ret = -EINVAL;
 bail:
-        if (!ret && !wr->next &&
-         !qib_sdma_empty(
-           dd_from_ibdev(qp->ibqp.device)->pport + qp->port_num - 1)) {
-                qib_schedule_send(qp);
-                *scheduled = 1;
-        }
         spin_unlock_irqrestore(&qp->s_lock, flags);
         return ret;
 }
@@ -464,10 +455,9 @@ static int qib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
 {
         struct qib_qp *qp = to_iqp(ibqp);
         int err = 0;
-        int scheduled = 0;
 
         for (; wr; wr = wr->next) {
-                err = qib_post_one_send(qp, wr, &scheduled);
+                err = qib_post_one_send(qp, wr);
                 if (err) {
                         *bad_wr = wr;
                         goto bail;
@@ -475,8 +465,7 @@ static int qib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
         }
 
         /* Try to do the send work in the caller's context. */
-        if (!scheduled)
-                qib_do_send(&qp->s_work);
+        qib_do_send(&qp->s_work);
 
 bail:
         return err;
@@ -670,25 +659,17 @@ void qib_ib_rcv(struct qib_ctxtdata *rcd, void *rhdr, void *data, u32 tlen)
                 if (atomic_dec_return(&mcast->refcount) <= 1)
                         wake_up(&mcast->wait);
         } else {
-                if (rcd->lookaside_qp) {
-                        if (rcd->lookaside_qpn != qp_num) {
-                                if (atomic_dec_and_test(
-                                        &rcd->lookaside_qp->refcount))
-                                        wake_up(
-                                         &rcd->lookaside_qp->wait);
-                                        rcd->lookaside_qp = NULL;
-                                }
-                }
-                if (!rcd->lookaside_qp) {
-                        qp = qib_lookup_qpn(ibp, qp_num);
-                        if (!qp)
-                                goto drop;
-                        rcd->lookaside_qp = qp;
-                        rcd->lookaside_qpn = qp_num;
-                } else
-                        qp = rcd->lookaside_qp;
+                qp = qib_lookup_qpn(ibp, qp_num);
+                if (!qp)
+                        goto drop;
                 ibp->n_unicast_rcv++;
                 qib_qp_rcv(rcd, hdr, lnh == QIB_LRH_GRH, data, tlen, qp);
+                /*
+                 * Notify qib_destroy_qp() if it is waiting
+                 * for us to finish.
+                 */
+                if (atomic_dec_and_test(&qp->refcount))
+                        wake_up(&qp->wait);
         }
         return;
 
@@ -922,8 +903,8 @@ static void copy_io(u32 __iomem *piobuf, struct qib_sge_state *ss,
                 __raw_writel(last, piobuf);
 }
 
-static noinline struct qib_verbs_txreq *__get_txreq(struct qib_ibdev *dev,
-                                           struct qib_qp *qp)
+static struct qib_verbs_txreq *get_txreq(struct qib_ibdev *dev,
+                                         struct qib_qp *qp, int *retp)
 {
         struct qib_verbs_txreq *tx;
         unsigned long flags;
@@ -935,9 +916,8 @@ static noinline struct qib_verbs_txreq *__get_txreq(struct qib_ibdev *dev,
                 struct list_head *l = dev->txreq_free.next;
 
                 list_del(l);
-                spin_unlock(&dev->pending_lock);
-                spin_unlock_irqrestore(&qp->s_lock, flags);
                 tx = list_entry(l, struct qib_verbs_txreq, txreq.list);
+                *retp = 0;
         } else {
                 if (ib_qib_state_ops[qp->state] & QIB_PROCESS_RECV_OK &&
                     list_empty(&qp->iowait)) {
@@ -945,33 +925,14 @@ static noinline struct qib_verbs_txreq *__get_txreq(struct qib_ibdev *dev,
                         qp->s_flags |= QIB_S_WAIT_TX;
                         list_add_tail(&qp->iowait, &dev->txwait);
                 }
+                tx = NULL;
                 qp->s_flags &= ~QIB_S_BUSY;
-                spin_unlock(&dev->pending_lock);
-                spin_unlock_irqrestore(&qp->s_lock, flags);
-                tx = ERR_PTR(-EBUSY);
+                *retp = -EBUSY;
         }
-        return tx;
-}
-
-static inline struct qib_verbs_txreq *get_txreq(struct qib_ibdev *dev,
-                                         struct qib_qp *qp)
-{
-        struct qib_verbs_txreq *tx;
-        unsigned long flags;
 
-        spin_lock_irqsave(&dev->pending_lock, flags);
-        /* assume the list non empty */
-        if (likely(!list_empty(&dev->txreq_free))) {
-                struct list_head *l = dev->txreq_free.next;
+        spin_unlock(&dev->pending_lock);
+        spin_unlock_irqrestore(&qp->s_lock, flags);
 
-                list_del(l);
-                spin_unlock_irqrestore(&dev->pending_lock, flags);
-                tx = list_entry(l, struct qib_verbs_txreq, txreq.list);
-        } else {
-                /* call slow path to get the extra lock */
-                spin_unlock_irqrestore(&dev->pending_lock, flags);
-                tx =  __get_txreq(dev, qp);
-        }
         return tx;
 }
 
@@ -987,7 +948,7 @@ void qib_put_txreq(struct qib_verbs_txreq *tx)
         if (atomic_dec_and_test(&qp->refcount))
                 wake_up(&qp->wait);
         if (tx->mr) {
-                qib_put_mr(tx->mr);
+                atomic_dec(&tx->mr->refcount);
                 tx->mr = NULL;
         }
         if (tx->txreq.flags & QIB_SDMA_TXREQ_F_FREEBUF) {
@@ -1151,9 +1112,9 @@ static int qib_verbs_send_dma(struct qib_qp *qp, struct qib_ib_header *hdr,
                 goto bail;
         }
 
-        tx = get_txreq(dev, qp);
-        if (IS_ERR(tx))
-                goto bail_tx;
+        tx = get_txreq(dev, qp, &ret);
+        if (!tx)
+                goto bail;
 
         control = dd->f_setpbc_control(ppd, plen, qp->s_srate,
                                        be16_to_cpu(hdr->lrh[0]) >> 12);
@@ -1224,9 +1185,6 @@ unaligned:
         ibp->n_unaligned++;
 bail:
         return ret;
-bail_tx:
-        ret = PTR_ERR(tx);
-        goto bail;
 }
 
 /*
@@ -1345,7 +1303,7 @@ done:
         }
         qib_sendbuf_done(dd, pbufn);
         if (qp->s_rdma_mr) {
-                qib_put_mr(qp->s_rdma_mr);
+                atomic_dec(&qp->s_rdma_mr->refcount);
                 qp->s_rdma_mr = NULL;
         }
         if (qp->s_wqe) {
@@ -1854,23 +1812,6 @@ bail:
         return ret;
 }
 
-struct ib_ah *qib_create_qp0_ah(struct qib_ibport *ibp, u16 dlid)
-{
-        struct ib_ah_attr attr;
-        struct ib_ah *ah = ERR_PTR(-EINVAL);
-        struct qib_qp *qp0;
-
-        memset(&attr, 0, sizeof attr);
-        attr.dlid = dlid;
-        attr.port_num = ppd_from_ibp(ibp)->port;
-        rcu_read_lock();
-        qp0 = rcu_dereference(ibp->qp0);
-        if (qp0)
-                ah = ib_create_ah(qp0->ibqp.pd, &attr);
-        rcu_read_unlock();
-        return ah;
-}
-
 /**
  * qib_destroy_ah - destroy an address handle
  * @ibah: the AH to destroy
@@ -2033,8 +1974,6 @@ static void init_ibport(struct qib_pportdata *ppd)
         ibp->z_excessive_buffer_overrun_errors =
                 cntrs.excessive_buffer_overrun_errors;
         ibp->z_vl15_dropped = cntrs.vl15_dropped;
-        RCU_INIT_POINTER(ibp->qp0, NULL);
-        RCU_INIT_POINTER(ibp->qp1, NULL);
 }
 
 /**
@@ -2051,15 +1990,12 @@ int qib_register_ib_device(struct qib_devdata *dd)
         int ret;
 
         dev->qp_table_size = ib_qib_qp_table_size;
-        get_random_bytes(&dev->qp_rnd, sizeof(dev->qp_rnd));
-        dev->qp_table = kmalloc(dev->qp_table_size * sizeof *dev->qp_table,
+        dev->qp_table = kzalloc(dev->qp_table_size * sizeof *dev->qp_table,
                                 GFP_KERNEL);
         if (!dev->qp_table) {
                 ret = -ENOMEM;
                 goto err_qpt;
         }
-        for (i = 0; i < dev->qp_table_size; i++)
-                RCU_INIT_POINTER(dev->qp_table[i], NULL);
 
         for (i = 0; i < dd->num_pports; i++)
                 init_ibport(ppd + i);
@@ -2086,15 +2022,13 @@ int qib_register_ib_device(struct qib_devdata *dd)
         spin_lock_init(&dev->lk_table.lock);
         dev->lk_table.max = 1 << ib_qib_lkey_table_size;
         lk_tab_size = dev->lk_table.max * sizeof(*dev->lk_table.table);
-        dev->lk_table.table = (struct qib_mregion __rcu **)
+        dev->lk_table.table = (struct qib_mregion **)
                 __get_free_pages(GFP_KERNEL, get_order(lk_tab_size));
         if (dev->lk_table.table == NULL) {
                 ret = -ENOMEM;
                 goto err_lk;
         }
-        RCU_INIT_POINTER(dev->dma_mr, NULL);
-        for (i = 0; i < dev->lk_table.max; i++)
-                RCU_INIT_POINTER(dev->lk_table.table[i], NULL);
+        memset(dev->lk_table.table, 0, lk_tab_size);
         INIT_LIST_HEAD(&dev->pending_mmaps);
         spin_lock_init(&dev->pending_lock);
         dev->mmap_offset = PAGE_SIZE;
@@ -2224,7 +2158,7 @@ int qib_register_ib_device(struct qib_devdata *dd)
         ibdev->dma_ops = &qib_dma_mapping_ops;
 
         snprintf(ibdev->node_desc, sizeof(ibdev->node_desc),
-                 "QLogic Infiniband HCA %s", init_utsname()->nodename);
+                 QIB_IDSTR " %s", init_utsname()->nodename);
 
         ret = ib_register_device(ibdev, qib_create_port_files);
         if (ret)
@@ -2317,17 +2251,3 @@ void qib_unregister_ib_device(struct qib_devdata *dd)
                    get_order(lk_tab_size));
         kfree(dev->qp_table);
 }
-
-/*
- * This must be called with s_lock held.
- */
-void qib_schedule_send(struct qib_qp *qp)
-{
-        if (qib_send_ok(qp)) {
-                struct qib_ibport *ibp =
-                        to_iport(qp->ibqp.device, qp->port_num);
-                struct qib_pportdata *ppd = ppd_from_ibp(ibp);
-
-                queue_work(ppd->qib_wq, &qp->s_work);
-        }
-}
diff --git a/drivers/infiniband/hw/qib/qib_verbs.h b/drivers/infiniband/hw/qib/qib_verbs.h
index aff8b2c1788..95e5b47223b 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.h
+++ b/drivers/infiniband/hw/qib/qib_verbs.h
@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2012 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
+ * All rights reserved.
  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -41,7 +41,6 @@
 #include <linux/interrupt.h>
 #include <linux/kref.h>
 #include <linux/workqueue.h>
-#include <linux/completion.h>
 #include <rdma/ib_pack.h>
 #include <rdma/ib_user_verbs.h>
 
@@ -303,9 +302,6 @@ struct qib_mregion {
         u32 max_segs;           /* number of qib_segs in all the arrays */
         u32 mapsz;              /* size of the map array */
         u8  page_shift;         /* 0 - non unform/non powerof2 sizes */
-        u8  lkey_published;     /* in global table */
-        struct completion comp; /* complete when refcount goes to zero */
-        struct rcu_head list;
         atomic_t refcount;
         struct qib_segarray *map[0];    /* the segments */
 };
@@ -371,10 +367,9 @@ struct qib_rwq {
 
 struct qib_rq {
         struct qib_rwq *wq;
+        spinlock_t lock; /* protect changes in this struct */
         u32 size;               /* size of RWQE array */
         u8 max_sge;
-        spinlock_t lock /* protect changes in this struct */
-                ____cacheline_aligned_in_smp;
 };
 
 struct qib_srq {
@@ -417,75 +412,31 @@ struct qib_ack_entry {
  */
 struct qib_qp {
         struct ib_qp ibqp;
-        /* read mostly fields above and below */
+        struct qib_qp *next;            /* link list for QPN hash table */
+        struct qib_qp *timer_next;      /* link list for qib_ib_timer() */
+        struct list_head iowait;        /* link for wait PIO buf */
+        struct list_head rspwait;       /* link for waititing to respond */
         struct ib_ah_attr remote_ah_attr;
         struct ib_ah_attr alt_ah_attr;
-        struct qib_qp __rcu *next;            /* link list for QPN hash table */
-        struct qib_swqe *s_wq;  /* send work queue */
-        struct qib_mmap_info *ip;
-        struct qib_ib_header *s_hdr;     /* next packet header to send */
-        unsigned long timeout_jiffies;  /* computed from timeout */
-
-        enum ib_mtu path_mtu;
-        u32 remote_qpn;
-        u32 pmtu;               /* decoded from path_mtu */
-        u32 qkey;               /* QKEY for this QP (for UD or RD) */
-        u32 s_size;             /* send work queue size */
-        u32 s_rnr_timeout;      /* number of milliseconds for RNR timeout */
-
-        u8 state;               /* QP state */
-        u8 qp_access_flags;
-        u8 alt_timeout;         /* Alternate path timeout for this QP */
-        u8 timeout;             /* Timeout for this QP */
-        u8 s_srate;
-        u8 s_mig_state;
-        u8 port_num;
-        u8 s_pkey_index;        /* PKEY index to use */
-        u8 s_alt_pkey_index;    /* Alternate path PKEY index to use */
-        u8 r_max_rd_atomic;     /* max number of RDMA read/atomic to receive */
-        u8 s_max_rd_atomic;     /* max number of RDMA read/atomic to send */
-        u8 s_retry_cnt;         /* number of times to retry */
-        u8 s_rnr_retry_cnt;
-        u8 r_min_rnr_timer;     /* retry timeout value for RNR NAKs */
-        u8 s_max_sge;           /* size of s_wq->sg_list */
-        u8 s_draining;
-
-        /* start of read/write fields */
-
-        atomic_t refcount ____cacheline_aligned_in_smp;
+        struct qib_ib_header s_hdr;     /* next packet header to send */
+        atomic_t refcount;
         wait_queue_head_t wait;
-
-
-        struct qib_ack_entry s_ack_queue[QIB_MAX_RDMA_ATOMIC + 1]
-                ____cacheline_aligned_in_smp;
-        struct qib_sge_state s_rdma_read_sge;
-
-        spinlock_t r_lock ____cacheline_aligned_in_smp;      /* used for APM */
-        unsigned long r_aflags;
-        u64 r_wr_id;            /* ID for current receive WQE */
-        u32 r_ack_psn;          /* PSN for next ACK or atomic ACK */
-        u32 r_len;              /* total length of r_sge */
-        u32 r_rcv_len;          /* receive data len processed */
-        u32 r_psn;              /* expected rcv packet sequence number */
-        u32 r_msn;              /* message sequence number */
-
-        u8 r_state;             /* opcode of last packet received */
-        u8 r_flags;
-        u8 r_head_ack_queue;    /* index into s_ack_queue[] */
-
-        struct list_head rspwait;       /* link for waititing to respond */
-
-        struct qib_sge_state r_sge;     /* current receive data */
-        struct qib_rq r_rq;             /* receive work queue */
-
-        spinlock_t s_lock ____cacheline_aligned_in_smp;
+        wait_queue_head_t wait_dma;
+        struct timer_list s_timer;
+        struct work_struct s_work;
+        struct qib_mmap_info *ip;
         struct qib_sge_state *s_cur_sge;
-        u32 s_flags;
         struct qib_verbs_txreq *s_tx;
-        struct qib_swqe *s_wqe;
-        struct qib_sge_state s_sge;     /* current send request data */
         struct qib_mregion *s_rdma_mr;
+        struct qib_sge_state s_sge;     /* current send request data */
+        struct qib_ack_entry s_ack_queue[QIB_MAX_RDMA_ATOMIC + 1];
+        struct qib_sge_state s_ack_rdma_sge;
+        struct qib_sge_state s_rdma_read_sge;
+        struct qib_sge_state r_sge;     /* current receive data */
+        spinlock_t r_lock;      /* used for APM */
+        spinlock_t s_lock;
         atomic_t s_dma_busy;
+        u32 s_flags;
         u32 s_cur_size;         /* size of send packet in bytes */
         u32 s_len;              /* total length of s_sge */
         u32 s_rdma_read_len;    /* total length of s_rdma_read_sge */
@@ -496,34 +447,58 @@ struct qib_qp {
         u32 s_psn;              /* current packet sequence number */
         u32 s_ack_rdma_psn;     /* PSN for sending RDMA read responses */
         u32 s_ack_psn;          /* PSN for acking sends and RDMA writes */
-        u32 s_head;             /* new entries added here */
-        u32 s_tail;             /* next entry to process */
-        u32 s_cur;              /* current work queue entry */
-        u32 s_acked;            /* last un-ACK'ed entry */
-        u32 s_last;             /* last completed entry */
-        u32 s_ssn;              /* SSN of tail entry */
-        u32 s_lsn;              /* limit sequence number (credit) */
+        u32 s_rnr_timeout;      /* number of milliseconds for RNR timeout */
+        u32 r_ack_psn;          /* PSN for next ACK or atomic ACK */
+        u64 r_wr_id;            /* ID for current receive WQE */
+        unsigned long r_aflags;
+        u32 r_len;              /* total length of r_sge */
+        u32 r_rcv_len;          /* receive data len processed */
+        u32 r_psn;              /* expected rcv packet sequence number */
+        u32 r_msn;              /* message sequence number */
         u16 s_hdrwords;         /* size of s_hdr in 32 bit words */
         u16 s_rdma_ack_cnt;
+        u8 state;               /* QP state */
         u8 s_state;             /* opcode of last packet sent */
         u8 s_ack_state;         /* opcode of packet to ACK */
         u8 s_nak_state;         /* non-zero if NAK is pending */
+        u8 r_state;             /* opcode of last packet received */
         u8 r_nak_state;         /* non-zero if NAK is pending */
+        u8 r_min_rnr_timer;     /* retry timeout value for RNR NAKs */
+        u8 r_flags;
+        u8 r_max_rd_atomic;     /* max number of RDMA read/atomic to receive */
+        u8 r_head_ack_queue;    /* index into s_ack_queue[] */
+        u8 qp_access_flags;
+        u8 s_max_sge;           /* size of s_wq->sg_list */
+        u8 s_retry_cnt;         /* number of times to retry */
+        u8 s_rnr_retry_cnt;
         u8 s_retry;             /* requester retry counter */
         u8 s_rnr_retry;         /* requester RNR retry counter */
+        u8 s_pkey_index;        /* PKEY index to use */
+        u8 s_alt_pkey_index;    /* Alternate path PKEY index to use */
+        u8 s_max_rd_atomic;     /* max number of RDMA read/atomic to send */
         u8 s_num_rd_atomic;     /* number of RDMA read/atomic pending */
         u8 s_tail_ack_queue;    /* index into s_ack_queue[] */
-
-        struct qib_sge_state s_ack_rdma_sge;
-        struct timer_list s_timer;
-        struct list_head iowait;        /* link for wait PIO buf */
-
-        struct work_struct s_work;
-
-        wait_queue_head_t wait_dma;
-
-        struct qib_sge r_sg_list[0] /* verified SGEs */
-                ____cacheline_aligned_in_smp;
+        u8 s_srate;
+        u8 s_draining;
+        u8 s_mig_state;
+        u8 timeout;             /* Timeout for this QP */
+        u8 alt_timeout;         /* Alternate path timeout for this QP */
+        u8 port_num;
+        enum ib_mtu path_mtu;
+        u32 remote_qpn;
+        u32 qkey;               /* QKEY for this QP (for UD or RD) */
+        u32 s_size;             /* send work queue size */
+        u32 s_head;             /* new entries added here */
+        u32 s_tail;             /* next entry to process */
+        u32 s_cur;              /* current work queue entry */
+        u32 s_acked;            /* last un-ACK'ed entry */
+        u32 s_last;             /* last completed entry */
+        u32 s_ssn;              /* SSN of tail entry */
+        u32 s_lsn;              /* limit sequence number (credit) */
+        struct qib_swqe *s_wq;  /* send work queue */
+        struct qib_swqe *s_wqe;
+        struct qib_rq r_rq;             /* receive work queue */
+        struct qib_sge r_sg_list[0];    /* verified SGEs */
 };
 
 /*
@@ -650,7 +625,7 @@ struct qib_lkey_table {
         u32 next;               /* next unused index (speeds search) */
         u32 gen;                /* generation count */
         u32 max;                /* size of the table */
-        struct qib_mregion __rcu **table;
+        struct qib_mregion **table;
 };
 
 struct qib_opcode_stats {
@@ -659,8 +634,8 @@ struct qib_opcode_stats {
 };
 
 struct qib_ibport {
-        struct qib_qp __rcu *qp0;
-        struct qib_qp __rcu *qp1;
+        struct qib_qp *qp0;
+        struct qib_qp *qp1;
         struct ib_mad_agent *send_agent;        /* agent for SMI (traps) */
         struct qib_ah *sm_ah;
         struct qib_ah *smi_ah;
@@ -727,13 +702,12 @@ struct qib_ibport {
         struct qib_opcode_stats opstats[128];
 };
 
-
 struct qib_ibdev {
         struct ib_device ibdev;
         struct list_head pending_mmaps;
         spinlock_t mmap_offset_lock; /* protect mmap_offset */
         u32 mmap_offset;
-        struct qib_mregion __rcu *dma_mr;
+        struct qib_mregion *dma_mr;
 
         /* QP numbers are shared by all IB ports */
         struct qib_qpn_table qpn_table;
@@ -744,13 +718,12 @@ struct qib_ibdev {
         struct list_head memwait;       /* list for wait kernel memory */
         struct list_head txreq_free;
         struct timer_list mem_timer;
-        struct qib_qp __rcu **qp_table;
+        struct qib_qp **qp_table;
         struct qib_pio_header *pio_hdrs;
         dma_addr_t pio_hdrs_phys;
         /* list of QPs waiting for RNR timer */
         spinlock_t pending_lock; /* protect wait lists, PMA counters, etc. */
-        u32 qp_table_size; /* size of the hash table */
-        u32 qp_rnd; /* random bytes for hash */
+        unsigned qp_table_size; /* size of the hash table */
         spinlock_t qpt_lock;
 
         u32 n_piowait;
@@ -837,7 +810,11 @@ extern struct workqueue_struct *qib_cq_wq;
 /*
  * This must be called with s_lock held.
  */
-void qib_schedule_send(struct qib_qp *qp);
+static inline void qib_schedule_send(struct qib_qp *qp)
+{
+        if (qib_send_ok(qp))
+                queue_work(ib_wq, &qp->s_work);
+}
 
 static inline int qib_pkey_ok(u16 pkey1, u16 pkey2)
 {
@@ -934,8 +911,6 @@ void qib_rc_rcv(struct qib_ctxtdata *rcd, struct qib_ib_header *hdr,
 
 int qib_check_ah(struct ib_device *ibdev, struct ib_ah_attr *ah_attr);
 
-struct ib_ah *qib_create_qp0_ah(struct qib_ibport *ibp, u16 dlid);
-
 void qib_rc_rnr_retry(unsigned long arg);
 
 void qib_rc_send_complete(struct qib_qp *qp, struct qib_ib_header *hdr);
@@ -947,9 +922,9 @@ int qib_post_ud_send(struct qib_qp *qp, struct ib_send_wr *wr);
 void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                 int has_grh, void *data, u32 tlen, struct qib_qp *qp);
 
-int qib_alloc_lkey(struct qib_mregion *mr, int dma_region);
+int qib_alloc_lkey(struct qib_lkey_table *rkt, struct qib_mregion *mr);
 
-void qib_free_lkey(struct qib_mregion *mr);
+int qib_free_lkey(struct qib_ibdev *dev, struct qib_mregion *mr);
 
 int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
                 struct qib_sge *isge, struct ib_sge *sge, int acc);
@@ -1017,29 +992,6 @@ int qib_unmap_fmr(struct list_head *fmr_list);
 
 int qib_dealloc_fmr(struct ib_fmr *ibfmr);
 
-static inline void qib_get_mr(struct qib_mregion *mr)
-{
-        atomic_inc(&mr->refcount);
-}
-
-void mr_rcu_callback(struct rcu_head *list);
-
-static inline void qib_put_mr(struct qib_mregion *mr)
-{
-        if (unlikely(atomic_dec_and_test(&mr->refcount)))
-                call_rcu(&mr->list, mr_rcu_callback);
-}
-
-static inline void qib_put_ss(struct qib_sge_state *ss)
-{
-        while (ss->num_sge) {
-                qib_put_mr(ss->sge.mr);
-                if (--ss->num_sge)
-                        ss->sge = *ss->sg_list++;
-        }
-}
-
-
 void qib_release_mmap_info(struct kref *ref);
 
 struct qib_mmap_info *qib_create_mmap_info(struct qib_ibdev *dev, u32 size,
diff --git a/drivers/infiniband/hw/qib/qib_wc_x86_64.c b/drivers/infiniband/hw/qib/qib_wc_x86_64.c
index 1d7281c5a02..561b8bca406 100644
--- a/drivers/infiniband/hw/qib/qib_wc_x86_64.c
+++ b/drivers/infiniband/hw/qib/qib_wc_x86_64.c
@@ -1,6 +1,5 @@
 /*
- * Copyright (c) 2012 Intel Corporation. All rights reserved.
- * Copyright (c) 2006 - 2012 QLogic Corporation. All rights reserved.
+ * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
@@ -103,10 +102,10 @@ int qib_enable_wc(struct qib_devdata *dd)
                 u64 atmp;
                 atmp = pioaddr & ~(piolen - 1);
                 if (atmp < addr || (atmp + piolen) > (addr + len)) {
-                        qib_dev_err(dd,
-                                "No way to align address/size (%llx/%llx), no WC mtrr\n",
-                                (unsigned long long) atmp,
-                                (unsigned long long) piolen << 1);
+                        qib_dev_err(dd, "No way to align address/size "
+                                    "(%llx/%llx), no WC mtrr\n",
+                                    (unsigned long long) atmp,
+                                    (unsigned long long) piolen << 1);
                         ret = -ENODEV;
                 } else {
                         pioaddr = atmp;
@@ -121,7 +120,8 @@ int qib_enable_wc(struct qib_devdata *dd)
                 if (cookie < 0) {
                         {
                                 qib_devinfo(dd->pcidev,
-                                         "mtrr_add()  WC for PIO bufs failed (%d)\n",
+                                         "mtrr_add()  WC for PIO bufs "
+                                         "failed (%d)\n",
                                          cookie);
                                 ret = -EINVAL;
                         }
diff --git a/drivers/infiniband/ulp/ipoib/Makefile b/drivers/infiniband/ulp/ipoib/Makefile
index e5430dd5076..3090100f0de 100644
--- a/drivers/infiniband/ulp/ipoib/Makefile
+++ b/drivers/infiniband/ulp/ipoib/Makefile
@@ -5,8 +5,7 @@ ib_ipoib-y					:= ipoib_main.o \
                                                    ipoib_multicast.o \
                                                    ipoib_verbs.o \
                                                    ipoib_vlan.o \
-                                                   ipoib_ethtool.o \
-                                                   ipoib_netlink.o
+                                                   ipoib_ethtool.o
 ib_ipoib-$(CONFIG_INFINIBAND_IPOIB_CM)          += ipoib_cm.o
 ib_ipoib-$(CONFIG_INFINIBAND_IPOIB_DEBUG)       += ipoib_fs.o
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index 07ca6fd5546..b3cc1e062b1 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -44,7 +44,6 @@
 #include <linux/mutex.h>
 
 #include <net/neighbour.h>
-#include <net/sch_generic.h>
 
 #include <linux/atomic.h>
 
@@ -92,8 +91,6 @@ enum {
         IPOIB_STOP_REAPER         = 7,
         IPOIB_FLAG_ADMIN_CM       = 9,
         IPOIB_FLAG_UMCAST         = 10,
-        IPOIB_STOP_NEIGH_GC       = 11,
-        IPOIB_NEIGH_TBL_FLUSH     = 12,
 
         IPOIB_MAX_BACKOFF_SECONDS = 16,
 
@@ -104,10 +101,6 @@ enum {
 
         MAX_SEND_CQE              = 16,
         IPOIB_CM_COPYBREAK        = 256,
-
-        IPOIB_NON_CHILD           = 0,
-        IPOIB_LEGACY_CHILD        = 1,
-        IPOIB_RTNL_CHILD          = 2,
 };
 
 #define IPOIB_OP_RECV   (1ul << 31)
@@ -124,9 +117,8 @@ struct ipoib_header {
         u16     reserved;
 };
 
-struct ipoib_cb {
-        struct qdisc_skb_cb     qdisc_cb;
-        u8                      hwaddr[INFINIBAND_ALEN];
+struct ipoib_pseudoheader {
+        u8  hwaddr[INFINIBAND_ALEN];
 };
 
 /* Used for all multicast joins (broadcast, IPv4 mcast and IPv6 mcast) */
@@ -266,23 +258,6 @@ struct ipoib_ethtool_st {
         u16     max_coalesced_frames;
 };
 
-struct ipoib_neigh_table;
-
-struct ipoib_neigh_hash {
-        struct ipoib_neigh_table       *ntbl;
-        struct ipoib_neigh __rcu      **buckets;
-        struct rcu_head                 rcu;
-        u32                             mask;
-        u32                             size;
-};
-
-struct ipoib_neigh_table {
-        struct ipoib_neigh_hash __rcu  *htbl;
-        atomic_t                        entries;
-        struct completion               flushed;
-        struct completion               deleted;
-};
-
 /*
  * Device private locking: network stack tx_lock protects members used
  * in TX fast path, lock protects everything else.  lock nests inside
@@ -302,8 +277,6 @@ struct ipoib_dev_priv {
         struct rb_root  path_tree;
         struct list_head path_list;
 
-        struct ipoib_neigh_table ntbl;
-
         struct ipoib_mcast *broadcast;
         struct list_head multicast_list;
         struct rb_root multicast_tree;
@@ -316,7 +289,7 @@ struct ipoib_dev_priv {
         struct work_struct flush_heavy;
         struct work_struct restart_task;
         struct delayed_work ah_reap_task;
-        struct delayed_work neigh_reap_task;
+
         struct ib_device *ca;
         u8                port;
         u16               pkey;
@@ -357,7 +330,6 @@ struct ipoib_dev_priv {
         struct net_device *parent;
         struct list_head child_intfs;
         struct list_head list;
-        int    child_type;
 
 #ifdef CONFIG_INFINIBAND_IPOIB_CM
         struct ipoib_cm_dev_priv cm;
@@ -403,16 +375,13 @@ struct ipoib_neigh {
 #ifdef CONFIG_INFINIBAND_IPOIB_CM
         struct ipoib_cm_tx *cm;
 #endif
-        u8     daddr[INFINIBAND_ALEN];
+        union ib_gid        dgid;
         struct sk_buff_head queue;
 
+        struct neighbour   *neighbour;
         struct net_device *dev;
 
         struct list_head    list;
-        struct ipoib_neigh __rcu *hnext;
-        struct rcu_head     rcu;
-        atomic_t            refcnt;
-        unsigned long       alive;
 };
 
 #define IPOIB_UD_MTU(ib_mtu)            (ib_mtu - IPOIB_ENCAP_LEN)
@@ -423,17 +392,21 @@ static inline int ipoib_ud_need_sg(unsigned int ib_mtu)
         return IPOIB_UD_BUF_SIZE(ib_mtu) > PAGE_SIZE;
 }
 
-void ipoib_neigh_dtor(struct ipoib_neigh *neigh);
-static inline void ipoib_neigh_put(struct ipoib_neigh *neigh)
+/*
+ * We stash a pointer to our private neighbour information after our
+ * hardware address in neigh->ha.  The ALIGN() expression here makes
+ * sure that this pointer is stored aligned so that an unaligned
+ * load is not needed to dereference it.
+ */
+static inline struct ipoib_neigh **to_ipoib_neigh(struct neighbour *neigh)
 {
-        if (atomic_dec_and_test(&neigh->refcnt))
-                ipoib_neigh_dtor(neigh);
+        return (void*) neigh + ALIGN(offsetof(struct neighbour, ha) +
+                                     INFINIBAND_ALEN, sizeof(void *));
 }
-struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr);
-struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr,
+
+struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neigh,
                                       struct net_device *dev);
-void ipoib_neigh_free(struct ipoib_neigh *neigh);
-void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid);
+void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh);
 
 extern struct workqueue_struct *ipoib_workqueue;
 
@@ -450,6 +423,7 @@ static inline void ipoib_put_ah(struct ipoib_ah *ah)
 {
         kref_put(&ah->ref, ipoib_free_ah);
 }
+
 int ipoib_open(struct net_device *dev);
 int ipoib_add_pkey_attr(struct net_device *dev);
 int ipoib_add_umcast_attr(struct net_device *dev);
@@ -479,7 +453,7 @@ void ipoib_dev_cleanup(struct net_device *dev);
 
 void ipoib_mcast_join_task(struct work_struct *work);
 void ipoib_mcast_carrier_on_task(struct work_struct *work);
-void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb);
+void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb);
 
 void ipoib_mcast_restart_task(struct work_struct *work);
 int ipoib_mcast_start_thread(struct net_device *dev);
@@ -517,17 +491,6 @@ void ipoib_event(struct ib_event_handler *handler,
 int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey);
 int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey);
 
-int __ipoib_vlan_add(struct ipoib_dev_priv *ppriv, struct ipoib_dev_priv *priv,
-                     u16 pkey, int child_type);
-
-int  __init ipoib_netlink_init(void);
-void __exit ipoib_netlink_fini(void);
-
-void ipoib_set_umcast(struct net_device *ndev, int umcast_val);
-int  ipoib_set_mode(struct net_device *dev, const char *buf);
-
-void ipoib_setup(struct net_device *dev);
-
 void ipoib_pkey_poll(struct work_struct *work);
 int ipoib_pkey_dev_delay_open(struct net_device *dev);
 void ipoib_drain_cq(struct net_device *dev);
@@ -535,14 +498,14 @@ void ipoib_drain_cq(struct net_device *dev);
 void ipoib_set_ethtool_ops(struct net_device *dev);
 int ipoib_set_dev_features(struct ipoib_dev_priv *priv, struct ib_device *hca);
 
+#ifdef CONFIG_INFINIBAND_IPOIB_CM
+
 #define IPOIB_FLAGS_RC          0x80
 #define IPOIB_FLAGS_UC          0x40
 
 /* We don't support UC connections at the moment */
 #define IPOIB_CM_SUPPORTED(ha)   (ha[0] & (IPOIB_FLAGS_RC))
 
-#ifdef CONFIG_INFINIBAND_IPOIB_CM
-
 extern int ipoib_max_conn_qp;
 
 static inline int ipoib_cm_admin_enabled(struct net_device *dev)
@@ -552,10 +515,10 @@ static inline int ipoib_cm_admin_enabled(struct net_device *dev)
                 test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
 }
 
-static inline int ipoib_cm_enabled(struct net_device *dev, u8 *hwaddr)
+static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
-        return IPOIB_CM_SUPPORTED(hwaddr) &&
+        return IPOIB_CM_SUPPORTED(n->ha) &&
                 test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
 }
 
@@ -610,7 +573,7 @@ static inline int ipoib_cm_admin_enabled(struct net_device *dev)
 {
         return 0;
 }
-static inline int ipoib_cm_enabled(struct net_device *dev, u8 *hwaddr)
+static inline int ipoib_cm_enabled(struct net_device *dev, struct neighbour *n)
 
 {
         return 0;
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
index 03103d2bd64..39913a065f9 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
@@ -37,7 +37,6 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
-#include <linux/moduleparam.h>
 
 #include "ipoib.h"
 
@@ -85,7 +84,7 @@ static void ipoib_cm_dma_unmap_rx(struct ipoib_dev_priv *priv, int frags,
         ib_dma_unmap_single(priv->ca, mapping[0], IPOIB_CM_HEAD_SIZE, DMA_FROM_DEVICE);
 
         for (i = 0; i < frags; ++i)
-                ib_dma_unmap_page(priv->ca, mapping[i + 1], PAGE_SIZE, DMA_FROM_DEVICE);
+                ib_dma_unmap_single(priv->ca, mapping[i + 1], PAGE_SIZE, DMA_FROM_DEVICE);
 }
 
 static int ipoib_cm_post_receive_srq(struct net_device *dev, int id)
@@ -170,7 +169,7 @@ static struct sk_buff *ipoib_cm_alloc_rx_skb(struct net_device *dev,
                         goto partial_error;
                 skb_fill_page_desc(skb, i, page, 0, PAGE_SIZE);
 
-                mapping[i + 1] = ib_dma_map_page(priv->ca, page,
+                mapping[i + 1] = ib_dma_map_page(priv->ca, skb_shinfo(skb)->frags[i].page,
                                                  0, PAGE_SIZE, DMA_FROM_DEVICE);
                 if (unlikely(ib_dma_mapping_error(priv->ca, mapping[i + 1])))
                         goto partial_error;
@@ -184,7 +183,7 @@ partial_error:
         ib_dma_unmap_single(priv->ca, mapping[0], IPOIB_CM_HEAD_SIZE, DMA_FROM_DEVICE);
 
         for (; i > 0; --i)
-                ib_dma_unmap_page(priv->ca, mapping[i], PAGE_SIZE, DMA_FROM_DEVICE);
+                ib_dma_unmap_single(priv->ca, mapping[i], PAGE_SIZE, DMA_FROM_DEVICE);
 
         dev_kfree_skb_any(skb);
         return NULL;
@@ -538,13 +537,12 @@ static void skb_put_frags(struct sk_buff *skb, unsigned int hdr_space,
 
                 if (length == 0) {
                         /* don't need this page */
-                        skb_fill_page_desc(toskb, i, skb_frag_page(frag),
-                                           0, PAGE_SIZE);
+                        skb_fill_page_desc(toskb, i, frag->page, 0, PAGE_SIZE);
                         --skb_shinfo(skb)->nr_frags;
                 } else {
                         size = min(length, (unsigned) PAGE_SIZE);
 
-                        skb_frag_size_set(frag, size);
+                        frag->size = size;
                         skb->data_len += size;
                         skb->truesize += size;
                         skb->len += size;
@@ -752,9 +750,6 @@ void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_
                 dev->trans_start = jiffies;
                 ++tx->tx_head;
 
-                skb_orphan(skb);
-                skb_dst_drop(skb);
-
                 if (++priv->tx_outstanding == ipoib_sendq_size) {
                         ipoib_dbg(priv, "TX ring 0x%x full, stopping kernel net queue\n",
                                   tx->qp->qp_num);
@@ -814,7 +809,9 @@ void ipoib_cm_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
                 if (neigh) {
                         neigh->cm = NULL;
                         list_del(&neigh->list);
-                        ipoib_neigh_free(neigh);
+                        if (neigh->ah)
+                                ipoib_put_ah(neigh->ah);
+                        ipoib_neigh_free(dev, neigh);
 
                         tx->neigh = NULL;
                 }
@@ -1231,7 +1228,9 @@ static int ipoib_cm_tx_handler(struct ib_cm_id *cm_id,
                 if (neigh) {
                         neigh->cm = NULL;
                         list_del(&neigh->list);
-                        ipoib_neigh_free(neigh);
+                        if (neigh->ah)
+                                ipoib_put_ah(neigh->ah);
+                        ipoib_neigh_free(dev, neigh);
 
                         tx->neigh = NULL;
                 }
@@ -1274,15 +1273,12 @@ struct ipoib_cm_tx *ipoib_cm_create_tx(struct net_device *dev, struct ipoib_path
 void ipoib_cm_destroy_tx(struct ipoib_cm_tx *tx)
 {
         struct ipoib_dev_priv *priv = netdev_priv(tx->dev);
-        unsigned long flags;
         if (test_and_clear_bit(IPOIB_FLAG_INITIALIZED, &tx->flags)) {
-                spin_lock_irqsave(&priv->lock, flags);
                 list_move(&tx->list, &priv->cm.reap_list);
                 queue_work(ipoib_workqueue, &priv->cm.reap_task);
                 ipoib_dbg(priv, "Reap connection for gid %pI6\n",
-                          tx->neigh->daddr + 4);
+                          tx->neigh->dgid.raw);
                 tx->neigh = NULL;
-                spin_unlock_irqrestore(&priv->lock, flags);
         }
 }
 
@@ -1306,7 +1302,7 @@ static void ipoib_cm_tx_start(struct work_struct *work)
                 p = list_entry(priv->cm.start_list.next, typeof(*p), list);
                 list_del_init(&p->list);
                 neigh = p->neigh;
-                qpn = IPOIB_QPN(neigh->daddr);
+                qpn = IPOIB_QPN(neigh->neighbour->ha);
                 memcpy(&pathrec, &p->path->pathrec, sizeof pathrec);
 
                 spin_unlock_irqrestore(&priv->lock, flags);
@@ -1322,7 +1318,9 @@ static void ipoib_cm_tx_start(struct work_struct *work)
                         if (neigh) {
                                 neigh->cm = NULL;
                                 list_del(&neigh->list);
-                                ipoib_neigh_free(neigh);
+                                if (neigh->ah)
+                                        ipoib_put_ah(neigh->ah);
+                                ipoib_neigh_free(dev, neigh);
                         }
                         list_del(&p->list);
                         kfree(p);
@@ -1376,7 +1374,7 @@ static void ipoib_cm_skb_reap(struct work_struct *work)
 
                 if (skb->protocol == htons(ETH_P_IP))
                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
-#if IS_ENABLED(CONFIG_IPV6)
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
                 else if (skb->protocol == htons(ETH_P_IPV6))
                         icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
 #endif
@@ -1397,7 +1395,7 @@ void ipoib_cm_skb_too_long(struct net_device *dev, struct sk_buff *skb,
         int e = skb_queue_empty(&priv->cm.skb_queue);
 
         if (skb_dst(skb))
-                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
+                skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 
         skb_queue_tail(&priv->cm.skb_queue, skb);
         if (e)
@@ -1455,19 +1453,36 @@ static ssize_t set_mode(struct device *d, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
         struct net_device *dev = to_net_dev(d);
-        int ret;
+        struct ipoib_dev_priv *priv = netdev_priv(dev);
 
         if (!rtnl_trylock())
                 return restart_syscall();
 
-        ret = ipoib_set_mode(dev, buf);
+        /* flush paths if we switch modes so that connections are restarted */
+        if (IPOIB_CM_SUPPORTED(dev->dev_addr) && !strcmp(buf, "connected\n")) {
+                set_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
+                ipoib_warn(priv, "enabling connected mode "
+                           "will cause multicast packet drops\n");
+                netdev_update_features(dev);
+                rtnl_unlock();
+                priv->tx_wr.send_flags &= ~IB_SEND_IP_CSUM;
 
-        rtnl_unlock();
+                ipoib_flush_paths(dev);
+                return count;
+        }
+
+        if (!strcmp(buf, "datagram\n")) {
+                clear_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
+                netdev_update_features(dev);
+                dev_set_mtu(dev, min(priv->mcast_mtu, dev->mtu));
+                rtnl_unlock();
+                ipoib_flush_paths(dev);
 
-        if (!ret)
                 return count;
+        }
+        rtnl_unlock();
 
-        return ret;
+        return -EINVAL;
 }
 
 static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, show_mode, set_mode);
@@ -1481,7 +1496,6 @@ static void ipoib_cm_create_srq(struct net_device *dev, int max_sge)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ib_srq_init_attr srq_init_attr = {
-                .srq_type = IB_SRQT_BASIC,
                 .attr = {
                         .max_wr  = ipoib_recvq_size,
                         .max_sge = max_sge
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_fs.c b/drivers/infiniband/ulp/ipoib/ipoib_fs.c
index 50061854616..86eae229dc4 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_fs.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_fs.c
@@ -37,7 +37,6 @@
 struct file_operations;
 
 #include <linux/debugfs.h>
-#include <linux/export.h>
 
 #include "ipoib.h"
 
@@ -213,15 +212,16 @@ static int ipoib_path_seq_show(struct seq_file *file, void *iter_ptr)
                    gid_buf, path.pathrec.dlid ? "yes" : "no");
 
         if (path.pathrec.dlid) {
-                rate = ib_rate_to_mbps(path.pathrec.rate);
+                rate = ib_rate_to_mult(path.pathrec.rate) * 25;
 
                 seq_printf(file,
                            "  DLID:     0x%04x\n"
                            "  SL: %12d\n"
-                           "  rate: %8d.%d Gb/sec\n",
+                           "  rate: %*d%s Gb/sec\n",
                            be16_to_cpu(path.pathrec.dlid),
                            path.pathrec.sl,
-                           rate / 1000, rate % 1000);
+                           10 - ((rate % 10) ? 2 : 0),
+                           rate / 10, rate % 10 ? ".5" : "");
         }
 
         seq_putc(file, '\n');
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index a1bca70e20a..81ae61d68a2 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -34,7 +34,6 @@
  */
 
 #include <linux/delay.h>
-#include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 
@@ -57,24 +56,21 @@ struct ipoib_ah *ipoib_create_ah(struct net_device *dev,
                                  struct ib_pd *pd, struct ib_ah_attr *attr)
 {
         struct ipoib_ah *ah;
-        struct ib_ah *vah;
 
         ah = kmalloc(sizeof *ah, GFP_KERNEL);
         if (!ah)
-                return ERR_PTR(-ENOMEM);
+                return NULL;
 
         ah->dev       = dev;
         ah->last_send = 0;
         kref_init(&ah->ref);
 
-        vah = ib_create_ah(pd, attr);
-        if (IS_ERR(vah)) {
+        ah->ah = ib_create_ah(pd, attr);
+        if (IS_ERR(ah->ah)) {
                 kfree(ah);
-                ah = (struct ipoib_ah *)vah;
-        } else {
-                ah->ah = vah;
+                ah = NULL;
+        } else
                 ipoib_dbg(netdev_priv(dev), "Created ah %p\n", ah->ah);
-        }
 
         return ah;
 }
@@ -121,9 +117,9 @@ static void ipoib_ud_skb_put_frags(struct ipoib_dev_priv *priv,
 
                 size = length - IPOIB_UD_HEAD_SIZE;
 
-                skb_frag_size_set(frag, size);
+                frag->size     = size;
                 skb->data_len += size;
-                skb->truesize += PAGE_SIZE;
+                skb->truesize += size;
         } else
                 skb_put(skb, length);
 
@@ -156,18 +152,14 @@ static struct sk_buff *ipoib_alloc_rx_skb(struct net_device *dev, int id)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct sk_buff *skb;
         int buf_size;
-        int tailroom;
         u64 *mapping;
 
-        if (ipoib_ud_need_sg(priv->max_ib_mtu)) {
+        if (ipoib_ud_need_sg(priv->max_ib_mtu))
                 buf_size = IPOIB_UD_HEAD_SIZE;
-                tailroom = 128; /* reserve some tailroom for IP/TCP headers */
-        } else {
+        else
                 buf_size = IPOIB_UD_BUF_SIZE(priv->max_ib_mtu);
-                tailroom = 0;
-        }
 
-        skb = dev_alloc_skb(buf_size + tailroom + 4);
+        skb = dev_alloc_skb(buf_size + 4);
         if (unlikely(!skb))
                 return NULL;
 
@@ -190,7 +182,7 @@ static struct sk_buff *ipoib_alloc_rx_skb(struct net_device *dev, int id)
                         goto partial_error;
                 skb_fill_page_desc(skb, 0, page, 0, PAGE_SIZE);
                 mapping[1] =
-                        ib_dma_map_page(priv->ca, page,
+                        ib_dma_map_page(priv->ca, skb_shinfo(skb)->frags[0].page,
                                         0, PAGE_SIZE, DMA_FROM_DEVICE);
                 if (unlikely(ib_dma_mapping_error(priv->ca, mapping[1])))
                         goto partial_error;
@@ -300,8 +292,7 @@ static void ipoib_ib_handle_rx_wc(struct net_device *dev, struct ib_wc *wc)
         dev->stats.rx_bytes += skb->len;
 
         skb->dev = dev;
-        if ((dev->features & NETIF_F_RXCSUM) &&
-                        likely(wc->wc_flags & IB_WC_IP_CSUM_OK))
+        if ((dev->features & NETIF_F_RXCSUM) && likely(wc->csum_ok))
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 
         napi_gro_receive(&priv->napi, skb);
@@ -331,10 +322,9 @@ static int ipoib_dma_map_tx(struct ib_device *ca,
                 off = 0;
 
         for (i = 0; i < skb_shinfo(skb)->nr_frags; ++i) {
-                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
-                mapping[i + off] = ib_dma_map_page(ca,
-                                                 skb_frag_page(frag),
-                                                 frag->page_offset, skb_frag_size(frag),
+                skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                mapping[i + off] = ib_dma_map_page(ca, frag->page,
+                                                 frag->page_offset, frag->size,
                                                  DMA_TO_DEVICE);
                 if (unlikely(ib_dma_mapping_error(ca, mapping[i + off])))
                         goto partial_error;
@@ -343,9 +333,8 @@ static int ipoib_dma_map_tx(struct ib_device *ca,
 
 partial_error:
         for (; i > 0; --i) {
-                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i - 1];
-
-                ib_dma_unmap_page(ca, mapping[i - !off], skb_frag_size(frag), DMA_TO_DEVICE);
+                skb_frag_t *frag = &skb_shinfo(skb)->frags[i - 1];
+                ib_dma_unmap_page(ca, mapping[i - !off], frag->size, DMA_TO_DEVICE);
         }
 
         if (off)
@@ -369,9 +358,8 @@ static void ipoib_dma_unmap_tx(struct ib_device *ca,
                 off = 0;
 
         for (i = 0; i < skb_shinfo(skb)->nr_frags; ++i) {
-                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
-
-                ib_dma_unmap_page(ca, mapping[i + off], skb_frag_size(frag),
+                skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
+                ib_dma_unmap_page(ca, mapping[i + off], frag->size,
                                   DMA_TO_DEVICE);
         }
 }
@@ -521,7 +509,7 @@ static inline int post_send(struct ipoib_dev_priv *priv,
 
         for (i = 0; i < nr_frags; ++i) {
                 priv->tx_sge[i + off].addr = mapping[i + off];
-                priv->tx_sge[i + off].length = skb_frag_size(&frags[i]);
+                priv->tx_sge[i + off].length = frags[i].size;
         }
         priv->tx_wr.num_sge          = nr_frags + off;
         priv->tx_wr.wr_id            = wr_id;
@@ -615,9 +603,8 @@ void ipoib_send(struct net_device *dev, struct sk_buff *skb,
 
                 address->last_send = priv->tx_head;
                 ++priv->tx_head;
-
                 skb_orphan(skb);
-                skb_dst_drop(skb);
+
         }
 
         if (unlikely(priv->tx_outstanding > MAX_SEND_CQE))
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 6fdc9e78da0..a98c414978e 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -46,8 +46,7 @@
 #include <linux/ip.h>
 #include <linux/in.h>
 
-#include <linux/jhash.h>
-#include <net/arp.h>
+#include <net/dst.h>
 
 MODULE_AUTHOR("Roland Dreier");
 MODULE_DESCRIPTION("IP-over-InfiniBand net driver");
@@ -85,7 +84,6 @@ struct ib_sa_client ipoib_sa_client;
 
 static void ipoib_add_one(struct ib_device *device);
 static void ipoib_remove_one(struct ib_device *device);
-static void ipoib_neigh_reclaim(struct rcu_head *rp);
 
 static struct ib_client ipoib_client = {
         .name   = "ipoib",
@@ -150,7 +148,7 @@ static int ipoib_stop(struct net_device *dev)
 
         netif_stop_queue(dev);
 
-        ipoib_ib_dev_down(dev, 1);
+        ipoib_ib_dev_down(dev, 0);
         ipoib_ib_dev_stop(dev, 0);
 
         if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) {
@@ -173,12 +171,7 @@ static int ipoib_stop(struct net_device *dev)
         return 0;
 }
 
-static void ipoib_uninit(struct net_device *dev)
-{
-        ipoib_dev_cleanup(dev);
-}
-
-static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_features_t features)
+static u32 ipoib_fix_features(struct net_device *dev, u32 features)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
 
@@ -215,37 +208,6 @@ static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
         return 0;
 }
 
-int ipoib_set_mode(struct net_device *dev, const char *buf)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-
-        /* flush paths if we switch modes so that connections are restarted */
-        if (IPOIB_CM_SUPPORTED(dev->dev_addr) && !strcmp(buf, "connected\n")) {
-                set_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
-                ipoib_warn(priv, "enabling connected mode "
-                           "will cause multicast packet drops\n");
-                netdev_update_features(dev);
-                rtnl_unlock();
-                priv->tx_wr.send_flags &= ~IB_SEND_IP_CSUM;
-
-                ipoib_flush_paths(dev);
-                rtnl_lock();
-                return 0;
-        }
-
-        if (!strcmp(buf, "datagram\n")) {
-                clear_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
-                netdev_update_features(dev);
-                dev_set_mtu(dev, min(priv->mcast_mtu, dev->mtu));
-                rtnl_unlock();
-                ipoib_flush_paths(dev);
-                rtnl_lock();
-                return 0;
-        }
-
-        return -EINVAL;
-}
-
 static struct ipoib_path *__path_find(struct net_device *dev, void *gid)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
@@ -302,15 +264,30 @@ static int __path_add(struct net_device *dev, struct ipoib_path *path)
 
 static void path_free(struct net_device *dev, struct ipoib_path *path)
 {
+        struct ipoib_dev_priv *priv = netdev_priv(dev);
+        struct ipoib_neigh *neigh, *tn;
         struct sk_buff *skb;
+        unsigned long flags;
 
         while ((skb = __skb_dequeue(&path->queue)))
                 dev_kfree_skb_irq(skb);
 
-        ipoib_dbg(netdev_priv(dev), "path_free\n");
+        spin_lock_irqsave(&priv->lock, flags);
+
+        list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) {
+                /*
+                 * It's safe to call ipoib_put_ah() inside priv->lock
+                 * here, because we know that path->ah will always
+                 * hold one more reference, so ipoib_put_ah() will
+                 * never do more than decrement the ref count.
+                 */
+                if (neigh->ah)
+                        ipoib_put_ah(neigh->ah);
+
+                ipoib_neigh_free(dev, neigh);
+        }
 
-        /* remove all neigh connected to this path */
-        ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);
+        spin_unlock_irqrestore(&priv->lock, flags);
 
         if (path->ah)
                 ipoib_put_ah(path->ah);
@@ -455,7 +432,7 @@ static void path_rec_completion(int status,
 
         spin_lock_irqsave(&priv->lock, flags);
 
-        if (!IS_ERR_OR_NULL(ah)) {
+        if (ah) {
                 path->pathrec = *pathrec;
 
                 old_ah   = path->ah;
@@ -481,15 +458,19 @@ static void path_rec_completion(int status,
                         }
                         kref_get(&path->ah->ref);
                         neigh->ah = path->ah;
+                        memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw,
+                               sizeof(union ib_gid));
 
-                        if (ipoib_cm_enabled(dev, neigh->daddr)) {
+                        if (ipoib_cm_enabled(dev, neigh->neighbour)) {
                                 if (!ipoib_cm_get(neigh))
                                         ipoib_cm_set(neigh, ipoib_cm_create_tx(dev,
                                                                                path,
                                                                                neigh));
                                 if (!ipoib_cm_get(neigh)) {
                                         list_del(&neigh->list);
-                                        ipoib_neigh_free(neigh);
+                                        if (neigh->ah)
+                                                ipoib_put_ah(neigh->ah);
+                                        ipoib_neigh_free(dev, neigh);
                                         continue;
                                 }
                         }
@@ -574,26 +555,28 @@ static int path_rec_start(struct net_device *dev,
         return 0;
 }
 
-static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
-                           struct net_device *dev)
+/* called with rcu_read_lock */
+static void neigh_add_path(struct sk_buff *skb, struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_path *path;
         struct ipoib_neigh *neigh;
+        struct neighbour *n;
         unsigned long flags;
 
-        spin_lock_irqsave(&priv->lock, flags);
-        neigh = ipoib_neigh_alloc(daddr, dev);
+        n = dst_get_neighbour(skb_dst(skb));
+        neigh = ipoib_neigh_alloc(n, skb->dev);
         if (!neigh) {
-                spin_unlock_irqrestore(&priv->lock, flags);
                 ++dev->stats.tx_dropped;
                 dev_kfree_skb_any(skb);
                 return;
         }
 
-        path = __path_find(dev, daddr + 4);
+        spin_lock_irqsave(&priv->lock, flags);
+
+        path = __path_find(dev, n->ha + 4);
         if (!path) {
-                path = path_rec_create(dev, daddr + 4);
+                path = path_rec_create(dev, n->ha + 4);
                 if (!path)
                         goto err_path;
 
@@ -605,13 +588,17 @@ static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
         if (path->ah) {
                 kref_get(&path->ah->ref);
                 neigh->ah = path->ah;
+                memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw,
+                       sizeof(union ib_gid));
 
-                if (ipoib_cm_enabled(dev, neigh->daddr)) {
+                if (ipoib_cm_enabled(dev, neigh->neighbour)) {
                         if (!ipoib_cm_get(neigh))
                                 ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh));
                         if (!ipoib_cm_get(neigh)) {
                                 list_del(&neigh->list);
-                                ipoib_neigh_free(neigh);
+                                if (neigh->ah)
+                                        ipoib_put_ah(neigh->ah);
+                                ipoib_neigh_free(dev, neigh);
                                 goto err_drop;
                         }
                         if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE)
@@ -623,8 +610,7 @@ static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
                         }
                 } else {
                         spin_unlock_irqrestore(&priv->lock, flags);
-                        ipoib_send(dev, skb, path->ah, IPOIB_QPN(daddr));
-                        ipoib_neigh_put(neigh);
+                        ipoib_send(dev, skb, path->ah, IPOIB_QPN(n->ha));
                         return;
                 }
         } else {
@@ -637,24 +623,42 @@ static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
         }
 
         spin_unlock_irqrestore(&priv->lock, flags);
-        ipoib_neigh_put(neigh);
         return;
 
 err_list:
         list_del(&neigh->list);
 
 err_path:
-        ipoib_neigh_free(neigh);
+        ipoib_neigh_free(dev, neigh);
 err_drop:
         ++dev->stats.tx_dropped;
         dev_kfree_skb_any(skb);
 
         spin_unlock_irqrestore(&priv->lock, flags);
-        ipoib_neigh_put(neigh);
+}
+
+/* called with rcu_read_lock */
+static void ipoib_path_lookup(struct sk_buff *skb, struct net_device *dev)
+{
+        struct ipoib_dev_priv *priv = netdev_priv(skb->dev);
+        struct dst_entry *dst = skb_dst(skb);
+        struct neighbour *n;
+
+        /* Look up path record for unicasts */
+        n = dst_get_neighbour(dst);
+        if (n->ha[4] != 0xff) {
+                neigh_add_path(skb, dev);
+                return;
+        }
+
+        /* Add in the P_Key for multicasts */
+        n->ha[8] = (priv->pkey >> 8) & 0xff;
+        n->ha[9] = priv->pkey & 0xff;
+        ipoib_mcast_send(dev, n->ha + 4, skb);
 }
 
 static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
-                             struct ipoib_cb *cb)
+                             struct ipoib_pseudoheader *phdr)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_path *path;
@@ -662,15 +666,17 @@ static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
 
         spin_lock_irqsave(&priv->lock, flags);
 
-        path = __path_find(dev, cb->hwaddr + 4);
+        path = __path_find(dev, phdr->hwaddr + 4);
         if (!path || !path->valid) {
                 int new_path = 0;
 
                 if (!path) {
-                        path = path_rec_create(dev, cb->hwaddr + 4);
+                        path = path_rec_create(dev, phdr->hwaddr + 4);
                         new_path = 1;
                 }
                 if (path) {
+                        /* put pseudoheader back on for next time */
+                        skb_push(skb, sizeof *phdr);
                         __skb_queue_tail(&path->queue, skb);
 
                         if (!path->query && path_rec_start(dev, path)) {
@@ -694,10 +700,12 @@ static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
                           be16_to_cpu(path->pathrec.dlid));
 
                 spin_unlock_irqrestore(&priv->lock, flags);
-                ipoib_send(dev, skb, path->ah, IPOIB_QPN(cb->hwaddr));
+                ipoib_send(dev, skb, path->ah, IPOIB_QPN(phdr->hwaddr));
                 return;
         } else if ((path->query || !path_rec_start(dev, path)) &&
                    skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
+                /* put pseudoheader back on for next time */
+                skb_push(skb, sizeof *phdr);
                 __skb_queue_tail(&path->queue, skb);
         } else {
                 ++dev->stats.tx_dropped;
@@ -711,80 +719,91 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_neigh *neigh;
-        struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
-        struct ipoib_header *header;
+        struct neighbour *n = NULL;
         unsigned long flags;
 
-        header = (struct ipoib_header *) skb->data;
+        rcu_read_lock();
+        if (likely(skb_dst(skb)))
+                n = dst_get_neighbour(skb_dst(skb));
 
-        if (unlikely(cb->hwaddr[4] == 0xff)) {
-                /* multicast, arrange "if" according to probability */
-                if ((header->proto != htons(ETH_P_IP)) &&
-                    (header->proto != htons(ETH_P_IPV6)) &&
-                    (header->proto != htons(ETH_P_ARP)) &&
-                    (header->proto != htons(ETH_P_RARP))) {
-                        /* ethertype not supported by IPoIB */
-                        ++dev->stats.tx_dropped;
-                        dev_kfree_skb_any(skb);
-                        return NETDEV_TX_OK;
+        if (likely(n)) {
+                if (unlikely(!*to_ipoib_neigh(n))) {
+                        ipoib_path_lookup(skb, dev);
+                        goto unlock;
                 }
-                /* Add in the P_Key for multicast*/
-                cb->hwaddr[8] = (priv->pkey >> 8) & 0xff;
-                cb->hwaddr[9] = priv->pkey & 0xff;
-
-                neigh = ipoib_neigh_get(dev, cb->hwaddr);
-                if (likely(neigh))
-                        goto send_using_neigh;
-                ipoib_mcast_send(dev, cb->hwaddr, skb);
-                return NETDEV_TX_OK;
-        }
 
-        /* unicast, arrange "switch" according to probability */
-        switch (header->proto) {
-        case htons(ETH_P_IP):
-        case htons(ETH_P_IPV6):
-                neigh = ipoib_neigh_get(dev, cb->hwaddr);
-                if (unlikely(!neigh)) {
-                        neigh_add_path(skb, cb->hwaddr, dev);
-                        return NETDEV_TX_OK;
+                neigh = *to_ipoib_neigh(n);
+
+                if (unlikely((memcmp(&neigh->dgid.raw,
+                                     n->ha + 4,
+                                     sizeof(union ib_gid))) ||
+                             (neigh->dev != dev))) {
+                        spin_lock_irqsave(&priv->lock, flags);
+                        /*
+                         * It's safe to call ipoib_put_ah() inside
+                         * priv->lock here, because we know that
+                         * path->ah will always hold one more reference,
+                         * so ipoib_put_ah() will never do more than
+                         * decrement the ref count.
+                         */
+                        if (neigh->ah)
+                                ipoib_put_ah(neigh->ah);
+                        list_del(&neigh->list);
+                        ipoib_neigh_free(dev, neigh);
+                        spin_unlock_irqrestore(&priv->lock, flags);
+                        ipoib_path_lookup(skb, dev);
+                        goto unlock;
                 }
-                break;
-        case htons(ETH_P_ARP):
-        case htons(ETH_P_RARP):
-                /* for unicast ARP and RARP should always perform path find */
-                unicast_arp_send(skb, dev, cb);
-                return NETDEV_TX_OK;
-        default:
-                /* ethertype not supported by IPoIB */
-                ++dev->stats.tx_dropped;
-                dev_kfree_skb_any(skb);
-                return NETDEV_TX_OK;
-        }
 
-send_using_neigh:
-        /* note we now hold a ref to neigh */
-        if (ipoib_cm_get(neigh)) {
-                if (ipoib_cm_up(neigh)) {
-                        ipoib_cm_send(dev, skb, ipoib_cm_get(neigh));
-                        goto unref;
+                if (ipoib_cm_get(neigh)) {
+                        if (ipoib_cm_up(neigh)) {
+                                ipoib_cm_send(dev, skb, ipoib_cm_get(neigh));
+                                goto unlock;
+                        }
+                } else if (neigh->ah) {
+                        ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(n->ha));
+                        goto unlock;
                 }
-        } else if (neigh->ah) {
-                ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(cb->hwaddr));
-                goto unref;
-        }
 
-        if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
-                spin_lock_irqsave(&priv->lock, flags);
-                __skb_queue_tail(&neigh->queue, skb);
-                spin_unlock_irqrestore(&priv->lock, flags);
+                if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
+                        spin_lock_irqsave(&priv->lock, flags);
+                        __skb_queue_tail(&neigh->queue, skb);
+                        spin_unlock_irqrestore(&priv->lock, flags);
+                } else {
+                        ++dev->stats.tx_dropped;
+                        dev_kfree_skb_any(skb);
+                }
         } else {
-                ++dev->stats.tx_dropped;
-                dev_kfree_skb_any(skb);
-        }
+                struct ipoib_pseudoheader *phdr =
+                        (struct ipoib_pseudoheader *) skb->data;
+                skb_pull(skb, sizeof *phdr);
 
-unref:
-        ipoib_neigh_put(neigh);
+                if (phdr->hwaddr[4] == 0xff) {
+                        /* Add in the P_Key for multicast*/
+                        phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff;
+                        phdr->hwaddr[9] = priv->pkey & 0xff;
+
+                        ipoib_mcast_send(dev, phdr->hwaddr + 4, skb);
+                } else {
+                        /* unicast GID -- should be ARP or RARP reply */
+
+                        if ((be16_to_cpup((__be16 *) skb->data) != ETH_P_ARP) &&
+                            (be16_to_cpup((__be16 *) skb->data) != ETH_P_RARP)) {
+                                ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x %pI6\n",
+                                           skb_dst(skb) ? "neigh" : "dst",
+                                           be16_to_cpup((__be16 *) skb->data),
+                                           IPOIB_QPN(phdr->hwaddr),
+                                           phdr->hwaddr + 4);
+                                dev_kfree_skb_any(skb);
+                                ++dev->stats.tx_dropped;
+                                goto unlock;
+                        }
 
+                        unicast_arp_send(skb, dev, phdr);
+                }
+        }
+unlock:
+        rcu_read_unlock();
         return NETDEV_TX_OK;
 }
 
@@ -806,7 +825,8 @@ static int ipoib_hard_header(struct sk_buff *skb,
                              const void *daddr, const void *saddr, unsigned len)
 {
         struct ipoib_header *header;
-        struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
+        struct dst_entry *dst;
+        struct neighbour *n;
 
         header = (struct ipoib_header *) skb_push(skb, sizeof *header);
 
@@ -814,11 +834,19 @@ static int ipoib_hard_header(struct sk_buff *skb,
         header->reserved = 0;
 
         /*
-         * we don't rely on dst_entry structure,  always stuff the
-         * destination address into skb->cb so we can figure out where
-         * to send the packet later.
+         * If we don't have a neighbour structure, stuff the
+         * destination address onto the front of the skb so we can
+         * figure out where to send the packet later.
          */
-        memcpy(cb->hwaddr, daddr, INFINIBAND_ALEN);
+        dst = skb_dst(skb);
+        n = NULL;
+        if (dst)
+                n = dst_get_neighbour_raw(dst);
+        if ((!dst || !n) && daddr) {
+                struct ipoib_pseudoheader *phdr =
+                        (struct ipoib_pseudoheader *) skb_push(skb, sizeof *phdr);
+                memcpy(phdr->hwaddr, daddr, INFINIBAND_ALEN);
+        }
 
         return 0;
 }
@@ -835,433 +863,86 @@ static void ipoib_set_mcast_list(struct net_device *dev)
         queue_work(ipoib_workqueue, &priv->restart_task);
 }
 
-static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr)
-{
-        /*
-         * Use only the address parts that contributes to spreading
-         * The subnet prefix is not used as one can not connect to
-         * same remote port (GUID) using the same remote QPN via two
-         * different subnets.
-         */
-         /* qpn octets[1:4) & port GUID octets[12:20) */
-        u32 *daddr_32 = (u32 *) daddr;
-        u32 hv;
-
-        hv = jhash_3words(daddr_32[3], daddr_32[4], 0xFFFFFF & daddr_32[0], 0);
-        return hv & htbl->mask;
-}
-
-struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        struct ipoib_neigh *neigh = NULL;
-        u32 hash_val;
-
-        rcu_read_lock_bh();
-
-        htbl = rcu_dereference_bh(ntbl->htbl);
-
-        if (!htbl)
-                goto out_unlock;
-
-        hash_val = ipoib_addr_hash(htbl, daddr);
-        for (neigh = rcu_dereference_bh(htbl->buckets[hash_val]);
-             neigh != NULL;
-             neigh = rcu_dereference_bh(neigh->hnext)) {
-                if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
-                        /* found, take one ref on behalf of the caller */
-                        if (!atomic_inc_not_zero(&neigh->refcnt)) {
-                                /* deleted */
-                                neigh = NULL;
-                                goto out_unlock;
-                        }
-                        neigh->alive = jiffies;
-                        goto out_unlock;
-                }
-        }
-
-out_unlock:
-        rcu_read_unlock_bh();
-        return neigh;
-}
-
-static void __ipoib_reap_neigh(struct ipoib_dev_priv *priv)
+static void ipoib_neigh_cleanup(struct neighbour *n)
 {
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        unsigned long neigh_obsolete;
-        unsigned long dt;
+        struct ipoib_neigh *neigh;
+        struct ipoib_dev_priv *priv = netdev_priv(n->dev);
         unsigned long flags;
-        int i;
+        struct ipoib_ah *ah = NULL;
 
-        if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
+        neigh = *to_ipoib_neigh(n);
+        if (neigh)
+                priv = netdev_priv(neigh->dev);
+        else
                 return;
+        ipoib_dbg(priv,
+                  "neigh_cleanup for %06x %pI6\n",
+                  IPOIB_QPN(n->ha),
+                  n->ha + 4);
 
         spin_lock_irqsave(&priv->lock, flags);
 
-        htbl = rcu_dereference_protected(ntbl->htbl,
-                                         lockdep_is_held(&priv->lock));
-
-        if (!htbl)
-                goto out_unlock;
-
-        /* neigh is obsolete if it was idle for two GC periods */
-        dt = 2 * arp_tbl.gc_interval;
-        neigh_obsolete = jiffies - dt;
-        /* handle possible race condition */
-        if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
-                goto out_unlock;
-
-        for (i = 0; i < htbl->size; i++) {
-                struct ipoib_neigh *neigh;
-                struct ipoib_neigh __rcu **np = &htbl->buckets[i];
-
-                while ((neigh = rcu_dereference_protected(*np,
-                                                          lockdep_is_held(&priv->lock))) != NULL) {
-                        /* was the neigh idle for two GC periods */
-                        if (time_after(neigh_obsolete, neigh->alive)) {
-                                rcu_assign_pointer(*np,
-                                                   rcu_dereference_protected(neigh->hnext,
-                                                                             lockdep_is_held(&priv->lock)));
-                                /* remove from path/mc list */
-                                list_del(&neigh->list);
-                                call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
-                        } else {
-                                np = &neigh->hnext;
-                        }
-
-                }
-        }
+        if (neigh->ah)
+                ah = neigh->ah;
+        list_del(&neigh->list);
+        ipoib_neigh_free(n->dev, neigh);
 
-out_unlock:
         spin_unlock_irqrestore(&priv->lock, flags);
-}
-
-static void ipoib_reap_neigh(struct work_struct *work)
-{
-        struct ipoib_dev_priv *priv =
-                container_of(work, struct ipoib_dev_priv, neigh_reap_task.work);
 
-        __ipoib_reap_neigh(priv);
-
-        if (!test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
-                queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
-                                   arp_tbl.gc_interval);
+        if (ah)
+                ipoib_put_ah(ah);
 }
 
-
-static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr,
+struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neighbour,
                                       struct net_device *dev)
 {
         struct ipoib_neigh *neigh;
 
-        neigh = kzalloc(sizeof *neigh, GFP_ATOMIC);
+        neigh = kmalloc(sizeof *neigh, GFP_ATOMIC);
         if (!neigh)
                 return NULL;
 
+        neigh->neighbour = neighbour;
         neigh->dev = dev;
-        memcpy(&neigh->daddr, daddr, sizeof(neigh->daddr));
+        memset(&neigh->dgid.raw, 0, sizeof (union ib_gid));
+        *to_ipoib_neigh(neighbour) = neigh;
         skb_queue_head_init(&neigh->queue);
-        INIT_LIST_HEAD(&neigh->list);
         ipoib_cm_set(neigh, NULL);
-        /* one ref on behalf of the caller */
-        atomic_set(&neigh->refcnt, 1);
 
         return neigh;
 }
 
-struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr,
-                                      struct net_device *dev)
+void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh)
 {
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        struct ipoib_neigh *neigh;
-        u32 hash_val;
-
-        htbl = rcu_dereference_protected(ntbl->htbl,
-                                         lockdep_is_held(&priv->lock));
-        if (!htbl) {
-                neigh = NULL;
-                goto out_unlock;
-        }
-
-        /* need to add a new neigh, but maybe some other thread succeeded?
-         * recalc hash, maybe hash resize took place so we do a search
-         */
-        hash_val = ipoib_addr_hash(htbl, daddr);
-        for (neigh = rcu_dereference_protected(htbl->buckets[hash_val],
-                                               lockdep_is_held(&priv->lock));
-             neigh != NULL;
-             neigh = rcu_dereference_protected(neigh->hnext,
-                                               lockdep_is_held(&priv->lock))) {
-                if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
-                        /* found, take one ref on behalf of the caller */
-                        if (!atomic_inc_not_zero(&neigh->refcnt)) {
-                                /* deleted */
-                                neigh = NULL;
-                                break;
-                        }
-                        neigh->alive = jiffies;
-                        goto out_unlock;
-                }
-        }
-
-        neigh = ipoib_neigh_ctor(daddr, dev);
-        if (!neigh)
-                goto out_unlock;
-
-        /* one ref on behalf of the hash table */
-        atomic_inc(&neigh->refcnt);
-        neigh->alive = jiffies;
-        /* put in hash */
-        rcu_assign_pointer(neigh->hnext,
-                           rcu_dereference_protected(htbl->buckets[hash_val],
-                                                     lockdep_is_held(&priv->lock)));
-        rcu_assign_pointer(htbl->buckets[hash_val], neigh);
-        atomic_inc(&ntbl->entries);
-
-out_unlock:
-
-        return neigh;
-}
-
-void ipoib_neigh_dtor(struct ipoib_neigh *neigh)
-{
-        /* neigh reference count was dropprd to zero */
-        struct net_device *dev = neigh->dev;
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct sk_buff *skb;
-        if (neigh->ah)
-                ipoib_put_ah(neigh->ah);
+        *to_ipoib_neigh(neigh->neighbour) = NULL;
         while ((skb = __skb_dequeue(&neigh->queue))) {
                 ++dev->stats.tx_dropped;
                 dev_kfree_skb_any(skb);
         }
         if (ipoib_cm_get(neigh))
                 ipoib_cm_destroy_tx(ipoib_cm_get(neigh));
-        ipoib_dbg(netdev_priv(dev),
-                  "neigh free for %06x %pI6\n",
-                  IPOIB_QPN(neigh->daddr),
-                  neigh->daddr + 4);
         kfree(neigh);
-        if (atomic_dec_and_test(&priv->ntbl.entries)) {
-                if (test_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags))
-                        complete(&priv->ntbl.flushed);
-        }
-}
-
-static void ipoib_neigh_reclaim(struct rcu_head *rp)
-{
-        /* Called as a result of removal from hash table */
-        struct ipoib_neigh *neigh = container_of(rp, struct ipoib_neigh, rcu);
-        /* note TX context may hold another ref */
-        ipoib_neigh_put(neigh);
-}
-
-void ipoib_neigh_free(struct ipoib_neigh *neigh)
-{
-        struct net_device *dev = neigh->dev;
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        struct ipoib_neigh __rcu **np;
-        struct ipoib_neigh *n;
-        u32 hash_val;
-
-        htbl = rcu_dereference_protected(ntbl->htbl,
-                                        lockdep_is_held(&priv->lock));
-        if (!htbl)
-                return;
-
-        hash_val = ipoib_addr_hash(htbl, neigh->daddr);
-        np = &htbl->buckets[hash_val];
-        for (n = rcu_dereference_protected(*np,
-                                            lockdep_is_held(&priv->lock));
-             n != NULL;
-             n = rcu_dereference_protected(*np,
-                                        lockdep_is_held(&priv->lock))) {
-                if (n == neigh) {
-                        /* found */
-                        rcu_assign_pointer(*np,
-                                           rcu_dereference_protected(neigh->hnext,
-                                                                     lockdep_is_held(&priv->lock)));
-                        call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
-                        return;
-                } else {
-                        np = &n->hnext;
-                }
-        }
 }
 
-static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv)
+static int ipoib_neigh_setup_dev(struct net_device *dev, struct neigh_parms *parms)
 {
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        struct ipoib_neigh **buckets;
-        u32 size;
-
-        clear_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
-        ntbl->htbl = NULL;
-        htbl = kzalloc(sizeof(*htbl), GFP_KERNEL);
-        if (!htbl)
-                return -ENOMEM;
-        set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
-        size = roundup_pow_of_two(arp_tbl.gc_thresh3);
-        buckets = kzalloc(size * sizeof(*buckets), GFP_KERNEL);
-        if (!buckets) {
-                kfree(htbl);
-                return -ENOMEM;
-        }
-        htbl->size = size;
-        htbl->mask = (size - 1);
-        htbl->buckets = buckets;
-        ntbl->htbl = htbl;
-        htbl->ntbl = ntbl;
-        atomic_set(&ntbl->entries, 0);
-
-        /* start garbage collection */
-        clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
-        queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
-                           arp_tbl.gc_interval);
+        parms->neigh_cleanup = ipoib_neigh_cleanup;
 
         return 0;
 }
 
-static void neigh_hash_free_rcu(struct rcu_head *head)
-{
-        struct ipoib_neigh_hash *htbl = container_of(head,
-                                                    struct ipoib_neigh_hash,
-                                                    rcu);
-        struct ipoib_neigh __rcu **buckets = htbl->buckets;
-        struct ipoib_neigh_table *ntbl = htbl->ntbl;
-
-        kfree(buckets);
-        kfree(htbl);
-        complete(&ntbl->deleted);
-}
-
-void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        unsigned long flags;
-        int i;
-
-        /* remove all neigh connected to a given path or mcast */
-        spin_lock_irqsave(&priv->lock, flags);
-
-        htbl = rcu_dereference_protected(ntbl->htbl,
-                                         lockdep_is_held(&priv->lock));
-
-        if (!htbl)
-                goto out_unlock;
-
-        for (i = 0; i < htbl->size; i++) {
-                struct ipoib_neigh *neigh;
-                struct ipoib_neigh __rcu **np = &htbl->buckets[i];
-
-                while ((neigh = rcu_dereference_protected(*np,
-                                                          lockdep_is_held(&priv->lock))) != NULL) {
-                        /* delete neighs belong to this parent */
-                        if (!memcmp(gid, neigh->daddr + 4, sizeof (union ib_gid))) {
-                                rcu_assign_pointer(*np,
-                                                   rcu_dereference_protected(neigh->hnext,
-                                                                             lockdep_is_held(&priv->lock)));
-                                /* remove from parent list */
-                                list_del(&neigh->list);
-                                call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
-                        } else {
-                                np = &neigh->hnext;
-                        }
-
-                }
-        }
-out_unlock:
-        spin_unlock_irqrestore(&priv->lock, flags);
-}
-
-static void ipoib_flush_neighs(struct ipoib_dev_priv *priv)
-{
-        struct ipoib_neigh_table *ntbl = &priv->ntbl;
-        struct ipoib_neigh_hash *htbl;
-        unsigned long flags;
-        int i, wait_flushed = 0;
-
-        init_completion(&priv->ntbl.flushed);
-
-        spin_lock_irqsave(&priv->lock, flags);
-
-        htbl = rcu_dereference_protected(ntbl->htbl,
-                                        lockdep_is_held(&priv->lock));
-        if (!htbl)
-                goto out_unlock;
-
-        wait_flushed = atomic_read(&priv->ntbl.entries);
-        if (!wait_flushed)
-                goto free_htbl;
-
-        for (i = 0; i < htbl->size; i++) {
-                struct ipoib_neigh *neigh;
-                struct ipoib_neigh __rcu **np = &htbl->buckets[i];
-
-                while ((neigh = rcu_dereference_protected(*np,
-                                       lockdep_is_held(&priv->lock))) != NULL) {
-                        rcu_assign_pointer(*np,
-                                           rcu_dereference_protected(neigh->hnext,
-                                                                     lockdep_is_held(&priv->lock)));
-                        /* remove from path/mc list */
-                        list_del(&neigh->list);
-                        call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
-                }
-        }
-
-free_htbl:
-        rcu_assign_pointer(ntbl->htbl, NULL);
-        call_rcu(&htbl->rcu, neigh_hash_free_rcu);
-
-out_unlock:
-        spin_unlock_irqrestore(&priv->lock, flags);
-        if (wait_flushed)
-                wait_for_completion(&priv->ntbl.flushed);
-}
-
-static void ipoib_neigh_hash_uninit(struct net_device *dev)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        int stopped;
-
-        ipoib_dbg(priv, "ipoib_neigh_hash_uninit\n");
-        init_completion(&priv->ntbl.deleted);
-        set_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
-
-        /* Stop GC if called at init fail need to cancel work */
-        stopped = test_and_set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
-        if (!stopped)
-                cancel_delayed_work(&priv->neigh_reap_task);
-
-        ipoib_flush_neighs(priv);
-
-        wait_for_completion(&priv->ntbl.deleted);
-}
-
-
 int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
 
-        if (ipoib_neigh_hash_init(priv) < 0)
-                goto out;
         /* Allocate RX/TX "rings" to hold queued skbs */
         priv->rx_ring = kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring,
                                 GFP_KERNEL);
         if (!priv->rx_ring) {
                 printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n",
                        ca->name, ipoib_recvq_size);
-                goto out_neigh_hash_cleanup;
+                goto out;
         }
 
         priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring);
@@ -1284,8 +965,6 @@ out_tx_ring_cleanup:
 out_rx_ring_cleanup:
         kfree(priv->rx_ring);
 
-out_neigh_hash_cleanup:
-        ipoib_neigh_hash_uninit(dev);
 out:
         return -ENOMEM;
 }
@@ -1293,20 +972,15 @@ out:
 void ipoib_dev_cleanup(struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev), *cpriv, *tcpriv;
-        LIST_HEAD(head);
-
-        ASSERT_RTNL();
 
         ipoib_delete_debug_files(dev);
 
         /* Delete any child interfaces first */
         list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) {
-                /* Stop GC on child */
-                set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags);
-                cancel_delayed_work(&cpriv->neigh_reap_task);
-                unregister_netdevice_queue(cpriv->dev, &head);
+                unregister_netdev(cpriv->dev);
+                ipoib_dev_cleanup(cpriv->dev);
+                free_netdev(cpriv->dev);
         }
-        unregister_netdevice_many(&head);
 
         ipoib_ib_dev_cleanup(dev);
 
@@ -1315,8 +989,6 @@ void ipoib_dev_cleanup(struct net_device *dev)
 
         priv->rx_ring = NULL;
         priv->tx_ring = NULL;
-
-        ipoib_neigh_hash_uninit(dev);
 }
 
 static const struct header_ops ipoib_header_ops = {
@@ -1324,17 +996,17 @@ static const struct header_ops ipoib_header_ops = {
 };
 
 static const struct net_device_ops ipoib_netdev_ops = {
-        .ndo_uninit              = ipoib_uninit,
         .ndo_open                = ipoib_open,
         .ndo_stop                = ipoib_stop,
         .ndo_change_mtu          = ipoib_change_mtu,
         .ndo_fix_features        = ipoib_fix_features,
         .ndo_start_xmit          = ipoib_start_xmit,
         .ndo_tx_timeout          = ipoib_timeout,
-        .ndo_set_rx_mode         = ipoib_set_mcast_list,
+        .ndo_set_multicast_list  = ipoib_set_mcast_list,
+        .ndo_neigh_setup         = ipoib_neigh_setup_dev,
 };
 
-void ipoib_setup(struct net_device *dev)
+static void ipoib_setup(struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
 
@@ -1349,7 +1021,11 @@ void ipoib_setup(struct net_device *dev)
 
         dev->flags              |= IFF_BROADCAST | IFF_MULTICAST;
 
-        dev->hard_header_len     = IPOIB_ENCAP_LEN;
+        /*
+         * We add in INFINIBAND_ALEN to allow for the destination
+         * address "pseudoheader" for skbs without neighbour struct.
+         */
+        dev->hard_header_len     = IPOIB_ENCAP_LEN + INFINIBAND_ALEN;
         dev->addr_len            = INFINIBAND_ALEN;
         dev->type                = ARPHRD_INFINIBAND;
         dev->tx_queue_len        = ipoib_sendq_size * 2;
@@ -1380,7 +1056,6 @@ void ipoib_setup(struct net_device *dev)
         INIT_WORK(&priv->flush_heavy,   ipoib_ib_dev_flush_heavy);
         INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task);
         INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah);
-        INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh);
 }
 
 struct ipoib_dev_priv *ipoib_intf_alloc(const char *name)
@@ -1412,9 +1087,12 @@ static ssize_t show_umcast(struct device *dev,
         return sprintf(buf, "%d\n", test_bit(IPOIB_FLAG_UMCAST, &priv->flags));
 }
 
-void ipoib_set_umcast(struct net_device *ndev, int umcast_val)
+static ssize_t set_umcast(struct device *dev,
+                          struct device_attribute *attr,
+                          const char *buf, size_t count)
 {
-        struct ipoib_dev_priv *priv = netdev_priv(ndev);
+        struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));
+        unsigned long umcast_val = simple_strtoul(buf, NULL, 0);
 
         if (umcast_val > 0) {
                 set_bit(IPOIB_FLAG_UMCAST, &priv->flags);
@@ -1422,15 +1100,6 @@ void ipoib_set_umcast(struct net_device *ndev, int umcast_val)
                                 "by userspace\n");
         } else
                 clear_bit(IPOIB_FLAG_UMCAST, &priv->flags);
-}
-
-static ssize_t set_umcast(struct device *dev,
-                          struct device_attribute *attr,
-                          const char *buf, size_t count)
-{
-        unsigned long umcast_val = simple_strtoul(buf, NULL, 0);
-
-        ipoib_set_umcast(to_net_dev(dev), umcast_val);
 
         return count;
 }
@@ -1553,8 +1222,6 @@ static struct net_device *ipoib_add_port(const char *format,
         priv->dev->mtu  = IPOIB_UD_MTU(priv->max_ib_mtu);
         priv->mcast_mtu  = priv->admin_mtu = priv->dev->mtu;
 
-        priv->dev->neigh_priv_len = sizeof(struct ipoib_neigh);
-
         result = ib_query_pkey(hca, port, 0, &priv->pkey);
         if (result) {
                 printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n",
@@ -1627,9 +1294,6 @@ sysfs_failed:
 
 register_failed:
         ib_unregister_event_handler(&priv->event_handler);
-        /* Stop GC if started before flush */
-        set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
-        cancel_delayed_work(&priv->neigh_reap_task);
         flush_workqueue(ipoib_workqueue);
 
 event_failed:
@@ -1696,12 +1360,10 @@ static void ipoib_remove_one(struct ib_device *device)
                 dev_change_flags(priv->dev, priv->dev->flags & ~IFF_UP);
                 rtnl_unlock();
 
-                /* Stop GC */
-                set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
-                cancel_delayed_work(&priv->neigh_reap_task);
                 flush_workqueue(ipoib_workqueue);
 
                 unregister_netdev(priv->dev);
+                ipoib_dev_cleanup(priv->dev);
                 free_netdev(priv->dev);
         }
 
@@ -1753,15 +1415,8 @@ static int __init ipoib_init_module(void)
         if (ret)
                 goto err_sa;
 
-        ret = ipoib_netlink_init();
-        if (ret)
-                goto err_client;
-
         return 0;
 
-err_client:
-        ib_unregister_client(&ipoib_client);
-
 err_sa:
         ib_sa_unregister_client(&ipoib_sa_client);
         destroy_workqueue(ipoib_workqueue);
@@ -1774,7 +1429,6 @@ err_fs:
 
 static void __exit ipoib_cleanup_module(void)
 {
-        ipoib_netlink_fini();
         ib_unregister_client(&ipoib_client);
         ib_sa_unregister_client(&ipoib_sa_client);
         ipoib_unregister_debugfs();
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index cecb98a4c66..a8d2a891b84 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -34,7 +34,6 @@
 
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
-#include <linux/moduleparam.h>
 #include <linux/ip.h>
 #include <linux/in.h>
 #include <linux/igmp.h>
@@ -69,13 +68,28 @@ struct ipoib_mcast_iter {
 static void ipoib_mcast_free(struct ipoib_mcast *mcast)
 {
         struct net_device *dev = mcast->dev;
+        struct ipoib_dev_priv *priv = netdev_priv(dev);
+        struct ipoib_neigh *neigh, *tmp;
         int tx_dropped = 0;
 
         ipoib_dbg_mcast(netdev_priv(dev), "deleting multicast group %pI6\n",
                         mcast->mcmember.mgid.raw);
 
-        /* remove all neigh connected to this mcast */
-        ipoib_del_neighs_by_gid(dev, mcast->mcmember.mgid.raw);
+        spin_lock_irq(&priv->lock);
+
+        list_for_each_entry_safe(neigh, tmp, &mcast->neigh_list, list) {
+                /*
+                 * It's safe to call ipoib_put_ah() inside priv->lock
+                 * here, because we know that mcast->ah will always
+                 * hold one more reference, so ipoib_put_ah() will
+                 * never do more than decrement the ref count.
+                 */
+                if (neigh->ah)
+                        ipoib_put_ah(neigh->ah);
+                ipoib_neigh_free(dev, neigh);
+        }
+
+        spin_unlock_irq(&priv->lock);
 
         if (mcast->ah)
                 ipoib_put_ah(mcast->ah);
@@ -175,9 +189,7 @@ static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
 
         mcast->mcmember = *mcmember;
 
-        /* Set the multicast MTU and cached Q_Key before we attach if it's
-         * the broadcast group.
-         */
+        /* Set the cached Q_Key before we attach if it's the broadcast group */
         if (!memcmp(mcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
                     sizeof (union ib_gid))) {
                 spin_lock_irq(&priv->lock);
@@ -185,17 +197,10 @@ static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
                         spin_unlock_irq(&priv->lock);
                         return -EAGAIN;
                 }
-                priv->mcast_mtu = IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
                 priv->qkey = be32_to_cpu(priv->broadcast->mcmember.qkey);
                 spin_unlock_irq(&priv->lock);
                 priv->tx_wr.wr.ud.remote_qkey = priv->qkey;
                 set_qkey = 1;
-
-                if (!ipoib_cm_admin_enabled(dev)) {
-                        rtnl_lock();
-                        dev_set_mtu(dev, min(priv->mcast_mtu, priv->admin_mtu));
-                        rtnl_unlock();
-                }
         }
 
         if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
@@ -234,11 +239,8 @@ static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
                 av.grh.dgid = mcast->mcmember.mgid;
 
                 ah = ipoib_create_ah(dev, priv->pd, &av);
-                if (IS_ERR(ah)) {
-                        ipoib_warn(priv, "ib_address_create failed %ld\n",
-                                -PTR_ERR(ah));
-                        /* use original error */
-                        return PTR_ERR(ah);
+                if (!ah) {
+                        ipoib_warn(priv, "ib_address_create failed\n");
                 } else {
                         spin_lock_irq(&priv->lock);
                         mcast->ah = ah;
@@ -256,13 +258,21 @@ static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
         netif_tx_lock_bh(dev);
         while (!skb_queue_empty(&mcast->pkt_queue)) {
                 struct sk_buff *skb = skb_dequeue(&mcast->pkt_queue);
+                struct dst_entry *dst = skb_dst(skb);
+                struct neighbour *n = NULL;
 
                 netif_tx_unlock_bh(dev);
 
                 skb->dev = dev;
+                if (dst)
+                        n = dst_get_neighbour_raw(dst);
+                if (!dst || !n) {
+                        /* put pseudoheader back on for next time */
+                        skb_push(skb, sizeof (struct ipoib_pseudoheader));
+                }
+
                 if (dev_queue_xmit(skb))
                         ipoib_warn(priv, "dev_queue_xmit failed to requeue packet\n");
-
                 netif_tx_lock_bh(dev);
         }
         netif_tx_unlock_bh(dev);
@@ -583,6 +593,14 @@ void ipoib_mcast_join_task(struct work_struct *work)
                 return;
         }
 
+        priv->mcast_mtu = IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
+
+        if (!ipoib_cm_admin_enabled(dev)) {
+                rtnl_lock();
+                dev_set_mtu(dev, min(priv->mcast_mtu, priv->admin_mtu));
+                rtnl_unlock();
+        }
+
         ipoib_dbg_mcast(priv, "successfully joined all multicast groups\n");
 
         clear_bit(IPOIB_MCAST_RUN, &priv->flags);
@@ -641,12 +659,11 @@ static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast)
         return 0;
 }
 
-void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb)
+void ipoib_mcast_send(struct net_device *dev, void *mgid, struct sk_buff *skb)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_mcast *mcast;
         unsigned long flags;
-        void *mgid = daddr + 4;
 
         spin_lock_irqsave(&priv->lock, flags);
 
@@ -702,23 +719,25 @@ void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb)
 
 out:
         if (mcast && mcast->ah) {
-                struct ipoib_neigh *neigh;
+                struct dst_entry *dst = skb_dst(skb);
+                struct neighbour *n = NULL;
+
+                rcu_read_lock();
+                if (dst)
+                        n = dst_get_neighbour(dst);
+                if (n && !*to_ipoib_neigh(n)) {
+                        struct ipoib_neigh *neigh = ipoib_neigh_alloc(n,
+                                                                      skb->dev);
 
-                spin_unlock_irqrestore(&priv->lock, flags);
-                neigh = ipoib_neigh_get(dev, daddr);
-                spin_lock_irqsave(&priv->lock, flags);
-                if (!neigh) {
-                        neigh = ipoib_neigh_alloc(daddr, dev);
                         if (neigh) {
                                 kref_get(&mcast->ah->ref);
                                 neigh->ah       = mcast->ah;
                                 list_add_tail(&neigh->list, &mcast->neigh_list);
                         }
                 }
+                rcu_read_unlock();
                 spin_unlock_irqrestore(&priv->lock, flags);
                 ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN);
-                if (neigh)
-                        ipoib_neigh_put(neigh);
                 return;
         }
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_netlink.c b/drivers/infiniband/ulp/ipoib/ipoib_netlink.c
deleted file mode 100644
index 74685936c94..00000000000
--- a/drivers/infiniband/ulp/ipoib/ipoib_netlink.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright (c) 2012 Mellanox Technologies. -  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/netdevice.h>
-#include <linux/module.h>
-#include <net/rtnetlink.h>
-#include "ipoib.h"
-
-static const struct nla_policy ipoib_policy[IFLA_IPOIB_MAX + 1] = {
-        [IFLA_IPOIB_PKEY]       = { .type = NLA_U16 },
-        [IFLA_IPOIB_MODE]       = { .type = NLA_U16 },
-        [IFLA_IPOIB_UMCAST]     = { .type = NLA_U16 },
-};
-
-static int ipoib_fill_info(struct sk_buff *skb, const struct net_device *dev)
-{
-        struct ipoib_dev_priv *priv = netdev_priv(dev);
-        u16 val;
-
-        if (nla_put_u16(skb, IFLA_IPOIB_PKEY, priv->pkey))
-                goto nla_put_failure;
-
-        val = test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
-        if (nla_put_u16(skb, IFLA_IPOIB_MODE, val))
-                goto nla_put_failure;
-
-        val = test_bit(IPOIB_FLAG_UMCAST, &priv->flags);
-        if (nla_put_u16(skb, IFLA_IPOIB_UMCAST, val))
-                goto nla_put_failure;
-
-        return 0;
-
-nla_put_failure:
-        return -EMSGSIZE;
-}
-
-static int ipoib_changelink(struct net_device *dev,
-                            struct nlattr *tb[], struct nlattr *data[])
-{
-        u16 mode, umcast;
-        int ret = 0;
-
-        if (data[IFLA_IPOIB_MODE]) {
-                mode  = nla_get_u16(data[IFLA_IPOIB_MODE]);
-                if (mode == IPOIB_MODE_DATAGRAM)
-                        ret = ipoib_set_mode(dev, "datagram\n");
-                else if (mode == IPOIB_MODE_CONNECTED)
-                        ret = ipoib_set_mode(dev, "connected\n");
-                else
-                        ret = -EINVAL;
-
-                if (ret < 0)
-                        goto out_err;
-        }
-
-        if (data[IFLA_IPOIB_UMCAST]) {
-                umcast = nla_get_u16(data[IFLA_IPOIB_UMCAST]);
-                ipoib_set_umcast(dev, umcast);
-        }
-
-out_err:
-        return ret;
-}
-
-static int ipoib_new_child_link(struct net *src_net, struct net_device *dev,
-                               struct nlattr *tb[], struct nlattr *data[])
-{
-        struct net_device *pdev;
-        struct ipoib_dev_priv *ppriv;
-        u16 child_pkey;
-        int err;
-
-        if (!tb[IFLA_LINK])
-                return -EINVAL;
-
-        pdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
-        if (!pdev)
-                return -ENODEV;
-
-        ppriv = netdev_priv(pdev);
-
-        if (test_bit(IPOIB_FLAG_SUBINTERFACE, &ppriv->flags)) {
-                ipoib_warn(ppriv, "child creation disallowed for child devices\n");
-                return -EINVAL;
-        }
-
-        if (!data || !data[IFLA_IPOIB_PKEY]) {
-                ipoib_dbg(ppriv, "no pkey specified, using parent pkey\n");
-                child_pkey  = ppriv->pkey;
-        } else
-                child_pkey  = nla_get_u16(data[IFLA_IPOIB_PKEY]);
-
-        err = __ipoib_vlan_add(ppriv, netdev_priv(dev), child_pkey, IPOIB_RTNL_CHILD);
-
-        if (!err && data)
-                err = ipoib_changelink(dev, tb, data);
-        return err;
-}
-
-static void ipoib_unregister_child_dev(struct net_device *dev, struct list_head *head)
-{
-        struct ipoib_dev_priv *priv, *ppriv;
-
-        priv = netdev_priv(dev);
-        ppriv = netdev_priv(priv->parent);
-
-        mutex_lock(&ppriv->vlan_mutex);
-        unregister_netdevice_queue(dev, head);
-        list_del(&priv->list);
-        mutex_unlock(&ppriv->vlan_mutex);
-}
-
-static size_t ipoib_get_size(const struct net_device *dev)
-{
-        return nla_total_size(2) +      /* IFLA_IPOIB_PKEY   */
-                nla_total_size(2) +     /* IFLA_IPOIB_MODE   */
-                nla_total_size(2);      /* IFLA_IPOIB_UMCAST */
-}
-
-static struct rtnl_link_ops ipoib_link_ops __read_mostly = {
-        .kind           = "ipoib",
-        .maxtype        = IFLA_IPOIB_MAX,
-        .policy         = ipoib_policy,
-        .priv_size      = sizeof(struct ipoib_dev_priv),
-        .setup          = ipoib_setup,
-        .newlink        = ipoib_new_child_link,
-        .changelink     = ipoib_changelink,
-        .dellink        = ipoib_unregister_child_dev,
-        .get_size       = ipoib_get_size,
-        .fill_info      = ipoib_fill_info,
-};
-
-int __init ipoib_netlink_init(void)
-{
-        return rtnl_link_register(&ipoib_link_ops);
-}
-
-void __exit ipoib_netlink_fini(void)
-{
-        rtnl_link_unregister(&ipoib_link_ops);
-}
-
-MODULE_ALIAS_RTNL_LINK("ipoib");
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
index 8292554bccb..d7e9740c724 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
@@ -49,11 +49,47 @@ static ssize_t show_parent(struct device *d, struct device_attribute *attr,
 }
 static DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL);
 
-int __ipoib_vlan_add(struct ipoib_dev_priv *ppriv, struct ipoib_dev_priv *priv,
-                     u16 pkey, int type)
+int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 {
+        struct ipoib_dev_priv *ppriv, *priv;
+        char intf_name[IFNAMSIZ];
         int result;
 
+        if (!capable(CAP_NET_ADMIN))
+                return -EPERM;
+
+        ppriv = netdev_priv(pdev);
+
+        if (!rtnl_trylock())
+                return restart_syscall();
+        mutex_lock(&ppriv->vlan_mutex);
+
+        /*
+         * First ensure this isn't a duplicate. We check the parent device and
+         * then all of the child interfaces to make sure the Pkey doesn't match.
+         */
+        if (ppriv->pkey == pkey) {
+                result = -ENOTUNIQ;
+                priv = NULL;
+                goto err;
+        }
+
+        list_for_each_entry(priv, &ppriv->child_intfs, list) {
+                if (priv->pkey == pkey) {
+                        result = -ENOTUNIQ;
+                        priv = NULL;
+                        goto err;
+                }
+        }
+
+        snprintf(intf_name, sizeof intf_name, "%s.%04x",
+                 ppriv->dev->name, pkey);
+        priv = ipoib_intf_alloc(intf_name);
+        if (!priv) {
+                result = -ENOMEM;
+                goto err;
+        }
+
         priv->max_ib_mtu = ppriv->max_ib_mtu;
         /* MTU will be reset when mcast join happens */
         priv->dev->mtu   = IPOIB_UD_MTU(priv->max_ib_mtu);
@@ -88,27 +124,24 @@ int __ipoib_vlan_add(struct ipoib_dev_priv *ppriv, struct ipoib_dev_priv *priv,
 
         ipoib_create_debug_files(priv->dev);
 
-        /* RTNL childs don't need proprietary sysfs entries */
-        if (type == IPOIB_LEGACY_CHILD) {
-                if (ipoib_cm_add_mode_attr(priv->dev))
-                        goto sysfs_failed;
-                if (ipoib_add_pkey_attr(priv->dev))
-                        goto sysfs_failed;
-                if (ipoib_add_umcast_attr(priv->dev))
-                        goto sysfs_failed;
-
-                if (device_create_file(&priv->dev->dev, &dev_attr_parent))
-                        goto sysfs_failed;
-        }
+        if (ipoib_cm_add_mode_attr(priv->dev))
+                goto sysfs_failed;
+        if (ipoib_add_pkey_attr(priv->dev))
+                goto sysfs_failed;
+        if (ipoib_add_umcast_attr(priv->dev))
+                goto sysfs_failed;
+
+        if (device_create_file(&priv->dev->dev, &dev_attr_parent))
+                goto sysfs_failed;
 
-        priv->child_type  = type;
-        priv->dev->iflink = ppriv->dev->ifindex;
         list_add_tail(&priv->list, &ppriv->child_intfs);
 
+        mutex_unlock(&ppriv->vlan_mutex);
+        rtnl_unlock();
+
         return 0;
 
 sysfs_failed:
-        result = -ENOMEM;
         ipoib_delete_debug_files(priv->dev);
         unregister_netdevice(priv->dev);
 
@@ -116,59 +149,10 @@ register_failed:
         ipoib_dev_cleanup(priv->dev);
 
 err:
-        return result;
-}
-
-int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
-{
-        struct ipoib_dev_priv *ppriv, *priv;
-        char intf_name[IFNAMSIZ];
-        struct ipoib_dev_priv *tpriv;
-        int result;
-
-        if (!capable(CAP_NET_ADMIN))
-                return -EPERM;
-
-        ppriv = netdev_priv(pdev);
-
-        snprintf(intf_name, sizeof intf_name, "%s.%04x",
-                 ppriv->dev->name, pkey);
-        priv = ipoib_intf_alloc(intf_name);
-        if (!priv)
-                return -ENOMEM;
-
-        if (!rtnl_trylock())
-                return restart_syscall();
-
-        mutex_lock(&ppriv->vlan_mutex);
-
-        /*
-         * First ensure this isn't a duplicate. We check the parent device and
-         * then all of the legacy child interfaces to make sure the Pkey
-         * doesn't match.
-         */
-        if (ppriv->pkey == pkey) {
-                result = -ENOTUNIQ;
-                goto out;
-        }
-
-        list_for_each_entry(tpriv, &ppriv->child_intfs, list) {
-                if (tpriv->pkey == pkey &&
-                    tpriv->child_type == IPOIB_LEGACY_CHILD) {
-                        result = -ENOTUNIQ;
-                        goto out;
-                }
-        }
-
-        result = __ipoib_vlan_add(ppriv, priv, pkey, IPOIB_LEGACY_CHILD);
-
-out:
         mutex_unlock(&ppriv->vlan_mutex);
-
-        if (result)
-                free_netdev(priv->dev);
-
         rtnl_unlock();
+        if (priv)
+                free_netdev(priv->dev);
 
         return result;
 }
@@ -187,9 +171,9 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
                 return restart_syscall();
         mutex_lock(&ppriv->vlan_mutex);
         list_for_each_entry_safe(priv, tpriv, &ppriv->child_intfs, list) {
-                if (priv->pkey == pkey &&
-                    priv->child_type == IPOIB_LEGACY_CHILD) {
+                if (priv->pkey == pkey) {
                         unregister_netdevice(priv->dev);
+                        ipoib_dev_cleanup(priv->dev);
                         list_del(&priv->list);
                         dev = priv->dev;
                         break;
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index 0ab8c9cc3a7..9c61b9c2c59 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -57,7 +57,6 @@
 #include <linux/scatterlist.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include <net/sock.h>
 
@@ -152,6 +151,7 @@ int iser_initialize_task_headers(struct iscsi_task *task,
         tx_desc->tx_sg[0].length = ISER_HEADERS_LEN;
         tx_desc->tx_sg[0].lkey   = device->mr->lkey;
 
+        iser_task->headers_initialized  = 1;
         iser_task->iser_conn            = iser_conn;
         return 0;
 }
@@ -166,7 +166,8 @@ iscsi_iser_task_init(struct iscsi_task *task)
 {
         struct iscsi_iser_task *iser_task = task->dd_data;
 
-        if (iser_initialize_task_headers(task, &iser_task->desc))
+        if (!iser_task->headers_initialized)
+                if (iser_initialize_task_headers(task, &iser_task->desc))
                         return -ENOMEM;
 
         /* mgmt task */
@@ -277,13 +278,6 @@ iscsi_iser_task_xmit(struct iscsi_task *task)
 static void iscsi_iser_cleanup_task(struct iscsi_task *task)
 {
         struct iscsi_iser_task *iser_task = task->dd_data;
-        struct iser_tx_desc     *tx_desc = &iser_task->desc;
-
-        struct iscsi_iser_conn *iser_conn = task->conn->dd_data;
-        struct iser_device     *device    = iser_conn->ib_conn->device;
-
-        ib_dma_unmap_single(device->ib_device,
-                tx_desc->dma_addr, ISER_HEADERS_LEN, DMA_TO_DEVICE);
 
         /* mgmt tasks do not need special cleanup */
         if (!task->sc)
@@ -364,9 +358,6 @@ iscsi_iser_conn_bind(struct iscsi_cls_session *cls_session,
         }
         ib_conn = ep->dd_data;
 
-        if (iser_alloc_rx_descriptors(ib_conn))
-                return -ENOMEM;
-
         /* binds the iSER connection retrieved from the previously
          * connected ep_handle to the iSCSI layer connection. exchanges
          * connection pointers */
@@ -401,6 +392,19 @@ iscsi_iser_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         iser_conn->ib_conn = NULL;
 }
 
+static int
+iscsi_iser_conn_start(struct iscsi_cls_conn *cls_conn)
+{
+        struct iscsi_conn *conn = cls_conn->dd_data;
+        int err;
+
+        err = iser_conn_set_full_featured_mode(conn);
+        if (err)
+                return err;
+
+        return iscsi_conn_start(cls_conn);
+}
+
 static void iscsi_iser_session_destroy(struct iscsi_cls_session *cls_session)
 {
         struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
@@ -573,9 +577,10 @@ iscsi_iser_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
 
         err = iser_connect(ib_conn, NULL, (struct sockaddr_in *)dst_addr,
                            non_blocking);
-        if (err)
+        if (err) {
+                iscsi_destroy_endpoint(ep);
                 return ERR_PTR(err);
-
+        }
         return ep;
 }
 
@@ -627,59 +632,6 @@ iscsi_iser_ep_disconnect(struct iscsi_endpoint *ep)
         iser_conn_terminate(ib_conn);
 }
 
-static umode_t iser_attr_is_visible(int param_type, int param)
-{
-        switch (param_type) {
-        case ISCSI_HOST_PARAM:
-                switch (param) {
-                case ISCSI_HOST_PARAM_NETDEV_NAME:
-                case ISCSI_HOST_PARAM_HWADDRESS:
-                case ISCSI_HOST_PARAM_INITIATOR_NAME:
-                        return S_IRUGO;
-                default:
-                        return 0;
-                }
-        case ISCSI_PARAM:
-                switch (param) {
-                case ISCSI_PARAM_MAX_RECV_DLENGTH:
-                case ISCSI_PARAM_MAX_XMIT_DLENGTH:
-                case ISCSI_PARAM_HDRDGST_EN:
-                case ISCSI_PARAM_DATADGST_EN:
-                case ISCSI_PARAM_CONN_ADDRESS:
-                case ISCSI_PARAM_CONN_PORT:
-                case ISCSI_PARAM_EXP_STATSN:
-                case ISCSI_PARAM_PERSISTENT_ADDRESS:
-                case ISCSI_PARAM_PERSISTENT_PORT:
-                case ISCSI_PARAM_PING_TMO:
-                case ISCSI_PARAM_RECV_TMO:
-                case ISCSI_PARAM_INITIAL_R2T_EN:
-                case ISCSI_PARAM_MAX_R2T:
-                case ISCSI_PARAM_IMM_DATA_EN:
-                case ISCSI_PARAM_FIRST_BURST:
-                case ISCSI_PARAM_MAX_BURST:
-                case ISCSI_PARAM_PDU_INORDER_EN:
-                case ISCSI_PARAM_DATASEQ_INORDER_EN:
-                case ISCSI_PARAM_TARGET_NAME:
-                case ISCSI_PARAM_TPGT:
-                case ISCSI_PARAM_USERNAME:
-                case ISCSI_PARAM_PASSWORD:
-                case ISCSI_PARAM_USERNAME_IN:
-                case ISCSI_PARAM_PASSWORD_IN:
-                case ISCSI_PARAM_FAST_ABORT:
-                case ISCSI_PARAM_ABORT_TMO:
-                case ISCSI_PARAM_LU_RESET_TMO:
-                case ISCSI_PARAM_TGT_RESET_TMO:
-                case ISCSI_PARAM_IFACE_NAME:
-                case ISCSI_PARAM_INITIATOR_NAME:
-                        return S_IRUGO;
-                default:
-                        return 0;
-                }
-        }
-
-        return 0;
-}
-
 static struct scsi_host_template iscsi_iser_sht = {
         .module                 = THIS_MODULE,
         .name                   = "iSCSI Initiator over iSER, v." DRV_VER,
@@ -701,6 +653,32 @@ static struct iscsi_transport iscsi_iser_transport = {
         .owner                  = THIS_MODULE,
         .name                   = "iser",
         .caps                   = CAP_RECOVERY_L0 | CAP_MULTI_R2T,
+        .param_mask             = ISCSI_MAX_RECV_DLENGTH |
+                                  ISCSI_MAX_XMIT_DLENGTH |
+                                  ISCSI_HDRDGST_EN |
+                                  ISCSI_DATADGST_EN |
+                                  ISCSI_INITIAL_R2T_EN |
+                                  ISCSI_MAX_R2T |
+                                  ISCSI_IMM_DATA_EN |
+                                  ISCSI_FIRST_BURST |
+                                  ISCSI_MAX_BURST |
+                                  ISCSI_PDU_INORDER_EN |
+                                  ISCSI_DATASEQ_INORDER_EN |
+                                  ISCSI_CONN_PORT |
+                                  ISCSI_CONN_ADDRESS |
+                                  ISCSI_EXP_STATSN |
+                                  ISCSI_PERSISTENT_PORT |
+                                  ISCSI_PERSISTENT_ADDRESS |
+                                  ISCSI_TARGET_NAME | ISCSI_TPGT |
+                                  ISCSI_USERNAME | ISCSI_PASSWORD |
+                                  ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
+                                  ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
+                                  ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
+                                  ISCSI_PING_TMO | ISCSI_RECV_TMO |
+                                  ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
+        .host_param_mask        = ISCSI_HOST_HWADDRESS |
+                                  ISCSI_HOST_NETDEV_NAME |
+                                  ISCSI_HOST_INITIATOR_NAME,
         /* session management */
         .create_session         = iscsi_iser_session_create,
         .destroy_session        = iscsi_iser_session_destroy,
@@ -708,12 +686,11 @@ static struct iscsi_transport iscsi_iser_transport = {
         .create_conn            = iscsi_iser_conn_create,
         .bind_conn              = iscsi_iser_conn_bind,
         .destroy_conn           = iscsi_iser_conn_destroy,
-        .attr_is_visible        = iser_attr_is_visible,
         .set_param              = iscsi_iser_set_param,
         .get_conn_param         = iscsi_conn_get_param,
         .get_ep_param           = iscsi_iser_get_ep_param,
         .get_session_param      = iscsi_session_get_param,
-        .start_conn             = iscsi_conn_start,
+        .start_conn             = iscsi_iser_conn_start,
         .stop_conn              = iscsi_iser_conn_stop,
         /* iscsi host params */
         .get_host_param         = iscsi_host_get_param,
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index ef7d3be46c3..db6f3ce9f3b 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -177,7 +177,6 @@ struct iser_data_buf {
 
 /* fwd declarations */
 struct iser_device;
-struct iser_cq_desc;
 struct iscsi_iser_conn;
 struct iscsi_iser_task;
 struct iscsi_endpoint;
@@ -227,21 +226,16 @@ struct iser_rx_desc {
         char                         pad[ISER_RX_PAD_SIZE];
 } __attribute__((packed));
 
-#define ISER_MAX_CQ 4
-
 struct iser_device {
         struct ib_device             *ib_device;
         struct ib_pd                 *pd;
-        struct ib_cq                 *rx_cq[ISER_MAX_CQ];
-        struct ib_cq                 *tx_cq[ISER_MAX_CQ];
+        struct ib_cq                 *rx_cq;
+        struct ib_cq                 *tx_cq;
         struct ib_mr                 *mr;
-        struct tasklet_struct        cq_tasklet[ISER_MAX_CQ];
+        struct tasklet_struct        cq_tasklet;
         struct ib_event_handler      event_handler;
         struct list_head             ig_list; /* entry in ig devices list */
         int                          refcount;
-        int                          cq_active_qps[ISER_MAX_CQ];
-        int                          cqs_used;
-        struct iser_cq_desc          *cq_desc;
 };
 
 struct iser_conn {
@@ -263,8 +257,7 @@ struct iser_conn {
         struct list_head             conn_list;       /* entry in ig conn list */
 
         char                         *login_buf;
-        char                         *login_req_buf, *login_resp_buf;
-        u64                          login_req_dma, login_resp_dma;
+        u64                          login_dma;
         unsigned int                 rx_desc_head;
         struct iser_rx_desc          *rx_descs;
         struct ib_recv_wr            rx_wr[ISER_MIN_POSTED_RX];
@@ -284,6 +277,7 @@ struct iscsi_iser_task {
         struct iser_regd_buf         rdma_regd[ISER_DIRS_NUM];/* regd rdma buf */
         struct iser_data_buf         data[ISER_DIRS_NUM];     /* orig. data des*/
         struct iser_data_buf         data_copy[ISER_DIRS_NUM];/* contig. copy  */
+        int                          headers_initialized;
 };
 
 struct iser_page_vec {
@@ -293,11 +287,6 @@ struct iser_page_vec {
         int data_size;
 };
 
-struct iser_cq_desc {
-        struct iser_device           *device;
-        int                          cq_index;
-};
-
 struct iser_global {
         struct mutex      device_list_mutex;/*                   */
         struct list_head  device_list;       /* all iSER devices */
@@ -377,5 +366,4 @@ int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
 void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task);
 int  iser_initialize_task_headers(struct iscsi_task *task,
                         struct iser_tx_desc *tx_desc);
-int iser_alloc_rx_descriptors(struct iser_conn *ib_conn);
 #endif
diff --git a/drivers/infiniband/ulp/iser/iser_initiator.c b/drivers/infiniband/ulp/iser/iser_initiator.c
index a00ccd1ca33..f299de6b419 100644
--- a/drivers/infiniband/ulp/iser/iser_initiator.c
+++ b/drivers/infiniband/ulp/iser/iser_initiator.c
@@ -170,7 +170,7 @@ static void iser_create_send_desc(struct iser_conn	*ib_conn,
 }
 
 
-int iser_alloc_rx_descriptors(struct iser_conn *ib_conn)
+static int iser_alloc_rx_descriptors(struct iser_conn *ib_conn)
 {
         int i, j;
         u64 dma_addr;
@@ -220,6 +220,12 @@ void iser_free_rx_descriptors(struct iser_conn *ib_conn)
         struct iser_rx_desc *rx_desc;
         struct iser_device *device = ib_conn->device;
 
+        if (ib_conn->login_buf) {
+                ib_dma_unmap_single(device->ib_device, ib_conn->login_dma,
+                        ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
+                kfree(ib_conn->login_buf);
+        }
+
         if (!ib_conn->rx_descs)
                 return;
 
@@ -230,24 +236,23 @@ void iser_free_rx_descriptors(struct iser_conn *ib_conn)
         kfree(ib_conn->rx_descs);
 }
 
-static int iser_post_rx_bufs(struct iscsi_conn *conn, struct iscsi_hdr *req)
+/**
+ *  iser_conn_set_full_featured_mode - (iSER API)
+ */
+int iser_conn_set_full_featured_mode(struct iscsi_conn *conn)
 {
         struct iscsi_iser_conn *iser_conn = conn->dd_data;
 
-        iser_dbg("req op %x flags %x\n", req->opcode, req->flags);
-        /* check if this is the last login - going to full feature phase */
-        if ((req->flags & ISCSI_FULL_FEATURE_PHASE) != ISCSI_FULL_FEATURE_PHASE)
-                return 0;
+        iser_dbg("Initially post: %d\n", ISER_MIN_POSTED_RX);
 
-        /*
-         * Check that there is one posted recv buffer (for the last login
-         * response) and no posted send buffers left - they must have been
-         * consumed during previous login phases.
-         */
-        WARN_ON(iser_conn->ib_conn->post_recv_buf_count != 1);
-        WARN_ON(atomic_read(&iser_conn->ib_conn->post_send_buf_count) != 0);
+        /* Check that there is no posted recv or send buffers left - */
+        /* they must be consumed during the login phase */
+        BUG_ON(iser_conn->ib_conn->post_recv_buf_count != 0);
+        BUG_ON(atomic_read(&iser_conn->ib_conn->post_send_buf_count) != 0);
+
+        if (iser_alloc_rx_descriptors(iser_conn->ib_conn))
+                return -ENOMEM;
 
-        iser_dbg("Initially post: %d\n", ISER_MIN_POSTED_RX);
         /* Initial post receive buffers */
         if (iser_post_recvm(iser_conn->ib_conn, ISER_MIN_POSTED_RX))
                 return -ENOMEM;
@@ -389,7 +394,6 @@ int iser_send_control(struct iscsi_conn *conn,
         unsigned long data_seg_len;
         int err = 0;
         struct iser_device *device;
-        struct iser_conn *ib_conn = iser_conn->ib_conn;
 
         /* build the tx desc regd header and add it to the tx desc dto */
         mdesc->type = ISCSI_TX_CONTROL;
@@ -405,19 +409,9 @@ int iser_send_control(struct iscsi_conn *conn,
                         iser_err("data present on non login task!!!\n");
                         goto send_control_error;
                 }
-
-                ib_dma_sync_single_for_cpu(device->ib_device,
-                        ib_conn->login_req_dma, task->data_count,
-                        DMA_TO_DEVICE);
-
-                memcpy(iser_conn->ib_conn->login_req_buf, task->data,
+                memcpy(iser_conn->ib_conn->login_buf, task->data,
                                                         task->data_count);
-
-                ib_dma_sync_single_for_device(device->ib_device,
-                        ib_conn->login_req_dma, task->data_count,
-                        DMA_TO_DEVICE);
-
-                tx_dsg->addr    = iser_conn->ib_conn->login_req_dma;
+                tx_dsg->addr    = iser_conn->ib_conn->login_dma;
                 tx_dsg->length  = task->data_count;
                 tx_dsg->lkey    = device->mr->lkey;
                 mdesc->num_sge = 2;
@@ -427,9 +421,6 @@ int iser_send_control(struct iscsi_conn *conn,
                 err = iser_post_recvl(iser_conn->ib_conn);
                 if (err)
                         goto send_control_error;
-                err = iser_post_rx_bufs(conn, task->hdr);
-                if (err)
-                        goto send_control_error;
         }
 
         err = iser_post_send(iser_conn->ib_conn, mdesc);
@@ -454,8 +445,8 @@ void iser_rcv_completion(struct iser_rx_desc *rx_desc,
         int rx_buflen, outstanding, count, err;
 
         /* differentiate between login to all other PDUs */
-        if ((char *)rx_desc == ib_conn->login_resp_buf) {
-                rx_dma = ib_conn->login_resp_dma;
+        if ((char *)rx_desc == ib_conn->login_buf) {
+                rx_dma = ib_conn->login_dma;
                 rx_buflen = ISER_RX_LOGIN_SIZE;
         } else {
                 rx_dma = rx_desc->dma_addr;
@@ -482,7 +473,7 @@ void iser_rcv_completion(struct iser_rx_desc *rx_desc,
          * for the posted rx bufs refcount to become zero handles everything   */
         conn->ib_conn->post_recv_buf_count--;
 
-        if (rx_dma == ib_conn->login_resp_dma)
+        if (rx_dma == ib_conn->login_dma)
                 return;
 
         outstanding = ib_conn->post_recv_buf_count;
diff --git a/drivers/infiniband/ulp/iser/iser_memory.c b/drivers/infiniband/ulp/iser/iser_memory.c
index 2033a928d34..fb88d6896b6 100644
--- a/drivers/infiniband/ulp/iser/iser_memory.c
+++ b/drivers/infiniband/ulp/iser/iser_memory.c
@@ -73,11 +73,11 @@ static int iser_start_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 
                 p = mem;
                 for_each_sg(sgl, sg, data->size, i) {
-                        from = kmap_atomic(sg_page(sg));
+                        from = kmap_atomic(sg_page(sg), KM_USER0);
                         memcpy(p,
                                from + sg->offset,
                                sg->length);
-                        kunmap_atomic(from);
+                        kunmap_atomic(from, KM_USER0);
                         p += sg->length;
                 }
         }
@@ -133,11 +133,11 @@ void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 
                 p = mem;
                 for_each_sg(sgl, sg, sg_size, i) {
-                        to = kmap_atomic(sg_page(sg));
+                        to = kmap_atomic(sg_page(sg), KM_SOFTIRQ0);
                         memcpy(to + sg->offset,
                                p,
                                sg->length);
-                        kunmap_atomic(to);
+                        kunmap_atomic(to, KM_SOFTIRQ0);
                         p += sg->length;
                 }
         }
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index 95a49affee4..ede1475bee0 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -70,50 +70,32 @@ static void iser_event_handler(struct ib_event_handler *handler,
  */
 static int iser_create_device_ib_res(struct iser_device *device)
 {
-        int i, j;
-        struct iser_cq_desc *cq_desc;
-
-        device->cqs_used = min(ISER_MAX_CQ, device->ib_device->num_comp_vectors);
-        iser_err("using %d CQs, device %s supports %d vectors\n", device->cqs_used,
-                 device->ib_device->name, device->ib_device->num_comp_vectors);
-
-        device->cq_desc = kmalloc(sizeof(struct iser_cq_desc) * device->cqs_used,
-                                  GFP_KERNEL);
-        if (device->cq_desc == NULL)
-                goto cq_desc_err;
-        cq_desc = device->cq_desc;
-
         device->pd = ib_alloc_pd(device->ib_device);
         if (IS_ERR(device->pd))
                 goto pd_err;
 
-        for (i = 0; i < device->cqs_used; i++) {
-                cq_desc[i].device   = device;
-                cq_desc[i].cq_index = i;
+        device->rx_cq = ib_create_cq(device->ib_device,
+                                  iser_cq_callback,
+                                  iser_cq_event_callback,
+                                  (void *)device,
+                                  ISER_MAX_RX_CQ_LEN, 0);
+        if (IS_ERR(device->rx_cq))
+                goto rx_cq_err;
 
-                device->rx_cq[i] = ib_create_cq(device->ib_device,
-                                          iser_cq_callback,
-                                          iser_cq_event_callback,
-                                          (void *)&cq_desc[i],
-                                          ISER_MAX_RX_CQ_LEN, i);
-                if (IS_ERR(device->rx_cq[i]))
-                        goto cq_err;
+        device->tx_cq = ib_create_cq(device->ib_device,
+                                  NULL, iser_cq_event_callback,
+                                  (void *)device,
+                                  ISER_MAX_TX_CQ_LEN, 0);
 
-                device->tx_cq[i] = ib_create_cq(device->ib_device,
-                                          NULL, iser_cq_event_callback,
-                                          (void *)&cq_desc[i],
-                                          ISER_MAX_TX_CQ_LEN, i);
+        if (IS_ERR(device->tx_cq))
+                goto tx_cq_err;
 
-                if (IS_ERR(device->tx_cq[i]))
-                        goto cq_err;
+        if (ib_req_notify_cq(device->rx_cq, IB_CQ_NEXT_COMP))
+                goto cq_arm_err;
 
-                if (ib_req_notify_cq(device->rx_cq[i], IB_CQ_NEXT_COMP))
-                        goto cq_err;
-
-                tasklet_init(&device->cq_tasklet[i],
-                             iser_cq_tasklet_fn,
-                        (unsigned long)&cq_desc[i]);
-        }
+        tasklet_init(&device->cq_tasklet,
+                     iser_cq_tasklet_fn,
+                     (unsigned long)device);
 
         device->mr = ib_get_dma_mr(device->pd, IB_ACCESS_LOCAL_WRITE |
                                    IB_ACCESS_REMOTE_WRITE |
@@ -131,19 +113,14 @@ static int iser_create_device_ib_res(struct iser_device *device)
 handler_err:
         ib_dereg_mr(device->mr);
 dma_mr_err:
-        for (j = 0; j < device->cqs_used; j++)
-                tasklet_kill(&device->cq_tasklet[j]);
-cq_err:
-        for (j = 0; j < i; j++) {
-                if (device->tx_cq[j])
-                        ib_destroy_cq(device->tx_cq[j]);
-                if (device->rx_cq[j])
-                        ib_destroy_cq(device->rx_cq[j]);
-        }
+        tasklet_kill(&device->cq_tasklet);
+cq_arm_err:
+        ib_destroy_cq(device->tx_cq);
+tx_cq_err:
+        ib_destroy_cq(device->rx_cq);
+rx_cq_err:
         ib_dealloc_pd(device->pd);
 pd_err:
-        kfree(device->cq_desc);
-cq_desc_err:
         iser_err("failed to allocate an IB resource\n");
         return -1;
 }
@@ -154,24 +131,18 @@ cq_desc_err:
  */
 static void iser_free_device_ib_res(struct iser_device *device)
 {
-        int i;
         BUG_ON(device->mr == NULL);
 
-        for (i = 0; i < device->cqs_used; i++) {
-                tasklet_kill(&device->cq_tasklet[i]);
-                (void)ib_destroy_cq(device->tx_cq[i]);
-                (void)ib_destroy_cq(device->rx_cq[i]);
-                device->tx_cq[i] = NULL;
-                device->rx_cq[i] = NULL;
-        }
-
+        tasklet_kill(&device->cq_tasklet);
         (void)ib_unregister_event_handler(&device->event_handler);
         (void)ib_dereg_mr(device->mr);
+        (void)ib_destroy_cq(device->tx_cq);
+        (void)ib_destroy_cq(device->rx_cq);
         (void)ib_dealloc_pd(device->pd);
 
-        kfree(device->cq_desc);
-
         device->mr = NULL;
+        device->tx_cq = NULL;
+        device->rx_cq = NULL;
         device->pd = NULL;
 }
 
@@ -184,40 +155,20 @@ static int iser_create_ib_conn_res(struct iser_conn *ib_conn)
 {
         struct iser_device      *device;
         struct ib_qp_init_attr  init_attr;
-        int                     req_err, resp_err, ret = -ENOMEM;
+        int                     ret = -ENOMEM;
         struct ib_fmr_pool_param params;
-        int index, min_index = 0;
 
         BUG_ON(ib_conn->device == NULL);
 
         device = ib_conn->device;
 
-        ib_conn->login_buf = kmalloc(ISCSI_DEF_MAX_RECV_SEG_LEN +
-                                        ISER_RX_LOGIN_SIZE, GFP_KERNEL);
+        ib_conn->login_buf = kmalloc(ISER_RX_LOGIN_SIZE, GFP_KERNEL);
         if (!ib_conn->login_buf)
                 goto out_err;
 
-        ib_conn->login_req_buf  = ib_conn->login_buf;
-        ib_conn->login_resp_buf = ib_conn->login_buf + ISCSI_DEF_MAX_RECV_SEG_LEN;
-
-        ib_conn->login_req_dma = ib_dma_map_single(ib_conn->device->ib_device,
-                                (void *)ib_conn->login_req_buf,
-                                ISCSI_DEF_MAX_RECV_SEG_LEN, DMA_TO_DEVICE);
-
-        ib_conn->login_resp_dma = ib_dma_map_single(ib_conn->device->ib_device,
-                                (void *)ib_conn->login_resp_buf,
-                                ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
-
-        req_err  = ib_dma_mapping_error(device->ib_device, ib_conn->login_req_dma);
-        resp_err = ib_dma_mapping_error(device->ib_device, ib_conn->login_resp_dma);
-
-        if (req_err || resp_err) {
-                if (req_err)
-                        ib_conn->login_req_dma = 0;
-                if (resp_err)
-                        ib_conn->login_resp_dma = 0;
-                goto out_err;
-        }
+        ib_conn->login_dma = ib_dma_map_single(ib_conn->device->ib_device,
+                                (void *)ib_conn->login_buf, ISER_RX_LOGIN_SIZE,
+                                DMA_FROM_DEVICE);
 
         ib_conn->page_vec = kmalloc(sizeof(struct iser_page_vec) +
                                     (sizeof(u64) * (ISCSI_ISER_SG_TABLESIZE +1)),
@@ -250,20 +201,10 @@ static int iser_create_ib_conn_res(struct iser_conn *ib_conn)
 
         memset(&init_attr, 0, sizeof init_attr);
 
-        mutex_lock(&ig.connlist_mutex);
-        /* select the CQ with the minimal number of usages */
-        for (index = 0; index < device->cqs_used; index++)
-                if (device->cq_active_qps[index] <
-                    device->cq_active_qps[min_index])
-                        min_index = index;
-        device->cq_active_qps[min_index]++;
-        mutex_unlock(&ig.connlist_mutex);
-        iser_err("cq index %d used for ib_conn %p\n", min_index, ib_conn);
-
         init_attr.event_handler = iser_qp_event_callback;
         init_attr.qp_context    = (void *)ib_conn;
-        init_attr.send_cq       = device->tx_cq[min_index];
-        init_attr.recv_cq       = device->rx_cq[min_index];
+        init_attr.send_cq       = device->tx_cq;
+        init_attr.recv_cq       = device->rx_cq;
         init_attr.cap.max_send_wr  = ISER_QP_MAX_REQ_DTOS;
         init_attr.cap.max_recv_wr  = ISER_QP_MAX_RECV_DTOS;
         init_attr.cap.max_send_sge = 2;
@@ -292,7 +233,6 @@ out_err:
  */
 static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
 {
-        int cq_index;
         BUG_ON(ib_conn == NULL);
 
         iser_err("freeing conn %p cma_id %p fmr pool %p qp %p\n",
@@ -303,12 +243,9 @@ static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
         if (ib_conn->fmr_pool != NULL)
                 ib_destroy_fmr_pool(ib_conn->fmr_pool);
 
-        if (ib_conn->qp != NULL) {
-                cq_index = ((struct iser_cq_desc *)ib_conn->qp->recv_cq->cq_context)->cq_index;
-                ib_conn->device->cq_active_qps[cq_index]--;
-
+        if (ib_conn->qp != NULL)
                 rdma_destroy_qp(ib_conn->cma_id);
-        }
+
         /* if cma handler context, the caller acts s.t the cma destroy the id */
         if (ib_conn->cma_id != NULL && can_destroy_id)
                 rdma_destroy_id(ib_conn->cma_id);
@@ -318,18 +255,6 @@ static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
         ib_conn->cma_id   = NULL;
         kfree(ib_conn->page_vec);
 
-        if (ib_conn->login_buf) {
-                if (ib_conn->login_req_dma)
-                        ib_dma_unmap_single(ib_conn->device->ib_device,
-                                ib_conn->login_req_dma,
-                                ISCSI_DEF_MAX_RECV_SEG_LEN, DMA_TO_DEVICE);
-                if (ib_conn->login_resp_dma)
-                        ib_dma_unmap_single(ib_conn->device->ib_device,
-                                ib_conn->login_resp_dma,
-                                ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
-                kfree(ib_conn->login_buf);
-        }
-
         return 0;
 }
 
@@ -657,9 +582,8 @@ id_failure:
         ib_conn->cma_id = NULL;
 addr_failure:
         ib_conn->state = ISER_CONN_DOWN;
-        iser_conn_put(ib_conn, 1); /* deref ib conn's cma id */
 connect_failure:
-        iser_conn_put(ib_conn, 1); /* deref ib conn deallocate */
+        iser_conn_release(ib_conn, 1);
         return err;
 }
 
@@ -734,11 +658,11 @@ int iser_post_recvl(struct iser_conn *ib_conn)
         struct ib_sge     sge;
         int ib_ret;
 
-        sge.addr   = ib_conn->login_resp_dma;
+        sge.addr   = ib_conn->login_dma;
         sge.length = ISER_RX_LOGIN_SIZE;
         sge.lkey   = ib_conn->device->mr->lkey;
 
-        rx_wr.wr_id   = (unsigned long)ib_conn->login_resp_buf;
+        rx_wr.wr_id   = (unsigned long)ib_conn->login_buf;
         rx_wr.sg_list = &sge;
         rx_wr.num_sge = 1;
         rx_wr.next    = NULL;
@@ -835,9 +759,9 @@ static void iser_handle_comp_error(struct iser_tx_desc *desc,
         }
 }
 
-static int iser_drain_tx_cq(struct iser_device  *device, int cq_index)
+static int iser_drain_tx_cq(struct iser_device  *device)
 {
-        struct ib_cq  *cq = device->tx_cq[cq_index];
+        struct ib_cq  *cq = device->tx_cq;
         struct ib_wc  wc;
         struct iser_tx_desc *tx_desc;
         struct iser_conn *ib_conn;
@@ -866,10 +790,8 @@ static int iser_drain_tx_cq(struct iser_device  *device, int cq_index)
 
 static void iser_cq_tasklet_fn(unsigned long data)
 {
-        struct iser_cq_desc *cq_desc = (struct iser_cq_desc *)data;
-        struct iser_device  *device = cq_desc->device;
-        int cq_index = cq_desc->cq_index;
-        struct ib_cq         *cq = device->rx_cq[cq_index];
+         struct iser_device  *device = (struct iser_device *)data;
+         struct ib_cq        *cq = device->rx_cq;
          struct ib_wc        wc;
          struct iser_rx_desc *desc;
          unsigned long       xfer_len;
@@ -897,21 +819,19 @@ static void iser_cq_tasklet_fn(unsigned long data)
                 }
                 completed_rx++;
                 if (!(completed_rx & 63))
-                        completed_tx += iser_drain_tx_cq(device, cq_index);
+                        completed_tx += iser_drain_tx_cq(device);
         }
         /* #warning "it is assumed here that arming CQ only once its empty" *
          * " would not cause interrupts to be missed"                       */
         ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
 
-        completed_tx += iser_drain_tx_cq(device, cq_index);
+        completed_tx += iser_drain_tx_cq(device);
         iser_dbg("got %d rx %d tx completions\n", completed_rx, completed_tx);
 }
 
 static void iser_cq_callback(struct ib_cq *cq, void *cq_context)
 {
-        struct iser_cq_desc *cq_desc = (struct iser_cq_desc *)cq_context;
-        struct iser_device  *device = cq_desc->device;
-        int cq_index = cq_desc->cq_index;
+        struct iser_device  *device = (struct iser_device *)cq_context;
 
-        tasklet_schedule(&device->cq_tasklet[cq_index]);
+        tasklet_schedule(&device->cq_tasklet);
 }
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index d5088ce7829..0bfa545675b 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -30,8 +30,6 @@
  * SOFTWARE.
  */
 
-#define pr_fmt(fmt) PFX fmt
-
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -167,7 +165,7 @@ static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
 
 static void srp_qp_event(struct ib_event *event, void *context)
 {
-        pr_debug("QP event %d\n", event->event);
+        printk(KERN_ERR PFX "QP event %d\n", event->event);
 }
 
 static int srp_init_qp(struct srp_target_port *target,
@@ -222,29 +220,27 @@ static int srp_new_cm_id(struct srp_target_port *target)
 static int srp_create_target_ib(struct srp_target_port *target)
 {
         struct ib_qp_init_attr *init_attr;
-        struct ib_cq *recv_cq, *send_cq;
-        struct ib_qp *qp;
         int ret;
 
         init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
         if (!init_attr)
                 return -ENOMEM;
 
-        recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
-                               srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
-        if (IS_ERR(recv_cq)) {
-                ret = PTR_ERR(recv_cq);
+        target->recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                       srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
+        if (IS_ERR(target->recv_cq)) {
+                ret = PTR_ERR(target->recv_cq);
                 goto err;
         }
 
-        send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
-                               srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
-        if (IS_ERR(send_cq)) {
-                ret = PTR_ERR(send_cq);
+        target->send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
+                                       srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
+        if (IS_ERR(target->send_cq)) {
+                ret = PTR_ERR(target->send_cq);
                 goto err_recv_cq;
         }
 
-        ib_req_notify_cq(recv_cq, IB_CQ_NEXT_COMP);
+        ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP);
 
         init_attr->event_handler       = srp_qp_event;
         init_attr->cap.max_send_wr     = SRP_SQ_SIZE;
@@ -253,41 +249,30 @@ static int srp_create_target_ib(struct srp_target_port *target)
         init_attr->cap.max_send_sge    = 1;
         init_attr->sq_sig_type         = IB_SIGNAL_ALL_WR;
         init_attr->qp_type             = IB_QPT_RC;
-        init_attr->send_cq             = send_cq;
-        init_attr->recv_cq             = recv_cq;
+        init_attr->send_cq             = target->send_cq;
+        init_attr->recv_cq             = target->recv_cq;
 
-        qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
-        if (IS_ERR(qp)) {
-                ret = PTR_ERR(qp);
+        target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
+        if (IS_ERR(target->qp)) {
+                ret = PTR_ERR(target->qp);
                 goto err_send_cq;
         }
 
-        ret = srp_init_qp(target, qp);
+        ret = srp_init_qp(target, target->qp);
         if (ret)
                 goto err_qp;
 
-        if (target->qp)
-                ib_destroy_qp(target->qp);
-        if (target->recv_cq)
-                ib_destroy_cq(target->recv_cq);
-        if (target->send_cq)
-                ib_destroy_cq(target->send_cq);
-
-        target->qp = qp;
-        target->recv_cq = recv_cq;
-        target->send_cq = send_cq;
-
         kfree(init_attr);
         return 0;
 
 err_qp:
-        ib_destroy_qp(qp);
+        ib_destroy_qp(target->qp);
 
 err_send_cq:
-        ib_destroy_cq(send_cq);
+        ib_destroy_cq(target->send_cq);
 
 err_recv_cq:
-        ib_destroy_cq(recv_cq);
+        ib_destroy_cq(target->recv_cq);
 
 err:
         kfree(init_attr);
@@ -302,9 +287,6 @@ static void srp_free_target_ib(struct srp_target_port *target)
         ib_destroy_cq(target->send_cq);
         ib_destroy_cq(target->recv_cq);
 
-        target->qp = NULL;
-        target->send_cq = target->recv_cq = NULL;
-
         for (i = 0; i < SRP_RQ_SIZE; ++i)
                 srp_free_iu(target->srp_host, target->rx_ring[i]);
         for (i = 0; i < SRP_SQ_SIZE; ++i)
@@ -444,50 +426,34 @@ static int srp_send_req(struct srp_target_port *target)
         return status;
 }
 
-static bool srp_queue_remove_work(struct srp_target_port *target)
+static void srp_disconnect_target(struct srp_target_port *target)
 {
-        bool changed = false;
+        /* XXX should send SRP_I_LOGOUT request */
 
-        spin_lock_irq(&target->lock);
-        if (target->state != SRP_TARGET_REMOVED) {
-                target->state = SRP_TARGET_REMOVED;
-                changed = true;
+        init_completion(&target->done);
+        if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
+                shost_printk(KERN_DEBUG, target->scsi_host,
+                             PFX "Sending CM DREQ failed\n");
+                return;
         }
-        spin_unlock_irq(&target->lock);
-
-        if (changed)
-                queue_work(system_long_wq, &target->remove_work);
-
-        return changed;
+        wait_for_completion(&target->done);
 }
 
-static bool srp_change_conn_state(struct srp_target_port *target,
-                                  bool connected)
+static bool srp_change_state(struct srp_target_port *target,
+                            enum srp_target_state old,
+                            enum srp_target_state new)
 {
         bool changed = false;
 
         spin_lock_irq(&target->lock);
-        if (target->connected != connected) {
-                target->connected = connected;
+        if (target->state == old) {
+                target->state = new;
                 changed = true;
         }
         spin_unlock_irq(&target->lock);
-
         return changed;
 }
 
-static void srp_disconnect_target(struct srp_target_port *target)
-{
-        if (srp_change_conn_state(target, false)) {
-                /* XXX should send SRP_I_LOGOUT request */
-
-                if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
-                        shost_printk(KERN_DEBUG, target->scsi_host,
-                                     PFX "Sending CM DREQ failed\n");
-                }
-        }
-}
-
 static void srp_free_req_data(struct srp_target_port *target)
 {
         struct ib_device *ibdev = target->srp_host->srp_dev->dev;
@@ -506,65 +472,31 @@ static void srp_free_req_data(struct srp_target_port *target)
         }
 }
 
-/**
- * srp_del_scsi_host_attr() - Remove attributes defined in the host template.
- * @shost: SCSI host whose attributes to remove from sysfs.
- *
- * Note: Any attributes defined in the host template and that did not exist
- * before invocation of this function will be ignored.
- */
-static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
+static void srp_remove_work(struct work_struct *work)
 {
-        struct device_attribute **attr;
+        struct srp_target_port *target =
+                container_of(work, struct srp_target_port, work);
 
-        for (attr = shost->hostt->shost_attrs; attr && *attr; ++attr)
-                device_remove_file(&shost->shost_dev, *attr);
-}
+        if (!srp_change_state(target, SRP_TARGET_DEAD, SRP_TARGET_REMOVED))
+                return;
 
-static void srp_remove_target(struct srp_target_port *target)
-{
-        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
+        spin_lock(&target->srp_host->target_lock);
+        list_del(&target->list);
+        spin_unlock(&target->srp_host->target_lock);
 
-        srp_del_scsi_host_attr(target->scsi_host);
         srp_remove_host(target->scsi_host);
         scsi_remove_host(target->scsi_host);
-        srp_disconnect_target(target);
         ib_destroy_cm_id(target->cm_id);
         srp_free_target_ib(target);
         srp_free_req_data(target);
         scsi_host_put(target->scsi_host);
 }
 
-static void srp_remove_work(struct work_struct *work)
-{
-        struct srp_target_port *target =
-                container_of(work, struct srp_target_port, remove_work);
-
-        WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);
-
-        spin_lock(&target->srp_host->target_lock);
-        list_del(&target->list);
-        spin_unlock(&target->srp_host->target_lock);
-
-        srp_remove_target(target);
-}
-
-static void srp_rport_delete(struct srp_rport *rport)
-{
-        struct srp_target_port *target = rport->lld_data;
-
-        srp_queue_remove_work(target);
-}
-
 static int srp_connect_target(struct srp_target_port *target)
 {
         int retries = 3;
         int ret;
 
-        WARN_ON_ONCE(target->connected);
-
-        target->qp_in_error = false;
-
         ret = srp_lookup_path(target);
         if (ret)
                 return ret;
@@ -584,7 +516,6 @@ static int srp_connect_target(struct srp_target_port *target)
                  */
                 switch (target->status) {
                 case 0:
-                        srp_change_conn_state(target, true);
                         return 0;
 
                 case SRP_PORT_REDIRECT:
@@ -637,74 +568,35 @@ static void srp_unmap_data(struct scsi_cmnd *scmnd,
                         scmnd->sc_data_direction);
 }
 
-/**
- * srp_claim_req - Take ownership of the scmnd associated with a request.
- * @target: SRP target port.
- * @req: SRP request.
- * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
- *         ownership of @req->scmnd if it equals @scmnd.
- *
- * Return value:
- * Either NULL or a pointer to the SCSI command the caller became owner of.
- */
-static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target,
-                                       struct srp_request *req,
-                                       struct scsi_cmnd *scmnd)
+static void srp_remove_req(struct srp_target_port *target,
+                           struct srp_request *req, s32 req_lim_delta)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&target->lock, flags);
-        if (!scmnd) {
-                scmnd = req->scmnd;
-                req->scmnd = NULL;
-        } else if (req->scmnd == scmnd) {
-                req->scmnd = NULL;
-        } else {
-                scmnd = NULL;
-        }
-        spin_unlock_irqrestore(&target->lock, flags);
-
-        return scmnd;
-}
-
-/**
- * srp_free_req() - Unmap data and add request to the free request list.
- */
-static void srp_free_req(struct srp_target_port *target,
-                         struct srp_request *req, struct scsi_cmnd *scmnd,
-                         s32 req_lim_delta)
-{
-        unsigned long flags;
-
-        srp_unmap_data(scmnd, target, req);
-
+        srp_unmap_data(req->scmnd, target, req);
         spin_lock_irqsave(&target->lock, flags);
         target->req_lim += req_lim_delta;
+        req->scmnd = NULL;
         list_add_tail(&req->list, &target->free_reqs);
         spin_unlock_irqrestore(&target->lock, flags);
 }
 
 static void srp_reset_req(struct srp_target_port *target, struct srp_request *req)
 {
-        struct scsi_cmnd *scmnd = srp_claim_req(target, req, NULL);
-
-        if (scmnd) {
-                srp_free_req(target, req, scmnd, 0);
-                scmnd->result = DID_RESET << 16;
-                scmnd->scsi_done(scmnd);
-        }
+        req->scmnd->result = DID_RESET << 16;
+        req->scmnd->scsi_done(req->scmnd);
+        srp_remove_req(target, req, 0);
 }
 
 static int srp_reconnect_target(struct srp_target_port *target)
 {
-        struct Scsi_Host *shost = target->scsi_host;
+        struct ib_qp_attr qp_attr;
+        struct ib_wc wc;
         int i, ret;
 
-        if (target->state != SRP_TARGET_LIVE)
+        if (!srp_change_state(target, SRP_TARGET_LIVE, SRP_TARGET_CONNECTING))
                 return -EAGAIN;
 
-        scsi_target_block(&shost->shost_gendev);
-
         srp_disconnect_target(target);
         /*
          * Now get a new local CM ID so that we avoid confusing the
@@ -712,11 +604,21 @@ static int srp_reconnect_target(struct srp_target_port *target)
          */
         ret = srp_new_cm_id(target);
         if (ret)
-                goto unblock;
+                goto err;
 
-        ret = srp_create_target_ib(target);
+        qp_attr.qp_state = IB_QPS_RESET;
+        ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE);
+        if (ret)
+                goto err;
+
+        ret = srp_init_qp(target, target->qp);
         if (ret)
-                goto unblock;
+                goto err;
+
+        while (ib_poll_cq(target->recv_cq, 1, &wc) > 0)
+                ; /* nothing */
+        while (ib_poll_cq(target->send_cq, 1, &wc) > 0)
+                ; /* nothing */
 
         for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
                 struct srp_request *req = &target->req_ring[i];
@@ -728,16 +630,13 @@ static int srp_reconnect_target(struct srp_target_port *target)
         for (i = 0; i < SRP_SQ_SIZE; ++i)
                 list_add(&target->tx_ring[i]->list, &target->free_tx);
 
+        target->qp_in_error = 0;
         ret = srp_connect_target(target);
-
-unblock:
-        scsi_target_unblock(&shost->shost_gendev, ret == 0 ? SDEV_RUNNING :
-                            SDEV_TRANSPORT_OFFLINE);
-
         if (ret)
                 goto err;
 
-        shost_printk(KERN_INFO, target->scsi_host, PFX "reconnect succeeded\n");
+        if (!srp_change_state(target, SRP_TARGET_CONNECTING, SRP_TARGET_LIVE))
+                ret = -EAGAIN;
 
         return ret;
 
@@ -750,8 +649,17 @@ err:
          * However, we have to defer the real removal because we
          * are in the context of the SCSI error handler now, which
          * will deadlock if we call scsi_remove_host().
+         *
+         * Schedule our work inside the lock to avoid a race with
+         * the flush_scheduled_work() in srp_remove_one().
          */
-        srp_queue_remove_work(target);
+        spin_lock_irq(&target->lock);
+        if (target->state == SRP_TARGET_CONNECTING) {
+                target->state = SRP_TARGET_DEAD;
+                INIT_WORK(&target->work, srp_remove_work);
+                queue_work(ib_wq, &target->work);
+        }
+        spin_unlock_irq(&target->lock);
 
         return ret;
 }
@@ -1147,18 +1055,11 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
                 complete(&target->tsk_mgmt_done);
         } else {
                 req = &target->req_ring[rsp->tag];
-                scmnd = srp_claim_req(target, req, NULL);
-                if (!scmnd) {
+                scmnd = req->scmnd;
+                if (!scmnd)
                         shost_printk(KERN_ERR, target->scsi_host,
                                      "Null scmnd for RSP w/tag %016llx\n",
                                      (unsigned long long) rsp->tag);
-
-                        spin_lock_irqsave(&target->lock, flags);
-                        target->req_lim += be32_to_cpu(rsp->req_lim_delta);
-                        spin_unlock_irqrestore(&target->lock, flags);
-
-                        return;
-                }
                 scmnd->result = rsp->status;
 
                 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
@@ -1173,9 +1074,7 @@ static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
                 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER))
                         scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
 
-                srp_free_req(target, req, scmnd,
-                             be32_to_cpu(rsp->req_lim_delta));
-
+                srp_remove_req(target, req, be32_to_cpu(rsp->req_lim_delta));
                 scmnd->host_scribble = NULL;
                 scmnd->scsi_done(scmnd);
         }
@@ -1298,19 +1197,6 @@ static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
                              PFX "Recv failed with error code %d\n", res);
 }
 
-static void srp_handle_qp_err(enum ib_wc_status wc_status,
-                              enum ib_wc_opcode wc_opcode,
-                              struct srp_target_port *target)
-{
-        if (target->connected && !target->qp_in_error) {
-                shost_printk(KERN_ERR, target->scsi_host,
-                             PFX "failed %s status %d\n",
-                             wc_opcode & IB_WC_RECV ? "receive" : "send",
-                             wc_status);
-        }
-        target->qp_in_error = true;
-}
-
 static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
 {
         struct srp_target_port *target = target_ptr;
@@ -1318,11 +1204,15 @@ static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
 
         ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
         while (ib_poll_cq(cq, 1, &wc) > 0) {
-                if (likely(wc.status == IB_WC_SUCCESS)) {
-                        srp_handle_recv(target, &wc);
-                } else {
-                        srp_handle_qp_err(wc.status, wc.opcode, target);
+                if (wc.status) {
+                        shost_printk(KERN_ERR, target->scsi_host,
+                                     PFX "failed receive status %d\n",
+                                     wc.status);
+                        target->qp_in_error = 1;
+                        break;
                 }
+
+                srp_handle_recv(target, &wc);
         }
 }
 
@@ -1333,12 +1223,16 @@ static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
         struct srp_iu *iu;
 
         while (ib_poll_cq(cq, 1, &wc) > 0) {
-                if (likely(wc.status == IB_WC_SUCCESS)) {
-                        iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
-                        list_add(&iu->list, &target->free_tx);
-                } else {
-                        srp_handle_qp_err(wc.status, wc.opcode, target);
+                if (wc.status) {
+                        shost_printk(KERN_ERR, target->scsi_host,
+                                     PFX "failed send status %d\n",
+                                     wc.status);
+                        target->qp_in_error = 1;
+                        break;
                 }
+
+                iu = (struct srp_iu *) (uintptr_t) wc.wr_id;
+                list_add(&iu->list, &target->free_tx);
         }
 }
 
@@ -1352,6 +1246,16 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         unsigned long flags;
         int len;
 
+        if (target->state == SRP_TARGET_CONNECTING)
+                goto err;
+
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED) {
+                scmnd->result = DID_BAD_TARGET << 16;
+                scmnd->scsi_done(scmnd);
+                return 0;
+        }
+
         spin_lock_irqsave(&target->lock, flags);
         iu = __srp_get_tx_iu(target, SRP_IU_CMD);
         if (!iu)
@@ -1408,6 +1312,7 @@ err_iu:
 err_unlock:
         spin_unlock_irqrestore(&target->lock, flags);
 
+err:
         return SCSI_MLQUEUE_HOST_BUSY;
 }
 
@@ -1449,33 +1354,6 @@ err:
         return -ENOMEM;
 }
 
-static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask)
-{
-        uint64_t T_tr_ns, max_compl_time_ms;
-        uint32_t rq_tmo_jiffies;
-
-        /*
-         * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair,
-         * table 91), both the QP timeout and the retry count have to be set
-         * for RC QP's during the RTR to RTS transition.
-         */
-        WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) !=
-                     (IB_QP_TIMEOUT | IB_QP_RETRY_CNT));
-
-        /*
-         * Set target->rq_tmo_jiffies to one second more than the largest time
-         * it can take before an error completion is generated. See also
-         * C9-140..142 in the IBTA spec for more information about how to
-         * convert the QP Local ACK Timeout value to nanoseconds.
-         */
-        T_tr_ns = 4096 * (1ULL << qp_attr->timeout);
-        max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns;
-        do_div(max_compl_time_ms, NSEC_PER_MSEC);
-        rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000);
-
-        return rq_tmo_jiffies;
-}
-
 static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
                                struct srp_login_rsp *lrsp,
                                struct srp_target_port *target)
@@ -1535,8 +1413,6 @@ static void srp_cm_rep_handler(struct ib_cm_id *cm_id,
         if (ret)
                 goto error_free;
 
-        target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);
-
         ret = ib_modify_qp(target->qp, qp_attr, attr_mask);
         if (ret)
                 goto error_free;
@@ -1658,7 +1534,6 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
         case IB_CM_DREQ_RECEIVED:
                 shost_printk(KERN_WARNING, target->scsi_host,
                              PFX "DREQ received - connection closed\n");
-                srp_change_conn_state(target, false);
                 if (ib_send_cm_drep(cm_id, NULL, 0))
                         shost_printk(KERN_ERR, target->scsi_host,
                                      PFX "Sending CM DREP failed\n");
@@ -1668,6 +1543,7 @@ static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
                 shost_printk(KERN_ERR, target->scsi_host,
                              PFX "connection closed\n");
 
+                comp = 1;
                 target->status = 0;
                 break;
 
@@ -1695,6 +1571,10 @@ static int srp_send_tsk_mgmt(struct srp_target_port *target,
         struct srp_iu *iu;
         struct srp_tsk_mgmt *tsk_mgmt;
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -1;
+
         init_completion(&target->tsk_mgmt_done);
 
         spin_lock_irq(&target->lock);
@@ -1733,18 +1613,25 @@ static int srp_abort(struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(scmnd->device->host);
         struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
+        int ret = SUCCESS;
 
         shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
 
-        if (!req || target->qp_in_error || !srp_claim_req(target, req, scmnd))
+        if (!req || target->qp_in_error)
+                return FAILED;
+        if (srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
+                              SRP_TSK_ABORT_TASK))
                 return FAILED;
-        srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
-                          SRP_TSK_ABORT_TASK);
-        srp_free_req(target, req, scmnd, 0);
-        scmnd->result = DID_ABORT << 16;
-        scmnd->scsi_done(scmnd);
 
-        return SUCCESS;
+        if (req->scmnd) {
+                if (!target->tsk_mgmt_status) {
+                        srp_remove_req(target, req, 0);
+                        scmnd->result = DID_ABORT << 16;
+                } else
+                        ret = FAILED;
+        }
+
+        return ret;
 }
 
 static int srp_reset_device(struct scsi_cmnd *scmnd)
@@ -1784,26 +1671,15 @@ static int srp_reset_host(struct scsi_cmnd *scmnd)
         return ret;
 }
 
-static int srp_slave_configure(struct scsi_device *sdev)
-{
-        struct Scsi_Host *shost = sdev->host;
-        struct srp_target_port *target = host_to_target(shost);
-        struct request_queue *q = sdev->request_queue;
-        unsigned long timeout;
-
-        if (sdev->type == TYPE_DISK) {
-                timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies);
-                blk_queue_rq_timeout(q, timeout);
-        }
-
-        return 0;
-}
-
 static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
                            char *buf)
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->id_ext));
 }
@@ -1813,6 +1689,10 @@ static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->ioc_guid));
 }
@@ -1822,6 +1702,10 @@ static ssize_t show_service_id(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%016llx\n",
                        (unsigned long long) be64_to_cpu(target->service_id));
 }
@@ -1831,6 +1715,10 @@ static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
 }
 
@@ -1839,6 +1727,10 @@ static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%pI6\n", target->path.dgid.raw);
 }
 
@@ -1847,6 +1739,10 @@ static ssize_t show_orig_dgid(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%pI6\n", target->orig_dgid);
 }
 
@@ -1855,6 +1751,10 @@ static ssize_t show_req_lim(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%d\n", target->req_lim);
 }
 
@@ -1863,6 +1763,10 @@ static ssize_t show_zero_req_lim(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
+        if (target->state == SRP_TARGET_DEAD ||
+            target->state == SRP_TARGET_REMOVED)
+                return -ENODEV;
+
         return sprintf(buf, "%d\n", target->zero_req_lim);
 }
 
@@ -1931,7 +1835,6 @@ static struct scsi_host_template srp_template = {
         .module                         = THIS_MODULE,
         .name                           = "InfiniBand SRP initiator",
         .proc_name                      = DRV_NAME,
-        .slave_configure                = srp_slave_configure,
         .info                           = srp_target_info,
         .queuecommand                   = srp_queuecommand,
         .eh_abort_handler               = srp_abort,
@@ -1965,14 +1868,11 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
                 return PTR_ERR(rport);
         }
 
-        rport->lld_data = target;
-
         spin_lock(&host->target_lock);
         list_add_tail(&target->list, &host->target_list);
         spin_unlock(&host->target_lock);
 
         target->state = SRP_TARGET_LIVE;
-        target->connected = false;
 
         scsi_scan_target(&target->scsi_host->shost_gendev,
                          0, target->scsi_id, SCAN_WILD_CARD, 0);
@@ -2089,7 +1989,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                                 goto out;
                         }
                         if (strlen(p) != 32) {
-                                pr_warn("bad dest GID parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad dest GID parameter '%s'\n", p);
                                 kfree(p);
                                 goto out;
                         }
@@ -2104,7 +2004,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_PKEY:
                         if (match_hex(args, &token)) {
-                                pr_warn("bad P_Key parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad P_Key parameter '%s'\n", p);
                                 goto out;
                         }
                         target->path.pkey = cpu_to_be16(token);
@@ -2123,7 +2023,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_MAX_SECT:
                         if (match_int(args, &token)) {
-                                pr_warn("bad max sect parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad max sect parameter '%s'\n", p);
                                 goto out;
                         }
                         target->scsi_host->max_sectors = token;
@@ -2131,8 +2031,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_MAX_CMD_PER_LUN:
                         if (match_int(args, &token)) {
-                                pr_warn("bad max cmd_per_lun parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p);
                                 goto out;
                         }
                         target->scsi_host->cmd_per_lun = min(token, SRP_CMD_SQ_SIZE);
@@ -2140,14 +2039,14 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_IO_CLASS:
                         if (match_hex(args, &token)) {
-                                pr_warn("bad IO class parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad  IO class parameter '%s' \n", p);
                                 goto out;
                         }
                         if (token != SRP_REV10_IB_IO_CLASS &&
                             token != SRP_REV16A_IB_IO_CLASS) {
-                                pr_warn("unknown IO class parameter value %x specified (use %x or %x).\n",
-                                        token, SRP_REV10_IB_IO_CLASS,
-                                        SRP_REV16A_IB_IO_CLASS);
+                                printk(KERN_WARNING PFX "unknown IO class parameter value"
+                                       " %x specified (use %x or %x).\n",
+                                       token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS);
                                 goto out;
                         }
                         target->io_class = token;
@@ -2165,8 +2064,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_CMD_SG_ENTRIES:
                         if (match_int(args, &token) || token < 1 || token > 255) {
-                                pr_warn("bad max cmd_sg_entries parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max cmd_sg_entries parameter '%s'\n", p);
                                 goto out;
                         }
                         target->cmd_sg_cnt = token;
@@ -2174,7 +2072,7 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
 
                 case SRP_OPT_ALLOW_EXT_SG:
                         if (match_int(args, &token)) {
-                                pr_warn("bad allow_ext_sg parameter '%s'\n", p);
+                                printk(KERN_WARNING PFX "bad allow_ext_sg parameter '%s'\n", p);
                                 goto out;
                         }
                         target->allow_ext_sg = !!token;
@@ -2183,16 +2081,15 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                 case SRP_OPT_SG_TABLESIZE:
                         if (match_int(args, &token) || token < 1 ||
                                         token > SCSI_MAX_SG_CHAIN_SEGMENTS) {
-                                pr_warn("bad max sg_tablesize parameter '%s'\n",
-                                        p);
+                                printk(KERN_WARNING PFX "bad max sg_tablesize parameter '%s'\n", p);
                                 goto out;
                         }
                         target->sg_tablesize = token;
                         break;
 
                 default:
-                        pr_warn("unknown parameter or missing value '%s' in target creation request\n",
-                                p);
+                        printk(KERN_WARNING PFX "unknown parameter or missing value "
+                               "'%s' in target creation request\n", p);
                         goto out;
                 }
         }
@@ -2203,8 +2100,9 @@ static int srp_parse_options(const char *buf, struct srp_target_port *target)
                 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
                         if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
                             !(srp_opt_tokens[i].token & opt_mask))
-                                pr_warn("target creation request is missing parameter '%s'\n",
-                                        srp_opt_tokens[i].pattern);
+                                printk(KERN_WARNING PFX "target creation request is "
+                                       "missing parameter '%s'\n",
+                                       srp_opt_tokens[i].pattern);
 
 out:
         kfree(options);
@@ -2251,7 +2149,7 @@ static ssize_t srp_create_target(struct device *dev,
 
         if (!host->srp_dev->fmr_pool && !target->allow_ext_sg &&
                                 target->cmd_sg_cnt < target->sg_tablesize) {
-                pr_warn("No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
+                printk(KERN_WARNING PFX "No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
                 target->sg_tablesize = target->cmd_sg_cnt;
         }
 
@@ -2262,7 +2160,6 @@ static ssize_t srp_create_target(struct device *dev,
                              sizeof (struct srp_indirect_buf) +
                              target->cmd_sg_cnt * sizeof (struct srp_direct_buf);
 
-        INIT_WORK(&target->remove_work, srp_remove_work);
         spin_lock_init(&target->lock);
         INIT_LIST_HEAD(&target->free_tx);
         INIT_LIST_HEAD(&target->free_reqs);
@@ -2307,6 +2204,7 @@ static ssize_t srp_create_target(struct device *dev,
         if (ret)
                 goto err_free_ib;
 
+        target->qp_in_error = 0;
         ret = srp_connect_target(target);
         if (ret) {
                 shost_printk(KERN_ERR, target->scsi_host,
@@ -2411,7 +2309,8 @@ static void srp_add_one(struct ib_device *device)
                 return;
 
         if (ib_query_device(device, dev_attr)) {
-                pr_warn("Query device failed for %s\n", device->name);
+                printk(KERN_WARNING PFX "Query device failed for %s\n",
+                       device->name);
                 goto free_attr;
         }
 
@@ -2496,7 +2395,8 @@ static void srp_remove_one(struct ib_device *device)
 {
         struct srp_device *srp_dev;
         struct srp_host *host, *tmp_host;
-        struct srp_target_port *target;
+        LIST_HEAD(target_list);
+        struct srp_target_port *target, *tmp_target;
 
         srp_dev = ib_get_client_data(device, &srp_client);
 
@@ -2509,17 +2409,34 @@ static void srp_remove_one(struct ib_device *device)
                 wait_for_completion(&host->released);
 
                 /*
-                 * Remove all target ports.
+                 * Mark all target ports as removed, so we stop queueing
+                 * commands and don't try to reconnect.
                  */
                 spin_lock(&host->target_lock);
-                list_for_each_entry(target, &host->target_list, list)
-                        srp_queue_remove_work(target);
+                list_for_each_entry(target, &host->target_list, list) {
+                        spin_lock_irq(&target->lock);
+                        target->state = SRP_TARGET_REMOVED;
+                        spin_unlock_irq(&target->lock);
+                }
                 spin_unlock(&host->target_lock);
 
                 /*
-                 * Wait for target port removal tasks.
+                 * Wait for any reconnection tasks that may have
+                 * started before we marked our target ports as
+                 * removed, and any target port removal tasks.
                  */
-                flush_workqueue(system_long_wq);
+                flush_workqueue(ib_wq);
+
+                list_for_each_entry_safe(target, tmp_target,
+                                         &host->target_list, list) {
+                        srp_remove_host(target->scsi_host);
+                        scsi_remove_host(target->scsi_host);
+                        srp_disconnect_target(target);
+                        ib_destroy_cm_id(target->cm_id);
+                        srp_free_target_ib(target);
+                        srp_free_req_data(target);
+                        scsi_host_put(target->scsi_host);
+                }
 
                 kfree(host);
         }
@@ -2533,7 +2450,6 @@ static void srp_remove_one(struct ib_device *device)
 }
 
 static struct srp_function_template ib_srp_transport_functions = {
-        .rport_delete            = srp_rport_delete,
 };
 
 static int __init srp_init_module(void)
@@ -2543,7 +2459,7 @@ static int __init srp_init_module(void)
         BUILD_BUG_ON(FIELD_SIZEOF(struct ib_wc, wr_id) < sizeof(void *));
 
         if (srp_sg_tablesize) {
-                pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
+                printk(KERN_WARNING PFX "srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
                 if (!cmd_sg_entries)
                         cmd_sg_entries = srp_sg_tablesize;
         }
@@ -2552,15 +2468,14 @@ static int __init srp_init_module(void)
                 cmd_sg_entries = SRP_DEF_SG_TABLESIZE;
 
         if (cmd_sg_entries > 255) {
-                pr_warn("Clamping cmd_sg_entries to 255\n");
+                printk(KERN_WARNING PFX "Clamping cmd_sg_entries to 255\n");
                 cmd_sg_entries = 255;
         }
 
         if (!indirect_sg_entries)
                 indirect_sg_entries = cmd_sg_entries;
         else if (indirect_sg_entries < cmd_sg_entries) {
-                pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n",
-                        cmd_sg_entries);
+                printk(KERN_WARNING PFX "Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n", cmd_sg_entries);
                 indirect_sg_entries = cmd_sg_entries;
         }
 
@@ -2571,7 +2486,7 @@ static int __init srp_init_module(void)
 
         ret = class_register(&srp_class);
         if (ret) {
-                pr_err("couldn't register class infiniband_srp\n");
+                printk(KERN_ERR PFX "couldn't register class infiniband_srp\n");
                 srp_release_transport(ib_srp_transport_template);
                 return ret;
         }
@@ -2580,7 +2495,7 @@ static int __init srp_init_module(void)
 
         ret = ib_register_client(&srp_client);
         if (ret) {
-                pr_err("couldn't register IB client\n");
+                printk(KERN_ERR PFX "couldn't register IB client\n");
                 srp_release_transport(ib_srp_transport_template);
                 ib_sa_unregister_client(&srp_sa_client);
                 class_unregister(&srp_class);
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index de2d0b3c0bf..020caf0c378 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -80,7 +80,9 @@ enum {
 
 enum srp_target_state {
         SRP_TARGET_LIVE,
-        SRP_TARGET_REMOVED,
+        SRP_TARGET_CONNECTING,
+        SRP_TARGET_DEAD,
+        SRP_TARGET_REMOVED
 };
 
 enum srp_iu_type {
@@ -161,9 +163,6 @@ struct srp_target_port {
         struct ib_sa_query     *path_query;
         int                     path_query_id;
 
-        u32                     rq_tmo_jiffies;
-        bool                    connected;
-
         struct ib_cm_id        *cm_id;
 
         int                     max_ti_iu_len;
@@ -174,12 +173,12 @@ struct srp_target_port {
         struct srp_iu          *rx_ring[SRP_RQ_SIZE];
         struct srp_request      req_ring[SRP_CMD_SQ_SIZE];
 
-        struct work_struct      remove_work;
+        struct work_struct      work;
 
         struct list_head        list;
         struct completion       done;
         int                     status;
-        bool                    qp_in_error;
+        int                     qp_in_error;
 
         struct completion       tsk_mgmt_done;
         u8                      tsk_mgmt_status;
diff --git a/drivers/infiniband/ulp/srpt/Kconfig b/drivers/infiniband/ulp/srpt/Kconfig
deleted file mode 100644
index 31ee83d528d..00000000000
--- a/drivers/infiniband/ulp/srpt/Kconfig
+++ /dev/null
@@ -1,12 +0,0 @@
-config INFINIBAND_SRPT
-        tristate "InfiniBand SCSI RDMA Protocol target support"
-        depends on INFINIBAND && TARGET_CORE
-        ---help---
-
-          Support for the SCSI RDMA Protocol (SRP) Target driver. The
-          SRP protocol is a protocol that allows an initiator to access
-          a block storage device on another host (target) over a network
-          that supports the RDMA protocol. Currently the RDMA protocol is
-          supported by InfiniBand and by iWarp network hardware. More
-          information about the SRP protocol can be found on the website
-          of the INCITS T10 technical committee (http://www.t10.org/).
diff --git a/drivers/infiniband/ulp/srpt/Makefile b/drivers/infiniband/ulp/srpt/Makefile
deleted file mode 100644
index e3ee4bdfffa..00000000000
--- a/drivers/infiniband/ulp/srpt/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-ccflags-y                       := -Idrivers/target
-obj-$(CONFIG_INFINIBAND_SRPT)   += ib_srpt.o
diff --git a/drivers/infiniband/ulp/srpt/ib_dm_mad.h b/drivers/infiniband/ulp/srpt/ib_dm_mad.h
deleted file mode 100644
index fb1de1f6f29..00000000000
--- a/drivers/infiniband/ulp/srpt/ib_dm_mad.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright (c) 2006 - 2009 Mellanox Technology 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.
- *
- */
-
-#ifndef IB_DM_MAD_H
-#define IB_DM_MAD_H
-
-#include <linux/types.h>
-
-#include <rdma/ib_mad.h>
-
-enum {
-        /*
-         * See also section 13.4.7 Status Field, table 115 MAD Common Status
-         * Field Bit Values and also section 16.3.1.1 Status Field in the
-         * InfiniBand Architecture Specification.
-         */
-        DM_MAD_STATUS_UNSUP_METHOD = 0x0008,
-        DM_MAD_STATUS_UNSUP_METHOD_ATTR = 0x000c,
-        DM_MAD_STATUS_INVALID_FIELD = 0x001c,
-        DM_MAD_STATUS_NO_IOC = 0x0100,
-
-        /*
-         * See also the Device Management chapter, section 16.3.3 Attributes,
-         * table 279 Device Management Attributes in the InfiniBand
-         * Architecture Specification.
-         */
-        DM_ATTR_CLASS_PORT_INFO = 0x01,
-        DM_ATTR_IOU_INFO = 0x10,
-        DM_ATTR_IOC_PROFILE = 0x11,
-        DM_ATTR_SVC_ENTRIES = 0x12
-};
-
-struct ib_dm_hdr {
-        u8 reserved[28];
-};
-
-/*
- * Structure of management datagram sent by the SRP target implementation.
- * Contains a management datagram header, reliable multi-packet transaction
- * protocol (RMPP) header and ib_dm_hdr. Notes:
- * - The SRP target implementation does not use RMPP or ib_dm_hdr when sending
- *   management datagrams.
- * - The header size must be exactly 64 bytes (IB_MGMT_DEVICE_HDR), since this
- *   is the header size that is passed to ib_create_send_mad() in ib_srpt.c.
- * - The maximum supported size for a management datagram when not using RMPP
- *   is 256 bytes -- 64 bytes header and 192 (IB_MGMT_DEVICE_DATA) bytes data.
- */
-struct ib_dm_mad {
-        struct ib_mad_hdr mad_hdr;
-        struct ib_rmpp_hdr rmpp_hdr;
-        struct ib_dm_hdr dm_hdr;
-        u8 data[IB_MGMT_DEVICE_DATA];
-};
-
-/*
- * IOUnitInfo as defined in section 16.3.3.3 IOUnitInfo of the InfiniBand
- * Architecture Specification.
- */
-struct ib_dm_iou_info {
-        __be16 change_id;
-        u8 max_controllers;
-        u8 op_rom;
-        u8 controller_list[128];
-};
-
-/*
- * IOControllerprofile as defined in section 16.3.3.4 IOControllerProfile of
- * the InfiniBand Architecture Specification.
- */
-struct ib_dm_ioc_profile {
-        __be64 guid;
-        __be32 vendor_id;
-        __be32 device_id;
-        __be16 device_version;
-        __be16 reserved1;
-        __be32 subsys_vendor_id;
-        __be32 subsys_device_id;
-        __be16 io_class;
-        __be16 io_subclass;
-        __be16 protocol;
-        __be16 protocol_version;
-        __be16 service_conn;
-        __be16 initiators_supported;
-        __be16 send_queue_depth;
-        u8 reserved2;
-        u8 rdma_read_depth;
-        __be32 send_size;
-        __be32 rdma_size;
-        u8 op_cap_mask;
-        u8 svc_cap_mask;
-        u8 num_svc_entries;
-        u8 reserved3[9];
-        u8 id_string[64];
-};
-
-struct ib_dm_svc_entry {
-        u8 name[40];
-        __be64 id;
-};
-
-/*
- * See also section 16.3.3.5 ServiceEntries in the InfiniBand Architecture
- * Specification. See also section B.7, table B.8 in the T10 SRP r16a document.
- */
-struct ib_dm_svc_entries {
-        struct ib_dm_svc_entry service_entries[4];
-};
-
-#endif
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
deleted file mode 100644
index c09d41b1a2f..00000000000
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ /dev/null
@@ -1,4018 +0,0 @@
-/*
- * Copyright (c) 2006 - 2009 Mellanox Technology Inc.  All rights reserved.
- * Copyright (C) 2008 - 2011 Bart Van Assche <bvanassche@acm.org>.
- *
- * 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/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/err.h>
-#include <linux/ctype.h>
-#include <linux/kthread.h>
-#include <linux/string.h>
-#include <linux/delay.h>
-#include <linux/atomic.h>
-#include <scsi/scsi_tcq.h>
-#include <target/configfs_macros.h>
-#include <target/target_core_base.h>
-#include <target/target_core_fabric_configfs.h>
-#include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
-#include "ib_srpt.h"
-
-/* Name of this kernel module. */
-#define DRV_NAME                "ib_srpt"
-#define DRV_VERSION             "2.0.0"
-#define DRV_RELDATE             "2011-02-14"
-
-#define SRPT_ID_STRING  "Linux SRP target"
-
-#undef pr_fmt
-#define pr_fmt(fmt) DRV_NAME " " fmt
-
-MODULE_AUTHOR("Vu Pham and Bart Van Assche");
-MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol target "
-                   "v" DRV_VERSION " (" DRV_RELDATE ")");
-MODULE_LICENSE("Dual BSD/GPL");
-
-/*
- * Global Variables
- */
-
-static u64 srpt_service_guid;
-static DEFINE_SPINLOCK(srpt_dev_lock);  /* Protects srpt_dev_list. */
-static LIST_HEAD(srpt_dev_list);        /* List of srpt_device structures. */
-
-static unsigned srp_max_req_size = DEFAULT_MAX_REQ_SIZE;
-module_param(srp_max_req_size, int, 0444);
-MODULE_PARM_DESC(srp_max_req_size,
-                 "Maximum size of SRP request messages in bytes.");
-
-static int srpt_srq_size = DEFAULT_SRPT_SRQ_SIZE;
-module_param(srpt_srq_size, int, 0444);
-MODULE_PARM_DESC(srpt_srq_size,
-                 "Shared receive queue (SRQ) size.");
-
-static int srpt_get_u64_x(char *buffer, struct kernel_param *kp)
-{
-        return sprintf(buffer, "0x%016llx", *(u64 *)kp->arg);
-}
-module_param_call(srpt_service_guid, NULL, srpt_get_u64_x, &srpt_service_guid,
-                  0444);
-MODULE_PARM_DESC(srpt_service_guid,
-                 "Using this value for ioc_guid, id_ext, and cm_listen_id"
-                 " instead of using the node_guid of the first HCA.");
-
-static struct ib_client srpt_client;
-static struct target_fabric_configfs *srpt_target;
-static void srpt_release_channel(struct srpt_rdma_ch *ch);
-static int srpt_queue_status(struct se_cmd *cmd);
-
-/**
- * opposite_dma_dir() - Swap DMA_TO_DEVICE and DMA_FROM_DEVICE.
- */
-static inline
-enum dma_data_direction opposite_dma_dir(enum dma_data_direction dir)
-{
-        switch (dir) {
-        case DMA_TO_DEVICE:     return DMA_FROM_DEVICE;
-        case DMA_FROM_DEVICE:   return DMA_TO_DEVICE;
-        default:                return dir;
-        }
-}
-
-/**
- * srpt_sdev_name() - Return the name associated with the HCA.
- *
- * Examples are ib0, ib1, ...
- */
-static inline const char *srpt_sdev_name(struct srpt_device *sdev)
-{
-        return sdev->device->name;
-}
-
-static enum rdma_ch_state srpt_get_ch_state(struct srpt_rdma_ch *ch)
-{
-        unsigned long flags;
-        enum rdma_ch_state state;
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        state = ch->state;
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-        return state;
-}
-
-static enum rdma_ch_state
-srpt_set_ch_state(struct srpt_rdma_ch *ch, enum rdma_ch_state new_state)
-{
-        unsigned long flags;
-        enum rdma_ch_state prev;
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        prev = ch->state;
-        ch->state = new_state;
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-        return prev;
-}
-
-/**
- * srpt_test_and_set_ch_state() - Test and set the channel state.
- *
- * Returns true if and only if the channel state has been set to the new state.
- */
-static bool
-srpt_test_and_set_ch_state(struct srpt_rdma_ch *ch, enum rdma_ch_state old,
-                           enum rdma_ch_state new)
-{
-        unsigned long flags;
-        enum rdma_ch_state prev;
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        prev = ch->state;
-        if (prev == old)
-                ch->state = new;
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-        return prev == old;
-}
-
-/**
- * srpt_event_handler() - Asynchronous IB event callback function.
- *
- * Callback function called by the InfiniBand core when an asynchronous IB
- * event occurs. This callback may occur in interrupt context. See also
- * section 11.5.2, Set Asynchronous Event Handler in the InfiniBand
- * Architecture Specification.
- */
-static void srpt_event_handler(struct ib_event_handler *handler,
-                               struct ib_event *event)
-{
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
-
-        sdev = ib_get_client_data(event->device, &srpt_client);
-        if (!sdev || sdev->device != event->device)
-                return;
-
-        pr_debug("ASYNC event= %d on device= %s\n", event->event,
-                 srpt_sdev_name(sdev));
-
-        switch (event->event) {
-        case IB_EVENT_PORT_ERR:
-                if (event->element.port_num <= sdev->device->phys_port_cnt) {
-                        sport = &sdev->port[event->element.port_num - 1];
-                        sport->lid = 0;
-                        sport->sm_lid = 0;
-                }
-                break;
-        case IB_EVENT_PORT_ACTIVE:
-        case IB_EVENT_LID_CHANGE:
-        case IB_EVENT_PKEY_CHANGE:
-        case IB_EVENT_SM_CHANGE:
-        case IB_EVENT_CLIENT_REREGISTER:
-                /* Refresh port data asynchronously. */
-                if (event->element.port_num <= sdev->device->phys_port_cnt) {
-                        sport = &sdev->port[event->element.port_num - 1];
-                        if (!sport->lid && !sport->sm_lid)
-                                schedule_work(&sport->work);
-                }
-                break;
-        default:
-                printk(KERN_ERR "received unrecognized IB event %d\n",
-                       event->event);
-                break;
-        }
-}
-
-/**
- * srpt_srq_event() - SRQ event callback function.
- */
-static void srpt_srq_event(struct ib_event *event, void *ctx)
-{
-        printk(KERN_INFO "SRQ event %d\n", event->event);
-}
-
-/**
- * srpt_qp_event() - QP event callback function.
- */
-static void srpt_qp_event(struct ib_event *event, struct srpt_rdma_ch *ch)
-{
-        pr_debug("QP event %d on cm_id=%p sess_name=%s state=%d\n",
-                 event->event, ch->cm_id, ch->sess_name, srpt_get_ch_state(ch));
-
-        switch (event->event) {
-        case IB_EVENT_COMM_EST:
-                ib_cm_notify(ch->cm_id, event->event);
-                break;
-        case IB_EVENT_QP_LAST_WQE_REACHED:
-                if (srpt_test_and_set_ch_state(ch, CH_DRAINING,
-                                               CH_RELEASING))
-                        srpt_release_channel(ch);
-                else
-                        pr_debug("%s: state %d - ignored LAST_WQE.\n",
-                                 ch->sess_name, srpt_get_ch_state(ch));
-                break;
-        default:
-                printk(KERN_ERR "received unrecognized IB QP event %d\n",
-                       event->event);
-                break;
-        }
-}
-
-/**
- * srpt_set_ioc() - Helper function for initializing an IOUnitInfo structure.
- *
- * @slot: one-based slot number.
- * @value: four-bit value.
- *
- * Copies the lowest four bits of value in element slot of the array of four
- * bit elements called c_list (controller list). The index slot is one-based.
- */
-static void srpt_set_ioc(u8 *c_list, u32 slot, u8 value)
-{
-        u16 id;
-        u8 tmp;
-
-        id = (slot - 1) / 2;
-        if (slot & 0x1) {
-                tmp = c_list[id] & 0xf;
-                c_list[id] = (value << 4) | tmp;
-        } else {
-                tmp = c_list[id] & 0xf0;
-                c_list[id] = (value & 0xf) | tmp;
-        }
-}
-
-/**
- * srpt_get_class_port_info() - Copy ClassPortInfo to a management datagram.
- *
- * See also section 16.3.3.1 ClassPortInfo in the InfiniBand Architecture
- * Specification.
- */
-static void srpt_get_class_port_info(struct ib_dm_mad *mad)
-{
-        struct ib_class_port_info *cif;
-
-        cif = (struct ib_class_port_info *)mad->data;
-        memset(cif, 0, sizeof *cif);
-        cif->base_version = 1;
-        cif->class_version = 1;
-        cif->resp_time_value = 20;
-
-        mad->mad_hdr.status = 0;
-}
-
-/**
- * srpt_get_iou() - Write IOUnitInfo to a management datagram.
- *
- * See also section 16.3.3.3 IOUnitInfo in the InfiniBand Architecture
- * Specification. See also section B.7, table B.6 in the SRP r16a document.
- */
-static void srpt_get_iou(struct ib_dm_mad *mad)
-{
-        struct ib_dm_iou_info *ioui;
-        u8 slot;
-        int i;
-
-        ioui = (struct ib_dm_iou_info *)mad->data;
-        ioui->change_id = __constant_cpu_to_be16(1);
-        ioui->max_controllers = 16;
-
-        /* set present for slot 1 and empty for the rest */
-        srpt_set_ioc(ioui->controller_list, 1, 1);
-        for (i = 1, slot = 2; i < 16; i++, slot++)
-                srpt_set_ioc(ioui->controller_list, slot, 0);
-
-        mad->mad_hdr.status = 0;
-}
-
-/**
- * srpt_get_ioc() - Write IOControllerprofile to a management datagram.
- *
- * See also section 16.3.3.4 IOControllerProfile in the InfiniBand
- * Architecture Specification. See also section B.7, table B.7 in the SRP
- * r16a document.
- */
-static void srpt_get_ioc(struct srpt_port *sport, u32 slot,
-                         struct ib_dm_mad *mad)
-{
-        struct srpt_device *sdev = sport->sdev;
-        struct ib_dm_ioc_profile *iocp;
-
-        iocp = (struct ib_dm_ioc_profile *)mad->data;
-
-        if (!slot || slot > 16) {
-                mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
-                return;
-        }
-
-        if (slot > 2) {
-                mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_NO_IOC);
-                return;
-        }
-
-        memset(iocp, 0, sizeof *iocp);
-        strcpy(iocp->id_string, SRPT_ID_STRING);
-        iocp->guid = cpu_to_be64(srpt_service_guid);
-        iocp->vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id);
-        iocp->device_id = cpu_to_be32(sdev->dev_attr.vendor_part_id);
-        iocp->device_version = cpu_to_be16(sdev->dev_attr.hw_ver);
-        iocp->subsys_vendor_id = cpu_to_be32(sdev->dev_attr.vendor_id);
-        iocp->subsys_device_id = 0x0;
-        iocp->io_class = __constant_cpu_to_be16(SRP_REV16A_IB_IO_CLASS);
-        iocp->io_subclass = __constant_cpu_to_be16(SRP_IO_SUBCLASS);
-        iocp->protocol = __constant_cpu_to_be16(SRP_PROTOCOL);
-        iocp->protocol_version = __constant_cpu_to_be16(SRP_PROTOCOL_VERSION);
-        iocp->send_queue_depth = cpu_to_be16(sdev->srq_size);
-        iocp->rdma_read_depth = 4;
-        iocp->send_size = cpu_to_be32(srp_max_req_size);
-        iocp->rdma_size = cpu_to_be32(min(sport->port_attrib.srp_max_rdma_size,
-                                          1U << 24));
-        iocp->num_svc_entries = 1;
-        iocp->op_cap_mask = SRP_SEND_TO_IOC | SRP_SEND_FROM_IOC |
-                SRP_RDMA_READ_FROM_IOC | SRP_RDMA_WRITE_FROM_IOC;
-
-        mad->mad_hdr.status = 0;
-}
-
-/**
- * srpt_get_svc_entries() - Write ServiceEntries to a management datagram.
- *
- * See also section 16.3.3.5 ServiceEntries in the InfiniBand Architecture
- * Specification. See also section B.7, table B.8 in the SRP r16a document.
- */
-static void srpt_get_svc_entries(u64 ioc_guid,
-                                 u16 slot, u8 hi, u8 lo, struct ib_dm_mad *mad)
-{
-        struct ib_dm_svc_entries *svc_entries;
-
-        WARN_ON(!ioc_guid);
-
-        if (!slot || slot > 16) {
-                mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
-                return;
-        }
-
-        if (slot > 2 || lo > hi || hi > 1) {
-                mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_NO_IOC);
-                return;
-        }
-
-        svc_entries = (struct ib_dm_svc_entries *)mad->data;
-        memset(svc_entries, 0, sizeof *svc_entries);
-        svc_entries->service_entries[0].id = cpu_to_be64(ioc_guid);
-        snprintf(svc_entries->service_entries[0].name,
-                 sizeof(svc_entries->service_entries[0].name),
-                 "%s%016llx",
-                 SRP_SERVICE_NAME_PREFIX,
-                 ioc_guid);
-
-        mad->mad_hdr.status = 0;
-}
-
-/**
- * srpt_mgmt_method_get() - Process a received management datagram.
- * @sp:      source port through which the MAD has been received.
- * @rq_mad:  received MAD.
- * @rsp_mad: response MAD.
- */
-static void srpt_mgmt_method_get(struct srpt_port *sp, struct ib_mad *rq_mad,
-                                 struct ib_dm_mad *rsp_mad)
-{
-        u16 attr_id;
-        u32 slot;
-        u8 hi, lo;
-
-        attr_id = be16_to_cpu(rq_mad->mad_hdr.attr_id);
-        switch (attr_id) {
-        case DM_ATTR_CLASS_PORT_INFO:
-                srpt_get_class_port_info(rsp_mad);
-                break;
-        case DM_ATTR_IOU_INFO:
-                srpt_get_iou(rsp_mad);
-                break;
-        case DM_ATTR_IOC_PROFILE:
-                slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod);
-                srpt_get_ioc(sp, slot, rsp_mad);
-                break;
-        case DM_ATTR_SVC_ENTRIES:
-                slot = be32_to_cpu(rq_mad->mad_hdr.attr_mod);
-                hi = (u8) ((slot >> 8) & 0xff);
-                lo = (u8) (slot & 0xff);
-                slot = (u16) ((slot >> 16) & 0xffff);
-                srpt_get_svc_entries(srpt_service_guid,
-                                     slot, hi, lo, rsp_mad);
-                break;
-        default:
-                rsp_mad->mad_hdr.status =
-                    __constant_cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
-                break;
-        }
-}
-
-/**
- * srpt_mad_send_handler() - Post MAD-send callback function.
- */
-static void srpt_mad_send_handler(struct ib_mad_agent *mad_agent,
-                                  struct ib_mad_send_wc *mad_wc)
-{
-        ib_destroy_ah(mad_wc->send_buf->ah);
-        ib_free_send_mad(mad_wc->send_buf);
-}
-
-/**
- * srpt_mad_recv_handler() - MAD reception callback function.
- */
-static void srpt_mad_recv_handler(struct ib_mad_agent *mad_agent,
-                                  struct ib_mad_recv_wc *mad_wc)
-{
-        struct srpt_port *sport = (struct srpt_port *)mad_agent->context;
-        struct ib_ah *ah;
-        struct ib_mad_send_buf *rsp;
-        struct ib_dm_mad *dm_mad;
-
-        if (!mad_wc || !mad_wc->recv_buf.mad)
-                return;
-
-        ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc,
-                                  mad_wc->recv_buf.grh, mad_agent->port_num);
-        if (IS_ERR(ah))
-                goto err;
-
-        BUILD_BUG_ON(offsetof(struct ib_dm_mad, data) != IB_MGMT_DEVICE_HDR);
-
-        rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp,
-                                 mad_wc->wc->pkey_index, 0,
-                                 IB_MGMT_DEVICE_HDR, IB_MGMT_DEVICE_DATA,
-                                 GFP_KERNEL);
-        if (IS_ERR(rsp))
-                goto err_rsp;
-
-        rsp->ah = ah;
-
-        dm_mad = rsp->mad;
-        memcpy(dm_mad, mad_wc->recv_buf.mad, sizeof *dm_mad);
-        dm_mad->mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
-        dm_mad->mad_hdr.status = 0;
-
-        switch (mad_wc->recv_buf.mad->mad_hdr.method) {
-        case IB_MGMT_METHOD_GET:
-                srpt_mgmt_method_get(sport, mad_wc->recv_buf.mad, dm_mad);
-                break;
-        case IB_MGMT_METHOD_SET:
-                dm_mad->mad_hdr.status =
-                    __constant_cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
-                break;
-        default:
-                dm_mad->mad_hdr.status =
-                    __constant_cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD);
-                break;
-        }
-
-        if (!ib_post_send_mad(rsp, NULL)) {
-                ib_free_recv_mad(mad_wc);
-                /* will destroy_ah & free_send_mad in send completion */
-                return;
-        }
-
-        ib_free_send_mad(rsp);
-
-err_rsp:
-        ib_destroy_ah(ah);
-err:
-        ib_free_recv_mad(mad_wc);
-}
-
-/**
- * srpt_refresh_port() - Configure a HCA port.
- *
- * Enable InfiniBand management datagram processing, update the cached sm_lid,
- * lid and gid values, and register a callback function for processing MADs
- * on the specified port.
- *
- * Note: It is safe to call this function more than once for the same port.
- */
-static int srpt_refresh_port(struct srpt_port *sport)
-{
-        struct ib_mad_reg_req reg_req;
-        struct ib_port_modify port_modify;
-        struct ib_port_attr port_attr;
-        int ret;
-
-        memset(&port_modify, 0, sizeof port_modify);
-        port_modify.set_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP;
-        port_modify.clr_port_cap_mask = 0;
-
-        ret = ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify);
-        if (ret)
-                goto err_mod_port;
-
-        ret = ib_query_port(sport->sdev->device, sport->port, &port_attr);
-        if (ret)
-                goto err_query_port;
-
-        sport->sm_lid = port_attr.sm_lid;
-        sport->lid = port_attr.lid;
-
-        ret = ib_query_gid(sport->sdev->device, sport->port, 0, &sport->gid);
-        if (ret)
-                goto err_query_port;
-
-        if (!sport->mad_agent) {
-                memset(&reg_req, 0, sizeof reg_req);
-                reg_req.mgmt_class = IB_MGMT_CLASS_DEVICE_MGMT;
-                reg_req.mgmt_class_version = IB_MGMT_BASE_VERSION;
-                set_bit(IB_MGMT_METHOD_GET, reg_req.method_mask);
-                set_bit(IB_MGMT_METHOD_SET, reg_req.method_mask);
-
-                sport->mad_agent = ib_register_mad_agent(sport->sdev->device,
-                                                         sport->port,
-                                                         IB_QPT_GSI,
-                                                         &reg_req, 0,
-                                                         srpt_mad_send_handler,
-                                                         srpt_mad_recv_handler,
-                                                         sport);
-                if (IS_ERR(sport->mad_agent)) {
-                        ret = PTR_ERR(sport->mad_agent);
-                        sport->mad_agent = NULL;
-                        goto err_query_port;
-                }
-        }
-
-        return 0;
-
-err_query_port:
-
-        port_modify.set_port_cap_mask = 0;
-        port_modify.clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP;
-        ib_modify_port(sport->sdev->device, sport->port, 0, &port_modify);
-
-err_mod_port:
-
-        return ret;
-}
-
-/**
- * srpt_unregister_mad_agent() - Unregister MAD callback functions.
- *
- * Note: It is safe to call this function more than once for the same device.
- */
-static void srpt_unregister_mad_agent(struct srpt_device *sdev)
-{
-        struct ib_port_modify port_modify = {
-                .clr_port_cap_mask = IB_PORT_DEVICE_MGMT_SUP,
-        };
-        struct srpt_port *sport;
-        int i;
-
-        for (i = 1; i <= sdev->device->phys_port_cnt; i++) {
-                sport = &sdev->port[i - 1];
-                WARN_ON(sport->port != i);
-                if (ib_modify_port(sdev->device, i, 0, &port_modify) < 0)
-                        printk(KERN_ERR "disabling MAD processing failed.\n");
-                if (sport->mad_agent) {
-                        ib_unregister_mad_agent(sport->mad_agent);
-                        sport->mad_agent = NULL;
-                }
-        }
-}
-
-/**
- * srpt_alloc_ioctx() - Allocate an SRPT I/O context structure.
- */
-static struct srpt_ioctx *srpt_alloc_ioctx(struct srpt_device *sdev,
-                                           int ioctx_size, int dma_size,
-                                           enum dma_data_direction dir)
-{
-        struct srpt_ioctx *ioctx;
-
-        ioctx = kmalloc(ioctx_size, GFP_KERNEL);
-        if (!ioctx)
-                goto err;
-
-        ioctx->buf = kmalloc(dma_size, GFP_KERNEL);
-        if (!ioctx->buf)
-                goto err_free_ioctx;
-
-        ioctx->dma = ib_dma_map_single(sdev->device, ioctx->buf, dma_size, dir);
-        if (ib_dma_mapping_error(sdev->device, ioctx->dma))
-                goto err_free_buf;
-
-        return ioctx;
-
-err_free_buf:
-        kfree(ioctx->buf);
-err_free_ioctx:
-        kfree(ioctx);
-err:
-        return NULL;
-}
-
-/**
- * srpt_free_ioctx() - Free an SRPT I/O context structure.
- */
-static void srpt_free_ioctx(struct srpt_device *sdev, struct srpt_ioctx *ioctx,
-                            int dma_size, enum dma_data_direction dir)
-{
-        if (!ioctx)
-                return;
-
-        ib_dma_unmap_single(sdev->device, ioctx->dma, dma_size, dir);
-        kfree(ioctx->buf);
-        kfree(ioctx);
-}
-
-/**
- * srpt_alloc_ioctx_ring() - Allocate a ring of SRPT I/O context structures.
- * @sdev:       Device to allocate the I/O context ring for.
- * @ring_size:  Number of elements in the I/O context ring.
- * @ioctx_size: I/O context size.
- * @dma_size:   DMA buffer size.
- * @dir:        DMA data direction.
- */
-static struct srpt_ioctx **srpt_alloc_ioctx_ring(struct srpt_device *sdev,
-                                int ring_size, int ioctx_size,
-                                int dma_size, enum dma_data_direction dir)
-{
-        struct srpt_ioctx **ring;
-        int i;
-
-        WARN_ON(ioctx_size != sizeof(struct srpt_recv_ioctx)
-                && ioctx_size != sizeof(struct srpt_send_ioctx));
-
-        ring = kmalloc(ring_size * sizeof(ring[0]), GFP_KERNEL);
-        if (!ring)
-                goto out;
-        for (i = 0; i < ring_size; ++i) {
-                ring[i] = srpt_alloc_ioctx(sdev, ioctx_size, dma_size, dir);
-                if (!ring[i])
-                        goto err;
-                ring[i]->index = i;
-        }
-        goto out;
-
-err:
-        while (--i >= 0)
-                srpt_free_ioctx(sdev, ring[i], dma_size, dir);
-        kfree(ring);
-        ring = NULL;
-out:
-        return ring;
-}
-
-/**
- * srpt_free_ioctx_ring() - Free the ring of SRPT I/O context structures.
- */
-static void srpt_free_ioctx_ring(struct srpt_ioctx **ioctx_ring,
-                                 struct srpt_device *sdev, int ring_size,
-                                 int dma_size, enum dma_data_direction dir)
-{
-        int i;
-
-        for (i = 0; i < ring_size; ++i)
-                srpt_free_ioctx(sdev, ioctx_ring[i], dma_size, dir);
-        kfree(ioctx_ring);
-}
-
-/**
- * srpt_get_cmd_state() - Get the state of a SCSI command.
- */
-static enum srpt_command_state srpt_get_cmd_state(struct srpt_send_ioctx *ioctx)
-{
-        enum srpt_command_state state;
-        unsigned long flags;
-
-        BUG_ON(!ioctx);
-
-        spin_lock_irqsave(&ioctx->spinlock, flags);
-        state = ioctx->state;
-        spin_unlock_irqrestore(&ioctx->spinlock, flags);
-        return state;
-}
-
-/**
- * srpt_set_cmd_state() - Set the state of a SCSI command.
- *
- * Does not modify the state of aborted commands. Returns the previous command
- * state.
- */
-static enum srpt_command_state srpt_set_cmd_state(struct srpt_send_ioctx *ioctx,
-                                                  enum srpt_command_state new)
-{
-        enum srpt_command_state previous;
-        unsigned long flags;
-
-        BUG_ON(!ioctx);
-
-        spin_lock_irqsave(&ioctx->spinlock, flags);
-        previous = ioctx->state;
-        if (previous != SRPT_STATE_DONE)
-                ioctx->state = new;
-        spin_unlock_irqrestore(&ioctx->spinlock, flags);
-
-        return previous;
-}
-
-/**
- * srpt_test_and_set_cmd_state() - Test and set the state of a command.
- *
- * Returns true if and only if the previous command state was equal to 'old'.
- */
-static bool srpt_test_and_set_cmd_state(struct srpt_send_ioctx *ioctx,
-                                        enum srpt_command_state old,
-                                        enum srpt_command_state new)
-{
-        enum srpt_command_state previous;
-        unsigned long flags;
-
-        WARN_ON(!ioctx);
-        WARN_ON(old == SRPT_STATE_DONE);
-        WARN_ON(new == SRPT_STATE_NEW);
-
-        spin_lock_irqsave(&ioctx->spinlock, flags);
-        previous = ioctx->state;
-        if (previous == old)
-                ioctx->state = new;
-        spin_unlock_irqrestore(&ioctx->spinlock, flags);
-        return previous == old;
-}
-
-/**
- * srpt_post_recv() - Post an IB receive request.
- */
-static int srpt_post_recv(struct srpt_device *sdev,
-                          struct srpt_recv_ioctx *ioctx)
-{
-        struct ib_sge list;
-        struct ib_recv_wr wr, *bad_wr;
-
-        BUG_ON(!sdev);
-        wr.wr_id = encode_wr_id(SRPT_RECV, ioctx->ioctx.index);
-
-        list.addr = ioctx->ioctx.dma;
-        list.length = srp_max_req_size;
-        list.lkey = sdev->mr->lkey;
-
-        wr.next = NULL;
-        wr.sg_list = &list;
-        wr.num_sge = 1;
-
-        return ib_post_srq_recv(sdev->srq, &wr, &bad_wr);
-}
-
-/**
- * srpt_post_send() - Post an IB send request.
- *
- * Returns zero upon success and a non-zero value upon failure.
- */
-static int srpt_post_send(struct srpt_rdma_ch *ch,
-                          struct srpt_send_ioctx *ioctx, int len)
-{
-        struct ib_sge list;
-        struct ib_send_wr wr, *bad_wr;
-        struct srpt_device *sdev = ch->sport->sdev;
-        int ret;
-
-        atomic_inc(&ch->req_lim);
-
-        ret = -ENOMEM;
-        if (unlikely(atomic_dec_return(&ch->sq_wr_avail) < 0)) {
-                printk(KERN_WARNING "IB send queue full (needed 1)\n");
-                goto out;
-        }
-
-        ib_dma_sync_single_for_device(sdev->device, ioctx->ioctx.dma, len,
-                                      DMA_TO_DEVICE);
-
-        list.addr = ioctx->ioctx.dma;
-        list.length = len;
-        list.lkey = sdev->mr->lkey;
-
-        wr.next = NULL;
-        wr.wr_id = encode_wr_id(SRPT_SEND, ioctx->ioctx.index);
-        wr.sg_list = &list;
-        wr.num_sge = 1;
-        wr.opcode = IB_WR_SEND;
-        wr.send_flags = IB_SEND_SIGNALED;
-
-        ret = ib_post_send(ch->qp, &wr, &bad_wr);
-
-out:
-        if (ret < 0) {
-                atomic_inc(&ch->sq_wr_avail);
-                atomic_dec(&ch->req_lim);
-        }
-        return ret;
-}
-
-/**
- * srpt_get_desc_tbl() - Parse the data descriptors of an SRP_CMD request.
- * @ioctx: Pointer to the I/O context associated with the request.
- * @srp_cmd: Pointer to the SRP_CMD request data.
- * @dir: Pointer to the variable to which the transfer direction will be
- *   written.
- * @data_len: Pointer to the variable to which the total data length of all
- *   descriptors in the SRP_CMD request will be written.
- *
- * This function initializes ioctx->nrbuf and ioctx->r_bufs.
- *
- * Returns -EINVAL when the SRP_CMD request contains inconsistent descriptors;
- * -ENOMEM when memory allocation fails and zero upon success.
- */
-static int srpt_get_desc_tbl(struct srpt_send_ioctx *ioctx,
-                             struct srp_cmd *srp_cmd,
-                             enum dma_data_direction *dir, u64 *data_len)
-{
-        struct srp_indirect_buf *idb;
-        struct srp_direct_buf *db;
-        unsigned add_cdb_offset;
-        int ret;
-
-        /*
-         * The pointer computations below will only be compiled correctly
-         * if srp_cmd::add_data is declared as s8*, u8*, s8[] or u8[], so check
-         * whether srp_cmd::add_data has been declared as a byte pointer.
-         */
-        BUILD_BUG_ON(!__same_type(srp_cmd->add_data[0], (s8)0)
-                     && !__same_type(srp_cmd->add_data[0], (u8)0));
-
-        BUG_ON(!dir);
-        BUG_ON(!data_len);
-
-        ret = 0;
-        *data_len = 0;
-
-        /*
-         * The lower four bits of the buffer format field contain the DATA-IN
-         * buffer descriptor format, and the highest four bits contain the
-         * DATA-OUT buffer descriptor format.
-         */
-        *dir = DMA_NONE;
-        if (srp_cmd->buf_fmt & 0xf)
-                /* DATA-IN: transfer data from target to initiator (read). */
-                *dir = DMA_FROM_DEVICE;
-        else if (srp_cmd->buf_fmt >> 4)
-                /* DATA-OUT: transfer data from initiator to target (write). */
-                *dir = DMA_TO_DEVICE;
-
-        /*
-         * According to the SRP spec, the lower two bits of the 'ADDITIONAL
-         * CDB LENGTH' field are reserved and the size in bytes of this field
-         * is four times the value specified in bits 3..7. Hence the "& ~3".
-         */
-        add_cdb_offset = srp_cmd->add_cdb_len & ~3;
-        if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_DIRECT) ||
-            ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_DIRECT)) {
-                ioctx->n_rbuf = 1;
-                ioctx->rbufs = &ioctx->single_rbuf;
-
-                db = (struct srp_direct_buf *)(srp_cmd->add_data
-                                               + add_cdb_offset);
-                memcpy(ioctx->rbufs, db, sizeof *db);
-                *data_len = be32_to_cpu(db->len);
-        } else if (((srp_cmd->buf_fmt & 0xf) == SRP_DATA_DESC_INDIRECT) ||
-                   ((srp_cmd->buf_fmt >> 4) == SRP_DATA_DESC_INDIRECT)) {
-                idb = (struct srp_indirect_buf *)(srp_cmd->add_data
-                                                  + add_cdb_offset);
-
-                ioctx->n_rbuf = be32_to_cpu(idb->table_desc.len) / sizeof *db;
-
-                if (ioctx->n_rbuf >
-                    (srp_cmd->data_out_desc_cnt + srp_cmd->data_in_desc_cnt)) {
-                        printk(KERN_ERR "received unsupported SRP_CMD request"
-                               " type (%u out + %u in != %u / %zu)\n",
-                               srp_cmd->data_out_desc_cnt,
-                               srp_cmd->data_in_desc_cnt,
-                               be32_to_cpu(idb->table_desc.len),
-                               sizeof(*db));
-                        ioctx->n_rbuf = 0;
-                        ret = -EINVAL;
-                        goto out;
-                }
-
-                if (ioctx->n_rbuf == 1)
-                        ioctx->rbufs = &ioctx->single_rbuf;
-                else {
-                        ioctx->rbufs =
-                                kmalloc(ioctx->n_rbuf * sizeof *db, GFP_ATOMIC);
-                        if (!ioctx->rbufs) {
-                                ioctx->n_rbuf = 0;
-                                ret = -ENOMEM;
-                                goto out;
-                        }
-                }
-
-                db = idb->desc_list;
-                memcpy(ioctx->rbufs, db, ioctx->n_rbuf * sizeof *db);
-                *data_len = be32_to_cpu(idb->len);
-        }
-out:
-        return ret;
-}
-
-/**
- * srpt_init_ch_qp() - Initialize queue pair attributes.
- *
- * Initialized the attributes of queue pair 'qp' by allowing local write,
- * remote read and remote write. Also transitions 'qp' to state IB_QPS_INIT.
- */
-static int srpt_init_ch_qp(struct srpt_rdma_ch *ch, struct ib_qp *qp)
-{
-        struct ib_qp_attr *attr;
-        int ret;
-
-        attr = kzalloc(sizeof *attr, GFP_KERNEL);
-        if (!attr)
-                return -ENOMEM;
-
-        attr->qp_state = IB_QPS_INIT;
-        attr->qp_access_flags = IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_READ |
-            IB_ACCESS_REMOTE_WRITE;
-        attr->port_num = ch->sport->port;
-        attr->pkey_index = 0;
-
-        ret = ib_modify_qp(qp, attr,
-                           IB_QP_STATE | IB_QP_ACCESS_FLAGS | IB_QP_PORT |
-                           IB_QP_PKEY_INDEX);
-
-        kfree(attr);
-        return ret;
-}
-
-/**
- * srpt_ch_qp_rtr() - Change the state of a channel to 'ready to receive' (RTR).
- * @ch: channel of the queue pair.
- * @qp: queue pair to change the state of.
- *
- * Returns zero upon success and a negative value upon failure.
- *
- * Note: currently a struct ib_qp_attr takes 136 bytes on a 64-bit system.
- * If this structure ever becomes larger, it might be necessary to allocate
- * it dynamically instead of on the stack.
- */
-static int srpt_ch_qp_rtr(struct srpt_rdma_ch *ch, struct ib_qp *qp)
-{
-        struct ib_qp_attr qp_attr;
-        int attr_mask;
-        int ret;
-
-        qp_attr.qp_state = IB_QPS_RTR;
-        ret = ib_cm_init_qp_attr(ch->cm_id, &qp_attr, &attr_mask);
-        if (ret)
-                goto out;
-
-        qp_attr.max_dest_rd_atomic = 4;
-
-        ret = ib_modify_qp(qp, &qp_attr, attr_mask);
-
-out:
-        return ret;
-}
-
-/**
- * srpt_ch_qp_rts() - Change the state of a channel to 'ready to send' (RTS).
- * @ch: channel of the queue pair.
- * @qp: queue pair to change the state of.
- *
- * Returns zero upon success and a negative value upon failure.
- *
- * Note: currently a struct ib_qp_attr takes 136 bytes on a 64-bit system.
- * If this structure ever becomes larger, it might be necessary to allocate
- * it dynamically instead of on the stack.
- */
-static int srpt_ch_qp_rts(struct srpt_rdma_ch *ch, struct ib_qp *qp)
-{
-        struct ib_qp_attr qp_attr;
-        int attr_mask;
-        int ret;
-
-        qp_attr.qp_state = IB_QPS_RTS;
-        ret = ib_cm_init_qp_attr(ch->cm_id, &qp_attr, &attr_mask);
-        if (ret)
-                goto out;
-
-        qp_attr.max_rd_atomic = 4;
-
-        ret = ib_modify_qp(qp, &qp_attr, attr_mask);
-
-out:
-        return ret;
-}
-
-/**
- * srpt_ch_qp_err() - Set the channel queue pair state to 'error'.
- */
-static int srpt_ch_qp_err(struct srpt_rdma_ch *ch)
-{
-        struct ib_qp_attr qp_attr;
-
-        qp_attr.qp_state = IB_QPS_ERR;
-        return ib_modify_qp(ch->qp, &qp_attr, IB_QP_STATE);
-}
-
-/**
- * srpt_unmap_sg_to_ib_sge() - Unmap an IB SGE list.
- */
-static void srpt_unmap_sg_to_ib_sge(struct srpt_rdma_ch *ch,
-                                    struct srpt_send_ioctx *ioctx)
-{
-        struct scatterlist *sg;
-        enum dma_data_direction dir;
-
-        BUG_ON(!ch);
-        BUG_ON(!ioctx);
-        BUG_ON(ioctx->n_rdma && !ioctx->rdma_ius);
-
-        while (ioctx->n_rdma)
-                kfree(ioctx->rdma_ius[--ioctx->n_rdma].sge);
-
-        kfree(ioctx->rdma_ius);
-        ioctx->rdma_ius = NULL;
-
-        if (ioctx->mapped_sg_count) {
-                sg = ioctx->sg;
-                WARN_ON(!sg);
-                dir = ioctx->cmd.data_direction;
-                BUG_ON(dir == DMA_NONE);
-                ib_dma_unmap_sg(ch->sport->sdev->device, sg, ioctx->sg_cnt,
-                                opposite_dma_dir(dir));
-                ioctx->mapped_sg_count = 0;
-        }
-}
-
-/**
- * srpt_map_sg_to_ib_sge() - Map an SG list to an IB SGE list.
- */
-static int srpt_map_sg_to_ib_sge(struct srpt_rdma_ch *ch,
-                                 struct srpt_send_ioctx *ioctx)
-{
-        struct se_cmd *cmd;
-        struct scatterlist *sg, *sg_orig;
-        int sg_cnt;
-        enum dma_data_direction dir;
-        struct rdma_iu *riu;
-        struct srp_direct_buf *db;
-        dma_addr_t dma_addr;
-        struct ib_sge *sge;
-        u64 raddr;
-        u32 rsize;
-        u32 tsize;
-        u32 dma_len;
-        int count, nrdma;
-        int i, j, k;
-
-        BUG_ON(!ch);
-        BUG_ON(!ioctx);
-        cmd = &ioctx->cmd;
-        dir = cmd->data_direction;
-        BUG_ON(dir == DMA_NONE);
-
-        ioctx->sg = sg = sg_orig = cmd->t_data_sg;
-        ioctx->sg_cnt = sg_cnt = cmd->t_data_nents;
-
-        count = ib_dma_map_sg(ch->sport->sdev->device, sg, sg_cnt,
-                              opposite_dma_dir(dir));
-        if (unlikely(!count))
-                return -EAGAIN;
-
-        ioctx->mapped_sg_count = count;
-
-        if (ioctx->rdma_ius && ioctx->n_rdma_ius)
-                nrdma = ioctx->n_rdma_ius;
-        else {
-                nrdma = (count + SRPT_DEF_SG_PER_WQE - 1) / SRPT_DEF_SG_PER_WQE
-                        + ioctx->n_rbuf;
-
-                ioctx->rdma_ius = kzalloc(nrdma * sizeof *riu, GFP_KERNEL);
-                if (!ioctx->rdma_ius)
-                        goto free_mem;
-
-                ioctx->n_rdma_ius = nrdma;
-        }
-
-        db = ioctx->rbufs;
-        tsize = cmd->data_length;
-        dma_len = sg_dma_len(&sg[0]);
-        riu = ioctx->rdma_ius;
-
-        /*
-         * For each remote desc - calculate the #ib_sge.
-         * If #ib_sge < SRPT_DEF_SG_PER_WQE per rdma operation then
-         *      each remote desc rdma_iu is required a rdma wr;
-         * else
-         *      we need to allocate extra rdma_iu to carry extra #ib_sge in
-         *      another rdma wr
-         */
-        for (i = 0, j = 0;
-             j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) {
-                rsize = be32_to_cpu(db->len);
-                raddr = be64_to_cpu(db->va);
-                riu->raddr = raddr;
-                riu->rkey = be32_to_cpu(db->key);
-                riu->sge_cnt = 0;
-
-                /* calculate how many sge required for this remote_buf */
-                while (rsize > 0 && tsize > 0) {
-
-                        if (rsize >= dma_len) {
-                                tsize -= dma_len;
-                                rsize -= dma_len;
-                                raddr += dma_len;
-
-                                if (tsize > 0) {
-                                        ++j;
-                                        if (j < count) {
-                                                sg = sg_next(sg);
-                                                dma_len = sg_dma_len(sg);
-                                        }
-                                }
-                        } else {
-                                tsize -= rsize;
-                                dma_len -= rsize;
-                                rsize = 0;
-                        }
-
-                        ++riu->sge_cnt;
-
-                        if (rsize > 0 && riu->sge_cnt == SRPT_DEF_SG_PER_WQE) {
-                                ++ioctx->n_rdma;
-                                riu->sge =
-                                    kmalloc(riu->sge_cnt * sizeof *riu->sge,
-                                            GFP_KERNEL);
-                                if (!riu->sge)
-                                        goto free_mem;
-
-                                ++riu;
-                                riu->sge_cnt = 0;
-                                riu->raddr = raddr;
-                                riu->rkey = be32_to_cpu(db->key);
-                        }
-                }
-
-                ++ioctx->n_rdma;
-                riu->sge = kmalloc(riu->sge_cnt * sizeof *riu->sge,
-                                   GFP_KERNEL);
-                if (!riu->sge)
-                        goto free_mem;
-        }
-
-        db = ioctx->rbufs;
-        tsize = cmd->data_length;
-        riu = ioctx->rdma_ius;
-        sg = sg_orig;
-        dma_len = sg_dma_len(&sg[0]);
-        dma_addr = sg_dma_address(&sg[0]);
-
-        /* this second loop is really mapped sg_addres to rdma_iu->ib_sge */
-        for (i = 0, j = 0;
-             j < count && i < ioctx->n_rbuf && tsize > 0; ++i, ++riu, ++db) {
-                rsize = be32_to_cpu(db->len);
-                sge = riu->sge;
-                k = 0;
-
-                while (rsize > 0 && tsize > 0) {
-                        sge->addr = dma_addr;
-                        sge->lkey = ch->sport->sdev->mr->lkey;
-
-                        if (rsize >= dma_len) {
-                                sge->length =
-                                        (tsize < dma_len) ? tsize : dma_len;
-                                tsize -= dma_len;
-                                rsize -= dma_len;
-
-                                if (tsize > 0) {
-                                        ++j;
-                                        if (j < count) {
-                                                sg = sg_next(sg);
-                                                dma_len = sg_dma_len(sg);
-                                                dma_addr = sg_dma_address(sg);
-                                        }
-                                }
-                        } else {
-                                sge->length = (tsize < rsize) ? tsize : rsize;
-                                tsize -= rsize;
-                                dma_len -= rsize;
-                                dma_addr += rsize;
-                                rsize = 0;
-                        }
-
-                        ++k;
-                        if (k == riu->sge_cnt && rsize > 0 && tsize > 0) {
-                                ++riu;
-                                sge = riu->sge;
-                                k = 0;
-                        } else if (rsize > 0 && tsize > 0)
-                                ++sge;
-                }
-        }
-
-        return 0;
-
-free_mem:
-        srpt_unmap_sg_to_ib_sge(ch, ioctx);
-
-        return -ENOMEM;
-}
-
-/**
- * srpt_get_send_ioctx() - Obtain an I/O context for sending to the initiator.
- */
-static struct srpt_send_ioctx *srpt_get_send_ioctx(struct srpt_rdma_ch *ch)
-{
-        struct srpt_send_ioctx *ioctx;
-        unsigned long flags;
-
-        BUG_ON(!ch);
-
-        ioctx = NULL;
-        spin_lock_irqsave(&ch->spinlock, flags);
-        if (!list_empty(&ch->free_list)) {
-                ioctx = list_first_entry(&ch->free_list,
-                                         struct srpt_send_ioctx, free_list);
-                list_del(&ioctx->free_list);
-        }
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-
-        if (!ioctx)
-                return ioctx;
-
-        BUG_ON(ioctx->ch != ch);
-        spin_lock_init(&ioctx->spinlock);
-        ioctx->state = SRPT_STATE_NEW;
-        ioctx->n_rbuf = 0;
-        ioctx->rbufs = NULL;
-        ioctx->n_rdma = 0;
-        ioctx->n_rdma_ius = 0;
-        ioctx->rdma_ius = NULL;
-        ioctx->mapped_sg_count = 0;
-        init_completion(&ioctx->tx_done);
-        ioctx->queue_status_only = false;
-        /*
-         * transport_init_se_cmd() does not initialize all fields, so do it
-         * here.
-         */
-        memset(&ioctx->cmd, 0, sizeof(ioctx->cmd));
-        memset(&ioctx->sense_data, 0, sizeof(ioctx->sense_data));
-
-        return ioctx;
-}
-
-/**
- * srpt_abort_cmd() - Abort a SCSI command.
- * @ioctx:   I/O context associated with the SCSI command.
- * @context: Preferred execution context.
- */
-static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
-{
-        enum srpt_command_state state;
-        unsigned long flags;
-
-        BUG_ON(!ioctx);
-
-        /*
-         * If the command is in a state where the target core is waiting for
-         * the ib_srpt driver, change the state to the next state. Changing
-         * the state of the command from SRPT_STATE_NEED_DATA to
-         * SRPT_STATE_DATA_IN ensures that srpt_xmit_response() will call this
-         * function a second time.
-         */
-
-        spin_lock_irqsave(&ioctx->spinlock, flags);
-        state = ioctx->state;
-        switch (state) {
-        case SRPT_STATE_NEED_DATA:
-                ioctx->state = SRPT_STATE_DATA_IN;
-                break;
-        case SRPT_STATE_DATA_IN:
-        case SRPT_STATE_CMD_RSP_SENT:
-        case SRPT_STATE_MGMT_RSP_SENT:
-                ioctx->state = SRPT_STATE_DONE;
-                break;
-        default:
-                break;
-        }
-        spin_unlock_irqrestore(&ioctx->spinlock, flags);
-
-        if (state == SRPT_STATE_DONE) {
-                struct srpt_rdma_ch *ch = ioctx->ch;
-
-                BUG_ON(ch->sess == NULL);
-
-                target_put_sess_cmd(ch->sess, &ioctx->cmd);
-                goto out;
-        }
-
-        pr_debug("Aborting cmd with state %d and tag %lld\n", state,
-                 ioctx->tag);
-
-        switch (state) {
-        case SRPT_STATE_NEW:
-        case SRPT_STATE_DATA_IN:
-        case SRPT_STATE_MGMT:
-                /*
-                 * Do nothing - defer abort processing until
-                 * srpt_queue_response() is invoked.
-                 */
-                WARN_ON(!transport_check_aborted_status(&ioctx->cmd, false));
-                break;
-        case SRPT_STATE_NEED_DATA:
-                /* DMA_TO_DEVICE (write) - RDMA read error. */
-
-                /* XXX(hch): this is a horrible layering violation.. */
-                spin_lock_irqsave(&ioctx->cmd.t_state_lock, flags);
-                ioctx->cmd.transport_state |= CMD_T_LUN_STOP;
-                ioctx->cmd.transport_state &= ~CMD_T_ACTIVE;
-                spin_unlock_irqrestore(&ioctx->cmd.t_state_lock, flags);
-
-                complete(&ioctx->cmd.transport_lun_stop_comp);
-                break;
-        case SRPT_STATE_CMD_RSP_SENT:
-                /*
-                 * SRP_RSP sending failed or the SRP_RSP send completion has
-                 * not been received in time.
-                 */
-                srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx);
-                spin_lock_irqsave(&ioctx->cmd.t_state_lock, flags);
-                ioctx->cmd.transport_state |= CMD_T_LUN_STOP;
-                spin_unlock_irqrestore(&ioctx->cmd.t_state_lock, flags);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
-                break;
-        case SRPT_STATE_MGMT_RSP_SENT:
-                srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
-                break;
-        default:
-                WARN_ON("ERROR: unexpected command state");
-                break;
-        }
-
-out:
-        return state;
-}
-
-/**
- * srpt_handle_send_err_comp() - Process an IB_WC_SEND error completion.
- */
-static void srpt_handle_send_err_comp(struct srpt_rdma_ch *ch, u64 wr_id)
-{
-        struct srpt_send_ioctx *ioctx;
-        enum srpt_command_state state;
-        struct se_cmd *cmd;
-        u32 index;
-
-        atomic_inc(&ch->sq_wr_avail);
-
-        index = idx_from_wr_id(wr_id);
-        ioctx = ch->ioctx_ring[index];
-        state = srpt_get_cmd_state(ioctx);
-        cmd = &ioctx->cmd;
-
-        WARN_ON(state != SRPT_STATE_CMD_RSP_SENT
-                && state != SRPT_STATE_MGMT_RSP_SENT
-                && state != SRPT_STATE_NEED_DATA
-                && state != SRPT_STATE_DONE);
-
-        /* If SRP_RSP sending failed, undo the ch->req_lim change. */
-        if (state == SRPT_STATE_CMD_RSP_SENT
-            || state == SRPT_STATE_MGMT_RSP_SENT)
-                atomic_dec(&ch->req_lim);
-
-        srpt_abort_cmd(ioctx);
-}
-
-/**
- * srpt_handle_send_comp() - Process an IB send completion notification.
- */
-static void srpt_handle_send_comp(struct srpt_rdma_ch *ch,
-                                  struct srpt_send_ioctx *ioctx)
-{
-        enum srpt_command_state state;
-
-        atomic_inc(&ch->sq_wr_avail);
-
-        state = srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
-
-        if (WARN_ON(state != SRPT_STATE_CMD_RSP_SENT
-                    && state != SRPT_STATE_MGMT_RSP_SENT
-                    && state != SRPT_STATE_DONE))
-                pr_debug("state = %d\n", state);
-
-        if (state != SRPT_STATE_DONE) {
-                srpt_unmap_sg_to_ib_sge(ch, ioctx);
-                transport_generic_free_cmd(&ioctx->cmd, 0);
-        } else {
-                printk(KERN_ERR "IB completion has been received too late for"
-                       " wr_id = %u.\n", ioctx->ioctx.index);
-        }
-}
-
-/**
- * srpt_handle_rdma_comp() - Process an IB RDMA completion notification.
- *
- * XXX: what is now target_execute_cmd used to be asynchronous, and unmapping
- * the data that has been transferred via IB RDMA had to be postponed until the
- * check_stop_free() callback.  None of this is necessary anymore and needs to
- * be cleaned up.
- */
-static void srpt_handle_rdma_comp(struct srpt_rdma_ch *ch,
-                                  struct srpt_send_ioctx *ioctx,
-                                  enum srpt_opcode opcode)
-{
-        WARN_ON(ioctx->n_rdma <= 0);
-        atomic_add(ioctx->n_rdma, &ch->sq_wr_avail);
-
-        if (opcode == SRPT_RDMA_READ_LAST) {
-                if (srpt_test_and_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA,
-                                                SRPT_STATE_DATA_IN))
-                        target_execute_cmd(&ioctx->cmd);
-                else
-                        printk(KERN_ERR "%s[%d]: wrong state = %d\n", __func__,
-                               __LINE__, srpt_get_cmd_state(ioctx));
-        } else if (opcode == SRPT_RDMA_ABORT) {
-                ioctx->rdma_aborted = true;
-        } else {
-                WARN(true, "unexpected opcode %d\n", opcode);
-        }
-}
-
-/**
- * srpt_handle_rdma_err_comp() - Process an IB RDMA error completion.
- */
-static void srpt_handle_rdma_err_comp(struct srpt_rdma_ch *ch,
-                                      struct srpt_send_ioctx *ioctx,
-                                      enum srpt_opcode opcode)
-{
-        struct se_cmd *cmd;
-        enum srpt_command_state state;
-        unsigned long flags;
-
-        cmd = &ioctx->cmd;
-        state = srpt_get_cmd_state(ioctx);
-        switch (opcode) {
-        case SRPT_RDMA_READ_LAST:
-                if (ioctx->n_rdma <= 0) {
-                        printk(KERN_ERR "Received invalid RDMA read"
-                               " error completion with idx %d\n",
-                               ioctx->ioctx.index);
-                        break;
-                }
-                atomic_add(ioctx->n_rdma, &ch->sq_wr_avail);
-                if (state == SRPT_STATE_NEED_DATA)
-                        srpt_abort_cmd(ioctx);
-                else
-                        printk(KERN_ERR "%s[%d]: wrong state = %d\n",
-                               __func__, __LINE__, state);
-                break;
-        case SRPT_RDMA_WRITE_LAST:
-                spin_lock_irqsave(&ioctx->cmd.t_state_lock, flags);
-                ioctx->cmd.transport_state |= CMD_T_LUN_STOP;
-                spin_unlock_irqrestore(&ioctx->cmd.t_state_lock, flags);
-                break;
-        default:
-                printk(KERN_ERR "%s[%d]: opcode = %u\n", __func__,
-                       __LINE__, opcode);
-                break;
-        }
-}
-
-/**
- * srpt_build_cmd_rsp() - Build an SRP_RSP response.
- * @ch: RDMA channel through which the request has been received.
- * @ioctx: I/O context associated with the SRP_CMD request. The response will
- *   be built in the buffer ioctx->buf points at and hence this function will
- *   overwrite the request data.
- * @tag: tag of the request for which this response is being generated.
- * @status: value for the STATUS field of the SRP_RSP information unit.
- *
- * Returns the size in bytes of the SRP_RSP response.
- *
- * An SRP_RSP response contains a SCSI status or service response. See also
- * section 6.9 in the SRP r16a document for the format of an SRP_RSP
- * response. See also SPC-2 for more information about sense data.
- */
-static int srpt_build_cmd_rsp(struct srpt_rdma_ch *ch,
-                              struct srpt_send_ioctx *ioctx, u64 tag,
-                              int status)
-{
-        struct srp_rsp *srp_rsp;
-        const u8 *sense_data;
-        int sense_data_len, max_sense_len;
-
-        /*
-         * The lowest bit of all SAM-3 status codes is zero (see also
-         * paragraph 5.3 in SAM-3).
-         */
-        WARN_ON(status & 1);
-
-        srp_rsp = ioctx->ioctx.buf;
-        BUG_ON(!srp_rsp);
-
-        sense_data = ioctx->sense_data;
-        sense_data_len = ioctx->cmd.scsi_sense_length;
-        WARN_ON(sense_data_len > sizeof(ioctx->sense_data));
-
-        memset(srp_rsp, 0, sizeof *srp_rsp);
-        srp_rsp->opcode = SRP_RSP;
-        srp_rsp->req_lim_delta =
-                __constant_cpu_to_be32(1 + atomic_xchg(&ch->req_lim_delta, 0));
-        srp_rsp->tag = tag;
-        srp_rsp->status = status;
-
-        if (sense_data_len) {
-                BUILD_BUG_ON(MIN_MAX_RSP_SIZE <= sizeof(*srp_rsp));
-                max_sense_len = ch->max_ti_iu_len - sizeof(*srp_rsp);
-                if (sense_data_len > max_sense_len) {
-                        printk(KERN_WARNING "truncated sense data from %d to %d"
-                               " bytes\n", sense_data_len, max_sense_len);
-                        sense_data_len = max_sense_len;
-                }
-
-                srp_rsp->flags |= SRP_RSP_FLAG_SNSVALID;
-                srp_rsp->sense_data_len = cpu_to_be32(sense_data_len);
-                memcpy(srp_rsp + 1, sense_data, sense_data_len);
-        }
-
-        return sizeof(*srp_rsp) + sense_data_len;
-}
-
-/**
- * srpt_build_tskmgmt_rsp() - Build a task management response.
- * @ch:       RDMA channel through which the request has been received.
- * @ioctx:    I/O context in which the SRP_RSP response will be built.
- * @rsp_code: RSP_CODE that will be stored in the response.
- * @tag:      Tag of the request for which this response is being generated.
- *
- * Returns the size in bytes of the SRP_RSP response.
- *
- * An SRP_RSP response contains a SCSI status or service response. See also
- * section 6.9 in the SRP r16a document for the format of an SRP_RSP
- * response.
- */
-static int srpt_build_tskmgmt_rsp(struct srpt_rdma_ch *ch,
-                                  struct srpt_send_ioctx *ioctx,
-                                  u8 rsp_code, u64 tag)
-{
-        struct srp_rsp *srp_rsp;
-        int resp_data_len;
-        int resp_len;
-
-        resp_data_len = (rsp_code == SRP_TSK_MGMT_SUCCESS) ? 0 : 4;
-        resp_len = sizeof(*srp_rsp) + resp_data_len;
-
-        srp_rsp = ioctx->ioctx.buf;
-        BUG_ON(!srp_rsp);
-        memset(srp_rsp, 0, sizeof *srp_rsp);
-
-        srp_rsp->opcode = SRP_RSP;
-        srp_rsp->req_lim_delta = __constant_cpu_to_be32(1
-                                    + atomic_xchg(&ch->req_lim_delta, 0));
-        srp_rsp->tag = tag;
-
-        if (rsp_code != SRP_TSK_MGMT_SUCCESS) {
-                srp_rsp->flags |= SRP_RSP_FLAG_RSPVALID;
-                srp_rsp->resp_data_len = cpu_to_be32(resp_data_len);
-                srp_rsp->data[3] = rsp_code;
-        }
-
-        return resp_len;
-}
-
-#define NO_SUCH_LUN ((uint64_t)-1LL)
-
-/*
- * SCSI LUN addressing method. See also SAM-2 and the section about
- * eight byte LUNs.
- */
-enum scsi_lun_addr_method {
-        SCSI_LUN_ADDR_METHOD_PERIPHERAL   = 0,
-        SCSI_LUN_ADDR_METHOD_FLAT         = 1,
-        SCSI_LUN_ADDR_METHOD_LUN          = 2,
-        SCSI_LUN_ADDR_METHOD_EXTENDED_LUN = 3,
-};
-
-/*
- * srpt_unpack_lun() - Convert from network LUN to linear LUN.
- *
- * Convert an 2-byte, 4-byte, 6-byte or 8-byte LUN structure in network byte
- * order (big endian) to a linear LUN. Supports three LUN addressing methods:
- * peripheral, flat and logical unit. See also SAM-2, section 4.9.4 (page 40).
- */
-static uint64_t srpt_unpack_lun(const uint8_t *lun, int len)
-{
-        uint64_t res = NO_SUCH_LUN;
-        int addressing_method;
-
-        if (unlikely(len < 2)) {
-                printk(KERN_ERR "Illegal LUN length %d, expected 2 bytes or "
-                       "more", len);
-                goto out;
-        }
-
-        switch (len) {
-        case 8:
-                if ((*((__be64 *)lun) &
-                     __constant_cpu_to_be64(0x0000FFFFFFFFFFFFLL)) != 0)
-                        goto out_err;
-                break;
-        case 4:
-                if (*((__be16 *)&lun[2]) != 0)
-                        goto out_err;
-                break;
-        case 6:
-                if (*((__be32 *)&lun[2]) != 0)
-                        goto out_err;
-                break;
-        case 2:
-                break;
-        default:
-                goto out_err;
-        }
-
-        addressing_method = (*lun) >> 6; /* highest two bits of byte 0 */
-        switch (addressing_method) {
-        case SCSI_LUN_ADDR_METHOD_PERIPHERAL:
-        case SCSI_LUN_ADDR_METHOD_FLAT:
-        case SCSI_LUN_ADDR_METHOD_LUN:
-                res = *(lun + 1) | (((*lun) & 0x3f) << 8);
-                break;
-
-        case SCSI_LUN_ADDR_METHOD_EXTENDED_LUN:
-        default:
-                printk(KERN_ERR "Unimplemented LUN addressing method %u",
-                       addressing_method);
-                break;
-        }
-
-out:
-        return res;
-
-out_err:
-        printk(KERN_ERR "Support for multi-level LUNs has not yet been"
-               " implemented");
-        goto out;
-}
-
-static int srpt_check_stop_free(struct se_cmd *cmd)
-{
-        struct srpt_send_ioctx *ioctx = container_of(cmd,
-                                struct srpt_send_ioctx, cmd);
-
-        return target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
-}
-
-/**
- * srpt_handle_cmd() - Process SRP_CMD.
- */
-static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
-                           struct srpt_recv_ioctx *recv_ioctx,
-                           struct srpt_send_ioctx *send_ioctx)
-{
-        struct se_cmd *cmd;
-        struct srp_cmd *srp_cmd;
-        uint64_t unpacked_lun;
-        u64 data_len;
-        enum dma_data_direction dir;
-        sense_reason_t ret;
-        int rc;
-
-        BUG_ON(!send_ioctx);
-
-        srp_cmd = recv_ioctx->ioctx.buf;
-        cmd = &send_ioctx->cmd;
-        send_ioctx->tag = srp_cmd->tag;
-
-        switch (srp_cmd->task_attr) {
-        case SRP_CMD_SIMPLE_Q:
-                cmd->sam_task_attr = MSG_SIMPLE_TAG;
-                break;
-        case SRP_CMD_ORDERED_Q:
-        default:
-                cmd->sam_task_attr = MSG_ORDERED_TAG;
-                break;
-        case SRP_CMD_HEAD_OF_Q:
-                cmd->sam_task_attr = MSG_HEAD_TAG;
-                break;
-        case SRP_CMD_ACA:
-                cmd->sam_task_attr = MSG_ACA_TAG;
-                break;
-        }
-
-        if (srpt_get_desc_tbl(send_ioctx, srp_cmd, &dir, &data_len)) {
-                printk(KERN_ERR "0x%llx: parsing SRP descriptor table failed.\n",
-                       srp_cmd->tag);
-                ret = TCM_INVALID_CDB_FIELD;
-                goto send_sense;
-        }
-
-        unpacked_lun = srpt_unpack_lun((uint8_t *)&srp_cmd->lun,
-                                       sizeof(srp_cmd->lun));
-        rc = target_submit_cmd(cmd, ch->sess, srp_cmd->cdb,
-                        &send_ioctx->sense_data[0], unpacked_lun, data_len,
-                        MSG_SIMPLE_TAG, dir, TARGET_SCF_ACK_KREF);
-        if (rc != 0) {
-                ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                goto send_sense;
-        }
-        return 0;
-
-send_sense:
-        transport_send_check_condition_and_sense(cmd, ret, 0);
-        return -1;
-}
-
-/**
- * srpt_rx_mgmt_fn_tag() - Process a task management function by tag.
- * @ch: RDMA channel of the task management request.
- * @fn: Task management function to perform.
- * @req_tag: Tag of the SRP task management request.
- * @mgmt_ioctx: I/O context of the task management request.
- *
- * Returns zero if the target core will process the task management
- * request asynchronously.
- *
- * Note: It is assumed that the initiator serializes tag-based task management
- * requests.
- */
-static int srpt_rx_mgmt_fn_tag(struct srpt_send_ioctx *ioctx, u64 tag)
-{
-        struct srpt_device *sdev;
-        struct srpt_rdma_ch *ch;
-        struct srpt_send_ioctx *target;
-        int ret, i;
-
-        ret = -EINVAL;
-        ch = ioctx->ch;
-        BUG_ON(!ch);
-        BUG_ON(!ch->sport);
-        sdev = ch->sport->sdev;
-        BUG_ON(!sdev);
-        spin_lock_irq(&sdev->spinlock);
-        for (i = 0; i < ch->rq_size; ++i) {
-                target = ch->ioctx_ring[i];
-                if (target->cmd.se_lun == ioctx->cmd.se_lun &&
-                    target->tag == tag &&
-                    srpt_get_cmd_state(target) != SRPT_STATE_DONE) {
-                        ret = 0;
-                        /* now let the target core abort &target->cmd; */
-                        break;
-                }
-        }
-        spin_unlock_irq(&sdev->spinlock);
-        return ret;
-}
-
-static int srp_tmr_to_tcm(int fn)
-{
-        switch (fn) {
-        case SRP_TSK_ABORT_TASK:
-                return TMR_ABORT_TASK;
-        case SRP_TSK_ABORT_TASK_SET:
-                return TMR_ABORT_TASK_SET;
-        case SRP_TSK_CLEAR_TASK_SET:
-                return TMR_CLEAR_TASK_SET;
-        case SRP_TSK_LUN_RESET:
-                return TMR_LUN_RESET;
-        case SRP_TSK_CLEAR_ACA:
-                return TMR_CLEAR_ACA;
-        default:
-                return -1;
-        }
-}
-
-/**
- * srpt_handle_tsk_mgmt() - Process an SRP_TSK_MGMT information unit.
- *
- * Returns 0 if and only if the request will be processed by the target core.
- *
- * For more information about SRP_TSK_MGMT information units, see also section
- * 6.7 in the SRP r16a document.
- */
-static void srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch,
-                                 struct srpt_recv_ioctx *recv_ioctx,
-                                 struct srpt_send_ioctx *send_ioctx)
-{
-        struct srp_tsk_mgmt *srp_tsk;
-        struct se_cmd *cmd;
-        struct se_session *sess = ch->sess;
-        uint64_t unpacked_lun;
-        uint32_t tag = 0;
-        int tcm_tmr;
-        int rc;
-
-        BUG_ON(!send_ioctx);
-
-        srp_tsk = recv_ioctx->ioctx.buf;
-        cmd = &send_ioctx->cmd;
-
-        pr_debug("recv tsk_mgmt fn %d for task_tag %lld and cmd tag %lld"
-                 " cm_id %p sess %p\n", srp_tsk->tsk_mgmt_func,
-                 srp_tsk->task_tag, srp_tsk->tag, ch->cm_id, ch->sess);
-
-        srpt_set_cmd_state(send_ioctx, SRPT_STATE_MGMT);
-        send_ioctx->tag = srp_tsk->tag;
-        tcm_tmr = srp_tmr_to_tcm(srp_tsk->tsk_mgmt_func);
-        if (tcm_tmr < 0) {
-                send_ioctx->cmd.se_tmr_req->response =
-                        TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED;
-                goto fail;
-        }
-        unpacked_lun = srpt_unpack_lun((uint8_t *)&srp_tsk->lun,
-                                       sizeof(srp_tsk->lun));
-
-        if (srp_tsk->tsk_mgmt_func == SRP_TSK_ABORT_TASK) {
-                rc = srpt_rx_mgmt_fn_tag(send_ioctx, srp_tsk->task_tag);
-                if (rc < 0) {
-                        send_ioctx->cmd.se_tmr_req->response =
-                                        TMR_TASK_DOES_NOT_EXIST;
-                        goto fail;
-                }
-                tag = srp_tsk->task_tag;
-        }
-        rc = target_submit_tmr(&send_ioctx->cmd, sess, NULL, unpacked_lun,
-                                srp_tsk, tcm_tmr, GFP_KERNEL, tag,
-                                TARGET_SCF_ACK_KREF);
-        if (rc != 0) {
-                send_ioctx->cmd.se_tmr_req->response = TMR_FUNCTION_REJECTED;
-                goto fail;
-        }
-        return;
-fail:
-        transport_send_check_condition_and_sense(cmd, 0, 0); // XXX:
-}
-
-/**
- * srpt_handle_new_iu() - Process a newly received information unit.
- * @ch:    RDMA channel through which the information unit has been received.
- * @ioctx: SRPT I/O context associated with the information unit.
- */
-static void srpt_handle_new_iu(struct srpt_rdma_ch *ch,
-                               struct srpt_recv_ioctx *recv_ioctx,
-                               struct srpt_send_ioctx *send_ioctx)
-{
-        struct srp_cmd *srp_cmd;
-        enum rdma_ch_state ch_state;
-
-        BUG_ON(!ch);
-        BUG_ON(!recv_ioctx);
-
-        ib_dma_sync_single_for_cpu(ch->sport->sdev->device,
-                                   recv_ioctx->ioctx.dma, srp_max_req_size,
-                                   DMA_FROM_DEVICE);
-
-        ch_state = srpt_get_ch_state(ch);
-        if (unlikely(ch_state == CH_CONNECTING)) {
-                list_add_tail(&recv_ioctx->wait_list, &ch->cmd_wait_list);
-                goto out;
-        }
-
-        if (unlikely(ch_state != CH_LIVE))
-                goto out;
-
-        srp_cmd = recv_ioctx->ioctx.buf;
-        if (srp_cmd->opcode == SRP_CMD || srp_cmd->opcode == SRP_TSK_MGMT) {
-                if (!send_ioctx)
-                        send_ioctx = srpt_get_send_ioctx(ch);
-                if (unlikely(!send_ioctx)) {
-                        list_add_tail(&recv_ioctx->wait_list,
-                                      &ch->cmd_wait_list);
-                        goto out;
-                }
-        }
-
-        switch (srp_cmd->opcode) {
-        case SRP_CMD:
-                srpt_handle_cmd(ch, recv_ioctx, send_ioctx);
-                break;
-        case SRP_TSK_MGMT:
-                srpt_handle_tsk_mgmt(ch, recv_ioctx, send_ioctx);
-                break;
-        case SRP_I_LOGOUT:
-                printk(KERN_ERR "Not yet implemented: SRP_I_LOGOUT\n");
-                break;
-        case SRP_CRED_RSP:
-                pr_debug("received SRP_CRED_RSP\n");
-                break;
-        case SRP_AER_RSP:
-                pr_debug("received SRP_AER_RSP\n");
-                break;
-        case SRP_RSP:
-                printk(KERN_ERR "Received SRP_RSP\n");
-                break;
-        default:
-                printk(KERN_ERR "received IU with unknown opcode 0x%x\n",
-                       srp_cmd->opcode);
-                break;
-        }
-
-        srpt_post_recv(ch->sport->sdev, recv_ioctx);
-out:
-        return;
-}
-
-static void srpt_process_rcv_completion(struct ib_cq *cq,
-                                        struct srpt_rdma_ch *ch,
-                                        struct ib_wc *wc)
-{
-        struct srpt_device *sdev = ch->sport->sdev;
-        struct srpt_recv_ioctx *ioctx;
-        u32 index;
-
-        index = idx_from_wr_id(wc->wr_id);
-        if (wc->status == IB_WC_SUCCESS) {
-                int req_lim;
-
-                req_lim = atomic_dec_return(&ch->req_lim);
-                if (unlikely(req_lim < 0))
-                        printk(KERN_ERR "req_lim = %d < 0\n", req_lim);
-                ioctx = sdev->ioctx_ring[index];
-                srpt_handle_new_iu(ch, ioctx, NULL);
-        } else {
-                printk(KERN_INFO "receiving failed for idx %u with status %d\n",
-                       index, wc->status);
-        }
-}
-
-/**
- * srpt_process_send_completion() - Process an IB send completion.
- *
- * Note: Although this has not yet been observed during tests, at least in
- * theory it is possible that the srpt_get_send_ioctx() call invoked by
- * srpt_handle_new_iu() fails. This is possible because the req_lim_delta
- * value in each response is set to one, and it is possible that this response
- * makes the initiator send a new request before the send completion for that
- * response has been processed. This could e.g. happen if the call to
- * srpt_put_send_iotcx() is delayed because of a higher priority interrupt or
- * if IB retransmission causes generation of the send completion to be
- * delayed. Incoming information units for which srpt_get_send_ioctx() fails
- * are queued on cmd_wait_list. The code below processes these delayed
- * requests one at a time.
- */
-static void srpt_process_send_completion(struct ib_cq *cq,
-                                         struct srpt_rdma_ch *ch,
-                                         struct ib_wc *wc)
-{
-        struct srpt_send_ioctx *send_ioctx;
-        uint32_t index;
-        enum srpt_opcode opcode;
-
-        index = idx_from_wr_id(wc->wr_id);
-        opcode = opcode_from_wr_id(wc->wr_id);
-        send_ioctx = ch->ioctx_ring[index];
-        if (wc->status == IB_WC_SUCCESS) {
-                if (opcode == SRPT_SEND)
-                        srpt_handle_send_comp(ch, send_ioctx);
-                else {
-                        WARN_ON(opcode != SRPT_RDMA_ABORT &&
-                                wc->opcode != IB_WC_RDMA_READ);
-                        srpt_handle_rdma_comp(ch, send_ioctx, opcode);
-                }
-        } else {
-                if (opcode == SRPT_SEND) {
-                        printk(KERN_INFO "sending response for idx %u failed"
-                               " with status %d\n", index, wc->status);
-                        srpt_handle_send_err_comp(ch, wc->wr_id);
-                } else if (opcode != SRPT_RDMA_MID) {
-                        printk(KERN_INFO "RDMA t %d for idx %u failed with"
-                                " status %d", opcode, index, wc->status);
-                        srpt_handle_rdma_err_comp(ch, send_ioctx, opcode);
-                }
-        }
-
-        while (unlikely(opcode == SRPT_SEND
-                        && !list_empty(&ch->cmd_wait_list)
-                        && srpt_get_ch_state(ch) == CH_LIVE
-                        && (send_ioctx = srpt_get_send_ioctx(ch)) != NULL)) {
-                struct srpt_recv_ioctx *recv_ioctx;
-
-                recv_ioctx = list_first_entry(&ch->cmd_wait_list,
-                                              struct srpt_recv_ioctx,
-                                              wait_list);
-                list_del(&recv_ioctx->wait_list);
-                srpt_handle_new_iu(ch, recv_ioctx, send_ioctx);
-        }
-}
-
-static void srpt_process_completion(struct ib_cq *cq, struct srpt_rdma_ch *ch)
-{
-        struct ib_wc *const wc = ch->wc;
-        int i, n;
-
-        WARN_ON(cq != ch->cq);
-
-        ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
-        while ((n = ib_poll_cq(cq, ARRAY_SIZE(ch->wc), wc)) > 0) {
-                for (i = 0; i < n; i++) {
-                        if (opcode_from_wr_id(wc[i].wr_id) == SRPT_RECV)
-                                srpt_process_rcv_completion(cq, ch, &wc[i]);
-                        else
-                                srpt_process_send_completion(cq, ch, &wc[i]);
-                }
-        }
-}
-
-/**
- * srpt_completion() - IB completion queue callback function.
- *
- * Notes:
- * - It is guaranteed that a completion handler will never be invoked
- *   concurrently on two different CPUs for the same completion queue. See also
- *   Documentation/infiniband/core_locking.txt and the implementation of
- *   handle_edge_irq() in kernel/irq/chip.c.
- * - When threaded IRQs are enabled, completion handlers are invoked in thread
- *   context instead of interrupt context.
- */
-static void srpt_completion(struct ib_cq *cq, void *ctx)
-{
-        struct srpt_rdma_ch *ch = ctx;
-
-        wake_up_interruptible(&ch->wait_queue);
-}
-
-static int srpt_compl_thread(void *arg)
-{
-        struct srpt_rdma_ch *ch;
-
-        /* Hibernation / freezing of the SRPT kernel thread is not supported. */
-        current->flags |= PF_NOFREEZE;
-
-        ch = arg;
-        BUG_ON(!ch);
-        printk(KERN_INFO "Session %s: kernel thread %s (PID %d) started\n",
-               ch->sess_name, ch->thread->comm, current->pid);
-        while (!kthread_should_stop()) {
-                wait_event_interruptible(ch->wait_queue,
-                        (srpt_process_completion(ch->cq, ch),
-                         kthread_should_stop()));
-        }
-        printk(KERN_INFO "Session %s: kernel thread %s (PID %d) stopped\n",
-               ch->sess_name, ch->thread->comm, current->pid);
-        return 0;
-}
-
-/**
- * srpt_create_ch_ib() - Create receive and send completion queues.
- */
-static int srpt_create_ch_ib(struct srpt_rdma_ch *ch)
-{
-        struct ib_qp_init_attr *qp_init;
-        struct srpt_port *sport = ch->sport;
-        struct srpt_device *sdev = sport->sdev;
-        u32 srp_sq_size = sport->port_attrib.srp_sq_size;
-        int ret;
-
-        WARN_ON(ch->rq_size < 1);
-
-        ret = -ENOMEM;
-        qp_init = kzalloc(sizeof *qp_init, GFP_KERNEL);
-        if (!qp_init)
-                goto out;
-
-        ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch,
-                              ch->rq_size + srp_sq_size, 0);
-        if (IS_ERR(ch->cq)) {
-                ret = PTR_ERR(ch->cq);
-                printk(KERN_ERR "failed to create CQ cqe= %d ret= %d\n",
-                       ch->rq_size + srp_sq_size, ret);
-                goto out;
-        }
-
-        qp_init->qp_context = (void *)ch;
-        qp_init->event_handler
-                = (void(*)(struct ib_event *, void*))srpt_qp_event;
-        qp_init->send_cq = ch->cq;
-        qp_init->recv_cq = ch->cq;
-        qp_init->srq = sdev->srq;
-        qp_init->sq_sig_type = IB_SIGNAL_REQ_WR;
-        qp_init->qp_type = IB_QPT_RC;
-        qp_init->cap.max_send_wr = srp_sq_size;
-        qp_init->cap.max_send_sge = SRPT_DEF_SG_PER_WQE;
-
-        ch->qp = ib_create_qp(sdev->pd, qp_init);
-        if (IS_ERR(ch->qp)) {
-                ret = PTR_ERR(ch->qp);
-                printk(KERN_ERR "failed to create_qp ret= %d\n", ret);
-                goto err_destroy_cq;
-        }
-
-        atomic_set(&ch->sq_wr_avail, qp_init->cap.max_send_wr);
-
-        pr_debug("%s: max_cqe= %d max_sge= %d sq_size = %d cm_id= %p\n",
-                 __func__, ch->cq->cqe, qp_init->cap.max_send_sge,
-                 qp_init->cap.max_send_wr, ch->cm_id);
-
-        ret = srpt_init_ch_qp(ch, ch->qp);
-        if (ret)
-                goto err_destroy_qp;
-
-        init_waitqueue_head(&ch->wait_queue);
-
-        pr_debug("creating thread for session %s\n", ch->sess_name);
-
-        ch->thread = kthread_run(srpt_compl_thread, ch, "ib_srpt_compl");
-        if (IS_ERR(ch->thread)) {
-                printk(KERN_ERR "failed to create kernel thread %ld\n",
-                       PTR_ERR(ch->thread));
-                ch->thread = NULL;
-                goto err_destroy_qp;
-        }
-
-out:
-        kfree(qp_init);
-        return ret;
-
-err_destroy_qp:
-        ib_destroy_qp(ch->qp);
-err_destroy_cq:
-        ib_destroy_cq(ch->cq);
-        goto out;
-}
-
-static void srpt_destroy_ch_ib(struct srpt_rdma_ch *ch)
-{
-        if (ch->thread)
-                kthread_stop(ch->thread);
-
-        ib_destroy_qp(ch->qp);
-        ib_destroy_cq(ch->cq);
-}
-
-/**
- * __srpt_close_ch() - Close an RDMA channel by setting the QP error state.
- *
- * Reset the QP and make sure all resources associated with the channel will
- * be deallocated at an appropriate time.
- *
- * Note: The caller must hold ch->sport->sdev->spinlock.
- */
-static void __srpt_close_ch(struct srpt_rdma_ch *ch)
-{
-        struct srpt_device *sdev;
-        enum rdma_ch_state prev_state;
-        unsigned long flags;
-
-        sdev = ch->sport->sdev;
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        prev_state = ch->state;
-        switch (prev_state) {
-        case CH_CONNECTING:
-        case CH_LIVE:
-                ch->state = CH_DISCONNECTING;
-                break;
-        default:
-                break;
-        }
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-
-        switch (prev_state) {
-        case CH_CONNECTING:
-                ib_send_cm_rej(ch->cm_id, IB_CM_REJ_NO_RESOURCES, NULL, 0,
-                               NULL, 0);
-                /* fall through */
-        case CH_LIVE:
-                if (ib_send_cm_dreq(ch->cm_id, NULL, 0) < 0)
-                        printk(KERN_ERR "sending CM DREQ failed.\n");
-                break;
-        case CH_DISCONNECTING:
-                break;
-        case CH_DRAINING:
-        case CH_RELEASING:
-                break;
-        }
-}
-
-/**
- * srpt_close_ch() - Close an RDMA channel.
- */
-static void srpt_close_ch(struct srpt_rdma_ch *ch)
-{
-        struct srpt_device *sdev;
-
-        sdev = ch->sport->sdev;
-        spin_lock_irq(&sdev->spinlock);
-        __srpt_close_ch(ch);
-        spin_unlock_irq(&sdev->spinlock);
-}
-
-/**
- * srpt_drain_channel() - Drain a channel by resetting the IB queue pair.
- * @cm_id: Pointer to the CM ID of the channel to be drained.
- *
- * Note: Must be called from inside srpt_cm_handler to avoid a race between
- * accessing sdev->spinlock and the call to kfree(sdev) in srpt_remove_one()
- * (the caller of srpt_cm_handler holds the cm_id spinlock; srpt_remove_one()
- * waits until all target sessions for the associated IB device have been
- * unregistered and target session registration involves a call to
- * ib_destroy_cm_id(), which locks the cm_id spinlock and hence waits until
- * this function has finished).
- */
-static void srpt_drain_channel(struct ib_cm_id *cm_id)
-{
-        struct srpt_device *sdev;
-        struct srpt_rdma_ch *ch;
-        int ret;
-        bool do_reset = false;
-
-        WARN_ON_ONCE(irqs_disabled());
-
-        sdev = cm_id->context;
-        BUG_ON(!sdev);
-        spin_lock_irq(&sdev->spinlock);
-        list_for_each_entry(ch, &sdev->rch_list, list) {
-                if (ch->cm_id == cm_id) {
-                        do_reset = srpt_test_and_set_ch_state(ch,
-                                        CH_CONNECTING, CH_DRAINING) ||
-                                   srpt_test_and_set_ch_state(ch,
-                                        CH_LIVE, CH_DRAINING) ||
-                                   srpt_test_and_set_ch_state(ch,
-                                        CH_DISCONNECTING, CH_DRAINING);
-                        break;
-                }
-        }
-        spin_unlock_irq(&sdev->spinlock);
-
-        if (do_reset) {
-                ret = srpt_ch_qp_err(ch);
-                if (ret < 0)
-                        printk(KERN_ERR "Setting queue pair in error state"
-                               " failed: %d\n", ret);
-        }
-}
-
-/**
- * srpt_find_channel() - Look up an RDMA channel.
- * @cm_id: Pointer to the CM ID of the channel to be looked up.
- *
- * Return NULL if no matching RDMA channel has been found.
- */
-static struct srpt_rdma_ch *srpt_find_channel(struct srpt_device *sdev,
-                                              struct ib_cm_id *cm_id)
-{
-        struct srpt_rdma_ch *ch;
-        bool found;
-
-        WARN_ON_ONCE(irqs_disabled());
-        BUG_ON(!sdev);
-
-        found = false;
-        spin_lock_irq(&sdev->spinlock);
-        list_for_each_entry(ch, &sdev->rch_list, list) {
-                if (ch->cm_id == cm_id) {
-                        found = true;
-                        break;
-                }
-        }
-        spin_unlock_irq(&sdev->spinlock);
-
-        return found ? ch : NULL;
-}
-
-/**
- * srpt_release_channel() - Release channel resources.
- *
- * Schedules the actual release because:
- * - Calling the ib_destroy_cm_id() call from inside an IB CM callback would
- *   trigger a deadlock.
- * - It is not safe to call TCM transport_* functions from interrupt context.
- */
-static void srpt_release_channel(struct srpt_rdma_ch *ch)
-{
-        schedule_work(&ch->release_work);
-}
-
-static void srpt_release_channel_work(struct work_struct *w)
-{
-        struct srpt_rdma_ch *ch;
-        struct srpt_device *sdev;
-        struct se_session *se_sess;
-
-        ch = container_of(w, struct srpt_rdma_ch, release_work);
-        pr_debug("ch = %p; ch->sess = %p; release_done = %p\n", ch, ch->sess,
-                 ch->release_done);
-
-        sdev = ch->sport->sdev;
-        BUG_ON(!sdev);
-
-        se_sess = ch->sess;
-        BUG_ON(!se_sess);
-
-        target_wait_for_sess_cmds(se_sess, 0);
-
-        transport_deregister_session_configfs(se_sess);
-        transport_deregister_session(se_sess);
-        ch->sess = NULL;
-
-        srpt_destroy_ch_ib(ch);
-
-        srpt_free_ioctx_ring((struct srpt_ioctx **)ch->ioctx_ring,
-                             ch->sport->sdev, ch->rq_size,
-                             ch->rsp_size, DMA_TO_DEVICE);
-
-        spin_lock_irq(&sdev->spinlock);
-        list_del(&ch->list);
-        spin_unlock_irq(&sdev->spinlock);
-
-        ib_destroy_cm_id(ch->cm_id);
-
-        if (ch->release_done)
-                complete(ch->release_done);
-
-        wake_up(&sdev->ch_releaseQ);
-
-        kfree(ch);
-}
-
-static struct srpt_node_acl *__srpt_lookup_acl(struct srpt_port *sport,
-                                               u8 i_port_id[16])
-{
-        struct srpt_node_acl *nacl;
-
-        list_for_each_entry(nacl, &sport->port_acl_list, list)
-                if (memcmp(nacl->i_port_id, i_port_id,
-                           sizeof(nacl->i_port_id)) == 0)
-                        return nacl;
-
-        return NULL;
-}
-
-static struct srpt_node_acl *srpt_lookup_acl(struct srpt_port *sport,
-                                             u8 i_port_id[16])
-{
-        struct srpt_node_acl *nacl;
-
-        spin_lock_irq(&sport->port_acl_lock);
-        nacl = __srpt_lookup_acl(sport, i_port_id);
-        spin_unlock_irq(&sport->port_acl_lock);
-
-        return nacl;
-}
-
-/**
- * srpt_cm_req_recv() - Process the event IB_CM_REQ_RECEIVED.
- *
- * Ownership of the cm_id is transferred to the target session if this
- * functions returns zero. Otherwise the caller remains the owner of cm_id.
- */
-static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
-                            struct ib_cm_req_event_param *param,
-                            void *private_data)
-{
-        struct srpt_device *sdev = cm_id->context;
-        struct srpt_port *sport = &sdev->port[param->port - 1];
-        struct srp_login_req *req;
-        struct srp_login_rsp *rsp;
-        struct srp_login_rej *rej;
-        struct ib_cm_rep_param *rep_param;
-        struct srpt_rdma_ch *ch, *tmp_ch;
-        struct srpt_node_acl *nacl;
-        u32 it_iu_len;
-        int i;
-        int ret = 0;
-
-        WARN_ON_ONCE(irqs_disabled());
-
-        if (WARN_ON(!sdev || !private_data))
-                return -EINVAL;
-
-        req = (struct srp_login_req *)private_data;
-
-        it_iu_len = be32_to_cpu(req->req_it_iu_len);
-
-        printk(KERN_INFO "Received SRP_LOGIN_REQ with i_port_id 0x%llx:0x%llx,"
-               " t_port_id 0x%llx:0x%llx and it_iu_len %d on port %d"
-               " (guid=0x%llx:0x%llx)\n",
-               be64_to_cpu(*(__be64 *)&req->initiator_port_id[0]),
-               be64_to_cpu(*(__be64 *)&req->initiator_port_id[8]),
-               be64_to_cpu(*(__be64 *)&req->target_port_id[0]),
-               be64_to_cpu(*(__be64 *)&req->target_port_id[8]),
-               it_iu_len,
-               param->port,
-               be64_to_cpu(*(__be64 *)&sdev->port[param->port - 1].gid.raw[0]),
-               be64_to_cpu(*(__be64 *)&sdev->port[param->port - 1].gid.raw[8]));
-
-        rsp = kzalloc(sizeof *rsp, GFP_KERNEL);
-        rej = kzalloc(sizeof *rej, GFP_KERNEL);
-        rep_param = kzalloc(sizeof *rep_param, GFP_KERNEL);
-
-        if (!rsp || !rej || !rep_param) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        if (it_iu_len > srp_max_req_size || it_iu_len < 64) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE);
-                ret = -EINVAL;
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because its"
-                       " length (%d bytes) is out of range (%d .. %d)\n",
-                       it_iu_len, 64, srp_max_req_size);
-                goto reject;
-        }
-
-        if (!sport->enabled) {
-                rej->reason = __constant_cpu_to_be32(
-                             SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
-                ret = -EINVAL;
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because the target port"
-                       " has not yet been enabled\n");
-                goto reject;
-        }
-
-        if ((req->req_flags & SRP_MTCH_ACTION) == SRP_MULTICHAN_SINGLE) {
-                rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_NO_CHAN;
-
-                spin_lock_irq(&sdev->spinlock);
-
-                list_for_each_entry_safe(ch, tmp_ch, &sdev->rch_list, list) {
-                        if (!memcmp(ch->i_port_id, req->initiator_port_id, 16)
-                            && !memcmp(ch->t_port_id, req->target_port_id, 16)
-                            && param->port == ch->sport->port
-                            && param->listen_id == ch->sport->sdev->cm_id
-                            && ch->cm_id) {
-                                enum rdma_ch_state ch_state;
-
-                                ch_state = srpt_get_ch_state(ch);
-                                if (ch_state != CH_CONNECTING
-                                    && ch_state != CH_LIVE)
-                                        continue;
-
-                                /* found an existing channel */
-                                pr_debug("Found existing channel %s"
-                                         " cm_id= %p state= %d\n",
-                                         ch->sess_name, ch->cm_id, ch_state);
-
-                                __srpt_close_ch(ch);
-
-                                rsp->rsp_flags =
-                                        SRP_LOGIN_RSP_MULTICHAN_TERMINATED;
-                        }
-                }
-
-                spin_unlock_irq(&sdev->spinlock);
-
-        } else
-                rsp->rsp_flags = SRP_LOGIN_RSP_MULTICHAN_MAINTAINED;
-
-        if (*(__be64 *)req->target_port_id != cpu_to_be64(srpt_service_guid)
-            || *(__be64 *)(req->target_port_id + 8) !=
-               cpu_to_be64(srpt_service_guid)) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL);
-                ret = -ENOMEM;
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because it"
-                       " has an invalid target port identifier.\n");
-                goto reject;
-        }
-
-        ch = kzalloc(sizeof *ch, GFP_KERNEL);
-        if (!ch) {
-                rej->reason = __constant_cpu_to_be32(
-                                        SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because no memory.\n");
-                ret = -ENOMEM;
-                goto reject;
-        }
-
-        INIT_WORK(&ch->release_work, srpt_release_channel_work);
-        memcpy(ch->i_port_id, req->initiator_port_id, 16);
-        memcpy(ch->t_port_id, req->target_port_id, 16);
-        ch->sport = &sdev->port[param->port - 1];
-        ch->cm_id = cm_id;
-        /*
-         * Avoid QUEUE_FULL conditions by limiting the number of buffers used
-         * for the SRP protocol to the command queue size.
-         */
-        ch->rq_size = SRPT_RQ_SIZE;
-        spin_lock_init(&ch->spinlock);
-        ch->state = CH_CONNECTING;
-        INIT_LIST_HEAD(&ch->cmd_wait_list);
-        ch->rsp_size = ch->sport->port_attrib.srp_max_rsp_size;
-
-        ch->ioctx_ring = (struct srpt_send_ioctx **)
-                srpt_alloc_ioctx_ring(ch->sport->sdev, ch->rq_size,
-                                      sizeof(*ch->ioctx_ring[0]),
-                                      ch->rsp_size, DMA_TO_DEVICE);
-        if (!ch->ioctx_ring)
-                goto free_ch;
-
-        INIT_LIST_HEAD(&ch->free_list);
-        for (i = 0; i < ch->rq_size; i++) {
-                ch->ioctx_ring[i]->ch = ch;
-                list_add_tail(&ch->ioctx_ring[i]->free_list, &ch->free_list);
-        }
-
-        ret = srpt_create_ch_ib(ch);
-        if (ret) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because creating"
-                       " a new RDMA channel failed.\n");
-                goto free_ring;
-        }
-
-        ret = srpt_ch_qp_rtr(ch, ch->qp);
-        if (ret) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
-                printk(KERN_ERR "rejected SRP_LOGIN_REQ because enabling"
-                       " RTR failed (error code = %d)\n", ret);
-                goto destroy_ib;
-        }
-        /*
-         * Use the initator port identifier as the session name.
-         */
-        snprintf(ch->sess_name, sizeof(ch->sess_name), "0x%016llx%016llx",
-                        be64_to_cpu(*(__be64 *)ch->i_port_id),
-                        be64_to_cpu(*(__be64 *)(ch->i_port_id + 8)));
-
-        pr_debug("registering session %s\n", ch->sess_name);
-
-        nacl = srpt_lookup_acl(sport, ch->i_port_id);
-        if (!nacl) {
-                printk(KERN_INFO "Rejected login because no ACL has been"
-                       " configured yet for initiator %s.\n", ch->sess_name);
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED);
-                goto destroy_ib;
-        }
-
-        ch->sess = transport_init_session();
-        if (IS_ERR(ch->sess)) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
-                pr_debug("Failed to create session\n");
-                goto deregister_session;
-        }
-        ch->sess->se_node_acl = &nacl->nacl;
-        transport_register_session(&sport->port_tpg_1, &nacl->nacl, ch->sess, ch);
-
-        pr_debug("Establish connection sess=%p name=%s cm_id=%p\n", ch->sess,
-                 ch->sess_name, ch->cm_id);
-
-        /* create srp_login_response */
-        rsp->opcode = SRP_LOGIN_RSP;
-        rsp->tag = req->tag;
-        rsp->max_it_iu_len = req->req_it_iu_len;
-        rsp->max_ti_iu_len = req->req_it_iu_len;
-        ch->max_ti_iu_len = it_iu_len;
-        rsp->buf_fmt = __constant_cpu_to_be16(SRP_BUF_FORMAT_DIRECT
-                                              | SRP_BUF_FORMAT_INDIRECT);
-        rsp->req_lim_delta = cpu_to_be32(ch->rq_size);
-        atomic_set(&ch->req_lim, ch->rq_size);
-        atomic_set(&ch->req_lim_delta, 0);
-
-        /* create cm reply */
-        rep_param->qp_num = ch->qp->qp_num;
-        rep_param->private_data = (void *)rsp;
-        rep_param->private_data_len = sizeof *rsp;
-        rep_param->rnr_retry_count = 7;
-        rep_param->flow_control = 1;
-        rep_param->failover_accepted = 0;
-        rep_param->srq = 1;
-        rep_param->responder_resources = 4;
-        rep_param->initiator_depth = 4;
-
-        ret = ib_send_cm_rep(cm_id, rep_param);
-        if (ret) {
-                printk(KERN_ERR "sending SRP_LOGIN_REQ response failed"
-                       " (error code = %d)\n", ret);
-                goto release_channel;
-        }
-
-        spin_lock_irq(&sdev->spinlock);
-        list_add_tail(&ch->list, &sdev->rch_list);
-        spin_unlock_irq(&sdev->spinlock);
-
-        goto out;
-
-release_channel:
-        srpt_set_ch_state(ch, CH_RELEASING);
-        transport_deregister_session_configfs(ch->sess);
-
-deregister_session:
-        transport_deregister_session(ch->sess);
-        ch->sess = NULL;
-
-destroy_ib:
-        srpt_destroy_ch_ib(ch);
-
-free_ring:
-        srpt_free_ioctx_ring((struct srpt_ioctx **)ch->ioctx_ring,
-                             ch->sport->sdev, ch->rq_size,
-                             ch->rsp_size, DMA_TO_DEVICE);
-free_ch:
-        kfree(ch);
-
-reject:
-        rej->opcode = SRP_LOGIN_REJ;
-        rej->tag = req->tag;
-        rej->buf_fmt = __constant_cpu_to_be16(SRP_BUF_FORMAT_DIRECT
-                                              | SRP_BUF_FORMAT_INDIRECT);
-
-        ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED, NULL, 0,
-                             (void *)rej, sizeof *rej);
-
-out:
-        kfree(rep_param);
-        kfree(rsp);
-        kfree(rej);
-
-        return ret;
-}
-
-static void srpt_cm_rej_recv(struct ib_cm_id *cm_id)
-{
-        printk(KERN_INFO "Received IB REJ for cm_id %p.\n", cm_id);
-        srpt_drain_channel(cm_id);
-}
-
-/**
- * srpt_cm_rtu_recv() - Process an IB_CM_RTU_RECEIVED or USER_ESTABLISHED event.
- *
- * An IB_CM_RTU_RECEIVED message indicates that the connection is established
- * and that the recipient may begin transmitting (RTU = ready to use).
- */
-static void srpt_cm_rtu_recv(struct ib_cm_id *cm_id)
-{
-        struct srpt_rdma_ch *ch;
-        int ret;
-
-        ch = srpt_find_channel(cm_id->context, cm_id);
-        BUG_ON(!ch);
-
-        if (srpt_test_and_set_ch_state(ch, CH_CONNECTING, CH_LIVE)) {
-                struct srpt_recv_ioctx *ioctx, *ioctx_tmp;
-
-                ret = srpt_ch_qp_rts(ch, ch->qp);
-
-                list_for_each_entry_safe(ioctx, ioctx_tmp, &ch->cmd_wait_list,
-                                         wait_list) {
-                        list_del(&ioctx->wait_list);
-                        srpt_handle_new_iu(ch, ioctx, NULL);
-                }
-                if (ret)
-                        srpt_close_ch(ch);
-        }
-}
-
-static void srpt_cm_timewait_exit(struct ib_cm_id *cm_id)
-{
-        printk(KERN_INFO "Received IB TimeWait exit for cm_id %p.\n", cm_id);
-        srpt_drain_channel(cm_id);
-}
-
-static void srpt_cm_rep_error(struct ib_cm_id *cm_id)
-{
-        printk(KERN_INFO "Received IB REP error for cm_id %p.\n", cm_id);
-        srpt_drain_channel(cm_id);
-}
-
-/**
- * srpt_cm_dreq_recv() - Process reception of a DREQ message.
- */
-static void srpt_cm_dreq_recv(struct ib_cm_id *cm_id)
-{
-        struct srpt_rdma_ch *ch;
-        unsigned long flags;
-        bool send_drep = false;
-
-        ch = srpt_find_channel(cm_id->context, cm_id);
-        BUG_ON(!ch);
-
-        pr_debug("cm_id= %p ch->state= %d\n", cm_id, srpt_get_ch_state(ch));
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        switch (ch->state) {
-        case CH_CONNECTING:
-        case CH_LIVE:
-                send_drep = true;
-                ch->state = CH_DISCONNECTING;
-                break;
-        case CH_DISCONNECTING:
-        case CH_DRAINING:
-        case CH_RELEASING:
-                WARN(true, "unexpected channel state %d\n", ch->state);
-                break;
-        }
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-
-        if (send_drep) {
-                if (ib_send_cm_drep(ch->cm_id, NULL, 0) < 0)
-                        printk(KERN_ERR "Sending IB DREP failed.\n");
-                printk(KERN_INFO "Received DREQ and sent DREP for session %s.\n",
-                       ch->sess_name);
-        }
-}
-
-/**
- * srpt_cm_drep_recv() - Process reception of a DREP message.
- */
-static void srpt_cm_drep_recv(struct ib_cm_id *cm_id)
-{
-        printk(KERN_INFO "Received InfiniBand DREP message for cm_id %p.\n",
-               cm_id);
-        srpt_drain_channel(cm_id);
-}
-
-/**
- * srpt_cm_handler() - IB connection manager callback function.
- *
- * A non-zero return value will cause the caller destroy the CM ID.
- *
- * Note: srpt_cm_handler() must only return a non-zero value when transferring
- * ownership of the cm_id to a channel by srpt_cm_req_recv() failed. Returning
- * a non-zero value in any other case will trigger a race with the
- * ib_destroy_cm_id() call in srpt_release_channel().
- */
-static int srpt_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
-{
-        int ret;
-
-        ret = 0;
-        switch (event->event) {
-        case IB_CM_REQ_RECEIVED:
-                ret = srpt_cm_req_recv(cm_id, &event->param.req_rcvd,
-                                       event->private_data);
-                break;
-        case IB_CM_REJ_RECEIVED:
-                srpt_cm_rej_recv(cm_id);
-                break;
-        case IB_CM_RTU_RECEIVED:
-        case IB_CM_USER_ESTABLISHED:
-                srpt_cm_rtu_recv(cm_id);
-                break;
-        case IB_CM_DREQ_RECEIVED:
-                srpt_cm_dreq_recv(cm_id);
-                break;
-        case IB_CM_DREP_RECEIVED:
-                srpt_cm_drep_recv(cm_id);
-                break;
-        case IB_CM_TIMEWAIT_EXIT:
-                srpt_cm_timewait_exit(cm_id);
-                break;
-        case IB_CM_REP_ERROR:
-                srpt_cm_rep_error(cm_id);
-                break;
-        case IB_CM_DREQ_ERROR:
-                printk(KERN_INFO "Received IB DREQ ERROR event.\n");
-                break;
-        case IB_CM_MRA_RECEIVED:
-                printk(KERN_INFO "Received IB MRA event\n");
-                break;
-        default:
-                printk(KERN_ERR "received unrecognized IB CM event %d\n",
-                       event->event);
-                break;
-        }
-
-        return ret;
-}
-
-/**
- * srpt_perform_rdmas() - Perform IB RDMA.
- *
- * Returns zero upon success or a negative number upon failure.
- */
-static int srpt_perform_rdmas(struct srpt_rdma_ch *ch,
-                              struct srpt_send_ioctx *ioctx)
-{
-        struct ib_send_wr wr;
-        struct ib_send_wr *bad_wr;
-        struct rdma_iu *riu;
-        int i;
-        int ret;
-        int sq_wr_avail;
-        enum dma_data_direction dir;
-        const int n_rdma = ioctx->n_rdma;
-
-        dir = ioctx->cmd.data_direction;
-        if (dir == DMA_TO_DEVICE) {
-                /* write */
-                ret = -ENOMEM;
-                sq_wr_avail = atomic_sub_return(n_rdma, &ch->sq_wr_avail);
-                if (sq_wr_avail < 0) {
-                        printk(KERN_WARNING "IB send queue full (needed %d)\n",
-                               n_rdma);
-                        goto out;
-                }
-        }
-
-        ioctx->rdma_aborted = false;
-        ret = 0;
-        riu = ioctx->rdma_ius;
-        memset(&wr, 0, sizeof wr);
-
-        for (i = 0; i < n_rdma; ++i, ++riu) {
-                if (dir == DMA_FROM_DEVICE) {
-                        wr.opcode = IB_WR_RDMA_WRITE;
-                        wr.wr_id = encode_wr_id(i == n_rdma - 1 ?
-                                                SRPT_RDMA_WRITE_LAST :
-                                                SRPT_RDMA_MID,
-                                                ioctx->ioctx.index);
-                } else {
-                        wr.opcode = IB_WR_RDMA_READ;
-                        wr.wr_id = encode_wr_id(i == n_rdma - 1 ?
-                                                SRPT_RDMA_READ_LAST :
-                                                SRPT_RDMA_MID,
-                                                ioctx->ioctx.index);
-                }
-                wr.next = NULL;
-                wr.wr.rdma.remote_addr = riu->raddr;
-                wr.wr.rdma.rkey = riu->rkey;
-                wr.num_sge = riu->sge_cnt;
-                wr.sg_list = riu->sge;
-
-                /* only get completion event for the last rdma write */
-                if (i == (n_rdma - 1) && dir == DMA_TO_DEVICE)
-                        wr.send_flags = IB_SEND_SIGNALED;
-
-                ret = ib_post_send(ch->qp, &wr, &bad_wr);
-                if (ret)
-                        break;
-        }
-
-        if (ret)
-                printk(KERN_ERR "%s[%d]: ib_post_send() returned %d for %d/%d",
-                                 __func__, __LINE__, ret, i, n_rdma);
-        if (ret && i > 0) {
-                wr.num_sge = 0;
-                wr.wr_id = encode_wr_id(SRPT_RDMA_ABORT, ioctx->ioctx.index);
-                wr.send_flags = IB_SEND_SIGNALED;
-                while (ch->state == CH_LIVE &&
-                        ib_post_send(ch->qp, &wr, &bad_wr) != 0) {
-                        printk(KERN_INFO "Trying to abort failed RDMA transfer [%d]",
-                                ioctx->ioctx.index);
-                        msleep(1000);
-                }
-                while (ch->state != CH_RELEASING && !ioctx->rdma_aborted) {
-                        printk(KERN_INFO "Waiting until RDMA abort finished [%d]",
-                                ioctx->ioctx.index);
-                        msleep(1000);
-                }
-        }
-out:
-        if (unlikely(dir == DMA_TO_DEVICE && ret < 0))
-                atomic_add(n_rdma, &ch->sq_wr_avail);
-        return ret;
-}
-
-/**
- * srpt_xfer_data() - Start data transfer from initiator to target.
- */
-static int srpt_xfer_data(struct srpt_rdma_ch *ch,
-                          struct srpt_send_ioctx *ioctx)
-{
-        int ret;
-
-        ret = srpt_map_sg_to_ib_sge(ch, ioctx);
-        if (ret) {
-                printk(KERN_ERR "%s[%d] ret=%d\n", __func__, __LINE__, ret);
-                goto out;
-        }
-
-        ret = srpt_perform_rdmas(ch, ioctx);
-        if (ret) {
-                if (ret == -EAGAIN || ret == -ENOMEM)
-                        printk(KERN_INFO "%s[%d] queue full -- ret=%d\n",
-                                   __func__, __LINE__, ret);
-                else
-                        printk(KERN_ERR "%s[%d] fatal error -- ret=%d\n",
-                               __func__, __LINE__, ret);
-                goto out_unmap;
-        }
-
-out:
-        return ret;
-out_unmap:
-        srpt_unmap_sg_to_ib_sge(ch, ioctx);
-        goto out;
-}
-
-static int srpt_write_pending_status(struct se_cmd *se_cmd)
-{
-        struct srpt_send_ioctx *ioctx;
-
-        ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);
-        return srpt_get_cmd_state(ioctx) == SRPT_STATE_NEED_DATA;
-}
-
-/*
- * srpt_write_pending() - Start data transfer from initiator to target (write).
- */
-static int srpt_write_pending(struct se_cmd *se_cmd)
-{
-        struct srpt_rdma_ch *ch;
-        struct srpt_send_ioctx *ioctx;
-        enum srpt_command_state new_state;
-        enum rdma_ch_state ch_state;
-        int ret;
-
-        ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);
-
-        new_state = srpt_set_cmd_state(ioctx, SRPT_STATE_NEED_DATA);
-        WARN_ON(new_state == SRPT_STATE_DONE);
-
-        ch = ioctx->ch;
-        BUG_ON(!ch);
-
-        ch_state = srpt_get_ch_state(ch);
-        switch (ch_state) {
-        case CH_CONNECTING:
-                WARN(true, "unexpected channel state %d\n", ch_state);
-                ret = -EINVAL;
-                goto out;
-        case CH_LIVE:
-                break;
-        case CH_DISCONNECTING:
-        case CH_DRAINING:
-        case CH_RELEASING:
-                pr_debug("cmd with tag %lld: channel disconnecting\n",
-                         ioctx->tag);
-                srpt_set_cmd_state(ioctx, SRPT_STATE_DATA_IN);
-                ret = -EINVAL;
-                goto out;
-        }
-        ret = srpt_xfer_data(ch, ioctx);
-
-out:
-        return ret;
-}
-
-static u8 tcm_to_srp_tsk_mgmt_status(const int tcm_mgmt_status)
-{
-        switch (tcm_mgmt_status) {
-        case TMR_FUNCTION_COMPLETE:
-                return SRP_TSK_MGMT_SUCCESS;
-        case TMR_FUNCTION_REJECTED:
-                return SRP_TSK_MGMT_FUNC_NOT_SUPP;
-        }
-        return SRP_TSK_MGMT_FAILED;
-}
-
-/**
- * srpt_queue_response() - Transmits the response to a SCSI command.
- *
- * Callback function called by the TCM core. Must not block since it can be
- * invoked on the context of the IB completion handler.
- */
-static int srpt_queue_response(struct se_cmd *cmd)
-{
-        struct srpt_rdma_ch *ch;
-        struct srpt_send_ioctx *ioctx;
-        enum srpt_command_state state;
-        unsigned long flags;
-        int ret;
-        enum dma_data_direction dir;
-        int resp_len;
-        u8 srp_tm_status;
-
-        ret = 0;
-
-        ioctx = container_of(cmd, struct srpt_send_ioctx, cmd);
-        ch = ioctx->ch;
-        BUG_ON(!ch);
-
-        spin_lock_irqsave(&ioctx->spinlock, flags);
-        state = ioctx->state;
-        switch (state) {
-        case SRPT_STATE_NEW:
-        case SRPT_STATE_DATA_IN:
-                ioctx->state = SRPT_STATE_CMD_RSP_SENT;
-                break;
-        case SRPT_STATE_MGMT:
-                ioctx->state = SRPT_STATE_MGMT_RSP_SENT;
-                break;
-        default:
-                WARN(true, "ch %p; cmd %d: unexpected command state %d\n",
-                        ch, ioctx->ioctx.index, ioctx->state);
-                break;
-        }
-        spin_unlock_irqrestore(&ioctx->spinlock, flags);
-
-        if (unlikely(transport_check_aborted_status(&ioctx->cmd, false)
-                     || WARN_ON_ONCE(state == SRPT_STATE_CMD_RSP_SENT))) {
-                atomic_inc(&ch->req_lim_delta);
-                srpt_abort_cmd(ioctx);
-                goto out;
-        }
-
-        dir = ioctx->cmd.data_direction;
-
-        /* For read commands, transfer the data to the initiator. */
-        if (dir == DMA_FROM_DEVICE && ioctx->cmd.data_length &&
-            !ioctx->queue_status_only) {
-                ret = srpt_xfer_data(ch, ioctx);
-                if (ret) {
-                        printk(KERN_ERR "xfer_data failed for tag %llu\n",
-                               ioctx->tag);
-                        goto out;
-                }
-        }
-
-        if (state != SRPT_STATE_MGMT)
-                resp_len = srpt_build_cmd_rsp(ch, ioctx, ioctx->tag,
-                                              cmd->scsi_status);
-        else {
-                srp_tm_status
-                        = tcm_to_srp_tsk_mgmt_status(cmd->se_tmr_req->response);
-                resp_len = srpt_build_tskmgmt_rsp(ch, ioctx, srp_tm_status,
-                                                 ioctx->tag);
-        }
-        ret = srpt_post_send(ch, ioctx, resp_len);
-        if (ret) {
-                printk(KERN_ERR "sending cmd response failed for tag %llu\n",
-                       ioctx->tag);
-                srpt_unmap_sg_to_ib_sge(ch, ioctx);
-                srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
-        }
-
-out:
-        return ret;
-}
-
-static int srpt_queue_status(struct se_cmd *cmd)
-{
-        struct srpt_send_ioctx *ioctx;
-
-        ioctx = container_of(cmd, struct srpt_send_ioctx, cmd);
-        BUG_ON(ioctx->sense_data != cmd->sense_buffer);
-        if (cmd->se_cmd_flags &
-            (SCF_TRANSPORT_TASK_SENSE | SCF_EMULATED_TASK_SENSE))
-                WARN_ON(cmd->scsi_status != SAM_STAT_CHECK_CONDITION);
-        ioctx->queue_status_only = true;
-        return srpt_queue_response(cmd);
-}
-
-static void srpt_refresh_port_work(struct work_struct *work)
-{
-        struct srpt_port *sport = container_of(work, struct srpt_port, work);
-
-        srpt_refresh_port(sport);
-}
-
-static int srpt_ch_list_empty(struct srpt_device *sdev)
-{
-        int res;
-
-        spin_lock_irq(&sdev->spinlock);
-        res = list_empty(&sdev->rch_list);
-        spin_unlock_irq(&sdev->spinlock);
-
-        return res;
-}
-
-/**
- * srpt_release_sdev() - Free the channel resources associated with a target.
- */
-static int srpt_release_sdev(struct srpt_device *sdev)
-{
-        struct srpt_rdma_ch *ch, *tmp_ch;
-        int res;
-
-        WARN_ON_ONCE(irqs_disabled());
-
-        BUG_ON(!sdev);
-
-        spin_lock_irq(&sdev->spinlock);
-        list_for_each_entry_safe(ch, tmp_ch, &sdev->rch_list, list)
-                __srpt_close_ch(ch);
-        spin_unlock_irq(&sdev->spinlock);
-
-        res = wait_event_interruptible(sdev->ch_releaseQ,
-                                       srpt_ch_list_empty(sdev));
-        if (res)
-                printk(KERN_ERR "%s: interrupted.\n", __func__);
-
-        return 0;
-}
-
-static struct srpt_port *__srpt_lookup_port(const char *name)
-{
-        struct ib_device *dev;
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
-        int i;
-
-        list_for_each_entry(sdev, &srpt_dev_list, list) {
-                dev = sdev->device;
-                if (!dev)
-                        continue;
-
-                for (i = 0; i < dev->phys_port_cnt; i++) {
-                        sport = &sdev->port[i];
-
-                        if (!strcmp(sport->port_guid, name))
-                                return sport;
-                }
-        }
-
-        return NULL;
-}
-
-static struct srpt_port *srpt_lookup_port(const char *name)
-{
-        struct srpt_port *sport;
-
-        spin_lock(&srpt_dev_lock);
-        sport = __srpt_lookup_port(name);
-        spin_unlock(&srpt_dev_lock);
-
-        return sport;
-}
-
-/**
- * srpt_add_one() - Infiniband device addition callback function.
- */
-static void srpt_add_one(struct ib_device *device)
-{
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
-        struct ib_srq_init_attr srq_attr;
-        int i;
-
-        pr_debug("device = %p, device->dma_ops = %p\n", device,
-                 device->dma_ops);
-
-        sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
-        if (!sdev)
-                goto err;
-
-        sdev->device = device;
-        INIT_LIST_HEAD(&sdev->rch_list);
-        init_waitqueue_head(&sdev->ch_releaseQ);
-        spin_lock_init(&sdev->spinlock);
-
-        if (ib_query_device(device, &sdev->dev_attr))
-                goto free_dev;
-
-        sdev->pd = ib_alloc_pd(device);
-        if (IS_ERR(sdev->pd))
-                goto free_dev;
-
-        sdev->mr = ib_get_dma_mr(sdev->pd, IB_ACCESS_LOCAL_WRITE);
-        if (IS_ERR(sdev->mr))
-                goto err_pd;
-
-        sdev->srq_size = min(srpt_srq_size, sdev->dev_attr.max_srq_wr);
-
-        srq_attr.event_handler = srpt_srq_event;
-        srq_attr.srq_context = (void *)sdev;
-        srq_attr.attr.max_wr = sdev->srq_size;
-        srq_attr.attr.max_sge = 1;
-        srq_attr.attr.srq_limit = 0;
-        srq_attr.srq_type = IB_SRQT_BASIC;
-
-        sdev->srq = ib_create_srq(sdev->pd, &srq_attr);
-        if (IS_ERR(sdev->srq))
-                goto err_mr;
-
-        pr_debug("%s: create SRQ #wr= %d max_allow=%d dev= %s\n",
-                 __func__, sdev->srq_size, sdev->dev_attr.max_srq_wr,
-                 device->name);
-
-        if (!srpt_service_guid)
-                srpt_service_guid = be64_to_cpu(device->node_guid);
-
-        sdev->cm_id = ib_create_cm_id(device, srpt_cm_handler, sdev);
-        if (IS_ERR(sdev->cm_id))
-                goto err_srq;
-
-        /* print out target login information */
-        pr_debug("Target login info: id_ext=%016llx,ioc_guid=%016llx,"
-                 "pkey=ffff,service_id=%016llx\n", srpt_service_guid,
-                 srpt_service_guid, srpt_service_guid);
-
-        /*
-         * We do not have a consistent service_id (ie. also id_ext of target_id)
-         * to identify this target. We currently use the guid of the first HCA
-         * in the system as service_id; therefore, the target_id will change
-         * if this HCA is gone bad and replaced by different HCA
-         */
-        if (ib_cm_listen(sdev->cm_id, cpu_to_be64(srpt_service_guid), 0, NULL))
-                goto err_cm;
-
-        INIT_IB_EVENT_HANDLER(&sdev->event_handler, sdev->device,
-                              srpt_event_handler);
-        if (ib_register_event_handler(&sdev->event_handler))
-                goto err_cm;
-
-        sdev->ioctx_ring = (struct srpt_recv_ioctx **)
-                srpt_alloc_ioctx_ring(sdev, sdev->srq_size,
-                                      sizeof(*sdev->ioctx_ring[0]),
-                                      srp_max_req_size, DMA_FROM_DEVICE);
-        if (!sdev->ioctx_ring)
-                goto err_event;
-
-        for (i = 0; i < sdev->srq_size; ++i)
-                srpt_post_recv(sdev, sdev->ioctx_ring[i]);
-
-        WARN_ON(sdev->device->phys_port_cnt > ARRAY_SIZE(sdev->port));
-
-        for (i = 1; i <= sdev->device->phys_port_cnt; i++) {
-                sport = &sdev->port[i - 1];
-                sport->sdev = sdev;
-                sport->port = i;
-                sport->port_attrib.srp_max_rdma_size = DEFAULT_MAX_RDMA_SIZE;
-                sport->port_attrib.srp_max_rsp_size = DEFAULT_MAX_RSP_SIZE;
-                sport->port_attrib.srp_sq_size = DEF_SRPT_SQ_SIZE;
-                INIT_WORK(&sport->work, srpt_refresh_port_work);
-                INIT_LIST_HEAD(&sport->port_acl_list);
-                spin_lock_init(&sport->port_acl_lock);
-
-                if (srpt_refresh_port(sport)) {
-                        printk(KERN_ERR "MAD registration failed for %s-%d.\n",
-                               srpt_sdev_name(sdev), i);
-                        goto err_ring;
-                }
-                snprintf(sport->port_guid, sizeof(sport->port_guid),
-                        "0x%016llx%016llx",
-                        be64_to_cpu(sport->gid.global.subnet_prefix),
-                        be64_to_cpu(sport->gid.global.interface_id));
-        }
-
-        spin_lock(&srpt_dev_lock);
-        list_add_tail(&sdev->list, &srpt_dev_list);
-        spin_unlock(&srpt_dev_lock);
-
-out:
-        ib_set_client_data(device, &srpt_client, sdev);
-        pr_debug("added %s.\n", device->name);
-        return;
-
-err_ring:
-        srpt_free_ioctx_ring((struct srpt_ioctx **)sdev->ioctx_ring, sdev,
-                             sdev->srq_size, srp_max_req_size,
-                             DMA_FROM_DEVICE);
-err_event:
-        ib_unregister_event_handler(&sdev->event_handler);
-err_cm:
-        ib_destroy_cm_id(sdev->cm_id);
-err_srq:
-        ib_destroy_srq(sdev->srq);
-err_mr:
-        ib_dereg_mr(sdev->mr);
-err_pd:
-        ib_dealloc_pd(sdev->pd);
-free_dev:
-        kfree(sdev);
-err:
-        sdev = NULL;
-        printk(KERN_INFO "%s(%s) failed.\n", __func__, device->name);
-        goto out;
-}
-
-/**
- * srpt_remove_one() - InfiniBand device removal callback function.
- */
-static void srpt_remove_one(struct ib_device *device)
-{
-        struct srpt_device *sdev;
-        int i;
-
-        sdev = ib_get_client_data(device, &srpt_client);
-        if (!sdev) {
-                printk(KERN_INFO "%s(%s): nothing to do.\n", __func__,
-                       device->name);
-                return;
-        }
-
-        srpt_unregister_mad_agent(sdev);
-
-        ib_unregister_event_handler(&sdev->event_handler);
-
-        /* Cancel any work queued by the just unregistered IB event handler. */
-        for (i = 0; i < sdev->device->phys_port_cnt; i++)
-                cancel_work_sync(&sdev->port[i].work);
-
-        ib_destroy_cm_id(sdev->cm_id);
-
-        /*
-         * Unregistering a target must happen after destroying sdev->cm_id
-         * such that no new SRP_LOGIN_REQ information units can arrive while
-         * destroying the target.
-         */
-        spin_lock(&srpt_dev_lock);
-        list_del(&sdev->list);
-        spin_unlock(&srpt_dev_lock);
-        srpt_release_sdev(sdev);
-
-        ib_destroy_srq(sdev->srq);
-        ib_dereg_mr(sdev->mr);
-        ib_dealloc_pd(sdev->pd);
-
-        srpt_free_ioctx_ring((struct srpt_ioctx **)sdev->ioctx_ring, sdev,
-                             sdev->srq_size, srp_max_req_size, DMA_FROM_DEVICE);
-        sdev->ioctx_ring = NULL;
-        kfree(sdev);
-}
-
-static struct ib_client srpt_client = {
-        .name = DRV_NAME,
-        .add = srpt_add_one,
-        .remove = srpt_remove_one
-};
-
-static int srpt_check_true(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static int srpt_check_false(struct se_portal_group *se_tpg)
-{
-        return 0;
-}
-
-static char *srpt_get_fabric_name(void)
-{
-        return "srpt";
-}
-
-static u8 srpt_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        return SCSI_TRANSPORTID_PROTOCOLID_SRP;
-}
-
-static char *srpt_get_fabric_wwn(struct se_portal_group *tpg)
-{
-        struct srpt_port *sport = container_of(tpg, struct srpt_port, port_tpg_1);
-
-        return sport->port_guid;
-}
-
-static u16 srpt_get_tag(struct se_portal_group *tpg)
-{
-        return 1;
-}
-
-static u32 srpt_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32 srpt_get_pr_transport_id(struct se_portal_group *se_tpg,
-                                    struct se_node_acl *se_nacl,
-                                    struct t10_pr_registration *pr_reg,
-                                    int *format_code, unsigned char *buf)
-{
-        struct srpt_node_acl *nacl;
-        struct spc_rdma_transport_id *tr_id;
-
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        tr_id = (void *)buf;
-        tr_id->protocol_identifier = SCSI_TRANSPORTID_PROTOCOLID_SRP;
-        memcpy(tr_id->i_port_id, nacl->i_port_id, sizeof(tr_id->i_port_id));
-        return sizeof(*tr_id);
-}
-
-static u32 srpt_get_pr_transport_id_len(struct se_portal_group *se_tpg,
-                                        struct se_node_acl *se_nacl,
-                                        struct t10_pr_registration *pr_reg,
-                                        int *format_code)
-{
-        *format_code = 0;
-        return sizeof(struct spc_rdma_transport_id);
-}
-
-static char *srpt_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
-                                            const char *buf, u32 *out_tid_len,
-                                            char **port_nexus_ptr)
-{
-        struct spc_rdma_transport_id *tr_id;
-
-        *port_nexus_ptr = NULL;
-        *out_tid_len = sizeof(struct spc_rdma_transport_id);
-        tr_id = (void *)buf;
-        return (char *)tr_id->i_port_id;
-}
-
-static struct se_node_acl *srpt_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct srpt_node_acl *nacl;
-
-        nacl = kzalloc(sizeof(struct srpt_node_acl), GFP_KERNEL);
-        if (!nacl) {
-                printk(KERN_ERR "Unable to allocate struct srpt_node_acl\n");
-                return NULL;
-        }
-
-        return &nacl->nacl;
-}
-
-static void srpt_release_fabric_acl(struct se_portal_group *se_tpg,
-                                    struct se_node_acl *se_nacl)
-{
-        struct srpt_node_acl *nacl;
-
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        kfree(nacl);
-}
-
-static u32 srpt_tpg_get_inst_index(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static void srpt_release_cmd(struct se_cmd *se_cmd)
-{
-        struct srpt_send_ioctx *ioctx = container_of(se_cmd,
-                                struct srpt_send_ioctx, cmd);
-        struct srpt_rdma_ch *ch = ioctx->ch;
-        unsigned long flags;
-
-        WARN_ON(ioctx->state != SRPT_STATE_DONE);
-        WARN_ON(ioctx->mapped_sg_count != 0);
-
-        if (ioctx->n_rbuf > 1) {
-                kfree(ioctx->rbufs);
-                ioctx->rbufs = NULL;
-                ioctx->n_rbuf = 0;
-        }
-
-        spin_lock_irqsave(&ch->spinlock, flags);
-        list_add(&ioctx->free_list, &ch->free_list);
-        spin_unlock_irqrestore(&ch->spinlock, flags);
-}
-
-/**
- * srpt_shutdown_session() - Whether or not a session may be shut down.
- */
-static int srpt_shutdown_session(struct se_session *se_sess)
-{
-        return true;
-}
-
-/**
- * srpt_close_session() - Forcibly close a session.
- *
- * Callback function invoked by the TCM core to clean up sessions associated
- * with a node ACL when the user invokes
- * rmdir /sys/kernel/config/target/$driver/$port/$tpg/acls/$i_port_id
- */
-static void srpt_close_session(struct se_session *se_sess)
-{
-        DECLARE_COMPLETION_ONSTACK(release_done);
-        struct srpt_rdma_ch *ch;
-        struct srpt_device *sdev;
-        int res;
-
-        ch = se_sess->fabric_sess_ptr;
-        WARN_ON(ch->sess != se_sess);
-
-        pr_debug("ch %p state %d\n", ch, srpt_get_ch_state(ch));
-
-        sdev = ch->sport->sdev;
-        spin_lock_irq(&sdev->spinlock);
-        BUG_ON(ch->release_done);
-        ch->release_done = &release_done;
-        __srpt_close_ch(ch);
-        spin_unlock_irq(&sdev->spinlock);
-
-        res = wait_for_completion_timeout(&release_done, 60 * HZ);
-        WARN_ON(res <= 0);
-}
-
-/**
- * srpt_sess_get_index() - Return the value of scsiAttIntrPortIndex (SCSI-MIB).
- *
- * A quote from RFC 4455 (SCSI-MIB) about this MIB object:
- * This object represents an arbitrary integer used to uniquely identify a
- * particular attached remote initiator port to a particular SCSI target port
- * within a particular SCSI target device within a particular SCSI instance.
- */
-static u32 srpt_sess_get_index(struct se_session *se_sess)
-{
-        return 0;
-}
-
-static void srpt_set_default_node_attrs(struct se_node_acl *nacl)
-{
-}
-
-static u32 srpt_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct srpt_send_ioctx *ioctx;
-
-        ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);
-        return ioctx->tag;
-}
-
-/* Note: only used from inside debug printk's by the TCM core. */
-static int srpt_get_tcm_cmd_state(struct se_cmd *se_cmd)
-{
-        struct srpt_send_ioctx *ioctx;
-
-        ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);
-        return srpt_get_cmd_state(ioctx);
-}
-
-/**
- * srpt_parse_i_port_id() - Parse an initiator port ID.
- * @name: ASCII representation of a 128-bit initiator port ID.
- * @i_port_id: Binary 128-bit port ID.
- */
-static int srpt_parse_i_port_id(u8 i_port_id[16], const char *name)
-{
-        const char *p;
-        unsigned len, count, leading_zero_bytes;
-        int ret, rc;
-
-        p = name;
-        if (strnicmp(p, "0x", 2) == 0)
-                p += 2;
-        ret = -EINVAL;
-        len = strlen(p);
-        if (len % 2)
-                goto out;
-        count = min(len / 2, 16U);
-        leading_zero_bytes = 16 - count;
-        memset(i_port_id, 0, leading_zero_bytes);
-        rc = hex2bin(i_port_id + leading_zero_bytes, p, count);
-        if (rc < 0)
-                pr_debug("hex2bin failed for srpt_parse_i_port_id: %d\n", rc);
-        ret = 0;
-out:
-        return ret;
-}
-
-/*
- * configfs callback function invoked for
- * mkdir /sys/kernel/config/target/$driver/$port/$tpg/acls/$i_port_id
- */
-static struct se_node_acl *srpt_make_nodeacl(struct se_portal_group *tpg,
-                                             struct config_group *group,
-                                             const char *name)
-{
-        struct srpt_port *sport = container_of(tpg, struct srpt_port, port_tpg_1);
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct srpt_node_acl *nacl;
-        int ret = 0;
-        u32 nexus_depth = 1;
-        u8 i_port_id[16];
-
-        if (srpt_parse_i_port_id(i_port_id, name) < 0) {
-                printk(KERN_ERR "invalid initiator port ID %s\n", name);
-                ret = -EINVAL;
-                goto err;
-        }
-
-        se_nacl_new = srpt_alloc_fabric_acl(tpg);
-        if (!se_nacl_new) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        /*
-         * nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a node ACL from demo mode to explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(tpg, se_nacl_new, name,
-                                                  nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                ret = PTR_ERR(se_nacl);
-                goto err;
-        }
-        /* Locate our struct srpt_node_acl and set sdev and i_port_id. */
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        memcpy(&nacl->i_port_id[0], &i_port_id[0], 16);
-        nacl->sport = sport;
-
-        spin_lock_irq(&sport->port_acl_lock);
-        list_add_tail(&nacl->list, &sport->port_acl_list);
-        spin_unlock_irq(&sport->port_acl_lock);
-
-        return se_nacl;
-err:
-        return ERR_PTR(ret);
-}
-
-/*
- * configfs callback function invoked for
- * rmdir /sys/kernel/config/target/$driver/$port/$tpg/acls/$i_port_id
- */
-static void srpt_drop_nodeacl(struct se_node_acl *se_nacl)
-{
-        struct srpt_node_acl *nacl;
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
-
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        sport = nacl->sport;
-        sdev = sport->sdev;
-        spin_lock_irq(&sport->port_acl_lock);
-        list_del(&nacl->list);
-        spin_unlock_irq(&sport->port_acl_lock);
-        core_tpg_del_initiator_node_acl(&sport->port_tpg_1, se_nacl, 1);
-        srpt_release_fabric_acl(NULL, se_nacl);
-}
-
-static ssize_t srpt_tpg_attrib_show_srp_max_rdma_size(
-        struct se_portal_group *se_tpg,
-        char *page)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-
-        return sprintf(page, "%u\n", sport->port_attrib.srp_max_rdma_size);
-}
-
-static ssize_t srpt_tpg_attrib_store_srp_max_rdma_size(
-        struct se_portal_group *se_tpg,
-        const char *page,
-        size_t count)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(page, 0, &val);
-        if (ret < 0) {
-                pr_err("strict_strtoul() failed with ret: %d\n", ret);
-                return -EINVAL;
-        }
-        if (val > MAX_SRPT_RDMA_SIZE) {
-                pr_err("val: %lu exceeds MAX_SRPT_RDMA_SIZE: %d\n", val,
-                        MAX_SRPT_RDMA_SIZE);
-                return -EINVAL;
-        }
-        if (val < DEFAULT_MAX_RDMA_SIZE) {
-                pr_err("val: %lu smaller than DEFAULT_MAX_RDMA_SIZE: %d\n",
-                        val, DEFAULT_MAX_RDMA_SIZE);
-                return -EINVAL;
-        }
-        sport->port_attrib.srp_max_rdma_size = val;
-
-        return count;
-}
-
-TF_TPG_ATTRIB_ATTR(srpt, srp_max_rdma_size, S_IRUGO | S_IWUSR);
-
-static ssize_t srpt_tpg_attrib_show_srp_max_rsp_size(
-        struct se_portal_group *se_tpg,
-        char *page)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-
-        return sprintf(page, "%u\n", sport->port_attrib.srp_max_rsp_size);
-}
-
-static ssize_t srpt_tpg_attrib_store_srp_max_rsp_size(
-        struct se_portal_group *se_tpg,
-        const char *page,
-        size_t count)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(page, 0, &val);
-        if (ret < 0) {
-                pr_err("strict_strtoul() failed with ret: %d\n", ret);
-                return -EINVAL;
-        }
-        if (val > MAX_SRPT_RSP_SIZE) {
-                pr_err("val: %lu exceeds MAX_SRPT_RSP_SIZE: %d\n", val,
-                        MAX_SRPT_RSP_SIZE);
-                return -EINVAL;
-        }
-        if (val < MIN_MAX_RSP_SIZE) {
-                pr_err("val: %lu smaller than MIN_MAX_RSP_SIZE: %d\n", val,
-                        MIN_MAX_RSP_SIZE);
-                return -EINVAL;
-        }
-        sport->port_attrib.srp_max_rsp_size = val;
-
-        return count;
-}
-
-TF_TPG_ATTRIB_ATTR(srpt, srp_max_rsp_size, S_IRUGO | S_IWUSR);
-
-static ssize_t srpt_tpg_attrib_show_srp_sq_size(
-        struct se_portal_group *se_tpg,
-        char *page)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-
-        return sprintf(page, "%u\n", sport->port_attrib.srp_sq_size);
-}
-
-static ssize_t srpt_tpg_attrib_store_srp_sq_size(
-        struct se_portal_group *se_tpg,
-        const char *page,
-        size_t count)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(page, 0, &val);
-        if (ret < 0) {
-                pr_err("strict_strtoul() failed with ret: %d\n", ret);
-                return -EINVAL;
-        }
-        if (val > MAX_SRPT_SRQ_SIZE) {
-                pr_err("val: %lu exceeds MAX_SRPT_SRQ_SIZE: %d\n", val,
-                        MAX_SRPT_SRQ_SIZE);
-                return -EINVAL;
-        }
-        if (val < MIN_SRPT_SRQ_SIZE) {
-                pr_err("val: %lu smaller than MIN_SRPT_SRQ_SIZE: %d\n", val,
-                        MIN_SRPT_SRQ_SIZE);
-                return -EINVAL;
-        }
-        sport->port_attrib.srp_sq_size = val;
-
-        return count;
-}
-
-TF_TPG_ATTRIB_ATTR(srpt, srp_sq_size, S_IRUGO | S_IWUSR);
-
-static struct configfs_attribute *srpt_tpg_attrib_attrs[] = {
-        &srpt_tpg_attrib_srp_max_rdma_size.attr,
-        &srpt_tpg_attrib_srp_max_rsp_size.attr,
-        &srpt_tpg_attrib_srp_sq_size.attr,
-        NULL,
-};
-
-static ssize_t srpt_tpg_show_enable(
-        struct se_portal_group *se_tpg,
-        char *page)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-
-        return snprintf(page, PAGE_SIZE, "%d\n", (sport->enabled) ? 1: 0);
-}
-
-static ssize_t srpt_tpg_store_enable(
-        struct se_portal_group *se_tpg,
-        const char *page,
-        size_t count)
-{
-        struct srpt_port *sport = container_of(se_tpg, struct srpt_port, port_tpg_1);
-        unsigned long tmp;
-        int ret;
-
-        ret = strict_strtoul(page, 0, &tmp);
-        if (ret < 0) {
-                printk(KERN_ERR "Unable to extract srpt_tpg_store_enable\n");
-                return -EINVAL;
-        }
-
-        if ((tmp != 0) && (tmp != 1)) {
-                printk(KERN_ERR "Illegal value for srpt_tpg_store_enable: %lu\n", tmp);
-                return -EINVAL;
-        }
-        if (tmp == 1)
-                sport->enabled = true;
-        else
-                sport->enabled = false;
-
-        return count;
-}
-
-TF_TPG_BASE_ATTR(srpt, enable, S_IRUGO | S_IWUSR);
-
-static struct configfs_attribute *srpt_tpg_attrs[] = {
-        &srpt_tpg_enable.attr,
-        NULL,
-};
-
-/**
- * configfs callback invoked for
- * mkdir /sys/kernel/config/target/$driver/$port/$tpg
- */
-static struct se_portal_group *srpt_make_tpg(struct se_wwn *wwn,
-                                             struct config_group *group,
-                                             const char *name)
-{
-        struct srpt_port *sport = container_of(wwn, struct srpt_port, port_wwn);
-        int res;
-
-        /* Initialize sport->port_wwn and sport->port_tpg_1 */
-        res = core_tpg_register(&srpt_target->tf_ops, &sport->port_wwn,
-                        &sport->port_tpg_1, sport, TRANSPORT_TPG_TYPE_NORMAL);
-        if (res)
-                return ERR_PTR(res);
-
-        return &sport->port_tpg_1;
-}
-
-/**
- * configfs callback invoked for
- * rmdir /sys/kernel/config/target/$driver/$port/$tpg
- */
-static void srpt_drop_tpg(struct se_portal_group *tpg)
-{
-        struct srpt_port *sport = container_of(tpg,
-                                struct srpt_port, port_tpg_1);
-
-        sport->enabled = false;
-        core_tpg_deregister(&sport->port_tpg_1);
-}
-
-/**
- * configfs callback invoked for
- * mkdir /sys/kernel/config/target/$driver/$port
- */
-static struct se_wwn *srpt_make_tport(struct target_fabric_configfs *tf,
-                                      struct config_group *group,
-                                      const char *name)
-{
-        struct srpt_port *sport;
-        int ret;
-
-        sport = srpt_lookup_port(name);
-        pr_debug("make_tport(%s)\n", name);
-        ret = -EINVAL;
-        if (!sport)
-                goto err;
-
-        return &sport->port_wwn;
-
-err:
-        return ERR_PTR(ret);
-}
-
-/**
- * configfs callback invoked for
- * rmdir /sys/kernel/config/target/$driver/$port
- */
-static void srpt_drop_tport(struct se_wwn *wwn)
-{
-        struct srpt_port *sport = container_of(wwn, struct srpt_port, port_wwn);
-
-        pr_debug("drop_tport(%s\n", config_item_name(&sport->port_wwn.wwn_group.cg_item));
-}
-
-static ssize_t srpt_wwn_show_attr_version(struct target_fabric_configfs *tf,
-                                              char *buf)
-{
-        return scnprintf(buf, PAGE_SIZE, "%s\n", DRV_VERSION);
-}
-
-TF_WWN_ATTR_RO(srpt, version);
-
-static struct configfs_attribute *srpt_wwn_attrs[] = {
-        &srpt_wwn_version.attr,
-        NULL,
-};
-
-static struct target_core_fabric_ops srpt_template = {
-        .get_fabric_name                = srpt_get_fabric_name,
-        .get_fabric_proto_ident         = srpt_get_fabric_proto_ident,
-        .tpg_get_wwn                    = srpt_get_fabric_wwn,
-        .tpg_get_tag                    = srpt_get_tag,
-        .tpg_get_default_depth          = srpt_get_default_depth,
-        .tpg_get_pr_transport_id        = srpt_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = srpt_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = srpt_parse_pr_out_transport_id,
-        .tpg_check_demo_mode            = srpt_check_false,
-        .tpg_check_demo_mode_cache      = srpt_check_true,
-        .tpg_check_demo_mode_write_protect = srpt_check_true,
-        .tpg_check_prod_mode_write_protect = srpt_check_false,
-        .tpg_alloc_fabric_acl           = srpt_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = srpt_release_fabric_acl,
-        .tpg_get_inst_index             = srpt_tpg_get_inst_index,
-        .release_cmd                    = srpt_release_cmd,
-        .check_stop_free                = srpt_check_stop_free,
-        .shutdown_session               = srpt_shutdown_session,
-        .close_session                  = srpt_close_session,
-        .sess_get_index                 = srpt_sess_get_index,
-        .sess_get_initiator_sid         = NULL,
-        .write_pending                  = srpt_write_pending,
-        .write_pending_status           = srpt_write_pending_status,
-        .set_default_node_attributes    = srpt_set_default_node_attrs,
-        .get_task_tag                   = srpt_get_task_tag,
-        .get_cmd_state                  = srpt_get_tcm_cmd_state,
-        .queue_data_in                  = srpt_queue_response,
-        .queue_status                   = srpt_queue_status,
-        .queue_tm_rsp                   = srpt_queue_response,
-        /*
-         * Setup function pointers for generic logic in
-         * target_core_fabric_configfs.c
-         */
-        .fabric_make_wwn                = srpt_make_tport,
-        .fabric_drop_wwn                = srpt_drop_tport,
-        .fabric_make_tpg                = srpt_make_tpg,
-        .fabric_drop_tpg                = srpt_drop_tpg,
-        .fabric_post_link               = NULL,
-        .fabric_pre_unlink              = NULL,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = srpt_make_nodeacl,
-        .fabric_drop_nodeacl            = srpt_drop_nodeacl,
-};
-
-/**
- * srpt_init_module() - Kernel module initialization.
- *
- * Note: Since ib_register_client() registers callback functions, and since at
- * least one of these callback functions (srpt_add_one()) calls target core
- * functions, this driver must be registered with the target core before
- * ib_register_client() is called.
- */
-static int __init srpt_init_module(void)
-{
-        int ret;
-
-        ret = -EINVAL;
-        if (srp_max_req_size < MIN_MAX_REQ_SIZE) {
-                printk(KERN_ERR "invalid value %d for kernel module parameter"
-                       " srp_max_req_size -- must be at least %d.\n",
-                       srp_max_req_size, MIN_MAX_REQ_SIZE);
-                goto out;
-        }
-
-        if (srpt_srq_size < MIN_SRPT_SRQ_SIZE
-            || srpt_srq_size > MAX_SRPT_SRQ_SIZE) {
-                printk(KERN_ERR "invalid value %d for kernel module parameter"
-                       " srpt_srq_size -- must be in the range [%d..%d].\n",
-                       srpt_srq_size, MIN_SRPT_SRQ_SIZE, MAX_SRPT_SRQ_SIZE);
-                goto out;
-        }
-
-        srpt_target = target_fabric_configfs_init(THIS_MODULE, "srpt");
-        if (IS_ERR(srpt_target)) {
-                printk(KERN_ERR "couldn't register\n");
-                ret = PTR_ERR(srpt_target);
-                goto out;
-        }
-
-        srpt_target->tf_ops = srpt_template;
-
-        /*
-         * Set up default attribute lists.
-         */
-        srpt_target->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = srpt_wwn_attrs;
-        srpt_target->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = srpt_tpg_attrs;
-        srpt_target->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = srpt_tpg_attrib_attrs;
-        srpt_target->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = NULL;
-        srpt_target->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = NULL;
-        srpt_target->tf_cit_tmpl.tfc_tpg_nacl_base_cit.ct_attrs = NULL;
-        srpt_target->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
-        srpt_target->tf_cit_tmpl.tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
-        srpt_target->tf_cit_tmpl.tfc_tpg_nacl_param_cit.ct_attrs = NULL;
-
-        ret = target_fabric_configfs_register(srpt_target);
-        if (ret < 0) {
-                printk(KERN_ERR "couldn't register\n");
-                goto out_free_target;
-        }
-
-        ret = ib_register_client(&srpt_client);
-        if (ret) {
-                printk(KERN_ERR "couldn't register IB client\n");
-                goto out_unregister_target;
-        }
-
-        return 0;
-
-out_unregister_target:
-        target_fabric_configfs_deregister(srpt_target);
-        srpt_target = NULL;
-out_free_target:
-        if (srpt_target)
-                target_fabric_configfs_free(srpt_target);
-out:
-        return ret;
-}
-
-static void __exit srpt_cleanup_module(void)
-{
-        ib_unregister_client(&srpt_client);
-        target_fabric_configfs_deregister(srpt_target);
-        srpt_target = NULL;
-}
-
-module_init(srpt_init_module);
-module_exit(srpt_cleanup_module);
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
deleted file mode 100644
index 4caf55cda7b..00000000000
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
- * Copyright (c) 2006 - 2009 Mellanox Technology Inc.  All rights reserved.
- * Copyright (C) 2009 - 2010 Bart Van Assche <bvanassche@acm.org>.
- *
- * 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.
- *
- */
-
-#ifndef IB_SRPT_H
-#define IB_SRPT_H
-
-#include <linux/types.h>
-#include <linux/list.h>
-#include <linux/wait.h>
-
-#include <rdma/ib_verbs.h>
-#include <rdma/ib_sa.h>
-#include <rdma/ib_cm.h>
-
-#include <scsi/srp.h>
-
-#include "ib_dm_mad.h"
-
-/*
- * The prefix the ServiceName field must start with in the device management
- * ServiceEntries attribute pair. See also the SRP specification.
- */
-#define SRP_SERVICE_NAME_PREFIX         "SRP.T10:"
-
-enum {
-        /*
-         * SRP IOControllerProfile attributes for SRP target ports that have
-         * not been defined in <scsi/srp.h>. Source: section B.7, table B.7
-         * in the SRP specification.
-         */
-        SRP_PROTOCOL = 0x0108,
-        SRP_PROTOCOL_VERSION = 0x0001,
-        SRP_IO_SUBCLASS = 0x609e,
-        SRP_SEND_TO_IOC = 0x01,
-        SRP_SEND_FROM_IOC = 0x02,
-        SRP_RDMA_READ_FROM_IOC = 0x08,
-        SRP_RDMA_WRITE_FROM_IOC = 0x20,
-
-        /*
-         * srp_login_cmd.req_flags bitmasks. See also table 9 in the SRP
-         * specification.
-         */
-        SRP_MTCH_ACTION = 0x03, /* MULTI-CHANNEL ACTION */
-        SRP_LOSOLNT = 0x10, /* logout solicited notification */
-        SRP_CRSOLNT = 0x20, /* credit request solicited notification */
-        SRP_AESOLNT = 0x40, /* asynchronous event solicited notification */
-
-        /*
-         * srp_cmd.sol_nt / srp_tsk_mgmt.sol_not bitmasks. See also tables
-         * 18 and 20 in the SRP specification.
-         */
-        SRP_SCSOLNT = 0x02, /* SCSOLNT = successful solicited notification */
-        SRP_UCSOLNT = 0x04, /* UCSOLNT = unsuccessful solicited notification */
-
-        /*
-         * srp_rsp.sol_not / srp_t_logout.sol_not bitmasks. See also tables
-         * 16 and 22 in the SRP specification.
-         */
-        SRP_SOLNT = 0x01, /* SOLNT = solicited notification */
-
-        /* See also table 24 in the SRP specification. */
-        SRP_TSK_MGMT_SUCCESS = 0x00,
-        SRP_TSK_MGMT_FUNC_NOT_SUPP = 0x04,
-        SRP_TSK_MGMT_FAILED = 0x05,
-
-        /* See also table 21 in the SRP specification. */
-        SRP_CMD_SIMPLE_Q = 0x0,
-        SRP_CMD_HEAD_OF_Q = 0x1,
-        SRP_CMD_ORDERED_Q = 0x2,
-        SRP_CMD_ACA = 0x4,
-
-        SRP_LOGIN_RSP_MULTICHAN_NO_CHAN = 0x0,
-        SRP_LOGIN_RSP_MULTICHAN_TERMINATED = 0x1,
-        SRP_LOGIN_RSP_MULTICHAN_MAINTAINED = 0x2,
-
-        SRPT_DEF_SG_TABLESIZE = 128,
-        SRPT_DEF_SG_PER_WQE = 16,
-
-        MIN_SRPT_SQ_SIZE = 16,
-        DEF_SRPT_SQ_SIZE = 4096,
-        SRPT_RQ_SIZE = 128,
-        MIN_SRPT_SRQ_SIZE = 4,
-        DEFAULT_SRPT_SRQ_SIZE = 4095,
-        MAX_SRPT_SRQ_SIZE = 65535,
-        MAX_SRPT_RDMA_SIZE = 1U << 24,
-        MAX_SRPT_RSP_SIZE = 1024,
-
-        MIN_MAX_REQ_SIZE = 996,
-        DEFAULT_MAX_REQ_SIZE
-                = sizeof(struct srp_cmd)/*48*/
-                + sizeof(struct srp_indirect_buf)/*20*/
-                + 128 * sizeof(struct srp_direct_buf)/*16*/,
-
-        MIN_MAX_RSP_SIZE = sizeof(struct srp_rsp)/*36*/ + 4,
-        DEFAULT_MAX_RSP_SIZE = 256, /* leaves 220 bytes for sense data */
-
-        DEFAULT_MAX_RDMA_SIZE = 65536,
-};
-
-enum srpt_opcode {
-        SRPT_RECV,
-        SRPT_SEND,
-        SRPT_RDMA_MID,
-        SRPT_RDMA_ABORT,
-        SRPT_RDMA_READ_LAST,
-        SRPT_RDMA_WRITE_LAST,
-};
-
-static inline u64 encode_wr_id(u8 opcode, u32 idx)
-{
-        return ((u64)opcode << 32) | idx;
-}
-static inline enum srpt_opcode opcode_from_wr_id(u64 wr_id)
-{
-        return wr_id >> 32;
-}
-static inline u32 idx_from_wr_id(u64 wr_id)
-{
-        return (u32)wr_id;
-}
-
-struct rdma_iu {
-        u64             raddr;
-        u32             rkey;
-        struct ib_sge   *sge;
-        u32             sge_cnt;
-        int             mem_id;
-};
-
-/**
- * enum srpt_command_state - SCSI command state managed by SRPT.
- * @SRPT_STATE_NEW:           New command arrived and is being processed.
- * @SRPT_STATE_NEED_DATA:     Processing a write or bidir command and waiting
- *                            for data arrival.
- * @SRPT_STATE_DATA_IN:       Data for the write or bidir command arrived and is
- *                            being processed.
- * @SRPT_STATE_CMD_RSP_SENT:  SRP_RSP for SRP_CMD has been sent.
- * @SRPT_STATE_MGMT:          Processing a SCSI task management command.
- * @SRPT_STATE_MGMT_RSP_SENT: SRP_RSP for SRP_TSK_MGMT has been sent.
- * @SRPT_STATE_DONE:          Command processing finished successfully, command
- *                            processing has been aborted or command processing
- *                            failed.
- */
-enum srpt_command_state {
-        SRPT_STATE_NEW           = 0,
-        SRPT_STATE_NEED_DATA     = 1,
-        SRPT_STATE_DATA_IN       = 2,
-        SRPT_STATE_CMD_RSP_SENT  = 3,
-        SRPT_STATE_MGMT          = 4,
-        SRPT_STATE_MGMT_RSP_SENT = 5,
-        SRPT_STATE_DONE          = 6,
-};
-
-/**
- * struct srpt_ioctx - Shared SRPT I/O context information.
- * @buf:   Pointer to the buffer.
- * @dma:   DMA address of the buffer.
- * @index: Index of the I/O context in its ioctx_ring array.
- */
-struct srpt_ioctx {
-        void                    *buf;
-        dma_addr_t              dma;
-        uint32_t                index;
-};
-
-/**
- * struct srpt_recv_ioctx - SRPT receive I/O context.
- * @ioctx:     See above.
- * @wait_list: Node for insertion in srpt_rdma_ch.cmd_wait_list.
- */
-struct srpt_recv_ioctx {
-        struct srpt_ioctx       ioctx;
-        struct list_head        wait_list;
-};
-
-/**
- * struct srpt_send_ioctx - SRPT send I/O context.
- * @ioctx:       See above.
- * @ch:          Channel pointer.
- * @free_list:   Node in srpt_rdma_ch.free_list.
- * @n_rbuf:      Number of data buffers in the received SRP command.
- * @rbufs:       Pointer to SRP data buffer array.
- * @single_rbuf: SRP data buffer if the command has only a single buffer.
- * @sg:          Pointer to sg-list associated with this I/O context.
- * @sg_cnt:      SG-list size.
- * @mapped_sg_count: ib_dma_map_sg() return value.
- * @n_rdma_ius:  Number of elements in the rdma_ius array.
- * @rdma_ius:    Array with information about the RDMA mapping.
- * @tag:         Tag of the received SRP information unit.
- * @spinlock:    Protects 'state'.
- * @state:       I/O context state.
- * @rdma_aborted: If initiating a multipart RDMA transfer failed, whether
- *               the already initiated transfers have finished.
- * @cmd:         Target core command data structure.
- * @sense_data:  SCSI sense data.
- */
-struct srpt_send_ioctx {
-        struct srpt_ioctx       ioctx;
-        struct srpt_rdma_ch     *ch;
-        struct rdma_iu          *rdma_ius;
-        struct srp_direct_buf   *rbufs;
-        struct srp_direct_buf   single_rbuf;
-        struct scatterlist      *sg;
-        struct list_head        free_list;
-        spinlock_t              spinlock;
-        enum srpt_command_state state;
-        bool                    rdma_aborted;
-        struct se_cmd           cmd;
-        struct completion       tx_done;
-        u64                     tag;
-        int                     sg_cnt;
-        int                     mapped_sg_count;
-        u16                     n_rdma_ius;
-        u8                      n_rdma;
-        u8                      n_rbuf;
-        bool                    queue_status_only;
-        u8                      sense_data[SCSI_SENSE_BUFFERSIZE];
-};
-
-/**
- * enum rdma_ch_state - SRP channel state.
- * @CH_CONNECTING:       QP is in RTR state; waiting for RTU.
- * @CH_LIVE:             QP is in RTS state.
- * @CH_DISCONNECTING:    DREQ has been received; waiting for DREP
- *                       or DREQ has been send and waiting for DREP
- *                       or .
- * @CH_DRAINING:         QP is in ERR state; waiting for last WQE event.
- * @CH_RELEASING:        Last WQE event has been received; releasing resources.
- */
-enum rdma_ch_state {
-        CH_CONNECTING,
-        CH_LIVE,
-        CH_DISCONNECTING,
-        CH_DRAINING,
-        CH_RELEASING
-};
-
-/**
- * struct srpt_rdma_ch - RDMA channel.
- * @wait_queue:    Allows the kernel thread to wait for more work.
- * @thread:        Kernel thread that processes the IB queues associated with
- *                 the channel.
- * @cm_id:         IB CM ID associated with the channel.
- * @qp:            IB queue pair used for communicating over this channel.
- * @cq:            IB completion queue for this channel.
- * @rq_size:       IB receive queue size.
- * @rsp_size       IB response message size in bytes.
- * @sq_wr_avail:   number of work requests available in the send queue.
- * @sport:         pointer to the information of the HCA port used by this
- *                 channel.
- * @i_port_id:     128-bit initiator port identifier copied from SRP_LOGIN_REQ.
- * @t_port_id:     128-bit target port identifier copied from SRP_LOGIN_REQ.
- * @max_ti_iu_len: maximum target-to-initiator information unit length.
- * @req_lim:       request limit: maximum number of requests that may be sent
- *                 by the initiator without having received a response.
- * @req_lim_delta: Number of credits not yet sent back to the initiator.
- * @spinlock:      Protects free_list and state.
- * @free_list:     Head of list with free send I/O contexts.
- * @state:         channel state. See also enum rdma_ch_state.
- * @ioctx_ring:    Send ring.
- * @wc:            IB work completion array for srpt_process_completion().
- * @list:          Node for insertion in the srpt_device.rch_list list.
- * @cmd_wait_list: List of SCSI commands that arrived before the RTU event. This
- *                 list contains struct srpt_ioctx elements and is protected
- *                 against concurrent modification by the cm_id spinlock.
- * @sess:          Session information associated with this SRP channel.
- * @sess_name:     Session name.
- * @release_work:  Allows scheduling of srpt_release_channel().
- * @release_done:  Enables waiting for srpt_release_channel() completion.
- */
-struct srpt_rdma_ch {
-        wait_queue_head_t       wait_queue;
-        struct task_struct      *thread;
-        struct ib_cm_id         *cm_id;
-        struct ib_qp            *qp;
-        struct ib_cq            *cq;
-        int                     rq_size;
-        u32                     rsp_size;
-        atomic_t                sq_wr_avail;
-        struct srpt_port        *sport;
-        u8                      i_port_id[16];
-        u8                      t_port_id[16];
-        int                     max_ti_iu_len;
-        atomic_t                req_lim;
-        atomic_t                req_lim_delta;
-        spinlock_t              spinlock;
-        struct list_head        free_list;
-        enum rdma_ch_state      state;
-        struct srpt_send_ioctx  **ioctx_ring;
-        struct ib_wc            wc[16];
-        struct list_head        list;
-        struct list_head        cmd_wait_list;
-        struct se_session       *sess;
-        u8                      sess_name[36];
-        struct work_struct      release_work;
-        struct completion       *release_done;
-};
-
-/**
- * struct srpt_port_attib - Attributes for SRPT port
- * @srp_max_rdma_size: Maximum size of SRP RDMA transfers for new connections.
- * @srp_max_rsp_size: Maximum size of SRP response messages in bytes.
- * @srp_sq_size: Shared receive queue (SRQ) size.
- */
-struct srpt_port_attrib {
-        u32                     srp_max_rdma_size;
-        u32                     srp_max_rsp_size;
-        u32                     srp_sq_size;
-};
-
-/**
- * struct srpt_port - Information associated by SRPT with a single IB port.
- * @sdev:      backpointer to the HCA information.
- * @mad_agent: per-port management datagram processing information.
- * @enabled:   Whether or not this target port is enabled.
- * @port_guid: ASCII representation of Port GUID
- * @port:      one-based port number.
- * @sm_lid:    cached value of the port's sm_lid.
- * @lid:       cached value of the port's lid.
- * @gid:       cached value of the port's gid.
- * @port_acl_lock spinlock for port_acl_list:
- * @work:      work structure for refreshing the aforementioned cached values.
- * @port_tpg_1 Target portal group = 1 data.
- * @port_wwn:  Target core WWN data.
- * @port_acl_list: Head of the list with all node ACLs for this port.
- */
-struct srpt_port {
-        struct srpt_device      *sdev;
-        struct ib_mad_agent     *mad_agent;
-        bool                    enabled;
-        u8                      port_guid[64];
-        u8                      port;
-        u16                     sm_lid;
-        u16                     lid;
-        union ib_gid            gid;
-        spinlock_t              port_acl_lock;
-        struct work_struct      work;
-        struct se_portal_group  port_tpg_1;
-        struct se_wwn           port_wwn;
-        struct list_head        port_acl_list;
-        struct srpt_port_attrib port_attrib;
-};
-
-/**
- * struct srpt_device - Information associated by SRPT with a single HCA.
- * @device:        Backpointer to the struct ib_device managed by the IB core.
- * @pd:            IB protection domain.
- * @mr:            L_Key (local key) with write access to all local memory.
- * @srq:           Per-HCA SRQ (shared receive queue).
- * @cm_id:         Connection identifier.
- * @dev_attr:      Attributes of the InfiniBand device as obtained during the
- *                 ib_client.add() callback.
- * @srq_size:      SRQ size.
- * @ioctx_ring:    Per-HCA SRQ.
- * @rch_list:      Per-device channel list -- see also srpt_rdma_ch.list.
- * @ch_releaseQ:   Enables waiting for removal from rch_list.
- * @spinlock:      Protects rch_list and tpg.
- * @port:          Information about the ports owned by this HCA.
- * @event_handler: Per-HCA asynchronous IB event handler.
- * @list:          Node in srpt_dev_list.
- */
-struct srpt_device {
-        struct ib_device        *device;
-        struct ib_pd            *pd;
-        struct ib_mr            *mr;
-        struct ib_srq           *srq;
-        struct ib_cm_id         *cm_id;
-        struct ib_device_attr   dev_attr;
-        int                     srq_size;
-        struct srpt_recv_ioctx  **ioctx_ring;
-        struct list_head        rch_list;
-        wait_queue_head_t       ch_releaseQ;
-        spinlock_t              spinlock;
-        struct srpt_port        port[2];
-        struct ib_event_handler event_handler;
-        struct list_head        list;
-};
-
-/**
- * struct srpt_node_acl - Per-initiator ACL data (managed via configfs).
- * @i_port_id: 128-bit SRP initiator port ID.
- * @sport:     port information.
- * @nacl:      Target core node ACL information.
- * @list:      Element of the per-HCA ACL list.
- */
-struct srpt_node_acl {
-        u8                      i_port_id[16];
-        struct srpt_port        *sport;
-        struct se_node_acl      nacl;
-        struct list_head        list;
-};
-
-/*
- * SRP-releated SCSI persistent reservation definitions.
- *
- * See also SPC4r28, section 7.6.1 (Protocol specific parameters introduction).
- * See also SPC4r28, section 7.6.4.5 (TransportID for initiator ports using
- * SCSI over an RDMA interface).
- */
-
-enum {
-        SCSI_TRANSPORTID_PROTOCOLID_SRP = 4,
-};
-
-struct spc_rdma_transport_id {
-        uint8_t protocol_identifier;
-        uint8_t reserved[7];
-        uint8_t i_port_id[16];
-};
-
-#endif                          /* IB_SRPT_H */