Merge branch 'for-4.3/gembird' into for-linus

104 files changed, 3806 insertions, 2091 deletions

diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c
index 38339d220d7f..746cdf56bc76 100644
--- a/drivers/infiniband/core/addr.c
+++ b/drivers/infiniband/core/addr.c
@@ -457,8 +457,8 @@ static void resolve_cb(int status, struct sockaddr *src_addr,
         complete(&((struct resolve_cb_context *)context)->comp);
 }
 
-int rdma_addr_find_dmac_by_grh(union ib_gid *sgid, union ib_gid *dgid, u8 *dmac,
-                               u16 *vlan_id)
+int rdma_addr_find_dmac_by_grh(const union ib_gid *sgid, const union ib_gid *dgid,
+                               u8 *dmac, u16 *vlan_id)
 {
         int ret = 0;
         struct rdma_dev_addr dev_addr;
diff --git a/drivers/infiniband/core/agent.c b/drivers/infiniband/core/agent.c
index f6d29614cb01..0429040304fd 100644
--- a/drivers/infiniband/core/agent.c
+++ b/drivers/infiniband/core/agent.c
@@ -54,7 +54,7 @@ static DEFINE_SPINLOCK(ib_agent_port_list_lock);
 static LIST_HEAD(ib_agent_port_list);
 
 static struct ib_agent_port_private *
-__ib_get_agent_port(struct ib_device *device, int port_num)
+__ib_get_agent_port(const struct ib_device *device, int port_num)
 {
         struct ib_agent_port_private *entry;
 
@@ -67,7 +67,7 @@ __ib_get_agent_port(struct ib_device *device, int port_num)
 }
 
 static struct ib_agent_port_private *
-ib_get_agent_port(struct ib_device *device, int port_num)
+ib_get_agent_port(const struct ib_device *device, int port_num)
 {
         struct ib_agent_port_private *entry;
         unsigned long flags;
@@ -78,9 +78,9 @@ ib_get_agent_port(struct ib_device *device, int port_num)
         return entry;
 }
 
-void agent_send_response(struct ib_mad *mad, struct ib_grh *grh,
-                         struct ib_wc *wc, struct ib_device *device,
-                         int port_num, int qpn)
+void agent_send_response(const struct ib_mad_hdr *mad_hdr, const struct ib_grh *grh,
+                         const struct ib_wc *wc, const struct ib_device *device,
+                         int port_num, int qpn, size_t resp_mad_len, bool opa)
 {
         struct ib_agent_port_private *port_priv;
         struct ib_mad_agent *agent;
@@ -88,7 +88,7 @@ void agent_send_response(struct ib_mad *mad, struct ib_grh *grh,
         struct ib_ah *ah;
         struct ib_mad_send_wr_private *mad_send_wr;
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH)
+        if (rdma_cap_ib_switch(device))
                 port_priv = ib_get_agent_port(device, 0);
         else
                 port_priv = ib_get_agent_port(device, port_num);
@@ -106,18 +106,23 @@ void agent_send_response(struct ib_mad *mad, struct ib_grh *grh,
                 return;
         }
 
+        if (opa && mad_hdr->base_version != OPA_MGMT_BASE_VERSION)
+                resp_mad_len = IB_MGMT_MAD_SIZE;
+
         send_buf = ib_create_send_mad(agent, wc->src_qp, wc->pkey_index, 0,
-                                      IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
-                                      GFP_KERNEL);
+                                      IB_MGMT_MAD_HDR,
+                                      resp_mad_len - IB_MGMT_MAD_HDR,
+                                      GFP_KERNEL,
+                                      mad_hdr->base_version);
         if (IS_ERR(send_buf)) {
                 dev_err(&device->dev, "ib_create_send_mad error\n");
                 goto err1;
         }
 
-        memcpy(send_buf->mad, mad, sizeof *mad);
+        memcpy(send_buf->mad, mad_hdr, resp_mad_len);
         send_buf->ah = ah;
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
+        if (rdma_cap_ib_switch(device)) {
                 mad_send_wr = container_of(send_buf,
                                            struct ib_mad_send_wr_private,
                                            send_buf);
@@ -156,7 +161,7 @@ int ib_agent_port_open(struct ib_device *device, int port_num)
                 goto error1;
         }
 
-        if (rdma_port_get_link_layer(device, port_num) == IB_LINK_LAYER_INFINIBAND) {
+        if (rdma_cap_ib_smi(device, port_num)) {
                 /* Obtain send only MAD agent for SMI QP */
                 port_priv->agent[0] = ib_register_mad_agent(device, port_num,
                                                             IB_QPT_SMI, NULL, 0,
diff --git a/drivers/infiniband/core/agent.h b/drivers/infiniband/core/agent.h
index 6669287009c2..65f92bedae44 100644
--- a/drivers/infiniband/core/agent.h
+++ b/drivers/infiniband/core/agent.h
@@ -44,8 +44,8 @@ extern int ib_agent_port_open(struct ib_device *device, int port_num);
 
 extern int ib_agent_port_close(struct ib_device *device, int port_num);
 
-extern void agent_send_response(struct ib_mad *mad, struct ib_grh *grh,
-                                struct ib_wc *wc, struct ib_device *device,
-                                int port_num, int qpn);
+extern void agent_send_response(const struct ib_mad_hdr *mad_hdr, const struct ib_grh *grh,
+                                const struct ib_wc *wc, const struct ib_device *device,
+                                int port_num, int qpn, size_t resp_mad_len, bool opa);
 
 #endif  /* __AGENT_H_ */
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index 80f6cf2449fb..871da832d016 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -58,17 +58,6 @@ struct ib_update_work {
         u8                 port_num;
 };
 
-static inline int start_port(struct ib_device *device)
-{
-        return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
-}
-
-static inline int end_port(struct ib_device *device)
-{
-        return (device->node_type == RDMA_NODE_IB_SWITCH) ?
-                0 : device->phys_port_cnt;
-}
-
 int ib_get_cached_gid(struct ib_device *device,
                       u8                port_num,
                       int               index,
@@ -78,12 +67,12 @@ int ib_get_cached_gid(struct ib_device *device,
         unsigned long flags;
         int ret = 0;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         read_lock_irqsave(&device->cache.lock, flags);
 
-        cache = device->cache.gid_cache[port_num - start_port(device)];
+        cache = device->cache.gid_cache[port_num - rdma_start_port(device)];
 
         if (index < 0 || index >= cache->table_len)
                 ret = -EINVAL;
@@ -96,10 +85,10 @@ int ib_get_cached_gid(struct ib_device *device,
 }
 EXPORT_SYMBOL(ib_get_cached_gid);
 
-int ib_find_cached_gid(struct ib_device *device,
-                       union ib_gid     *gid,
-                       u8               *port_num,
-                       u16              *index)
+int ib_find_cached_gid(struct ib_device   *device,
+                       const union ib_gid *gid,
+                       u8                 *port_num,
+                       u16                *index)
 {
         struct ib_gid_cache *cache;
         unsigned long flags;
@@ -112,11 +101,11 @@ int ib_find_cached_gid(struct ib_device *device,
 
         read_lock_irqsave(&device->cache.lock, flags);
 
-        for (p = 0; p <= end_port(device) - start_port(device); ++p) {
+        for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p) {
                 cache = device->cache.gid_cache[p];
                 for (i = 0; i < cache->table_len; ++i) {
                         if (!memcmp(gid, &cache->table[i], sizeof *gid)) {
-                                *port_num = p + start_port(device);
+                                *port_num = p + rdma_start_port(device);
                                 if (index)
                                         *index = i;
                                 ret = 0;
@@ -140,12 +129,12 @@ int ib_get_cached_pkey(struct ib_device *device,
         unsigned long flags;
         int ret = 0;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         read_lock_irqsave(&device->cache.lock, flags);
 
-        cache = device->cache.pkey_cache[port_num - start_port(device)];
+        cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 
         if (index < 0 || index >= cache->table_len)
                 ret = -EINVAL;
@@ -169,12 +158,12 @@ int ib_find_cached_pkey(struct ib_device *device,
         int ret = -ENOENT;
         int partial_ix = -1;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         read_lock_irqsave(&device->cache.lock, flags);
 
-        cache = device->cache.pkey_cache[port_num - start_port(device)];
+        cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 
         *index = -1;
 
@@ -209,12 +198,12 @@ int ib_find_exact_cached_pkey(struct ib_device *device,
         int i;
         int ret = -ENOENT;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         read_lock_irqsave(&device->cache.lock, flags);
 
-        cache = device->cache.pkey_cache[port_num - start_port(device)];
+        cache = device->cache.pkey_cache[port_num - rdma_start_port(device)];
 
         *index = -1;
 
@@ -238,11 +227,11 @@ int ib_get_cached_lmc(struct ib_device *device,
         unsigned long flags;
         int ret = 0;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         read_lock_irqsave(&device->cache.lock, flags);
-        *lmc = device->cache.lmc_cache[port_num - start_port(device)];
+        *lmc = device->cache.lmc_cache[port_num - rdma_start_port(device)];
         read_unlock_irqrestore(&device->cache.lock, flags);
 
         return ret;
@@ -303,13 +292,13 @@ static void ib_cache_update(struct ib_device *device,
 
         write_lock_irq(&device->cache.lock);
 
-        old_pkey_cache = device->cache.pkey_cache[port - start_port(device)];
-        old_gid_cache  = device->cache.gid_cache [port - start_port(device)];
+        old_pkey_cache = device->cache.pkey_cache[port - rdma_start_port(device)];
+        old_gid_cache  = device->cache.gid_cache [port - rdma_start_port(device)];
 
-        device->cache.pkey_cache[port - start_port(device)] = pkey_cache;
-        device->cache.gid_cache [port - start_port(device)] = gid_cache;
+        device->cache.pkey_cache[port - rdma_start_port(device)] = pkey_cache;
+        device->cache.gid_cache [port - rdma_start_port(device)] = gid_cache;
 
-        device->cache.lmc_cache[port - start_port(device)] = tprops->lmc;
+        device->cache.lmc_cache[port - rdma_start_port(device)] = tprops->lmc;
 
         write_unlock_irq(&device->cache.lock);
 
@@ -363,14 +352,14 @@ static void ib_cache_setup_one(struct ib_device *device)
 
         device->cache.pkey_cache =
                 kmalloc(sizeof *device->cache.pkey_cache *
-                        (end_port(device) - start_port(device) + 1), GFP_KERNEL);
+                        (rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);
         device->cache.gid_cache =
                 kmalloc(sizeof *device->cache.gid_cache *
-                        (end_port(device) - start_port(device) + 1), GFP_KERNEL);
+                        (rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);
 
         device->cache.lmc_cache = kmalloc(sizeof *device->cache.lmc_cache *
-                                          (end_port(device) -
-                                           start_port(device) + 1),
+                                          (rdma_end_port(device) -
+                                           rdma_start_port(device) + 1),
                                           GFP_KERNEL);
 
         if (!device->cache.pkey_cache || !device->cache.gid_cache ||
@@ -380,10 +369,10 @@ static void ib_cache_setup_one(struct ib_device *device)
                 goto err;
         }
 
-        for (p = 0; p <= end_port(device) - start_port(device); ++p) {
+        for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p) {
                 device->cache.pkey_cache[p] = NULL;
                 device->cache.gid_cache [p] = NULL;
-                ib_cache_update(device, p + start_port(device));
+                ib_cache_update(device, p + rdma_start_port(device));
         }
 
         INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
@@ -394,7 +383,7 @@ static void ib_cache_setup_one(struct ib_device *device)
         return;
 
 err_cache:
-        for (p = 0; p <= end_port(device) - start_port(device); ++p) {
+        for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p) {
                 kfree(device->cache.pkey_cache[p]);
                 kfree(device->cache.gid_cache[p]);
         }
@@ -412,7 +401,7 @@ static void ib_cache_cleanup_one(struct ib_device *device)
         ib_unregister_event_handler(&device->cache.event_handler);
         flush_workqueue(ib_wq);
 
-        for (p = 0; p <= end_port(device) - start_port(device); ++p) {
+        for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p) {
                 kfree(device->cache.pkey_cache[p]);
                 kfree(device->cache.gid_cache[p]);
         }
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index 0271608a51c4..3a972ebf3c0d 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -169,6 +169,7 @@ struct cm_device {
         struct ib_device *ib_device;
         struct device *device;
         u8 ack_delay;
+        int going_down;
         struct cm_port *port[0];
 };
 
@@ -267,7 +268,8 @@ static int cm_alloc_msg(struct cm_id_private *cm_id_priv,
         m = ib_create_send_mad(mad_agent, cm_id_priv->id.remote_cm_qpn,
                                cm_id_priv->av.pkey_index,
                                0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
-                               GFP_ATOMIC);
+                               GFP_ATOMIC,
+                               IB_MGMT_BASE_VERSION);
         if (IS_ERR(m)) {
                 ib_destroy_ah(ah);
                 return PTR_ERR(m);
@@ -297,7 +299,8 @@ static int cm_alloc_response_msg(struct cm_port *port,
 
         m = ib_create_send_mad(port->mad_agent, 1, mad_recv_wc->wc->pkey_index,
                                0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
-                               GFP_ATOMIC);
+                               GFP_ATOMIC,
+                               IB_MGMT_BASE_VERSION);
         if (IS_ERR(m)) {
                 ib_destroy_ah(ah);
                 return PTR_ERR(m);
@@ -803,6 +806,11 @@ static void cm_enter_timewait(struct cm_id_private *cm_id_priv)
 {
         int wait_time;
         unsigned long flags;
+        struct cm_device *cm_dev;
+
+        cm_dev = ib_get_client_data(cm_id_priv->id.device, &cm_client);
+        if (!cm_dev)
+                return;
 
         spin_lock_irqsave(&cm.lock, flags);
         cm_cleanup_timewait(cm_id_priv->timewait_info);
@@ -816,8 +824,14 @@ static void cm_enter_timewait(struct cm_id_private *cm_id_priv)
          */
         cm_id_priv->id.state = IB_CM_TIMEWAIT;
         wait_time = cm_convert_to_ms(cm_id_priv->av.timeout);
-        queue_delayed_work(cm.wq, &cm_id_priv->timewait_info->work.work,
-                           msecs_to_jiffies(wait_time));
+
+        /* Check if the device started its remove_one */
+        spin_lock_irq(&cm.lock);
+        if (!cm_dev->going_down)
+                queue_delayed_work(cm.wq, &cm_id_priv->timewait_info->work.work,
+                                   msecs_to_jiffies(wait_time));
+        spin_unlock_irq(&cm.lock);
+
         cm_id_priv->timewait_info = NULL;
 }
 
@@ -3303,6 +3317,11 @@ static int cm_establish(struct ib_cm_id *cm_id)
         struct cm_work *work;
         unsigned long flags;
         int ret = 0;
+        struct cm_device *cm_dev;
+
+        cm_dev = ib_get_client_data(cm_id->device, &cm_client);
+        if (!cm_dev)
+                return -ENODEV;
 
         work = kmalloc(sizeof *work, GFP_ATOMIC);
         if (!work)
@@ -3341,7 +3360,17 @@ static int cm_establish(struct ib_cm_id *cm_id)
         work->remote_id = cm_id->remote_id;
         work->mad_recv_wc = NULL;
         work->cm_event.event = IB_CM_USER_ESTABLISHED;
-        queue_delayed_work(cm.wq, &work->work, 0);
+
+        /* Check if the device started its remove_one */
+        spin_lock_irq(&cm.lock);
+        if (!cm_dev->going_down) {
+                queue_delayed_work(cm.wq, &work->work, 0);
+        } else {
+                kfree(work);
+                ret = -ENODEV;
+        }
+        spin_unlock_irq(&cm.lock);
+
 out:
         return ret;
 }
@@ -3392,6 +3421,7 @@ static void cm_recv_handler(struct ib_mad_agent *mad_agent,
         enum ib_cm_event_type event;
         u16 attr_id;
         int paths = 0;
+        int going_down = 0;
 
         switch (mad_recv_wc->recv_buf.mad->mad_hdr.attr_id) {
         case CM_REQ_ATTR_ID:
@@ -3450,7 +3480,19 @@ static void cm_recv_handler(struct ib_mad_agent *mad_agent,
         work->cm_event.event = event;
         work->mad_recv_wc = mad_recv_wc;
         work->port = port;
-        queue_delayed_work(cm.wq, &work->work, 0);
+
+        /* Check if the device started its remove_one */
+        spin_lock_irq(&cm.lock);
+        if (!port->cm_dev->going_down)
+                queue_delayed_work(cm.wq, &work->work, 0);
+        else
+                going_down = 1;
+        spin_unlock_irq(&cm.lock);
+
+        if (going_down) {
+                kfree(work);
+                ib_free_recv_mad(mad_recv_wc);
+        }
 }
 
 static int cm_init_qp_init_attr(struct cm_id_private *cm_id_priv,
@@ -3759,11 +3801,9 @@ static void cm_add_one(struct ib_device *ib_device)
         };
         unsigned long flags;
         int ret;
+        int count = 0;
         u8 i;
 
-        if (rdma_node_get_transport(ib_device->node_type) != RDMA_TRANSPORT_IB)
-                return;
-
         cm_dev = kzalloc(sizeof(*cm_dev) + sizeof(*port) *
                          ib_device->phys_port_cnt, GFP_KERNEL);
         if (!cm_dev)
@@ -3771,7 +3811,7 @@ static void cm_add_one(struct ib_device *ib_device)
 
         cm_dev->ib_device = ib_device;
         cm_get_ack_delay(cm_dev);
-
+        cm_dev->going_down = 0;
         cm_dev->device = device_create(&cm_class, &ib_device->dev,
                                        MKDEV(0, 0), NULL,
                                        "%s", ib_device->name);
@@ -3782,6 +3822,9 @@ static void cm_add_one(struct ib_device *ib_device)
 
         set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
         for (i = 1; i <= ib_device->phys_port_cnt; i++) {
+                if (!rdma_cap_ib_cm(ib_device, i))
+                        continue;
+
                 port = kzalloc(sizeof *port, GFP_KERNEL);
                 if (!port)
                         goto error1;
@@ -3808,7 +3851,13 @@ static void cm_add_one(struct ib_device *ib_device)
                 ret = ib_modify_port(ib_device, i, 0, &port_modify);
                 if (ret)
                         goto error3;
+
+                count++;
         }
+
+        if (!count)
+                goto free;
+
         ib_set_client_data(ib_device, &cm_client, cm_dev);
 
         write_lock_irqsave(&cm.device_lock, flags);
@@ -3824,11 +3873,15 @@ error1:
         port_modify.set_port_cap_mask = 0;
         port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
         while (--i) {
+                if (!rdma_cap_ib_cm(ib_device, i))
+                        continue;
+
                 port = cm_dev->port[i-1];
                 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
                 ib_unregister_mad_agent(port->mad_agent);
                 cm_remove_port_fs(port);
         }
+free:
         device_unregister(cm_dev->device);
         kfree(cm_dev);
 }
@@ -3851,11 +3904,23 @@ static void cm_remove_one(struct ib_device *ib_device)
         list_del(&cm_dev->list);
         write_unlock_irqrestore(&cm.device_lock, flags);
 
+        spin_lock_irq(&cm.lock);
+        cm_dev->going_down = 1;
+        spin_unlock_irq(&cm.lock);
+
         for (i = 1; i <= ib_device->phys_port_cnt; i++) {
+                if (!rdma_cap_ib_cm(ib_device, i))
+                        continue;
+
                 port = cm_dev->port[i-1];
                 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
-                ib_unregister_mad_agent(port->mad_agent);
+                /*
+                 * We flush the queue here after the going_down set, this
+                 * verify that no new works will be queued in the recv handler,
+                 * after that we can call the unregister_mad_agent
+                 */
                 flush_workqueue(cm.wq);
+                ib_unregister_mad_agent(port->mad_agent);
                 cm_remove_port_fs(port);
         }
         device_unregister(cm_dev->device);
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index 38ffe0981503..143ded2bbe7c 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -65,6 +65,34 @@ MODULE_LICENSE("Dual BSD/GPL");
 #define CMA_CM_MRA_SETTING (IB_CM_MRA_FLAG_DELAY | 24)
 #define CMA_IBOE_PACKET_LIFETIME 18
 
+static const char * const cma_events[] = {
+        [RDMA_CM_EVENT_ADDR_RESOLVED]    = "address resolved",
+        [RDMA_CM_EVENT_ADDR_ERROR]       = "address error",
+        [RDMA_CM_EVENT_ROUTE_RESOLVED]   = "route resolved ",
+        [RDMA_CM_EVENT_ROUTE_ERROR]      = "route error",
+        [RDMA_CM_EVENT_CONNECT_REQUEST]  = "connect request",
+        [RDMA_CM_EVENT_CONNECT_RESPONSE] = "connect response",
+        [RDMA_CM_EVENT_CONNECT_ERROR]    = "connect error",
+        [RDMA_CM_EVENT_UNREACHABLE]      = "unreachable",
+        [RDMA_CM_EVENT_REJECTED]         = "rejected",
+        [RDMA_CM_EVENT_ESTABLISHED]      = "established",
+        [RDMA_CM_EVENT_DISCONNECTED]     = "disconnected",
+        [RDMA_CM_EVENT_DEVICE_REMOVAL]   = "device removal",
+        [RDMA_CM_EVENT_MULTICAST_JOIN]   = "multicast join",
+        [RDMA_CM_EVENT_MULTICAST_ERROR]  = "multicast error",
+        [RDMA_CM_EVENT_ADDR_CHANGE]      = "address change",
+        [RDMA_CM_EVENT_TIMEWAIT_EXIT]    = "timewait exit",
+};
+
+const char *rdma_event_msg(enum rdma_cm_event_type event)
+{
+        size_t index = event;
+
+        return (index < ARRAY_SIZE(cma_events) && cma_events[index]) ?
+                        cma_events[index] : "unrecognized event";
+}
+EXPORT_SYMBOL(rdma_event_msg);
+
 static void cma_add_one(struct ib_device *device);
 static void cma_remove_one(struct ib_device *device);
 
@@ -349,18 +377,35 @@ static int cma_translate_addr(struct sockaddr *addr, struct rdma_dev_addr *dev_a
         return ret;
 }
 
+static inline int cma_validate_port(struct ib_device *device, u8 port,
+                                      union ib_gid *gid, int dev_type)
+{
+        u8 found_port;
+        int ret = -ENODEV;
+
+        if ((dev_type == ARPHRD_INFINIBAND) && !rdma_protocol_ib(device, port))
+                return ret;
+
+        if ((dev_type != ARPHRD_INFINIBAND) && rdma_protocol_ib(device, port))
+                return ret;
+
+        ret = ib_find_cached_gid(device, gid, &found_port, NULL);
+        if (port != found_port)
+                return -ENODEV;
+
+        return ret;
+}
+
 static int cma_acquire_dev(struct rdma_id_private *id_priv,
                            struct rdma_id_private *listen_id_priv)
 {
         struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
         struct cma_device *cma_dev;
-        union ib_gid gid, iboe_gid;
+        union ib_gid gid, iboe_gid, *gidp;
         int ret = -ENODEV;
-        u8 port, found_port;
-        enum rdma_link_layer dev_ll = dev_addr->dev_type == ARPHRD_INFINIBAND ?
-                IB_LINK_LAYER_INFINIBAND : IB_LINK_LAYER_ETHERNET;
+        u8 port;
 
-        if (dev_ll != IB_LINK_LAYER_INFINIBAND &&
+        if (dev_addr->dev_type != ARPHRD_INFINIBAND &&
             id_priv->id.ps == RDMA_PS_IPOIB)
                 return -EINVAL;
 
@@ -370,41 +415,36 @@ static int cma_acquire_dev(struct rdma_id_private *id_priv,
 
         memcpy(&gid, dev_addr->src_dev_addr +
                rdma_addr_gid_offset(dev_addr), sizeof gid);
-        if (listen_id_priv &&
-            rdma_port_get_link_layer(listen_id_priv->id.device,
-                                     listen_id_priv->id.port_num) == dev_ll) {
+
+        if (listen_id_priv) {
                 cma_dev = listen_id_priv->cma_dev;
                 port = listen_id_priv->id.port_num;
-                if (rdma_node_get_transport(cma_dev->device->node_type) == RDMA_TRANSPORT_IB &&
-                    rdma_port_get_link_layer(cma_dev->device, port) == IB_LINK_LAYER_ETHERNET)
-                        ret = ib_find_cached_gid(cma_dev->device, &iboe_gid,
-                                                 &found_port, NULL);
-                else
-                        ret = ib_find_cached_gid(cma_dev->device, &gid,
-                                                 &found_port, NULL);
+                gidp = rdma_protocol_roce(cma_dev->device, port) ?
+                       &iboe_gid : &gid;
 
-                if (!ret && (port  == found_port)) {
-                        id_priv->id.port_num = found_port;
+                ret = cma_validate_port(cma_dev->device, port, gidp,
+                                        dev_addr->dev_type);
+                if (!ret) {
+                        id_priv->id.port_num = port;
                         goto out;
                 }
         }
+
         list_for_each_entry(cma_dev, &dev_list, list) {
                 for (port = 1; port <= cma_dev->device->phys_port_cnt; ++port) {
                         if (listen_id_priv &&
                             listen_id_priv->cma_dev == cma_dev &&
                             listen_id_priv->id.port_num == port)
                                 continue;
-                        if (rdma_port_get_link_layer(cma_dev->device, port) == dev_ll) {
-                                if (rdma_node_get_transport(cma_dev->device->node_type) == RDMA_TRANSPORT_IB &&
-                                    rdma_port_get_link_layer(cma_dev->device, port) == IB_LINK_LAYER_ETHERNET)
-                                        ret = ib_find_cached_gid(cma_dev->device, &iboe_gid, &found_port, NULL);
-                                else
-                                        ret = ib_find_cached_gid(cma_dev->device, &gid, &found_port, NULL);
-
-                                if (!ret && (port == found_port)) {
-                                        id_priv->id.port_num = found_port;
-                                        goto out;
-                                }
+
+                        gidp = rdma_protocol_roce(cma_dev->device, port) ?
+                               &iboe_gid : &gid;
+
+                        ret = cma_validate_port(cma_dev->device, port, gidp,
+                                                dev_addr->dev_type);
+                        if (!ret) {
+                                id_priv->id.port_num = port;
+                                goto out;
                         }
                 }
         }
@@ -435,10 +475,10 @@ static int cma_resolve_ib_dev(struct rdma_id_private *id_priv)
         pkey = ntohs(addr->sib_pkey);
 
         list_for_each_entry(cur_dev, &dev_list, list) {
-                if (rdma_node_get_transport(cur_dev->device->node_type) != RDMA_TRANSPORT_IB)
-                        continue;
-
                 for (p = 1; p <= cur_dev->device->phys_port_cnt; ++p) {
+                        if (!rdma_cap_af_ib(cur_dev->device, p))
+                                continue;
+
                         if (ib_find_cached_pkey(cur_dev->device, p, pkey, &index))
                                 continue;
 
@@ -633,10 +673,9 @@ static int cma_modify_qp_rtr(struct rdma_id_private *id_priv,
         if (ret)
                 goto out;
 
-        if (rdma_node_get_transport(id_priv->cma_dev->device->node_type)
-            == RDMA_TRANSPORT_IB &&
-            rdma_port_get_link_layer(id_priv->id.device, id_priv->id.port_num)
-            == IB_LINK_LAYER_ETHERNET) {
+        BUG_ON(id_priv->cma_dev->device != id_priv->id.device);
+
+        if (rdma_protocol_roce(id_priv->id.device, id_priv->id.port_num)) {
                 ret = rdma_addr_find_smac_by_sgid(&sgid, qp_attr.smac, NULL);
 
                 if (ret)
@@ -700,11 +739,10 @@ static int cma_ib_init_qp_attr(struct rdma_id_private *id_priv,
         int ret;
         u16 pkey;
 
-        if (rdma_port_get_link_layer(id_priv->id.device, id_priv->id.port_num) ==
-            IB_LINK_LAYER_INFINIBAND)
-                pkey = ib_addr_get_pkey(dev_addr);
-        else
+        if (rdma_cap_eth_ah(id_priv->id.device, id_priv->id.port_num))
                 pkey = 0xffff;
+        else
+                pkey = ib_addr_get_pkey(dev_addr);
 
         ret = ib_find_cached_pkey(id_priv->id.device, id_priv->id.port_num,
                                   pkey, &qp_attr->pkey_index);
@@ -735,8 +773,7 @@ int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
         int ret = 0;
 
         id_priv = container_of(id, struct rdma_id_private, id);
-        switch (rdma_node_get_transport(id_priv->id.device->node_type)) {
-        case RDMA_TRANSPORT_IB:
+        if (rdma_cap_ib_cm(id->device, id->port_num)) {
                 if (!id_priv->cm_id.ib || (id_priv->id.qp_type == IB_QPT_UD))
                         ret = cma_ib_init_qp_attr(id_priv, qp_attr, qp_attr_mask);
                 else
@@ -745,19 +782,15 @@ int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
 
                 if (qp_attr->qp_state == IB_QPS_RTR)
                         qp_attr->rq_psn = id_priv->seq_num;
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        } else if (rdma_cap_iw_cm(id->device, id->port_num)) {
                 if (!id_priv->cm_id.iw) {
                         qp_attr->qp_access_flags = 0;
                         *qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS;
                 } else
                         ret = iw_cm_init_qp_attr(id_priv->cm_id.iw, qp_attr,
                                                  qp_attr_mask);
-                break;
-        default:
+        } else
                 ret = -ENOSYS;
-                break;
-        }
 
         return ret;
 }
@@ -945,13 +978,9 @@ static inline int cma_user_data_offset(struct rdma_id_private *id_priv)
 
 static void cma_cancel_route(struct rdma_id_private *id_priv)
 {
-        switch (rdma_port_get_link_layer(id_priv->id.device, id_priv->id.port_num)) {
-        case IB_LINK_LAYER_INFINIBAND:
+        if (rdma_cap_ib_sa(id_priv->id.device, id_priv->id.port_num)) {
                 if (id_priv->query)
                         ib_sa_cancel_query(id_priv->query_id, id_priv->query);
-                break;
-        default:
-                break;
         }
 }
 
@@ -1023,17 +1052,12 @@ static void cma_leave_mc_groups(struct rdma_id_private *id_priv)
                 mc = container_of(id_priv->mc_list.next,
                                   struct cma_multicast, list);
                 list_del(&mc->list);
-                switch (rdma_port_get_link_layer(id_priv->cma_dev->device, id_priv->id.port_num)) {
-                case IB_LINK_LAYER_INFINIBAND:
+                if (rdma_cap_ib_mcast(id_priv->cma_dev->device,
+                                      id_priv->id.port_num)) {
                         ib_sa_free_multicast(mc->multicast.ib);
                         kfree(mc);
-                        break;
-                case IB_LINK_LAYER_ETHERNET:
+                } else
                         kref_put(&mc->mcref, release_mc);
-                        break;
-                default:
-                        break;
-                }
         }
 }
 
@@ -1054,17 +1078,12 @@ void rdma_destroy_id(struct rdma_cm_id *id)
         mutex_unlock(&id_priv->handler_mutex);
 
         if (id_priv->cma_dev) {
-                switch (rdma_node_get_transport(id_priv->id.device->node_type)) {
-                case RDMA_TRANSPORT_IB:
+                if (rdma_cap_ib_cm(id_priv->id.device, 1)) {
                         if (id_priv->cm_id.ib)
                                 ib_destroy_cm_id(id_priv->cm_id.ib);
-                        break;
-                case RDMA_TRANSPORT_IWARP:
+                } else if (rdma_cap_iw_cm(id_priv->id.device, 1)) {
                         if (id_priv->cm_id.iw)
                                 iw_destroy_cm_id(id_priv->cm_id.iw);
-                        break;
-                default:
-                        break;
                 }
                 cma_leave_mc_groups(id_priv);
                 cma_release_dev(id_priv);
@@ -1610,6 +1629,7 @@ static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)
         if (IS_ERR(id))
                 return PTR_ERR(id);
 
+        id->tos = id_priv->tos;
         id_priv->cm_id.iw = id;
 
         memcpy(&id_priv->cm_id.iw->local_addr, cma_src_addr(id_priv),
@@ -1642,8 +1662,7 @@ static void cma_listen_on_dev(struct rdma_id_private *id_priv,
         struct rdma_cm_id *id;
         int ret;
 
-        if (cma_family(id_priv) == AF_IB &&
-            rdma_node_get_transport(cma_dev->device->node_type) != RDMA_TRANSPORT_IB)
+        if (cma_family(id_priv) == AF_IB && !rdma_cap_ib_cm(cma_dev->device, 1))
                 return;
 
         id = rdma_create_id(cma_listen_handler, id_priv, id_priv->id.ps,
@@ -1984,26 +2003,15 @@ int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms)
                 return -EINVAL;
 
         atomic_inc(&id_priv->refcount);
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
-                switch (rdma_port_get_link_layer(id->device, id->port_num)) {
-                case IB_LINK_LAYER_INFINIBAND:
-                        ret = cma_resolve_ib_route(id_priv, timeout_ms);
-                        break;
-                case IB_LINK_LAYER_ETHERNET:
-                        ret = cma_resolve_iboe_route(id_priv);
-                        break;
-                default:
-                        ret = -ENOSYS;
-                }
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        if (rdma_cap_ib_sa(id->device, id->port_num))
+                ret = cma_resolve_ib_route(id_priv, timeout_ms);
+        else if (rdma_protocol_roce(id->device, id->port_num))
+                ret = cma_resolve_iboe_route(id_priv);
+        else if (rdma_protocol_iwarp(id->device, id->port_num))
                 ret = cma_resolve_iw_route(id_priv, timeout_ms);
-                break;
-        default:
+        else
                 ret = -ENOSYS;
-                break;
-        }
+
         if (ret)
                 goto err;
 
@@ -2045,7 +2053,7 @@ static int cma_bind_loopback(struct rdma_id_private *id_priv)
         mutex_lock(&lock);
         list_for_each_entry(cur_dev, &dev_list, list) {
                 if (cma_family(id_priv) == AF_IB &&
-                    rdma_node_get_transport(cur_dev->device->node_type) != RDMA_TRANSPORT_IB)
+                    !rdma_cap_ib_cm(cur_dev->device, 1))
                         continue;
 
                 if (!cma_dev)
@@ -2077,7 +2085,7 @@ port_found:
                 goto out;
 
         id_priv->id.route.addr.dev_addr.dev_type =
-                (rdma_port_get_link_layer(cma_dev->device, p) == IB_LINK_LAYER_INFINIBAND) ?
+                (rdma_protocol_ib(cma_dev->device, p)) ?
                 ARPHRD_INFINIBAND : ARPHRD_ETHER;
 
         rdma_addr_set_sgid(&id_priv->id.route.addr.dev_addr, &gid);
@@ -2554,18 +2562,15 @@ int rdma_listen(struct rdma_cm_id *id, int backlog)
 
         id_priv->backlog = backlog;
         if (id->device) {
-                switch (rdma_node_get_transport(id->device->node_type)) {
-                case RDMA_TRANSPORT_IB:
+                if (rdma_cap_ib_cm(id->device, 1)) {
                         ret = cma_ib_listen(id_priv);
                         if (ret)
                                 goto err;
-                        break;
-                case RDMA_TRANSPORT_IWARP:
+                } else if (rdma_cap_iw_cm(id->device, 1)) {
                         ret = cma_iw_listen(id_priv, backlog);
                         if (ret)
                                 goto err;
-                        break;
-                default:
+                } else {
                         ret = -ENOSYS;
                         goto err;
                 }
@@ -2857,6 +2862,7 @@ static int cma_connect_iw(struct rdma_id_private *id_priv,
         if (IS_ERR(cm_id))
                 return PTR_ERR(cm_id);
 
+        cm_id->tos = id_priv->tos;
         id_priv->cm_id.iw = cm_id;
 
         memcpy(&cm_id->local_addr, cma_src_addr(id_priv),
@@ -2901,20 +2907,15 @@ int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
                 id_priv->srq = conn_param->srq;
         }
 
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
+        if (rdma_cap_ib_cm(id->device, id->port_num)) {
                 if (id->qp_type == IB_QPT_UD)
                         ret = cma_resolve_ib_udp(id_priv, conn_param);
                 else
                         ret = cma_connect_ib(id_priv, conn_param);
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        } else if (rdma_cap_iw_cm(id->device, id->port_num))
                 ret = cma_connect_iw(id_priv, conn_param);
-                break;
-        default:
+        else
                 ret = -ENOSYS;
-                break;
-        }
         if (ret)
                 goto err;
 
@@ -3017,8 +3018,7 @@ int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
                 id_priv->srq = conn_param->srq;
         }
 
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
+        if (rdma_cap_ib_cm(id->device, id->port_num)) {
                 if (id->qp_type == IB_QPT_UD) {
                         if (conn_param)
                                 ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
@@ -3034,14 +3034,10 @@ int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
                         else
                                 ret = cma_rep_recv(id_priv);
                 }
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        } else if (rdma_cap_iw_cm(id->device, id->port_num))
                 ret = cma_accept_iw(id_priv, conn_param);
-                break;
-        default:
+        else
                 ret = -ENOSYS;
-                break;
-        }
 
         if (ret)
                 goto reject;
@@ -3085,8 +3081,7 @@ int rdma_reject(struct rdma_cm_id *id, const void *private_data,
         if (!id_priv->cm_id.ib)
                 return -EINVAL;
 
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
+        if (rdma_cap_ib_cm(id->device, id->port_num)) {
                 if (id->qp_type == IB_QPT_UD)
                         ret = cma_send_sidr_rep(id_priv, IB_SIDR_REJECT, 0,
                                                 private_data, private_data_len);
@@ -3094,15 +3089,12 @@ int rdma_reject(struct rdma_cm_id *id, const void *private_data,
                         ret = ib_send_cm_rej(id_priv->cm_id.ib,
                                              IB_CM_REJ_CONSUMER_DEFINED, NULL,
                                              0, private_data, private_data_len);
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        } else if (rdma_cap_iw_cm(id->device, id->port_num)) {
                 ret = iw_cm_reject(id_priv->cm_id.iw,
                                    private_data, private_data_len);
-                break;
-        default:
+        } else
                 ret = -ENOSYS;
-                break;
-        }
+
         return ret;
 }
 EXPORT_SYMBOL(rdma_reject);
@@ -3116,22 +3108,18 @@ int rdma_disconnect(struct rdma_cm_id *id)
         if (!id_priv->cm_id.ib)
                 return -EINVAL;
 
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
+        if (rdma_cap_ib_cm(id->device, id->port_num)) {
                 ret = cma_modify_qp_err(id_priv);
                 if (ret)
                         goto out;
                 /* Initiate or respond to a disconnect. */
                 if (ib_send_cm_dreq(id_priv->cm_id.ib, NULL, 0))
                         ib_send_cm_drep(id_priv->cm_id.ib, NULL, 0);
-                break;
-        case RDMA_TRANSPORT_IWARP:
+        } else if (rdma_cap_iw_cm(id->device, id->port_num)) {
                 ret = iw_cm_disconnect(id_priv->cm_id.iw, 0);
-                break;
-        default:
+        } else
                 ret = -EINVAL;
-                break;
-        }
+
 out:
         return ret;
 }
@@ -3377,24 +3365,13 @@ int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
         list_add(&mc->list, &id_priv->mc_list);
         spin_unlock(&id_priv->lock);
 
-        switch (rdma_node_get_transport(id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
-                switch (rdma_port_get_link_layer(id->device, id->port_num)) {
-                case IB_LINK_LAYER_INFINIBAND:
-                        ret = cma_join_ib_multicast(id_priv, mc);
-                        break;
-                case IB_LINK_LAYER_ETHERNET:
-                        kref_init(&mc->mcref);
-                        ret = cma_iboe_join_multicast(id_priv, mc);
-                        break;
-                default:
-                        ret = -EINVAL;
-                }
-                break;
-        default:
+        if (rdma_protocol_roce(id->device, id->port_num)) {
+                kref_init(&mc->mcref);
+                ret = cma_iboe_join_multicast(id_priv, mc);
+        } else if (rdma_cap_ib_mcast(id->device, id->port_num))
+                ret = cma_join_ib_multicast(id_priv, mc);
+        else
                 ret = -ENOSYS;
-                break;
-        }
 
         if (ret) {
                 spin_lock_irq(&id_priv->lock);
@@ -3422,19 +3399,15 @@ void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr)
                                 ib_detach_mcast(id->qp,
                                                 &mc->multicast.ib->rec.mgid,
                                                 be16_to_cpu(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:
-                                        ib_sa_free_multicast(mc->multicast.ib);
-                                        kfree(mc);
-                                        break;
-                                case IB_LINK_LAYER_ETHERNET:
-                                        kref_put(&mc->mcref, release_mc);
-                                        break;
-                                default:
-                                        break;
-                                }
-                        }
+
+                        BUG_ON(id_priv->cma_dev->device != id->device);
+
+                        if (rdma_cap_ib_mcast(id->device, id->port_num)) {
+                                ib_sa_free_multicast(mc->multicast.ib);
+                                kfree(mc);
+                        } else if (rdma_protocol_roce(id->device, id->port_num))
+                                kref_put(&mc->mcref, release_mc);
+
                         return;
                 }
         }
diff --git a/drivers/infiniband/core/device.c b/drivers/infiniband/core/device.c
index 18c1ece765f2..9567756ca4f9 100644
--- a/drivers/infiniband/core/device.c
+++ b/drivers/infiniband/core/device.c
@@ -92,7 +92,8 @@ static int ib_device_check_mandatory(struct ib_device *device)
                 IB_MANDATORY_FUNC(poll_cq),
                 IB_MANDATORY_FUNC(req_notify_cq),
                 IB_MANDATORY_FUNC(get_dma_mr),
-                IB_MANDATORY_FUNC(dereg_mr)
+                IB_MANDATORY_FUNC(dereg_mr),
+                IB_MANDATORY_FUNC(get_port_immutable)
         };
         int i;
 
@@ -151,18 +152,6 @@ static int alloc_name(char *name)
         return 0;
 }
 
-static int start_port(struct ib_device *device)
-{
-        return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
-}
-
-
-static int end_port(struct ib_device *device)
-{
-        return (device->node_type == RDMA_NODE_IB_SWITCH) ?
-                0 : device->phys_port_cnt;
-}
-
 /**
  * ib_alloc_device - allocate an IB device struct
  * @size:size of structure to allocate
@@ -222,42 +211,49 @@ static int add_client_context(struct ib_device *device, struct ib_client *client
         return 0;
 }
 
-static int read_port_table_lengths(struct ib_device *device)
+static int verify_immutable(const struct ib_device *dev, u8 port)
 {
-        struct ib_port_attr *tprops = NULL;
-        int num_ports, ret = -ENOMEM;
-        u8 port_index;
-
-        tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
-        if (!tprops)
-                goto out;
-
-        num_ports = end_port(device) - start_port(device) + 1;
+        return WARN_ON(!rdma_cap_ib_mad(dev, port) &&
+                            rdma_max_mad_size(dev, port) != 0);
+}
 
-        device->pkey_tbl_len = kmalloc(sizeof *device->pkey_tbl_len * num_ports,
-                                       GFP_KERNEL);
-        device->gid_tbl_len = kmalloc(sizeof *device->gid_tbl_len * num_ports,
-                                      GFP_KERNEL);
-        if (!device->pkey_tbl_len || !device->gid_tbl_len)
+static int read_port_immutable(struct ib_device *device)
+{
+        int ret = -ENOMEM;
+        u8 start_port = rdma_start_port(device);
+        u8 end_port = rdma_end_port(device);
+        u8 port;
+
+        /**
+         * device->port_immutable is indexed directly by the port number to make
+         * access to this data as efficient as possible.
+         *
+         * Therefore port_immutable is declared as a 1 based array with
+         * potential empty slots at the beginning.
+         */
+        device->port_immutable = kzalloc(sizeof(*device->port_immutable)
+                                         * (end_port + 1),
+                                         GFP_KERNEL);
+        if (!device->port_immutable)
                 goto err;
 
-        for (port_index = 0; port_index < num_ports; ++port_index) {
-                ret = ib_query_port(device, port_index + start_port(device),
-                                        tprops);
+        for (port = start_port; port <= end_port; ++port) {
+                ret = device->get_port_immutable(device, port,
+                                                 &device->port_immutable[port]);
                 if (ret)
                         goto err;
-                device->pkey_tbl_len[port_index] = tprops->pkey_tbl_len;
-                device->gid_tbl_len[port_index]  = tprops->gid_tbl_len;
+
+                if (verify_immutable(device, port)) {
+                        ret = -EINVAL;
+                        goto err;
+                }
         }
 
         ret = 0;
         goto out;
-
 err:
-        kfree(device->gid_tbl_len);
-        kfree(device->pkey_tbl_len);
+        kfree(device->port_immutable);
 out:
-        kfree(tprops);
         return ret;
 }
 
@@ -294,9 +290,9 @@ int ib_register_device(struct ib_device *device,
         spin_lock_init(&device->event_handler_lock);
         spin_lock_init(&device->client_data_lock);
 
-        ret = read_port_table_lengths(device);
+        ret = read_port_immutable(device);
         if (ret) {
-                printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n",
+                printk(KERN_WARNING "Couldn't create per port immutable data %s\n",
                        device->name);
                 goto out;
         }
@@ -305,8 +301,7 @@ int ib_register_device(struct ib_device *device,
         if (ret) {
                 printk(KERN_WARNING "Couldn't register device %s with driver model\n",
                        device->name);
-                kfree(device->gid_tbl_len);
-                kfree(device->pkey_tbl_len);
+                kfree(device->port_immutable);
                 goto out;
         }
 
@@ -348,9 +343,6 @@ void ib_unregister_device(struct ib_device *device)
 
         list_del(&device->core_list);
 
-        kfree(device->gid_tbl_len);
-        kfree(device->pkey_tbl_len);
-
         mutex_unlock(&device_mutex);
 
         ib_device_unregister_sysfs(device);
@@ -558,7 +550,11 @@ EXPORT_SYMBOL(ib_dispatch_event);
 int ib_query_device(struct ib_device *device,
                     struct ib_device_attr *device_attr)
 {
-        return device->query_device(device, device_attr);
+        struct ib_udata uhw = {.outlen = 0, .inlen = 0};
+
+        memset(device_attr, 0, sizeof(*device_attr));
+
+        return device->query_device(device, device_attr, &uhw);
 }
 EXPORT_SYMBOL(ib_query_device);
 
@@ -575,7 +571,7 @@ int ib_query_port(struct ib_device *device,
                   u8 port_num,
                   struct ib_port_attr *port_attr)
 {
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         return device->query_port(device, port_num, port_attr);
@@ -653,7 +649,7 @@ int ib_modify_port(struct ib_device *device,
         if (!device->modify_port)
                 return -ENOSYS;
 
-        if (port_num < start_port(device) || port_num > end_port(device))
+        if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
         return device->modify_port(device, port_num, port_modify_mask,
@@ -676,8 +672,8 @@ int ib_find_gid(struct ib_device *device, union ib_gid *gid,
         union ib_gid tmp_gid;
         int ret, port, i;
 
-        for (port = start_port(device); port <= end_port(device); ++port) {
-                for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) {
+        for (port = rdma_start_port(device); port <= rdma_end_port(device); ++port) {
+                for (i = 0; i < device->port_immutable[port].gid_tbl_len; ++i) {
                         ret = ib_query_gid(device, port, i, &tmp_gid);
                         if (ret)
                                 return ret;
@@ -709,7 +705,7 @@ int ib_find_pkey(struct ib_device *device,
         u16 tmp_pkey;
         int partial_ix = -1;
 
-        for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) {
+        for (i = 0; i < device->port_immutable[port_num].pkey_tbl_len; ++i) {
                 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
                 if (ret)
                         return ret;
diff --git a/drivers/infiniband/core/iwpm_msg.c b/drivers/infiniband/core/iwpm_msg.c
index e6ffa2e66c1a..22a3abee2a54 100644
--- a/drivers/infiniband/core/iwpm_msg.c
+++ b/drivers/infiniband/core/iwpm_msg.c
@@ -67,7 +67,8 @@ int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client)
                 err_str = "Invalid port mapper client";
                 goto pid_query_error;
         }
-        if (iwpm_registered_client(nl_client))
+        if (iwpm_check_registration(nl_client, IWPM_REG_VALID) ||
+                        iwpm_user_pid == IWPM_PID_UNAVAILABLE)
                 return 0;
         skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REG_PID, &nlh, nl_client);
         if (!skb) {
@@ -106,7 +107,6 @@ int iwpm_register_pid(struct iwpm_dev_data *pm_msg, u8 nl_client)
         ret = ibnl_multicast(skb, nlh, RDMA_NL_GROUP_IWPM, GFP_KERNEL);
         if (ret) {
                 skb = NULL; /* skb is freed in the netlink send-op handling */
-                iwpm_set_registered(nl_client, 1);
                 iwpm_user_pid = IWPM_PID_UNAVAILABLE;
                 err_str = "Unable to send a nlmsg";
                 goto pid_query_error;
@@ -144,12 +144,12 @@ int iwpm_add_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
                 err_str = "Invalid port mapper client";
                 goto add_mapping_error;
         }
-        if (!iwpm_registered_client(nl_client)) {
+        if (!iwpm_valid_pid())
+                return 0;
+        if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
                 err_str = "Unregistered port mapper client";
                 goto add_mapping_error;
         }
-        if (!iwpm_valid_pid())
-                return 0;
         skb = iwpm_create_nlmsg(RDMA_NL_IWPM_ADD_MAPPING, &nlh, nl_client);
         if (!skb) {
                 err_str = "Unable to create a nlmsg";
@@ -214,12 +214,12 @@ int iwpm_add_and_query_mapping(struct iwpm_sa_data *pm_msg, u8 nl_client)
                 err_str = "Invalid port mapper client";
                 goto query_mapping_error;
         }
-        if (!iwpm_registered_client(nl_client)) {
+        if (!iwpm_valid_pid())
+                return 0;
+        if (!iwpm_check_registration(nl_client, IWPM_REG_VALID)) {
                 err_str = "Unregistered port mapper client";
                 goto query_mapping_error;
         }
-        if (!iwpm_valid_pid())
-                return 0;
         ret = -ENOMEM;
         skb = iwpm_create_nlmsg(RDMA_NL_IWPM_QUERY_MAPPING, &nlh, nl_client);
         if (!skb) {
@@ -288,12 +288,12 @@ int iwpm_remove_mapping(struct sockaddr_storage *local_addr, u8 nl_client)
                 err_str = "Invalid port mapper client";
                 goto remove_mapping_error;
         }
-        if (!iwpm_registered_client(nl_client)) {
+        if (!iwpm_valid_pid())
+                return 0;
+        if (iwpm_check_registration(nl_client, IWPM_REG_UNDEF)) {
                 err_str = "Unregistered port mapper client";
                 goto remove_mapping_error;
         }
-        if (!iwpm_valid_pid())
-                return 0;
         skb = iwpm_create_nlmsg(RDMA_NL_IWPM_REMOVE_MAPPING, &nlh, nl_client);
         if (!skb) {
                 ret = -ENOMEM;
@@ -388,7 +388,7 @@ int iwpm_register_pid_cb(struct sk_buff *skb, struct netlink_callback *cb)
         pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
                         __func__, iwpm_user_pid);
         if (iwpm_valid_client(nl_client))
-                iwpm_set_registered(nl_client, 1);
+                iwpm_set_registration(nl_client, IWPM_REG_VALID);
 register_pid_response_exit:
         nlmsg_request->request_done = 1;
         /* always for found nlmsg_request */
@@ -644,7 +644,6 @@ int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct nlattr *nltb[IWPM_NLA_MAPINFO_REQ_MAX];
         const char *msg_type = "Mapping Info response";
-        int iwpm_pid;
         u8 nl_client;
         char *iwpm_name;
         u16 iwpm_version;
@@ -669,14 +668,14 @@ int iwpm_mapping_info_cb(struct sk_buff *skb, struct netlink_callback *cb)
                                 __func__, nl_client);
                 return ret;
         }
-        iwpm_set_registered(nl_client, 0);
+        iwpm_set_registration(nl_client, IWPM_REG_INCOMPL);
         atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq);
+        iwpm_user_pid = cb->nlh->nlmsg_pid;
         if (!iwpm_mapinfo_available())
                 return 0;
-        iwpm_pid = cb->nlh->nlmsg_pid;
         pr_debug("%s: iWarp Port Mapper (pid = %d) is available!\n",
-                 __func__, iwpm_pid);
-        ret = iwpm_send_mapinfo(nl_client, iwpm_pid);
+                 __func__, iwpm_user_pid);
+        ret = iwpm_send_mapinfo(nl_client, iwpm_user_pid);
         return ret;
 }
 EXPORT_SYMBOL(iwpm_mapping_info_cb);
diff --git a/drivers/infiniband/core/iwpm_util.c b/drivers/infiniband/core/iwpm_util.c
index a626795bf9c7..5fb089e91353 100644
--- a/drivers/infiniband/core/iwpm_util.c
+++ b/drivers/infiniband/core/iwpm_util.c
@@ -78,6 +78,7 @@ init_exit:
         mutex_unlock(&iwpm_admin_lock);
         if (!ret) {
                 iwpm_set_valid(nl_client, 1);
+                iwpm_set_registration(nl_client, IWPM_REG_UNDEF);
                 pr_debug("%s: Mapinfo and reminfo tables are created\n",
                                 __func__);
         }
@@ -106,6 +107,7 @@ int iwpm_exit(u8 nl_client)
         }
         mutex_unlock(&iwpm_admin_lock);
         iwpm_set_valid(nl_client, 0);
+        iwpm_set_registration(nl_client, IWPM_REG_UNDEF);
         return 0;
 }
 EXPORT_SYMBOL(iwpm_exit);
@@ -397,17 +399,23 @@ void iwpm_set_valid(u8 nl_client, int valid)
 }
 
 /* valid client */
-int iwpm_registered_client(u8 nl_client)
+u32 iwpm_get_registration(u8 nl_client)
 {
         return iwpm_admin.reg_list[nl_client];
 }
 
 /* valid client */
-void iwpm_set_registered(u8 nl_client, int reg)
+void iwpm_set_registration(u8 nl_client, u32 reg)
 {
         iwpm_admin.reg_list[nl_client] = reg;
 }
 
+/* valid client */
+u32 iwpm_check_registration(u8 nl_client, u32 reg)
+{
+        return (iwpm_get_registration(nl_client) & reg);
+}
+
 int iwpm_compare_sockaddr(struct sockaddr_storage *a_sockaddr,
                                 struct sockaddr_storage *b_sockaddr)
 {
diff --git a/drivers/infiniband/core/iwpm_util.h b/drivers/infiniband/core/iwpm_util.h
index ee2d9ff095be..b7b9e194ce81 100644
--- a/drivers/infiniband/core/iwpm_util.h
+++ b/drivers/infiniband/core/iwpm_util.h
@@ -58,6 +58,10 @@
 #define IWPM_PID_UNDEFINED     -1
 #define IWPM_PID_UNAVAILABLE   -2
 
+#define IWPM_REG_UNDEF          0x01
+#define IWPM_REG_VALID          0x02
+#define IWPM_REG_INCOMPL        0x04
+
 struct iwpm_nlmsg_request {
         struct list_head    inprocess_list;
         __u32               nlmsg_seq;
@@ -88,7 +92,7 @@ struct iwpm_admin_data {
         atomic_t refcount;
         atomic_t nlmsg_seq;
         int      client_list[RDMA_NL_NUM_CLIENTS];
-        int      reg_list[RDMA_NL_NUM_CLIENTS];
+        u32      reg_list[RDMA_NL_NUM_CLIENTS];
 };
 
 /**
@@ -159,19 +163,31 @@ int iwpm_valid_client(u8 nl_client);
 void iwpm_set_valid(u8 nl_client, int valid);
 
 /**
- * iwpm_registered_client - Check if the port mapper client is registered
+ * iwpm_check_registration - Check if the client registration
+ *                            matches the given one
  * @nl_client: The index of the netlink client
+ * @reg: The given registration type to compare with
  *
  * Call iwpm_register_pid() to register a client
+ * Returns true if the client registration matches reg,
+ * otherwise returns false
+ */
+u32 iwpm_check_registration(u8 nl_client, u32 reg);
+
+/**
+ * iwpm_set_registration - Set the client registration
+ * @nl_client: The index of the netlink client
+ * @reg: Registration type to set
  */
-int iwpm_registered_client(u8 nl_client);
+void iwpm_set_registration(u8 nl_client, u32 reg);
 
 /**
- * iwpm_set_registered - Set the port mapper client to registered or not
+ * iwpm_get_registration
  * @nl_client: The index of the netlink client
- * @reg: 1 if registered or 0 if not
+ *
+ * Returns the client registration type
  */
-void iwpm_set_registered(u8 nl_client, int reg);
+u32 iwpm_get_registration(u8 nl_client);
 
 /**
  * iwpm_send_mapinfo - Send local and mapped IPv4/IPv6 address info of
diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index 74c30f4c557e..786fc51bf04b 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
  * Copyright (c) 2005 Mellanox Technologies Ltd.  All rights reserved.
  * Copyright (c) 2009 HNR Consulting. All rights reserved.
+ * Copyright (c) 2014 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
@@ -44,6 +45,7 @@
 #include "mad_priv.h"
 #include "mad_rmpp.h"
 #include "smi.h"
+#include "opa_smi.h"
 #include "agent.h"
 
 MODULE_LICENSE("Dual BSD/GPL");
@@ -59,8 +61,6 @@ MODULE_PARM_DESC(send_queue_size, "Size of send queue in number of work requests
 module_param_named(recv_queue_size, mad_recvq_size, int, 0444);
 MODULE_PARM_DESC(recv_queue_size, "Size of receive queue in number of work requests");
 
-static struct kmem_cache *ib_mad_cache;
-
 static struct list_head ib_mad_port_list;
 static u32 ib_mad_client_id = 0;
 
@@ -73,7 +73,7 @@ static int method_in_use(struct ib_mad_mgmt_method_table **method,
 static void remove_mad_reg_req(struct ib_mad_agent_private *priv);
 static struct ib_mad_agent_private *find_mad_agent(
                                         struct ib_mad_port_private *port_priv,
-                                        struct ib_mad *mad);
+                                        const struct ib_mad_hdr *mad);
 static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
                                     struct ib_mad_private *mad);
 static void cancel_mads(struct ib_mad_agent_private *mad_agent_priv);
@@ -179,12 +179,12 @@ static int is_vendor_method_in_use(
         return 0;
 }
 
-int ib_response_mad(struct ib_mad *mad)
+int ib_response_mad(const struct ib_mad_hdr *hdr)
 {
-        return ((mad->mad_hdr.method & IB_MGMT_METHOD_RESP) ||
-                (mad->mad_hdr.method == IB_MGMT_METHOD_TRAP_REPRESS) ||
-                ((mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_BM) &&
-                 (mad->mad_hdr.attr_mod & IB_BM_ATTR_MOD_RESP)));
+        return ((hdr->method & IB_MGMT_METHOD_RESP) ||
+                (hdr->method == IB_MGMT_METHOD_TRAP_REPRESS) ||
+                ((hdr->mgmt_class == IB_MGMT_CLASS_BM) &&
+                 (hdr->attr_mod & IB_BM_ATTR_MOD_RESP)));
 }
 EXPORT_SYMBOL(ib_response_mad);
 
@@ -717,6 +717,32 @@ static void build_smp_wc(struct ib_qp *qp,
         wc->port_num = port_num;
 }
 
+static size_t mad_priv_size(const struct ib_mad_private *mp)
+{
+        return sizeof(struct ib_mad_private) + mp->mad_size;
+}
+
+static struct ib_mad_private *alloc_mad_private(size_t mad_size, gfp_t flags)
+{
+        size_t size = sizeof(struct ib_mad_private) + mad_size;
+        struct ib_mad_private *ret = kzalloc(size, flags);
+
+        if (ret)
+                ret->mad_size = mad_size;
+
+        return ret;
+}
+
+static size_t port_mad_size(const struct ib_mad_port_private *port_priv)
+{
+        return rdma_max_mad_size(port_priv->device, port_priv->port_num);
+}
+
+static size_t mad_priv_dma_size(const struct ib_mad_private *mp)
+{
+        return sizeof(struct ib_grh) + mp->mad_size;
+}
+
 /*
  * Return 0 if SMP is to be sent
  * Return 1 if SMP was consumed locally (whether or not solicited)
@@ -727,6 +753,7 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
 {
         int ret = 0;
         struct ib_smp *smp = mad_send_wr->send_buf.mad;
+        struct opa_smp *opa_smp = (struct opa_smp *)smp;
         unsigned long flags;
         struct ib_mad_local_private *local;
         struct ib_mad_private *mad_priv;
@@ -736,8 +763,13 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
         u8 port_num;
         struct ib_wc mad_wc;
         struct ib_send_wr *send_wr = &mad_send_wr->send_wr;
+        size_t mad_size = port_mad_size(mad_agent_priv->qp_info->port_priv);
+        u16 out_mad_pkey_index = 0;
+        u16 drslid;
+        bool opa = rdma_cap_opa_mad(mad_agent_priv->qp_info->port_priv->device,
+                                    mad_agent_priv->qp_info->port_priv->port_num);
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH &&
+        if (rdma_cap_ib_switch(device) &&
             smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
                 port_num = send_wr->wr.ud.port_num;
         else
@@ -749,19 +781,49 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
          * If we are at the start of the LID routed part, don't update the
          * hop_ptr or hop_cnt.  See section 14.2.2, Vol 1 IB spec.
          */
-        if ((ib_get_smp_direction(smp) ? smp->dr_dlid : smp->dr_slid) ==
-             IB_LID_PERMISSIVE &&
-             smi_handle_dr_smp_send(smp, device->node_type, port_num) ==
-             IB_SMI_DISCARD) {
-                ret = -EINVAL;
-                dev_err(&device->dev, "Invalid directed route\n");
-                goto out;
-        }
+        if (opa && smp->class_version == OPA_SMP_CLASS_VERSION) {
+                u32 opa_drslid;
+
+                if ((opa_get_smp_direction(opa_smp)
+                     ? opa_smp->route.dr.dr_dlid : opa_smp->route.dr.dr_slid) ==
+                     OPA_LID_PERMISSIVE &&
+                     opa_smi_handle_dr_smp_send(opa_smp,
+                                                rdma_cap_ib_switch(device),
+                                                port_num) == IB_SMI_DISCARD) {
+                        ret = -EINVAL;
+                        dev_err(&device->dev, "OPA Invalid directed route\n");
+                        goto out;
+                }
+                opa_drslid = be32_to_cpu(opa_smp->route.dr.dr_slid);
+                if (opa_drslid != be32_to_cpu(OPA_LID_PERMISSIVE) &&
+                    opa_drslid & 0xffff0000) {
+                        ret = -EINVAL;
+                        dev_err(&device->dev, "OPA Invalid dr_slid 0x%x\n",
+                               opa_drslid);
+                        goto out;
+                }
+                drslid = (u16)(opa_drslid & 0x0000ffff);
 
-        /* Check to post send on QP or process locally */
-        if (smi_check_local_smp(smp, device) == IB_SMI_DISCARD &&
-            smi_check_local_returning_smp(smp, device) == IB_SMI_DISCARD)
-                goto out;
+                /* Check to post send on QP or process locally */
+                if (opa_smi_check_local_smp(opa_smp, device) == IB_SMI_DISCARD &&
+                    opa_smi_check_local_returning_smp(opa_smp, device) == IB_SMI_DISCARD)
+                        goto out;
+        } else {
+                if ((ib_get_smp_direction(smp) ? smp->dr_dlid : smp->dr_slid) ==
+                     IB_LID_PERMISSIVE &&
+                     smi_handle_dr_smp_send(smp, rdma_cap_ib_switch(device), port_num) ==
+                     IB_SMI_DISCARD) {
+                        ret = -EINVAL;
+                        dev_err(&device->dev, "Invalid directed route\n");
+                        goto out;
+                }
+                drslid = be16_to_cpu(smp->dr_slid);
+
+                /* Check to post send on QP or process locally */
+                if (smi_check_local_smp(smp, device) == IB_SMI_DISCARD &&
+                    smi_check_local_returning_smp(smp, device) == IB_SMI_DISCARD)
+                        goto out;
+        }
 
         local = kmalloc(sizeof *local, GFP_ATOMIC);
         if (!local) {
@@ -771,7 +833,7 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
         }
         local->mad_priv = NULL;
         local->recv_mad_agent = NULL;
-        mad_priv = kmem_cache_alloc(ib_mad_cache, GFP_ATOMIC);
+        mad_priv = alloc_mad_private(mad_size, GFP_ATOMIC);
         if (!mad_priv) {
                 ret = -ENOMEM;
                 dev_err(&device->dev, "No memory for local response MAD\n");
@@ -780,18 +842,25 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
         }
 
         build_smp_wc(mad_agent_priv->agent.qp,
-                     send_wr->wr_id, be16_to_cpu(smp->dr_slid),
+                     send_wr->wr_id, drslid,
                      send_wr->wr.ud.pkey_index,
                      send_wr->wr.ud.port_num, &mad_wc);
 
+        if (opa && smp->base_version == OPA_MGMT_BASE_VERSION) {
+                mad_wc.byte_len = mad_send_wr->send_buf.hdr_len
+                                        + mad_send_wr->send_buf.data_len
+                                        + sizeof(struct ib_grh);
+        }
+
         /* No GRH for DR SMP */
         ret = device->process_mad(device, 0, port_num, &mad_wc, NULL,
-                                  (struct ib_mad *)smp,
-                                  (struct ib_mad *)&mad_priv->mad);
+                                  (const struct ib_mad_hdr *)smp, mad_size,
+                                  (struct ib_mad_hdr *)mad_priv->mad,
+                                  &mad_size, &out_mad_pkey_index);
         switch (ret)
         {
         case IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY:
-                if (ib_response_mad(&mad_priv->mad.mad) &&
+                if (ib_response_mad((const struct ib_mad_hdr *)mad_priv->mad) &&
                     mad_agent_priv->agent.recv_handler) {
                         local->mad_priv = mad_priv;
                         local->recv_mad_agent = mad_agent_priv;
@@ -801,39 +870,43 @@ static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv,
                          */
                         atomic_inc(&mad_agent_priv->refcount);
                 } else
-                        kmem_cache_free(ib_mad_cache, mad_priv);
+                        kfree(mad_priv);
                 break;
         case IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED:
-                kmem_cache_free(ib_mad_cache, mad_priv);
+                kfree(mad_priv);
                 break;
         case IB_MAD_RESULT_SUCCESS:
                 /* Treat like an incoming receive MAD */
                 port_priv = ib_get_mad_port(mad_agent_priv->agent.device,
                                             mad_agent_priv->agent.port_num);
                 if (port_priv) {
-                        memcpy(&mad_priv->mad.mad, smp, sizeof(struct ib_mad));
+                        memcpy(mad_priv->mad, smp, mad_priv->mad_size);
                         recv_mad_agent = find_mad_agent(port_priv,
-                                                        &mad_priv->mad.mad);
+                                                        (const struct ib_mad_hdr *)mad_priv->mad);
                 }
                 if (!port_priv || !recv_mad_agent) {
                         /*
                          * No receiving agent so drop packet and
                          * generate send completion.
                          */
-                        kmem_cache_free(ib_mad_cache, mad_priv);
+                        kfree(mad_priv);
                         break;
                 }
                 local->mad_priv = mad_priv;
                 local->recv_mad_agent = recv_mad_agent;
                 break;
         default:
-                kmem_cache_free(ib_mad_cache, mad_priv);
+                kfree(mad_priv);
                 kfree(local);
                 ret = -EINVAL;
                 goto out;
         }
 
         local->mad_send_wr = mad_send_wr;
+        if (opa) {
+                local->mad_send_wr->send_wr.wr.ud.pkey_index = out_mad_pkey_index;
+                local->return_wc_byte_len = mad_size;
+        }
         /* Reference MAD agent until send side of local completion handled */
         atomic_inc(&mad_agent_priv->refcount);
         /* Queue local completion to local list */
@@ -847,11 +920,11 @@ out:
         return ret;
 }
 
-static int get_pad_size(int hdr_len, int data_len)
+static int get_pad_size(int hdr_len, int data_len, size_t mad_size)
 {
         int seg_size, pad;
 
-        seg_size = sizeof(struct ib_mad) - hdr_len;
+        seg_size = mad_size - hdr_len;
         if (data_len && seg_size) {
                 pad = seg_size - data_len % seg_size;
                 return pad == seg_size ? 0 : pad;
@@ -870,14 +943,15 @@ static void free_send_rmpp_list(struct ib_mad_send_wr_private *mad_send_wr)
 }
 
 static int alloc_send_rmpp_list(struct ib_mad_send_wr_private *send_wr,
-                                gfp_t gfp_mask)
+                                size_t mad_size, gfp_t gfp_mask)
 {
         struct ib_mad_send_buf *send_buf = &send_wr->send_buf;
         struct ib_rmpp_mad *rmpp_mad = send_buf->mad;
         struct ib_rmpp_segment *seg = NULL;
         int left, seg_size, pad;
 
-        send_buf->seg_size = sizeof (struct ib_mad) - send_buf->hdr_len;
+        send_buf->seg_size = mad_size - send_buf->hdr_len;
+        send_buf->seg_rmpp_size = mad_size - IB_MGMT_RMPP_HDR;
         seg_size = send_buf->seg_size;
         pad = send_wr->pad;
 
@@ -910,7 +984,7 @@ static int alloc_send_rmpp_list(struct ib_mad_send_wr_private *send_wr,
         return 0;
 }
 
-int ib_mad_kernel_rmpp_agent(struct ib_mad_agent *agent)
+int ib_mad_kernel_rmpp_agent(const struct ib_mad_agent *agent)
 {
         return agent->rmpp_version && !(agent->flags & IB_MAD_USER_RMPP);
 }
@@ -920,26 +994,37 @@ struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent,
                                             u32 remote_qpn, u16 pkey_index,
                                             int rmpp_active,
                                             int hdr_len, int data_len,
-                                            gfp_t gfp_mask)
+                                            gfp_t gfp_mask,
+                                            u8 base_version)
 {
         struct ib_mad_agent_private *mad_agent_priv;
         struct ib_mad_send_wr_private *mad_send_wr;
         int pad, message_size, ret, size;
         void *buf;
+        size_t mad_size;
+        bool opa;
 
         mad_agent_priv = container_of(mad_agent, struct ib_mad_agent_private,
                                       agent);
-        pad = get_pad_size(hdr_len, data_len);
+
+        opa = rdma_cap_opa_mad(mad_agent->device, mad_agent->port_num);
+
+        if (opa && base_version == OPA_MGMT_BASE_VERSION)
+                mad_size = sizeof(struct opa_mad);
+        else
+                mad_size = sizeof(struct ib_mad);
+
+        pad = get_pad_size(hdr_len, data_len, mad_size);
         message_size = hdr_len + data_len + pad;
 
         if (ib_mad_kernel_rmpp_agent(mad_agent)) {
-                if (!rmpp_active && message_size > sizeof(struct ib_mad))
+                if (!rmpp_active && message_size > mad_size)
                         return ERR_PTR(-EINVAL);
         } else
-                if (rmpp_active || message_size > sizeof(struct ib_mad))
+                if (rmpp_active || message_size > mad_size)
                         return ERR_PTR(-EINVAL);
 
-        size = rmpp_active ? hdr_len : sizeof(struct ib_mad);
+        size = rmpp_active ? hdr_len : mad_size;
         buf = kzalloc(sizeof *mad_send_wr + size, gfp_mask);
         if (!buf)
                 return ERR_PTR(-ENOMEM);
@@ -954,7 +1039,14 @@ struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent,
         mad_send_wr->mad_agent_priv = mad_agent_priv;
         mad_send_wr->sg_list[0].length = hdr_len;
         mad_send_wr->sg_list[0].lkey = mad_agent->mr->lkey;
-        mad_send_wr->sg_list[1].length = sizeof(struct ib_mad) - hdr_len;
+
+        /* OPA MADs don't have to be the full 2048 bytes */
+        if (opa && base_version == OPA_MGMT_BASE_VERSION &&
+            data_len < mad_size - hdr_len)
+                mad_send_wr->sg_list[1].length = data_len;
+        else
+                mad_send_wr->sg_list[1].length = mad_size - hdr_len;
+
         mad_send_wr->sg_list[1].lkey = mad_agent->mr->lkey;
 
         mad_send_wr->send_wr.wr_id = (unsigned long) mad_send_wr;
@@ -967,7 +1059,7 @@ struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent,
         mad_send_wr->send_wr.wr.ud.pkey_index = pkey_index;
 
         if (rmpp_active) {
-                ret = alloc_send_rmpp_list(mad_send_wr, gfp_mask);
+                ret = alloc_send_rmpp_list(mad_send_wr, mad_size, gfp_mask);
                 if (ret) {
                         kfree(buf);
                         return ERR_PTR(ret);
@@ -1237,7 +1329,7 @@ void ib_free_recv_mad(struct ib_mad_recv_wc *mad_recv_wc)
                                             recv_wc);
                 priv = container_of(mad_priv_hdr, struct ib_mad_private,
                                     header);
-                kmem_cache_free(ib_mad_cache, priv);
+                kfree(priv);
         }
 }
 EXPORT_SYMBOL(ib_free_recv_mad);
@@ -1324,7 +1416,7 @@ static int check_vendor_class(struct ib_mad_mgmt_vendor_class *vendor_class)
 }
 
 static int find_vendor_oui(struct ib_mad_mgmt_vendor_class *vendor_class,
-                           char *oui)
+                           const char *oui)
 {
         int i;
 
@@ -1622,13 +1714,13 @@ out:
 
 static struct ib_mad_agent_private *
 find_mad_agent(struct ib_mad_port_private *port_priv,
-               struct ib_mad *mad)
+               const struct ib_mad_hdr *mad_hdr)
 {
         struct ib_mad_agent_private *mad_agent = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&port_priv->reg_lock, flags);
-        if (ib_response_mad(mad)) {
+        if (ib_response_mad(mad_hdr)) {
                 u32 hi_tid;
                 struct ib_mad_agent_private *entry;
 
@@ -1636,7 +1728,7 @@ find_mad_agent(struct ib_mad_port_private *port_priv,
                  * Routing is based on high 32 bits of transaction ID
                  * of MAD.
                  */
-                hi_tid = be64_to_cpu(mad->mad_hdr.tid) >> 32;
+                hi_tid = be64_to_cpu(mad_hdr->tid) >> 32;
                 list_for_each_entry(entry, &port_priv->agent_list, agent_list) {
                         if (entry->agent.hi_tid == hi_tid) {
                                 mad_agent = entry;
@@ -1648,45 +1740,45 @@ find_mad_agent(struct ib_mad_port_private *port_priv,
                 struct ib_mad_mgmt_method_table *method;
                 struct ib_mad_mgmt_vendor_class_table *vendor;
                 struct ib_mad_mgmt_vendor_class *vendor_class;
-                struct ib_vendor_mad *vendor_mad;
+                const struct ib_vendor_mad *vendor_mad;
                 int index;
 
                 /*
                  * Routing is based on version, class, and method
                  * For "newer" vendor MADs, also based on OUI
                  */
-                if (mad->mad_hdr.class_version >= MAX_MGMT_VERSION)
+                if (mad_hdr->class_version >= MAX_MGMT_VERSION)
                         goto out;
-                if (!is_vendor_class(mad->mad_hdr.mgmt_class)) {
+                if (!is_vendor_class(mad_hdr->mgmt_class)) {
                         class = port_priv->version[
-                                        mad->mad_hdr.class_version].class;
+                                        mad_hdr->class_version].class;
                         if (!class)
                                 goto out;
-                        if (convert_mgmt_class(mad->mad_hdr.mgmt_class) >=
+                        if (convert_mgmt_class(mad_hdr->mgmt_class) >=
                             IB_MGMT_MAX_METHODS)
                                 goto out;
                         method = class->method_table[convert_mgmt_class(
-                                                        mad->mad_hdr.mgmt_class)];
+                                                        mad_hdr->mgmt_class)];
                         if (method)
-                                mad_agent = method->agent[mad->mad_hdr.method &
+                                mad_agent = method->agent[mad_hdr->method &
                                                           ~IB_MGMT_METHOD_RESP];
                 } else {
                         vendor = port_priv->version[
-                                        mad->mad_hdr.class_version].vendor;
+                                        mad_hdr->class_version].vendor;
                         if (!vendor)
                                 goto out;
                         vendor_class = vendor->vendor_class[vendor_class_index(
-                                                mad->mad_hdr.mgmt_class)];
+                                                mad_hdr->mgmt_class)];
                         if (!vendor_class)
                                 goto out;
                         /* Find matching OUI */
-                        vendor_mad = (struct ib_vendor_mad *)mad;
+                        vendor_mad = (const struct ib_vendor_mad *)mad_hdr;
                         index = find_vendor_oui(vendor_class, vendor_mad->oui);
                         if (index == -1)
                                 goto out;
                         method = vendor_class->method_table[index];
                         if (method) {
-                                mad_agent = method->agent[mad->mad_hdr.method &
+                                mad_agent = method->agent[mad_hdr->method &
                                                           ~IB_MGMT_METHOD_RESP];
                         }
                 }
@@ -1708,20 +1800,24 @@ out:
         return mad_agent;
 }
 
-static int validate_mad(struct ib_mad *mad, u32 qp_num)
+static int validate_mad(const struct ib_mad_hdr *mad_hdr,
+                        const struct ib_mad_qp_info *qp_info,
+                        bool opa)
 {
         int valid = 0;
+        u32 qp_num = qp_info->qp->qp_num;
 
         /* Make sure MAD base version is understood */
-        if (mad->mad_hdr.base_version != IB_MGMT_BASE_VERSION) {
-                pr_err("MAD received with unsupported base version %d\n",
-                        mad->mad_hdr.base_version);
+        if (mad_hdr->base_version != IB_MGMT_BASE_VERSION &&
+            (!opa || mad_hdr->base_version != OPA_MGMT_BASE_VERSION)) {
+                pr_err("MAD received with unsupported base version %d %s\n",
+                       mad_hdr->base_version, opa ? "(opa)" : "");
                 goto out;
         }
 
         /* Filter SMI packets sent to other than QP0 */
-        if ((mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED) ||
-            (mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)) {
+        if ((mad_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED) ||
+            (mad_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)) {
                 if (qp_num == 0)
                         valid = 1;
         } else {
@@ -1734,8 +1830,8 @@ out:
         return valid;
 }
 
-static int is_data_mad(struct ib_mad_agent_private *mad_agent_priv,
-                       struct ib_mad_hdr *mad_hdr)
+static int is_rmpp_data_mad(const struct ib_mad_agent_private *mad_agent_priv,
+                            const struct ib_mad_hdr *mad_hdr)
 {
         struct ib_rmpp_mad *rmpp_mad;
 
@@ -1747,16 +1843,16 @@ static int is_data_mad(struct ib_mad_agent_private *mad_agent_priv,
                 (rmpp_mad->rmpp_hdr.rmpp_type == IB_MGMT_RMPP_TYPE_DATA);
 }
 
-static inline int rcv_has_same_class(struct ib_mad_send_wr_private *wr,
-                                     struct ib_mad_recv_wc *rwc)
+static inline int rcv_has_same_class(const struct ib_mad_send_wr_private *wr,
+                                     const struct ib_mad_recv_wc *rwc)
 {
-        return ((struct ib_mad *)(wr->send_buf.mad))->mad_hdr.mgmt_class ==
+        return ((struct ib_mad_hdr *)(wr->send_buf.mad))->mgmt_class ==
                 rwc->recv_buf.mad->mad_hdr.mgmt_class;
 }
 
-static inline int rcv_has_same_gid(struct ib_mad_agent_private *mad_agent_priv,
-                                   struct ib_mad_send_wr_private *wr,
-                                   struct ib_mad_recv_wc *rwc )
+static inline int rcv_has_same_gid(const struct ib_mad_agent_private *mad_agent_priv,
+                                   const struct ib_mad_send_wr_private *wr,
+                                   const struct ib_mad_recv_wc *rwc )
 {
         struct ib_ah_attr attr;
         u8 send_resp, rcv_resp;
@@ -1765,8 +1861,8 @@ static inline int rcv_has_same_gid(struct ib_mad_agent_private *mad_agent_priv,
         u8 port_num = mad_agent_priv->agent.port_num;
         u8 lmc;
 
-        send_resp = ib_response_mad((struct ib_mad *)wr->send_buf.mad);
-        rcv_resp = ib_response_mad(rwc->recv_buf.mad);
+        send_resp = ib_response_mad((struct ib_mad_hdr *)wr->send_buf.mad);
+        rcv_resp = ib_response_mad(&rwc->recv_buf.mad->mad_hdr);
 
         if (send_resp == rcv_resp)
                 /* both requests, or both responses. GIDs different */
@@ -1811,22 +1907,22 @@ static inline int is_direct(u8 class)
 }
 
 struct ib_mad_send_wr_private*
-ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv,
-                 struct ib_mad_recv_wc *wc)
+ib_find_send_mad(const struct ib_mad_agent_private *mad_agent_priv,
+                 const struct ib_mad_recv_wc *wc)
 {
         struct ib_mad_send_wr_private *wr;
-        struct ib_mad *mad;
+        const struct ib_mad_hdr *mad_hdr;
 
-        mad = (struct ib_mad *)wc->recv_buf.mad;
+        mad_hdr = &wc->recv_buf.mad->mad_hdr;
 
         list_for_each_entry(wr, &mad_agent_priv->wait_list, agent_list) {
-                if ((wr->tid == mad->mad_hdr.tid) &&
+                if ((wr->tid == mad_hdr->tid) &&
                     rcv_has_same_class(wr, wc) &&
                     /*
                      * Don't check GID for direct routed MADs.
                      * These might have permissive LIDs.
                      */
-                    (is_direct(wc->recv_buf.mad->mad_hdr.mgmt_class) ||
+                    (is_direct(mad_hdr->mgmt_class) ||
                      rcv_has_same_gid(mad_agent_priv, wr, wc)))
                         return (wr->status == IB_WC_SUCCESS) ? wr : NULL;
         }
@@ -1836,15 +1932,15 @@ ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv,
          * been notified that the send has completed
          */
         list_for_each_entry(wr, &mad_agent_priv->send_list, agent_list) {
-                if (is_data_mad(mad_agent_priv, wr->send_buf.mad) &&
-                    wr->tid == mad->mad_hdr.tid &&
+                if (is_rmpp_data_mad(mad_agent_priv, wr->send_buf.mad) &&
+                    wr->tid == mad_hdr->tid &&
                     wr->timeout &&
                     rcv_has_same_class(wr, wc) &&
                     /*
                      * Don't check GID for direct routed MADs.
                      * These might have permissive LIDs.
                      */
-                    (is_direct(wc->recv_buf.mad->mad_hdr.mgmt_class) ||
+                    (is_direct(mad_hdr->mgmt_class) ||
                      rcv_has_same_gid(mad_agent_priv, wr, wc)))
                         /* Verify request has not been canceled */
                         return (wr->status == IB_WC_SUCCESS) ? wr : NULL;
@@ -1879,7 +1975,7 @@ static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv,
         }
 
         /* Complete corresponding request */
-        if (ib_response_mad(mad_recv_wc->recv_buf.mad)) {
+        if (ib_response_mad(&mad_recv_wc->recv_buf.mad->mad_hdr)) {
                 spin_lock_irqsave(&mad_agent_priv->lock, flags);
                 mad_send_wr = ib_find_send_mad(mad_agent_priv, mad_recv_wc);
                 if (!mad_send_wr) {
@@ -1924,26 +2020,163 @@ 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)
+static enum smi_action handle_ib_smi(const struct ib_mad_port_private *port_priv,
+                                     const struct ib_mad_qp_info *qp_info,
+                                     const struct ib_wc *wc,
+                                     int port_num,
+                                     struct ib_mad_private *recv,
+                                     struct ib_mad_private *response)
+{
+        enum smi_forward_action retsmi;
+        struct ib_smp *smp = (struct ib_smp *)recv->mad;
+
+        if (smi_handle_dr_smp_recv(smp,
+                                   rdma_cap_ib_switch(port_priv->device),
+                                   port_num,
+                                   port_priv->device->phys_port_cnt) ==
+                                   IB_SMI_DISCARD)
+                return IB_SMI_DISCARD;
+
+        retsmi = smi_check_forward_dr_smp(smp);
+        if (retsmi == IB_SMI_LOCAL)
+                return IB_SMI_HANDLE;
+
+        if (retsmi == IB_SMI_SEND) { /* don't forward */
+                if (smi_handle_dr_smp_send(smp,
+                                           rdma_cap_ib_switch(port_priv->device),
+                                           port_num) == IB_SMI_DISCARD)
+                        return IB_SMI_DISCARD;
+
+                if (smi_check_local_smp(smp, port_priv->device) == IB_SMI_DISCARD)
+                        return IB_SMI_DISCARD;
+        } else if (rdma_cap_ib_switch(port_priv->device)) {
+                /* forward case for switches */
+                memcpy(response, recv, mad_priv_size(response));
+                response->header.recv_wc.wc = &response->header.wc;
+                response->header.recv_wc.recv_buf.mad = (struct ib_mad *)response->mad;
+                response->header.recv_wc.recv_buf.grh = &response->grh;
+
+                agent_send_response((const struct ib_mad_hdr *)response->mad,
+                                    &response->grh, wc,
+                                    port_priv->device,
+                                    smi_get_fwd_port(smp),
+                                    qp_info->qp->qp_num,
+                                    response->mad_size,
+                                    false);
+
+                return IB_SMI_DISCARD;
+        }
+        return IB_SMI_HANDLE;
+}
+
+static bool generate_unmatched_resp(const struct ib_mad_private *recv,
+                                    struct ib_mad_private *response,
+                                    size_t *resp_len, bool opa)
 {
-        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);
+        const struct ib_mad_hdr *recv_hdr = (const struct ib_mad_hdr *)recv->mad;
+        struct ib_mad_hdr *resp_hdr = (struct ib_mad_hdr *)response->mad;
+
+        if (recv_hdr->method == IB_MGMT_METHOD_GET ||
+            recv_hdr->method == IB_MGMT_METHOD_SET) {
+                memcpy(response, recv, mad_priv_size(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.mad = (struct ib_mad *)response->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;
+                resp_hdr->method = IB_MGMT_METHOD_GET_RESP;
+                resp_hdr->status = cpu_to_be16(IB_MGMT_MAD_STATUS_UNSUPPORTED_METHOD_ATTRIB);
+                if (recv_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                        resp_hdr->status |= IB_SMP_DIRECTION;
+
+                if (opa && recv_hdr->base_version == OPA_MGMT_BASE_VERSION) {
+                        if (recv_hdr->mgmt_class ==
+                            IB_MGMT_CLASS_SUBN_LID_ROUTED ||
+                            recv_hdr->mgmt_class ==
+                            IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                                *resp_len = opa_get_smp_header_size(
+                                                        (struct opa_smp *)recv->mad);
+                        else
+                                *resp_len = sizeof(struct ib_mad_hdr);
+                }
 
                 return true;
         } else {
                 return false;
         }
 }
+
+static enum smi_action
+handle_opa_smi(struct ib_mad_port_private *port_priv,
+               struct ib_mad_qp_info *qp_info,
+               struct ib_wc *wc,
+               int port_num,
+               struct ib_mad_private *recv,
+               struct ib_mad_private *response)
+{
+        enum smi_forward_action retsmi;
+        struct opa_smp *smp = (struct opa_smp *)recv->mad;
+
+        if (opa_smi_handle_dr_smp_recv(smp,
+                                   rdma_cap_ib_switch(port_priv->device),
+                                   port_num,
+                                   port_priv->device->phys_port_cnt) ==
+                                   IB_SMI_DISCARD)
+                return IB_SMI_DISCARD;
+
+        retsmi = opa_smi_check_forward_dr_smp(smp);
+        if (retsmi == IB_SMI_LOCAL)
+                return IB_SMI_HANDLE;
+
+        if (retsmi == IB_SMI_SEND) { /* don't forward */
+                if (opa_smi_handle_dr_smp_send(smp,
+                                           rdma_cap_ib_switch(port_priv->device),
+                                           port_num) == IB_SMI_DISCARD)
+                        return IB_SMI_DISCARD;
+
+                if (opa_smi_check_local_smp(smp, port_priv->device) ==
+                    IB_SMI_DISCARD)
+                        return IB_SMI_DISCARD;
+
+        } else if (rdma_cap_ib_switch(port_priv->device)) {
+                /* forward case for switches */
+                memcpy(response, recv, mad_priv_size(response));
+                response->header.recv_wc.wc = &response->header.wc;
+                response->header.recv_wc.recv_buf.opa_mad =
+                                (struct opa_mad *)response->mad;
+                response->header.recv_wc.recv_buf.grh = &response->grh;
+
+                agent_send_response((const struct ib_mad_hdr *)response->mad,
+                                    &response->grh, wc,
+                                    port_priv->device,
+                                    opa_smi_get_fwd_port(smp),
+                                    qp_info->qp->qp_num,
+                                    recv->header.wc.byte_len,
+                                    true);
+
+                return IB_SMI_DISCARD;
+        }
+
+        return IB_SMI_HANDLE;
+}
+
+static enum smi_action
+handle_smi(struct ib_mad_port_private *port_priv,
+           struct ib_mad_qp_info *qp_info,
+           struct ib_wc *wc,
+           int port_num,
+           struct ib_mad_private *recv,
+           struct ib_mad_private *response,
+           bool opa)
+{
+        struct ib_mad_hdr *mad_hdr = (struct ib_mad_hdr *)recv->mad;
+
+        if (opa && mad_hdr->base_version == OPA_MGMT_BASE_VERSION &&
+            mad_hdr->class_version == OPA_SMI_CLASS_VERSION)
+                return handle_opa_smi(port_priv, qp_info, wc, port_num, recv,
+                                      response);
+
+        return handle_ib_smi(port_priv, qp_info, wc, port_num, recv, response);
+}
+
 static void ib_mad_recv_done_handler(struct ib_mad_port_private *port_priv,
                                      struct ib_wc *wc)
 {
@@ -1954,109 +2187,97 @@ static void ib_mad_recv_done_handler(struct ib_mad_port_private *port_priv,
         struct ib_mad_agent_private *mad_agent;
         int port_num;
         int ret = IB_MAD_RESULT_SUCCESS;
+        size_t mad_size;
+        u16 resp_mad_pkey_index = 0;
+        bool opa;
 
         mad_list = (struct ib_mad_list_head *)(unsigned long)wc->wr_id;
         qp_info = mad_list->mad_queue->qp_info;
         dequeue_mad(mad_list);
 
+        opa = rdma_cap_opa_mad(qp_info->port_priv->device,
+                               qp_info->port_priv->port_num);
+
         mad_priv_hdr = container_of(mad_list, struct ib_mad_private_header,
                                     mad_list);
         recv = container_of(mad_priv_hdr, struct ib_mad_private, header);
         ib_dma_unmap_single(port_priv->device,
                             recv->header.mapping,
-                            sizeof(struct ib_mad_private) -
-                              sizeof(struct ib_mad_private_header),
+                            mad_priv_dma_size(recv),
                             DMA_FROM_DEVICE);
 
         /* Setup MAD receive work completion from "normal" work completion */
         recv->header.wc = *wc;
         recv->header.recv_wc.wc = &recv->header.wc;
-        recv->header.recv_wc.mad_len = sizeof(struct ib_mad);
-        recv->header.recv_wc.recv_buf.mad = &recv->mad.mad;
+
+        if (opa && ((struct ib_mad_hdr *)(recv->mad))->base_version == OPA_MGMT_BASE_VERSION) {
+                recv->header.recv_wc.mad_len = wc->byte_len - sizeof(struct ib_grh);
+                recv->header.recv_wc.mad_seg_size = sizeof(struct opa_mad);
+        } else {
+                recv->header.recv_wc.mad_len = sizeof(struct ib_mad);
+                recv->header.recv_wc.mad_seg_size = sizeof(struct ib_mad);
+        }
+
+        recv->header.recv_wc.recv_buf.mad = (struct ib_mad *)recv->mad;
         recv->header.recv_wc.recv_buf.grh = &recv->grh;
 
         if (atomic_read(&qp_info->snoop_count))
                 snoop_recv(qp_info, &recv->header.recv_wc, IB_MAD_SNOOP_RECVS);
 
         /* Validate MAD */
-        if (!validate_mad(&recv->mad.mad, qp_info->qp->qp_num))
+        if (!validate_mad((const struct ib_mad_hdr *)recv->mad, qp_info, opa))
                 goto out;
 
-        response = kmem_cache_alloc(ib_mad_cache, GFP_KERNEL);
+        mad_size = recv->mad_size;
+        response = alloc_mad_private(mad_size, GFP_KERNEL);
         if (!response) {
                 dev_err(&port_priv->device->dev,
                         "ib_mad_recv_done_handler no memory for response buffer\n");
                 goto out;
         }
 
-        if (port_priv->device->node_type == RDMA_NODE_IB_SWITCH)
+        if (rdma_cap_ib_switch(port_priv->device))
                 port_num = wc->port_num;
         else
                 port_num = port_priv->port_num;
 
-        if (recv->mad.mad.mad_hdr.mgmt_class ==
+        if (((struct ib_mad_hdr *)recv->mad)->mgmt_class ==
             IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
-                enum smi_forward_action retsmi;
-
-                if (smi_handle_dr_smp_recv(&recv->mad.smp,
-                                           port_priv->device->node_type,
-                                           port_num,
-                                           port_priv->device->phys_port_cnt) ==
-                                           IB_SMI_DISCARD)
-                        goto out;
-
-                retsmi = smi_check_forward_dr_smp(&recv->mad.smp);
-                if (retsmi == IB_SMI_LOCAL)
-                        goto local;
-
-                if (retsmi == IB_SMI_SEND) { /* don't forward */
-                        if (smi_handle_dr_smp_send(&recv->mad.smp,
-                                                   port_priv->device->node_type,
-                                                   port_num) == IB_SMI_DISCARD)
-                                goto out;
-
-                        if (smi_check_local_smp(&recv->mad.smp, port_priv->device) == IB_SMI_DISCARD)
-                                goto out;
-                } else if (port_priv->device->node_type == RDMA_NODE_IB_SWITCH) {
-                        /* forward case for switches */
-                        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;
-
-                        agent_send_response(&response->mad.mad,
-                                            &response->grh, wc,
-                                            port_priv->device,
-                                            smi_get_fwd_port(&recv->mad.smp),
-                                            qp_info->qp->qp_num);
-
+                if (handle_smi(port_priv, qp_info, wc, port_num, recv,
+                               response, opa)
+                    == IB_SMI_DISCARD)
                         goto out;
-                }
         }
 
-local:
         /* Give driver "right of first refusal" on incoming MAD */
         if (port_priv->device->process_mad) {
                 ret = port_priv->device->process_mad(port_priv->device, 0,
                                                      port_priv->port_num,
                                                      wc, &recv->grh,
-                                                     &recv->mad.mad,
-                                                     &response->mad.mad);
+                                                     (const struct ib_mad_hdr *)recv->mad,
+                                                     recv->mad_size,
+                                                     (struct ib_mad_hdr *)response->mad,
+                                                     &mad_size, &resp_mad_pkey_index);
+
+                if (opa)
+                        wc->pkey_index = resp_mad_pkey_index;
+
                 if (ret & IB_MAD_RESULT_SUCCESS) {
                         if (ret & IB_MAD_RESULT_CONSUMED)
                                 goto out;
                         if (ret & IB_MAD_RESULT_REPLY) {
-                                agent_send_response(&response->mad.mad,
+                                agent_send_response((const struct ib_mad_hdr *)response->mad,
                                                     &recv->grh, wc,
                                                     port_priv->device,
                                                     port_num,
-                                                    qp_info->qp->qp_num);
+                                                    qp_info->qp->qp_num,
+                                                    mad_size, opa);
                                 goto out;
                         }
                 }
         }
 
-        mad_agent = find_mad_agent(port_priv, &recv->mad.mad);
+        mad_agent = find_mad_agent(port_priv, (const struct ib_mad_hdr *)recv->mad);
         if (mad_agent) {
                 ib_mad_complete_recv(mad_agent, &recv->header.recv_wc);
                 /*
@@ -2065,17 +2286,17 @@ local:
                  */
                 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);
+                   generate_unmatched_resp(recv, response, &mad_size, opa)) {
+                agent_send_response((const struct ib_mad_hdr *)response->mad, &recv->grh, wc,
+                                    port_priv->device, port_num,
+                                    qp_info->qp->qp_num, mad_size, opa);
         }
 
 out:
         /* Post another receive request for this QP */
         if (response) {
                 ib_mad_post_receive_mads(qp_info, response);
-                if (recv)
-                        kmem_cache_free(ib_mad_cache, recv);
+                kfree(recv);
         } else
                 ib_mad_post_receive_mads(qp_info, recv);
 }
@@ -2411,7 +2632,8 @@ find_send_wr(struct ib_mad_agent_private *mad_agent_priv,
 
         list_for_each_entry(mad_send_wr, &mad_agent_priv->send_list,
                             agent_list) {
-                if (is_data_mad(mad_agent_priv, mad_send_wr->send_buf.mad) &&
+                if (is_rmpp_data_mad(mad_agent_priv,
+                                     mad_send_wr->send_buf.mad) &&
                     &mad_send_wr->send_buf == send_buf)
                         return mad_send_wr;
         }
@@ -2468,10 +2690,14 @@ static void local_completions(struct work_struct *work)
         int free_mad;
         struct ib_wc wc;
         struct ib_mad_send_wc mad_send_wc;
+        bool opa;
 
         mad_agent_priv =
                 container_of(work, struct ib_mad_agent_private, local_work);
 
+        opa = rdma_cap_opa_mad(mad_agent_priv->qp_info->port_priv->device,
+                               mad_agent_priv->qp_info->port_priv->port_num);
+
         spin_lock_irqsave(&mad_agent_priv->lock, flags);
         while (!list_empty(&mad_agent_priv->local_list)) {
                 local = list_entry(mad_agent_priv->local_list.next,
@@ -2481,6 +2707,7 @@ static void local_completions(struct work_struct *work)
                 spin_unlock_irqrestore(&mad_agent_priv->lock, flags);
                 free_mad = 0;
                 if (local->mad_priv) {
+                        u8 base_version;
                         recv_mad_agent = local->recv_mad_agent;
                         if (!recv_mad_agent) {
                                 dev_err(&mad_agent_priv->agent.device->dev,
@@ -2496,17 +2723,26 @@ static void local_completions(struct work_struct *work)
                         build_smp_wc(recv_mad_agent->agent.qp,
                                      (unsigned long) local->mad_send_wr,
                                      be16_to_cpu(IB_LID_PERMISSIVE),
-                                     0, recv_mad_agent->agent.port_num, &wc);
+                                     local->mad_send_wr->send_wr.wr.ud.pkey_index,
+                                     recv_mad_agent->agent.port_num, &wc);
 
                         local->mad_priv->header.recv_wc.wc = &wc;
-                        local->mad_priv->header.recv_wc.mad_len =
-                                                sizeof(struct ib_mad);
+
+                        base_version = ((struct ib_mad_hdr *)(local->mad_priv->mad))->base_version;
+                        if (opa && base_version == OPA_MGMT_BASE_VERSION) {
+                                local->mad_priv->header.recv_wc.mad_len = local->return_wc_byte_len;
+                                local->mad_priv->header.recv_wc.mad_seg_size = sizeof(struct opa_mad);
+                        } else {
+                                local->mad_priv->header.recv_wc.mad_len = sizeof(struct ib_mad);
+                                local->mad_priv->header.recv_wc.mad_seg_size = sizeof(struct ib_mad);
+                        }
+
                         INIT_LIST_HEAD(&local->mad_priv->header.recv_wc.rmpp_list);
                         list_add(&local->mad_priv->header.recv_wc.recv_buf.list,
                                  &local->mad_priv->header.recv_wc.rmpp_list);
                         local->mad_priv->header.recv_wc.recv_buf.grh = NULL;
                         local->mad_priv->header.recv_wc.recv_buf.mad =
-                                                &local->mad_priv->mad.mad;
+                                                (struct ib_mad *)local->mad_priv->mad;
                         if (atomic_read(&recv_mad_agent->qp_info->snoop_count))
                                 snoop_recv(recv_mad_agent->qp_info,
                                           &local->mad_priv->header.recv_wc,
@@ -2534,7 +2770,7 @@ local_send_completion:
                 spin_lock_irqsave(&mad_agent_priv->lock, flags);
                 atomic_dec(&mad_agent_priv->refcount);
                 if (free_mad)
-                        kmem_cache_free(ib_mad_cache, local->mad_priv);
+                        kfree(local->mad_priv);
                 kfree(local);
         }
         spin_unlock_irqrestore(&mad_agent_priv->lock, flags);
@@ -2649,7 +2885,6 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
         struct ib_mad_queue *recv_queue = &qp_info->recv_queue;
 
         /* Initialize common scatter list fields */
-        sg_list.length = sizeof *mad_priv - sizeof mad_priv->header;
         sg_list.lkey = (*qp_info->port_priv->mr).lkey;
 
         /* Initialize common receive WR fields */
@@ -2663,7 +2898,8 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
                         mad_priv = mad;
                         mad = NULL;
                 } else {
-                        mad_priv = kmem_cache_alloc(ib_mad_cache, GFP_KERNEL);
+                        mad_priv = alloc_mad_private(port_mad_size(qp_info->port_priv),
+                                                     GFP_ATOMIC);
                         if (!mad_priv) {
                                 dev_err(&qp_info->port_priv->device->dev,
                                         "No memory for receive buffer\n");
@@ -2671,10 +2907,10 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
                                 break;
                         }
                 }
+                sg_list.length = mad_priv_dma_size(mad_priv);
                 sg_list.addr = ib_dma_map_single(qp_info->port_priv->device,
                                                  &mad_priv->grh,
-                                                 sizeof *mad_priv -
-                                                   sizeof mad_priv->header,
+                                                 mad_priv_dma_size(mad_priv),
                                                  DMA_FROM_DEVICE);
                 if (unlikely(ib_dma_mapping_error(qp_info->port_priv->device,
                                                   sg_list.addr))) {
@@ -2698,10 +2934,9 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
                         spin_unlock_irqrestore(&recv_queue->lock, flags);
                         ib_dma_unmap_single(qp_info->port_priv->device,
                                             mad_priv->header.mapping,
-                                            sizeof *mad_priv -
-                                              sizeof mad_priv->header,
+                                            mad_priv_dma_size(mad_priv),
                                             DMA_FROM_DEVICE);
-                        kmem_cache_free(ib_mad_cache, mad_priv);
+                        kfree(mad_priv);
                         dev_err(&qp_info->port_priv->device->dev,
                                 "ib_post_recv failed: %d\n", ret);
                         break;
@@ -2738,10 +2973,9 @@ static void cleanup_recv_queue(struct ib_mad_qp_info *qp_info)
 
                 ib_dma_unmap_single(qp_info->port_priv->device,
                                     recv->header.mapping,
-                                    sizeof(struct ib_mad_private) -
-                                      sizeof(struct ib_mad_private_header),
+                                    mad_priv_dma_size(recv),
                                     DMA_FROM_DEVICE);
-                kmem_cache_free(ib_mad_cache, recv);
+                kfree(recv);
         }
 
         qp_info->recv_queue.count = 0;
@@ -2922,6 +3156,14 @@ static int ib_mad_port_open(struct ib_device *device,
         unsigned long flags;
         char name[sizeof "ib_mad123"];
         int has_smi;
+        struct ib_cq_init_attr cq_attr = {};
+
+        if (WARN_ON(rdma_max_mad_size(device, port_num) < IB_MGMT_MAD_SIZE))
+                return -EFAULT;
+
+        if (WARN_ON(rdma_cap_opa_mad(device, port_num) &&
+                    rdma_max_mad_size(device, port_num) < OPA_MGMT_MAD_SIZE))
+                return -EFAULT;
 
         /* Create new device info */
         port_priv = kzalloc(sizeof *port_priv, GFP_KERNEL);
@@ -2938,13 +3180,14 @@ static int ib_mad_port_open(struct ib_device *device,
         init_mad_qp(port_priv, &port_priv->qp_info[1]);
 
         cq_size = mad_sendq_size + mad_recvq_size;
-        has_smi = rdma_port_get_link_layer(device, port_num) == IB_LINK_LAYER_INFINIBAND;
+        has_smi = rdma_cap_ib_smi(device, port_num);
         if (has_smi)
                 cq_size *= 2;
 
+        cq_attr.cqe = cq_size;
         port_priv->cq = ib_create_cq(port_priv->device,
                                      ib_mad_thread_completion_handler,
-                                     NULL, port_priv, cq_size, 0);
+                                     NULL, port_priv, &cq_attr);
         if (IS_ERR(port_priv->cq)) {
                 dev_err(&device->dev, "Couldn't create ib_mad CQ\n");
                 ret = PTR_ERR(port_priv->cq);
@@ -3055,20 +3298,14 @@ static int ib_mad_port_close(struct ib_device *device, int port_num)
 
 static void ib_mad_init_device(struct ib_device *device)
 {
-        int start, end, i;
+        int start, i;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
+        start = rdma_start_port(device);
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
-                start = 0;
-                end   = 0;
-        } else {
-                start = 1;
-                end   = device->phys_port_cnt;
-        }
+        for (i = start; i <= rdma_end_port(device); i++) {
+                if (!rdma_cap_ib_mad(device, i))
+                        continue;
 
-        for (i = start; i <= end; i++) {
                 if (ib_mad_port_open(device, i)) {
                         dev_err(&device->dev, "Couldn't open port %d\n", i);
                         goto error;
@@ -3086,40 +3323,31 @@ error_agent:
                 dev_err(&device->dev, "Couldn't close port %d\n", i);
 
 error:
-        i--;
+        while (--i >= start) {
+                if (!rdma_cap_ib_mad(device, i))
+                        continue;
 
-        while (i >= start) {
                 if (ib_agent_port_close(device, i))
                         dev_err(&device->dev,
                                 "Couldn't close port %d for agents\n", i);
                 if (ib_mad_port_close(device, i))
                         dev_err(&device->dev, "Couldn't close port %d\n", i);
-                i--;
         }
 }
 
 static void ib_mad_remove_device(struct ib_device *device)
 {
-        int i, num_ports, cur_port;
+        int i;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
+        for (i = rdma_start_port(device); i <= rdma_end_port(device); i++) {
+                if (!rdma_cap_ib_mad(device, i))
+                        continue;
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
-                num_ports = 1;
-                cur_port = 0;
-        } else {
-                num_ports = device->phys_port_cnt;
-                cur_port = 1;
-        }
-        for (i = 0; i < num_ports; i++, cur_port++) {
-                if (ib_agent_port_close(device, cur_port))
+                if (ib_agent_port_close(device, i))
                         dev_err(&device->dev,
-                                "Couldn't close port %d for agents\n",
-                                cur_port);
-                if (ib_mad_port_close(device, cur_port))
-                        dev_err(&device->dev, "Couldn't close port %d\n",
-                                cur_port);
+                                "Couldn't close port %d for agents\n", i);
+                if (ib_mad_port_close(device, i))
+                        dev_err(&device->dev, "Couldn't close port %d\n", i);
         }
 }
 
@@ -3131,45 +3359,25 @@ static struct ib_client mad_client = {
 
 static int __init ib_mad_init_module(void)
 {
-        int ret;
-
         mad_recvq_size = min(mad_recvq_size, IB_MAD_QP_MAX_SIZE);
         mad_recvq_size = max(mad_recvq_size, IB_MAD_QP_MIN_SIZE);
 
         mad_sendq_size = min(mad_sendq_size, IB_MAD_QP_MAX_SIZE);
         mad_sendq_size = max(mad_sendq_size, IB_MAD_QP_MIN_SIZE);
 
-        ib_mad_cache = kmem_cache_create("ib_mad",
-                                         sizeof(struct ib_mad_private),
-                                         0,
-                                         SLAB_HWCACHE_ALIGN,
-                                         NULL);
-        if (!ib_mad_cache) {
-                pr_err("Couldn't create ib_mad cache\n");
-                ret = -ENOMEM;
-                goto error1;
-        }
-
         INIT_LIST_HEAD(&ib_mad_port_list);
 
         if (ib_register_client(&mad_client)) {
                 pr_err("Couldn't register ib_mad client\n");
-                ret = -EINVAL;
-                goto error2;
+                return -EINVAL;
         }
 
         return 0;
-
-error2:
-        kmem_cache_destroy(ib_mad_cache);
-error1:
-        return ret;
 }
 
 static void __exit ib_mad_cleanup_module(void)
 {
         ib_unregister_client(&mad_client);
-        kmem_cache_destroy(ib_mad_cache);
 }
 
 module_init(ib_mad_init_module);
diff --git a/drivers/infiniband/core/mad_priv.h b/drivers/infiniband/core/mad_priv.h
index d1a0b0ee9444..5be89f98928f 100644
--- a/drivers/infiniband/core/mad_priv.h
+++ b/drivers/infiniband/core/mad_priv.h
@@ -41,6 +41,7 @@
 #include <linux/workqueue.h>
 #include <rdma/ib_mad.h>
 #include <rdma/ib_smi.h>
+#include <rdma/opa_smi.h>
 
 #define IB_MAD_QPS_CORE         2 /* Always QP0 and QP1 as a minimum */
 
@@ -56,7 +57,7 @@
 
 /* Registration table sizes */
 #define MAX_MGMT_CLASS          80
-#define MAX_MGMT_VERSION        8
+#define MAX_MGMT_VERSION        0x83
 #define MAX_MGMT_OUI            8
 #define MAX_MGMT_VENDOR_RANGE2  (IB_MGMT_CLASS_VENDOR_RANGE2_END - \
                                 IB_MGMT_CLASS_VENDOR_RANGE2_START + 1)
@@ -75,12 +76,9 @@ struct ib_mad_private_header {
 
 struct ib_mad_private {
         struct ib_mad_private_header header;
+        size_t mad_size;
         struct ib_grh grh;
-        union {
-                struct ib_mad mad;
-                struct ib_rmpp_mad rmpp_mad;
-                struct ib_smp smp;
-        } mad;
+        u8 mad[0];
 } __attribute__ ((packed));
 
 struct ib_rmpp_segment {
@@ -150,6 +148,7 @@ struct ib_mad_local_private {
         struct ib_mad_private *mad_priv;
         struct ib_mad_agent_private *recv_mad_agent;
         struct ib_mad_send_wr_private *mad_send_wr;
+        size_t return_wc_byte_len;
 };
 
 struct ib_mad_mgmt_method_table {
@@ -213,8 +212,8 @@ struct ib_mad_port_private {
 int ib_send_mad(struct ib_mad_send_wr_private *mad_send_wr);
 
 struct ib_mad_send_wr_private *
-ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv,
-                 struct ib_mad_recv_wc *mad_recv_wc);
+ib_find_send_mad(const struct ib_mad_agent_private *mad_agent_priv,
+                 const struct ib_mad_recv_wc *mad_recv_wc);
 
 void ib_mad_complete_send_wr(struct ib_mad_send_wr_private *mad_send_wr,
                              struct ib_mad_send_wc *mad_send_wc);
diff --git a/drivers/infiniband/core/mad_rmpp.c b/drivers/infiniband/core/mad_rmpp.c
index f37878c9c06e..382941b46e43 100644
--- a/drivers/infiniband/core/mad_rmpp.c
+++ b/drivers/infiniband/core/mad_rmpp.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2005 Intel Inc. All rights reserved.
  * Copyright (c) 2005-2006 Voltaire, Inc. All rights reserved.
+ * Copyright (c) 2014 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
@@ -67,6 +68,7 @@ struct mad_rmpp_recv {
         u8 mgmt_class;
         u8 class_version;
         u8 method;
+        u8 base_version;
 };
 
 static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv)
@@ -139,7 +141,8 @@ static void ack_recv(struct mad_rmpp_recv *rmpp_recv,
         hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);
         msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,
                                  recv_wc->wc->pkey_index, 1, hdr_len,
-                                 0, GFP_KERNEL);
+                                 0, GFP_KERNEL,
+                                 IB_MGMT_BASE_VERSION);
         if (IS_ERR(msg))
                 return;
 
@@ -165,7 +168,8 @@ static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent,
         hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);
         msg = ib_create_send_mad(agent, recv_wc->wc->src_qp,
                                  recv_wc->wc->pkey_index, 1,
-                                 hdr_len, 0, GFP_KERNEL);
+                                 hdr_len, 0, GFP_KERNEL,
+                                 IB_MGMT_BASE_VERSION);
         if (IS_ERR(msg))
                 ib_destroy_ah(ah);
         else {
@@ -316,6 +320,7 @@ create_rmpp_recv(struct ib_mad_agent_private *agent,
         rmpp_recv->mgmt_class = mad_hdr->mgmt_class;
         rmpp_recv->class_version = mad_hdr->class_version;
         rmpp_recv->method  = mad_hdr->method;
+        rmpp_recv->base_version  = mad_hdr->base_version;
         return rmpp_recv;
 
 error:  kfree(rmpp_recv);
@@ -431,14 +436,23 @@ static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv)
 {
         struct ib_rmpp_mad *rmpp_mad;
         int hdr_size, data_size, pad;
+        bool opa = rdma_cap_opa_mad(rmpp_recv->agent->qp_info->port_priv->device,
+                                    rmpp_recv->agent->qp_info->port_priv->port_num);
 
         rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad;
 
         hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);
-        data_size = sizeof(struct ib_rmpp_mad) - hdr_size;
-        pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
-        if (pad > IB_MGMT_RMPP_DATA || pad < 0)
-                pad = 0;
+        if (opa && rmpp_recv->base_version == OPA_MGMT_BASE_VERSION) {
+                data_size = sizeof(struct opa_rmpp_mad) - hdr_size;
+                pad = OPA_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
+                if (pad > OPA_MGMT_RMPP_DATA || pad < 0)
+                        pad = 0;
+        } else {
+                data_size = sizeof(struct ib_rmpp_mad) - hdr_size;
+                pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);
+                if (pad > IB_MGMT_RMPP_DATA || pad < 0)
+                        pad = 0;
+        }
 
         return hdr_size + rmpp_recv->seg_num * data_size - pad;
 }
@@ -570,13 +584,14 @@ static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr)
 
         if (mad_send_wr->seg_num == 1) {
                 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_FIRST;
-                paylen = mad_send_wr->send_buf.seg_count * IB_MGMT_RMPP_DATA -
-                         mad_send_wr->pad;
+                paylen = (mad_send_wr->send_buf.seg_count *
+                          mad_send_wr->send_buf.seg_rmpp_size) -
+                          mad_send_wr->pad;
         }
 
         if (mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) {
                 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_LAST;
-                paylen = IB_MGMT_RMPP_DATA - mad_send_wr->pad;
+                paylen = mad_send_wr->send_buf.seg_rmpp_size - mad_send_wr->pad;
         }
         rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen);
 
diff --git a/drivers/infiniband/core/multicast.c b/drivers/infiniband/core/multicast.c
index fa17b552ff78..2cb865c7ce7a 100644
--- a/drivers/infiniband/core/multicast.c
+++ b/drivers/infiniband/core/multicast.c
@@ -780,8 +780,7 @@ static void mcast_event_handler(struct ib_event_handler *handler,
         int index;
 
         dev = container_of(handler, struct mcast_device, event_handler);
-        if (rdma_port_get_link_layer(dev->device, event->element.port_num) !=
-            IB_LINK_LAYER_INFINIBAND)
+        if (!rdma_cap_ib_mcast(dev->device, event->element.port_num))
                 return;
 
         index = event->element.port_num - dev->start_port;
@@ -808,24 +807,16 @@ static void mcast_add_one(struct ib_device *device)
         int i;
         int count = 0;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
-
         dev = kmalloc(sizeof *dev + device->phys_port_cnt * sizeof *port,
                       GFP_KERNEL);
         if (!dev)
                 return;
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH)
-                dev->start_port = dev->end_port = 0;
-        else {
-                dev->start_port = 1;
-                dev->end_port = device->phys_port_cnt;
-        }
+        dev->start_port = rdma_start_port(device);
+        dev->end_port = rdma_end_port(device);
 
         for (i = 0; i <= dev->end_port - dev->start_port; i++) {
-                if (rdma_port_get_link_layer(device, dev->start_port + i) !=
-                    IB_LINK_LAYER_INFINIBAND)
+                if (!rdma_cap_ib_mcast(device, dev->start_port + i))
                         continue;
                 port = &dev->port[i];
                 port->dev = dev;
@@ -863,8 +854,7 @@ static void mcast_remove_one(struct ib_device *device)
         flush_workqueue(mcast_wq);
 
         for (i = 0; i <= dev->end_port - dev->start_port; i++) {
-                if (rdma_port_get_link_layer(device, dev->start_port + i) ==
-                    IB_LINK_LAYER_INFINIBAND) {
+                if (rdma_cap_ib_mcast(device, dev->start_port + i)) {
                         port = &dev->port[i];
                         deref_port(port);
                         wait_for_completion(&port->comp);
diff --git a/drivers/infiniband/core/opa_smi.h b/drivers/infiniband/core/opa_smi.h
new file mode 100644
index 000000000000..3bfab3505a29
--- /dev/null
+++ b/drivers/infiniband/core/opa_smi.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2014 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
+ * 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 __OPA_SMI_H_
+#define __OPA_SMI_H_
+
+#include <rdma/ib_smi.h>
+#include <rdma/opa_smi.h>
+
+#include "smi.h"
+
+enum smi_action opa_smi_handle_dr_smp_recv(struct opa_smp *smp, bool is_switch,
+                                       int port_num, int phys_port_cnt);
+int opa_smi_get_fwd_port(struct opa_smp *smp);
+extern enum smi_forward_action opa_smi_check_forward_dr_smp(struct opa_smp *smp);
+extern enum smi_action opa_smi_handle_dr_smp_send(struct opa_smp *smp,
+                                              bool is_switch, int port_num);
+
+/*
+ * Return IB_SMI_HANDLE if the SMP should be handled by the local SMA/SM
+ * via process_mad
+ */
+static inline enum smi_action opa_smi_check_local_smp(struct opa_smp *smp,
+                                                      struct ib_device *device)
+{
+        /* C14-9:3 -- We're at the end of the DR segment of path */
+        /* C14-9:4 -- Hop Pointer = Hop Count + 1 -> give to SMA/SM */
+        return (device->process_mad &&
+                !opa_get_smp_direction(smp) &&
+                (smp->hop_ptr == smp->hop_cnt + 1)) ?
+                IB_SMI_HANDLE : IB_SMI_DISCARD;
+}
+
+/*
+ * Return IB_SMI_HANDLE if the SMP should be handled by the local SMA/SM
+ * via process_mad
+ */
+static inline enum smi_action opa_smi_check_local_returning_smp(struct opa_smp *smp,
+                                                                struct ib_device *device)
+{
+        /* C14-13:3 -- We're at the end of the DR segment of path */
+        /* C14-13:4 -- Hop Pointer == 0 -> give to SM */
+        return (device->process_mad &&
+                opa_get_smp_direction(smp) &&
+                !smp->hop_ptr) ? IB_SMI_HANDLE : IB_SMI_DISCARD;
+}
+
+#endif  /* __OPA_SMI_H_ */
diff --git a/drivers/infiniband/core/sa_query.c b/drivers/infiniband/core/sa_query.c
index c38f030f0dc9..ca919f429666 100644
--- a/drivers/infiniband/core/sa_query.c
+++ b/drivers/infiniband/core/sa_query.c
@@ -450,7 +450,7 @@ static void ib_sa_event(struct ib_event_handler *handler, struct ib_event *event
                 struct ib_sa_port *port =
                         &sa_dev->port[event->element.port_num - sa_dev->start_port];
 
-                if (rdma_port_get_link_layer(handler->device, port->port_num) != IB_LINK_LAYER_INFINIBAND)
+                if (!rdma_cap_ib_sa(handler->device, port->port_num))
                         return;
 
                 spin_lock_irqsave(&port->ah_lock, flags);
@@ -540,7 +540,7 @@ int ib_init_ah_from_path(struct ib_device *device, u8 port_num,
         ah_attr->port_num = port_num;
         ah_attr->static_rate = rec->rate;
 
-        force_grh = rdma_port_get_link_layer(device, port_num) == IB_LINK_LAYER_ETHERNET;
+        force_grh = rdma_cap_eth_ah(device, port_num);
 
         if (rec->hop_limit > 1 || force_grh) {
                 ah_attr->ah_flags = IB_AH_GRH;
@@ -583,7 +583,8 @@ static int alloc_mad(struct ib_sa_query *query, gfp_t gfp_mask)
         query->mad_buf = ib_create_send_mad(query->port->agent, 1,
                                             query->sm_ah->pkey_index,
                                             0, IB_MGMT_SA_HDR, IB_MGMT_SA_DATA,
-                                            gfp_mask);
+                                            gfp_mask,
+                                            IB_MGMT_BASE_VERSION);
         if (IS_ERR(query->mad_buf)) {
                 kref_put(&query->sm_ah->ref, free_sm_ah);
                 return -ENOMEM;
@@ -1153,16 +1154,10 @@ static void ib_sa_add_one(struct ib_device *device)
 {
         struct ib_sa_device *sa_dev;
         int s, e, i;
+        int count = 0;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
-
-        if (device->node_type == RDMA_NODE_IB_SWITCH)
-                s = e = 0;
-        else {
-                s = 1;
-                e = device->phys_port_cnt;
-        }
+        s = rdma_start_port(device);
+        e = rdma_end_port(device);
 
         sa_dev = kzalloc(sizeof *sa_dev +
                          (e - s + 1) * sizeof (struct ib_sa_port),
@@ -1175,7 +1170,7 @@ static void ib_sa_add_one(struct ib_device *device)
 
         for (i = 0; i <= e - s; ++i) {
                 spin_lock_init(&sa_dev->port[i].ah_lock);
-                if (rdma_port_get_link_layer(device, i + 1) != IB_LINK_LAYER_INFINIBAND)
+                if (!rdma_cap_ib_sa(device, i + 1))
                         continue;
 
                 sa_dev->port[i].sm_ah    = NULL;
@@ -1189,8 +1184,13 @@ static void ib_sa_add_one(struct ib_device *device)
                         goto err;
 
                 INIT_WORK(&sa_dev->port[i].update_task, update_sm_ah);
+
+                count++;
         }
 
+        if (!count)
+                goto free;
+
         ib_set_client_data(device, &sa_client, sa_dev);
 
         /*
@@ -1204,19 +1204,20 @@ static void ib_sa_add_one(struct ib_device *device)
         if (ib_register_event_handler(&sa_dev->event_handler))
                 goto err;
 
-        for (i = 0; i <= e - s; ++i)
-                if (rdma_port_get_link_layer(device, i + 1) == IB_LINK_LAYER_INFINIBAND)
+        for (i = 0; i <= e - s; ++i) {
+                if (rdma_cap_ib_sa(device, i + 1))
                         update_sm_ah(&sa_dev->port[i].update_task);
+        }
 
         return;
 
 err:
-        while (--i >= 0)
-                if (rdma_port_get_link_layer(device, i + 1) == IB_LINK_LAYER_INFINIBAND)
+        while (--i >= 0) {
+                if (rdma_cap_ib_sa(device, i + 1))
                         ib_unregister_mad_agent(sa_dev->port[i].agent);
-
+        }
+free:
         kfree(sa_dev);
-
         return;
 }
 
@@ -1233,7 +1234,7 @@ static void ib_sa_remove_one(struct ib_device *device)
         flush_workqueue(ib_wq);
 
         for (i = 0; i <= sa_dev->end_port - sa_dev->start_port; ++i) {
-                if (rdma_port_get_link_layer(device, i + 1) == IB_LINK_LAYER_INFINIBAND) {
+                if (rdma_cap_ib_sa(device, i + 1)) {
                         ib_unregister_mad_agent(sa_dev->port[i].agent);
                         if (sa_dev->port[i].sm_ah)
                                 kref_put(&sa_dev->port[i].sm_ah->ref, free_sm_ah);
diff --git a/drivers/infiniband/core/smi.c b/drivers/infiniband/core/smi.c
index 5855e4405d9b..f19b23817c2b 100644
--- a/drivers/infiniband/core/smi.c
+++ b/drivers/infiniband/core/smi.c
@@ -5,6 +5,7 @@
  * Copyright (c) 2004, 2005 Topspin Corporation.  All rights reserved.
  * Copyright (c) 2004-2007 Voltaire Corporation.  All rights reserved.
  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
+ * Copyright (c) 2014 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
@@ -38,85 +39,82 @@
 
 #include <rdma/ib_smi.h>
 #include "smi.h"
-
-/*
- * Fixup a directed route SMP for sending
- * Return 0 if the SMP should be discarded
- */
-enum smi_action smi_handle_dr_smp_send(struct ib_smp *smp,
-                                       u8 node_type, int port_num)
+#include "opa_smi.h"
+
+static enum smi_action __smi_handle_dr_smp_send(bool is_switch, int port_num,
+                                                u8 *hop_ptr, u8 hop_cnt,
+                                                const u8 *initial_path,
+                                                const u8 *return_path,
+                                                u8 direction,
+                                                bool dr_dlid_is_permissive,
+                                                bool dr_slid_is_permissive)
 {
-        u8 hop_ptr, hop_cnt;
-
-        hop_ptr = smp->hop_ptr;
-        hop_cnt = smp->hop_cnt;
-
         /* See section 14.2.2.2, Vol 1 IB spec */
         /* C14-6 -- valid hop_cnt values are from 0 to 63 */
         if (hop_cnt >= IB_SMP_MAX_PATH_HOPS)
                 return IB_SMI_DISCARD;
 
-        if (!ib_get_smp_direction(smp)) {
+        if (!direction) {
                 /* C14-9:1 */
-                if (hop_cnt && hop_ptr == 0) {
-                        smp->hop_ptr++;
-                        return (smp->initial_path[smp->hop_ptr] ==
+                if (hop_cnt && *hop_ptr == 0) {
+                        (*hop_ptr)++;
+                        return (initial_path[*hop_ptr] ==
                                 port_num ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-9:2 */
-                if (hop_ptr && hop_ptr < hop_cnt) {
-                        if (node_type != RDMA_NODE_IB_SWITCH)
+                if (*hop_ptr && *hop_ptr < hop_cnt) {
+                        if (!is_switch)
                                 return IB_SMI_DISCARD;
 
-                        /* smp->return_path set when received */
-                        smp->hop_ptr++;
-                        return (smp->initial_path[smp->hop_ptr] ==
+                        /* return_path set when received */
+                        (*hop_ptr)++;
+                        return (initial_path[*hop_ptr] ==
                                 port_num ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-9:3 -- We're at the end of the DR segment of path */
-                if (hop_ptr == hop_cnt) {
-                        /* smp->return_path set when received */
-                        smp->hop_ptr++;
-                        return (node_type == RDMA_NODE_IB_SWITCH ||
-                                smp->dr_dlid == IB_LID_PERMISSIVE ?
+                if (*hop_ptr == hop_cnt) {
+                        /* return_path set when received */
+                        (*hop_ptr)++;
+                        return (is_switch ||
+                                dr_dlid_is_permissive ?
                                 IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
                 /* C14-9:5 -- Fail unreasonable hop pointer */
-                return (hop_ptr == hop_cnt + 1 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
+                return (*hop_ptr == hop_cnt + 1 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
 
         } else {
                 /* C14-13:1 */
-                if (hop_cnt && hop_ptr == hop_cnt + 1) {
-                        smp->hop_ptr--;
-                        return (smp->return_path[smp->hop_ptr] ==
+                if (hop_cnt && *hop_ptr == hop_cnt + 1) {
+                        (*hop_ptr)--;
+                        return (return_path[*hop_ptr] ==
                                 port_num ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:2 */
-                if (2 <= hop_ptr && hop_ptr <= hop_cnt) {
-                        if (node_type != RDMA_NODE_IB_SWITCH)
+                if (2 <= *hop_ptr && *hop_ptr <= hop_cnt) {
+                        if (!is_switch)
                                 return IB_SMI_DISCARD;
 
-                        smp->hop_ptr--;
-                        return (smp->return_path[smp->hop_ptr] ==
+                        (*hop_ptr)--;
+                        return (return_path[*hop_ptr] ==
                                 port_num ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:3 -- at the end of the DR segment of path */
-                if (hop_ptr == 1) {
-                        smp->hop_ptr--;
+                if (*hop_ptr == 1) {
+                        (*hop_ptr)--;
                         /* C14-13:3 -- SMPs destined for SM shouldn't be here */
-                        return (node_type == RDMA_NODE_IB_SWITCH ||
-                                smp->dr_slid == IB_LID_PERMISSIVE ?
+                        return (is_switch ||
+                                dr_slid_is_permissive ?
                                 IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:4 -- hop_ptr = 0 -> should have gone to SM */
-                if (hop_ptr == 0)
+                if (*hop_ptr == 0)
                         return IB_SMI_HANDLE;
 
                 /* C14-13:5 -- Check for unreasonable hop pointer */
@@ -125,105 +123,163 @@ enum smi_action smi_handle_dr_smp_send(struct ib_smp *smp,
 }
 
 /*
- * Adjust information for a received SMP
- * Return 0 if the SMP should be dropped
+ * Fixup a directed route SMP for sending
+ * Return IB_SMI_DISCARD if the SMP should be discarded
  */
-enum smi_action smi_handle_dr_smp_recv(struct ib_smp *smp, u8 node_type,
-                                       int port_num, int phys_port_cnt)
+enum smi_action smi_handle_dr_smp_send(struct ib_smp *smp,
+                                       bool is_switch, int port_num)
 {
-        u8 hop_ptr, hop_cnt;
+        return __smi_handle_dr_smp_send(is_switch, port_num,
+                                        &smp->hop_ptr, smp->hop_cnt,
+                                        smp->initial_path,
+                                        smp->return_path,
+                                        ib_get_smp_direction(smp),
+                                        smp->dr_dlid == IB_LID_PERMISSIVE,
+                                        smp->dr_slid == IB_LID_PERMISSIVE);
+}
 
-        hop_ptr = smp->hop_ptr;
-        hop_cnt = smp->hop_cnt;
+enum smi_action opa_smi_handle_dr_smp_send(struct opa_smp *smp,
+                                       bool is_switch, int port_num)
+{
+        return __smi_handle_dr_smp_send(is_switch, port_num,
+                                        &smp->hop_ptr, smp->hop_cnt,
+                                        smp->route.dr.initial_path,
+                                        smp->route.dr.return_path,
+                                        opa_get_smp_direction(smp),
+                                        smp->route.dr.dr_dlid ==
+                                        OPA_LID_PERMISSIVE,
+                                        smp->route.dr.dr_slid ==
+                                        OPA_LID_PERMISSIVE);
+}
 
+static enum smi_action __smi_handle_dr_smp_recv(bool is_switch, int port_num,
+                                                int phys_port_cnt,
+                                                u8 *hop_ptr, u8 hop_cnt,
+                                                const u8 *initial_path,
+                                                u8 *return_path,
+                                                u8 direction,
+                                                bool dr_dlid_is_permissive,
+                                                bool dr_slid_is_permissive)
+{
         /* See section 14.2.2.2, Vol 1 IB spec */
         /* C14-6 -- valid hop_cnt values are from 0 to 63 */
         if (hop_cnt >= IB_SMP_MAX_PATH_HOPS)
                 return IB_SMI_DISCARD;
 
-        if (!ib_get_smp_direction(smp)) {
+        if (!direction) {
                 /* C14-9:1 -- sender should have incremented hop_ptr */
-                if (hop_cnt && hop_ptr == 0)
+                if (hop_cnt && *hop_ptr == 0)
                         return IB_SMI_DISCARD;
 
                 /* C14-9:2 -- intermediate hop */
-                if (hop_ptr && hop_ptr < hop_cnt) {
-                        if (node_type != RDMA_NODE_IB_SWITCH)
+                if (*hop_ptr && *hop_ptr < hop_cnt) {
+                        if (!is_switch)
                                 return IB_SMI_DISCARD;
 
-                        smp->return_path[hop_ptr] = port_num;
-                        /* smp->hop_ptr updated when sending */
-                        return (smp->initial_path[hop_ptr+1] <= phys_port_cnt ?
+                        return_path[*hop_ptr] = port_num;
+                        /* hop_ptr updated when sending */
+                        return (initial_path[*hop_ptr+1] <= phys_port_cnt ?
                                 IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-9:3 -- We're at the end of the DR segment of path */
-                if (hop_ptr == hop_cnt) {
+                if (*hop_ptr == hop_cnt) {
                         if (hop_cnt)
-                                smp->return_path[hop_ptr] = port_num;
-                        /* smp->hop_ptr updated when sending */
+                                return_path[*hop_ptr] = port_num;
+                        /* hop_ptr updated when sending */
 
-                        return (node_type == RDMA_NODE_IB_SWITCH ||
-                                smp->dr_dlid == IB_LID_PERMISSIVE ?
+                        return (is_switch ||
+                                dr_dlid_is_permissive ?
                                 IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
                 /* C14-9:5 -- fail unreasonable hop pointer */
-                return (hop_ptr == hop_cnt + 1 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
+                return (*hop_ptr == hop_cnt + 1 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
 
         } else {
 
                 /* C14-13:1 */
-                if (hop_cnt && hop_ptr == hop_cnt + 1) {
-                        smp->hop_ptr--;
-                        return (smp->return_path[smp->hop_ptr] ==
+                if (hop_cnt && *hop_ptr == hop_cnt + 1) {
+                        (*hop_ptr)--;
+                        return (return_path[*hop_ptr] ==
                                 port_num ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:2 */
-                if (2 <= hop_ptr && hop_ptr <= hop_cnt) {
-                        if (node_type != RDMA_NODE_IB_SWITCH)
+                if (2 <= *hop_ptr && *hop_ptr <= hop_cnt) {
+                        if (!is_switch)
                                 return IB_SMI_DISCARD;
 
-                        /* smp->hop_ptr updated when sending */
-                        return (smp->return_path[hop_ptr-1] <= phys_port_cnt ?
+                        /* hop_ptr updated when sending */
+                        return (return_path[*hop_ptr-1] <= phys_port_cnt ?
                                 IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:3 -- We're at the end of the DR segment of path */
-                if (hop_ptr == 1) {
-                        if (smp->dr_slid == IB_LID_PERMISSIVE) {
+                if (*hop_ptr == 1) {
+                        if (dr_slid_is_permissive) {
                                 /* giving SMP to SM - update hop_ptr */
-                                smp->hop_ptr--;
+                                (*hop_ptr)--;
                                 return IB_SMI_HANDLE;
                         }
-                        /* smp->hop_ptr updated when sending */
-                        return (node_type == RDMA_NODE_IB_SWITCH ?
-                                IB_SMI_HANDLE : IB_SMI_DISCARD);
+                        /* hop_ptr updated when sending */
+                        return (is_switch ? IB_SMI_HANDLE : IB_SMI_DISCARD);
                 }
 
                 /* C14-13:4 -- hop_ptr = 0 -> give to SM */
                 /* C14-13:5 -- Check for unreasonable hop pointer */
-                return (hop_ptr == 0 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
+                return (*hop_ptr == 0 ? IB_SMI_HANDLE : IB_SMI_DISCARD);
         }
 }
 
-enum smi_forward_action smi_check_forward_dr_smp(struct ib_smp *smp)
+/*
+ * Adjust information for a received SMP
+ * Return IB_SMI_DISCARD if the SMP should be dropped
+ */
+enum smi_action smi_handle_dr_smp_recv(struct ib_smp *smp, bool is_switch,
+                                       int port_num, int phys_port_cnt)
 {
-        u8 hop_ptr, hop_cnt;
+        return __smi_handle_dr_smp_recv(is_switch, port_num, phys_port_cnt,
+                                        &smp->hop_ptr, smp->hop_cnt,
+                                        smp->initial_path,
+                                        smp->return_path,
+                                        ib_get_smp_direction(smp),
+                                        smp->dr_dlid == IB_LID_PERMISSIVE,
+                                        smp->dr_slid == IB_LID_PERMISSIVE);
+}
 
-        hop_ptr = smp->hop_ptr;
-        hop_cnt = smp->hop_cnt;
+/*
+ * Adjust information for a received SMP
+ * Return IB_SMI_DISCARD if the SMP should be dropped
+ */
+enum smi_action opa_smi_handle_dr_smp_recv(struct opa_smp *smp, bool is_switch,
+                                           int port_num, int phys_port_cnt)
+{
+        return __smi_handle_dr_smp_recv(is_switch, port_num, phys_port_cnt,
+                                        &smp->hop_ptr, smp->hop_cnt,
+                                        smp->route.dr.initial_path,
+                                        smp->route.dr.return_path,
+                                        opa_get_smp_direction(smp),
+                                        smp->route.dr.dr_dlid ==
+                                        OPA_LID_PERMISSIVE,
+                                        smp->route.dr.dr_slid ==
+                                        OPA_LID_PERMISSIVE);
+}
 
-        if (!ib_get_smp_direction(smp)) {
+static enum smi_forward_action __smi_check_forward_dr_smp(u8 hop_ptr, u8 hop_cnt,
+                                                          u8 direction,
+                                                          bool dr_dlid_is_permissive,
+                                                          bool dr_slid_is_permissive)
+{
+        if (!direction) {
                 /* C14-9:2 -- intermediate hop */
                 if (hop_ptr && hop_ptr < hop_cnt)
                         return IB_SMI_FORWARD;
 
                 /* C14-9:3 -- at the end of the DR segment of path */
                 if (hop_ptr == hop_cnt)
-                        return (smp->dr_dlid == IB_LID_PERMISSIVE ?
+                        return (dr_dlid_is_permissive ?
                                 IB_SMI_SEND : IB_SMI_LOCAL);
 
                 /* C14-9:4 -- hop_ptr = hop_cnt + 1 -> give to SMA/SM */
@@ -236,10 +292,29 @@ enum smi_forward_action smi_check_forward_dr_smp(struct ib_smp *smp)
 
                 /* C14-13:3 -- at the end of the DR segment of path */
                 if (hop_ptr == 1)
-                        return (smp->dr_slid != IB_LID_PERMISSIVE ?
+                        return (!dr_slid_is_permissive ?
                                 IB_SMI_SEND : IB_SMI_LOCAL);
         }
         return IB_SMI_LOCAL;
+
+}
+
+enum smi_forward_action smi_check_forward_dr_smp(struct ib_smp *smp)
+{
+        return __smi_check_forward_dr_smp(smp->hop_ptr, smp->hop_cnt,
+                                          ib_get_smp_direction(smp),
+                                          smp->dr_dlid == IB_LID_PERMISSIVE,
+                                          smp->dr_slid == IB_LID_PERMISSIVE);
+}
+
+enum smi_forward_action opa_smi_check_forward_dr_smp(struct opa_smp *smp)
+{
+        return __smi_check_forward_dr_smp(smp->hop_ptr, smp->hop_cnt,
+                                          opa_get_smp_direction(smp),
+                                          smp->route.dr.dr_dlid ==
+                                          OPA_LID_PERMISSIVE,
+                                          smp->route.dr.dr_slid ==
+                                          OPA_LID_PERMISSIVE);
 }
 
 /*
@@ -251,3 +326,13 @@ int smi_get_fwd_port(struct ib_smp *smp)
         return (!ib_get_smp_direction(smp) ? smp->initial_path[smp->hop_ptr+1] :
                 smp->return_path[smp->hop_ptr-1]);
 }
+
+/*
+ * Return the forwarding port number from initial_path for outgoing SMP and
+ * from return_path for returning SMP
+ */
+int opa_smi_get_fwd_port(struct opa_smp *smp)
+{
+        return !opa_get_smp_direction(smp) ? smp->route.dr.initial_path[smp->hop_ptr+1] :
+                smp->route.dr.return_path[smp->hop_ptr-1];
+}
diff --git a/drivers/infiniband/core/smi.h b/drivers/infiniband/core/smi.h
index aff96bac49b4..33c91c8a16e9 100644
--- a/drivers/infiniband/core/smi.h
+++ b/drivers/infiniband/core/smi.h
@@ -51,12 +51,12 @@ enum smi_forward_action {
         IB_SMI_FORWARD  /* SMP should be forwarded (for switches only) */
 };
 
-enum smi_action smi_handle_dr_smp_recv(struct ib_smp *smp, u8 node_type,
+enum smi_action smi_handle_dr_smp_recv(struct ib_smp *smp, bool is_switch,
                                        int port_num, int phys_port_cnt);
 int smi_get_fwd_port(struct ib_smp *smp);
 extern enum smi_forward_action smi_check_forward_dr_smp(struct ib_smp *smp);
 extern enum smi_action smi_handle_dr_smp_send(struct ib_smp *smp,
-                                              u8 node_type, int port_num);
+                                              bool is_switch, int port_num);
 
 /*
  * Return IB_SMI_HANDLE if the SMP should be handled by the local SMA/SM
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index cbd0383f622e..0b84a9cdfe5b 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -326,6 +326,8 @@ static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
         int width  = (tab_attr->index >> 16) & 0xff;
         struct ib_mad *in_mad  = NULL;
         struct ib_mad *out_mad = NULL;
+        size_t mad_size = sizeof(*out_mad);
+        u16 out_mad_pkey_index = 0;
         ssize_t ret;
 
         if (!p->ibdev->process_mad)
@@ -347,7 +349,10 @@ static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
         in_mad->data[41] = p->port_num; /* PortSelect field */
 
         if ((p->ibdev->process_mad(p->ibdev, IB_MAD_IGNORE_MKEY,
-                 p->port_num, NULL, NULL, in_mad, out_mad) &
+                 p->port_num, NULL, NULL,
+                 (const struct ib_mad_hdr *)in_mad, mad_size,
+                 (struct ib_mad_hdr *)out_mad, &mad_size,
+                 &out_mad_pkey_index) &
              (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) !=
             (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) {
                 ret = -EINVAL;
@@ -456,6 +461,7 @@ static void ib_device_release(struct device *device)
 {
         struct ib_device *dev = container_of(device, struct ib_device, dev);
 
+        kfree(dev->port_immutable);
         kfree(dev);
 }
 
@@ -864,7 +870,7 @@ int ib_device_register_sysfs(struct ib_device *device,
                 goto err_put;
         }
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
+        if (rdma_cap_ib_switch(device)) {
                 ret = add_port(device, 0, port_callback);
                 if (ret)
                         goto err_put;
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index f2f63933e8a9..009481073644 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -1193,6 +1193,7 @@ static int ib_ucm_close(struct inode *inode, struct file *filp)
         return 0;
 }
 
+static DECLARE_BITMAP(overflow_map, IB_UCM_MAX_DEVICES);
 static void ib_ucm_release_dev(struct device *dev)
 {
         struct ib_ucm_device *ucm_dev;
@@ -1202,7 +1203,7 @@ static void ib_ucm_release_dev(struct device *dev)
         if (ucm_dev->devnum < IB_UCM_MAX_DEVICES)
                 clear_bit(ucm_dev->devnum, dev_map);
         else
-                clear_bit(ucm_dev->devnum - IB_UCM_MAX_DEVICES, dev_map);
+                clear_bit(ucm_dev->devnum - IB_UCM_MAX_DEVICES, overflow_map);
         kfree(ucm_dev);
 }
 
@@ -1226,7 +1227,6 @@ static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
 static dev_t overflow_maj;
-static DECLARE_BITMAP(overflow_map, IB_UCM_MAX_DEVICES);
 static int find_overflow_devnum(void)
 {
         int ret;
@@ -1253,8 +1253,7 @@ static void ib_ucm_add_one(struct ib_device *device)
         dev_t base;
         struct ib_ucm_device *ucm_dev;
 
-        if (!device->alloc_ucontext ||
-            rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
+        if (!device->alloc_ucontext || !rdma_cap_ib_cm(device, 1))
                 return;
 
         ucm_dev = kzalloc(sizeof *ucm_dev, GFP_KERNEL);
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index 45d67e9228d7..29b21213ea75 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -722,26 +722,13 @@ static ssize_t ucma_query_route(struct ucma_file *file,
 
         resp.node_guid = (__force __u64) ctx->cm_id->device->node_guid;
         resp.port_num = ctx->cm_id->port_num;
-        switch (rdma_node_get_transport(ctx->cm_id->device->node_type)) {
-        case RDMA_TRANSPORT_IB:
-                switch (rdma_port_get_link_layer(ctx->cm_id->device,
-                        ctx->cm_id->port_num)) {
-                case IB_LINK_LAYER_INFINIBAND:
-                        ucma_copy_ib_route(&resp, &ctx->cm_id->route);
-                        break;
-                case IB_LINK_LAYER_ETHERNET:
-                        ucma_copy_iboe_route(&resp, &ctx->cm_id->route);
-                        break;
-                default:
-                        break;
-                }
-                break;
-        case RDMA_TRANSPORT_IWARP:
+
+        if (rdma_cap_ib_sa(ctx->cm_id->device, ctx->cm_id->port_num))
+                ucma_copy_ib_route(&resp, &ctx->cm_id->route);
+        else if (rdma_protocol_roce(ctx->cm_id->device, ctx->cm_id->port_num))
+                ucma_copy_iboe_route(&resp, &ctx->cm_id->route);
+        else if (rdma_protocol_iwarp(ctx->cm_id->device, ctx->cm_id->port_num))
                 ucma_copy_iw_route(&resp, &ctx->cm_id->route);
-                break;
-        default:
-                break;
-        }
 
 out:
         if (copy_to_user((void __user *)(unsigned long)cmd.response,
@@ -1367,10 +1354,10 @@ static void ucma_lock_files(struct ucma_file *file1, struct ucma_file *file2)
         /* Acquire mutex's based on pointer comparison to prevent deadlock. */
         if (file1 < file2) {
                 mutex_lock(&file1->mut);
-                mutex_lock(&file2->mut);
+                mutex_lock_nested(&file2->mut, SINGLE_DEPTH_NESTING);
         } else {
                 mutex_lock(&file2->mut);
-                mutex_lock(&file1->mut);
+                mutex_lock_nested(&file1->mut, SINGLE_DEPTH_NESTING);
         }
 }
 
@@ -1629,6 +1616,7 @@ static void __exit ucma_cleanup(void)
         device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
         misc_deregister(&ucma_misc);
         idr_destroy(&ctx_idr);
+        idr_destroy(&multicast_idr);
 }
 
 module_init(ucma_init);
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
index 928cdd20e2d1..35567fffaa4e 100644
--- a/drivers/infiniband/core/user_mad.c
+++ b/drivers/infiniband/core/user_mad.c
@@ -99,7 +99,6 @@ struct ib_umad_port {
 };
 
 struct ib_umad_device {
-        int                  start_port, end_port;
         struct kobject       kobj;
         struct ib_umad_port  port[0];
 };
@@ -263,20 +262,23 @@ static ssize_t copy_recv_mad(struct ib_umad_file *file, char __user *buf,
 {
         struct ib_mad_recv_buf *recv_buf;
         int left, seg_payload, offset, max_seg_payload;
+        size_t seg_size;
 
-        /* We need enough room to copy the first (or only) MAD segment. */
         recv_buf = &packet->recv_wc->recv_buf;
-        if ((packet->length <= sizeof (*recv_buf->mad) &&
+        seg_size = packet->recv_wc->mad_seg_size;
+
+        /* We need enough room to copy the first (or only) MAD segment. */
+        if ((packet->length <= seg_size &&
              count < hdr_size(file) + packet->length) ||
-            (packet->length > sizeof (*recv_buf->mad) &&
-             count < hdr_size(file) + sizeof (*recv_buf->mad)))
+            (packet->length > seg_size &&
+             count < hdr_size(file) + seg_size))
                 return -EINVAL;
 
         if (copy_to_user(buf, &packet->mad, hdr_size(file)))
                 return -EFAULT;
 
         buf += hdr_size(file);
-        seg_payload = min_t(int, packet->length, sizeof (*recv_buf->mad));
+        seg_payload = min_t(int, packet->length, seg_size);
         if (copy_to_user(buf, recv_buf->mad, seg_payload))
                 return -EFAULT;
 
@@ -293,7 +295,7 @@ static ssize_t copy_recv_mad(struct ib_umad_file *file, char __user *buf,
                         return -ENOSPC;
                 }
                 offset = ib_get_mad_data_offset(recv_buf->mad->mad_hdr.mgmt_class);
-                max_seg_payload = sizeof (struct ib_mad) - offset;
+                max_seg_payload = seg_size - offset;
 
                 for (left = packet->length - seg_payload, buf += seg_payload;
                      left; left -= seg_payload, buf += seg_payload) {
@@ -426,11 +428,11 @@ static int is_duplicate(struct ib_umad_file *file,
                  * the same TID, reject the second as a duplicate.  This is more
                  * restrictive than required by the spec.
                  */
-                if (!ib_response_mad((struct ib_mad *) hdr)) {
-                        if (!ib_response_mad((struct ib_mad *) sent_hdr))
+                if (!ib_response_mad(hdr)) {
+                        if (!ib_response_mad(sent_hdr))
                                 return 1;
                         continue;
-                } else if (!ib_response_mad((struct ib_mad *) sent_hdr))
+                } else if (!ib_response_mad(sent_hdr))
                         continue;
 
                 if (same_destination(&packet->mad.hdr, &sent_packet->mad.hdr))
@@ -451,6 +453,7 @@ static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
         struct ib_rmpp_mad *rmpp_mad;
         __be64 *tid;
         int ret, data_len, hdr_len, copy_offset, rmpp_active;
+        u8 base_version;
 
         if (count < hdr_size(file) + IB_MGMT_RMPP_HDR)
                 return -EINVAL;
@@ -517,11 +520,13 @@ static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
                 rmpp_active = 0;
         }
 
+        base_version = ((struct ib_mad_hdr *)&packet->mad.data)->base_version;
         data_len = count - hdr_size(file) - hdr_len;
         packet->msg = ib_create_send_mad(agent,
                                          be32_to_cpu(packet->mad.hdr.qpn),
                                          packet->mad.hdr.pkey_index, rmpp_active,
-                                         hdr_len, data_len, GFP_KERNEL);
+                                         hdr_len, data_len, GFP_KERNEL,
+                                         base_version);
         if (IS_ERR(packet->msg)) {
                 ret = PTR_ERR(packet->msg);
                 goto err_ah;
@@ -1273,16 +1278,10 @@ static void ib_umad_add_one(struct ib_device *device)
 {
         struct ib_umad_device *umad_dev;
         int s, e, i;
+        int count = 0;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
-
-        if (device->node_type == RDMA_NODE_IB_SWITCH)
-                s = e = 0;
-        else {
-                s = 1;
-                e = device->phys_port_cnt;
-        }
+        s = rdma_start_port(device);
+        e = rdma_end_port(device);
 
         umad_dev = kzalloc(sizeof *umad_dev +
                            (e - s + 1) * sizeof (struct ib_umad_port),
@@ -1292,25 +1291,34 @@ static void ib_umad_add_one(struct ib_device *device)
 
         kobject_init(&umad_dev->kobj, &ib_umad_dev_ktype);
 
-        umad_dev->start_port = s;
-        umad_dev->end_port   = e;
-
         for (i = s; i <= e; ++i) {
+                if (!rdma_cap_ib_mad(device, i))
+                        continue;
+
                 umad_dev->port[i - s].umad_dev = umad_dev;
 
                 if (ib_umad_init_port(device, i, umad_dev,
                                       &umad_dev->port[i - s]))
                         goto err;
+
+                count++;
         }
 
+        if (!count)
+                goto free;
+
         ib_set_client_data(device, &umad_client, umad_dev);
 
         return;
 
 err:
-        while (--i >= s)
-                ib_umad_kill_port(&umad_dev->port[i - s]);
+        while (--i >= s) {
+                if (!rdma_cap_ib_mad(device, i))
+                        continue;
 
+                ib_umad_kill_port(&umad_dev->port[i - s]);
+        }
+free:
         kobject_put(&umad_dev->kobj);
 }
 
@@ -1322,8 +1330,10 @@ static void ib_umad_remove_one(struct ib_device *device)
         if (!umad_dev)
                 return;
 
-        for (i = 0; i <= umad_dev->end_port - umad_dev->start_port; ++i)
-                ib_umad_kill_port(&umad_dev->port[i]);
+        for (i = 0; i <= rdma_end_port(device) - rdma_start_port(device); ++i) {
+                if (rdma_cap_ib_mad(device, i + rdma_start_port(device)))
+                        ib_umad_kill_port(&umad_dev->port[i]);
+        }
 
         kobject_put(&umad_dev->kobj);
 }
diff --git a/drivers/infiniband/core/uverbs.h b/drivers/infiniband/core/uverbs.h
index b716b0815644..ba365b6d1e8d 100644
--- a/drivers/infiniband/core/uverbs.h
+++ b/drivers/infiniband/core/uverbs.h
@@ -259,5 +259,6 @@ IB_UVERBS_DECLARE_CMD(close_xrcd);
 IB_UVERBS_DECLARE_EX_CMD(create_flow);
 IB_UVERBS_DECLARE_EX_CMD(destroy_flow);
 IB_UVERBS_DECLARE_EX_CMD(query_device);
+IB_UVERBS_DECLARE_EX_CMD(create_cq);
 
 #endif /* UVERBS_H */
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index a9f048990dfc..bbb02ffe87df 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -1330,40 +1330,37 @@ ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file,
         return in_len;
 }
 
-ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
-                            const char __user *buf, int in_len,
-                            int out_len)
+static struct ib_ucq_object *create_cq(struct ib_uverbs_file *file,
+                                       struct ib_udata *ucore,
+                                       struct ib_udata *uhw,
+                                       struct ib_uverbs_ex_create_cq *cmd,
+                                       size_t cmd_sz,
+                                       int (*cb)(struct ib_uverbs_file *file,
+                                                 struct ib_ucq_object *obj,
+                                                 struct ib_uverbs_ex_create_cq_resp *resp,
+                                                 struct ib_udata *udata,
+                                                 void *context),
+                                       void *context)
 {
-        struct ib_uverbs_create_cq      cmd;
-        struct ib_uverbs_create_cq_resp resp;
-        struct ib_udata                 udata;
         struct ib_ucq_object           *obj;
         struct ib_uverbs_event_file    *ev_file = NULL;
         struct ib_cq                   *cq;
         int                             ret;
+        struct ib_uverbs_ex_create_cq_resp resp;
+        struct ib_cq_init_attr attr = {};
 
-        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);
-
-        if (cmd.comp_vector >= file->device->num_comp_vectors)
-                return -EINVAL;
+        if (cmd->comp_vector >= file->device->num_comp_vectors)
+                return ERR_PTR(-EINVAL);
 
         obj = kmalloc(sizeof *obj, GFP_KERNEL);
         if (!obj)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
-        init_uobj(&obj->uobject, cmd.user_handle, file->ucontext, &cq_lock_class);
+        init_uobj(&obj->uobject, cmd->user_handle, file->ucontext, &cq_lock_class);
         down_write(&obj->uobject.mutex);
 
-        if (cmd.comp_channel >= 0) {
-                ev_file = ib_uverbs_lookup_comp_file(cmd.comp_channel);
+        if (cmd->comp_channel >= 0) {
+                ev_file = ib_uverbs_lookup_comp_file(cmd->comp_channel);
                 if (!ev_file) {
                         ret = -EINVAL;
                         goto err;
@@ -1376,9 +1373,14 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
         INIT_LIST_HEAD(&obj->comp_list);
         INIT_LIST_HEAD(&obj->async_list);
 
-        cq = file->device->ib_dev->create_cq(file->device->ib_dev, cmd.cqe,
-                                             cmd.comp_vector,
-                                             file->ucontext, &udata);
+        attr.cqe = cmd->cqe;
+        attr.comp_vector = cmd->comp_vector;
+
+        if (cmd_sz > offsetof(typeof(*cmd), flags) + sizeof(cmd->flags))
+                attr.flags = cmd->flags;
+
+        cq = file->device->ib_dev->create_cq(file->device->ib_dev, &attr,
+                                             file->ucontext, uhw);
         if (IS_ERR(cq)) {
                 ret = PTR_ERR(cq);
                 goto err_file;
@@ -1397,14 +1399,15 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
                 goto err_free;
 
         memset(&resp, 0, sizeof resp);
-        resp.cq_handle = obj->uobject.id;
-        resp.cqe       = cq->cqe;
+        resp.base.cq_handle = obj->uobject.id;
+        resp.base.cqe       = cq->cqe;
 
-        if (copy_to_user((void __user *) (unsigned long) cmd.response,
-                         &resp, sizeof resp)) {
-                ret = -EFAULT;
-                goto err_copy;
-        }
+        resp.response_length = offsetof(typeof(resp), response_length) +
+                sizeof(resp.response_length);
+
+        ret = cb(file, obj, &resp, ucore, context);
+        if (ret)
+                goto err_cb;
 
         mutex_lock(&file->mutex);
         list_add_tail(&obj->uobject.list, &file->ucontext->cq_list);
@@ -1414,9 +1417,9 @@ ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
 
         up_write(&obj->uobject.mutex);
 
-        return in_len;
+        return obj;
 
-err_copy:
+err_cb:
         idr_remove_uobj(&ib_uverbs_cq_idr, &obj->uobject);
 
 err_free:
@@ -1428,7 +1431,106 @@ err_file:
 
 err:
         put_uobj_write(&obj->uobject);
-        return ret;
+
+        return ERR_PTR(ret);
+}
+
+static int ib_uverbs_create_cq_cb(struct ib_uverbs_file *file,
+                                  struct ib_ucq_object *obj,
+                                  struct ib_uverbs_ex_create_cq_resp *resp,
+                                  struct ib_udata *ucore, void *context)
+{
+        if (ib_copy_to_udata(ucore, &resp->base, sizeof(resp->base)))
+                return -EFAULT;
+
+        return 0;
+}
+
+ssize_t ib_uverbs_create_cq(struct ib_uverbs_file *file,
+                            const char __user *buf, int in_len,
+                            int out_len)
+{
+        struct ib_uverbs_create_cq      cmd;
+        struct ib_uverbs_ex_create_cq   cmd_ex;
+        struct ib_uverbs_create_cq_resp resp;
+        struct ib_udata                 ucore;
+        struct ib_udata                 uhw;
+        struct ib_ucq_object           *obj;
+
+        if (out_len < sizeof(resp))
+                return -ENOSPC;
+
+        if (copy_from_user(&cmd, buf, sizeof(cmd)))
+                return -EFAULT;
+
+        INIT_UDATA(&ucore, buf, cmd.response, sizeof(cmd), sizeof(resp));
+
+        INIT_UDATA(&uhw, buf + sizeof(cmd),
+                   (unsigned long)cmd.response + sizeof(resp),
+                   in_len - sizeof(cmd), out_len - sizeof(resp));
+
+        memset(&cmd_ex, 0, sizeof(cmd_ex));
+        cmd_ex.user_handle = cmd.user_handle;
+        cmd_ex.cqe = cmd.cqe;
+        cmd_ex.comp_vector = cmd.comp_vector;
+        cmd_ex.comp_channel = cmd.comp_channel;
+
+        obj = create_cq(file, &ucore, &uhw, &cmd_ex,
+                        offsetof(typeof(cmd_ex), comp_channel) +
+                        sizeof(cmd.comp_channel), ib_uverbs_create_cq_cb,
+                        NULL);
+
+        if (IS_ERR(obj))
+                return PTR_ERR(obj);
+
+        return in_len;
+}
+
+static int ib_uverbs_ex_create_cq_cb(struct ib_uverbs_file *file,
+                                     struct ib_ucq_object *obj,
+                                     struct ib_uverbs_ex_create_cq_resp *resp,
+                                     struct ib_udata *ucore, void *context)
+{
+        if (ib_copy_to_udata(ucore, resp, resp->response_length))
+                return -EFAULT;
+
+        return 0;
+}
+
+int ib_uverbs_ex_create_cq(struct ib_uverbs_file *file,
+                           struct ib_udata *ucore,
+                           struct ib_udata *uhw)
+{
+        struct ib_uverbs_ex_create_cq_resp resp;
+        struct ib_uverbs_ex_create_cq  cmd;
+        struct ib_ucq_object           *obj;
+        int err;
+
+        if (ucore->inlen < sizeof(cmd))
+                return -EINVAL;
+
+        err = ib_copy_from_udata(&cmd, ucore, sizeof(cmd));
+        if (err)
+                return err;
+
+        if (cmd.comp_mask)
+                return -EINVAL;
+
+        if (cmd.reserved)
+                return -EINVAL;
+
+        if (ucore->outlen < (offsetof(typeof(resp), response_length) +
+                             sizeof(resp.response_length)))
+                return -ENOSPC;
+
+        obj = create_cq(file, ucore, uhw, &cmd,
+                        min(ucore->inlen, sizeof(cmd)),
+                        ib_uverbs_ex_create_cq_cb, NULL);
+
+        if (IS_ERR(obj))
+                return PTR_ERR(obj);
+
+        return 0;
 }
 
 ssize_t ib_uverbs_resize_cq(struct ib_uverbs_file *file,
@@ -3324,7 +3426,9 @@ int ib_uverbs_ex_query_device(struct ib_uverbs_file *file,
         if (ucore->outlen < resp.response_length)
                 return -ENOSPC;
 
-        err = device->query_device(device, &attr);
+        memset(&attr, 0, sizeof(attr));
+
+        err = device->query_device(device, &attr, uhw);
         if (err)
                 return err;
 
@@ -3348,6 +3452,18 @@ int ib_uverbs_ex_query_device(struct ib_uverbs_file *file,
 #endif
         resp.response_length += sizeof(resp.odp_caps);
 
+        if (ucore->outlen < resp.response_length + sizeof(resp.timestamp_mask))
+                goto end;
+
+        resp.timestamp_mask = attr.timestamp_mask;
+        resp.response_length += sizeof(resp.timestamp_mask);
+
+        if (ucore->outlen < resp.response_length + sizeof(resp.hca_core_clock))
+                goto end;
+
+        resp.hca_core_clock = attr.hca_core_clock;
+        resp.response_length += sizeof(resp.hca_core_clock);
+
 end:
         err = ib_copy_to_udata(ucore, &resp, resp.response_length);
         if (err)
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 88cce9bb72fe..f6eef2da7097 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -124,6 +124,7 @@ static int (*uverbs_ex_cmd_table[])(struct ib_uverbs_file *file,
         [IB_USER_VERBS_EX_CMD_CREATE_FLOW]      = ib_uverbs_ex_create_flow,
         [IB_USER_VERBS_EX_CMD_DESTROY_FLOW]     = ib_uverbs_ex_destroy_flow,
         [IB_USER_VERBS_EX_CMD_QUERY_DEVICE]     = ib_uverbs_ex_query_device,
+        [IB_USER_VERBS_EX_CMD_CREATE_CQ]        = ib_uverbs_ex_create_cq,
 };
 
 static void ib_uverbs_add_one(struct ib_device *device);
diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
index f93eb8da7b5a..bac3fb406a74 100644
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@ -48,6 +48,71 @@
 
 #include "core_priv.h"
 
+static const char * const ib_events[] = {
+        [IB_EVENT_CQ_ERR]               = "CQ error",
+        [IB_EVENT_QP_FATAL]             = "QP fatal error",
+        [IB_EVENT_QP_REQ_ERR]           = "QP request error",
+        [IB_EVENT_QP_ACCESS_ERR]        = "QP access error",
+        [IB_EVENT_COMM_EST]             = "communication established",
+        [IB_EVENT_SQ_DRAINED]           = "send queue drained",
+        [IB_EVENT_PATH_MIG]             = "path migration successful",
+        [IB_EVENT_PATH_MIG_ERR]         = "path migration error",
+        [IB_EVENT_DEVICE_FATAL]         = "device fatal error",
+        [IB_EVENT_PORT_ACTIVE]          = "port active",
+        [IB_EVENT_PORT_ERR]             = "port error",
+        [IB_EVENT_LID_CHANGE]           = "LID change",
+        [IB_EVENT_PKEY_CHANGE]          = "P_key change",
+        [IB_EVENT_SM_CHANGE]            = "SM change",
+        [IB_EVENT_SRQ_ERR]              = "SRQ error",
+        [IB_EVENT_SRQ_LIMIT_REACHED]    = "SRQ limit reached",
+        [IB_EVENT_QP_LAST_WQE_REACHED]  = "last WQE reached",
+        [IB_EVENT_CLIENT_REREGISTER]    = "client reregister",
+        [IB_EVENT_GID_CHANGE]           = "GID changed",
+};
+
+const char *ib_event_msg(enum ib_event_type event)
+{
+        size_t index = event;
+
+        return (index < ARRAY_SIZE(ib_events) && ib_events[index]) ?
+                        ib_events[index] : "unrecognized event";
+}
+EXPORT_SYMBOL(ib_event_msg);
+
+static const char * const wc_statuses[] = {
+        [IB_WC_SUCCESS]                 = "success",
+        [IB_WC_LOC_LEN_ERR]             = "local length error",
+        [IB_WC_LOC_QP_OP_ERR]           = "local QP operation error",
+        [IB_WC_LOC_EEC_OP_ERR]          = "local EE context operation error",
+        [IB_WC_LOC_PROT_ERR]            = "local protection error",
+        [IB_WC_WR_FLUSH_ERR]            = "WR flushed",
+        [IB_WC_MW_BIND_ERR]             = "memory management operation error",
+        [IB_WC_BAD_RESP_ERR]            = "bad response error",
+        [IB_WC_LOC_ACCESS_ERR]          = "local access error",
+        [IB_WC_REM_INV_REQ_ERR]         = "invalid request error",
+        [IB_WC_REM_ACCESS_ERR]          = "remote access error",
+        [IB_WC_REM_OP_ERR]              = "remote operation error",
+        [IB_WC_RETRY_EXC_ERR]           = "transport retry counter exceeded",
+        [IB_WC_RNR_RETRY_EXC_ERR]       = "RNR retry counter exceeded",
+        [IB_WC_LOC_RDD_VIOL_ERR]        = "local RDD violation error",
+        [IB_WC_REM_INV_RD_REQ_ERR]      = "remote invalid RD request",
+        [IB_WC_REM_ABORT_ERR]           = "operation aborted",
+        [IB_WC_INV_EECN_ERR]            = "invalid EE context number",
+        [IB_WC_INV_EEC_STATE_ERR]       = "invalid EE context state",
+        [IB_WC_FATAL_ERR]               = "fatal error",
+        [IB_WC_RESP_TIMEOUT_ERR]        = "response timeout error",
+        [IB_WC_GENERAL_ERR]             = "general error",
+};
+
+const char *ib_wc_status_msg(enum ib_wc_status status)
+{
+        size_t index = status;
+
+        return (index < ARRAY_SIZE(wc_statuses) && wc_statuses[index]) ?
+                        wc_statuses[index] : "unrecognized status";
+}
+EXPORT_SYMBOL(ib_wc_status_msg);
+
 __attribute_const__ int ib_rate_to_mult(enum ib_rate rate)
 {
         switch (rate) {
@@ -192,17 +257,16 @@ struct ib_ah *ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr)
 }
 EXPORT_SYMBOL(ib_create_ah);
 
-int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
-                       struct ib_grh *grh, struct ib_ah_attr *ah_attr)
+int ib_init_ah_from_wc(struct ib_device *device, u8 port_num,
+                       const struct ib_wc *wc, const struct ib_grh *grh,
+                       struct ib_ah_attr *ah_attr)
 {
         u32 flow_class;
         u16 gid_index;
         int ret;
-        int is_eth = (rdma_port_get_link_layer(device, port_num) ==
-                        IB_LINK_LAYER_ETHERNET);
 
         memset(ah_attr, 0, sizeof *ah_attr);
-        if (is_eth) {
+        if (rdma_cap_eth_ah(device, port_num)) {
                 if (!(wc->wc_flags & IB_WC_GRH))
                         return -EPROTOTYPE;
 
@@ -244,8 +308,8 @@ int ib_init_ah_from_wc(struct ib_device *device, u8 port_num, struct ib_wc *wc,
 }
 EXPORT_SYMBOL(ib_init_ah_from_wc);
 
-struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, struct ib_wc *wc,
-                                   struct ib_grh *grh, u8 port_num)
+struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
+                                   const struct ib_grh *grh, u8 port_num)
 {
         struct ib_ah_attr ah_attr;
         int ret;
@@ -871,7 +935,7 @@ int ib_resolve_eth_l2_attrs(struct ib_qp *qp,
         union ib_gid  sgid;
 
         if ((*qp_attr_mask & IB_QP_AV)  &&
-            (rdma_port_get_link_layer(qp->device, qp_attr->ah_attr.port_num) == IB_LINK_LAYER_ETHERNET)) {
+            (rdma_cap_eth_ah(qp->device, qp_attr->ah_attr.port_num))) {
                 ret = ib_query_gid(qp->device, qp_attr->ah_attr.port_num,
                                    qp_attr->ah_attr.grh.sgid_index, &sgid);
                 if (ret)
@@ -1012,11 +1076,12 @@ EXPORT_SYMBOL(ib_destroy_qp);
 struct ib_cq *ib_create_cq(struct ib_device *device,
                            ib_comp_handler comp_handler,
                            void (*event_handler)(struct ib_event *, void *),
-                           void *cq_context, int cqe, int comp_vector)
+                           void *cq_context,
+                           const struct ib_cq_init_attr *cq_attr)
 {
         struct ib_cq *cq;
 
-        cq = device->create_cq(device, cqe, comp_vector, NULL, NULL);
+        cq = device->create_cq(device, cq_attr, NULL, NULL);
 
         if (!IS_ERR(cq)) {
                 cq->device        = device;
diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c
index bdf3507810cb..25c3f0085563 100644
--- a/drivers/infiniband/hw/amso1100/c2_provider.c
+++ b/drivers/infiniband/hw/amso1100/c2_provider.c
@@ -63,13 +63,16 @@
 #include "c2_provider.h"
 #include "c2_user.h"
 
-static int c2_query_device(struct ib_device *ibdev,
-                           struct ib_device_attr *props)
+static int c2_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                           struct ib_udata *uhw)
 {
         struct c2_dev *c2dev = to_c2dev(ibdev);
 
         pr_debug("%s:%u\n", __func__, __LINE__);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         *props = c2dev->props;
         return 0;
 }
@@ -286,13 +289,18 @@ static int c2_destroy_qp(struct ib_qp *ib_qp)
         return 0;
 }
 
-static struct ib_cq *c2_create_cq(struct ib_device *ibdev, int entries, int vector,
+static struct ib_cq *c2_create_cq(struct ib_device *ibdev,
+                                  const struct ib_cq_init_attr *attr,
                                   struct ib_ucontext *context,
                                   struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct c2_cq *cq;
         int err;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         cq = kmalloc(sizeof(*cq), GFP_KERNEL);
         if (!cq) {
                 pr_debug("%s: Unable to allocate CQ\n", __func__);
@@ -582,9 +590,13 @@ static int c2_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 static int c2_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)
+                          const struct ib_wc *in_wc,
+                          const struct ib_grh *in_grh,
+                          const struct ib_mad_hdr *in_mad,
+                          size_t in_mad_size,
+                          struct ib_mad_hdr *out_mad,
+                          size_t *out_mad_size,
+                          u16 *out_mad_pkey_index)
 {
         pr_debug("%s:%u\n", __func__, __LINE__);
         return -ENOSYS;
@@ -757,6 +769,23 @@ static struct net_device *c2_pseudo_netdev_init(struct c2_dev *c2dev)
         return netdev;
 }
 
+static int c2_port_immutable(struct ib_device *ibdev, u8 port_num,
+                             struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = c2_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IWARP;
+
+        return 0;
+}
+
 int c2_register_device(struct c2_dev *dev)
 {
         int ret = -ENOMEM;
@@ -820,6 +849,7 @@ int c2_register_device(struct c2_dev *dev)
         dev->ibdev.reg_phys_mr = c2_reg_phys_mr;
         dev->ibdev.reg_user_mr = c2_reg_user_mr;
         dev->ibdev.dereg_mr = c2_dereg_mr;
+        dev->ibdev.get_port_immutable = c2_port_immutable;
 
         dev->ibdev.alloc_fmr = NULL;
         dev->ibdev.unmap_fmr = NULL;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index 811b24a539c0..bbbe0184e592 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -85,9 +85,13 @@ static int iwch_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 static int iwch_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)
+                            const struct ib_wc *in_wc,
+                            const struct ib_grh *in_grh,
+                            const struct ib_mad_hdr *in_mad,
+                            size_t in_mad_size,
+                            struct ib_mad_hdr *out_mad,
+                            size_t *out_mad_size,
+                            u16 *out_mad_pkey_index)
 {
         return -ENOSYS;
 }
@@ -138,10 +142,12 @@ static int iwch_destroy_cq(struct ib_cq *ib_cq)
         return 0;
 }
 
-static struct ib_cq *iwch_create_cq(struct ib_device *ibdev, int entries, int vector,
-                             struct ib_ucontext *ib_context,
-                             struct ib_udata *udata)
+static struct ib_cq *iwch_create_cq(struct ib_device *ibdev,
+                                    const struct ib_cq_init_attr *attr,
+                                    struct ib_ucontext *ib_context,
+                                    struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct iwch_dev *rhp;
         struct iwch_cq *chp;
         struct iwch_create_cq_resp uresp;
@@ -151,6 +157,9 @@ static struct ib_cq *iwch_create_cq(struct ib_device *ibdev, int entries, int ve
         size_t resplen;
 
         PDBG("%s ib_dev %p entries %d\n", __func__, ibdev, entries);
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         rhp = to_iwch_dev(ibdev);
         chp = kzalloc(sizeof(*chp), GFP_KERNEL);
         if (!chp)
@@ -727,6 +736,10 @@ static struct ib_mr *iwch_get_dma_mr(struct ib_pd *pd, int acc)
         /*
          * T3 only supports 32 bits of size.
          */
+        if (sizeof(phys_addr_t) > 4) {
+                pr_warn_once(MOD "Cannot support dma_mrs on this platform.\n");
+                return ERR_PTR(-ENOTSUPP);
+        }
         bl.size = 0xffffffff;
         bl.addr = 0;
         kva = 0;
@@ -1145,13 +1158,17 @@ static u64 fw_vers_string_to_u64(struct iwch_dev *iwch_dev)
                (fw_mic & 0xffff);
 }
 
-static int iwch_query_device(struct ib_device *ibdev,
-                             struct ib_device_attr *props)
+static int iwch_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                             struct ib_udata *uhw)
 {
 
         struct iwch_dev *dev;
+
         PDBG("%s ibdev %p\n", __func__, ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         dev = to_iwch_dev(ibdev);
         memset(props, 0, sizeof *props);
         memcpy(&props->sys_image_guid, dev->rdev.t3cdev_p->lldev->dev_addr, 6);
@@ -1343,6 +1360,23 @@ static struct device_attribute *iwch_class_attributes[] = {
         &dev_attr_board_id,
 };
 
+static int iwch_port_immutable(struct ib_device *ibdev, u8 port_num,
+                               struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = iwch_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IWARP;
+
+        return 0;
+}
+
 int iwch_register_device(struct iwch_dev *dev)
 {
         int ret;
@@ -1420,6 +1454,7 @@ int iwch_register_device(struct iwch_dev *dev)
         dev->ibdev.post_recv = iwch_post_receive;
         dev->ibdev.get_protocol_stats = iwch_get_mib;
         dev->ibdev.uverbs_abi_ver = IWCH_UVERBS_ABI_VERSION;
+        dev->ibdev.get_port_immutable = iwch_port_immutable;
 
         dev->ibdev.iwcm = kmalloc(sizeof(struct iw_cm_verbs), GFP_KERNEL);
         if (!dev->ibdev.iwcm)
diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
index 68ddb3710215..c7aab48f07cd 100644
--- a/drivers/infiniband/hw/cxgb4/cq.c
+++ b/drivers/infiniband/hw/cxgb4/cq.c
@@ -156,19 +156,17 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq,
                 goto err4;
 
         cq->gen = 1;
+        cq->gts = rdev->lldi.gts_reg;
         cq->rdev = rdev;
-        if (user) {
-                u32 off = (cq->cqid << rdev->cqshift) & PAGE_MASK;
 
-                cq->ugts = (u64)rdev->bar2_pa + off;
-        } else if (is_t4(rdev->lldi.adapter_type)) {
-                cq->gts = rdev->lldi.gts_reg;
-                cq->qid_mask = -1U;
-        } else {
-                u32 off = ((cq->cqid << rdev->cqshift) & PAGE_MASK) + 12;
-
-                cq->gts = rdev->bar2_kva + off;
-                cq->qid_mask = rdev->qpmask;
+        cq->bar2_va = c4iw_bar2_addrs(rdev, cq->cqid, T4_BAR2_QTYPE_INGRESS,
+                                      &cq->bar2_qid,
+                                      user ? &cq->bar2_pa : NULL);
+        if (user && !cq->bar2_va) {
+                pr_warn(MOD "%s: cqid %u not in BAR2 range.\n",
+                        pci_name(rdev->lldi.pdev), cq->cqid);
+                ret = -EINVAL;
+                goto err4;
         }
         return 0;
 err4:
@@ -866,10 +864,13 @@ int c4iw_destroy_cq(struct ib_cq *ib_cq)
         return 0;
 }
 
-struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
-                             int vector, struct ib_ucontext *ib_context,
+struct ib_cq *c4iw_create_cq(struct ib_device *ibdev,
+                             const struct ib_cq_init_attr *attr,
+                             struct ib_ucontext *ib_context,
                              struct ib_udata *udata)
 {
+        int entries = attr->cqe;
+        int vector = attr->comp_vector;
         struct c4iw_dev *rhp;
         struct c4iw_cq *chp;
         struct c4iw_create_cq_resp uresp;
@@ -879,6 +880,8 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
         struct c4iw_mm_entry *mm, *mm2;
 
         PDBG("%s ib_dev %p entries %d\n", __func__, ibdev, entries);
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
 
         rhp = to_c4iw_dev(ibdev);
 
@@ -971,7 +974,7 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
                 insert_mmap(ucontext, mm);
 
                 mm2->key = uresp.gts_key;
-                mm2->addr = chp->cq.ugts;
+                mm2->addr = chp->cq.bar2_pa;
                 mm2->len = PAGE_SIZE;
                 insert_mmap(ucontext, mm2);
         }
diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c
index 7e895d714b19..1a297391b54c 100644
--- a/drivers/infiniband/hw/cxgb4/device.c
+++ b/drivers/infiniband/hw/cxgb4/device.c
@@ -795,13 +795,7 @@ static int c4iw_rdev_open(struct c4iw_rdev *rdev)
                 goto err1;
         }
 
-        /*
-         * qpshift is the number of bits to shift the qpid left in order
-         * to get the correct address of the doorbell for that qp.
-         */
-        rdev->qpshift = PAGE_SHIFT - ilog2(rdev->lldi.udb_density);
         rdev->qpmask = rdev->lldi.udb_density - 1;
-        rdev->cqshift = PAGE_SHIFT - ilog2(rdev->lldi.ucq_density);
         rdev->cqmask = rdev->lldi.ucq_density - 1;
         PDBG("%s dev %s stag start 0x%0x size 0x%0x num stags %d "
              "pbl start 0x%0x size 0x%0x rq start 0x%0x size 0x%0x "
@@ -815,14 +809,12 @@ static int c4iw_rdev_open(struct c4iw_rdev *rdev)
              rdev->lldi.vr->qp.size,
              rdev->lldi.vr->cq.start,
              rdev->lldi.vr->cq.size);
-        PDBG("udb len 0x%x udb base %p db_reg %p gts_reg %p qpshift %lu "
-             "qpmask 0x%x cqshift %lu cqmask 0x%x\n",
+        PDBG("udb len 0x%x udb base %p db_reg %p gts_reg %p "
+             "qpmask 0x%x cqmask 0x%x\n",
              (unsigned)pci_resource_len(rdev->lldi.pdev, 2),
              (void *)pci_resource_start(rdev->lldi.pdev, 2),
-             rdev->lldi.db_reg,
-             rdev->lldi.gts_reg,
-             rdev->qpshift, rdev->qpmask,
-             rdev->cqshift, rdev->cqmask);
+             rdev->lldi.db_reg, rdev->lldi.gts_reg,
+             rdev->qpmask, rdev->cqmask);
 
         if (c4iw_num_stags(rdev) == 0) {
                 err = -EINVAL;
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index 97bb5550a6cf..cc77844fada3 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -165,9 +165,7 @@ struct wr_log_entry {
 
 struct c4iw_rdev {
         struct c4iw_resource resource;
-        unsigned long qpshift;
         u32 qpmask;
-        unsigned long cqshift;
         u32 cqmask;
         struct c4iw_dev_ucontext uctx;
         struct gen_pool *pbl_pool;
@@ -992,10 +990,10 @@ int c4iw_reregister_phys_mem(struct ib_mr *mr,
                                      int acc, u64 *iova_start);
 int c4iw_dereg_mr(struct ib_mr *ib_mr);
 int c4iw_destroy_cq(struct ib_cq *ib_cq);
-struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
-                                        int vector,
-                                        struct ib_ucontext *ib_context,
-                                        struct ib_udata *udata);
+struct ib_cq *c4iw_create_cq(struct ib_device *ibdev,
+                             const struct ib_cq_init_attr *attr,
+                             struct ib_ucontext *ib_context,
+                             struct ib_udata *udata);
 int c4iw_resize_cq(struct ib_cq *cq, int cqe, struct ib_udata *udata);
 int c4iw_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags);
 int c4iw_destroy_qp(struct ib_qp *ib_qp);
@@ -1032,6 +1030,9 @@ 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];
+void __iomem *c4iw_bar2_addrs(struct c4iw_rdev *rdev, unsigned int qid,
+                              enum cxgb4_bar2_qtype qtype,
+                              unsigned int *pbar2_qid, u64 *pbar2_pa);
 extern void c4iw_log_wr_stats(struct t4_wq *wq, struct t4_cqe *cqe);
 extern int c4iw_wr_log;
 extern int db_fc_threshold;
diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
index 66bd6a2ad83b..6eee3d385541 100644
--- a/drivers/infiniband/hw/cxgb4/provider.c
+++ b/drivers/infiniband/hw/cxgb4/provider.c
@@ -80,9 +80,13 @@ static int c4iw_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 }
 
 static int c4iw_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)
+                            u8 port_num, const struct ib_wc *in_wc,
+                            const struct ib_grh *in_grh,
+                            const struct ib_mad_hdr *in_mad,
+                            size_t in_mad_size,
+                            struct ib_mad_hdr *out_mad,
+                            size_t *out_mad_size,
+                            u16 *out_mad_pkey_index)
 {
         return -ENOSYS;
 }
@@ -301,13 +305,17 @@ static int c4iw_query_gid(struct ib_device *ibdev, u8 port, int index,
         return 0;
 }
 
-static int c4iw_query_device(struct ib_device *ibdev,
-                             struct ib_device_attr *props)
+static int c4iw_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                             struct ib_udata *uhw)
 {
 
         struct c4iw_dev *dev;
+
         PDBG("%s ibdev %p\n", __func__, ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         dev = to_c4iw_dev(ibdev);
         memset(props, 0, sizeof *props);
         memcpy(&props->sys_image_guid, dev->rdev.lldi.ports[0]->dev_addr, 6);
@@ -445,10 +453,10 @@ static int c4iw_get_mib(struct ib_device *ibdev,
 
         cxgb4_get_tcp_stats(c4iw_dev->rdev.lldi.pdev, &v4, &v6);
         memset(stats, 0, sizeof *stats);
-        stats->iw.tcpInSegs = v4.tcpInSegs + v6.tcpInSegs;
-        stats->iw.tcpOutSegs = v4.tcpOutSegs + v6.tcpOutSegs;
-        stats->iw.tcpRetransSegs = v4.tcpRetransSegs + v6.tcpRetransSegs;
-        stats->iw.tcpOutRsts = v4.tcpOutRsts + v6.tcpOutSegs;
+        stats->iw.tcpInSegs = v4.tcp_in_segs + v6.tcp_in_segs;
+        stats->iw.tcpOutSegs = v4.tcp_out_segs + v6.tcp_out_segs;
+        stats->iw.tcpRetransSegs = v4.tcp_retrans_segs + v6.tcp_retrans_segs;
+        stats->iw.tcpOutRsts = v4.tcp_out_rsts + v6.tcp_out_rsts;
 
         return 0;
 }
@@ -465,6 +473,23 @@ static struct device_attribute *c4iw_class_attributes[] = {
         &dev_attr_board_id,
 };
 
+static int c4iw_port_immutable(struct ib_device *ibdev, u8 port_num,
+                               struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = c4iw_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IWARP;
+
+        return 0;
+}
+
 int c4iw_register_device(struct c4iw_dev *dev)
 {
         int ret;
@@ -542,6 +567,7 @@ int c4iw_register_device(struct c4iw_dev *dev)
         dev->ibdev.post_recv = c4iw_post_receive;
         dev->ibdev.get_protocol_stats = c4iw_get_mib;
         dev->ibdev.uverbs_abi_ver = C4IW_UVERBS_ABI_VERSION;
+        dev->ibdev.get_port_immutable = c4iw_port_immutable;
 
         dev->ibdev.iwcm = kmalloc(sizeof(struct iw_cm_verbs), GFP_KERNEL);
         if (!dev->ibdev.iwcm)
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index 389ced335bc5..6517e1208ccb 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -165,6 +165,29 @@ static int destroy_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         return 0;
 }
 
+/*
+ * Determine the BAR2 virtual address and qid. If pbar2_pa is not NULL,
+ * then this is a user mapping so compute the page-aligned physical address
+ * for mapping.
+ */
+void __iomem *c4iw_bar2_addrs(struct c4iw_rdev *rdev, unsigned int qid,
+                              enum cxgb4_bar2_qtype qtype,
+                              unsigned int *pbar2_qid, u64 *pbar2_pa)
+{
+        u64 bar2_qoffset;
+        int ret;
+
+        ret = cxgb4_bar2_sge_qregs(rdev->lldi.ports[0], qid, qtype,
+                                   pbar2_pa ? 1 : 0,
+                                   &bar2_qoffset, pbar2_qid);
+        if (ret)
+                return NULL;
+
+        if (pbar2_pa)
+                *pbar2_pa = (rdev->bar2_pa + bar2_qoffset) & PAGE_MASK;
+        return rdev->bar2_kva + bar2_qoffset;
+}
+
 static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
                      struct t4_cq *rcq, struct t4_cq *scq,
                      struct c4iw_dev_ucontext *uctx)
@@ -236,25 +259,23 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         dma_unmap_addr_set(&wq->rq, mapping, wq->rq.dma_addr);
 
         wq->db = rdev->lldi.db_reg;
-        wq->gts = rdev->lldi.gts_reg;
-        if (user || is_t5(rdev->lldi.adapter_type)) {
-                u32 off;
 
-                off = (wq->sq.qid << rdev->qpshift) & PAGE_MASK;
-                if (user) {
-                        wq->sq.udb = (u64 __iomem *)(rdev->bar2_pa + off);
-                } else {
-                        off += 128 * (wq->sq.qid & rdev->qpmask) + 8;
-                        wq->sq.udb = (u64 __iomem *)(rdev->bar2_kva + off);
-                }
-                off = (wq->rq.qid << rdev->qpshift) & PAGE_MASK;
-                if (user) {
-                        wq->rq.udb = (u64 __iomem *)(rdev->bar2_pa + off);
-                } else {
-                        off += 128 * (wq->rq.qid & rdev->qpmask) + 8;
-                        wq->rq.udb = (u64 __iomem *)(rdev->bar2_kva + off);
-                }
+        wq->sq.bar2_va = c4iw_bar2_addrs(rdev, wq->sq.qid, T4_BAR2_QTYPE_EGRESS,
+                                         &wq->sq.bar2_qid,
+                                         user ? &wq->sq.bar2_pa : NULL);
+        wq->rq.bar2_va = c4iw_bar2_addrs(rdev, wq->rq.qid, T4_BAR2_QTYPE_EGRESS,
+                                         &wq->rq.bar2_qid,
+                                         user ? &wq->rq.bar2_pa : NULL);
+
+        /*
+         * User mode must have bar2 access.
+         */
+        if (user && (!wq->sq.bar2_va || !wq->rq.bar2_va)) {
+                pr_warn(MOD "%s: sqid %u or rqid %u not in BAR2 range.\n",
+                        pci_name(rdev->lldi.pdev), wq->sq.qid, wq->rq.qid);
+                goto free_dma;
         }
+
         wq->rdev = rdev;
         wq->rq.msn = 1;
 
@@ -336,10 +357,9 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         if (ret)
                 goto free_dma;
 
-        PDBG("%s sqid 0x%x rqid 0x%x kdb 0x%p squdb 0x%lx rqudb 0x%lx\n",
+        PDBG("%s sqid 0x%x rqid 0x%x kdb 0x%p sq_bar2_addr %p rq_bar2_addr %p\n",
              __func__, wq->sq.qid, wq->rq.qid, wq->db,
-             (__force unsigned long) wq->sq.udb,
-             (__force unsigned long) wq->rq.udb);
+             wq->sq.bar2_va, wq->rq.bar2_va);
 
         return 0;
 free_dma:
@@ -1766,11 +1786,11 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
                 mm2->len = PAGE_ALIGN(qhp->wq.rq.memsize);
                 insert_mmap(ucontext, mm2);
                 mm3->key = uresp.sq_db_gts_key;
-                mm3->addr = (__force unsigned long)qhp->wq.sq.udb;
+                mm3->addr = (__force unsigned long)qhp->wq.sq.bar2_pa;
                 mm3->len = PAGE_SIZE;
                 insert_mmap(ucontext, mm3);
                 mm4->key = uresp.rq_db_gts_key;
-                mm4->addr = (__force unsigned long)qhp->wq.rq.udb;
+                mm4->addr = (__force unsigned long)qhp->wq.rq.bar2_pa;
                 mm4->len = PAGE_SIZE;
                 insert_mmap(ucontext, mm4);
                 if (mm5) {
diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h
index 7f2a6c244d25..274a7ab13bef 100644
--- a/drivers/infiniband/hw/cxgb4/t4.h
+++ b/drivers/infiniband/hw/cxgb4/t4.h
@@ -33,6 +33,7 @@
 
 #include "t4_hw.h"
 #include "t4_regs.h"
+#include "t4_values.h"
 #include "t4_msg.h"
 #include "t4fw_ri_api.h"
 
@@ -290,8 +291,10 @@ struct t4_sq {
         unsigned long phys_addr;
         struct t4_swsqe *sw_sq;
         struct t4_swsqe *oldest_read;
-        u64 __iomem *udb;
+        void __iomem *bar2_va;
+        u64 bar2_pa;
         size_t memsize;
+        u32 bar2_qid;
         u32 qid;
         u16 in_use;
         u16 size;
@@ -314,8 +317,10 @@ struct t4_rq {
         dma_addr_t dma_addr;
         DEFINE_DMA_UNMAP_ADDR(mapping);
         struct t4_swrqe *sw_rq;
-        u64 __iomem *udb;
+        void __iomem *bar2_va;
+        u64 bar2_pa;
         size_t memsize;
+        u32 bar2_qid;
         u32 qid;
         u32 msn;
         u32 rqt_hwaddr;
@@ -332,7 +337,6 @@ struct t4_wq {
         struct t4_sq sq;
         struct t4_rq rq;
         void __iomem *db;
-        void __iomem *gts;
         struct c4iw_rdev *rdev;
         int flushed;
 };
@@ -457,15 +461,18 @@ static inline void t4_ring_sq_db(struct t4_wq *wq, u16 inc, u8 t5,
 
         /* Flush host queue memory writes. */
         wmb();
-        if (t5) {
-                if (inc == 1 && wqe) {
+        if (wq->sq.bar2_va) {
+                if (inc == 1 && wq->sq.bar2_qid == 0 && wqe) {
                         PDBG("%s: WC wq->sq.pidx = %d\n",
                              __func__, wq->sq.pidx);
-                        pio_copy(wq->sq.udb + 7, (void *)wqe);
+                        pio_copy((u64 __iomem *)
+                                 (wq->sq.bar2_va + SGE_UDB_WCDOORBELL),
+                                 (u64 *)wqe);
                 } else {
                         PDBG("%s: DB wq->sq.pidx = %d\n",
                              __func__, wq->sq.pidx);
-                        writel(PIDX_T5_V(inc), wq->sq.udb);
+                        writel(PIDX_T5_V(inc) | QID_V(wq->sq.bar2_qid),
+                               wq->sq.bar2_va + SGE_UDB_KDOORBELL);
                 }
 
                 /* Flush user doorbell area writes. */
@@ -481,15 +488,18 @@ static inline void t4_ring_rq_db(struct t4_wq *wq, u16 inc, u8 t5,
 
         /* Flush host queue memory writes. */
         wmb();
-        if (t5) {
-                if (inc == 1 && wqe) {
+        if (wq->rq.bar2_va) {
+                if (inc == 1 && wq->rq.bar2_qid == 0 && wqe) {
                         PDBG("%s: WC wq->rq.pidx = %d\n",
                              __func__, wq->rq.pidx);
-                        pio_copy(wq->rq.udb + 7, (void *)wqe);
+                        pio_copy((u64 __iomem *)
+                                 (wq->rq.bar2_va + SGE_UDB_WCDOORBELL),
+                                 (void *)wqe);
                 } else {
                         PDBG("%s: DB wq->rq.pidx = %d\n",
                              __func__, wq->rq.pidx);
-                        writel(PIDX_T5_V(inc), wq->rq.udb);
+                        writel(PIDX_T5_V(inc) | QID_V(wq->rq.bar2_qid),
+                               wq->rq.bar2_va + SGE_UDB_KDOORBELL);
                 }
 
                 /* Flush user doorbell area writes. */
@@ -534,8 +544,10 @@ struct t4_cq {
         DEFINE_DMA_UNMAP_ADDR(mapping);
         struct t4_cqe *sw_queue;
         void __iomem *gts;
+        void __iomem *bar2_va;
+        u64 bar2_pa;
+        u32 bar2_qid;
         struct c4iw_rdev *rdev;
-        u64 ugts;
         size_t memsize;
         __be64 bits_type_ts;
         u32 cqid;
@@ -552,6 +564,15 @@ struct t4_cq {
         unsigned long flags;
 };
 
+static inline void write_gts(struct t4_cq *cq, u32 val)
+{
+        if (cq->bar2_va)
+                writel(val | INGRESSQID_V(cq->bar2_qid),
+                       cq->bar2_va + SGE_UDB_GTS);
+        else
+                writel(val | INGRESSQID_V(cq->cqid), cq->gts);
+}
+
 static inline int t4_clear_cq_armed(struct t4_cq *cq)
 {
         return test_and_clear_bit(CQ_ARMED, &cq->flags);
@@ -563,14 +584,12 @@ static inline int t4_arm_cq(struct t4_cq *cq, int se)
 
         set_bit(CQ_ARMED, &cq->flags);
         while (cq->cidx_inc > CIDXINC_M) {
-                val = SEINTARM_V(0) | CIDXINC_V(CIDXINC_M) | TIMERREG_V(7) |
-                      INGRESSQID_V(cq->cqid & cq->qid_mask);
-                writel(val, cq->gts);
+                val = SEINTARM_V(0) | CIDXINC_V(CIDXINC_M) | TIMERREG_V(7);
+                write_gts(cq, val);
                 cq->cidx_inc -= CIDXINC_M;
         }
-        val = SEINTARM_V(se) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(6) |
-              INGRESSQID_V(cq->cqid & cq->qid_mask);
-        writel(val, cq->gts);
+        val = SEINTARM_V(se) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(6);
+        write_gts(cq, val);
         cq->cidx_inc = 0;
         return 0;
 }
@@ -601,9 +620,8 @@ static inline void t4_hwcq_consume(struct t4_cq *cq)
         if (++cq->cidx_inc == (cq->size >> 4) || cq->cidx_inc == CIDXINC_M) {
                 u32 val;
 
-                val = SEINTARM_V(0) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(7) |
-                      INGRESSQID_V(cq->cqid & cq->qid_mask);
-                writel(val, cq->gts);
+                val = SEINTARM_V(0) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(7);
+                write_gts(cq, val);
                 cq->cidx_inc = 0;
         }
         if (++cq->cidx == cq->size) {
diff --git a/drivers/infiniband/hw/ehca/ehca_cq.c b/drivers/infiniband/hw/ehca/ehca_cq.c
index 8cc837537768..9b68b175069b 100644
--- a/drivers/infiniband/hw/ehca/ehca_cq.c
+++ b/drivers/infiniband/hw/ehca/ehca_cq.c
@@ -113,10 +113,12 @@ struct ehca_qp *ehca_cq_get_qp(struct ehca_cq *cq, int real_qp_num)
         return ret;
 }
 
-struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
+struct ib_cq *ehca_create_cq(struct ib_device *device,
+                             const struct ib_cq_init_attr *attr,
                              struct ib_ucontext *context,
                              struct ib_udata *udata)
 {
+        int cqe = attr->cqe;
         static const u32 additional_cqe = 20;
         struct ib_cq *cq;
         struct ehca_cq *my_cq;
@@ -131,6 +133,9 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
         int ipz_rc, i;
         unsigned long flags;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (cqe >= 0xFFFFFFFF - 64 - additional_cqe)
                 return ERR_PTR(-EINVAL);
 
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 9ed4d2588304..e8b1bb65797a 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -50,7 +50,8 @@ static unsigned int limit_uint(unsigned int value)
         return min_t(unsigned int, value, INT_MAX);
 }
 
-int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
+int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                      struct ib_udata *uhw)
 {
         int i, ret = 0;
         struct ehca_shca *shca = container_of(ibdev, struct ehca_shca,
@@ -71,6 +72,9 @@ int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
                 IB_DEVICE_PORT_ACTIVE_EVENT,  HCA_CAP_PORT_ACTIVE_EVENT,
         };
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
         if (!rblock) {
                 ehca_err(&shca->ib_device, "Can't allocate rblock memory.");
diff --git a/drivers/infiniband/hw/ehca/ehca_iverbs.h b/drivers/infiniband/hw/ehca/ehca_iverbs.h
index 22f79afa7fc1..80e6a3d5df3e 100644
--- a/drivers/infiniband/hw/ehca/ehca_iverbs.h
+++ b/drivers/infiniband/hw/ehca/ehca_iverbs.h
@@ -44,11 +44,15 @@
 
 #include "ehca_classes.h"
 
-int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props);
+int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                      struct ib_udata *uhw);
 
 int ehca_query_port(struct ib_device *ibdev, u8 port,
                     struct ib_port_attr *props);
 
+enum rdma_protocol_type
+ehca_query_protocol(struct ib_device *device, u8 port_num);
+
 int ehca_query_sma_attr(struct ehca_shca *shca, u8 port,
                         struct ehca_sma_attr *attr);
 
@@ -126,7 +130,8 @@ int ehca_destroy_eq(struct ehca_shca *shca, struct ehca_eq *eq);
 void *ehca_poll_eq(struct ehca_shca *shca, struct ehca_eq *eq);
 
 
-struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
+struct ib_cq *ehca_create_cq(struct ib_device *device,
+                             const struct ib_cq_init_attr *attr,
                              struct ib_ucontext *context,
                              struct ib_udata *udata);
 
@@ -188,9 +193,10 @@ int ehca_dealloc_ucontext(struct ib_ucontext *context);
 int ehca_mmap(struct ib_ucontext *context, struct vm_area_struct *vma);
 
 int ehca_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);
+                     const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                     const struct ib_mad_hdr *in, size_t in_mad_size,
+                     struct ib_mad_hdr *out, size_t *out_mad_size,
+                     u16 *out_mad_pkey_index);
 
 void ehca_poll_eqs(unsigned long data);
 
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index cd8d290a09fc..8246418cd4e0 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -46,6 +46,7 @@
 
 #include <linux/notifier.h>
 #include <linux/memory.h>
+#include <rdma/ib_mad.h>
 #include "ehca_classes.h"
 #include "ehca_iverbs.h"
 #include "ehca_mrmw.h"
@@ -431,6 +432,24 @@ init_node_guid1:
         return ret;
 }
 
+static int ehca_port_immutable(struct ib_device *ibdev, u8 port_num,
+                               struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = ehca_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 static int ehca_init_device(struct ehca_shca *shca)
 {
         int ret;
@@ -510,6 +529,7 @@ static int ehca_init_device(struct ehca_shca *shca)
         shca->ib_device.process_mad         = ehca_process_mad;
         shca->ib_device.mmap                = ehca_mmap;
         shca->ib_device.dma_ops             = &ehca_dma_mapping_ops;
+        shca->ib_device.get_port_immutable  = ehca_port_immutable;
 
         if (EHCA_BMASK_GET(HCA_CAP_SRQ, shca->hca_cap)) {
                 shca->ib_device.uverbs_cmd_mask |=
@@ -534,6 +554,7 @@ static int ehca_create_aqp1(struct ehca_shca *shca, u32 port)
         struct ib_cq *ibcq;
         struct ib_qp *ibqp;
         struct ib_qp_init_attr qp_init_attr;
+        struct ib_cq_init_attr cq_attr = {};
         int ret;
 
         if (sport->ibcq_aqp1) {
@@ -541,7 +562,9 @@ static int ehca_create_aqp1(struct ehca_shca *shca, u32 port)
                 return -EPERM;
         }
 
-        ibcq = ib_create_cq(&shca->ib_device, NULL, NULL, (void *)(-1), 10, 0);
+        cq_attr.cqe = 10;
+        ibcq = ib_create_cq(&shca->ib_device, NULL, NULL, (void *)(-1),
+                            &cq_attr);
         if (IS_ERR(ibcq)) {
                 ehca_err(&shca->ib_device, "Cannot create AQP1 CQ.");
                 return PTR_ERR(ibcq);
diff --git a/drivers/infiniband/hw/ehca/ehca_sqp.c b/drivers/infiniband/hw/ehca/ehca_sqp.c
index dba8f9f8b996..376b031c2c7f 100644
--- a/drivers/infiniband/hw/ehca/ehca_sqp.c
+++ b/drivers/infiniband/hw/ehca/ehca_sqp.c
@@ -140,10 +140,10 @@ struct vertcfl {
 } __attribute__ ((packed));
 
 static int ehca_process_perf(struct ib_device *ibdev, u8 port_num,
-                             struct ib_wc *in_wc, struct ib_grh *in_grh,
-                             struct ib_mad *in_mad, struct ib_mad *out_mad)
+                             const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                             const struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
-        struct ib_perf *in_perf = (struct ib_perf *)in_mad;
+        const struct ib_perf *in_perf = (const struct ib_perf *)in_mad;
         struct ib_perf *out_perf = (struct ib_perf *)out_mad;
         struct ib_class_port_info *poi =
                 (struct ib_class_port_info *)out_perf->data;
@@ -187,8 +187,8 @@ static int ehca_process_perf(struct ib_device *ibdev, u8 port_num,
 
                 /* if request was globally routed, copy route info */
                 if (in_grh) {
-                        struct vertcfl *vertcfl =
-                                (struct vertcfl *)&in_grh->version_tclass_flow;
+                        const struct vertcfl *vertcfl =
+                                (const struct vertcfl *)&in_grh->version_tclass_flow;
                         memcpy(poi->redirect_gid, in_grh->dgid.raw,
                                sizeof(poi->redirect_gid));
                         tcslfl->tc        = vertcfl->tc;
@@ -217,10 +217,18 @@ perf_reply:
 }
 
 int ehca_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)
+                     const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                     const struct ib_mad_hdr *in, size_t in_mad_size,
+                     struct ib_mad_hdr *out, size_t *out_mad_size,
+                     u16 *out_mad_pkey_index)
 {
         int ret;
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         if (!port_num || port_num > ibdev->phys_port_cnt || !in_wc)
                 return IB_MAD_RESULT_FAILURE;
diff --git a/drivers/infiniband/hw/ehca/ipz_pt_fn.c b/drivers/infiniband/hw/ehca/ipz_pt_fn.c
index 8d594517cd29..7ffc748cb973 100644
--- a/drivers/infiniband/hw/ehca/ipz_pt_fn.c
+++ b/drivers/infiniband/hw/ehca/ipz_pt_fn.c
@@ -245,10 +245,7 @@ int ipz_queue_ctor(struct ehca_pd *pd, struct ipz_queue *queue,
 ipz_queue_ctor_exit0:
         ehca_gen_err("Couldn't alloc pages queue=%p "
                  "nr_of_pages=%x",  queue, nr_of_pages);
-        if (is_vmalloc_addr(queue->queue_pages))
-                vfree(queue->queue_pages);
-        else
-                kfree(queue->queue_pages);
+        kvfree(queue->queue_pages);
 
         return 0;
 }
@@ -270,10 +267,7 @@ int ipz_queue_dtor(struct ehca_pd *pd, struct ipz_queue *queue)
                         free_page((unsigned long)queue->queue_pages[i]);
         }
 
-        if (is_vmalloc_addr(queue->queue_pages))
-                vfree(queue->queue_pages);
-        else
-                kfree(queue->queue_pages);
+        kvfree(queue->queue_pages);
 
         return 1;
 }
diff --git a/drivers/infiniband/hw/ipath/ipath_cq.c b/drivers/infiniband/hw/ipath/ipath_cq.c
index 0416c6c0e126..e9dd9112e718 100644
--- a/drivers/infiniband/hw/ipath/ipath_cq.c
+++ b/drivers/infiniband/hw/ipath/ipath_cq.c
@@ -188,7 +188,7 @@ static void send_complete(unsigned long data)
 /**
  * ipath_create_cq - create a completion queue
  * @ibdev: the device this completion queue is attached to
- * @entries: the minimum size of the completion queue
+ * @attr: creation attributes
  * @context: unused by the InfiniPath driver
  * @udata: unused by the InfiniPath driver
  *
@@ -197,16 +197,21 @@ static void send_complete(unsigned long data)
  *
  * Called by ib_create_cq() in the generic verbs code.
  */
-struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries, int comp_vector,
+struct ib_cq *ipath_create_cq(struct ib_device *ibdev,
+                              const struct ib_cq_init_attr *attr,
                               struct ib_ucontext *context,
                               struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct ipath_ibdev *dev = to_idev(ibdev);
         struct ipath_cq *cq;
         struct ipath_cq_wc *wc;
         struct ib_cq *ret;
         u32 sz;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (entries < 1 || entries > ib_ipath_max_cqes) {
                 ret = ERR_PTR(-EINVAL);
                 goto done;
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index 2d7e503d13cb..871dbe56216a 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -31,6 +31,8 @@
  * SOFTWARE.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/idr.h>
@@ -399,8 +401,8 @@ static int ipath_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         u32 bar0 = 0, bar1 = 0;
 
 #ifdef CONFIG_X86_64
-        if (WARN(pat_enabled(),
-                 "ipath needs PAT disabled, boot with nopat kernel parameter\n")) {
+        if (pat_enabled()) {
+                pr_warn("ipath needs PAT disabled, boot with nopat kernel parameter\n");
                 ret = -ENODEV;
                 goto bail;
         }
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index 1ca8e32a9592..25422a3a7238 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -277,7 +277,7 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {
+        if (simple_positive(tmp)) {
                 dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
diff --git a/drivers/infiniband/hw/ipath/ipath_mad.c b/drivers/infiniband/hw/ipath/ipath_mad.c
index e890e5ba0e01..ad3a926ab3c5 100644
--- a/drivers/infiniband/hw/ipath/ipath_mad.c
+++ b/drivers/infiniband/hw/ipath/ipath_mad.c
@@ -1257,7 +1257,7 @@ static int recv_pma_set_portcounters_ext(struct ib_pma_mad *pmp,
 }
 
 static int process_subn(struct ib_device *ibdev, int mad_flags,
-                        u8 port_num, struct ib_mad *in_mad,
+                        u8 port_num, const struct ib_mad *in_mad,
                         struct ib_mad *out_mad)
 {
         struct ib_smp *smp = (struct ib_smp *)out_mad;
@@ -1389,7 +1389,7 @@ bail:
 }
 
 static int process_perf(struct ib_device *ibdev, u8 port_num,
-                        struct ib_mad *in_mad,
+                        const struct ib_mad *in_mad,
                         struct ib_mad *out_mad)
 {
         struct ib_pma_mad *pmp = (struct ib_pma_mad *)out_mad;
@@ -1490,10 +1490,18 @@ bail:
  * This is called by the ib_mad module.
  */
 int ipath_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)
+                      const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                      const struct ib_mad_hdr *in, size_t in_mad_size,
+                      struct ib_mad_hdr *out, size_t *out_mad_size,
+                      u16 *out_mad_pkey_index)
 {
         int ret;
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         switch (in_mad->mad_hdr.mgmt_class) {
         case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index 44ea9390417c..30ba49c4a98c 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -1495,11 +1495,14 @@ bail:
         return 0;
 }
 
-static int ipath_query_device(struct ib_device *ibdev,
-                              struct ib_device_attr *props)
+static int ipath_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                              struct ib_udata *uhw)
 {
         struct ipath_ibdev *dev = to_idev(ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         memset(props, 0, sizeof(*props));
 
         props->device_cap_flags = IB_DEVICE_BAD_PKEY_CNTR |
@@ -1980,6 +1983,24 @@ static int disable_timer(struct ipath_devdata *dd)
         return 0;
 }
 
+static int ipath_port_immutable(struct ib_device *ibdev, u8 port_num,
+                                struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = ipath_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 /**
  * ipath_register_ib_device - register our device with the infiniband core
  * @dd: the device data structure
@@ -2023,9 +2044,9 @@ int ipath_register_ib_device(struct ipath_devdata *dd)
 
         spin_lock_init(&idev->qp_table.lock);
         spin_lock_init(&idev->lk_table.lock);
-        idev->sm_lid = __constant_be16_to_cpu(IB_LID_PERMISSIVE);
+        idev->sm_lid = be16_to_cpu(IB_LID_PERMISSIVE);
         /* Set the prefix to the default value (see ch. 4.1.1) */
-        idev->gid_prefix = __constant_cpu_to_be64(0xfe80000000000000ULL);
+        idev->gid_prefix = cpu_to_be64(0xfe80000000000000ULL);
 
         ret = ipath_init_qp_table(idev, ib_ipath_qp_table_size);
         if (ret)
@@ -2179,6 +2200,7 @@ int ipath_register_ib_device(struct ipath_devdata *dd)
         dev->process_mad = ipath_process_mad;
         dev->mmap = ipath_mmap;
         dev->dma_ops = &ipath_dma_mapping_ops;
+        dev->get_port_immutable = ipath_port_immutable;
 
         snprintf(dev->node_desc, sizeof(dev->node_desc),
                  IPATH_IDSTR " %s", init_utsname()->nodename);
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.h b/drivers/infiniband/hw/ipath/ipath_verbs.h
index ae6cff4abffc..ec167e545e15 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.h
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.h
@@ -701,9 +701,11 @@ static inline void ipath_schedule_send(struct ipath_qp *qp)
 int ipath_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);
+                      const struct ib_wc *in_wc,
+                      const struct ib_grh *in_grh,
+                      const struct ib_mad_hdr *in, size_t in_mad_size,
+                      struct ib_mad_hdr *out, size_t *out_mad_size,
+                      u16 *out_mad_pkey_index);
 
 /*
  * Compare the lower 24 bits of the two values.
@@ -807,7 +809,8 @@ void ipath_cq_enter(struct ipath_cq *cq, struct ib_wc *entry, int sig);
 
 int ipath_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry);
 
-struct ib_cq *ipath_create_cq(struct ib_device *ibdev, int entries, int comp_vector,
+struct ib_cq *ipath_create_cq(struct ib_device *ibdev,
+                              const struct ib_cq_init_attr *attr,
                               struct ib_ucontext *context,
                               struct ib_udata *udata);
 
diff --git a/drivers/infiniband/hw/mlx4/alias_GUID.c b/drivers/infiniband/hw/mlx4/alias_GUID.c
index 0f00204d2ece..21cb41a60fe8 100644
--- a/drivers/infiniband/hw/mlx4/alias_GUID.c
+++ b/drivers/infiniband/hw/mlx4/alias_GUID.c
@@ -189,7 +189,7 @@ void mlx4_ib_notify_slaves_on_guid_change(struct mlx4_ib_dev *dev,
 {
         int i;
         u64 guid_indexes;
-        int slave_id;
+        int slave_id, slave_port;
         enum slave_port_state new_state;
         enum slave_port_state prev_state;
         __be64 tmp_cur_ag, form_cache_ag;
@@ -217,6 +217,11 @@ void mlx4_ib_notify_slaves_on_guid_change(struct mlx4_ib_dev *dev,
                 slave_id = (block_num * NUM_ALIAS_GUID_IN_REC) + i ;
                 if (slave_id >= dev->dev->persist->num_vfs + 1)
                         return;
+
+                slave_port = mlx4_phys_to_slave_port(dev->dev, slave_id, port_num);
+                if (slave_port < 0) /* this port isn't available for the VF */
+                        continue;
+
                 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);
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 0176caa5792c..36eb3d012b6d 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -166,10 +166,14 @@ err_buf:
         return err;
 }
 
-struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector,
+#define CQ_CREATE_FLAGS_SUPPORTED IB_CQ_FLAGS_TIMESTAMP_COMPLETION
+struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev,
+                                const struct ib_cq_init_attr *attr,
                                 struct ib_ucontext *context,
                                 struct ib_udata *udata)
 {
+        int entries = attr->cqe;
+        int vector = attr->comp_vector;
         struct mlx4_ib_dev *dev = to_mdev(ibdev);
         struct mlx4_ib_cq *cq;
         struct mlx4_uar *uar;
@@ -178,6 +182,9 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector
         if (entries < 1 || entries > dev->dev->caps.max_cqes)
                 return ERR_PTR(-EINVAL);
 
+        if (attr->flags & ~CQ_CREATE_FLAGS_SUPPORTED)
+                return ERR_PTR(-EINVAL);
+
         cq = kmalloc(sizeof *cq, GFP_KERNEL);
         if (!cq)
                 return ERR_PTR(-ENOMEM);
@@ -188,6 +195,7 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector
         spin_lock_init(&cq->lock);
         cq->resize_buf = NULL;
         cq->resize_umem = NULL;
+        cq->create_flags = attr->flags;
         INIT_LIST_HEAD(&cq->send_qp_list);
         INIT_LIST_HEAD(&cq->recv_qp_list);
 
@@ -231,7 +239,8 @@ struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector
                 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, 0);
+                            cq->db.dma, &cq->mcq, vector, 0,
+                            !!(cq->create_flags & IB_CQ_FLAGS_TIMESTAMP_COMPLETION));
         if (err)
                 goto err_dbmap;
 
diff --git a/drivers/infiniband/hw/mlx4/mad.c b/drivers/infiniband/hw/mlx4/mad.c
index 9cd2b002d7ae..68b3dfa922bf 100644
--- a/drivers/infiniband/hw/mlx4/mad.c
+++ b/drivers/infiniband/hw/mlx4/mad.c
@@ -64,14 +64,6 @@ enum {
 #define GUID_TBL_BLK_NUM_ENTRIES 8
 #define GUID_TBL_BLK_SIZE (GUID_TBL_ENTRY_SIZE * GUID_TBL_BLK_NUM_ENTRIES)
 
-/* Counters should be saturate once they reach their maximum value */
-#define ASSIGN_32BIT_COUNTER(counter, value) do {\
-        if ((value) > U32_MAX)                   \
-                counter = cpu_to_be32(U32_MAX); \
-        else                                     \
-                counter = cpu_to_be32(value);    \
-} while (0)
-
 struct mlx4_mad_rcv_buf {
         struct ib_grh grh;
         u8 payload[256];
@@ -111,8 +103,9 @@ __be64 mlx4_ib_get_new_demux_tid(struct mlx4_ib_demux_ctx *ctx)
 }
 
 int mlx4_MAD_IFC(struct mlx4_ib_dev *dev, int mad_ifc_flags,
-                 int port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad)
+                 int port, const struct ib_wc *in_wc,
+                 const struct ib_grh *in_grh,
+                 const void *in_mad, void *response_mad)
 {
         struct mlx4_cmd_mailbox *inmailbox, *outmailbox;
         void *inbox;
@@ -220,7 +213,7 @@ static void update_sm_ah(struct mlx4_ib_dev *dev, u8 port_num, u16 lid, u8 sl)
  * 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.
  */
-static void smp_snoop(struct ib_device *ibdev, u8 port_num, struct ib_mad *mad,
+static void smp_snoop(struct ib_device *ibdev, u8 port_num, const struct ib_mad *mad,
                       u16 prev_lid)
 {
         struct ib_port_info *pinfo;
@@ -356,7 +349,7 @@ static void node_desc_override(struct ib_device *dev,
         }
 }
 
-static void forward_trap(struct mlx4_ib_dev *dev, u8 port_num, struct ib_mad *mad)
+static void forward_trap(struct mlx4_ib_dev *dev, u8 port_num, const struct ib_mad *mad)
 {
         int qpn = mad->mad_hdr.mgmt_class != IB_MGMT_CLASS_SUBN_LID_ROUTED;
         struct ib_mad_send_buf *send_buf;
@@ -366,7 +359,8 @@ static void forward_trap(struct mlx4_ib_dev *dev, u8 port_num, struct ib_mad *ma
 
         if (agent) {
                 send_buf = ib_create_send_mad(agent, qpn, 0, 0, IB_MGMT_MAD_HDR,
-                                              IB_MGMT_MAD_DATA, GFP_ATOMIC);
+                                              IB_MGMT_MAD_DATA, GFP_ATOMIC,
+                                              IB_MGMT_BASE_VERSION);
                 if (IS_ERR(send_buf))
                         return;
                 /*
@@ -722,8 +716,8 @@ static int mlx4_ib_demux_mad(struct ib_device *ibdev, u8 port,
 }
 
 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)
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
         u16 slid, prev_lid = 0;
         int err;
@@ -825,34 +819,28 @@ static void edit_counter(struct mlx4_counter *cnt,
 }
 
 static int iboe_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)
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad *in_mad, struct ib_mad *out_mad)
 {
-        struct mlx4_cmd_mailbox *mailbox;
+        struct mlx4_counter counter_stats;
         struct mlx4_ib_dev *dev = to_mdev(ibdev);
         int err;
-        u32 inmod = dev->counters[port_num - 1] & 0xffff;
-        u8 mode;
 
         if (in_mad->mad_hdr.mgmt_class != IB_MGMT_CLASS_PERF_MGMT)
                 return -EINVAL;
 
-        mailbox = mlx4_alloc_cmd_mailbox(dev->dev);
-        if (IS_ERR(mailbox))
-                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);
+        memset(&counter_stats, 0, sizeof(counter_stats));
+        err = mlx4_get_counter_stats(dev->dev,
+                                     dev->counters[port_num - 1].index,
+                                     &counter_stats, 0);
         if (err)
                 err = IB_MAD_RESULT_FAILURE;
         else {
                 memset(out_mad->data, 0, sizeof out_mad->data);
-                mode = ((struct mlx4_counter *)mailbox->buf)->counter_mode;
-                switch (mode & 0xf) {
+                switch (counter_stats.counter_mode & 0xf) {
                 case 0:
-                        edit_counter(mailbox->buf,
-                                                (void *)(out_mad->data + 40));
+                        edit_counter(&counter_stats,
+                                     (void *)(out_mad->data + 40));
                         err = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
                         break;
                 default:
@@ -860,25 +848,43 @@ static int iboe_process_mad(struct ib_device *ibdev, int mad_flags, u8 port_num,
                 }
         }
 
-        mlx4_free_cmd_mailbox(dev->dev, mailbox);
-
         return err;
 }
 
 int mlx4_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)
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad_hdr *in, size_t in_mad_size,
+                        struct ib_mad_hdr *out, size_t *out_mad_size,
+                        u16 *out_mad_pkey_index)
 {
-        switch (rdma_port_get_link_layer(ibdev, port_num)) {
-        case IB_LINK_LAYER_INFINIBAND:
+        struct mlx4_ib_dev *dev = to_mdev(ibdev);
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+        enum rdma_link_layer link = rdma_port_get_link_layer(ibdev, port_num);
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
+
+        /* iboe_process_mad() which uses the HCA flow-counters to implement IB PMA
+         * queries, should be called only by VFs and for that specific purpose
+         */
+        if (link == IB_LINK_LAYER_INFINIBAND) {
+                if (mlx4_is_slave(dev->dev) &&
+                    in_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_PERF_MGMT &&
+                    in_mad->mad_hdr.attr_id == IB_PMA_PORT_COUNTERS)
+                        return iboe_process_mad(ibdev, mad_flags, port_num, in_wc,
+                                                in_grh, in_mad, out_mad);
+
                 return ib_process_mad(ibdev, mad_flags, port_num, in_wc,
                                       in_grh, in_mad, out_mad);
-        case IB_LINK_LAYER_ETHERNET:
-                return iboe_process_mad(ibdev, mad_flags, port_num, in_wc,
-                                          in_grh, in_mad, out_mad);
-        default:
-                return -EINVAL;
         }
+
+        if (link == IB_LINK_LAYER_ETHERNET)
+                return iboe_process_mad(ibdev, mad_flags, port_num, in_wc,
+                                        in_grh, in_mad, out_mad);
+
+        return -EINVAL;
 }
 
 static void send_handler(struct ib_mad_agent *agent,
@@ -1365,14 +1371,17 @@ static void mlx4_ib_multiplex_mad(struct mlx4_ib_demux_pv_ctx *ctx, struct ib_wc
          * 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;
+
+        port = be32_to_cpu(ah.av.ib.port_pd) >> 24;
+        port = mlx4_slave_convert_port(dev->dev, slave, port);
+        if (port < 0)
+                return;
+        ah.av.ib.port_pd = cpu_to_be32(port << 24 | (be32_to_cpu(ah.av.ib.port_pd) & 0xffffff));
+
         mlx4_ib_query_ah(&ah.ibah, &ah_attr);
         if (ah_attr.ah_flags & IB_AH_GRH)
                 fill_in_real_sgid_index(dev, slave, ctx->port, &ah_attr);
 
-        port = mlx4_slave_convert_port(dev->dev, slave, ah_attr.port_num);
-        if (port < 0)
-                return;
-        ah_attr.port_num = port;
         memcpy(ah_attr.dmac, tunnel->hdr.mac, 6);
         ah_attr.vlan_id = be16_to_cpu(tunnel->hdr.vlan);
         /* if slave have default vlan use it */
@@ -1773,6 +1782,7 @@ 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;
+        struct ib_cq_init_attr cq_attr = {};
 
         if (ctx->state != DEMUX_PV_STATE_DOWN)
                 return -EEXIST;
@@ -1801,8 +1811,9 @@ static int create_pv_resources(struct ib_device *ibdev, int slave, int port,
         if (ctx->has_smi)
                 cq_size *= 2;
 
+        cq_attr.cqe = cq_size;
         ctx->cq = ib_create_cq(ctx->ib_dev, mlx4_ib_tunnel_comp_handler,
-                               NULL, ctx, cq_size, 0);
+                               NULL, ctx, &cq_attr);
         if (IS_ERR(ctx->cq)) {
                 ret = PTR_ERR(ctx->cq);
                 pr_err("Couldn't create tunnel CQ (%d)\n", ret);
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index cc64400d41ac..8be6db816460 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -132,14 +132,35 @@ static int num_ib_ports(struct mlx4_dev *dev)
 }
 
 static int mlx4_ib_query_device(struct ib_device *ibdev,
-                                struct ib_device_attr *props)
+                                struct ib_device_attr *props,
+                                struct ib_udata *uhw)
 {
         struct mlx4_ib_dev *dev = to_mdev(ibdev);
         struct ib_smp *in_mad  = NULL;
         struct ib_smp *out_mad = NULL;
         int err = -ENOMEM;
         int have_ib_ports;
+        struct mlx4_uverbs_ex_query_device cmd;
+        struct mlx4_uverbs_ex_query_device_resp resp = {.comp_mask = 0};
+        struct mlx4_clock_params clock_params;
 
+        if (uhw->inlen) {
+                if (uhw->inlen < sizeof(cmd))
+                        return -EINVAL;
+
+                err = ib_copy_from_udata(&cmd, uhw, sizeof(cmd));
+                if (err)
+                        return err;
+
+                if (cmd.comp_mask)
+                        return -EINVAL;
+
+                if (cmd.reserved)
+                        return -EINVAL;
+        }
+
+        resp.response_length = offsetof(typeof(resp), response_length) +
+                sizeof(resp.response_length);
         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
@@ -229,7 +250,25 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
         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->hca_core_clock = dev->dev->caps.hca_core_clock * 1000UL;
+        props->timestamp_mask = 0xFFFFFFFFFFFFULL;
 
+        if (!mlx4_is_slave(dev->dev))
+                err = mlx4_get_internal_clock_params(dev->dev, &clock_params);
+
+        if (uhw->outlen >= resp.response_length + sizeof(resp.hca_core_clock_offset)) {
+                resp.response_length += sizeof(resp.hca_core_clock_offset);
+                if (!err && !mlx4_is_slave(dev->dev)) {
+                        resp.comp_mask |= QUERY_DEVICE_RESP_MASK_TIMESTAMP;
+                        resp.hca_core_clock_offset = clock_params.offset % PAGE_SIZE;
+                }
+        }
+
+        if (uhw->outlen) {
+                err = ib_copy_to_udata(uhw, &resp, resp.response_length);
+                if (err)
+                        goto out;
+        }
 out:
         kfree(in_mad);
         kfree(out_mad);
@@ -712,8 +751,24 @@ static int mlx4_ib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
                                        dev->dev->caps.num_uars,
                                        PAGE_SIZE, vma->vm_page_prot))
                         return -EAGAIN;
-        } else
+        } else if (vma->vm_pgoff == 3) {
+                struct mlx4_clock_params params;
+                int ret = mlx4_get_internal_clock_params(dev->dev, &params);
+
+                if (ret)
+                        return ret;
+
+                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+                if (io_remap_pfn_range(vma, vma->vm_start,
+                                       (pci_resource_start(dev->dev->persist->pdev,
+                                                           params.bar) +
+                                        params.offset)
+                                       >> PAGE_SHIFT,
+                                       PAGE_SIZE, vma->vm_page_prot))
+                        return -EAGAIN;
+        } else {
                 return -EINVAL;
+        }
 
         return 0;
 }
@@ -758,6 +813,7 @@ static struct ib_xrcd *mlx4_ib_alloc_xrcd(struct ib_device *ibdev,
                                           struct ib_udata *udata)
 {
         struct mlx4_ib_xrcd *xrcd;
+        struct ib_cq_init_attr cq_attr = {};
         int err;
 
         if (!(to_mdev(ibdev)->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC))
@@ -777,7 +833,8 @@ static struct ib_xrcd *mlx4_ib_alloc_xrcd(struct ib_device *ibdev,
                 goto err2;
         }
 
-        xrcd->cq = ib_create_cq(ibdev, NULL, NULL, xrcd, 1, 0);
+        cq_attr.cqe = 1;
+        xrcd->cq = ib_create_cq(ibdev, NULL, NULL, xrcd, &cq_attr);
         if (IS_ERR(xrcd->cq)) {
                 err = PTR_ERR(xrcd->cq);
                 goto err3;
@@ -1090,7 +1147,7 @@ static int __mlx4_ib_create_flow(struct ib_qp *qp, struct ib_flow_attr *flow_att
 
         ret = mlx4_cmd_imm(mdev->dev, mailbox->dma, reg_id, size >> 2, 0,
                            MLX4_QP_FLOW_STEERING_ATTACH, MLX4_CMD_TIME_CLASS_A,
-                           MLX4_CMD_NATIVE);
+                           MLX4_CMD_WRAPPED);
         if (ret == -ENOMEM)
                 pr_err("mcg table is full. Fail to register network rule.\n");
         else if (ret == -ENXIO)
@@ -1107,7 +1164,7 @@ static int __mlx4_ib_destroy_flow(struct mlx4_dev *dev, u64 reg_id)
         int err;
         err = mlx4_cmd(dev, reg_id, 0, 0,
                        MLX4_QP_FLOW_STEERING_DETACH, MLX4_CMD_TIME_CLASS_A,
-                       MLX4_CMD_NATIVE);
+                       MLX4_CMD_WRAPPED);
         if (err)
                 pr_err("Fail to detach network rule. registration id = 0x%llx\n",
                        reg_id);
@@ -1185,7 +1242,6 @@ static struct ib_flow *mlx4_ib_create_flow(struct ib_qp *qp,
                                             &mflow->reg_id[i].id);
                 if (err)
                         goto err_create_flow;
-                i++;
                 if (is_bonded) {
                         /* Application always sees one port so the mirror rule
                          * must be on port #2
@@ -1200,6 +1256,7 @@ static struct ib_flow *mlx4_ib_create_flow(struct ib_qp *qp,
                         j++;
                 }
 
+                i++;
         }
 
         if (i < ARRAY_SIZE(type) && flow_attr->type == IB_FLOW_ATTR_NORMAL) {
@@ -1207,7 +1264,7 @@ static struct ib_flow *mlx4_ib_create_flow(struct ib_qp *qp,
                                                &mflow->reg_id[i].id);
                 if (err)
                         goto err_create_flow;
-                i++;
+
                 if (is_bonded) {
                         flow_attr->port = 2;
                         err = mlx4_ib_tunnel_steer_add(qp, flow_attr,
@@ -1218,6 +1275,7 @@ static struct ib_flow *mlx4_ib_create_flow(struct ib_qp *qp,
                         j++;
                 }
                 /* function to create mirror rule */
+                i++;
         }
 
         return &mflow->ibflow;
@@ -2041,77 +2099,75 @@ static void init_pkeys(struct mlx4_ib_dev *ibdev)
 
 static void mlx4_ib_alloc_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
 {
-        char name[80];
-        int eq_per_port = 0;
-        int added_eqs = 0;
-        int total_eqs = 0;
-        int i, j, eq;
+        int i, j, eq = 0, total_eqs = 0;
 
-        /* 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 = 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);
+        ibdev->eq_table = kcalloc(dev->caps.num_comp_vectors,
+                                  sizeof(ibdev->eq_table[0]), 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++) {
-                        snprintf(name, sizeof(name), "mlx4-ib-%d-%d@%s",
-                                 i, j, dev->persist->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++;
+        for (i = 1; i <= dev->caps.num_ports; i++) {
+                for (j = 0; j < mlx4_get_eqs_per_port(dev, i);
+                     j++, total_eqs++) {
+                        if (i > 1 &&  mlx4_is_eq_shared(dev, total_eqs))
+                                continue;
+                        ibdev->eq_table[eq] = total_eqs;
+                        if (!mlx4_assign_eq(dev, i,
+                                            &ibdev->eq_table[eq]))
+                                eq++;
+                        else
+                                ibdev->eq_table[eq] = -1;
                 }
         }
 
-        /* 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;
+        for (i = eq; i < dev->caps.num_comp_vectors;
+             ibdev->eq_table[i++] = -1)
+                ;
 
         /* Advertise the new number of EQs to clients */
-        ibdev->ib_dev.num_comp_vectors = total_eqs;
+        ibdev->ib_dev.num_comp_vectors = eq;
 }
 
 static void mlx4_ib_free_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
 {
         int i;
+        int total_eqs = ibdev->ib_dev.num_comp_vectors;
 
-        /* no additional eqs were added */
+        /* no eqs were allocated */
         if (!ibdev->eq_table)
                 return;
 
         /* Reset the advertised EQ number */
-        ibdev->ib_dev.num_comp_vectors = dev->caps.num_comp_vectors;
+        ibdev->ib_dev.num_comp_vectors = 0;
 
-        /* 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;
+        for (i = 0; i < total_eqs; i++)
                 mlx4_release_eq(dev, ibdev->eq_table[i]);
-        }
 
         kfree(ibdev->eq_table);
+        ibdev->eq_table = NULL;
+}
+
+static int mlx4_port_immutable(struct ib_device *ibdev, u8 port_num,
+                               struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = mlx4_ib_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+
+        if (mlx4_ib_port_link_layer(ibdev, port_num) == IB_LINK_LAYER_INFINIBAND)
+                immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        else
+                immutable->core_cap_flags = RDMA_CORE_PORT_IBA_ROCE;
+
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
 }
 
 static void *mlx4_ib_add(struct mlx4_dev *dev)
@@ -2123,6 +2179,8 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         struct mlx4_ib_iboe *iboe;
         int ib_num_ports = 0;
         int num_req_counters;
+        int allocated;
+        u32 counter_index;
 
         pr_info_once("%s", mlx4_ib_version);
 
@@ -2241,6 +2299,7 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         ibdev->ib_dev.attach_mcast      = mlx4_ib_mcg_attach;
         ibdev->ib_dev.detach_mcast      = mlx4_ib_mcg_detach;
         ibdev->ib_dev.process_mad       = mlx4_ib_process_mad;
+        ibdev->ib_dev.get_port_immutable = mlx4_port_immutable;
 
         if (!mlx4_is_slave(ibdev->dev)) {
                 ibdev->ib_dev.alloc_fmr         = mlx4_ib_fmr_alloc;
@@ -2278,6 +2337,10 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
                         (1ull << IB_USER_VERBS_EX_CMD_DESTROY_FLOW);
         }
 
+        ibdev->ib_dev.uverbs_ex_cmd_mask |=
+                (1ull << IB_USER_VERBS_EX_CMD_QUERY_DEVICE) |
+                (1ull << IB_USER_VERBS_EX_CMD_CREATE_CQ);
+
         mlx4_ib_alloc_eqs(dev, ibdev);
 
         spin_lock_init(&iboe->lock);
@@ -2288,19 +2351,31 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         num_req_counters = mlx4_is_bonded(dev) ? 1 : ibdev->num_ports;
         for (i = 0; i < num_req_counters; ++i) {
                 mutex_init(&ibdev->qp1_proxy_lock[i]);
+                allocated = 0;
                 if (mlx4_ib_port_link_layer(&ibdev->ib_dev, i + 1) ==
                                                 IB_LINK_LAYER_ETHERNET) {
-                        err = mlx4_counter_alloc(ibdev->dev, &ibdev->counters[i]);
+                        err = mlx4_counter_alloc(ibdev->dev, &counter_index);
+                        /* if failed to allocate a new counter, use default */
                         if (err)
-                                ibdev->counters[i] = -1;
-                } else {
-                        ibdev->counters[i] = -1;
+                                counter_index =
+                                        mlx4_get_default_counter_index(dev,
+                                                                       i + 1);
+                        else
+                                allocated = 1;
+                } else { /* IB_LINK_LAYER_INFINIBAND use the default counter */
+                        counter_index = mlx4_get_default_counter_index(dev,
+                                                                       i + 1);
                 }
+                ibdev->counters[i].index = counter_index;
+                ibdev->counters[i].allocated = allocated;
+                pr_info("counter index %d for port %d allocated %d\n",
+                        counter_index, i + 1, allocated);
         }
         if (mlx4_is_bonded(dev))
-                for (i = 1; i < ibdev->num_ports ; ++i)
-                        ibdev->counters[i] = ibdev->counters[0];
-
+                for (i = 1; i < ibdev->num_ports ; ++i) {
+                        ibdev->counters[i].index = ibdev->counters[0].index;
+                        ibdev->counters[i].allocated = 0;
+                }
 
         mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
                 ib_num_ports++;
@@ -2440,10 +2515,12 @@ err_steer_qp_release:
                 mlx4_qp_release_range(dev, ibdev->steer_qpn_base,
                                       ibdev->steer_qpn_count);
 err_counter:
-        for (; i; --i)
-                if (ibdev->counters[i - 1] != -1)
-                        mlx4_counter_free(ibdev->dev, ibdev->counters[i - 1]);
-
+        for (i = 0; i < ibdev->num_ports; ++i) {
+                if (ibdev->counters[i].index != -1 &&
+                    ibdev->counters[i].allocated)
+                        mlx4_counter_free(ibdev->dev,
+                                          ibdev->counters[i].index);
+        }
 err_map:
         iounmap(ibdev->uar_map);
 
@@ -2560,8 +2637,9 @@ static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
 
         iounmap(ibdev->uar_map);
         for (p = 0; p < ibdev->num_ports; ++p)
-                if (ibdev->counters[p] != -1)
-                        mlx4_counter_free(ibdev->dev, ibdev->counters[p]);
+                if (ibdev->counters[p].index != -1 &&
+                    ibdev->counters[p].allocated)
+                        mlx4_counter_free(ibdev->dev, ibdev->counters[p].index);
         mlx4_foreach_port(p, dev, MLX4_PORT_TYPE_IB)
                 mlx4_CLOSE_PORT(dev, p);
 
@@ -2592,31 +2670,33 @@ static void do_slave_init(struct mlx4_ib_dev *ibdev, int slave, int do_init)
         dm = kcalloc(ports, sizeof(*dm), GFP_ATOMIC);
         if (!dm) {
                 pr_err("failed to allocate memory for tunneling qp update\n");
-                goto out;
+                return;
         }
 
         for (i = 0; i < 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]);
-                        }
+                        while (--i >= 0)
+                                kfree(dm[i]);
                         goto out;
                 }
-        }
-        /* initialize or tear down tunnel QPs for the slave */
-        for (i = 0; i < ports; i++) {
                 INIT_WORK(&dm[i]->work, mlx4_ib_tunnels_update_work);
                 dm[i]->port = first_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)
+        }
+        /* initialize or tear down tunnel QPs for the slave */
+        spin_lock_irqsave(&ibdev->sriov.going_down_lock, flags);
+        if (!ibdev->sriov.is_going_down) {
+                for (i = 0; i < ports; i++)
                         queue_work(ibdev->sriov.demux[i].ud_wq, &dm[i]->work);
                 spin_unlock_irqrestore(&ibdev->sriov.going_down_lock, flags);
+        } else {
+                spin_unlock_irqrestore(&ibdev->sriov.going_down_lock, flags);
+                for (i = 0; i < ports; i++)
+                        kfree(dm[i]);
         }
 out:
         kfree(dm);
diff --git a/drivers/infiniband/hw/mlx4/mlx4_ib.h b/drivers/infiniband/hw/mlx4/mlx4_ib.h
index fce3934372a1..334387f63358 100644
--- a/drivers/infiniband/hw/mlx4/mlx4_ib.h
+++ b/drivers/infiniband/hw/mlx4/mlx4_ib.h
@@ -110,6 +110,7 @@ struct mlx4_ib_cq {
         struct mutex            resize_mutex;
         struct ib_umem         *umem;
         struct ib_umem         *resize_umem;
+        int                     create_flags;
         /* List of qps that it serves.*/
         struct list_head                send_qp_list;
         struct list_head                recv_qp_list;
@@ -503,6 +504,11 @@ struct mlx4_ib_iov_port {
         struct mlx4_ib_iov_sysfs_attr mcg_dentry;
 };
 
+struct counter_index {
+        u32             index;
+        u8              allocated;
+};
+
 struct mlx4_ib_dev {
         struct ib_device        ib_dev;
         struct mlx4_dev        *dev;
@@ -521,9 +527,8 @@ struct mlx4_ib_dev {
         struct mutex            cap_mask_mutex;
         bool                    ib_active;
         struct mlx4_ib_iboe     iboe;
-        int                     counters[MLX4_MAX_PORTS];
+        struct counter_index    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];
@@ -555,6 +560,21 @@ struct mlx4_ib_qp_tunnel_init_attr {
         u8 port;
 };
 
+struct mlx4_uverbs_ex_query_device {
+        __u32 comp_mask;
+        __u32 reserved;
+};
+
+enum query_device_resp_mask {
+        QUERY_DEVICE_RESP_MASK_TIMESTAMP = 1UL << 0,
+};
+
+struct mlx4_uverbs_ex_query_device_resp {
+        __u32 comp_mask;
+        __u32 response_length;
+        __u64 hca_core_clock_offset;
+};
+
 static inline struct mlx4_ib_dev *to_mdev(struct ib_device *ibdev)
 {
         return container_of(ibdev, struct mlx4_ib_dev, ib_dev);
@@ -668,7 +688,8 @@ void mlx4_ib_free_fast_reg_page_list(struct ib_fast_reg_page_list *page_list);
 
 int mlx4_ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period);
 int mlx4_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata);
-struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev, int entries, int vector,
+struct ib_cq *mlx4_ib_create_cq(struct ib_device *ibdev,
+                                const struct ib_cq_init_attr *attr,
                                 struct ib_ucontext *context,
                                 struct ib_udata *udata);
 int mlx4_ib_destroy_cq(struct ib_cq *cq);
@@ -706,11 +727,13 @@ 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 port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad);
+                 int port, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                 const void *in_mad, void *response_mad);
 int mlx4_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);
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad_hdr *in, size_t in_mad_size,
+                        struct ib_mad_hdr *out, size_t *out_mad_size,
+                        u16 *out_mad_pkey_index);
 int mlx4_ib_mad_init(struct mlx4_ib_dev *dev);
 void mlx4_ib_mad_cleanup(struct mlx4_ib_dev *dev);
 
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 02fc91c68027..c5a3a5f0de41 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -1539,12 +1539,13 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         }
 
         if (cur_state == IB_QPS_INIT && new_state == IB_QPS_RTR) {
-                if (dev->counters[qp->port - 1] != -1) {
+                if (dev->counters[qp->port - 1].index != -1) {
                         context->pri_path.counter_index =
-                                                dev->counters[qp->port - 1];
+                                        dev->counters[qp->port - 1].index;
                         optpar |= MLX4_QP_OPTPAR_COUNTER_INDEX;
                 } else
-                        context->pri_path.counter_index = 0xff;
+                        context->pri_path.counter_index =
+                                MLX4_SINK_COUNTER_INDEX(dev->dev);
 
                 if (qp->flags & MLX4_IB_QP_NETIF) {
                         mlx4_ib_steer_qp_reg(dev, qp, 1);
diff --git a/drivers/infiniband/hw/mlx5/Kconfig b/drivers/infiniband/hw/mlx5/Kconfig
index 10df386c6344..bce263b92821 100644
--- a/drivers/infiniband/hw/mlx5/Kconfig
+++ b/drivers/infiniband/hw/mlx5/Kconfig
@@ -1,8 +1,6 @@
 config MLX5_INFINIBAND
         tristate "Mellanox Connect-IB HCA support"
-        depends on NETDEVICES && ETHERNET && PCI
-        select NET_VENDOR_MELLANOX
-        select MLX5_CORE
+        depends on NETDEVICES && ETHERNET && PCI && MLX5_CORE
         ---help---
           This driver provides low-level InfiniBand support for
           Mellanox Connect-IB PCI Express host channel adapters (HCAs).
diff --git a/drivers/infiniband/hw/mlx5/cq.c b/drivers/infiniband/hw/mlx5/cq.c
index 2ee6b1051975..5c9eeea62805 100644
--- a/drivers/infiniband/hw/mlx5/cq.c
+++ b/drivers/infiniband/hw/mlx5/cq.c
@@ -590,8 +590,7 @@ static int alloc_cq_buf(struct mlx5_ib_dev *dev, struct mlx5_ib_cq_buf *buf,
 {
         int err;
 
-        err = mlx5_buf_alloc(dev->mdev, nent * cqe_size,
-                             PAGE_SIZE * 2, &buf->buf);
+        err = mlx5_buf_alloc(dev->mdev, nent * cqe_size, &buf->buf);
         if (err)
                 return err;
 
@@ -736,10 +735,13 @@ static void destroy_cq_kernel(struct mlx5_ib_dev *dev, struct mlx5_ib_cq *cq)
         mlx5_db_free(dev->mdev, &cq->db);
 }
 
-struct ib_cq *mlx5_ib_create_cq(struct ib_device *ibdev, int entries,
-                                int vector, struct ib_ucontext *context,
+struct ib_cq *mlx5_ib_create_cq(struct ib_device *ibdev,
+                                const struct ib_cq_init_attr *attr,
+                                struct ib_ucontext *context,
                                 struct ib_udata *udata)
 {
+        int entries = attr->cqe;
+        int vector = attr->comp_vector;
         struct mlx5_create_cq_mbox_in *cqb = NULL;
         struct mlx5_ib_dev *dev = to_mdev(ibdev);
         struct mlx5_ib_cq *cq;
@@ -750,11 +752,14 @@ struct ib_cq *mlx5_ib_create_cq(struct ib_device *ibdev, int entries,
         int eqn;
         int err;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (entries < 0)
                 return ERR_PTR(-EINVAL);
 
         entries = roundup_pow_of_two(entries + 1);
-        if (entries > dev->mdev->caps.gen.max_cqes)
+        if (entries > (1 << MLX5_CAP_GEN(dev->mdev, log_max_cq_sz)))
                 return ERR_PTR(-EINVAL);
 
         cq = kzalloc(sizeof(*cq), GFP_KERNEL);
@@ -921,7 +926,7 @@ int mlx5_ib_modify_cq(struct ib_cq *cq, u16 cq_count, u16 cq_period)
         int err;
         u32 fsel;
 
-        if (!(dev->mdev->caps.gen.flags & MLX5_DEV_CAP_FLAG_CQ_MODER))
+        if (!MLX5_CAP_GEN(dev->mdev, cq_moderation))
                 return -ENOSYS;
 
         in = kzalloc(sizeof(*in), GFP_KERNEL);
@@ -1076,7 +1081,7 @@ int mlx5_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
         int uninitialized_var(cqe_size);
         unsigned long flags;
 
-        if (!(dev->mdev->caps.gen.flags & MLX5_DEV_CAP_FLAG_RESIZE_CQ)) {
+        if (!MLX5_CAP_GEN(dev->mdev, cq_resize)) {
                 pr_info("Firmware does not support resize CQ\n");
                 return -ENOSYS;
         }
@@ -1085,7 +1090,7 @@ int mlx5_ib_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *udata)
                 return -EINVAL;
 
         entries = roundup_pow_of_two(entries + 1);
-        if (entries > dev->mdev->caps.gen.max_cqes + 1)
+        if (entries >  (1 << MLX5_CAP_GEN(dev->mdev, log_max_cq_sz)) + 1)
                 return -EINVAL;
 
         if (entries == ibcq->cqe + 1)
diff --git a/drivers/infiniband/hw/mlx5/mad.c b/drivers/infiniband/hw/mlx5/mad.c
index 9cf9a37bb5ff..b84d13a487cc 100644
--- a/drivers/infiniband/hw/mlx5/mad.c
+++ b/drivers/infiniband/hw/mlx5/mad.c
@@ -41,8 +41,8 @@ enum {
 };
 
 int mlx5_MAD_IFC(struct mlx5_ib_dev *dev, int ignore_mkey, int ignore_bkey,
-                 u8 port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad)
+                 u8 port, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                 const void *in_mad, void *response_mad)
 {
         u8 op_modifier = 0;
 
@@ -58,11 +58,19 @@ int mlx5_MAD_IFC(struct mlx5_ib_dev *dev, int ignore_mkey, int ignore_bkey,
 }
 
 int mlx5_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)
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad_hdr *in, size_t in_mad_size,
+                        struct ib_mad_hdr *out, size_t *out_mad_size,
+                        u16 *out_mad_pkey_index)
 {
         u16 slid;
         int err;
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         slid = in_wc ? in_wc->slid : be16_to_cpu(IB_LID_PERMISSIVE);
 
@@ -129,7 +137,7 @@ int mlx5_query_ext_port_caps(struct mlx5_ib_dev *dev, u8 port)
 
         packet_error = be16_to_cpu(out_mad->status);
 
-        dev->mdev->caps.gen.ext_port_cap[port - 1] = (!err && !packet_error) ?
+        dev->mdev->port_caps[port - 1].ext_port_cap = (!err && !packet_error) ?
                 MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO : 0;
 
 out:
@@ -137,3 +145,300 @@ out:
         kfree(out_mad);
         return err;
 }
+
+int mlx5_query_mad_ifc_smp_attr_node_info(struct ib_device *ibdev,
+                                          struct ib_smp *out_mad)
+{
+        struct ib_smp *in_mad = NULL;
+        int err = -ENOMEM;
+
+        in_mad = kzalloc(sizeof(*in_mad), GFP_KERNEL);
+        if (!in_mad)
+                return -ENOMEM;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
+
+        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, 1, NULL, NULL, in_mad,
+                           out_mad);
+
+        kfree(in_mad);
+        return err;
+}
+
+int mlx5_query_mad_ifc_system_image_guid(struct ib_device *ibdev,
+                                         __be64 *sys_image_guid)
+{
+        struct ib_smp *out_mad = NULL;
+        int err = -ENOMEM;
+
+        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
+        if (!out_mad)
+                return -ENOMEM;
+
+        err = mlx5_query_mad_ifc_smp_attr_node_info(ibdev, out_mad);
+        if (err)
+                goto out;
+
+        memcpy(sys_image_guid, out_mad->data + 4, 8);
+
+out:
+        kfree(out_mad);
+
+        return err;
+}
+
+int mlx5_query_mad_ifc_max_pkeys(struct ib_device *ibdev,
+                                 u16 *max_pkeys)
+{
+        struct ib_smp *out_mad = NULL;
+        int err = -ENOMEM;
+
+        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
+        if (!out_mad)
+                return -ENOMEM;
+
+        err = mlx5_query_mad_ifc_smp_attr_node_info(ibdev, out_mad);
+        if (err)
+                goto out;
+
+        *max_pkeys = be16_to_cpup((__be16 *)(out_mad->data + 28));
+
+out:
+        kfree(out_mad);
+
+        return err;
+}
+
+int mlx5_query_mad_ifc_vendor_id(struct ib_device *ibdev,
+                                 u32 *vendor_id)
+{
+        struct ib_smp *out_mad = NULL;
+        int err = -ENOMEM;
+
+        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
+        if (!out_mad)
+                return -ENOMEM;
+
+        err = mlx5_query_mad_ifc_smp_attr_node_info(ibdev, out_mad);
+        if (err)
+                goto out;
+
+        *vendor_id = be32_to_cpup((__be32 *)(out_mad->data + 36)) & 0xffff;
+
+out:
+        kfree(out_mad);
+
+        return err;
+}
+
+int mlx5_query_mad_ifc_node_desc(struct mlx5_ib_dev *dev, char *node_desc)
+{
+        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;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
+
+        err = mlx5_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
+        if (err)
+                goto out;
+
+        memcpy(node_desc, out_mad->data, 64);
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
+}
+
+int mlx5_query_mad_ifc_node_guid(struct mlx5_ib_dev *dev, __be64 *node_guid)
+{
+        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;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
+
+        err = mlx5_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
+        if (err)
+                goto out;
+
+        memcpy(node_guid, out_mad->data + 12, 8);
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
+}
+
+int mlx5_query_mad_ifc_pkey(struct ib_device *ibdev, u8 port, u16 index,
+                            u16 *pkey)
+{
+        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;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
+        in_mad->attr_mod = cpu_to_be32(index / 32);
+
+        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad,
+                           out_mad);
+        if (err)
+                goto out;
+
+        *pkey = be16_to_cpu(((__be16 *)out_mad->data)[index % 32]);
+
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
+}
+
+int mlx5_query_mad_ifc_gids(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;
+
+        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);
+
+        err = mlx5_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);
+
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
+        in_mad->attr_mod = cpu_to_be32(index / 8);
+
+        err = mlx5_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:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
+}
+
+int mlx5_query_mad_ifc_port(struct ib_device *ibdev, u8 port,
+                            struct ib_port_attr *props)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
+        struct ib_smp *in_mad  = NULL;
+        struct ib_smp *out_mad = NULL;
+        int ext_active_speed;
+        int err = -ENOMEM;
+
+        if (port < 1 || port > MLX5_CAP_GEN(mdev, num_ports)) {
+                mlx5_ib_warn(dev, "invalid port number %d\n", port);
+                return -EINVAL;
+        }
+
+        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 = mlx5_MAD_IFC(dev, 1, 1, port, NULL, NULL, in_mad, out_mad);
+        if (err) {
+                mlx5_ib_warn(dev, "err %d\n", 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));
+        props->sm_sl            = out_mad->data[36] & 0xf;
+        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));
+        props->gid_tbl_len      = out_mad->data[50];
+        props->max_msg_sz       = 1 << MLX5_CAP_GEN(mdev, log_max_msg);
+        props->pkey_tbl_len     = mdev->port_caps[port - 1].pkey_table_len;
+        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->active_width     = out_mad->data[31] & 0xf;
+        props->active_speed     = out_mad->data[35] >> 4;
+        props->max_mtu          = out_mad->data[41] & 0xf;
+        props->active_mtu       = out_mad->data[36] >> 4;
+        props->subnet_timeout   = out_mad->data[51] & 0x1f;
+        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 = 16; /* FDR */
+                        break;
+                case 2:
+                        props->active_speed = 32; /* EDR */
+                        break;
+                }
+        }
+
+        /* If reported active speed is QDR, check if is FDR-10 */
+        if (props->active_speed == 4) {
+                if (mdev->port_caps[port - 1].ext_port_cap &
+                    MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO) {
+                        init_query_mad(in_mad);
+                        in_mad->attr_id = MLX5_ATTR_EXTENDED_PORT_INFO;
+                        in_mad->attr_mod = cpu_to_be32(port);
+
+                        err = mlx5_MAD_IFC(dev, 1, 1, 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 = 8;
+                }
+        }
+
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+
+        return err;
+}
diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
index 57c9809e8b87..085c24b4b603 100644
--- a/drivers/infiniband/hw/mlx5/main.c
+++ b/drivers/infiniband/hw/mlx5/main.c
@@ -40,6 +40,7 @@
 #include <linux/io-mapping.h>
 #include <linux/sched.h>
 #include <rdma/ib_user_verbs.h>
+#include <linux/mlx5/vport.h>
 #include <rdma/ib_smi.h>
 #include <rdma/ib_umem.h>
 #include "user.h"
@@ -62,32 +63,172 @@ static char mlx5_version[] =
         DRIVER_NAME ": Mellanox Connect-IB Infiniband driver v"
         DRIVER_VERSION " (" DRIVER_RELDATE ")\n";
 
+static enum rdma_link_layer
+mlx5_ib_port_link_layer(struct ib_device *device)
+{
+        struct mlx5_ib_dev *dev = to_mdev(device);
+
+        switch (MLX5_CAP_GEN(dev->mdev, port_type)) {
+        case MLX5_CAP_PORT_TYPE_IB:
+                return IB_LINK_LAYER_INFINIBAND;
+        case MLX5_CAP_PORT_TYPE_ETH:
+                return IB_LINK_LAYER_ETHERNET;
+        default:
+                return IB_LINK_LAYER_UNSPECIFIED;
+        }
+}
+
+static int mlx5_use_mad_ifc(struct mlx5_ib_dev *dev)
+{
+        return !dev->mdev->issi;
+}
+
+enum {
+        MLX5_VPORT_ACCESS_METHOD_MAD,
+        MLX5_VPORT_ACCESS_METHOD_HCA,
+        MLX5_VPORT_ACCESS_METHOD_NIC,
+};
+
+static int mlx5_get_vport_access_method(struct ib_device *ibdev)
+{
+        if (mlx5_use_mad_ifc(to_mdev(ibdev)))
+                return MLX5_VPORT_ACCESS_METHOD_MAD;
+
+        if (mlx5_ib_port_link_layer(ibdev) ==
+            IB_LINK_LAYER_ETHERNET)
+                return MLX5_VPORT_ACCESS_METHOD_NIC;
+
+        return MLX5_VPORT_ACCESS_METHOD_HCA;
+}
+
+static int mlx5_query_system_image_guid(struct ib_device *ibdev,
+                                        __be64 *sys_image_guid)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
+        u64 tmp;
+        int err;
+
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_system_image_guid(ibdev,
+                                                            sys_image_guid);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+                err = mlx5_query_hca_vport_system_image_guid(mdev, &tmp);
+                if (!err)
+                        *sys_image_guid = cpu_to_be64(tmp);
+                return err;
+
+        default:
+                return -EINVAL;
+        }
+}
+
+static int mlx5_query_max_pkeys(struct ib_device *ibdev,
+                                u16 *max_pkeys)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
+
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_max_pkeys(ibdev, max_pkeys);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+        case MLX5_VPORT_ACCESS_METHOD_NIC:
+                *max_pkeys = mlx5_to_sw_pkey_sz(MLX5_CAP_GEN(mdev,
+                                                pkey_table_size));
+                return 0;
+
+        default:
+                return -EINVAL;
+        }
+}
+
+static int mlx5_query_vendor_id(struct ib_device *ibdev,
+                                u32 *vendor_id)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_vendor_id(ibdev, vendor_id);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+        case MLX5_VPORT_ACCESS_METHOD_NIC:
+                return mlx5_core_query_vendor_id(dev->mdev, vendor_id);
+
+        default:
+                return -EINVAL;
+        }
+}
+
+static int mlx5_query_node_guid(struct mlx5_ib_dev *dev,
+                                __be64 *node_guid)
+{
+        u64 tmp;
+        int err;
+
+        switch (mlx5_get_vport_access_method(&dev->ib_dev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_node_guid(dev, node_guid);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+                err = mlx5_query_hca_vport_node_guid(dev->mdev, &tmp);
+                if (!err)
+                        *node_guid = cpu_to_be64(tmp);
+                return err;
+
+        default:
+                return -EINVAL;
+        }
+}
+
+struct mlx5_reg_node_desc {
+        u8      desc[64];
+};
+
+static int mlx5_query_node_desc(struct mlx5_ib_dev *dev, char *node_desc)
+{
+        struct mlx5_reg_node_desc in;
+
+        if (mlx5_use_mad_ifc(dev))
+                return mlx5_query_mad_ifc_node_desc(dev, node_desc);
+
+        memset(&in, 0, sizeof(in));
+
+        return mlx5_core_access_reg(dev->mdev, &in, sizeof(in), node_desc,
+                                    sizeof(struct mlx5_reg_node_desc),
+                                    MLX5_REG_NODE_DESC, 0, 0);
+}
+
 static int mlx5_ib_query_device(struct ib_device *ibdev,
-                                struct ib_device_attr *props)
+                                struct ib_device_attr *props,
+                                struct ib_udata *uhw)
 {
         struct mlx5_ib_dev *dev = to_mdev(ibdev);
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        struct mlx5_general_caps *gen;
+        struct mlx5_core_dev *mdev = dev->mdev;
         int err = -ENOMEM;
         int max_rq_sg;
         int max_sq_sg;
-        u64 flags;
 
-        gen = &dev->mdev->caps.gen;
-        in_mad  = kzalloc(sizeof(*in_mad), GFP_KERNEL);
-        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
-        if (!in_mad || !out_mad)
-                goto out;
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
 
-        init_query_mad(in_mad);
-        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
+        memset(props, 0, sizeof(*props));
+        err = mlx5_query_system_image_guid(ibdev,
+                                           &props->sys_image_guid);
+        if (err)
+                return err;
 
-        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, 1, NULL, NULL, in_mad, out_mad);
+        err = mlx5_query_max_pkeys(ibdev, &props->max_pkeys);
         if (err)
-                goto out;
+                return err;
 
-        memset(props, 0, sizeof(*props));
+        err = mlx5_query_vendor_id(ibdev, &props->vendor_id);
+        if (err)
+                return err;
 
         props->fw_ver = ((u64)fw_rev_maj(dev->mdev) << 32) |
                 (fw_rev_min(dev->mdev) << 16) |
@@ -96,18 +237,18 @@ static int mlx5_ib_query_device(struct ib_device *ibdev,
                 IB_DEVICE_PORT_ACTIVE_EVENT             |
                 IB_DEVICE_SYS_IMAGE_GUID                |
                 IB_DEVICE_RC_RNR_NAK_GEN;
-        flags = gen->flags;
-        if (flags & MLX5_DEV_CAP_FLAG_BAD_PKEY_CNTR)
+
+        if (MLX5_CAP_GEN(mdev, pkv))
                 props->device_cap_flags |= IB_DEVICE_BAD_PKEY_CNTR;
-        if (flags & MLX5_DEV_CAP_FLAG_BAD_QKEY_CNTR)
+        if (MLX5_CAP_GEN(mdev, qkv))
                 props->device_cap_flags |= IB_DEVICE_BAD_QKEY_CNTR;
-        if (flags & MLX5_DEV_CAP_FLAG_APM)
+        if (MLX5_CAP_GEN(mdev, apm))
                 props->device_cap_flags |= IB_DEVICE_AUTO_PATH_MIG;
         props->device_cap_flags |= IB_DEVICE_LOCAL_DMA_LKEY;
-        if (flags & MLX5_DEV_CAP_FLAG_XRC)
+        if (MLX5_CAP_GEN(mdev, xrc))
                 props->device_cap_flags |= IB_DEVICE_XRC;
         props->device_cap_flags |= IB_DEVICE_MEM_MGT_EXTENSIONS;
-        if (flags & MLX5_DEV_CAP_FLAG_SIG_HAND_OVER) {
+        if (MLX5_CAP_GEN(mdev, sho)) {
                 props->device_cap_flags |= IB_DEVICE_SIGNATURE_HANDOVER;
                 /* At this stage no support for signature handover */
                 props->sig_prot_cap = IB_PROT_T10DIF_TYPE_1 |
@@ -116,221 +257,270 @@ static int mlx5_ib_query_device(struct ib_device *ibdev,
                 props->sig_guard_cap = IB_GUARD_T10DIF_CRC |
                                        IB_GUARD_T10DIF_CSUM;
         }
-        if (flags & MLX5_DEV_CAP_FLAG_BLOCK_MCAST)
+        if (MLX5_CAP_GEN(mdev, block_lb_mc))
                 props->device_cap_flags |= IB_DEVICE_BLOCK_MULTICAST_LOOPBACK;
 
-        props->vendor_id           = be32_to_cpup((__be32 *)(out_mad->data + 36)) &
-                0xffffff;
-        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->vendor_part_id      = mdev->pdev->device;
+        props->hw_ver              = mdev->pdev->revision;
 
         props->max_mr_size         = ~0ull;
-        props->page_size_cap       = gen->min_page_sz;
-        props->max_qp              = 1 << gen->log_max_qp;
-        props->max_qp_wr           = gen->max_wqes;
-        max_rq_sg = gen->max_rq_desc_sz / sizeof(struct mlx5_wqe_data_seg);
-        max_sq_sg = (gen->max_sq_desc_sz - sizeof(struct mlx5_wqe_ctrl_seg)) /
-                sizeof(struct mlx5_wqe_data_seg);
+        props->page_size_cap       = 1ull << MLX5_CAP_GEN(mdev, log_pg_sz);
+        props->max_qp              = 1 << MLX5_CAP_GEN(mdev, log_max_qp);
+        props->max_qp_wr           = 1 << MLX5_CAP_GEN(mdev, log_max_qp_sz);
+        max_rq_sg =  MLX5_CAP_GEN(mdev, max_wqe_sz_rq) /
+                     sizeof(struct mlx5_wqe_data_seg);
+        max_sq_sg = (MLX5_CAP_GEN(mdev, max_wqe_sz_sq) -
+                     sizeof(struct mlx5_wqe_ctrl_seg)) /
+                     sizeof(struct mlx5_wqe_data_seg);
         props->max_sge = min(max_rq_sg, max_sq_sg);
-        props->max_cq              = 1 << gen->log_max_cq;
-        props->max_cqe             = gen->max_cqes - 1;
-        props->max_mr              = 1 << gen->log_max_mkey;
-        props->max_pd              = 1 << gen->log_max_pd;
-        props->max_qp_rd_atom      = 1 << gen->log_max_ra_req_qp;
-        props->max_qp_init_rd_atom = 1 << gen->log_max_ra_res_qp;
-        props->max_srq             = 1 << gen->log_max_srq;
-        props->max_srq_wr          = gen->max_srq_wqes - 1;
-        props->local_ca_ack_delay  = gen->local_ca_ack_delay;
+        props->max_cq              = 1 << MLX5_CAP_GEN(mdev, log_max_cq);
+        props->max_cqe = (1 << MLX5_CAP_GEN(mdev, log_max_eq_sz)) - 1;
+        props->max_mr              = 1 << MLX5_CAP_GEN(mdev, log_max_mkey);
+        props->max_pd              = 1 << MLX5_CAP_GEN(mdev, log_max_pd);
+        props->max_qp_rd_atom      = 1 << MLX5_CAP_GEN(mdev, log_max_ra_req_qp);
+        props->max_qp_init_rd_atom = 1 << MLX5_CAP_GEN(mdev, log_max_ra_res_qp);
+        props->max_srq             = 1 << MLX5_CAP_GEN(mdev, log_max_srq);
+        props->max_srq_wr = (1 << MLX5_CAP_GEN(mdev, log_max_srq_sz)) - 1;
+        props->local_ca_ack_delay  = MLX5_CAP_GEN(mdev, local_ca_ack_delay);
         props->max_res_rd_atom     = props->max_qp_rd_atom * props->max_qp;
         props->max_srq_sge         = max_rq_sg - 1;
         props->max_fast_reg_page_list_len = (unsigned int)-1;
-        props->local_ca_ack_delay  = gen->local_ca_ack_delay;
         props->atomic_cap          = IB_ATOMIC_NONE;
         props->masked_atomic_cap   = IB_ATOMIC_NONE;
-        props->max_pkeys           = be16_to_cpup((__be16 *)(out_mad->data + 28));
-        props->max_mcast_grp       = 1 << gen->log_max_mcg;
-        props->max_mcast_qp_attach = gen->max_qp_mcg;
+        props->max_mcast_grp       = 1 << MLX5_CAP_GEN(mdev, log_max_mcg);
+        props->max_mcast_qp_attach = MLX5_CAP_GEN(mdev, max_qp_mcg);
         props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
                                            props->max_mcast_grp;
         props->max_map_per_fmr = INT_MAX; /* no limit in ConnectIB */
 
 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
-        if (dev->mdev->caps.gen.flags & MLX5_DEV_CAP_FLAG_ON_DMND_PG)
+        if (MLX5_CAP_GEN(mdev, pg))
                 props->device_cap_flags |= IB_DEVICE_ON_DEMAND_PAGING;
         props->odp_caps = dev->odp_caps;
 #endif
 
-out:
-        kfree(in_mad);
-        kfree(out_mad);
-
-        return err;
+        return 0;
 }
 
-int mlx5_ib_query_port(struct ib_device *ibdev, u8 port,
-                       struct ib_port_attr *props)
+enum mlx5_ib_width {
+        MLX5_IB_WIDTH_1X        = 1 << 0,
+        MLX5_IB_WIDTH_2X        = 1 << 1,
+        MLX5_IB_WIDTH_4X        = 1 << 2,
+        MLX5_IB_WIDTH_8X        = 1 << 3,
+        MLX5_IB_WIDTH_12X       = 1 << 4
+};
+
+static int translate_active_width(struct ib_device *ibdev, u8 active_width,
+                                  u8 *ib_width)
 {
         struct mlx5_ib_dev *dev = to_mdev(ibdev);
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        struct mlx5_general_caps *gen;
-        int ext_active_speed;
-        int err = -ENOMEM;
-
-        gen = &dev->mdev->caps.gen;
-        if (port < 1 || port > gen->num_ports) {
-                mlx5_ib_warn(dev, "invalid port number %d\n", port);
-                return -EINVAL;
+        int err = 0;
+
+        if (active_width & MLX5_IB_WIDTH_1X) {
+                *ib_width = IB_WIDTH_1X;
+        } else if (active_width & MLX5_IB_WIDTH_2X) {
+                mlx5_ib_dbg(dev, "active_width %d is not supported by IB spec\n",
+                            (int)active_width);
+                err = -EINVAL;
+        } else if (active_width & MLX5_IB_WIDTH_4X) {
+                *ib_width = IB_WIDTH_4X;
+        } else if (active_width & MLX5_IB_WIDTH_8X) {
+                *ib_width = IB_WIDTH_8X;
+        } else if (active_width & MLX5_IB_WIDTH_12X) {
+                *ib_width = IB_WIDTH_12X;
+        } else {
+                mlx5_ib_dbg(dev, "Invalid active_width %d\n",
+                            (int)active_width);
+                err = -EINVAL;
         }
 
-        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);
+        return err;
+}
 
-        err = mlx5_MAD_IFC(dev, 1, 1, port, NULL, NULL, in_mad, out_mad);
-        if (err) {
-                mlx5_ib_warn(dev, "err %d\n", err);
-                goto out;
+static int mlx5_mtu_to_ib_mtu(int mtu)
+{
+        switch (mtu) {
+        case 256: return 1;
+        case 512: return 2;
+        case 1024: return 3;
+        case 2048: return 4;
+        case 4096: return 5;
+        default:
+                pr_warn("invalid mtu\n");
+                return -1;
         }
+}
 
+enum ib_max_vl_num {
+        __IB_MAX_VL_0           = 1,
+        __IB_MAX_VL_0_1         = 2,
+        __IB_MAX_VL_0_3         = 3,
+        __IB_MAX_VL_0_7         = 4,
+        __IB_MAX_VL_0_14        = 5,
+};
 
-        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));
-        props->sm_sl            = out_mad->data[36] & 0xf;
-        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));
-        props->gid_tbl_len      = out_mad->data[50];
-        props->max_msg_sz       = 1 << gen->log_max_msg;
-        props->pkey_tbl_len     = gen->port[port - 1].pkey_table_len;
-        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->active_width     = out_mad->data[31] & 0xf;
-        props->active_speed     = out_mad->data[35] >> 4;
-        props->max_mtu          = out_mad->data[41] & 0xf;
-        props->active_mtu       = out_mad->data[36] >> 4;
-        props->subnet_timeout   = out_mad->data[51] & 0x1f;
-        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 = 16; /* FDR */
-                        break;
-                case 2:
-                        props->active_speed = 32; /* EDR */
-                        break;
-                }
-        }
+enum mlx5_vl_hw_cap {
+        MLX5_VL_HW_0    = 1,
+        MLX5_VL_HW_0_1  = 2,
+        MLX5_VL_HW_0_2  = 3,
+        MLX5_VL_HW_0_3  = 4,
+        MLX5_VL_HW_0_4  = 5,
+        MLX5_VL_HW_0_5  = 6,
+        MLX5_VL_HW_0_6  = 7,
+        MLX5_VL_HW_0_7  = 8,
+        MLX5_VL_HW_0_14 = 15
+};
 
-        /* If reported active speed is QDR, check if is FDR-10 */
-        if (props->active_speed == 4) {
-                if (gen->ext_port_cap[port - 1] &
-                    MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO) {
-                        init_query_mad(in_mad);
-                        in_mad->attr_id = MLX5_ATTR_EXTENDED_PORT_INFO;
-                        in_mad->attr_mod = cpu_to_be32(port);
-
-                        err = mlx5_MAD_IFC(dev, 1, 1, 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 = 8;
-                }
-        }
+static int translate_max_vl_num(struct ib_device *ibdev, u8 vl_hw_cap,
+                                u8 *max_vl_num)
+{
+        switch (vl_hw_cap) {
+        case MLX5_VL_HW_0:
+                *max_vl_num = __IB_MAX_VL_0;
+                break;
+        case MLX5_VL_HW_0_1:
+                *max_vl_num = __IB_MAX_VL_0_1;
+                break;
+        case MLX5_VL_HW_0_3:
+                *max_vl_num = __IB_MAX_VL_0_3;
+                break;
+        case MLX5_VL_HW_0_7:
+                *max_vl_num = __IB_MAX_VL_0_7;
+                break;
+        case MLX5_VL_HW_0_14:
+                *max_vl_num = __IB_MAX_VL_0_14;
+                break;
 
-out:
-        kfree(in_mad);
-        kfree(out_mad);
+        default:
+                return -EINVAL;
+        }
 
-        return err;
+        return 0;
 }
 
-static int mlx5_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
-                             union ib_gid *gid)
+static int mlx5_query_hca_port(struct ib_device *ibdev, u8 port,
+                               struct ib_port_attr *props)
 {
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        int err = -ENOMEM;
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
+        struct mlx5_hca_vport_context *rep;
+        int max_mtu;
+        int oper_mtu;
+        int err;
+        u8 ib_link_width_oper;
+        u8 vl_hw_cap;
 
-        in_mad  = kzalloc(sizeof(*in_mad), GFP_KERNEL);
-        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
-        if (!in_mad || !out_mad)
+        rep = kzalloc(sizeof(*rep), GFP_KERNEL);
+        if (!rep) {
+                err = -ENOMEM;
                 goto out;
+        }
 
-        init_query_mad(in_mad);
-        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
-        in_mad->attr_mod = cpu_to_be32(port);
+        memset(props, 0, sizeof(*props));
 
-        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
+        err = mlx5_query_hca_vport_context(mdev, 0, port, 0, rep);
         if (err)
                 goto out;
 
-        memcpy(gid->raw, out_mad->data + 8, 8);
-
-        init_query_mad(in_mad);
-        in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
-        in_mad->attr_mod = cpu_to_be32(index / 8);
+        props->lid              = rep->lid;
+        props->lmc              = rep->lmc;
+        props->sm_lid           = rep->sm_lid;
+        props->sm_sl            = rep->sm_sl;
+        props->state            = rep->vport_state;
+        props->phys_state       = rep->port_physical_state;
+        props->port_cap_flags   = rep->cap_mask1;
+        props->gid_tbl_len      = mlx5_get_gid_table_len(MLX5_CAP_GEN(mdev, gid_table_size));
+        props->max_msg_sz       = 1 << MLX5_CAP_GEN(mdev, log_max_msg);
+        props->pkey_tbl_len     = mlx5_to_sw_pkey_sz(MLX5_CAP_GEN(mdev, pkey_table_size));
+        props->bad_pkey_cntr    = rep->pkey_violation_counter;
+        props->qkey_viol_cntr   = rep->qkey_violation_counter;
+        props->subnet_timeout   = rep->subnet_timeout;
+        props->init_type_reply  = rep->init_type_reply;
+
+        err = mlx5_query_port_link_width_oper(mdev, &ib_link_width_oper, port);
+        if (err)
+                goto out;
 
-        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
+        err = translate_active_width(ibdev, ib_link_width_oper,
+                                     &props->active_width);
+        if (err)
+                goto out;
+        err = mlx5_query_port_proto_oper(mdev, &props->active_speed, MLX5_PTYS_IB,
+                                         port);
         if (err)
                 goto out;
 
-        memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
+        mlx5_query_port_max_mtu(mdev, &max_mtu, port);
+
+        props->max_mtu = mlx5_mtu_to_ib_mtu(max_mtu);
+
+        mlx5_query_port_oper_mtu(mdev, &oper_mtu, port);
+
+        props->active_mtu = mlx5_mtu_to_ib_mtu(oper_mtu);
 
+        err = mlx5_query_port_vl_hw_cap(mdev, &vl_hw_cap, port);
+        if (err)
+                goto out;
+
+        err = translate_max_vl_num(ibdev, vl_hw_cap,
+                                   &props->max_vl_num);
 out:
-        kfree(in_mad);
-        kfree(out_mad);
+        kfree(rep);
         return err;
 }
 
-static int mlx5_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
-                              u16 *pkey)
+int mlx5_ib_query_port(struct ib_device *ibdev, u8 port,
+                       struct ib_port_attr *props)
 {
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        int err = -ENOMEM;
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_port(ibdev, port, props);
 
-        in_mad  = kzalloc(sizeof(*in_mad), GFP_KERNEL);
-        out_mad = kmalloc(sizeof(*out_mad), GFP_KERNEL);
-        if (!in_mad || !out_mad)
-                goto out;
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+                return mlx5_query_hca_port(ibdev, port, props);
 
-        init_query_mad(in_mad);
-        in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
-        in_mad->attr_mod = cpu_to_be32(index / 32);
+        default:
+                return -EINVAL;
+        }
+}
 
-        err = mlx5_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
-        if (err)
-                goto out;
+static int mlx5_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
+                             union ib_gid *gid)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
 
-        *pkey = be16_to_cpu(((__be16 *)out_mad->data)[index % 32]);
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_gids(ibdev, port, index, gid);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+                return mlx5_query_hca_vport_gid(mdev, 0, port, 0, index, gid);
+
+        default:
+                return -EINVAL;
+        }
 
-out:
-        kfree(in_mad);
-        kfree(out_mad);
-        return err;
 }
 
-struct mlx5_reg_node_desc {
-        u8      desc[64];
-};
+static int mlx5_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
+                              u16 *pkey)
+{
+        struct mlx5_ib_dev *dev = to_mdev(ibdev);
+        struct mlx5_core_dev *mdev = dev->mdev;
+
+        switch (mlx5_get_vport_access_method(ibdev)) {
+        case MLX5_VPORT_ACCESS_METHOD_MAD:
+                return mlx5_query_mad_ifc_pkey(ibdev, port, index, pkey);
+
+        case MLX5_VPORT_ACCESS_METHOD_HCA:
+        case MLX5_VPORT_ACCESS_METHOD_NIC:
+                return mlx5_query_hca_vport_pkey(mdev, 0, port,  0, index,
+                                                 pkey);
+        default:
+                return -EINVAL;
+        }
+}
 
 static int mlx5_ib_modify_device(struct ib_device *ibdev, int mask,
                                  struct ib_device_modify *props)
@@ -392,7 +582,6 @@ static struct ib_ucontext *mlx5_ib_alloc_ucontext(struct ib_device *ibdev,
         struct mlx5_ib_alloc_ucontext_req_v2 req;
         struct mlx5_ib_alloc_ucontext_resp resp;
         struct mlx5_ib_ucontext *context;
-        struct mlx5_general_caps *gen;
         struct mlx5_uuar_info *uuari;
         struct mlx5_uar *uars;
         int gross_uuars;
@@ -403,7 +592,6 @@ static struct ib_ucontext *mlx5_ib_alloc_ucontext(struct ib_device *ibdev,
         int i;
         size_t reqlen;
 
-        gen = &dev->mdev->caps.gen;
         if (!dev->ib_active)
                 return ERR_PTR(-EAGAIN);
 
@@ -436,14 +624,14 @@ static struct ib_ucontext *mlx5_ib_alloc_ucontext(struct ib_device *ibdev,
 
         num_uars = req.total_num_uuars / MLX5_NON_FP_BF_REGS_PER_PAGE;
         gross_uuars = num_uars * MLX5_BF_REGS_PER_PAGE;
-        resp.qp_tab_size      = 1 << gen->log_max_qp;
-        resp.bf_reg_size      = gen->bf_reg_size;
-        resp.cache_line_size  = L1_CACHE_BYTES;
-        resp.max_sq_desc_sz = gen->max_sq_desc_sz;
-        resp.max_rq_desc_sz = gen->max_rq_desc_sz;
-        resp.max_send_wqebb = gen->max_wqes;
-        resp.max_recv_wr = gen->max_wqes;
-        resp.max_srq_recv_wr = gen->max_srq_wqes;
+        resp.qp_tab_size = 1 << MLX5_CAP_GEN(dev->mdev, log_max_qp);
+        resp.bf_reg_size = 1 << MLX5_CAP_GEN(dev->mdev, log_bf_reg_size);
+        resp.cache_line_size = L1_CACHE_BYTES;
+        resp.max_sq_desc_sz = MLX5_CAP_GEN(dev->mdev, max_wqe_sz_sq);
+        resp.max_rq_desc_sz = MLX5_CAP_GEN(dev->mdev, max_wqe_sz_rq);
+        resp.max_send_wqebb = 1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz);
+        resp.max_recv_wr = 1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz);
+        resp.max_srq_recv_wr = 1 << MLX5_CAP_GEN(dev->mdev, log_max_srq_sz);
 
         context = kzalloc(sizeof(*context), GFP_KERNEL);
         if (!context)
@@ -493,7 +681,7 @@ static struct ib_ucontext *mlx5_ib_alloc_ucontext(struct ib_device *ibdev,
         mutex_init(&context->db_page_mutex);
 
         resp.tot_uuars = req.total_num_uuars;
-        resp.num_ports = gen->num_ports;
+        resp.num_ports = MLX5_CAP_GEN(dev->mdev, num_ports);
         err = ib_copy_to_udata(udata, &resp,
                                sizeof(resp) - sizeof(resp.reserved));
         if (err)
@@ -731,37 +919,15 @@ static int mlx5_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 
 static int init_node_data(struct mlx5_ib_dev *dev)
 {
-        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;
-
-        init_query_mad(in_mad);
-        in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
-
-        err = mlx5_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
-        if (err)
-                goto out;
-
-        memcpy(dev->ib_dev.node_desc, out_mad->data, 64);
-
-        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
+        int err;
 
-        err = mlx5_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
+        err = mlx5_query_node_desc(dev, dev->ib_dev.node_desc);
         if (err)
-                goto out;
+                return err;
 
-        dev->mdev->rev_id = be32_to_cpup((__be32 *)(out_mad->data + 32));
-        memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
+        dev->mdev->rev_id = dev->mdev->pdev->revision;
 
-out:
-        kfree(in_mad);
-        kfree(out_mad);
-        return err;
+        return mlx5_query_node_guid(dev, &dev->ib_dev.node_guid);
 }
 
 static ssize_t show_fw_pages(struct device *device, struct device_attribute *attr,
@@ -895,11 +1061,9 @@ static void mlx5_ib_event(struct mlx5_core_dev *dev, void *context,
 
 static void get_ext_port_caps(struct mlx5_ib_dev *dev)
 {
-        struct mlx5_general_caps *gen;
         int port;
 
-        gen = &dev->mdev->caps.gen;
-        for (port = 1; port <= gen->num_ports; port++)
+        for (port = 1; port <= MLX5_CAP_GEN(dev->mdev, num_ports); port++)
                 mlx5_query_ext_port_caps(dev, port);
 }
 
@@ -907,11 +1071,10 @@ static int get_port_caps(struct mlx5_ib_dev *dev)
 {
         struct ib_device_attr *dprops = NULL;
         struct ib_port_attr *pprops = NULL;
-        struct mlx5_general_caps *gen;
         int err = -ENOMEM;
         int port;
+        struct ib_udata uhw = {.inlen = 0, .outlen = 0};
 
-        gen = &dev->mdev->caps.gen;
         pprops = kmalloc(sizeof(*pprops), GFP_KERNEL);
         if (!pprops)
                 goto out;
@@ -920,20 +1083,23 @@ static int get_port_caps(struct mlx5_ib_dev *dev)
         if (!dprops)
                 goto out;
 
-        err = mlx5_ib_query_device(&dev->ib_dev, dprops);
+        err = mlx5_ib_query_device(&dev->ib_dev, dprops, &uhw);
         if (err) {
                 mlx5_ib_warn(dev, "query_device failed %d\n", err);
                 goto out;
         }
 
-        for (port = 1; port <= gen->num_ports; port++) {
+        for (port = 1; port <= MLX5_CAP_GEN(dev->mdev, num_ports); port++) {
                 err = mlx5_ib_query_port(&dev->ib_dev, port, pprops);
                 if (err) {
-                        mlx5_ib_warn(dev, "query_port %d failed %d\n", port, err);
+                        mlx5_ib_warn(dev, "query_port %d failed %d\n",
+                                     port, err);
                         break;
                 }
-                gen->port[port - 1].pkey_table_len = dprops->max_pkeys;
-                gen->port[port - 1].gid_table_len = pprops->gid_tbl_len;
+                dev->mdev->port_caps[port - 1].pkey_table_len =
+                                                dprops->max_pkeys;
+                dev->mdev->port_caps[port - 1].gid_table_len =
+                                                pprops->gid_tbl_len;
                 mlx5_ib_dbg(dev, "pkey_table_len %d, gid_table_len %d\n",
                             dprops->max_pkeys, pprops->gid_tbl_len);
         }
@@ -971,6 +1137,7 @@ static int create_umr_res(struct mlx5_ib_dev *dev)
         struct ib_cq *cq;
         struct ib_qp *qp;
         struct ib_mr *mr;
+        struct ib_cq_init_attr cq_attr = {};
         int ret;
 
         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
@@ -994,8 +1161,9 @@ static int create_umr_res(struct mlx5_ib_dev *dev)
                 goto error_1;
         }
 
-        cq = ib_create_cq(&dev->ib_dev, mlx5_umr_cq_handler, NULL, NULL, 128,
-                          0);
+        cq_attr.cqe = 128;
+        cq = ib_create_cq(&dev->ib_dev, mlx5_umr_cq_handler, NULL, NULL,
+                          &cq_attr);
         if (IS_ERR(cq)) {
                 mlx5_ib_dbg(dev, "Couldn't create CQ for sync UMR QP\n");
                 ret = PTR_ERR(cq);
@@ -1087,6 +1255,7 @@ static int create_dev_resources(struct mlx5_ib_resources *devr)
 {
         struct ib_srq_init_attr attr;
         struct mlx5_ib_dev *dev;
+        struct ib_cq_init_attr cq_attr = {.cqe = 1};
         int ret = 0;
 
         dev = container_of(devr, struct mlx5_ib_dev, devr);
@@ -1100,7 +1269,7 @@ static int create_dev_resources(struct mlx5_ib_resources *devr)
         devr->p0->uobject = NULL;
         atomic_set(&devr->p0->usecnt, 0);
 
-        devr->c0 = mlx5_ib_create_cq(&dev->ib_dev, 1, 0, NULL, NULL);
+        devr->c0 = mlx5_ib_create_cq(&dev->ib_dev, &cq_attr, NULL, NULL);
         if (IS_ERR(devr->c0)) {
                 ret = PTR_ERR(devr->c0);
                 goto error1;
@@ -1159,8 +1328,29 @@ static int create_dev_resources(struct mlx5_ib_resources *devr)
         atomic_inc(&devr->p0->usecnt);
         atomic_set(&devr->s0->usecnt, 0);
 
+        memset(&attr, 0, sizeof(attr));
+        attr.attr.max_sge = 1;
+        attr.attr.max_wr = 1;
+        attr.srq_type = IB_SRQT_BASIC;
+        devr->s1 = mlx5_ib_create_srq(devr->p0, &attr, NULL);
+        if (IS_ERR(devr->s1)) {
+                ret = PTR_ERR(devr->s1);
+                goto error5;
+        }
+        devr->s1->device        = &dev->ib_dev;
+        devr->s1->pd            = devr->p0;
+        devr->s1->uobject       = NULL;
+        devr->s1->event_handler = NULL;
+        devr->s1->srq_context   = NULL;
+        devr->s1->srq_type      = IB_SRQT_BASIC;
+        devr->s1->ext.xrc.cq    = devr->c0;
+        atomic_inc(&devr->p0->usecnt);
+        atomic_set(&devr->s0->usecnt, 0);
+
         return 0;
 
+error5:
+        mlx5_ib_destroy_srq(devr->s0);
 error4:
         mlx5_ib_dealloc_xrcd(devr->x1);
 error3:
@@ -1175,6 +1365,7 @@ error0:
 
 static void destroy_dev_resources(struct mlx5_ib_resources *devr)
 {
+        mlx5_ib_destroy_srq(devr->s1);
         mlx5_ib_destroy_srq(devr->s0);
         mlx5_ib_dealloc_xrcd(devr->x0);
         mlx5_ib_dealloc_xrcd(devr->x1);
@@ -1182,12 +1373,34 @@ static void destroy_dev_resources(struct mlx5_ib_resources *devr)
         mlx5_ib_dealloc_pd(devr->p0);
 }
 
+static int mlx5_port_immutable(struct ib_device *ibdev, u8 port_num,
+                               struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = mlx5_ib_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 static void *mlx5_ib_add(struct mlx5_core_dev *mdev)
 {
         struct mlx5_ib_dev *dev;
         int err;
         int i;
 
+        /* don't create IB instance over Eth ports, no RoCE yet! */
+        if (MLX5_CAP_GEN(mdev, port_type) == MLX5_CAP_PORT_TYPE_ETH)
+                return NULL;
+
         printk_once(KERN_INFO "%s", mlx5_version);
 
         dev = (struct mlx5_ib_dev *)ib_alloc_device(sizeof(*dev));
@@ -1200,15 +1413,16 @@ static void *mlx5_ib_add(struct mlx5_core_dev *mdev)
         if (err)
                 goto err_dealloc;
 
-        get_ext_port_caps(dev);
+        if (mlx5_use_mad_ifc(dev))
+                get_ext_port_caps(dev);
 
         MLX5_INIT_DOORBELL_LOCK(&dev->uar_lock);
 
         strlcpy(dev->ib_dev.name, "mlx5_%d", IB_DEVICE_NAME_MAX);
         dev->ib_dev.owner               = THIS_MODULE;
         dev->ib_dev.node_type           = RDMA_NODE_IB_CA;
-        dev->ib_dev.local_dma_lkey      = mdev->caps.gen.reserved_lkey;
-        dev->num_ports          = mdev->caps.gen.num_ports;
+        dev->ib_dev.local_dma_lkey      = 0 /* not supported for now */;
+        dev->num_ports          = MLX5_CAP_GEN(mdev, num_ports);
         dev->ib_dev.phys_port_cnt     = dev->num_ports;
         dev->ib_dev.num_comp_vectors    =
                 dev->mdev->priv.eq_table.num_comp_vectors;
@@ -1285,10 +1499,11 @@ static void *mlx5_ib_add(struct mlx5_core_dev *mdev)
         dev->ib_dev.alloc_fast_reg_page_list = mlx5_ib_alloc_fast_reg_page_list;
         dev->ib_dev.free_fast_reg_page_list  = mlx5_ib_free_fast_reg_page_list;
         dev->ib_dev.check_mr_status     = mlx5_ib_check_mr_status;
+        dev->ib_dev.get_port_immutable  = mlx5_port_immutable;
 
-        mlx5_ib_internal_query_odp_caps(dev);
+        mlx5_ib_internal_fill_odp_caps(dev);
 
-        if (mdev->caps.gen.flags & MLX5_DEV_CAP_FLAG_XRC) {
+        if (MLX5_CAP_GEN(mdev, xrc)) {
                 dev->ib_dev.alloc_xrcd = mlx5_ib_alloc_xrcd;
                 dev->ib_dev.dealloc_xrcd = mlx5_ib_dealloc_xrcd;
                 dev->ib_dev.uverbs_cmd_mask |=
diff --git a/drivers/infiniband/hw/mlx5/mlx5_ib.h b/drivers/infiniband/hw/mlx5/mlx5_ib.h
index dff1cfcdf476..7cae09836481 100644
--- a/drivers/infiniband/hw/mlx5/mlx5_ib.h
+++ b/drivers/infiniband/hw/mlx5/mlx5_ib.h
@@ -415,6 +415,7 @@ struct mlx5_ib_resources {
         struct ib_xrcd  *x1;
         struct ib_pd    *p0;
         struct ib_srq   *s0;
+        struct ib_srq   *s1;
 };
 
 struct mlx5_ib_dev {
@@ -525,8 +526,8 @@ void __mlx5_ib_cq_clean(struct mlx5_ib_cq *cq, u32 qpn, struct mlx5_ib_srq *srq)
 void mlx5_ib_cq_clean(struct mlx5_ib_cq *cq, u32 qpn, struct mlx5_ib_srq *srq);
 void mlx5_ib_free_srq_wqe(struct mlx5_ib_srq *srq, int wqe_index);
 int mlx5_MAD_IFC(struct mlx5_ib_dev *dev, int ignore_mkey, int ignore_bkey,
-                 u8 port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad);
+                 u8 port, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                 const void *in_mad, void *response_mad);
 struct ib_ah *create_ib_ah(struct ib_ah_attr *ah_attr,
                            struct mlx5_ib_ah *ah);
 struct ib_ah *mlx5_ib_create_ah(struct ib_pd *pd, struct ib_ah_attr *ah_attr);
@@ -556,8 +557,9 @@ int mlx5_ib_post_recv(struct ib_qp *ibqp, struct ib_recv_wr *wr,
 void *mlx5_get_send_wqe(struct mlx5_ib_qp *qp, int n);
 int mlx5_ib_read_user_wqe(struct mlx5_ib_qp *qp, int send, int wqe_index,
                           void *buffer, u32 length);
-struct ib_cq *mlx5_ib_create_cq(struct ib_device *ibdev, int entries,
-                                int vector, struct ib_ucontext *context,
+struct ib_cq *mlx5_ib_create_cq(struct ib_device *ibdev,
+                                const struct ib_cq_init_attr *attr,
+                                struct ib_ucontext *context,
                                 struct ib_udata *udata);
 int mlx5_ib_destroy_cq(struct ib_cq *cq);
 int mlx5_ib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc);
@@ -586,14 +588,32 @@ int mlx5_ib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
 int mlx5_ib_unmap_fmr(struct list_head *fmr_list);
 int mlx5_ib_fmr_dealloc(struct ib_fmr *ibfmr);
 int mlx5_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);
+                        const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                        const struct ib_mad_hdr *in, size_t in_mad_size,
+                        struct ib_mad_hdr *out, size_t *out_mad_size,
+                        u16 *out_mad_pkey_index);
 struct ib_xrcd *mlx5_ib_alloc_xrcd(struct ib_device *ibdev,
                                           struct ib_ucontext *context,
                                           struct ib_udata *udata);
 int mlx5_ib_dealloc_xrcd(struct ib_xrcd *xrcd);
 int mlx5_ib_get_buf_offset(u64 addr, int page_shift, u32 *offset);
 int mlx5_query_ext_port_caps(struct mlx5_ib_dev *dev, u8 port);
+int mlx5_query_mad_ifc_smp_attr_node_info(struct ib_device *ibdev,
+                                          struct ib_smp *out_mad);
+int mlx5_query_mad_ifc_system_image_guid(struct ib_device *ibdev,
+                                         __be64 *sys_image_guid);
+int mlx5_query_mad_ifc_max_pkeys(struct ib_device *ibdev,
+                                 u16 *max_pkeys);
+int mlx5_query_mad_ifc_vendor_id(struct ib_device *ibdev,
+                                 u32 *vendor_id);
+int mlx5_query_mad_ifc_node_desc(struct mlx5_ib_dev *dev, char *node_desc);
+int mlx5_query_mad_ifc_node_guid(struct mlx5_ib_dev *dev, __be64 *node_guid);
+int mlx5_query_mad_ifc_pkey(struct ib_device *ibdev, u8 port, u16 index,
+                            u16 *pkey);
+int mlx5_query_mad_ifc_gids(struct ib_device *ibdev, u8 port, int index,
+                            union ib_gid *gid);
+int mlx5_query_mad_ifc_port(struct ib_device *ibdev, u8 port,
+                            struct ib_port_attr *props);
 int mlx5_ib_query_port(struct ib_device *ibdev, u8 port,
                        struct ib_port_attr *props);
 int mlx5_ib_init_fmr(struct mlx5_ib_dev *dev);
@@ -617,7 +637,7 @@ int mlx5_ib_check_mr_status(struct ib_mr *ibmr, u32 check_mask,
 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
 extern struct workqueue_struct *mlx5_ib_page_fault_wq;
 
-int mlx5_ib_internal_query_odp_caps(struct mlx5_ib_dev *dev);
+void mlx5_ib_internal_fill_odp_caps(struct mlx5_ib_dev *dev);
 void mlx5_ib_mr_pfault_handler(struct mlx5_ib_qp *qp,
                                struct mlx5_ib_pfault *pfault);
 void mlx5_ib_odp_create_qp(struct mlx5_ib_qp *qp);
@@ -631,9 +651,9 @@ void mlx5_ib_invalidate_range(struct ib_umem *umem, unsigned long start,
                               unsigned long end);
 
 #else /* CONFIG_INFINIBAND_ON_DEMAND_PAGING */
-static inline int mlx5_ib_internal_query_odp_caps(struct mlx5_ib_dev *dev)
+static inline void mlx5_ib_internal_fill_odp_caps(struct mlx5_ib_dev *dev)
 {
-        return 0;
+        return;
 }
 
 static inline void mlx5_ib_odp_create_qp(struct mlx5_ib_qp *qp)         {}
diff --git a/drivers/infiniband/hw/mlx5/mr.c b/drivers/infiniband/hw/mlx5/mr.c
index 71c593583864..bc9a0de897cb 100644
--- a/drivers/infiniband/hw/mlx5/mr.c
+++ b/drivers/infiniband/hw/mlx5/mr.c
@@ -975,8 +975,7 @@ static struct mlx5_ib_mr *reg_create(struct ib_pd *pd, u64 virt_addr,
         struct mlx5_ib_mr *mr;
         int inlen;
         int err;
-        bool pg_cap = !!(dev->mdev->caps.gen.flags &
-                         MLX5_DEV_CAP_FLAG_ON_DMND_PG);
+        bool pg_cap = !!(MLX5_CAP_GEN(dev->mdev, pg));
 
         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
         if (!mr)
diff --git a/drivers/infiniband/hw/mlx5/odp.c b/drivers/infiniband/hw/mlx5/odp.c
index 5099db08afd2..aa8391e75385 100644
--- a/drivers/infiniband/hw/mlx5/odp.c
+++ b/drivers/infiniband/hw/mlx5/odp.c
@@ -109,40 +109,33 @@ void mlx5_ib_invalidate_range(struct ib_umem *umem, unsigned long start,
         ib_umem_odp_unmap_dma_pages(umem, start, end);
 }
 
-#define COPY_ODP_BIT_MLX_TO_IB(reg, ib_caps, field_name, bit_name) do { \
-        if (be32_to_cpu(reg.field_name) & MLX5_ODP_SUPPORT_##bit_name)  \
-                ib_caps->field_name |= IB_ODP_SUPPORT_##bit_name;       \
-} while (0)
-
-int mlx5_ib_internal_query_odp_caps(struct mlx5_ib_dev *dev)
+void mlx5_ib_internal_fill_odp_caps(struct mlx5_ib_dev *dev)
 {
-        int err;
-        struct mlx5_odp_caps hw_caps;
         struct ib_odp_caps *caps = &dev->odp_caps;
 
         memset(caps, 0, sizeof(*caps));
 
-        if (!(dev->mdev->caps.gen.flags & MLX5_DEV_CAP_FLAG_ON_DMND_PG))
-                return 0;
-
-        err = mlx5_query_odp_caps(dev->mdev, &hw_caps);
-        if (err)
-                goto out;
+        if (!MLX5_CAP_GEN(dev->mdev, pg))
+                return;
 
         caps->general_caps = IB_ODP_SUPPORT;
-        COPY_ODP_BIT_MLX_TO_IB(hw_caps, caps, per_transport_caps.ud_odp_caps,
-                               SEND);
-        COPY_ODP_BIT_MLX_TO_IB(hw_caps, caps, per_transport_caps.rc_odp_caps,
-                               SEND);
-        COPY_ODP_BIT_MLX_TO_IB(hw_caps, caps, per_transport_caps.rc_odp_caps,
-                               RECV);
-        COPY_ODP_BIT_MLX_TO_IB(hw_caps, caps, per_transport_caps.rc_odp_caps,
-                               WRITE);
-        COPY_ODP_BIT_MLX_TO_IB(hw_caps, caps, per_transport_caps.rc_odp_caps,
-                               READ);
-
-out:
-        return err;
+
+        if (MLX5_CAP_ODP(dev->mdev, ud_odp_caps.send))
+                caps->per_transport_caps.ud_odp_caps |= IB_ODP_SUPPORT_SEND;
+
+        if (MLX5_CAP_ODP(dev->mdev, rc_odp_caps.send))
+                caps->per_transport_caps.rc_odp_caps |= IB_ODP_SUPPORT_SEND;
+
+        if (MLX5_CAP_ODP(dev->mdev, rc_odp_caps.receive))
+                caps->per_transport_caps.rc_odp_caps |= IB_ODP_SUPPORT_RECV;
+
+        if (MLX5_CAP_ODP(dev->mdev, rc_odp_caps.write))
+                caps->per_transport_caps.rc_odp_caps |= IB_ODP_SUPPORT_WRITE;
+
+        if (MLX5_CAP_ODP(dev->mdev, rc_odp_caps.read))
+                caps->per_transport_caps.rc_odp_caps |= IB_ODP_SUPPORT_READ;
+
+        return;
 }
 
 static struct mlx5_ib_mr *mlx5_ib_odp_find_mr_lkey(struct mlx5_ib_dev *dev,
diff --git a/drivers/infiniband/hw/mlx5/qp.c b/drivers/infiniband/hw/mlx5/qp.c
index d35f62d4f4c5..203c8a45e095 100644
--- a/drivers/infiniband/hw/mlx5/qp.c
+++ b/drivers/infiniband/hw/mlx5/qp.c
@@ -220,13 +220,11 @@ static void mlx5_ib_qp_event(struct mlx5_core_qp *qp, int type)
 static int set_rq_size(struct mlx5_ib_dev *dev, struct ib_qp_cap *cap,
                        int has_rq, struct mlx5_ib_qp *qp, struct mlx5_ib_create_qp *ucmd)
 {
-        struct mlx5_general_caps *gen;
         int wqe_size;
         int wq_size;
 
-        gen = &dev->mdev->caps.gen;
         /* Sanity check RQ size before proceeding */
-        if (cap->max_recv_wr  > gen->max_wqes)
+        if (cap->max_recv_wr > (1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz)))
                 return -EINVAL;
 
         if (!has_rq) {
@@ -246,10 +244,11 @@ static int set_rq_size(struct mlx5_ib_dev *dev, struct ib_qp_cap *cap,
                         wq_size = roundup_pow_of_two(cap->max_recv_wr) * wqe_size;
                         wq_size = max_t(int, wq_size, MLX5_SEND_WQE_BB);
                         qp->rq.wqe_cnt = wq_size / wqe_size;
-                        if (wqe_size > gen->max_rq_desc_sz) {
+                        if (wqe_size > MLX5_CAP_GEN(dev->mdev, max_wqe_sz_rq)) {
                                 mlx5_ib_dbg(dev, "wqe_size %d, max %d\n",
                                             wqe_size,
-                                            gen->max_rq_desc_sz);
+                                            MLX5_CAP_GEN(dev->mdev,
+                                                         max_wqe_sz_rq));
                                 return -EINVAL;
                         }
                         qp->rq.wqe_shift = ilog2(wqe_size);
@@ -330,11 +329,9 @@ static int calc_send_wqe(struct ib_qp_init_attr *attr)
 static int calc_sq_size(struct mlx5_ib_dev *dev, struct ib_qp_init_attr *attr,
                         struct mlx5_ib_qp *qp)
 {
-        struct mlx5_general_caps *gen;
         int wqe_size;
         int wq_size;
 
-        gen = &dev->mdev->caps.gen;
         if (!attr->cap.max_send_wr)
                 return 0;
 
@@ -343,9 +340,9 @@ static int calc_sq_size(struct mlx5_ib_dev *dev, struct ib_qp_init_attr *attr,
         if (wqe_size < 0)
                 return wqe_size;
 
-        if (wqe_size > gen->max_sq_desc_sz) {
+        if (wqe_size > MLX5_CAP_GEN(dev->mdev, max_wqe_sz_sq)) {
                 mlx5_ib_dbg(dev, "wqe_size(%d) > max_sq_desc_sz(%d)\n",
-                            wqe_size, gen->max_sq_desc_sz);
+                            wqe_size, MLX5_CAP_GEN(dev->mdev, max_wqe_sz_sq));
                 return -EINVAL;
         }
 
@@ -358,9 +355,10 @@ static int calc_sq_size(struct mlx5_ib_dev *dev, struct ib_qp_init_attr *attr,
 
         wq_size = roundup_pow_of_two(attr->cap.max_send_wr * wqe_size);
         qp->sq.wqe_cnt = wq_size / MLX5_SEND_WQE_BB;
-        if (qp->sq.wqe_cnt > gen->max_wqes) {
+        if (qp->sq.wqe_cnt > (1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz))) {
                 mlx5_ib_dbg(dev, "wqe count(%d) exceeds limits(%d)\n",
-                            qp->sq.wqe_cnt, gen->max_wqes);
+                            qp->sq.wqe_cnt,
+                            1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz));
                 return -ENOMEM;
         }
         qp->sq.wqe_shift = ilog2(MLX5_SEND_WQE_BB);
@@ -375,13 +373,11 @@ static int set_user_buf_size(struct mlx5_ib_dev *dev,
                             struct mlx5_ib_qp *qp,
                             struct mlx5_ib_create_qp *ucmd)
 {
-        struct mlx5_general_caps *gen;
         int desc_sz = 1 << qp->sq.wqe_shift;
 
-        gen = &dev->mdev->caps.gen;
-        if (desc_sz > gen->max_sq_desc_sz) {
+        if (desc_sz > MLX5_CAP_GEN(dev->mdev, max_wqe_sz_sq)) {
                 mlx5_ib_warn(dev, "desc_sz %d, max_sq_desc_sz %d\n",
-                             desc_sz, gen->max_sq_desc_sz);
+                             desc_sz, MLX5_CAP_GEN(dev->mdev, max_wqe_sz_sq));
                 return -EINVAL;
         }
 
@@ -393,9 +389,10 @@ static int set_user_buf_size(struct mlx5_ib_dev *dev,
 
         qp->sq.wqe_cnt = ucmd->sq_wqe_count;
 
-        if (qp->sq.wqe_cnt > gen->max_wqes) {
+        if (qp->sq.wqe_cnt > (1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz))) {
                 mlx5_ib_warn(dev, "wqe_cnt %d, max_wqes %d\n",
-                             qp->sq.wqe_cnt, gen->max_wqes);
+                             qp->sq.wqe_cnt,
+                             1 << MLX5_CAP_GEN(dev->mdev, log_max_qp_sz));
                 return -EINVAL;
         }
 
@@ -768,7 +765,7 @@ static int create_kernel_qp(struct mlx5_ib_dev *dev,
         qp->sq.offset = qp->rq.wqe_cnt << qp->rq.wqe_shift;
         qp->buf_size = err + (qp->rq.wqe_cnt << qp->rq.wqe_shift);
 
-        err = mlx5_buf_alloc(dev->mdev, qp->buf_size, PAGE_SIZE * 2, &qp->buf);
+        err = mlx5_buf_alloc(dev->mdev, qp->buf_size, &qp->buf);
         if (err) {
                 mlx5_ib_dbg(dev, "err %d\n", err);
                 goto err_uuar;
@@ -866,22 +863,21 @@ static int create_qp_common(struct mlx5_ib_dev *dev, struct ib_pd *pd,
                             struct ib_udata *udata, struct mlx5_ib_qp *qp)
 {
         struct mlx5_ib_resources *devr = &dev->devr;
+        struct mlx5_core_dev *mdev = dev->mdev;
         struct mlx5_ib_create_qp_resp resp;
         struct mlx5_create_qp_mbox_in *in;
-        struct mlx5_general_caps *gen;
         struct mlx5_ib_create_qp ucmd;
         int inlen = sizeof(*in);
         int err;
 
         mlx5_ib_odp_create_qp(qp);
 
-        gen = &dev->mdev->caps.gen;
         mutex_init(&qp->mutex);
         spin_lock_init(&qp->sq.lock);
         spin_lock_init(&qp->rq.lock);
 
         if (init_attr->create_flags & IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK) {
-                if (!(gen->flags & MLX5_DEV_CAP_FLAG_BLOCK_MCAST)) {
+                if (!MLX5_CAP_GEN(mdev, block_lb_mc)) {
                         mlx5_ib_dbg(dev, "block multicast loopback isn't supported\n");
                         return -EINVAL;
                 } else {
@@ -914,15 +910,17 @@ static int create_qp_common(struct mlx5_ib_dev *dev, struct ib_pd *pd,
 
         if (pd) {
                 if (pd->uobject) {
+                        __u32 max_wqes =
+                                1 << MLX5_CAP_GEN(mdev, log_max_qp_sz);
                         mlx5_ib_dbg(dev, "requested sq_wqe_count (%d)\n", ucmd.sq_wqe_count);
                         if (ucmd.rq_wqe_shift != qp->rq.wqe_shift ||
                             ucmd.rq_wqe_count != qp->rq.wqe_cnt) {
                                 mlx5_ib_dbg(dev, "invalid rq params\n");
                                 return -EINVAL;
                         }
-                        if (ucmd.sq_wqe_count > gen->max_wqes) {
+                        if (ucmd.sq_wqe_count > max_wqes) {
                                 mlx5_ib_dbg(dev, "requested sq_wqe_count (%d) > max allowed (%d)\n",
-                                            ucmd.sq_wqe_count, gen->max_wqes);
+                                            ucmd.sq_wqe_count, max_wqes);
                                 return -EINVAL;
                         }
                         err = create_user_qp(dev, pd, qp, udata, &in, &resp, &inlen);
@@ -1014,7 +1012,8 @@ static int create_qp_common(struct mlx5_ib_dev *dev, struct ib_pd *pd,
                         in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(init_attr->srq)->msrq.srqn);
                 } else {
                         in->ctx.xrcd = cpu_to_be32(to_mxrcd(devr->x1)->xrcdn);
-                        in->ctx.rq_type_srqn |= cpu_to_be32(to_msrq(devr->s0)->msrq.srqn);
+                        in->ctx.rq_type_srqn |=
+                                cpu_to_be32(to_msrq(devr->s1)->msrq.srqn);
                 }
         }
 
@@ -1226,7 +1225,6 @@ struct ib_qp *mlx5_ib_create_qp(struct ib_pd *pd,
                                 struct ib_qp_init_attr *init_attr,
                                 struct ib_udata *udata)
 {
-        struct mlx5_general_caps *gen;
         struct mlx5_ib_dev *dev;
         struct mlx5_ib_qp *qp;
         u16 xrcdn = 0;
@@ -1244,12 +1242,11 @@ struct ib_qp *mlx5_ib_create_qp(struct ib_pd *pd,
                 }
                 dev = to_mdev(to_mxrcd(init_attr->xrcd)->ibxrcd.device);
         }
-        gen = &dev->mdev->caps.gen;
 
         switch (init_attr->qp_type) {
         case IB_QPT_XRC_TGT:
         case IB_QPT_XRC_INI:
-                if (!(gen->flags & MLX5_DEV_CAP_FLAG_XRC)) {
+                if (!MLX5_CAP_GEN(dev->mdev, xrc)) {
                         mlx5_ib_dbg(dev, "XRC not supported\n");
                         return ERR_PTR(-ENOSYS);
                 }
@@ -1356,9 +1353,6 @@ enum {
 
 static int ib_rate_to_mlx5(struct mlx5_ib_dev *dev, u8 rate)
 {
-        struct mlx5_general_caps *gen;
-
-        gen = &dev->mdev->caps.gen;
         if (rate == IB_RATE_PORT_CURRENT) {
                 return 0;
         } else if (rate < IB_RATE_2_5_GBPS || rate > IB_RATE_300_GBPS) {
@@ -1366,7 +1360,7 @@ static int ib_rate_to_mlx5(struct mlx5_ib_dev *dev, u8 rate)
         } else {
                 while (rate != IB_RATE_2_5_GBPS &&
                        !(1 << (rate + MLX5_STAT_RATE_OFFSET) &
-                         gen->stat_rate_support))
+                         MLX5_CAP_GEN(dev->mdev, stat_rate_support)))
                         --rate;
         }
 
@@ -1377,10 +1371,8 @@ static int mlx5_set_path(struct mlx5_ib_dev *dev, const struct ib_ah_attr *ah,
                          struct mlx5_qp_path *path, u8 port, int attr_mask,
                          u32 path_flags, const struct ib_qp_attr *attr)
 {
-        struct mlx5_general_caps *gen;
         int err;
 
-        gen = &dev->mdev->caps.gen;
         path->fl = (path_flags & MLX5_PATH_FLAG_FL) ? 0x80 : 0;
         path->free_ar = (path_flags & MLX5_PATH_FLAG_FREE_AR) ? 0x80 : 0;
 
@@ -1391,9 +1383,11 @@ static int mlx5_set_path(struct mlx5_ib_dev *dev, const struct ib_ah_attr *ah,
         path->rlid      = cpu_to_be16(ah->dlid);
 
         if (ah->ah_flags & IB_AH_GRH) {
-                if (ah->grh.sgid_index >= gen->port[port - 1].gid_table_len) {
+                if (ah->grh.sgid_index >=
+                    dev->mdev->port_caps[port - 1].gid_table_len) {
                         pr_err("sgid_index (%u) too large. max is %d\n",
-                               ah->grh.sgid_index, gen->port[port - 1].gid_table_len);
+                               ah->grh.sgid_index,
+                               dev->mdev->port_caps[port - 1].gid_table_len);
                         return -EINVAL;
                 }
                 path->grh_mlid |= 1 << 7;
@@ -1570,7 +1564,6 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp,
         struct mlx5_ib_qp *qp = to_mqp(ibqp);
         struct mlx5_ib_cq *send_cq, *recv_cq;
         struct mlx5_qp_context *context;
-        struct mlx5_general_caps *gen;
         struct mlx5_modify_qp_mbox_in *in;
         struct mlx5_ib_pd *pd;
         enum mlx5_qp_state mlx5_cur, mlx5_new;
@@ -1579,7 +1572,6 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp,
         int mlx5_st;
         int err;
 
-        gen = &dev->mdev->caps.gen;
         in = kzalloc(sizeof(*in), GFP_KERNEL);
         if (!in)
                 return -ENOMEM;
@@ -1619,7 +1611,8 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp,
                         err = -EINVAL;
                         goto out;
                 }
-                context->mtu_msgmax = (attr->path_mtu << 5) | gen->log_max_msg;
+                context->mtu_msgmax = (attr->path_mtu << 5) |
+                                      (u8)MLX5_CAP_GEN(dev->mdev, log_max_msg);
         }
 
         if (attr_mask & IB_QP_DEST_QPN)
@@ -1777,11 +1770,9 @@ int mlx5_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         struct mlx5_ib_dev *dev = to_mdev(ibqp->device);
         struct mlx5_ib_qp *qp = to_mqp(ibqp);
         enum ib_qp_state cur_state, new_state;
-        struct mlx5_general_caps *gen;
         int err = -EINVAL;
         int port;
 
-        gen = &dev->mdev->caps.gen;
         mutex_lock(&qp->mutex);
 
         cur_state = attr_mask & IB_QP_CUR_STATE ? attr->cur_qp_state : qp->state;
@@ -1793,21 +1784,25 @@ int mlx5_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                 goto out;
 
         if ((attr_mask & IB_QP_PORT) &&
-            (attr->port_num == 0 || attr->port_num > gen->num_ports))
+            (attr->port_num == 0 ||
+             attr->port_num > MLX5_CAP_GEN(dev->mdev, num_ports)))
                 goto out;
 
         if (attr_mask & IB_QP_PKEY_INDEX) {
                 port = attr_mask & IB_QP_PORT ? attr->port_num : qp->port;
-                if (attr->pkey_index >= gen->port[port - 1].pkey_table_len)
+                if (attr->pkey_index >=
+                    dev->mdev->port_caps[port - 1].pkey_table_len)
                         goto out;
         }
 
         if (attr_mask & IB_QP_MAX_QP_RD_ATOMIC &&
-            attr->max_rd_atomic > (1 << gen->log_max_ra_res_qp))
+            attr->max_rd_atomic >
+            (1 << MLX5_CAP_GEN(dev->mdev, log_max_ra_res_qp)))
                 goto out;
 
         if (attr_mask & IB_QP_MAX_DEST_RD_ATOMIC &&
-            attr->max_dest_rd_atomic > (1 << gen->log_max_ra_req_qp))
+            attr->max_dest_rd_atomic >
+            (1 << MLX5_CAP_GEN(dev->mdev, log_max_ra_req_qp)))
                 goto out;
 
         if (cur_state == new_state && cur_state == IB_QPS_RESET) {
@@ -3009,7 +3004,7 @@ static void to_ib_ah_attr(struct mlx5_ib_dev *ibdev, struct ib_ah_attr *ib_ah_at
         ib_ah_attr->port_num      = path->port;
 
         if (ib_ah_attr->port_num == 0 ||
-            ib_ah_attr->port_num > dev->caps.gen.num_ports)
+            ib_ah_attr->port_num > MLX5_CAP_GEN(dev, num_ports))
                 return;
 
         ib_ah_attr->sl = path->sl & 0xf;
@@ -3135,12 +3130,10 @@ struct ib_xrcd *mlx5_ib_alloc_xrcd(struct ib_device *ibdev,
                                           struct ib_udata *udata)
 {
         struct mlx5_ib_dev *dev = to_mdev(ibdev);
-        struct mlx5_general_caps *gen;
         struct mlx5_ib_xrcd *xrcd;
         int err;
 
-        gen = &dev->mdev->caps.gen;
-        if (!(gen->flags & MLX5_DEV_CAP_FLAG_XRC))
+        if (!MLX5_CAP_GEN(dev->mdev, xrc))
                 return ERR_PTR(-ENOSYS);
 
         xrcd = kmalloc(sizeof(*xrcd), GFP_KERNEL);
diff --git a/drivers/infiniband/hw/mlx5/srq.c b/drivers/infiniband/hw/mlx5/srq.c
index 02d77a29764d..e008505e96e9 100644
--- a/drivers/infiniband/hw/mlx5/srq.c
+++ b/drivers/infiniband/hw/mlx5/srq.c
@@ -165,7 +165,7 @@ static int create_srq_kernel(struct mlx5_ib_dev *dev, struct mlx5_ib_srq *srq,
                 return err;
         }
 
-        if (mlx5_buf_alloc(dev->mdev, buf_size, PAGE_SIZE * 2, &srq->buf)) {
+        if (mlx5_buf_alloc(dev->mdev, buf_size, &srq->buf)) {
                 mlx5_ib_dbg(dev, "buf alloc failed\n");
                 err = -ENOMEM;
                 goto err_db;
@@ -236,7 +236,6 @@ struct ib_srq *mlx5_ib_create_srq(struct ib_pd *pd,
                                   struct ib_udata *udata)
 {
         struct mlx5_ib_dev *dev = to_mdev(pd->device);
-        struct mlx5_general_caps *gen;
         struct mlx5_ib_srq *srq;
         int desc_size;
         int buf_size;
@@ -245,13 +244,13 @@ struct ib_srq *mlx5_ib_create_srq(struct ib_pd *pd,
         int uninitialized_var(inlen);
         int is_xrc;
         u32 flgs, xrcdn;
+        __u32 max_srq_wqes = 1 << MLX5_CAP_GEN(dev->mdev, log_max_srq_sz);
 
-        gen = &dev->mdev->caps.gen;
         /* Sanity check SRQ size before proceeding */
-        if (init_attr->attr.max_wr >= gen->max_srq_wqes) {
+        if (init_attr->attr.max_wr >= max_srq_wqes) {
                 mlx5_ib_dbg(dev, "max_wr %d, cap %d\n",
                             init_attr->attr.max_wr,
-                            gen->max_srq_wqes);
+                            max_srq_wqes);
                 return ERR_PTR(-EINVAL);
         }
 
@@ -303,7 +302,7 @@ struct ib_srq *mlx5_ib_create_srq(struct ib_pd *pd,
 
         in->ctx.pd = cpu_to_be32(to_mpd(pd)->pdn);
         in->ctx.db_record = cpu_to_be64(srq->db.dma);
-        err = mlx5_core_create_srq(dev->mdev, &srq->msrq, in, inlen);
+        err = mlx5_core_create_srq(dev->mdev, &srq->msrq, in, inlen, is_xrc);
         kvfree(in);
         if (err) {
                 mlx5_ib_dbg(dev, "create SRQ failed, err %d\n", err);
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.c b/drivers/infiniband/hw/mthca/mthca_cmd.c
index 9d3e5c1ac60e..c7f49bbb0c72 100644
--- a/drivers/infiniband/hw/mthca/mthca_cmd.c
+++ b/drivers/infiniband/hw/mthca/mthca_cmd.c
@@ -1858,8 +1858,8 @@ int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn)
 }
 
 int mthca_MAD_IFC(struct mthca_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 port, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                  const void *in_mad, void *response_mad)
 {
         struct mthca_mailbox *inmailbox, *outmailbox;
         void *inbox;
diff --git a/drivers/infiniband/hw/mthca/mthca_cmd.h b/drivers/infiniband/hw/mthca/mthca_cmd.h
index f952244c54de..d2e5b194b938 100644
--- a/drivers/infiniband/hw/mthca/mthca_cmd.h
+++ b/drivers/infiniband/hw/mthca/mthca_cmd.h
@@ -312,8 +312,8 @@ int mthca_QUERY_QP(struct mthca_dev *dev, u32 num, int is_ee,
                    struct mthca_mailbox *mailbox);
 int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn);
 int mthca_MAD_IFC(struct mthca_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 port, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                  const void *in_mad, void *response_mad);
 int mthca_READ_MGM(struct mthca_dev *dev, int index,
                    struct mthca_mailbox *mailbox);
 int mthca_WRITE_MGM(struct mthca_dev *dev, int index,
diff --git a/drivers/infiniband/hw/mthca/mthca_dev.h b/drivers/infiniband/hw/mthca/mthca_dev.h
index 7e6a6d64ad4e..4393a022867b 100644
--- a/drivers/infiniband/hw/mthca/mthca_dev.h
+++ b/drivers/infiniband/hw/mthca/mthca_dev.h
@@ -576,10 +576,11 @@ int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid);
 int mthca_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);
+                      const struct ib_wc *in_wc,
+                      const struct ib_grh *in_grh,
+                      const struct ib_mad_hdr *in, size_t in_mad_size,
+                      struct ib_mad_hdr *out, size_t *out_mad_size,
+                      u16 *out_mad_pkey_index);
 int mthca_create_agents(struct mthca_dev *dev);
 void mthca_free_agents(struct mthca_dev *dev);
 
diff --git a/drivers/infiniband/hw/mthca/mthca_mad.c b/drivers/infiniband/hw/mthca/mthca_mad.c
index 8881fa376e06..7c3f2fb44ba5 100644
--- a/drivers/infiniband/hw/mthca/mthca_mad.c
+++ b/drivers/infiniband/hw/mthca/mthca_mad.c
@@ -104,7 +104,7 @@ static void update_sm_ah(struct mthca_dev *dev,
  */
 static void smp_snoop(struct ib_device *ibdev,
                       u8 port_num,
-                      struct ib_mad *mad,
+                      const struct ib_mad *mad,
                       u16 prev_lid)
 {
         struct ib_event event;
@@ -160,7 +160,7 @@ static void node_desc_override(struct ib_device *dev,
 
 static void forward_trap(struct mthca_dev *dev,
                          u8 port_num,
-                         struct ib_mad *mad)
+                         const struct ib_mad *mad)
 {
         int qpn = mad->mad_hdr.mgmt_class != IB_MGMT_CLASS_SUBN_LID_ROUTED;
         struct ib_mad_send_buf *send_buf;
@@ -170,7 +170,8 @@ static void forward_trap(struct mthca_dev *dev,
 
         if (agent) {
                 send_buf = ib_create_send_mad(agent, qpn, 0, 0, IB_MGMT_MAD_HDR,
-                                              IB_MGMT_MAD_DATA, GFP_ATOMIC);
+                                              IB_MGMT_MAD_DATA, GFP_ATOMIC,
+                                              IB_MGMT_BASE_VERSION);
                 if (IS_ERR(send_buf))
                         return;
                 /*
@@ -195,15 +196,22 @@ static void forward_trap(struct mthca_dev *dev,
 int mthca_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)
+                      const struct ib_wc *in_wc,
+                      const struct ib_grh *in_grh,
+                      const struct ib_mad_hdr *in, size_t in_mad_size,
+                      struct ib_mad_hdr *out, size_t *out_mad_size,
+                      u16 *out_mad_pkey_index)
 {
         int err;
         u16 slid = in_wc ? in_wc->slid : be16_to_cpu(IB_LID_PERMISSIVE);
         u16 prev_lid = 0;
         struct ib_port_attr pattr;
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         /* Forward locally generated traps to the SM */
         if (in_mad->mad_hdr.method == IB_MGMT_METHOD_TRAP &&
diff --git a/drivers/infiniband/hw/mthca/mthca_profile.c b/drivers/infiniband/hw/mthca/mthca_profile.c
index 8edb28a9a0e7..15d064479ef6 100644
--- a/drivers/infiniband/hw/mthca/mthca_profile.c
+++ b/drivers/infiniband/hw/mthca/mthca_profile.c
@@ -77,7 +77,6 @@ s64 mthca_make_profile(struct mthca_dev *dev,
         u64 mem_base, mem_avail;
         s64 total_size = 0;
         struct mthca_resource *profile;
-        struct mthca_resource tmp;
         int i, j;
 
         profile = kzalloc(MTHCA_RES_NUM * sizeof *profile, GFP_KERNEL);
@@ -136,11 +135,8 @@ s64 mthca_make_profile(struct mthca_dev *dev,
          */
         for (i = MTHCA_RES_NUM; i > 0; --i)
                 for (j = 1; j < i; ++j) {
-                        if (profile[j].size > profile[j - 1].size) {
-                                tmp            = profile[j];
-                                profile[j]     = profile[j - 1];
-                                profile[j - 1] = tmp;
-                        }
+                        if (profile[j].size > profile[j - 1].size)
+                                swap(profile[j], profile[j - 1]);
                 }
 
         for (i = 0; i < MTHCA_RES_NUM; ++i) {
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 415f8e1a54db..93ae51dcf2ff 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -57,14 +57,17 @@ static void init_query_mad(struct ib_smp *mad)
         mad->method        = IB_MGMT_METHOD_GET;
 }
 
-static int mthca_query_device(struct ib_device *ibdev,
-                              struct ib_device_attr *props)
+static int mthca_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                              struct ib_udata *uhw)
 {
         struct ib_smp *in_mad  = NULL;
         struct ib_smp *out_mad = NULL;
         int err = -ENOMEM;
         struct mthca_dev *mdev = to_mdev(ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
         if (!in_mad || !out_mad)
@@ -641,16 +644,20 @@ static int mthca_destroy_qp(struct ib_qp *qp)
         return 0;
 }
 
-static struct ib_cq *mthca_create_cq(struct ib_device *ibdev, int entries,
-                                     int comp_vector,
+static struct ib_cq *mthca_create_cq(struct ib_device *ibdev,
+                                     const struct ib_cq_init_attr *attr,
                                      struct ib_ucontext *context,
                                      struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct mthca_create_cq ucmd;
         struct mthca_cq *cq;
         int nent;
         int err;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (entries < 1 || entries > to_mdev(ibdev)->limits.max_cqes)
                 return ERR_PTR(-EINVAL);
 
@@ -1244,6 +1251,24 @@ out:
         return err;
 }
 
+static int mthca_port_immutable(struct ib_device *ibdev, u8 port_num,
+                                struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = mthca_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 int mthca_register_device(struct mthca_dev *dev)
 {
         int ret;
@@ -1323,6 +1348,7 @@ int mthca_register_device(struct mthca_dev *dev)
         dev->ib_dev.reg_phys_mr          = mthca_reg_phys_mr;
         dev->ib_dev.reg_user_mr          = mthca_reg_user_mr;
         dev->ib_dev.dereg_mr             = mthca_dereg_mr;
+        dev->ib_dev.get_port_immutable   = mthca_port_immutable;
 
         if (dev->mthca_flags & MTHCA_FLAG_FMR) {
                 dev->ib_dev.alloc_fmr            = mthca_alloc_fmr;
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index 72b43417cbe3..8a3ad170d790 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -1520,8 +1520,9 @@ static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpi
         int rc = arpindex;
         struct net_device *netdev;
         struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
+        __be32 dst_ipaddr = htonl(dst_ip);
 
-        rt = ip_route_output(&init_net, htonl(dst_ip), 0, 0, 0);
+        rt = ip_route_output(&init_net, dst_ipaddr, nesvnic->local_ipaddr, 0, 0);
         if (IS_ERR(rt)) {
                 printk(KERN_ERR "%s: ip_route_output_key failed for 0x%08X\n",
                        __func__, dst_ip);
@@ -1533,7 +1534,7 @@ static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpi
         else
                 netdev = nesvnic->netdev;
 
-        neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, netdev);
+        neigh = dst_neigh_lookup(&rt->dst, &dst_ipaddr);
 
         rcu_read_lock();
         if (neigh) {
@@ -1616,6 +1617,8 @@ static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
                   &cm_node->loc_addr, cm_node->loc_port,
                   &cm_node->rem_addr, cm_node->rem_port);
         cm_node->listener = listener;
+        if (listener)
+                cm_node->tos = listener->tos;
         cm_node->netdev = nesvnic->netdev;
         cm_node->cm_id = cm_info->cm_id;
         memcpy(cm_node->loc_mac, nesvnic->netdev->dev_addr, ETH_ALEN);
@@ -2938,6 +2941,9 @@ static int nes_cm_init_tsa_conn(struct nes_qp *nesqp, struct nes_cm_node *cm_nod
 
         nesqp->nesqp_context->misc2 |= cpu_to_le32(64 << NES_QPCONTEXT_MISC2_TTL_SHIFT);
 
+        nesqp->nesqp_context->misc2 |= cpu_to_le32(
+                cm_node->tos << NES_QPCONTEXT_MISC2_TOS_SHIFT);
+
         nesqp->nesqp_context->mss |= cpu_to_le32(((u32)cm_node->tcp_cntxt.mss) << 16);
 
         nesqp->nesqp_context->tcp_state_flow_label |= cpu_to_le32(
@@ -3612,6 +3618,7 @@ int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
                 cm_node->ord_size = 1;
 
         cm_node->apbvt_set = apbvt_set;
+        cm_node->tos = cm_id->tos;
         nesqp->cm_node = cm_node;
         cm_node->nesqp = nesqp;
         nes_add_ref(&nesqp->ibqp);
@@ -3666,6 +3673,7 @@ int nes_create_listen(struct iw_cm_id *cm_id, int backlog)
         }
 
         cm_id->provider_data = cm_node;
+        cm_node->tos = cm_id->tos;
 
         if (!cm_node->reused_node) {
                 if (nes_create_mapinfo(&cm_info))
diff --git a/drivers/infiniband/hw/nes/nes_cm.h b/drivers/infiniband/hw/nes/nes_cm.h
index f522cf639789..32a6420c2940 100644
--- a/drivers/infiniband/hw/nes/nes_cm.h
+++ b/drivers/infiniband/hw/nes/nes_cm.h
@@ -303,6 +303,7 @@ struct nes_cm_listener {
         int                        backlog;
         enum nes_cm_listener_state listener_state;
         u32                        reused_node;
+        u8                         tos;
 };
 
 /* per connection node and node state information */
@@ -352,6 +353,7 @@ struct nes_cm_node {
         struct list_head        reset_entry;
         struct nes_qp           *nesqp;
         atomic_t                passive_state;
+        u8                      tos;
 };
 
 /* structure for client or CM to fill when making CM api calls. */
diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c
index 02120d340d50..4713dd7ed764 100644
--- a/drivers/infiniband/hw/nes/nes_hw.c
+++ b/drivers/infiniband/hw/nes/nes_hw.c
@@ -3861,7 +3861,7 @@ void nes_manage_arp_cache(struct net_device *netdev, unsigned char *mac_addr,
                                 (((u32)mac_addr[2]) << 24) | (((u32)mac_addr[3]) << 16) |
                                 (((u32)mac_addr[4]) << 8)  | (u32)mac_addr[5]);
                 cqp_wqe->wqe_words[NES_CQP_ARP_WQE_MAC_HIGH_IDX] = cpu_to_le32(
-                                (((u32)mac_addr[0]) << 16) | (u32)mac_addr[1]);
+                                (((u32)mac_addr[0]) << 8) | (u32)mac_addr[1]);
         } else {
                 cqp_wqe->wqe_words[NES_CQP_ARP_WQE_MAC_ADDR_LOW_IDX] = 0;
                 cqp_wqe->wqe_words[NES_CQP_ARP_WQE_MAC_HIGH_IDX] = 0;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index c0d0296e7a00..fbc43e5f717b 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -512,12 +512,16 @@ static void nes_free_fast_reg_page_list(struct ib_fast_reg_page_list *pifrpl)
 /**
  * nes_query_device
  */
-static int nes_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
+static int nes_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                            struct ib_udata *uhw)
 {
         struct nes_vnic *nesvnic = to_nesvnic(ibdev);
         struct nes_device *nesdev = nesvnic->nesdev;
         struct nes_ib_device *nesibdev = nesvnic->nesibdev;
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         memset(props, 0, sizeof(*props));
         memcpy(&props->sys_image_guid, nesvnic->netdev->dev_addr, 6);
 
@@ -606,7 +610,6 @@ static int nes_query_port(struct ib_device *ibdev, u8 port, struct ib_port_attr
         return 0;
 }
 
-
 /**
  * nes_query_pkey
  */
@@ -1527,10 +1530,12 @@ static int nes_destroy_qp(struct ib_qp *ibqp)
 /**
  * nes_create_cq
  */
-static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
-                int comp_vector,
-                struct ib_ucontext *context, struct ib_udata *udata)
+static struct ib_cq *nes_create_cq(struct ib_device *ibdev,
+                                   const struct ib_cq_init_attr *attr,
+                                   struct ib_ucontext *context,
+                                   struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         u64 u64temp;
         struct nes_vnic *nesvnic = to_nesvnic(ibdev);
         struct nes_device *nesdev = nesvnic->nesdev;
@@ -1550,6 +1555,9 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
         unsigned long flags;
         int ret;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (entries > nesadapter->max_cqe)
                 return ERR_PTR(-EINVAL);
 
@@ -3222,8 +3230,10 @@ static int nes_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
  * nes_process_mad
  */
 static int nes_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)
+                u8 port_num, const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                const struct ib_mad_hdr *in, size_t in_mad_size,
+                struct ib_mad_hdr *out, size_t *out_mad_size,
+                u16 *out_mad_pkey_index)
 {
         nes_debug(NES_DBG_INIT, "\n");
         return -ENOSYS;
@@ -3828,6 +3838,22 @@ static int nes_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags notify_
         return 0;
 }
 
+static int nes_port_immutable(struct ib_device *ibdev, u8 port_num,
+                              struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = nes_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IWARP;
+
+        return 0;
+}
 
 /**
  * nes_init_ofa_device
@@ -3928,6 +3954,7 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
         nesibdev->ibdev.iwcm->reject = nes_reject;
         nesibdev->ibdev.iwcm->create_listen = nes_create_listen;
         nesibdev->ibdev.iwcm->destroy_listen = nes_destroy_listen;
+        nesibdev->ibdev.get_port_immutable   = nes_port_immutable;
 
         return nesibdev;
 }
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma.h b/drivers/infiniband/hw/ocrdma/ocrdma.h
index b396344fae16..6a36338593cd 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_H__
 #define __OCRDMA_H__
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_abi.h b/drivers/infiniband/hw/ocrdma/ocrdma_abi.h
index 1554cca5712a..430b1350fe96 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_abi.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_abi.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_ABI_H__
 #define __OCRDMA_ABI_H__
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c b/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
index f5a5ea836dbd..44766fee1f4e 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_ah.c
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #include <net/neighbour.h>
 #include <net/netevent.h>
@@ -204,12 +219,20 @@ int ocrdma_modify_ah(struct ib_ah *ibah, struct ib_ah_attr *attr)
 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)
+                       const struct ib_wc *in_wc,
+                       const struct ib_grh *in_grh,
+                       const struct ib_mad_hdr *in, size_t in_mad_size,
+                       struct ib_mad_hdr *out, size_t *out_mad_size,
+                       u16 *out_mad_pkey_index)
 {
         int status;
         struct ocrdma_dev *dev;
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         switch (in_mad->mad_hdr.mgmt_class) {
         case IB_MGMT_CLASS_PERF_MGMT:
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h b/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
index 726a87cf22dc..04a30ae67473 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_ah.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_AH_H__
 #define __OCRDMA_AH_H__
@@ -42,7 +57,9 @@ 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);
+                       const struct ib_wc *in_wc,
+                       const struct ib_grh *in_grh,
+                       const struct ib_mad_hdr *in, size_t in_mad_size,
+                       struct ib_mad_hdr *out, size_t *out_mad_size,
+                       u16 *out_mad_pkey_index);
 #endif                          /* __OCRDMA_AH_H__ */
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
index 47615ff33bc6..aab391a15db4 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #include <linux/sched.h>
 #include <linux/interrupt.h>
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h b/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
index e905972fceb7..7ed885c1851e 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_hw.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_HW_H__
 #define __OCRDMA_HW_H__
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_main.c b/drivers/infiniband/hw/ocrdma/ocrdma_main.c
index 7a2b59aca004..b119a3413a15 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_main.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_main.c
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,13 +38,14 @@
  * 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 <rdma/ib_mad.h>
 
 #include <linux/netdevice.h>
 #include <net/addrconf.h>
@@ -45,7 +61,7 @@
 MODULE_VERSION(OCRDMA_ROCE_DRV_VERSION);
 MODULE_DESCRIPTION(OCRDMA_ROCE_DRV_DESC " " OCRDMA_ROCE_DRV_VERSION);
 MODULE_AUTHOR("Emulex Corporation");
-MODULE_LICENSE("GPL");
+MODULE_LICENSE("Dual BSD/GPL");
 
 static LIST_HEAD(ocrdma_dev_list);
 static DEFINE_SPINLOCK(ocrdma_devlist_lock);
@@ -202,6 +218,24 @@ static enum rdma_link_layer ocrdma_link_layer(struct ib_device *device,
         return IB_LINK_LAYER_ETHERNET;
 }
 
+static int ocrdma_port_immutable(struct ib_device *ibdev, u8 port_num,
+                                 struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = ocrdma_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_ROCE;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 static int ocrdma_register_device(struct ocrdma_dev *dev)
 {
         strlcpy(dev->ibdev.name, "ocrdma%d", IB_DEVICE_NAME_MAX);
@@ -286,6 +320,7 @@ static int ocrdma_register_device(struct ocrdma_dev *dev)
         dev->ibdev.dma_device = &dev->nic_info.pdev->dev;
 
         dev->ibdev.process_mad = ocrdma_process_mad;
+        dev->ibdev.get_port_immutable = ocrdma_port_immutable;
 
         if (ocrdma_get_asic_type(dev) == OCRDMA_ASIC_GEN_SKH_R) {
                 dev->ibdev.uverbs_cmd_mask |=
@@ -676,6 +711,7 @@ static void __exit ocrdma_exit_module(void)
         ocrdma_unregister_inet6addr_notifier();
         ocrdma_unregister_inetaddr_notifier();
         ocrdma_rem_debugfs();
+        idr_destroy(&ocrdma_dev_id);
 }
 
 module_init(ocrdma_init_module);
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h b/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
index 02ad0aee99af..80006b24aa11 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_sli.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_SLI_H__
 #define __OCRDMA_SLI_H__
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
index 48d7ef51aa0c..69334e214571 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
@@ -1,21 +1,36 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2014 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #include <rdma/ib_addr.h>
 #include <rdma/ib_pma.h>
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_stats.h b/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
index 091edd68a8a3..c9e58d04c7b8 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_stats.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * This file is part of the Emulex RoCE Device Driver for          *
- * RoCE (RDMA over Converged Ethernet) adapters.                   *
- * Copyright (C) 2008-2014 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_STATS_H__
 #define __OCRDMA_STATS_H__
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
index 9dcb66077d6c..bc84cd462ecf 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #include <linux/dma-mapping.h>
 #include <rdma/ib_verbs.h>
@@ -61,10 +76,14 @@ int ocrdma_query_gid(struct ib_device *ibdev, u8 port,
         return 0;
 }
 
-int ocrdma_query_device(struct ib_device *ibdev, struct ib_device_attr *attr)
+int ocrdma_query_device(struct ib_device *ibdev, struct ib_device_attr *attr,
+                        struct ib_udata *uhw)
 {
         struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         memset(attr, 0, sizeof *attr);
         memcpy(&attr->fw_ver, &dev->attr.fw_ver[0],
                min(sizeof(dev->attr.fw_ver), sizeof(attr->fw_ver)));
@@ -375,7 +394,12 @@ static struct ocrdma_pd *_ocrdma_alloc_pd(struct ocrdma_dev *dev,
 
         if (dev->pd_mgr->pd_prealloc_valid) {
                 status = ocrdma_get_pd_num(dev, pd);
-                return (status == 0) ? pd : ERR_PTR(status);
+                if (status == 0) {
+                        return pd;
+                } else {
+                        kfree(pd);
+                        return ERR_PTR(status);
+                }
         }
 
 retry:
@@ -679,7 +703,6 @@ err:
                 ocrdma_release_ucontext_pd(uctx);
         } else {
                 status = _ocrdma_dealloc_pd(dev, pd);
-                kfree(pd);
         }
 exit:
         return ERR_PTR(status);
@@ -1000,10 +1023,12 @@ err:
         return status;
 }
 
-struct ib_cq *ocrdma_create_cq(struct ib_device *ibdev, int entries, int vector,
+struct ib_cq *ocrdma_create_cq(struct ib_device *ibdev,
+                               const struct ib_cq_init_attr *attr,
                                struct ib_ucontext *ib_ctx,
                                struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct ocrdma_cq *cq;
         struct ocrdma_dev *dev = get_ocrdma_dev(ibdev);
         struct ocrdma_ucontext *uctx = NULL;
@@ -1011,6 +1036,9 @@ struct ib_cq *ocrdma_create_cq(struct ib_device *ibdev, int entries, int vector,
         int status;
         struct ocrdma_create_cq_ureq ureq;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (udata) {
                 if (ib_copy_from_udata(&ureq, udata, sizeof(ureq)))
                         return ERR_PTR(-EFAULT);
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h
index b8f7853fd36c..eaccb2d3cb9f 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.h
@@ -1,21 +1,36 @@
-/*******************************************************************
- * 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.                                     *
+/* This file is part of the Emulex RoCE Device Driver for
+ * RoCE (RDMA over Converged Ethernet) adapters.
+ * Copyright (C) 2012-2015 Emulex. All rights reserved.
+ * EMULEX and SLI are trademarks of Emulex.
+ * www.emulex.com
+ *
+ * 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 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Contact Information:
  * linux-drivers@emulex.com
@@ -23,7 +38,7 @@
  * Emulex
  * 3333 Susan Street
  * Costa Mesa, CA 92626
- *******************************************************************/
+ */
 
 #ifndef __OCRDMA_VERBS_H__
 #define __OCRDMA_VERBS_H__
@@ -36,11 +51,15 @@ int ocrdma_post_recv(struct ib_qp *, struct ib_recv_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_device(struct ib_device *, struct ib_device_attr *props,
+                        struct ib_udata *uhw);
 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);
 
+enum rdma_protocol_type
+ocrdma_query_protocol(struct ib_device *device, u8 port_num);
+
 void ocrdma_get_guid(struct ocrdma_dev *, u8 *guid);
 int ocrdma_query_gid(struct ib_device *, u8 port,
                      int index, union ib_gid *gid);
@@ -56,8 +75,10 @@ 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 *);
+struct ib_cq *ocrdma_create_cq(struct ib_device *ibdev,
+                               const struct ib_cq_init_attr *attr,
+                               struct ib_ucontext *ib_ctx,
+                               struct ib_udata *udata);
 int ocrdma_resize_cq(struct ib_cq *, int cqe, struct ib_udata *);
 int ocrdma_destroy_cq(struct ib_cq *);
 
diff --git a/drivers/infiniband/hw/qib/qib_cq.c b/drivers/infiniband/hw/qib/qib_cq.c
index ab4e11cfab15..2b45d0b02300 100644
--- a/drivers/infiniband/hw/qib/qib_cq.c
+++ b/drivers/infiniband/hw/qib/qib_cq.c
@@ -203,7 +203,7 @@ static void send_complete(struct kthread_work *work)
 /**
  * qib_create_cq - create a completion queue
  * @ibdev: the device this completion queue is attached to
- * @entries: the minimum size of the completion queue
+ * @attr: creation attributes
  * @context: unused by the QLogic_IB driver
  * @udata: user data for libibverbs.so
  *
@@ -212,16 +212,21 @@ static void send_complete(struct kthread_work *work)
  *
  * Called by ib_create_cq() in the generic verbs code.
  */
-struct ib_cq *qib_create_cq(struct ib_device *ibdev, int entries,
-                            int comp_vector, struct ib_ucontext *context,
+struct ib_cq *qib_create_cq(struct ib_device *ibdev,
+                            const struct ib_cq_init_attr *attr,
+                            struct ib_ucontext *context,
                             struct ib_udata *udata)
 {
+        int entries = attr->cqe;
         struct qib_ibdev *dev = to_idev(ibdev);
         struct qib_cq *cq;
         struct qib_cq_wc *wc;
         struct ib_cq *ret;
         u32 sz;
 
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         if (entries < 1 || entries > ib_qib_max_cqes) {
                 ret = ERR_PTR(-EINVAL);
                 goto done;
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index bdd5d3857203..13ef22bd9459 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -455,7 +455,7 @@ static int remove_file(struct dentry *parent, char *name)
         }
 
         spin_lock(&tmp->d_lock);
-        if (!d_unhashed(tmp) && d_really_is_positive(tmp)) {
+        if (simple_positive(tmp)) {
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
                 simple_unlink(d_inode(parent), tmp);
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index f32b4628e991..6c8ff10101c0 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -5502,7 +5502,8 @@ static void try_7322_ipg(struct qib_pportdata *ppd)
                 goto retry;
 
         send_buf = ib_create_send_mad(agent, 0, 0, 0, IB_MGMT_MAD_HDR,
-                                      IB_MGMT_MAD_DATA, GFP_ATOMIC);
+                                      IB_MGMT_MAD_DATA, GFP_ATOMIC,
+                                      IB_MGMT_BASE_VERSION);
         if (IS_ERR(send_buf))
                 goto retry;
 
diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
index 395f4046dba2..9625e7c438e5 100644
--- a/drivers/infiniband/hw/qib/qib_mad.c
+++ b/drivers/infiniband/hw/qib/qib_mad.c
@@ -83,7 +83,8 @@ static void qib_send_trap(struct qib_ibport *ibp, void *data, unsigned len)
                 return;
 
         send_buf = ib_create_send_mad(agent, 0, 0, 0, IB_MGMT_MAD_HDR,
-                                      IB_MGMT_MAD_DATA, GFP_ATOMIC);
+                                      IB_MGMT_MAD_DATA, GFP_ATOMIC,
+                                      IB_MGMT_BASE_VERSION);
         if (IS_ERR(send_buf))
                 return;
 
@@ -1854,7 +1855,7 @@ static int pma_set_portcounters_ext(struct ib_pma_mad *pmp,
 }
 
 static int process_subn(struct ib_device *ibdev, int mad_flags,
-                        u8 port, struct ib_mad *in_mad,
+                        u8 port, const struct ib_mad *in_mad,
                         struct ib_mad *out_mad)
 {
         struct ib_smp *smp = (struct ib_smp *)out_mad;
@@ -2006,7 +2007,7 @@ bail:
 }
 
 static int process_perf(struct ib_device *ibdev, u8 port,
-                        struct ib_mad *in_mad,
+                        const struct ib_mad *in_mad,
                         struct ib_mad *out_mad)
 {
         struct ib_pma_mad *pmp = (struct ib_pma_mad *)out_mad;
@@ -2299,7 +2300,7 @@ static int check_cc_key(struct qib_ibport *ibp,
 }
 
 static int process_cc(struct ib_device *ibdev, int mad_flags,
-                        u8 port, struct ib_mad *in_mad,
+                        u8 port, const struct ib_mad *in_mad,
                         struct ib_mad *out_mad)
 {
         struct ib_cc_mad *ccp = (struct ib_cc_mad *)out_mad;
@@ -2400,12 +2401,20 @@ bail:
  * This is called by the ib_mad module.
  */
 int qib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port,
-                    struct ib_wc *in_wc, struct ib_grh *in_grh,
-                    struct ib_mad *in_mad, struct ib_mad *out_mad)
+                    const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                    const struct ib_mad_hdr *in, size_t in_mad_size,
+                    struct ib_mad_hdr *out, size_t *out_mad_size,
+                    u16 *out_mad_pkey_index)
 {
         int ret;
         struct qib_ibport *ibp = to_iport(ibdev, port);
         struct qib_pportdata *ppd = ppd_from_ibp(ibp);
+        const struct ib_mad *in_mad = (const struct ib_mad *)in;
+        struct ib_mad *out_mad = (struct ib_mad *)out;
+
+        if (WARN_ON_ONCE(in_mad_size != sizeof(*in_mad) ||
+                         *out_mad_size != sizeof(*out_mad)))
+                return IB_MAD_RESULT_FAILURE;
 
         switch (in_mad->mad_hdr.mgmt_class) {
         case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
diff --git a/drivers/infiniband/hw/qib/qib_verbs.c b/drivers/infiniband/hw/qib/qib_verbs.c
index 4a3599890ea5..a05d1a372208 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.c
+++ b/drivers/infiniband/hw/qib/qib_verbs.c
@@ -1550,12 +1550,14 @@ full:
         }
 }
 
-static int qib_query_device(struct ib_device *ibdev,
-                            struct ib_device_attr *props)
+static int qib_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
+                            struct ib_udata *uhw)
 {
         struct qib_devdata *dd = dd_from_ibdev(ibdev);
         struct qib_ibdev *dev = to_idev(ibdev);
 
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
         memset(props, 0, sizeof(*props));
 
         props->device_cap_flags = IB_DEVICE_BAD_PKEY_CNTR |
@@ -2040,6 +2042,24 @@ static void init_ibport(struct qib_pportdata *ppd)
         RCU_INIT_POINTER(ibp->qp1, NULL);
 }
 
+static int qib_port_immutable(struct ib_device *ibdev, u8 port_num,
+                              struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = qib_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+        immutable->core_cap_flags = RDMA_CORE_PORT_IBA_IB;
+        immutable->max_mad_size = IB_MGMT_MAD_SIZE;
+
+        return 0;
+}
+
 /**
  * qib_register_ib_device - register our device with the infiniband core
  * @dd: the device data structure
@@ -2227,6 +2247,7 @@ int qib_register_ib_device(struct qib_devdata *dd)
         ibdev->process_mad = qib_process_mad;
         ibdev->mmap = qib_mmap;
         ibdev->dma_ops = &qib_dma_mapping_ops;
+        ibdev->get_port_immutable = qib_port_immutable;
 
         snprintf(ibdev->node_desc, sizeof(ibdev->node_desc),
                  "Intel Infiniband HCA %s", init_utsname()->nodename);
diff --git a/drivers/infiniband/hw/qib/qib_verbs.h b/drivers/infiniband/hw/qib/qib_verbs.h
index bfc8948fdd35..1635572752ce 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.h
+++ b/drivers/infiniband/hw/qib/qib_verbs.h
@@ -872,8 +872,10 @@ void qib_cap_mask_chg(struct qib_ibport *ibp);
 void qib_sys_guid_chg(struct qib_ibport *ibp);
 void qib_node_desc_chg(struct qib_ibport *ibp);
 int qib_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);
+                    const struct ib_wc *in_wc, const struct ib_grh *in_grh,
+                    const struct ib_mad_hdr *in, size_t in_mad_size,
+                    struct ib_mad_hdr *out, size_t *out_mad_size,
+                    u16 *out_mad_pkey_index);
 int qib_create_agents(struct qib_ibdev *dev);
 void qib_free_agents(struct qib_ibdev *dev);
 
@@ -1007,8 +1009,9 @@ void qib_cq_enter(struct qib_cq *cq, struct ib_wc *entry, int sig);
 
 int qib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry);
 
-struct ib_cq *qib_create_cq(struct ib_device *ibdev, int entries,
-                            int comp_vector, struct ib_ucontext *context,
+struct ib_cq *qib_create_cq(struct ib_device *ibdev,
+                            const struct ib_cq_init_attr *attr,
+                            struct ib_ucontext *context,
                             struct ib_udata *udata);
 
 int qib_destroy_cq(struct ib_cq *ibcq);
diff --git a/drivers/infiniband/hw/usnic/usnic_ib_main.c b/drivers/infiniband/hw/usnic/usnic_ib_main.c
index 0d0f98695d53..34c49b8105fe 100644
--- a/drivers/infiniband/hw/usnic/usnic_ib_main.c
+++ b/drivers/infiniband/hw/usnic/usnic_ib_main.c
@@ -300,6 +300,22 @@ static struct notifier_block usnic_ib_inetaddr_notifier = {
 };
 /* End of inet section*/
 
+static int usnic_port_immutable(struct ib_device *ibdev, u8 port_num,
+                                struct ib_port_immutable *immutable)
+{
+        struct ib_port_attr attr;
+        int err;
+
+        err = usnic_ib_query_port(ibdev, port_num, &attr);
+        if (err)
+                return err;
+
+        immutable->pkey_tbl_len = attr.pkey_tbl_len;
+        immutable->gid_tbl_len = attr.gid_tbl_len;
+
+        return 0;
+}
+
 /* Start of PF discovery section */
 static void *usnic_ib_device_add(struct pci_dev *dev)
 {
@@ -383,6 +399,7 @@ static void *usnic_ib_device_add(struct pci_dev *dev)
         us_ibdev->ib_dev.poll_cq = usnic_ib_poll_cq;
         us_ibdev->ib_dev.req_notify_cq = usnic_ib_req_notify_cq;
         us_ibdev->ib_dev.get_dma_mr = usnic_ib_get_dma_mr;
+        us_ibdev->ib_dev.get_port_immutable = usnic_port_immutable;
 
 
         if (ib_register_device(&us_ibdev->ib_dev, NULL))
diff --git a/drivers/infiniband/hw/usnic/usnic_ib_verbs.c b/drivers/infiniband/hw/usnic/usnic_ib_verbs.c
index 53bd6a2d9cdb..7df43827cb29 100644
--- a/drivers/infiniband/hw/usnic/usnic_ib_verbs.c
+++ b/drivers/infiniband/hw/usnic/usnic_ib_verbs.c
@@ -248,7 +248,8 @@ enum rdma_link_layer usnic_ib_port_link_layer(struct ib_device *device,
 }
 
 int usnic_ib_query_device(struct ib_device *ibdev,
-                                struct ib_device_attr *props)
+                          struct ib_device_attr *props,
+                          struct ib_udata *uhw)
 {
         struct usnic_ib_dev *us_ibdev = to_usdev(ibdev);
         union ib_gid gid;
@@ -257,6 +258,9 @@ int usnic_ib_query_device(struct ib_device *ibdev,
         int qp_per_vf;
 
         usnic_dbg("\n");
+        if (uhw->inlen || uhw->outlen)
+                return -EINVAL;
+
         mutex_lock(&us_ibdev->usdev_lock);
         us_ibdev->netdev->ethtool_ops->get_drvinfo(us_ibdev->netdev, &info);
         us_ibdev->netdev->ethtool_ops->get_settings(us_ibdev->netdev, &cmd);
@@ -570,13 +574,17 @@ int usnic_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         return status;
 }
 
-struct ib_cq *usnic_ib_create_cq(struct ib_device *ibdev, int entries,
-                                        int vector, struct ib_ucontext *context,
-                                        struct ib_udata *udata)
+struct ib_cq *usnic_ib_create_cq(struct ib_device *ibdev,
+                                 const struct ib_cq_init_attr *attr,
+                                 struct ib_ucontext *context,
+                                 struct ib_udata *udata)
 {
         struct ib_cq *cq;
 
         usnic_dbg("\n");
+        if (attr->flags)
+                return ERR_PTR(-EINVAL);
+
         cq = kzalloc(sizeof(*cq), GFP_KERNEL);
         if (!cq)
                 return ERR_PTR(-EBUSY);
diff --git a/drivers/infiniband/hw/usnic/usnic_ib_verbs.h b/drivers/infiniband/hw/usnic/usnic_ib_verbs.h
index bb864f5aed70..0bd04efa16f3 100644
--- a/drivers/infiniband/hw/usnic/usnic_ib_verbs.h
+++ b/drivers/infiniband/hw/usnic/usnic_ib_verbs.h
@@ -24,9 +24,12 @@
 enum rdma_link_layer usnic_ib_port_link_layer(struct ib_device *device,
                                                 u8 port_num);
 int usnic_ib_query_device(struct ib_device *ibdev,
-                                struct ib_device_attr *props);
+                                struct ib_device_attr *props,
+                          struct ib_udata *uhw);
 int usnic_ib_query_port(struct ib_device *ibdev, u8 port,
                                 struct ib_port_attr *props);
+enum rdma_protocol_type
+usnic_ib_query_protocol(struct ib_device *device, u8 port_num);
 int usnic_ib_query_qp(struct ib_qp *qp, struct ib_qp_attr *qp_attr,
                                 int qp_attr_mask,
                                 struct ib_qp_init_attr *qp_init_attr);
@@ -44,9 +47,10 @@ struct ib_qp *usnic_ib_create_qp(struct ib_pd *pd,
 int usnic_ib_destroy_qp(struct ib_qp *qp);
 int usnic_ib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                                 int attr_mask, struct ib_udata *udata);
-struct ib_cq *usnic_ib_create_cq(struct ib_device *ibdev, int entries,
-                                        int vector, struct ib_ucontext *context,
-                                        struct ib_udata *udata);
+struct ib_cq *usnic_ib_create_cq(struct ib_device *ibdev,
+                                 const struct ib_cq_init_attr *attr,
+                                 struct ib_ucontext *context,
+                                 struct ib_udata *udata);
 int usnic_ib_destroy_cq(struct ib_cq *cq);
 struct ib_mr *usnic_ib_reg_mr(struct ib_pd *pd, u64 start, u64 length,
                                 u64 virt_addr, int access_flags,
diff --git a/drivers/infiniband/hw/usnic/usnic_uiom.c b/drivers/infiniband/hw/usnic/usnic_uiom.c
index 417de1f32960..cb2337f0532b 100644
--- a/drivers/infiniband/hw/usnic/usnic_uiom.c
+++ b/drivers/infiniband/hw/usnic/usnic_uiom.c
@@ -472,11 +472,10 @@ struct usnic_uiom_pd *usnic_uiom_alloc_pd(void)
                 return ERR_PTR(-ENOMEM);
 
         pd->domain = domain = iommu_domain_alloc(&pci_bus_type);
-        if (IS_ERR_OR_NULL(domain)) {
-                usnic_err("Failed to allocate IOMMU domain with err %ld\n",
-                                PTR_ERR(pd->domain));
+        if (!domain) {
+                usnic_err("Failed to allocate IOMMU domain");
                 kfree(pd);
-                return ERR_PTR(domain ? PTR_ERR(domain) : -ENOMEM);
+                return ERR_PTR(-ENOMEM);
         }
 
         iommu_set_fault_handler(pd->domain, usnic_uiom_dma_fault, NULL);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib.h b/drivers/infiniband/ulp/ipoib/ipoib.h
index bd94b0a6e9e5..79859c4d43c9 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib.h
+++ b/drivers/infiniband/ulp/ipoib/ipoib.h
@@ -239,7 +239,7 @@ struct ipoib_cm_tx {
         struct net_device   *dev;
         struct ipoib_neigh  *neigh;
         struct ipoib_path   *path;
-        struct ipoib_cm_tx_buf *tx_ring;
+        struct ipoib_tx_buf *tx_ring;
         unsigned             tx_head;
         unsigned             tx_tail;
         unsigned long        flags;
@@ -504,6 +504,33 @@ int ipoib_mcast_stop_thread(struct net_device *dev);
 void ipoib_mcast_dev_down(struct net_device *dev);
 void ipoib_mcast_dev_flush(struct net_device *dev);
 
+int ipoib_dma_map_tx(struct ib_device *ca, struct ipoib_tx_buf *tx_req);
+void ipoib_dma_unmap_tx(struct ipoib_dev_priv *priv,
+                        struct ipoib_tx_buf *tx_req);
+
+static inline void ipoib_build_sge(struct ipoib_dev_priv *priv,
+                                   struct ipoib_tx_buf *tx_req)
+{
+        int i, off;
+        struct sk_buff *skb = tx_req->skb;
+        skb_frag_t *frags = skb_shinfo(skb)->frags;
+        int nr_frags = skb_shinfo(skb)->nr_frags;
+        u64 *mapping = tx_req->mapping;
+
+        if (skb_headlen(skb)) {
+                priv->tx_sge[0].addr         = mapping[0];
+                priv->tx_sge[0].length       = skb_headlen(skb);
+                off = 1;
+        } else
+                off = 0;
+
+        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_wr.num_sge          = nr_frags + off;
+}
+
 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
 struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev);
 int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter);
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
index cf32a778e7d0..ee39be6ccfb0 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
@@ -694,14 +694,12 @@ repost:
 static inline int post_send(struct ipoib_dev_priv *priv,
                             struct ipoib_cm_tx *tx,
                             unsigned int wr_id,
-                            u64 addr, int len)
+                            struct ipoib_tx_buf *tx_req)
 {
         struct ib_send_wr *bad_wr;
 
-        priv->tx_sge[0].addr          = addr;
-        priv->tx_sge[0].length        = len;
+        ipoib_build_sge(priv, tx_req);
 
-        priv->tx_wr.num_sge     = 1;
         priv->tx_wr.wr_id       = wr_id | IPOIB_OP_CM;
 
         return ib_post_send(tx->qp, &priv->tx_wr, &bad_wr);
@@ -710,8 +708,7 @@ static inline int post_send(struct ipoib_dev_priv *priv,
 void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_tx *tx)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
-        struct ipoib_cm_tx_buf *tx_req;
-        u64 addr;
+        struct ipoib_tx_buf *tx_req;
         int rc;
 
         if (unlikely(skb->len > tx->mtu)) {
@@ -735,24 +732,21 @@ void ipoib_cm_send(struct net_device *dev, struct sk_buff *skb, struct ipoib_cm_
          */
         tx_req = &tx->tx_ring[tx->tx_head & (ipoib_sendq_size - 1)];
         tx_req->skb = skb;
-        addr = ib_dma_map_single(priv->ca, skb->data, skb->len, DMA_TO_DEVICE);
-        if (unlikely(ib_dma_mapping_error(priv->ca, addr))) {
+
+        if (unlikely(ipoib_dma_map_tx(priv->ca, tx_req))) {
                 ++dev->stats.tx_errors;
                 dev_kfree_skb_any(skb);
                 return;
         }
 
-        tx_req->mapping = addr;
-
         skb_orphan(skb);
         skb_dst_drop(skb);
 
-        rc = post_send(priv, tx, tx->tx_head & (ipoib_sendq_size - 1),
-                       addr, skb->len);
+        rc = post_send(priv, tx, tx->tx_head & (ipoib_sendq_size - 1), tx_req);
         if (unlikely(rc)) {
                 ipoib_warn(priv, "post_send failed, error %d\n", rc);
                 ++dev->stats.tx_errors;
-                ib_dma_unmap_single(priv->ca, addr, skb->len, DMA_TO_DEVICE);
+                ipoib_dma_unmap_tx(priv, tx_req);
                 dev_kfree_skb_any(skb);
         } else {
                 dev->trans_start = jiffies;
@@ -777,7 +771,7 @@ void ipoib_cm_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_cm_tx *tx = wc->qp->qp_context;
         unsigned int wr_id = wc->wr_id & ~IPOIB_OP_CM;
-        struct ipoib_cm_tx_buf *tx_req;
+        struct ipoib_tx_buf *tx_req;
         unsigned long flags;
 
         ipoib_dbg_data(priv, "cm send completion: id %d, status: %d\n",
@@ -791,7 +785,7 @@ void ipoib_cm_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
 
         tx_req = &tx->tx_ring[wr_id];
 
-        ib_dma_unmap_single(priv->ca, tx_req->mapping, tx_req->skb->len, DMA_TO_DEVICE);
+        ipoib_dma_unmap_tx(priv, tx_req);
 
         /* FIXME: is this right? Shouldn't we only increment on success? */
         ++dev->stats.tx_packets;
@@ -1036,6 +1030,9 @@ static struct ib_qp *ipoib_cm_create_tx_qp(struct net_device *dev, struct ipoib_
 
         struct ib_qp *tx_qp;
 
+        if (dev->features & NETIF_F_SG)
+                attr.cap.max_send_sge = MAX_SKB_FRAGS + 1;
+
         tx_qp = ib_create_qp(priv->pd, &attr);
         if (PTR_ERR(tx_qp) == -EINVAL) {
                 ipoib_warn(priv, "can't use GFP_NOIO for QPs on device %s, using GFP_KERNEL\n",
@@ -1170,7 +1167,7 @@ err_tx:
 static void ipoib_cm_tx_destroy(struct ipoib_cm_tx *p)
 {
         struct ipoib_dev_priv *priv = netdev_priv(p->dev);
-        struct ipoib_cm_tx_buf *tx_req;
+        struct ipoib_tx_buf *tx_req;
         unsigned long begin;
 
         ipoib_dbg(priv, "Destroy active connection 0x%x head 0x%x tail 0x%x\n",
@@ -1197,8 +1194,7 @@ timeout:
 
         while ((int) p->tx_tail - (int) p->tx_head < 0) {
                 tx_req = &p->tx_ring[p->tx_tail & (ipoib_sendq_size - 1)];
-                ib_dma_unmap_single(priv->ca, tx_req->mapping, tx_req->skb->len,
-                                    DMA_TO_DEVICE);
+                ipoib_dma_unmap_tx(priv, tx_req);
                 dev_kfree_skb_any(tx_req->skb);
                 ++p->tx_tail;
                 netif_tx_lock_bh(p->dev);
@@ -1455,7 +1451,6 @@ static void ipoib_cm_stale_task(struct work_struct *work)
         spin_unlock_irq(&priv->lock);
 }
 
-
 static ssize_t show_mode(struct device *d, struct device_attribute *attr,
                          char *buf)
 {
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_ib.c b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
index 63b92cbb29ad..d266667ca9b8 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_ib.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_ib.c
@@ -263,8 +263,7 @@ repost:
                            "for buf %d\n", wr_id);
 }
 
-static int ipoib_dma_map_tx(struct ib_device *ca,
-                            struct ipoib_tx_buf *tx_req)
+int ipoib_dma_map_tx(struct ib_device *ca, struct ipoib_tx_buf *tx_req)
 {
         struct sk_buff *skb = tx_req->skb;
         u64 *mapping = tx_req->mapping;
@@ -305,8 +304,8 @@ partial_error:
         return -EIO;
 }
 
-static void ipoib_dma_unmap_tx(struct ib_device *ca,
-                               struct ipoib_tx_buf *tx_req)
+void ipoib_dma_unmap_tx(struct ipoib_dev_priv *priv,
+                        struct ipoib_tx_buf *tx_req)
 {
         struct sk_buff *skb = tx_req->skb;
         u64 *mapping = tx_req->mapping;
@@ -314,7 +313,8 @@ static void ipoib_dma_unmap_tx(struct ib_device *ca,
         int off;
 
         if (skb_headlen(skb)) {
-                ib_dma_unmap_single(ca, mapping[0], skb_headlen(skb), DMA_TO_DEVICE);
+                ib_dma_unmap_single(priv->ca, mapping[0], skb_headlen(skb),
+                                    DMA_TO_DEVICE);
                 off = 1;
         } else
                 off = 0;
@@ -322,8 +322,8 @@ static void ipoib_dma_unmap_tx(struct ib_device *ca,
         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),
-                                  DMA_TO_DEVICE);
+                ib_dma_unmap_page(priv->ca, mapping[i + off],
+                                  skb_frag_size(frag), DMA_TO_DEVICE);
         }
 }
 
@@ -389,7 +389,7 @@ static void ipoib_ib_handle_tx_wc(struct net_device *dev, struct ib_wc *wc)
 
         tx_req = &priv->tx_ring[wr_id];
 
-        ipoib_dma_unmap_tx(priv->ca, tx_req);
+        ipoib_dma_unmap_tx(priv, tx_req);
 
         ++dev->stats.tx_packets;
         dev->stats.tx_bytes += tx_req->skb->len;
@@ -514,24 +514,10 @@ static inline int post_send(struct ipoib_dev_priv *priv,
                             void *head, int hlen)
 {
         struct ib_send_wr *bad_wr;
-        int i, off;
         struct sk_buff *skb = tx_req->skb;
-        skb_frag_t *frags = skb_shinfo(skb)->frags;
-        int nr_frags = skb_shinfo(skb)->nr_frags;
-        u64 *mapping = tx_req->mapping;
 
-        if (skb_headlen(skb)) {
-                priv->tx_sge[0].addr         = mapping[0];
-                priv->tx_sge[0].length       = skb_headlen(skb);
-                off = 1;
-        } else
-                off = 0;
+        ipoib_build_sge(priv, tx_req);
 
-        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_wr.num_sge          = nr_frags + off;
         priv->tx_wr.wr_id            = wr_id;
         priv->tx_wr.wr.ud.remote_qpn = qpn;
         priv->tx_wr.wr.ud.ah         = address;
@@ -617,7 +603,7 @@ void ipoib_send(struct net_device *dev, struct sk_buff *skb,
                 ipoib_warn(priv, "post_send failed, error %d\n", rc);
                 ++dev->stats.tx_errors;
                 --priv->tx_outstanding;
-                ipoib_dma_unmap_tx(priv->ca, tx_req);
+                ipoib_dma_unmap_tx(priv, tx_req);
                 dev_kfree_skb_any(skb);
                 if (netif_queue_stopped(dev))
                         netif_wake_queue(dev);
@@ -868,7 +854,7 @@ int ipoib_ib_dev_stop(struct net_device *dev)
                         while ((int) priv->tx_tail - (int) priv->tx_head < 0) {
                                 tx_req = &priv->tx_ring[priv->tx_tail &
                                                         (ipoib_sendq_size - 1)];
-                                ipoib_dma_unmap_tx(priv->ca, tx_req);
+                                ipoib_dma_unmap_tx(priv, tx_req);
                                 dev_kfree_skb_any(tx_req->skb);
                                 ++priv->tx_tail;
                                 --priv->tx_outstanding;
@@ -985,20 +971,21 @@ static inline int update_child_pkey(struct ipoib_dev_priv *priv)
 }
 
 static void __ipoib_ib_dev_flush(struct ipoib_dev_priv *priv,
-                                enum ipoib_flush_level level)
+                                enum ipoib_flush_level level,
+                                int nesting)
 {
         struct ipoib_dev_priv *cpriv;
         struct net_device *dev = priv->dev;
         int result;
 
-        down_read(&priv->vlan_rwsem);
+        down_read_nested(&priv->vlan_rwsem, nesting);
 
         /*
          * Flush any child interfaces too -- they might be up even if
          * the parent is down.
          */
         list_for_each_entry(cpriv, &priv->child_intfs, list)
-                __ipoib_ib_dev_flush(cpriv, level);
+                __ipoib_ib_dev_flush(cpriv, level, nesting + 1);
 
         up_read(&priv->vlan_rwsem);
 
@@ -1076,7 +1063,7 @@ void ipoib_ib_dev_flush_light(struct work_struct *work)
         struct ipoib_dev_priv *priv =
                 container_of(work, struct ipoib_dev_priv, flush_light);
 
-        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_LIGHT);
+        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_LIGHT, 0);
 }
 
 void ipoib_ib_dev_flush_normal(struct work_struct *work)
@@ -1084,7 +1071,7 @@ void ipoib_ib_dev_flush_normal(struct work_struct *work)
         struct ipoib_dev_priv *priv =
                 container_of(work, struct ipoib_dev_priv, flush_normal);
 
-        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_NORMAL);
+        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_NORMAL, 0);
 }
 
 void ipoib_ib_dev_flush_heavy(struct work_struct *work)
@@ -1092,7 +1079,7 @@ void ipoib_ib_dev_flush_heavy(struct work_struct *work)
         struct ipoib_dev_priv *priv =
                 container_of(work, struct ipoib_dev_priv, flush_heavy);
 
-        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_HEAVY);
+        __ipoib_ib_dev_flush(priv, IPOIB_FLUSH_HEAVY, 0);
 }
 
 void ipoib_ib_dev_cleanup(struct net_device *dev)
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 9e1b203d756d..b2943c84a5dd 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -190,7 +190,7 @@ static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_featu
         struct ipoib_dev_priv *priv = netdev_priv(dev);
 
         if (test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags))
-                features &= ~(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+                features &= ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
 
         return features;
 }
@@ -232,6 +232,7 @@ int ipoib_set_mode(struct net_device *dev, const char *buf)
                 ipoib_warn(priv, "enabling connected mode "
                            "will cause multicast packet drops\n");
                 netdev_update_features(dev);
+                dev_set_mtu(dev, ipoib_cm_max_mtu(dev));
                 rtnl_unlock();
                 priv->tx_wr.send_flags &= ~IB_SEND_IP_CSUM;
 
@@ -1128,7 +1129,7 @@ static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv)
 {
         struct ipoib_neigh_table *ntbl = &priv->ntbl;
         struct ipoib_neigh_hash *htbl;
-        struct ipoib_neigh **buckets;
+        struct ipoib_neigh __rcu **buckets;
         u32 size;
 
         clear_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
@@ -1146,7 +1147,7 @@ static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv)
         htbl->size = size;
         htbl->mask = (size - 1);
         htbl->buckets = buckets;
-        ntbl->htbl = htbl;
+        RCU_INIT_POINTER(ntbl->htbl, htbl);
         htbl->ntbl = ntbl;
         atomic_set(&ntbl->entries, 0);
 
@@ -1577,7 +1578,8 @@ static struct net_device *ipoib_add_port(const char *format,
         SET_NETDEV_DEV(priv->dev, hca->dma_device);
         priv->dev->dev_id = port - 1;
 
-        if (!ib_query_port(hca, port, &attr))
+        result = ib_query_port(hca, port, &attr);
+        if (!result)
                 priv->max_ib_mtu = ib_mtu_enum_to_int(attr.max_mtu);
         else {
                 printk(KERN_WARNING "%s: ib_query_port %d failed\n",
@@ -1598,7 +1600,8 @@ static struct net_device *ipoib_add_port(const char *format,
                 goto device_init_failed;
         }
 
-        if (ipoib_set_dev_features(priv, hca))
+        result = ipoib_set_dev_features(priv, hca);
+        if (result)
                 goto device_init_failed;
 
         /*
@@ -1684,10 +1687,8 @@ static void ipoib_add_one(struct ib_device *device)
         struct list_head *dev_list;
         struct net_device *dev;
         struct ipoib_dev_priv *priv;
-        int s, e, p;
-
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
+        int p;
+        int count = 0;
 
         dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
         if (!dev_list)
@@ -1695,24 +1696,22 @@ static void ipoib_add_one(struct ib_device *device)
 
         INIT_LIST_HEAD(dev_list);
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
-                s = 0;
-                e = 0;
-        } else {
-                s = 1;
-                e = device->phys_port_cnt;
-        }
-
-        for (p = s; p <= e; ++p) {
-                if (rdma_port_get_link_layer(device, p) != IB_LINK_LAYER_INFINIBAND)
+        for (p = rdma_start_port(device); p <= rdma_end_port(device); ++p) {
+                if (!rdma_protocol_ib(device, p))
                         continue;
                 dev = ipoib_add_port("ib%d", device, p);
                 if (!IS_ERR(dev)) {
                         priv = netdev_priv(dev);
                         list_add_tail(&priv->list, dev_list);
+                        count++;
                 }
         }
 
+        if (!count) {
+                kfree(dev_list);
+                return;
+        }
+
         ib_set_client_data(device, &ipoib_client, dev_list);
 }
 
@@ -1721,9 +1720,6 @@ static void ipoib_remove_one(struct ib_device *device)
         struct ipoib_dev_priv *priv, *tmp;
         struct list_head *dev_list;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
-                return;
-
         dev_list = ib_get_client_data(device, &ipoib_client);
         if (!dev_list)
                 return;
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
index e5cc43074196..851c8219d501 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_verbs.c
@@ -141,6 +141,7 @@ int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca)
                 .sq_sig_type = IB_SIGNAL_ALL_WR,
                 .qp_type     = IB_QPT_UD
         };
+        struct ib_cq_init_attr cq_attr = {};
 
         int ret, size;
         int i;
@@ -176,16 +177,20 @@ int ipoib_transport_dev_init(struct net_device *dev, struct ib_device *ca)
                 else
                         size += ipoib_recvq_size * ipoib_max_conn_qp;
         } else
-                goto out_free_wq;
+                if (ret != -ENOSYS)
+                        goto out_free_wq;
 
-        priv->recv_cq = ib_create_cq(priv->ca, ipoib_ib_completion, NULL, dev, size, 0);
+        cq_attr.cqe = size;
+        priv->recv_cq = ib_create_cq(priv->ca, ipoib_ib_completion, NULL,
+                                     dev, &cq_attr);
         if (IS_ERR(priv->recv_cq)) {
                 printk(KERN_WARNING "%s: failed to create receive CQ\n", ca->name);
                 goto out_cm_dev_cleanup;
         }
 
+        cq_attr.cqe = ipoib_sendq_size;
         priv->send_cq = ib_create_cq(priv->ca, ipoib_send_comp_handler, NULL,
-                                     dev, ipoib_sendq_size, 0);
+                                     dev, &cq_attr);
         if (IS_ERR(priv->send_cq)) {
                 printk(KERN_WARNING "%s: failed to create send CQ\n", ca->name);
                 goto out_free_recv_cq;
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index cc2dd35ffbc0..5c9f565ea0e8 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -51,19 +51,22 @@ static void iser_cq_callback(struct ib_cq *cq, void *cq_context);
 
 static void iser_cq_event_callback(struct ib_event *cause, void *context)
 {
-        iser_err("got cq event %d \n", cause->event);
+        iser_err("cq event %s (%d)\n",
+                 ib_event_msg(cause->event), cause->event);
 }
 
 static void iser_qp_event_callback(struct ib_event *cause, void *context)
 {
-        iser_err("got qp event %d\n",cause->event);
+        iser_err("qp event %s (%d)\n",
+                 ib_event_msg(cause->event), cause->event);
 }
 
 static void iser_event_handler(struct ib_event_handler *handler,
                                 struct ib_event *event)
 {
-        iser_err("async event %d on device %s port %d\n", event->event,
-                event->device->name, event->element.port_num);
+        iser_err("async event %s (%d) on device %s port %d\n",
+                 ib_event_msg(event->event), event->event,
+                 event->device->name, event->element.port_num);
 }
 
 /**
@@ -123,14 +126,17 @@ static int iser_create_device_ib_res(struct iser_device *device)
                 goto pd_err;
 
         for (i = 0; i < device->comps_used; i++) {
+                struct ib_cq_init_attr cq_attr = {};
                 struct iser_comp *comp = &device->comps[i];
 
                 comp->device = device;
+                cq_attr.cqe = max_cqe;
+                cq_attr.comp_vector = i;
                 comp->cq = ib_create_cq(device->ib_device,
                                         iser_cq_callback,
                                         iser_cq_event_callback,
                                         (void *)comp,
-                                        max_cqe, i);
+                                        &cq_attr);
                 if (IS_ERR(comp->cq)) {
                         comp->cq = NULL;
                         goto cq_err;
@@ -873,8 +879,9 @@ static int iser_cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *eve
         int ret = 0;
 
         iser_conn = (struct iser_conn *)cma_id->context;
-        iser_info("event %d status %d conn %p id %p\n",
-                  event->event, event->status, cma_id->context, cma_id);
+        iser_info("%s (%d): status %d conn %p id %p\n",
+                  rdma_event_msg(event->event), event->event,
+                  event->status, cma_id->context, cma_id);
 
         mutex_lock(&iser_conn->state_mutex);
         switch (event->event) {
@@ -913,7 +920,8 @@ static int iser_cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *eve
                 }
                 break;
         default:
-                iser_err("Unexpected RDMA CM event (%d)\n", event->event);
+                iser_err("Unexpected RDMA CM event: %s (%d)\n",
+                         rdma_event_msg(event->event), event->event);
                 break;
         }
         mutex_unlock(&iser_conn->state_mutex);
@@ -1173,10 +1181,13 @@ static void iser_handle_wc(struct ib_wc *wc)
                 }
         } else {
                 if (wc->status != IB_WC_WR_FLUSH_ERR)
-                        iser_err("wr id %llx status %d vend_err %x\n",
-                                 wc->wr_id, wc->status, wc->vendor_err);
+                        iser_err("%s (%d): wr id %llx vend_err %x\n",
+                                 ib_wc_status_msg(wc->status), wc->status,
+                                 wc->wr_id, wc->vendor_err);
                 else
-                        iser_dbg("flush error: wr id %llx\n", wc->wr_id);
+                        iser_dbg("%s (%d): wr id %llx\n",
+                                 ib_wc_status_msg(wc->status), wc->status,
+                                 wc->wr_id);
 
                 if (wc->wr_id == ISER_BEACON_WRID)
                         /* all flush errors were consumed */
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index 575a072d765f..d851e1828d6f 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -80,7 +80,9 @@ isert_qp_event_callback(struct ib_event *e, void *context)
 {
         struct isert_conn *isert_conn = context;
 
-        isert_err("conn %p event: %d\n", isert_conn, e->event);
+        isert_err("%s (%d): conn %p\n",
+                  ib_event_msg(e->event), e->event, isert_conn);
+
         switch (e->event) {
         case IB_EVENT_COMM_EST:
                 rdma_notify(isert_conn->cm_id, IB_EVENT_COMM_EST);
@@ -318,15 +320,18 @@ isert_alloc_comps(struct isert_device *device,
         max_cqe = min(ISER_MAX_CQ_LEN, attr->max_cqe);
 
         for (i = 0; i < device->comps_used; i++) {
+                struct ib_cq_init_attr cq_attr = {};
                 struct isert_comp *comp = &device->comps[i];
 
                 comp->device = device;
                 INIT_WORK(&comp->work, isert_cq_work);
+                cq_attr.cqe = max_cqe;
+                cq_attr.comp_vector = i;
                 comp->cq = ib_create_cq(device->ib_device,
                                         isert_cq_callback,
                                         isert_cq_event_callback,
                                         (void *)comp,
-                                        max_cqe, i);
+                                        &cq_attr);
                 if (IS_ERR(comp->cq)) {
                         isert_err("Unable to allocate cq\n");
                         ret = PTR_ERR(comp->cq);
@@ -770,6 +775,17 @@ isert_connect_request(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
         ret = isert_rdma_post_recvl(isert_conn);
         if (ret)
                 goto out_conn_dev;
+        /*
+         * Obtain the second reference now before isert_rdma_accept() to
+         * ensure that any initiator generated REJECT CM event that occurs
+         * asynchronously won't drop the last reference until the error path
+         * in iscsi_target_login_sess_out() does it's ->iscsit_free_conn() ->
+         * isert_free_conn() -> isert_put_conn() -> kref_put().
+         */
+        if (!kref_get_unless_zero(&isert_conn->kref)) {
+                isert_warn("conn %p connect_release is running\n", isert_conn);
+                goto out_conn_dev;
+        }
 
         ret = isert_rdma_accept(isert_conn);
         if (ret)
@@ -831,11 +847,6 @@ isert_connected_handler(struct rdma_cm_id *cma_id)
 
         isert_info("conn %p\n", isert_conn);
 
-        if (!kref_get_unless_zero(&isert_conn->kref)) {
-                isert_warn("conn %p connect_release is running\n", isert_conn);
-                return;
-        }
-
         mutex_lock(&isert_conn->mutex);
         if (isert_conn->state != ISER_CONN_FULL_FEATURE)
                 isert_conn->state = ISER_CONN_UP;
@@ -900,7 +911,8 @@ static int
 isert_np_cma_handler(struct isert_np *isert_np,
                      enum rdma_cm_event_type event)
 {
-        isert_dbg("isert np %p, handling event %d\n", isert_np, event);
+        isert_dbg("%s (%d): isert np %p\n",
+                  rdma_event_msg(event), event, isert_np);
 
         switch (event) {
         case RDMA_CM_EVENT_DEVICE_REMOVAL:
@@ -974,7 +986,8 @@ isert_cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
 {
         int ret = 0;
 
-        isert_info("event %d status %d id %p np %p\n", event->event,
+        isert_info("%s (%d): status %d id %p np %p\n",
+                   rdma_event_msg(event->event), event->event,
                    event->status, cma_id, cma_id->context);
 
         switch (event->event) {
@@ -1349,7 +1362,7 @@ sequence_cmd:
         if (!rc && dump_payload == false && unsol_data)
                 iscsit_set_unsoliticed_dataout(cmd);
         else if (dump_payload && imm_data)
-                target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                target_put_sess_cmd(&cmd->se_cmd);
 
         return 0;
 }
@@ -1774,7 +1787,7 @@ isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err)
                             cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) {
                                 struct se_cmd *se_cmd = &cmd->se_cmd;
 
-                                target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                                target_put_sess_cmd(se_cmd);
                         }
                 }
 
@@ -1947,7 +1960,7 @@ isert_completion_rdma_read(struct iser_tx_desc *tx_desc,
         spin_unlock_bh(&cmd->istate_lock);
 
         if (ret) {
-                target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                target_put_sess_cmd(se_cmd);
                 transport_send_check_condition_and_sense(se_cmd,
                                                          se_cmd->pi_err, 0);
         } else {
@@ -2108,10 +2121,13 @@ isert_handle_wc(struct ib_wc *wc)
                 }
         } else {
                 if (wc->status != IB_WC_WR_FLUSH_ERR)
-                        isert_err("wr id %llx status %d vend_err %x\n",
-                                  wc->wr_id, wc->status, wc->vendor_err);
+                        isert_err("%s (%d): wr id %llx vend_err %x\n",
+                                  ib_wc_status_msg(wc->status), wc->status,
+                                  wc->wr_id, wc->vendor_err);
                 else
-                        isert_dbg("flush error: wr id %llx\n", wc->wr_id);
+                        isert_dbg("%s (%d): wr id %llx\n",
+                                  ib_wc_status_msg(wc->status), wc->status,
+                                  wc->wr_id);
 
                 if (wc->wr_id != ISER_FASTREG_LI_WRID)
                         isert_cq_comp_err(isert_conn, wc);
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 918814cd0f80..31a20b462266 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -59,9 +59,10 @@
 #define DRV_RELDATE     "July 1, 2013"
 
 MODULE_AUTHOR("Roland Dreier");
-MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator "
-                   "v" DRV_VERSION " (" DRV_RELDATE ")");
+MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator");
 MODULE_LICENSE("Dual BSD/GPL");
+MODULE_VERSION(DRV_VERSION);
+MODULE_INFO(release_date, DRV_RELDATE);
 
 static unsigned int srp_sg_tablesize;
 static unsigned int cmd_sg_entries;
@@ -98,7 +99,7 @@ module_param(register_always, bool, 0444);
 MODULE_PARM_DESC(register_always,
                  "Use memory registration even for contiguous memory regions");
 
-static struct kernel_param_ops srp_tmo_ops;
+static const struct kernel_param_ops srp_tmo_ops;
 
 static int srp_reconnect_delay = 10;
 module_param_cb(reconnect_delay, &srp_tmo_ops, &srp_reconnect_delay,
@@ -160,13 +161,10 @@ static int srp_tmo_set(const char *val, const struct kernel_param *kp)
 {
         int tmo, res;
 
-        if (strncmp(val, "off", 3) != 0) {
-                res = kstrtoint(val, 0, &tmo);
-                if (res)
-                        goto out;
-        } else {
-                tmo = -1;
-        }
+        res = srp_parse_tmo(&tmo, val);
+        if (res)
+                goto out;
+
         if (kp->arg == &srp_reconnect_delay)
                 res = srp_tmo_valid(tmo, srp_fast_io_fail_tmo,
                                     srp_dev_loss_tmo);
@@ -183,7 +181,7 @@ out:
         return res;
 }
 
-static struct kernel_param_ops srp_tmo_ops = {
+static const struct kernel_param_ops srp_tmo_ops = {
         .get = srp_tmo_get,
         .set = srp_tmo_set,
 };
@@ -253,7 +251,8 @@ 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);
+        pr_debug("QP event %s (%d)\n",
+                 ib_event_msg(event->event), event->event);
 }
 
 static int srp_init_qp(struct srp_target_port *target,
@@ -465,14 +464,13 @@ static struct srp_fr_pool *srp_alloc_fr_pool(struct srp_target_port *target)
  */
 static void srp_destroy_qp(struct srp_rdma_ch *ch)
 {
-        struct srp_target_port *target = ch->target;
         static struct ib_qp_attr attr = { .qp_state = IB_QPS_ERR };
         static struct ib_recv_wr wr = { .wr_id = SRP_LAST_WR_ID };
         struct ib_recv_wr *bad_wr;
         int ret;
 
         /* Destroying a QP and reusing ch->done is only safe if not connected */
-        WARN_ON_ONCE(target->connected);
+        WARN_ON_ONCE(ch->connected);
 
         ret = ib_modify_qp(ch->qp, &attr, IB_QP_STATE);
         WARN_ONCE(ret, "ib_cm_init_qp_attr() returned %d\n", ret);
@@ -499,6 +497,7 @@ static int srp_create_ch_ib(struct srp_rdma_ch *ch)
         struct ib_fmr_pool *fmr_pool = NULL;
         struct srp_fr_pool *fr_pool = NULL;
         const int m = 1 + dev->use_fast_reg;
+        struct ib_cq_init_attr cq_attr = {};
         int ret;
 
         init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
@@ -506,15 +505,19 @@ static int srp_create_ch_ib(struct srp_rdma_ch *ch)
                 return -ENOMEM;
 
         /* + 1 for SRP_LAST_WR_ID */
+        cq_attr.cqe = target->queue_size + 1;
+        cq_attr.comp_vector = ch->comp_vector;
         recv_cq = ib_create_cq(dev->dev, srp_recv_completion, NULL, ch,
-                               target->queue_size + 1, ch->comp_vector);
+                               &cq_attr);
         if (IS_ERR(recv_cq)) {
                 ret = PTR_ERR(recv_cq);
                 goto err;
         }
 
+        cq_attr.cqe = m * target->queue_size;
+        cq_attr.comp_vector = ch->comp_vector;
         send_cq = ib_create_cq(dev->dev, srp_send_completion, NULL, ch,
-                               m * target->queue_size, ch->comp_vector);
+                               &cq_attr);
         if (IS_ERR(send_cq)) {
                 ret = PTR_ERR(send_cq);
                 goto err_recv_cq;
@@ -781,7 +784,7 @@ static int srp_send_req(struct srp_rdma_ch *ch, bool multich)
                 shost_printk(KERN_DEBUG, target->scsi_host,
                              PFX "Topspin/Cisco initiator port ID workaround "
                              "activated for target GUID %016llx\n",
-                             (unsigned long long) be64_to_cpu(target->ioc_guid));
+                             be64_to_cpu(target->ioc_guid));
                 memset(req->priv.initiator_port_id, 0, 8);
                 memcpy(req->priv.initiator_port_id + 8,
                        &target->srp_host->srp_dev->dev->node_guid, 8);
@@ -811,35 +814,19 @@ static bool srp_queue_remove_work(struct srp_target_port *target)
         return changed;
 }
 
-static bool srp_change_conn_state(struct srp_target_port *target,
-                                  bool connected)
-{
-        bool changed = false;
-
-        spin_lock_irq(&target->lock);
-        if (target->connected != connected) {
-                target->connected = connected;
-                changed = true;
-        }
-        spin_unlock_irq(&target->lock);
-
-        return changed;
-}
-
 static void srp_disconnect_target(struct srp_target_port *target)
 {
         struct srp_rdma_ch *ch;
         int i;
 
-        if (srp_change_conn_state(target, false)) {
-                /* XXX should send SRP_I_LOGOUT request */
+        /* XXX should send SRP_I_LOGOUT request */
 
-                for (i = 0; i < target->ch_count; i++) {
-                        ch = &target->ch[i];
-                        if (ch->cm_id && ib_send_cm_dreq(ch->cm_id, NULL, 0)) {
-                                shost_printk(KERN_DEBUG, target->scsi_host,
-                                             PFX "Sending CM DREQ failed\n");
-                        }
+        for (i = 0; i < target->ch_count; i++) {
+                ch = &target->ch[i];
+                ch->connected = false;
+                if (ch->cm_id && ib_send_cm_dreq(ch->cm_id, NULL, 0)) {
+                        shost_printk(KERN_DEBUG, target->scsi_host,
+                                     PFX "Sending CM DREQ failed\n");
                 }
         }
 }
@@ -852,7 +839,7 @@ static void srp_free_req_data(struct srp_target_port *target,
         struct srp_request *req;
         int i;
 
-        if (!ch->target || !ch->req_ring)
+        if (!ch->req_ring)
                 return;
 
         for (i = 0; i < target->req_ring_size; ++i) {
@@ -986,14 +973,26 @@ static void srp_rport_delete(struct srp_rport *rport)
         srp_queue_remove_work(target);
 }
 
+/**
+ * srp_connected_ch() - number of connected channels
+ * @target: SRP target port.
+ */
+static int srp_connected_ch(struct srp_target_port *target)
+{
+        int i, c = 0;
+
+        for (i = 0; i < target->ch_count; i++)
+                c += target->ch[i].connected;
+
+        return c;
+}
+
 static int srp_connect_ch(struct srp_rdma_ch *ch, bool multich)
 {
         struct srp_target_port *target = ch->target;
         int ret;
 
-        WARN_ON_ONCE(!multich && target->connected);
-
-        target->qp_in_error = false;
+        WARN_ON_ONCE(!multich && srp_connected_ch(target) > 0);
 
         ret = srp_lookup_path(ch);
         if (ret)
@@ -1016,7 +1015,7 @@ static int srp_connect_ch(struct srp_rdma_ch *ch, bool multich)
                  */
                 switch (ch->status) {
                 case 0:
-                        srp_change_conn_state(target, true);
+                        ch->connected = true;
                         return 0;
 
                 case SRP_PORT_REDIRECT:
@@ -1214,14 +1213,10 @@ static int srp_rport_reconnect(struct srp_rport *rport)
          */
         for (i = 0; i < target->ch_count; i++) {
                 ch = &target->ch[i];
-                if (!ch->target)
-                        break;
                 ret += srp_new_cm_id(ch);
         }
         for (i = 0; i < target->ch_count; i++) {
                 ch = &target->ch[i];
-                if (!ch->target)
-                        break;
                 for (j = 0; j < target->req_ring_size; ++j) {
                         struct srp_request *req = &ch->req_ring[j];
 
@@ -1230,8 +1225,6 @@ static int srp_rport_reconnect(struct srp_rport *rport)
         }
         for (i = 0; i < target->ch_count; i++) {
                 ch = &target->ch[i];
-                if (!ch->target)
-                        break;
                 /*
                  * Whether or not creating a new CM ID succeeded, create a new
                  * QP. This guarantees that all completion callback function
@@ -1243,13 +1236,13 @@ static int srp_rport_reconnect(struct srp_rport *rport)
                 for (j = 0; j < target->queue_size; ++j)
                         list_add(&ch->tx_ring[j]->list, &ch->free_tx);
         }
+
+        target->qp_in_error = false;
+
         for (i = 0; i < target->ch_count; i++) {
                 ch = &target->ch[i];
-                if (ret || !ch->target) {
-                        if (i > 1)
-                                ret = 0;
+                if (ret)
                         break;
-                }
                 ret = srp_connect_ch(ch, multich);
                 multich = true;
         }
@@ -1842,7 +1835,7 @@ static void srp_process_aer_req(struct srp_rdma_ch *ch,
         s32 delta = be32_to_cpu(req->req_lim_delta);
 
         shost_printk(KERN_ERR, target->scsi_host, PFX
-                     "ignoring AER for LUN %llu\n", be64_to_cpu(req->lun));
+                     "ignoring AER for LUN %llu\n", scsilun_to_int(&req->lun));
 
         if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
                 shost_printk(KERN_ERR, target->scsi_host, PFX
@@ -1929,20 +1922,21 @@ static void srp_handle_qp_err(u64 wr_id, enum ib_wc_status wc_status,
                 return;
         }
 
-        if (target->connected && !target->qp_in_error) {
+        if (ch->connected && !target->qp_in_error) {
                 if (wr_id & LOCAL_INV_WR_ID_MASK) {
                         shost_printk(KERN_ERR, target->scsi_host, PFX
-                                     "LOCAL_INV failed with status %d\n",
-                                     wc_status);
+                                     "LOCAL_INV failed with status %s (%d)\n",
+                                     ib_wc_status_msg(wc_status), wc_status);
                 } else if (wr_id & FAST_REG_WR_ID_MASK) {
                         shost_printk(KERN_ERR, target->scsi_host, PFX
-                                     "FAST_REG_MR failed status %d\n",
-                                     wc_status);
+                                     "FAST_REG_MR failed status %s (%d)\n",
+                                     ib_wc_status_msg(wc_status), wc_status);
                 } else {
                         shost_printk(KERN_ERR, target->scsi_host,
-                                     PFX "failed %s status %d for iu %p\n",
+                                     PFX "failed %s status %s (%d) for iu %p\n",
                                      send_err ? "send" : "receive",
-                                     wc_status, (void *)(uintptr_t)wr_id);
+                                     ib_wc_status_msg(wc_status), wc_status,
+                                     (void *)(uintptr_t)wr_id);
                 }
                 queue_work(system_long_wq, &target->tl_err_work);
         }
@@ -2034,7 +2028,7 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         memset(cmd, 0, sizeof *cmd);
 
         cmd->opcode = SRP_CMD;
-        cmd->lun    = cpu_to_be64((u64) scmnd->device->lun << 48);
+        int_to_scsilun(scmnd->device->lun, &cmd->lun);
         cmd->tag    = tag;
         memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
 
@@ -2367,7 +2361,7 @@ 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);
+                ch->connected = false;
                 if (ib_send_cm_drep(cm_id, NULL, 0))
                         shost_printk(KERN_ERR, target->scsi_host,
                                      PFX "Sending CM DREP failed\n");
@@ -2414,8 +2408,8 @@ srp_change_queue_depth(struct scsi_device *sdev, int qdepth)
         return scsi_change_queue_depth(sdev, qdepth);
 }
 
-static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag,
-                             unsigned int lun, u8 func)
+static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag, u64 lun,
+                             u8 func)
 {
         struct srp_target_port *target = ch->target;
         struct srp_rport *rport = target->rport;
@@ -2423,7 +2417,7 @@ static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag,
         struct srp_iu *iu;
         struct srp_tsk_mgmt *tsk_mgmt;
 
-        if (!target->connected || target->qp_in_error)
+        if (!ch->connected || target->qp_in_error)
                 return -1;
 
         init_completion(&ch->tsk_mgmt_done);
@@ -2449,7 +2443,7 @@ static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag,
         memset(tsk_mgmt, 0, sizeof *tsk_mgmt);
 
         tsk_mgmt->opcode        = SRP_TSK_MGMT;
-        tsk_mgmt->lun           = cpu_to_be64((u64) lun << 48);
+        int_to_scsilun(lun, &tsk_mgmt->lun);
         tsk_mgmt->tag           = req_tag | SRP_TAG_TSK_MGMT;
         tsk_mgmt->tsk_mgmt_func = func;
         tsk_mgmt->task_tag      = req_tag;
@@ -2563,8 +2557,7 @@ static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "0x%016llx\n",
-                       (unsigned long long) be64_to_cpu(target->id_ext));
+        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->id_ext));
 }
 
 static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
@@ -2572,8 +2565,7 @@ 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));
 
-        return sprintf(buf, "0x%016llx\n",
-                       (unsigned long long) be64_to_cpu(target->ioc_guid));
+        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->ioc_guid));
 }
 
 static ssize_t show_service_id(struct device *dev,
@@ -2581,8 +2573,7 @@ static ssize_t show_service_id(struct device *dev,
 {
         struct srp_target_port *target = host_to_target(class_to_shost(dev));
 
-        return sprintf(buf, "0x%016llx\n",
-                       (unsigned long long) be64_to_cpu(target->service_id));
+        return sprintf(buf, "0x%016llx\n", be64_to_cpu(target->service_id));
 }
 
 static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
@@ -2773,7 +2764,7 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
 
         target->state = SRP_TARGET_SCANNING;
         sprintf(target->target_name, "SRP.T10:%016llX",
-                 (unsigned long long) be64_to_cpu(target->id_ext));
+                be64_to_cpu(target->id_ext));
 
         if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
                 return -ENODEV;
@@ -2797,7 +2788,8 @@ static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
         scsi_scan_target(&target->scsi_host->shost_gendev,
                          0, target->scsi_id, SCAN_WILD_CARD, 0);
 
-        if (!target->connected || target->qp_in_error) {
+        if (srp_connected_ch(target) < target->ch_count ||
+            target->qp_in_error) {
                 shost_printk(KERN_INFO, target->scsi_host,
                              PFX "SCSI scan failed - removing SCSI host\n");
                 srp_queue_remove_work(target);
@@ -3146,7 +3138,7 @@ static ssize_t srp_create_target(struct device *dev,
         target_host->transportt  = ib_srp_transport_template;
         target_host->max_channel = 0;
         target_host->max_id      = 1;
-        target_host->max_lun     = SRP_MAX_LUN;
+        target_host->max_lun     = -1LL;
         target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb;
 
         target = host_to_target(target_host);
@@ -3172,11 +3164,11 @@ static ssize_t srp_create_target(struct device *dev,
 
         ret = srp_parse_options(buf, target);
         if (ret)
-                goto err;
+                goto out;
 
         ret = scsi_init_shared_tag_map(target_host, target_host->can_queue);
         if (ret)
-                goto err;
+                goto out;
 
         target->req_ring_size = target->queue_size - SRP_TSK_MGMT_SQ_SIZE;
 
@@ -3187,7 +3179,7 @@ static ssize_t srp_create_target(struct device *dev,
                              be64_to_cpu(target->ioc_guid),
                              be64_to_cpu(target->initiator_ext));
                 ret = -EEXIST;
-                goto err;
+                goto out;
         }
 
         if (!srp_dev->has_fmr && !srp_dev->has_fr && !target->allow_ext_sg &&
@@ -3208,7 +3200,7 @@ static ssize_t srp_create_target(struct device *dev,
         spin_lock_init(&target->lock);
         ret = ib_query_gid(ibdev, host->port, 0, &target->sgid);
         if (ret)
-                goto err;
+                goto out;
 
         ret = -ENOMEM;
         target->ch_count = max_t(unsigned, num_online_nodes(),
@@ -3219,7 +3211,7 @@ static ssize_t srp_create_target(struct device *dev,
         target->ch = kcalloc(target->ch_count, sizeof(*target->ch),
                              GFP_KERNEL);
         if (!target->ch)
-                goto err;
+                goto out;
 
         node_idx = 0;
         for_each_online_node(node) {
@@ -3315,9 +3307,6 @@ err_disconnect:
         }
 
         kfree(target->ch);
-
-err:
-        scsi_host_put(target_host);
         goto out;
 }
 
@@ -3387,7 +3376,7 @@ static void srp_add_one(struct ib_device *device)
         struct srp_device *srp_dev;
         struct ib_device_attr *dev_attr;
         struct srp_host *host;
-        int mr_page_shift, s, e, p;
+        int mr_page_shift, p;
         u64 max_pages_per_mr;
 
         dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
@@ -3451,15 +3440,7 @@ static void srp_add_one(struct ib_device *device)
         if (IS_ERR(srp_dev->mr))
                 goto err_pd;
 
-        if (device->node_type == RDMA_NODE_IB_SWITCH) {
-                s = 0;
-                e = 0;
-        } else {
-                s = 1;
-                e = device->phys_port_cnt;
-        }
-
-        for (p = s; p <= e; ++p) {
+        for (p = rdma_start_port(device); p <= rdma_end_port(device); ++p) {
                 host = srp_add_port(srp_dev, p);
                 if (host)
                         list_add_tail(&host->list, &srp_dev->dev_list);
diff --git a/drivers/infiniband/ulp/srp/ib_srp.h b/drivers/infiniband/ulp/srp/ib_srp.h
index a611556406ac..17ee3f80ba55 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.h
+++ b/drivers/infiniband/ulp/srp/ib_srp.h
@@ -54,7 +54,6 @@ enum {
         SRP_DLID_REDIRECT       = 2,
         SRP_STALE_CONN          = 3,
 
-        SRP_MAX_LUN             = 512,
         SRP_DEF_SG_TABLESIZE    = 12,
 
         SRP_DEFAULT_QUEUE_SIZE  = 1 << 6,
@@ -170,6 +169,7 @@ struct srp_rdma_ch {
 
         struct completion       tsk_mgmt_done;
         u8                      tsk_mgmt_status;
+        bool                    connected;
 };
 
 /**
@@ -214,7 +214,6 @@ struct srp_target_port {
         __be16                  pkey;
 
         u32                     rq_tmo_jiffies;
-        bool                    connected;
 
         int                     zero_req_lim;
 
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index 9b84b4c0a000..60ff0a2390e5 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -41,12 +41,12 @@
 #include <linux/string.h>
 #include <linux/delay.h>
 #include <linux/atomic.h>
+#include <scsi/scsi_proto.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. */
@@ -93,7 +93,6 @@ MODULE_PARM_DESC(srpt_service_guid,
                  " instead of using the node_guid of the first HCA.");
 
 static struct ib_client srpt_client;
-static const struct target_core_fabric_ops srpt_template;
 static void srpt_release_channel(struct srpt_rdma_ch *ch);
 static int srpt_queue_status(struct se_cmd *cmd);
 
@@ -303,7 +302,7 @@ static void srpt_get_iou(struct ib_dm_mad *mad)
         int i;
 
         ioui = (struct ib_dm_iou_info *)mad->data;
-        ioui->change_id = __constant_cpu_to_be16(1);
+        ioui->change_id = cpu_to_be16(1);
         ioui->max_controllers = 16;
 
         /* set present for slot 1 and empty for the rest */
@@ -331,13 +330,13 @@ static void srpt_get_ioc(struct srpt_port *sport, u32 slot,
 
         if (!slot || slot > 16) {
                 mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
+                        = 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);
+                        = cpu_to_be16(DM_MAD_STATUS_NO_IOC);
                 return;
         }
 
@@ -349,10 +348,10 @@ static void srpt_get_ioc(struct srpt_port *sport, u32 slot,
         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->io_class = cpu_to_be16(SRP_REV16A_IB_IO_CLASS);
+        iocp->io_subclass = cpu_to_be16(SRP_IO_SUBCLASS);
+        iocp->protocol = cpu_to_be16(SRP_PROTOCOL);
+        iocp->protocol_version = 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);
@@ -380,13 +379,13 @@ static void srpt_get_svc_entries(u64 ioc_guid,
 
         if (!slot || slot > 16) {
                 mad->mad_hdr.status
-                        = __constant_cpu_to_be16(DM_MAD_STATUS_INVALID_FIELD);
+                        = 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);
+                        = cpu_to_be16(DM_MAD_STATUS_NO_IOC);
                 return;
         }
 
@@ -437,7 +436,7 @@ static void srpt_mgmt_method_get(struct srpt_port *sp, struct ib_mad *rq_mad,
                 break;
         default:
                 rsp_mad->mad_hdr.status =
-                    __constant_cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
+                    cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
                 break;
         }
 }
@@ -476,7 +475,8 @@ static void srpt_mad_recv_handler(struct ib_mad_agent *mad_agent,
         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);
+                                 GFP_KERNEL,
+                                 IB_MGMT_BASE_VERSION);
         if (IS_ERR(rsp))
                 goto err_rsp;
 
@@ -493,11 +493,11 @@ static void srpt_mad_recv_handler(struct ib_mad_agent *mad_agent,
                 break;
         case IB_MGMT_METHOD_SET:
                 dm_mad->mad_hdr.status =
-                    __constant_cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD_ATTR);
+                    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);
+                    cpu_to_be16(DM_MAD_STATUS_UNSUP_METHOD);
                 break;
         }
 
@@ -1334,12 +1334,12 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
 
                 BUG_ON(ch->sess == NULL);
 
-                target_put_sess_cmd(ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&ioctx->cmd);
                 goto out;
         }
 
         pr_debug("Aborting cmd with state %d and tag %lld\n", state,
-                 ioctx->tag);
+                 ioctx->cmd.tag);
 
         switch (state) {
         case SRPT_STATE_NEW:
@@ -1365,11 +1365,11 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
                  * not been received in time.
                  */
                 srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&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);
+                target_put_sess_cmd(&ioctx->cmd);
                 break;
         default:
                 WARN(1, "Unexpected command state (%d)", state);
@@ -1387,7 +1387,6 @@ 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);
@@ -1395,7 +1394,6 @@ static void srpt_handle_send_err_comp(struct srpt_rdma_ch *ch, u64 wr_id)
         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
@@ -1472,10 +1470,8 @@ 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;
 
-        cmd = &ioctx->cmd;
         state = srpt_get_cmd_state(ioctx);
         switch (opcode) {
         case SRPT_RDMA_READ_LAST:
@@ -1539,7 +1535,7 @@ static int srpt_build_cmd_rsp(struct srpt_rdma_ch *ch,
         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));
+                cpu_to_be32(1 + atomic_xchg(&ch->req_lim_delta, 0));
         srp_rsp->tag = tag;
         srp_rsp->status = status;
 
@@ -1589,8 +1585,8 @@ static int srpt_build_tskmgmt_rsp(struct srpt_rdma_ch *ch,
         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->req_lim_delta =
+                cpu_to_be32(1 + atomic_xchg(&ch->req_lim_delta, 0));
         srp_rsp->tag = tag;
 
         srp_rsp->flags |= SRP_RSP_FLAG_RSPVALID;
@@ -1634,7 +1630,7 @@ static uint64_t srpt_unpack_lun(const uint8_t *lun, int len)
         switch (len) {
         case 8:
                 if ((*((__be64 *)lun) &
-                     __constant_cpu_to_be64(0x0000FFFFFFFFFFFFLL)) != 0)
+                     cpu_to_be64(0x0000FFFFFFFFFFFFLL)) != 0)
                         goto out_err;
                 break;
         case 4:
@@ -1679,7 +1675,7 @@ 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);
+        return target_put_sess_cmd(&ioctx->cmd);
 }
 
 /**
@@ -1701,7 +1697,7 @@ static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
 
         srp_cmd = recv_ioctx->ioctx.buf;
         cmd = &send_ioctx->cmd;
-        send_ioctx->tag = srp_cmd->tag;
+        cmd->tag = srp_cmd->tag;
 
         switch (srp_cmd->task_attr) {
         case SRP_CMD_SIMPLE_Q:
@@ -1772,7 +1768,7 @@ static int srpt_rx_mgmt_fn_tag(struct srpt_send_ioctx *ioctx, u64 tag)
         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 &&
+                    target->cmd.tag == tag &&
                     srpt_get_cmd_state(target) != SRPT_STATE_DONE) {
                         ret = 0;
                         /* now let the target core abort &target->cmd; */
@@ -1831,7 +1827,7 @@ static void srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch,
                  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;
+        send_ioctx->cmd.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 =
@@ -2080,6 +2076,7 @@ static int srpt_create_ch_ib(struct srpt_rdma_ch *ch)
         struct srpt_port *sport = ch->sport;
         struct srpt_device *sdev = sport->sdev;
         u32 srp_sq_size = sport->port_attrib.srp_sq_size;
+        struct ib_cq_init_attr cq_attr = {};
         int ret;
 
         WARN_ON(ch->rq_size < 1);
@@ -2090,8 +2087,9 @@ static int srpt_create_ch_ib(struct srpt_rdma_ch *ch)
                 goto out;
 
 retry:
+        cq_attr.cqe = ch->rq_size + srp_sq_size;
         ch->cq = ib_create_cq(sdev->device, srpt_completion, NULL, ch,
-                              ch->rq_size + srp_sq_size, 0);
+                              &cq_attr);
         if (IS_ERR(ch->cq)) {
                 ret = PTR_ERR(ch->cq);
                 pr_err("failed to create CQ cqe= %d ret= %d\n",
@@ -2176,12 +2174,9 @@ static void srpt_destroy_ch_ib(struct srpt_rdma_ch *ch)
  */
 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) {
@@ -2454,8 +2449,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         }
 
         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);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE);
                 ret = -EINVAL;
                 pr_err("rejected SRP_LOGIN_REQ because its"
                        " length (%d bytes) is out of range (%d .. %d)\n",
@@ -2464,8 +2459,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         }
 
         if (!sport->enabled) {
-                rej->reason = __constant_cpu_to_be32(
-                             SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
                 ret = -EINVAL;
                 pr_err("rejected SRP_LOGIN_REQ because the target port"
                        " has not yet been enabled\n");
@@ -2510,8 +2505,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         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);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL);
                 ret = -ENOMEM;
                 pr_err("rejected SRP_LOGIN_REQ because it"
                        " has an invalid target port identifier.\n");
@@ -2520,8 +2515,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
 
         ch = kzalloc(sizeof *ch, GFP_KERNEL);
         if (!ch) {
-                rej->reason = __constant_cpu_to_be32(
-                                        SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
                 pr_err("rejected SRP_LOGIN_REQ because no memory.\n");
                 ret = -ENOMEM;
                 goto reject;
@@ -2557,8 +2552,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
 
         ret = srpt_create_ch_ib(ch);
         if (ret) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
                 pr_err("rejected SRP_LOGIN_REQ because creating"
                        " a new RDMA channel failed.\n");
                 goto free_ring;
@@ -2566,8 +2561,7 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
 
         ret = srpt_ch_qp_rtr(ch, ch->qp);
         if (ret) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
+                rej->reason = cpu_to_be32(SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
                 pr_err("rejected SRP_LOGIN_REQ because enabling"
                        " RTR failed (error code = %d)\n", ret);
                 goto destroy_ib;
@@ -2585,15 +2579,15 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         if (!nacl) {
                 pr_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);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED);
                 goto destroy_ib;
         }
 
         ch->sess = transport_init_session(TARGET_PROT_NORMAL);
         if (IS_ERR(ch->sess)) {
-                rej->reason = __constant_cpu_to_be32(
-                                SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
+                rej->reason = cpu_to_be32(
+                              SRP_LOGIN_REJ_INSUFFICIENT_RESOURCES);
                 pr_debug("Failed to create session\n");
                 goto deregister_session;
         }
@@ -2609,8 +2603,8 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         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->buf_fmt = 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);
@@ -2660,8 +2654,8 @@ free_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);
+        rej->buf_fmt = 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);
@@ -2979,7 +2973,7 @@ static int srpt_write_pending(struct se_cmd *se_cmd)
         case CH_DRAINING:
         case CH_RELEASING:
                 pr_debug("cmd with tag %lld: channel disconnecting\n",
-                         ioctx->tag);
+                         ioctx->cmd.tag);
                 srpt_set_cmd_state(ioctx, SRPT_STATE_DATA_IN);
                 ret = -EINVAL;
                 goto out;
@@ -3054,27 +3048,27 @@ static void srpt_queue_response(struct se_cmd *cmd)
                 ret = srpt_xfer_data(ch, ioctx);
                 if (ret) {
                         pr_err("xfer_data failed for tag %llu\n",
-                               ioctx->tag);
+                               ioctx->cmd.tag);
                         return;
                 }
         }
 
         if (state != SRPT_STATE_MGMT)
-                resp_len = srpt_build_cmd_rsp(ch, ioctx, ioctx->tag,
+                resp_len = srpt_build_cmd_rsp(ch, ioctx, ioctx->cmd.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);
+                                                 ioctx->cmd.tag);
         }
         ret = srpt_post_send(ch, ioctx, resp_len);
         if (ret) {
                 pr_err("sending cmd response failed for tag %llu\n",
-                       ioctx->tag);
+                       ioctx->cmd.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);
+                target_put_sess_cmd(&ioctx->cmd);
         }
 }
 
@@ -3394,11 +3388,6 @@ 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);
@@ -3411,69 +3400,6 @@ 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) {
-                pr_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;
@@ -3547,14 +3473,6 @@ 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)
 {
@@ -3597,40 +3515,19 @@ out:
  * 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)
+static int srpt_init_nodeacl(struct se_node_acl *se_nacl, 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;
+        struct srpt_port *sport =
+                container_of(se_nacl->se_tpg, struct srpt_port, port_tpg_1);
+        struct srpt_node_acl *nacl =
+                container_of(se_nacl, struct srpt_node_acl, nacl);
         u8 i_port_id[16];
 
         if (srpt_parse_i_port_id(i_port_id, name) < 0) {
                 pr_err("invalid initiator port ID %s\n", name);
-                ret = -EINVAL;
-                goto err;
+                return -EINVAL;
         }
 
-        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;
 
@@ -3638,29 +3535,22 @@ static struct se_node_acl *srpt_make_nodeacl(struct se_portal_group *tpg,
         list_add_tail(&nacl->list, &sport->port_acl_list);
         spin_unlock_irq(&sport->port_acl_lock);
 
-        return se_nacl;
-err:
-        return ERR_PTR(ret);
+        return 0;
 }
 
 /*
  * 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)
+static void srpt_cleanup_nodeacl(struct se_node_acl *se_nacl)
 {
-        struct srpt_node_acl *nacl;
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
+        struct srpt_node_acl *nacl =
+                container_of(se_nacl, struct srpt_node_acl, nacl);
+        struct srpt_port *sport = nacl->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(
@@ -3845,8 +3735,7 @@ static struct se_portal_group *srpt_make_tpg(struct se_wwn *wwn,
         int res;
 
         /* Initialize sport->port_wwn and sport->port_tpg_1 */
-        res = core_tpg_register(&srpt_template, &sport->port_wwn,
-                        &sport->port_tpg_1, sport, TRANSPORT_TPG_TYPE_NORMAL);
+        res = core_tpg_register(&sport->port_wwn, &sport->port_tpg_1, SCSI_PROTOCOL_SRP);
         if (res)
                 return ERR_PTR(res);
 
@@ -3916,20 +3805,14 @@ static struct configfs_attribute *srpt_wwn_attrs[] = {
 static const struct target_core_fabric_ops srpt_template = {
         .module                         = THIS_MODULE,
         .name                           = "srpt",
+        .node_acl_size                  = sizeof(struct srpt_node_acl),
         .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,
@@ -3940,7 +3823,6 @@ static const struct target_core_fabric_ops srpt_template = {
         .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_data_in,
         .queue_status                   = srpt_queue_status,
@@ -3954,12 +3836,8 @@ static const struct target_core_fabric_ops srpt_template = {
         .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,
+        .fabric_init_nodeacl            = srpt_init_nodeacl,
+        .fabric_cleanup_nodeacl         = srpt_cleanup_nodeacl,
 
         .tfc_wwn_attrs                  = srpt_wwn_attrs,
         .tfc_tpg_base_attrs             = srpt_tpg_attrs,
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
index 3dae156905de..21f8df67522a 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.h
@@ -238,14 +238,13 @@ struct srpt_send_ioctx {
         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];
+        u8                      sense_data[TRANSPORT_SENSE_BUFFER];
 };
 
 /**
@@ -410,34 +409,16 @@ struct srpt_device {
 
 /**
  * struct srpt_node_acl - Per-initiator ACL data (managed via configfs).
+ * @nacl:      Target core node ACL information.
  * @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 {
+        struct se_node_acl      nacl;
         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 */