1 files changed, 212 insertions, 31 deletions

diff --git a/drivers/net/ethernet/qlogic/qed/qed_rdma.c b/drivers/net/ethernet/qlogic/qed/qed_rdma.c
index a411f9c702a1..7873d6dfd91f 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_rdma.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_rdma.c
@@ -134,28 +134,40 @@ static bool qed_bmap_is_empty(struct qed_bmap *bmap)
         return bmap->max_count == find_first_bit(bmap->bitmap, bmap->max_count);
 }
 
-u32 qed_rdma_get_sb_id(void *p_hwfn, u32 rel_sb_id)
+static u32 qed_rdma_get_sb_id(void *p_hwfn, u32 rel_sb_id)
 {
         /* First sb id for RoCE is after all the l2 sb */
         return FEAT_NUM((struct qed_hwfn *)p_hwfn, QED_PF_L2_QUE) + rel_sb_id;
 }
 
-static int qed_rdma_alloc(struct qed_hwfn *p_hwfn,
-                          struct qed_ptt *p_ptt,
-                          struct qed_rdma_start_in_params *params)
+int qed_rdma_info_alloc(struct qed_hwfn *p_hwfn)
 {
         struct qed_rdma_info *p_rdma_info;
-        u32 num_cons, num_tasks;
-        int rc = -ENOMEM;
 
-        DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Allocating RDMA\n");
-
-        /* Allocate a struct with current pf rdma info */
         p_rdma_info = kzalloc(sizeof(*p_rdma_info), GFP_KERNEL);
         if (!p_rdma_info)
-                return rc;
+                return -ENOMEM;
+
+        spin_lock_init(&p_rdma_info->lock);
 
         p_hwfn->p_rdma_info = p_rdma_info;
+        return 0;
+}
+
+void qed_rdma_info_free(struct qed_hwfn *p_hwfn)
+{
+        kfree(p_hwfn->p_rdma_info);
+        p_hwfn->p_rdma_info = NULL;
+}
+
+static int qed_rdma_alloc(struct qed_hwfn *p_hwfn)
+{
+        struct qed_rdma_info *p_rdma_info = p_hwfn->p_rdma_info;
+        u32 num_cons, num_tasks;
+        int rc = -ENOMEM;
+
+        DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Allocating RDMA\n");
+
         if (QED_IS_IWARP_PERSONALITY(p_hwfn))
                 p_rdma_info->proto = PROTOCOLID_IWARP;
         else
@@ -183,7 +195,7 @@ static int qed_rdma_alloc(struct qed_hwfn *p_hwfn,
         /* Allocate a struct with device params and fill it */
         p_rdma_info->dev = kzalloc(sizeof(*p_rdma_info->dev), GFP_KERNEL);
         if (!p_rdma_info->dev)
-                goto free_rdma_info;
+                return rc;
 
         /* Allocate a struct with port params and fill it */
         p_rdma_info->port = kzalloc(sizeof(*p_rdma_info->port), GFP_KERNEL);
@@ -228,7 +240,7 @@ static int qed_rdma_alloc(struct qed_hwfn *p_hwfn,
                                  num_cons, "Toggle");
         if (rc) {
                 DP_VERBOSE(p_hwfn, QED_MSG_RDMA,
-                           "Failed to allocate toogle bits, rc = %d\n", rc);
+                           "Failed to allocate toggle bits, rc = %d\n", rc);
                 goto free_cq_map;
         }
 
@@ -259,15 +271,29 @@ static int qed_rdma_alloc(struct qed_hwfn *p_hwfn,
                 goto free_cid_map;
         }
 
+        /* Allocate bitmap for srqs */
+        p_rdma_info->num_srqs = qed_cxt_get_srq_count(p_hwfn);
+        rc = qed_rdma_bmap_alloc(p_hwfn, &p_rdma_info->srq_map,
+                                 p_rdma_info->num_srqs, "SRQ");
+        if (rc) {
+                DP_VERBOSE(p_hwfn, QED_MSG_RDMA,
+                           "Failed to allocate srq bitmap, rc = %d\n", rc);
+                goto free_real_cid_map;
+        }
+
         if (QED_IS_IWARP_PERSONALITY(p_hwfn))
                 rc = qed_iwarp_alloc(p_hwfn);
 
         if (rc)
-                goto free_cid_map;
+                goto free_srq_map;
 
         DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Allocation successful\n");
         return 0;
 
+free_srq_map:
+        kfree(p_rdma_info->srq_map.bitmap);
+free_real_cid_map:
+        kfree(p_rdma_info->real_cid_map.bitmap);
 free_cid_map:
         kfree(p_rdma_info->cid_map.bitmap);
 free_tid_map:
@@ -284,8 +310,6 @@ free_rdma_port:
         kfree(p_rdma_info->port);
 free_rdma_dev:
         kfree(p_rdma_info->dev);
-free_rdma_info:
-        kfree(p_rdma_info);
 
         return rc;
 }
@@ -351,11 +375,11 @@ static void qed_rdma_resc_free(struct qed_hwfn *p_hwfn)
         qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->cq_map, 1);
         qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->toggle_bits, 0);
         qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->tid_map, 1);
+        qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->srq_map, 1);
+        qed_rdma_bmap_free(p_hwfn, &p_hwfn->p_rdma_info->real_cid_map, 1);
 
         kfree(p_rdma_info->port);
         kfree(p_rdma_info->dev);
-
-        kfree(p_rdma_info);
 }
 
 static void qed_rdma_free_tid(void *rdma_cxt, u32 itid)
@@ -431,6 +455,12 @@ static void qed_rdma_init_devinfo(struct qed_hwfn *p_hwfn,
         if (cdev->rdma_max_sge)
                 dev->max_sge = min_t(u32, cdev->rdma_max_sge, dev->max_sge);
 
+        dev->max_srq_sge = QED_RDMA_MAX_SGE_PER_SRQ_WQE;
+        if (p_hwfn->cdev->rdma_max_srq_sge) {
+                dev->max_srq_sge = min_t(u32,
+                                         p_hwfn->cdev->rdma_max_srq_sge,
+                                         dev->max_srq_sge);
+        }
         dev->max_inline = ROCE_REQ_MAX_INLINE_DATA_SIZE;
 
         dev->max_inline = (cdev->rdma_max_inline) ?
@@ -474,6 +504,8 @@ static void qed_rdma_init_devinfo(struct qed_hwfn *p_hwfn,
         dev->max_mr_mw_fmr_size = dev->max_mr_mw_fmr_pbl * PAGE_SIZE;
         dev->max_pkey = QED_RDMA_MAX_P_KEY;
 
+        dev->max_srq = p_hwfn->p_rdma_info->num_srqs;
+        dev->max_srq_wr = QED_RDMA_MAX_SRQ_WQE_ELEM;
         dev->max_qp_resp_rd_atomic_resc = RDMA_RING_PAGE_SIZE /
                                           (RDMA_RESP_RD_ATOMIC_ELM_SIZE * 2);
         dev->max_qp_req_rd_atomic_resc = RDMA_RING_PAGE_SIZE /
@@ -655,8 +687,6 @@ static int qed_rdma_setup(struct qed_hwfn *p_hwfn,
 
         DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "RDMA setup\n");
 
-        spin_lock_init(&p_hwfn->p_rdma_info->lock);
-
         qed_rdma_init_devinfo(p_hwfn, params);
         qed_rdma_init_port(p_hwfn);
         qed_rdma_init_events(p_hwfn, params);
@@ -682,7 +712,7 @@ static int qed_rdma_setup(struct qed_hwfn *p_hwfn,
         return qed_rdma_start_fw(p_hwfn, params, p_ptt);
 }
 
-int qed_rdma_stop(void *rdma_cxt)
+static int qed_rdma_stop(void *rdma_cxt)
 {
         struct qed_hwfn *p_hwfn = (struct qed_hwfn *)rdma_cxt;
         struct rdma_close_func_ramrod_data *p_ramrod;
@@ -703,7 +733,7 @@ int qed_rdma_stop(void *rdma_cxt)
         /* Disable RoCE search */
         qed_wr(p_hwfn, p_ptt, p_hwfn->rdma_prs_search_reg, 0);
         p_hwfn->b_rdma_enabled_in_prs = false;
-
+        p_hwfn->p_rdma_info->active = 0;
         qed_wr(p_hwfn, p_ptt, PRS_REG_ROCE_DEST_QP_MAX_PF, 0);
 
         ll2_ethertype_en = qed_rd(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN);
@@ -1212,7 +1242,8 @@ qed_rdma_create_qp(void *rdma_cxt,
         u8 max_stats_queues;
         int rc;
 
-        if (!rdma_cxt || !in_params || !out_params || !p_hwfn->p_rdma_info) {
+        if (!rdma_cxt || !in_params || !out_params ||
+            !p_hwfn->p_rdma_info->active) {
                 DP_ERR(p_hwfn->cdev,
                        "qed roce create qp failed due to NULL entry (rdma_cxt=%p, in=%p, out=%p, roce_info=?\n",
                        rdma_cxt, in_params, out_params);
@@ -1484,15 +1515,13 @@ qed_rdma_register_tid(void *rdma_cxt,
         case QED_RDMA_TID_FMR:
                 tid_type = RDMA_TID_FMR;
                 break;
-        case QED_RDMA_TID_MW_TYPE1:
-                tid_type = RDMA_TID_MW_TYPE1;
-                break;
-        case QED_RDMA_TID_MW_TYPE2A:
-                tid_type = RDMA_TID_MW_TYPE2A;
+        case QED_RDMA_TID_MW:
+                tid_type = RDMA_TID_MW;
                 break;
         default:
                 rc = -EINVAL;
                 DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "rc = %d\n", rc);
+                qed_sp_destroy_request(p_hwfn, p_ent);
                 return rc;
         }
         SET_FIELD(p_ramrod->flags1,
@@ -1520,7 +1549,6 @@ qed_rdma_register_tid(void *rdma_cxt,
                           RDMA_REGISTER_TID_RAMROD_DATA_DIF_ON_HOST_FLG, 1);
                 DMA_REGPAIR_LE(p_ramrod->dif_error_addr,
                                params->dif_error_addr);
-                DMA_REGPAIR_LE(p_ramrod->dif_runt_addr, params->dif_runt_addr);
         }
 
         rc = qed_spq_post(p_hwfn, p_ent, &fw_return_code);
@@ -1628,12 +1656,161 @@ static void *qed_rdma_get_rdma_ctx(struct qed_dev *cdev)
         return QED_LEADING_HWFN(cdev);
 }
 
+static int qed_rdma_modify_srq(void *rdma_cxt,
+                               struct qed_rdma_modify_srq_in_params *in_params)
+{
+        struct rdma_srq_modify_ramrod_data *p_ramrod;
+        struct qed_sp_init_data init_data = {};
+        struct qed_hwfn *p_hwfn = rdma_cxt;
+        struct qed_spq_entry *p_ent;
+        u16 opaque_fid;
+        int rc;
+
+        init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
+        init_data.comp_mode = QED_SPQ_MODE_EBLOCK;
+
+        rc = qed_sp_init_request(p_hwfn, &p_ent,
+                                 RDMA_RAMROD_MODIFY_SRQ,
+                                 p_hwfn->p_rdma_info->proto, &init_data);
+        if (rc)
+                return rc;
+
+        p_ramrod = &p_ent->ramrod.rdma_modify_srq;
+        p_ramrod->srq_id.srq_idx = cpu_to_le16(in_params->srq_id);
+        opaque_fid = p_hwfn->hw_info.opaque_fid;
+        p_ramrod->srq_id.opaque_fid = cpu_to_le16(opaque_fid);
+        p_ramrod->wqe_limit = cpu_to_le32(in_params->wqe_limit);
+
+        rc = qed_spq_post(p_hwfn, p_ent, NULL);
+        if (rc)
+                return rc;
+
+        DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "modified SRQ id = %x",
+                   in_params->srq_id);
+
+        return rc;
+}
+
+static int
+qed_rdma_destroy_srq(void *rdma_cxt,
+                     struct qed_rdma_destroy_srq_in_params *in_params)
+{
+        struct rdma_srq_destroy_ramrod_data *p_ramrod;
+        struct qed_sp_init_data init_data = {};
+        struct qed_hwfn *p_hwfn = rdma_cxt;
+        struct qed_spq_entry *p_ent;
+        struct qed_bmap *bmap;
+        u16 opaque_fid;
+        int rc;
+
+        opaque_fid = p_hwfn->hw_info.opaque_fid;
+
+        init_data.opaque_fid = opaque_fid;
+        init_data.comp_mode = QED_SPQ_MODE_EBLOCK;
+
+        rc = qed_sp_init_request(p_hwfn, &p_ent,
+                                 RDMA_RAMROD_DESTROY_SRQ,
+                                 p_hwfn->p_rdma_info->proto, &init_data);
+        if (rc)
+                return rc;
+
+        p_ramrod = &p_ent->ramrod.rdma_destroy_srq;
+        p_ramrod->srq_id.srq_idx = cpu_to_le16(in_params->srq_id);
+        p_ramrod->srq_id.opaque_fid = cpu_to_le16(opaque_fid);
+
+        rc = qed_spq_post(p_hwfn, p_ent, NULL);
+        if (rc)
+                return rc;
+
+        bmap = &p_hwfn->p_rdma_info->srq_map;
+
+        spin_lock_bh(&p_hwfn->p_rdma_info->lock);
+        qed_bmap_release_id(p_hwfn, bmap, in_params->srq_id);
+        spin_unlock_bh(&p_hwfn->p_rdma_info->lock);
+
+        DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "SRQ destroyed Id = %x",
+                   in_params->srq_id);
+
+        return rc;
+}
+
+static int
+qed_rdma_create_srq(void *rdma_cxt,
+                    struct qed_rdma_create_srq_in_params *in_params,
+                    struct qed_rdma_create_srq_out_params *out_params)
+{
+        struct rdma_srq_create_ramrod_data *p_ramrod;
+        struct qed_sp_init_data init_data = {};
+        struct qed_hwfn *p_hwfn = rdma_cxt;
+        enum qed_cxt_elem_type elem_type;
+        struct qed_spq_entry *p_ent;
+        u16 opaque_fid, srq_id;
+        struct qed_bmap *bmap;
+        u32 returned_id;
+        int rc;
+
+        bmap = &p_hwfn->p_rdma_info->srq_map;
+        spin_lock_bh(&p_hwfn->p_rdma_info->lock);
+        rc = qed_rdma_bmap_alloc_id(p_hwfn, bmap, &returned_id);
+        spin_unlock_bh(&p_hwfn->p_rdma_info->lock);
+
+        if (rc) {
+                DP_NOTICE(p_hwfn, "failed to allocate srq id\n");
+                return rc;
+        }
+
+        elem_type = QED_ELEM_SRQ;
+        rc = qed_cxt_dynamic_ilt_alloc(p_hwfn, elem_type, returned_id);
+        if (rc)
+                goto err;
+        /* returned id is no greater than u16 */
+        srq_id = (u16)returned_id;
+        opaque_fid = p_hwfn->hw_info.opaque_fid;
+
+        opaque_fid = p_hwfn->hw_info.opaque_fid;
+        init_data.opaque_fid = opaque_fid;
+        init_data.comp_mode = QED_SPQ_MODE_EBLOCK;
+
+        rc = qed_sp_init_request(p_hwfn, &p_ent,
+                                 RDMA_RAMROD_CREATE_SRQ,
+                                 p_hwfn->p_rdma_info->proto, &init_data);
+        if (rc)
+                goto err;
+
+        p_ramrod = &p_ent->ramrod.rdma_create_srq;
+        DMA_REGPAIR_LE(p_ramrod->pbl_base_addr, in_params->pbl_base_addr);
+        p_ramrod->pages_in_srq_pbl = cpu_to_le16(in_params->num_pages);
+        p_ramrod->pd_id = cpu_to_le16(in_params->pd_id);
+        p_ramrod->srq_id.srq_idx = cpu_to_le16(srq_id);
+        p_ramrod->srq_id.opaque_fid = cpu_to_le16(opaque_fid);
+        p_ramrod->page_size = cpu_to_le16(in_params->page_size);
+        DMA_REGPAIR_LE(p_ramrod->producers_addr, in_params->prod_pair_addr);
+
+        rc = qed_spq_post(p_hwfn, p_ent, NULL);
+        if (rc)
+                goto err;
+
+        out_params->srq_id = srq_id;
+
+        DP_VERBOSE(p_hwfn, QED_MSG_RDMA,
+                   "SRQ created Id = %x\n", out_params->srq_id);
+
+        return rc;
+
+err:
+        spin_lock_bh(&p_hwfn->p_rdma_info->lock);
+        qed_bmap_release_id(p_hwfn, bmap, returned_id);
+        spin_unlock_bh(&p_hwfn->p_rdma_info->lock);
+
+        return rc;
+}
+
 bool qed_rdma_allocated_qps(struct qed_hwfn *p_hwfn)
 {
         bool result;
 
-        /* if rdma info has not been allocated, naturally there are no qps */
-        if (!p_hwfn->p_rdma_info)
+        /* if rdma wasn't activated yet, naturally there are no qps */
+        if (!p_hwfn->p_rdma_info->active)
                 return false;
 
         spin_lock_bh(&p_hwfn->p_rdma_info->lock);
@@ -1679,7 +1856,7 @@ static int qed_rdma_start(void *rdma_cxt,
         if (!p_ptt)
                 goto err;
 
-        rc = qed_rdma_alloc(p_hwfn, p_ptt, params);
+        rc = qed_rdma_alloc(p_hwfn);
         if (rc)
                 goto err1;
 
@@ -1688,6 +1865,7 @@ static int qed_rdma_start(void *rdma_cxt,
                 goto err2;
 
         qed_ptt_release(p_hwfn, p_ptt);
+        p_hwfn->p_rdma_info->active = 1;
 
         return rc;
 
@@ -1773,6 +1951,9 @@ static const struct qed_rdma_ops qed_rdma_ops_pass = {
         .rdma_free_tid = &qed_rdma_free_tid,
         .rdma_register_tid = &qed_rdma_register_tid,
         .rdma_deregister_tid = &qed_rdma_deregister_tid,
+        .rdma_create_srq = &qed_rdma_create_srq,
+        .rdma_modify_srq = &qed_rdma_modify_srq,
+        .rdma_destroy_srq = &qed_rdma_destroy_srq,
         .ll2_acquire_connection = &qed_ll2_acquire_connection,
         .ll2_establish_connection = &qed_ll2_establish_connection,
         .ll2_terminate_connection = &qed_ll2_terminate_connection,