4 files changed, 324 insertions, 22 deletions

diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index bf218d9ec089..c2702f549f10 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -57,6 +57,7 @@
 #define DRV_RELDATE     "April 4, 2008"
 
 #define MLX4_IB_FLOW_MAX_PRIO 0xFFF
+#define MLX4_IB_FLOW_QPN_MASK 0xFFFFFF
 
 MODULE_AUTHOR("Roland Dreier");
 MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
@@ -94,21 +95,27 @@ static union ib_gid zgid;
 
 static int check_flow_steering_support(struct mlx4_dev *dev)
 {
+        int eth_num_ports = 0;
         int ib_num_ports = 0;
-        int i;
-
-        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
-                ib_num_ports++;
 
-        if (dev->caps.steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
-                if (ib_num_ports || mlx4_is_mfunc(dev)) {
-                        pr_warn("Device managed flow steering is unavailable "
-                                "for IB ports or in multifunction env.\n");
-                        return 0;
+        int dmfs = dev->caps.steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED;
+
+        if (dmfs) {
+                int i;
+                mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_ETH)
+                        eth_num_ports++;
+                mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
+                        ib_num_ports++;
+                dmfs &= (!ib_num_ports ||
+                         (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_DMFS_IPOIB)) &&
+                        (!eth_num_ports ||
+                         (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_FS_EN));
+                if (ib_num_ports && mlx4_is_mfunc(dev)) {
+                        pr_warn("Device managed flow steering is unavailable for IB port in multifunction env.\n");
+                        dmfs = 0;
                 }
-                return 1;
         }
-        return 0;
+        return dmfs;
 }
 
 static int mlx4_ib_query_device(struct ib_device *ibdev,
@@ -167,7 +174,7 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
                         props->device_cap_flags |= IB_DEVICE_MEM_WINDOW_TYPE_2B;
                 else
                         props->device_cap_flags |= IB_DEVICE_MEM_WINDOW_TYPE_2A;
-        if (check_flow_steering_support(dev->dev))
+        if (dev->steering_support ==  MLX4_STEERING_MODE_DEVICE_MANAGED)
                 props->device_cap_flags |= IB_DEVICE_MANAGED_FLOW_STEERING;
         }
 
@@ -816,6 +823,7 @@ struct mlx4_ib_steering {
 };
 
 static int parse_flow_attr(struct mlx4_dev *dev,
+                           u32 qp_num,
                            union ib_flow_spec *ib_spec,
                            struct _rule_hw *mlx4_spec)
 {
@@ -831,6 +839,14 @@ static int parse_flow_attr(struct mlx4_dev *dev,
                 mlx4_spec->eth.vlan_tag = ib_spec->eth.val.vlan_tag;
                 mlx4_spec->eth.vlan_tag_msk = ib_spec->eth.mask.vlan_tag;
                 break;
+        case IB_FLOW_SPEC_IB:
+                type = MLX4_NET_TRANS_RULE_ID_IB;
+                mlx4_spec->ib.l3_qpn =
+                        cpu_to_be32(qp_num);
+                mlx4_spec->ib.qpn_mask =
+                        cpu_to_be32(MLX4_IB_FLOW_QPN_MASK);
+                break;
+
 
         case IB_FLOW_SPEC_IPV4:
                 type = MLX4_NET_TRANS_RULE_ID_IPV4;
@@ -862,6 +878,115 @@ static int parse_flow_attr(struct mlx4_dev *dev,
         return mlx4_hw_rule_sz(dev, type);
 }
 
+struct default_rules {
+        __u32 mandatory_fields[IB_FLOW_SPEC_SUPPORT_LAYERS];
+        __u32 mandatory_not_fields[IB_FLOW_SPEC_SUPPORT_LAYERS];
+        __u32 rules_create_list[IB_FLOW_SPEC_SUPPORT_LAYERS];
+        __u8  link_layer;
+};
+static const struct default_rules default_table[] = {
+        {
+                .mandatory_fields = {IB_FLOW_SPEC_IPV4},
+                .mandatory_not_fields = {IB_FLOW_SPEC_ETH},
+                .rules_create_list = {IB_FLOW_SPEC_IB},
+                .link_layer = IB_LINK_LAYER_INFINIBAND
+        }
+};
+
+static int __mlx4_ib_default_rules_match(struct ib_qp *qp,
+                                         struct ib_flow_attr *flow_attr)
+{
+        int i, j, k;
+        void *ib_flow;
+        const struct default_rules *pdefault_rules = default_table;
+        u8 link_layer = rdma_port_get_link_layer(qp->device, flow_attr->port);
+
+        for (i = 0; i < sizeof(default_table)/sizeof(default_table[0]); i++,
+             pdefault_rules++) {
+                __u32 field_types[IB_FLOW_SPEC_SUPPORT_LAYERS];
+                memset(&field_types, 0, sizeof(field_types));
+
+                if (link_layer != pdefault_rules->link_layer)
+                        continue;
+
+                ib_flow = flow_attr + 1;
+                /* we assume the specs are sorted */
+                for (j = 0, k = 0; k < IB_FLOW_SPEC_SUPPORT_LAYERS &&
+                     j < flow_attr->num_of_specs; k++) {
+                        union ib_flow_spec *current_flow =
+                                (union ib_flow_spec *)ib_flow;
+
+                        /* same layer but different type */
+                        if (((current_flow->type & IB_FLOW_SPEC_LAYER_MASK) ==
+                             (pdefault_rules->mandatory_fields[k] &
+                              IB_FLOW_SPEC_LAYER_MASK)) &&
+                            (current_flow->type !=
+                             pdefault_rules->mandatory_fields[k]))
+                                goto out;
+
+                        /* same layer, try match next one */
+                        if (current_flow->type ==
+                            pdefault_rules->mandatory_fields[k]) {
+                                j++;
+                                ib_flow +=
+                                        ((union ib_flow_spec *)ib_flow)->size;
+                        }
+                }
+
+                ib_flow = flow_attr + 1;
+                for (j = 0; j < flow_attr->num_of_specs;
+                     j++, ib_flow += ((union ib_flow_spec *)ib_flow)->size)
+                        for (k = 0; k < IB_FLOW_SPEC_SUPPORT_LAYERS; k++)
+                                /* same layer and same type */
+                                if (((union ib_flow_spec *)ib_flow)->type ==
+                                    pdefault_rules->mandatory_not_fields[k])
+                                        goto out;
+
+                return i;
+        }
+out:
+        return -1;
+}
+
+static int __mlx4_ib_create_default_rules(
+                struct mlx4_ib_dev *mdev,
+                struct ib_qp *qp,
+                const struct default_rules *pdefault_rules,
+                struct _rule_hw *mlx4_spec) {
+        int size = 0;
+        int i;
+
+        for (i = 0; i < sizeof(pdefault_rules->rules_create_list)/
+                        sizeof(pdefault_rules->rules_create_list[0]); i++) {
+                int ret;
+                union ib_flow_spec ib_spec;
+                switch (pdefault_rules->rules_create_list[i]) {
+                case 0:
+                        /* no rule */
+                        continue;
+                case IB_FLOW_SPEC_IB:
+                        ib_spec.type = IB_FLOW_SPEC_IB;
+                        ib_spec.size = sizeof(struct ib_flow_spec_ib);
+
+                        break;
+                default:
+                        /* invalid rule */
+                        return -EINVAL;
+                }
+                /* We must put empty rule, qpn is being ignored */
+                ret = parse_flow_attr(mdev->dev, 0, &ib_spec,
+                                      mlx4_spec);
+                if (ret < 0) {
+                        pr_info("invalid parsing\n");
+                        return -EINVAL;
+                }
+
+                mlx4_spec = (void *)mlx4_spec + ret;
+                size += ret;
+        }
+        return size;
+}
+
 static int __mlx4_ib_create_flow(struct ib_qp *qp, struct ib_flow_attr *flow_attr,
                           int domain,
                           enum mlx4_net_trans_promisc_mode flow_type,
@@ -873,6 +998,7 @@ static int __mlx4_ib_create_flow(struct ib_qp *qp, struct ib_flow_attr *flow_att
         struct mlx4_ib_dev *mdev = to_mdev(qp->device);
         struct mlx4_cmd_mailbox *mailbox;
         struct mlx4_net_trans_rule_hw_ctrl *ctrl;
+        int default_flow;
 
         static const u16 __mlx4_domain[] = {
                 [IB_FLOW_DOMAIN_USER] = MLX4_DOMAIN_UVERBS,
@@ -907,8 +1033,21 @@ static int __mlx4_ib_create_flow(struct ib_qp *qp, struct ib_flow_attr *flow_att
 
         ib_flow = flow_attr + 1;
         size += sizeof(struct mlx4_net_trans_rule_hw_ctrl);
+        /* Add default flows */
+        default_flow = __mlx4_ib_default_rules_match(qp, flow_attr);
+        if (default_flow >= 0) {
+                ret = __mlx4_ib_create_default_rules(
+                                mdev, qp, default_table + default_flow,
+                                mailbox->buf + size);
+                if (ret < 0) {
+                        mlx4_free_cmd_mailbox(mdev->dev, mailbox);
+                        return -EINVAL;
+                }
+                size += ret;
+        }
         for (i = 0; i < flow_attr->num_of_specs; i++) {
-                ret = parse_flow_attr(mdev->dev, ib_flow, mailbox->buf + size);
+                ret = parse_flow_attr(mdev->dev, qp->qp_num, ib_flow,
+                                      mailbox->buf + size);
                 if (ret < 0) {
                         mlx4_free_cmd_mailbox(mdev->dev, mailbox);
                         return -EINVAL;
@@ -1820,6 +1959,7 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         }
 
         if (check_flow_steering_support(dev)) {
+                ibdev->steering_support = MLX4_STEERING_MODE_DEVICE_MANAGED;
                 ibdev->ib_dev.create_flow       = mlx4_ib_create_flow;
                 ibdev->ib_dev.destroy_flow      = mlx4_ib_destroy_flow;
 
@@ -1848,8 +1988,35 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         spin_lock_init(&ibdev->sm_lock);
         mutex_init(&ibdev->cap_mask_mutex);
 
+        if (ibdev->steering_support == MLX4_STEERING_MODE_DEVICE_MANAGED) {
+                ibdev->steer_qpn_count = MLX4_IB_UC_MAX_NUM_QPS;
+                err = mlx4_qp_reserve_range(dev, ibdev->steer_qpn_count,
+                                            MLX4_IB_UC_STEER_QPN_ALIGN,
+                                            &ibdev->steer_qpn_base);
+                if (err)
+                        goto err_counter;
+
+                ibdev->ib_uc_qpns_bitmap =
+                        kmalloc(BITS_TO_LONGS(ibdev->steer_qpn_count) *
+                                sizeof(long),
+                                GFP_KERNEL);
+                if (!ibdev->ib_uc_qpns_bitmap) {
+                        dev_err(&dev->pdev->dev, "bit map alloc failed\n");
+                        goto err_steer_qp_release;
+                }
+
+                bitmap_zero(ibdev->ib_uc_qpns_bitmap, ibdev->steer_qpn_count);
+
+                err = mlx4_FLOW_STEERING_IB_UC_QP_RANGE(
+                                dev, ibdev->steer_qpn_base,
+                                ibdev->steer_qpn_base +
+                                ibdev->steer_qpn_count - 1);
+                if (err)
+                        goto err_steer_free_bitmap;
+        }
+
         if (ib_register_device(&ibdev->ib_dev, NULL))
-                goto err_counter;
+                goto err_steer_free_bitmap;
 
         if (mlx4_ib_mad_init(ibdev))
                 goto err_reg;
@@ -1938,6 +2105,13 @@ err_mad:
 err_reg:
         ib_unregister_device(&ibdev->ib_dev);
 
+err_steer_free_bitmap:
+        kfree(ibdev->ib_uc_qpns_bitmap);
+
+err_steer_qp_release:
+        if (ibdev->steering_support == MLX4_STEERING_MODE_DEVICE_MANAGED)
+                mlx4_qp_release_range(dev, ibdev->steer_qpn_base,
+                                      ibdev->steer_qpn_count);
 err_counter:
         for (; i; --i)
                 if (ibdev->counters[i - 1] != -1)
@@ -1958,6 +2132,69 @@ err_dealloc:
         return NULL;
 }
 
+int mlx4_ib_steer_qp_alloc(struct mlx4_ib_dev *dev, int count, int *qpn)
+{
+        int offset;
+
+        WARN_ON(!dev->ib_uc_qpns_bitmap);
+
+        offset = bitmap_find_free_region(dev->ib_uc_qpns_bitmap,
+                                         dev->steer_qpn_count,
+                                         get_count_order(count));
+        if (offset < 0)
+                return offset;
+
+        *qpn = dev->steer_qpn_base + offset;
+        return 0;
+}
+
+void mlx4_ib_steer_qp_free(struct mlx4_ib_dev *dev, u32 qpn, int count)
+{
+        if (!qpn ||
+            dev->steering_support != MLX4_STEERING_MODE_DEVICE_MANAGED)
+                return;
+
+        BUG_ON(qpn < dev->steer_qpn_base);
+
+        bitmap_release_region(dev->ib_uc_qpns_bitmap,
+                              qpn - dev->steer_qpn_base,
+                              get_count_order(count));
+}
+
+int mlx4_ib_steer_qp_reg(struct mlx4_ib_dev *mdev, struct mlx4_ib_qp *mqp,
+                         int is_attach)
+{
+        int err;
+        size_t flow_size;
+        struct ib_flow_attr *flow = NULL;
+        struct ib_flow_spec_ib *ib_spec;
+
+        if (is_attach) {
+                flow_size = sizeof(struct ib_flow_attr) +
+                            sizeof(struct ib_flow_spec_ib);
+                flow = kzalloc(flow_size, GFP_KERNEL);
+                if (!flow)
+                        return -ENOMEM;
+                flow->port = mqp->port;
+                flow->num_of_specs = 1;
+                flow->size = flow_size;
+                ib_spec = (struct ib_flow_spec_ib *)(flow + 1);
+                ib_spec->type = IB_FLOW_SPEC_IB;
+                ib_spec->size = sizeof(struct ib_flow_spec_ib);
+                /* Add an empty rule for IB L2 */
+                memset(&ib_spec->mask, 0, sizeof(ib_spec->mask));
+
+                err = __mlx4_ib_create_flow(&mqp->ibqp, flow,
+                                            IB_FLOW_DOMAIN_NIC,
+                                            MLX4_FS_REGULAR,
+                                            &mqp->reg_id);
+        } else {
+                err = __mlx4_ib_destroy_flow(mdev->dev, mqp->reg_id);
+        }
+        kfree(flow);
+        return err;
+}
+
 static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
 {
         struct mlx4_ib_dev *ibdev = ibdev_ptr;
@@ -1971,6 +2208,13 @@ static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
                         pr_warn("failure unregistering notifier\n");
                 ibdev->iboe.nb.notifier_call = NULL;
         }
+
+        if (ibdev->steering_support == MLX4_STEERING_MODE_DEVICE_MANAGED) {
+                mlx4_qp_release_range(dev, ibdev->steer_qpn_base,
+                                      ibdev->steer_qpn_count);
+                kfree(ibdev->ib_uc_qpns_bitmap);
+        }
+
         if (ibdev->iboe.nb_inet.notifier_call) {
                 if (unregister_inetaddr_notifier(&ibdev->iboe.nb_inet))
                         pr_warn("failure unregistering notifier\n");
@@ -1983,6 +2227,7 @@ static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
                 ibdev->iboe.nb_inet6.notifier_call = NULL;
         }
 #endif
+
         iounmap(ibdev->uar_map);
         for (p = 0; p < ibdev->num_ports; ++p)
                 if (ibdev->counters[p] != -1)
diff --git a/drivers/infiniband/hw/mlx4/mlx4_ib.h b/drivers/infiniband/hw/mlx4/mlx4_ib.h
index c06f571619df..a230683af940 100644
--- a/drivers/infiniband/hw/mlx4/mlx4_ib.h
+++ b/drivers/infiniband/hw/mlx4/mlx4_ib.h
@@ -68,6 +68,8 @@ enum {
 /*module param to indicate if SM assigns the alias_GUID*/
 extern int mlx4_ib_sm_guid_assign;
 
+#define MLX4_IB_UC_STEER_QPN_ALIGN 1
+#define MLX4_IB_UC_MAX_NUM_QPS     256
 struct mlx4_ib_ucontext {
         struct ib_ucontext      ibucontext;
         struct mlx4_uar         uar;
@@ -153,6 +155,7 @@ struct mlx4_ib_wq {
 enum mlx4_ib_qp_flags {
         MLX4_IB_QP_LSO = IB_QP_CREATE_IPOIB_UD_LSO,
         MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK = IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK,
+        MLX4_IB_QP_NETIF = IB_QP_CREATE_NETIF_QP,
         MLX4_IB_SRIOV_TUNNEL_QP = 1 << 30,
         MLX4_IB_SRIOV_SQP = 1 << 31,
 };
@@ -270,6 +273,7 @@ struct mlx4_ib_qp {
         struct list_head        gid_list;
         struct list_head        steering_rules;
         struct mlx4_ib_buf      *sqp_proxy_rcv;
+        u64                     reg_id;
 
 };
 
@@ -497,6 +501,10 @@ struct mlx4_ib_dev {
         struct kobject         *dev_ports_parent[MLX4_MFUNC_MAX];
         struct mlx4_ib_iov_port iov_ports[MLX4_MAX_PORTS];
         struct pkey_mgt         pkeys;
+        unsigned long *ib_uc_qpns_bitmap;
+        int steer_qpn_count;
+        int steer_qpn_base;
+        int steering_support;
 };
 
 struct ib_event_work {
@@ -752,5 +760,9 @@ void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device);
 
 __be64 mlx4_ib_gen_node_guid(void);
 
+int mlx4_ib_steer_qp_alloc(struct mlx4_ib_dev *dev, int count, int *qpn);
+void mlx4_ib_steer_qp_free(struct mlx4_ib_dev *dev, u32 qpn, int count);
+int mlx4_ib_steer_qp_reg(struct mlx4_ib_dev *mdev, struct mlx4_ib_qp *mqp,
+                         int is_attach);
 
 #endif /* MLX4_IB_H */
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index e0c2186529ff..d8f4d1fe8494 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -731,6 +731,14 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                 if (init_attr->create_flags & IB_QP_CREATE_IPOIB_UD_LSO)
                         qp->flags |= MLX4_IB_QP_LSO;
 
+                if (init_attr->create_flags & IB_QP_CREATE_NETIF_QP) {
+                        if (dev->steering_support ==
+                            MLX4_STEERING_MODE_DEVICE_MANAGED)
+                                qp->flags |= MLX4_IB_QP_NETIF;
+                        else
+                                goto err;
+                }
+
                 err = set_kernel_sq_size(dev, &init_attr->cap, qp_type, qp);
                 if (err)
                         goto err;
@@ -780,7 +788,11 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                 if (init_attr->qp_type == IB_QPT_RAW_PACKET)
                         err = mlx4_qp_reserve_range(dev->dev, 1, 1 << 8, &qpn);
                 else
-                        err = mlx4_qp_reserve_range(dev->dev, 1, 1, &qpn);
+                        if (qp->flags & MLX4_IB_QP_NETIF)
+                                err = mlx4_ib_steer_qp_alloc(dev, 1, &qpn);
+                        else
+                                err = mlx4_qp_reserve_range(dev->dev, 1, 1,
+                                                            &qpn);
                 if (err)
                         goto err_proxy;
         }
@@ -805,8 +817,12 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
         return 0;
 
 err_qpn:
-        if (!sqpn)
-                mlx4_qp_release_range(dev->dev, qpn, 1);
+        if (!sqpn) {
+                if (qp->flags & MLX4_IB_QP_NETIF)
+                        mlx4_ib_steer_qp_free(dev, qpn, 1);
+                else
+                        mlx4_qp_release_range(dev->dev, qpn, 1);
+        }
 err_proxy:
         if (qp->mlx4_ib_qp_type == MLX4_IB_QPT_PROXY_GSI)
                 free_proxy_bufs(pd->device, qp);
@@ -947,8 +963,12 @@ static void destroy_qp_common(struct mlx4_ib_dev *dev, struct mlx4_ib_qp *qp,
 
         mlx4_qp_free(dev->dev, &qp->mqp);
 
-        if (!is_sqp(dev, qp) && !is_tunnel_qp(dev, qp))
-                mlx4_qp_release_range(dev->dev, qp->mqp.qpn, 1);
+        if (!is_sqp(dev, qp) && !is_tunnel_qp(dev, qp)) {
+                if (qp->flags & MLX4_IB_QP_NETIF)
+                        mlx4_ib_steer_qp_free(dev, qp->mqp.qpn, 1);
+                else
+                        mlx4_qp_release_range(dev->dev, qp->mqp.qpn, 1);
+        }
 
         mlx4_mtt_cleanup(dev->dev, &qp->mtt);
 
@@ -1002,9 +1022,16 @@ struct ib_qp *mlx4_ib_create_qp(struct ib_pd *pd,
          */
         if (init_attr->create_flags & ~(MLX4_IB_QP_LSO |
                                         MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK |
-                                        MLX4_IB_SRIOV_TUNNEL_QP | MLX4_IB_SRIOV_SQP))
+                                        MLX4_IB_SRIOV_TUNNEL_QP |
+                                        MLX4_IB_SRIOV_SQP |
+                                        MLX4_IB_QP_NETIF))
                 return ERR_PTR(-EINVAL);
 
+        if (init_attr->create_flags & IB_QP_CREATE_NETIF_QP) {
+                if (init_attr->qp_type != IB_QPT_UD)
+                        return ERR_PTR(-EINVAL);
+        }
+
         if (init_attr->create_flags &&
             (udata ||
              ((init_attr->create_flags & ~MLX4_IB_SRIOV_SQP) &&
@@ -1276,6 +1303,7 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
         struct mlx4_qp_context *context;
         enum mlx4_qp_optpar optpar = 0;
         int sqd_event;
+        int steer_qp = 0;
         int err = -EINVAL;
 
         context = kzalloc(sizeof *context, GFP_KERNEL);
@@ -1360,6 +1388,11 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                         optpar |= MLX4_QP_OPTPAR_COUNTER_INDEX;
                 } else
                         context->pri_path.counter_index = 0xff;
+
+                if (qp->flags & MLX4_IB_QP_NETIF) {
+                        mlx4_ib_steer_qp_reg(dev, qp, 1);
+                        steer_qp = 1;
+                }
         }
 
         if (attr_mask & IB_QP_PKEY_INDEX) {
@@ -1599,9 +1632,14 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                 qp->sq_next_wqe = 0;
                 if (qp->rq.wqe_cnt)
                         *qp->db.db  = 0;
+
+                if (qp->flags & MLX4_IB_QP_NETIF)
+                        mlx4_ib_steer_qp_reg(dev, qp, 0);
         }
 
 out:
+        if (err && steer_qp)
+                mlx4_ib_steer_qp_reg(dev, qp, 0);
         kfree(context);
         return err;
 }
@@ -2824,6 +2862,9 @@ done:
         if (qp->flags & MLX4_IB_QP_LSO)
                 qp_init_attr->create_flags |= IB_QP_CREATE_IPOIB_UD_LSO;
 
+        if (qp->flags & MLX4_IB_QP_NETIF)
+                qp_init_attr->create_flags |= IB_QP_CREATE_NETIF_QP;
+
         qp_init_attr->sq_sig_type =
                 qp->sq_signal_bits == cpu_to_be32(MLX4_WQE_CTRL_CQ_UPDATE) ?
                 IB_SIGNAL_ALL_WR : IB_SIGNAL_REQ_WR;
diff --git a/drivers/infiniband/hw/mlx4/sysfs.c b/drivers/infiniband/hw/mlx4/sysfs.c
index 97516eb363b7..db2ea31df832 100644
--- a/drivers/infiniband/hw/mlx4/sysfs.c
+++ b/drivers/infiniband/hw/mlx4/sysfs.c
@@ -582,8 +582,10 @@ static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
         p->pkey_group.attrs =
                 alloc_group_attrs(show_port_pkey, store_port_pkey,
                                   dev->dev->caps.pkey_table_len[port_num]);
-        if (!p->pkey_group.attrs)
+        if (!p->pkey_group.attrs) {
+                ret = -ENOMEM;
                 goto err_alloc;
+        }
 
         ret = sysfs_create_group(&p->kobj, &p->pkey_group);
         if (ret)
@@ -591,8 +593,10 @@ static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave)
 
         p->gid_group.name  = "gid_idx";
         p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1);
-        if (!p->gid_group.attrs)
+        if (!p->gid_group.attrs) {
+                ret = -ENOMEM;
                 goto err_free_pkey;
+        }
 
         ret = sysfs_create_group(&p->kobj, &p->gid_group);
         if (ret)