Commit b6db3f71 authored by Alexander Lobakin's avatar Alexander Lobakin Committed by David S. Miller
Browse files

qed: simplify chain allocation with init params struct 



To simplify qed_chain_alloc() prototype and call sites, introduce struct
qed_chain_init_params to specify chain params, and pass a pointer to
filled struct to the actual qed_chain_alloc() instead of a long list
of separate arguments.

Signed-off-by: default avatarAlexander Lobakin <alobakin@marvell.com>
Signed-off-by: default avatarIgor Russkikh <irusskikh@marvell.com>
Signed-off-by: default avatarMichal Kalderon <michal.kalderon@marvell.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent c3a321b0

drivers/infiniband/hw/qedr/main.c

+11 −9
Original line number Diff line number Diff line
@@ -346,9 +346,14 @@ static void qedr_free_resources(struct qedr_dev *dev) 


static int qedr_alloc_resources(struct qedr_dev *dev)

{

	struct qed_chain_init_params params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.intended_use	= QED_CHAIN_USE_TO_CONSUME,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U16,

		.elem_size	= sizeof(struct regpair *),

	};

	struct qedr_cnq *cnq;

	__le16 *cons_pi;

	u16 n_entries;

	int i, rc;



	dev->sgid_tbl = kcalloc(QEDR_MAX_SGID, sizeof(union ib_gid),
@@ -382,7 +387,9 @@ static int qedr_alloc_resources(struct qedr_dev *dev) 
	dev->sb_start = dev->ops->rdma_get_start_sb(dev->cdev);



	/* Allocate CNQ PBLs */

	n_entries = min_t(u32, QED_RDMA_MAX_CNQ_SIZE, QEDR_ROCE_MAX_CNQ_SIZE);

	params.num_elems = min_t(u32, QED_RDMA_MAX_CNQ_SIZE,

				 QEDR_ROCE_MAX_CNQ_SIZE);



	for (i = 0; i < dev->num_cnq; i++) {

		cnq = &dev->cnq_array[i];
@@ -391,13 +398,8 @@ static int qedr_alloc_resources(struct qedr_dev *dev) 
		if (rc)

			goto err3;



		rc = dev->ops->common->chain_alloc(dev->cdev,

						   QED_CHAIN_USE_TO_CONSUME,

						   QED_CHAIN_MODE_PBL,

						   QED_CHAIN_CNT_TYPE_U16,

						   n_entries,

						   sizeof(struct regpair *),

						   &cnq->pbl, NULL);

		rc = dev->ops->common->chain_alloc(dev->cdev, &cnq->pbl,

						   &params);

		if (rc)

			goto err4;

drivers/infiniband/hw/qedr/verbs.c

+47 −48
Original line number Diff line number Diff line
@@ -891,6 +891,12 @@ int qedr_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr, 
		udata, struct qedr_ucontext, ibucontext);

	struct qed_rdma_destroy_cq_out_params destroy_oparams;

	struct qed_rdma_destroy_cq_in_params destroy_iparams;

	struct qed_chain_init_params chain_params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.intended_use	= QED_CHAIN_USE_TO_CONSUME,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U32,

		.elem_size	= sizeof(union rdma_cqe),

	};

	struct qedr_dev *dev = get_qedr_dev(ibdev);

	struct qed_rdma_create_cq_in_params params;

	struct qedr_create_cq_ureq ureq = {};
@@ -917,6 +923,7 @@ int qedr_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr, 


	chain_entries = qedr_align_cq_entries(entries);

	chain_entries = min_t(int, chain_entries, QEDR_MAX_CQES);

	chain_params.num_elems = chain_entries;



	/* calc db offset. user will add DPI base, kernel will add db addr */

	db_offset = DB_ADDR_SHIFT(DQ_PWM_OFFSET_UCM_RDMA_CQ_CONS_32BIT);
@@ -951,13 +958,8 @@ int qedr_create_cq(struct ib_cq *ibcq, const struct ib_cq_init_attr *attr, 
	} else {

		cq->cq_type = QEDR_CQ_TYPE_KERNEL;



		rc = dev->ops->common->chain_alloc(dev->cdev,

						   QED_CHAIN_USE_TO_CONSUME,

						   QED_CHAIN_MODE_PBL,

						   QED_CHAIN_CNT_TYPE_U32,

						   chain_entries,

						   sizeof(union rdma_cqe),

						   &cq->pbl, NULL);

		rc = dev->ops->common->chain_alloc(dev->cdev, &cq->pbl,

						   &chain_params);

		if (rc)

			goto err0;
@@ -1446,6 +1448,12 @@ static int qedr_alloc_srq_kernel_params(struct qedr_srq *srq, 
					struct ib_srq_init_attr *init_attr)

{

	struct qedr_srq_hwq_info *hw_srq = &srq->hw_srq;

	struct qed_chain_init_params params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.intended_use	= QED_CHAIN_USE_TO_CONSUME_PRODUCE,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U32,

		.elem_size	= QEDR_SRQ_WQE_ELEM_SIZE,

	};

	dma_addr_t phy_prod_pair_addr;

	u32 num_elems;

	void *va;
@@ -1464,13 +1472,9 @@ static int qedr_alloc_srq_kernel_params(struct qedr_srq *srq, 
	hw_srq->virt_prod_pair_addr = va;



	num_elems = init_attr->attr.max_wr * RDMA_MAX_SRQ_WQE_SIZE;

	rc = dev->ops->common->chain_alloc(dev->cdev,

					   QED_CHAIN_USE_TO_CONSUME_PRODUCE,

					   QED_CHAIN_MODE_PBL,

					   QED_CHAIN_CNT_TYPE_U32,

					   num_elems,

					   QEDR_SRQ_WQE_ELEM_SIZE,

					   &hw_srq->pbl, NULL);

	params.num_elems = num_elems;



	rc = dev->ops->common->chain_alloc(dev->cdev, &hw_srq->pbl, &params);

	if (rc)

		goto err0;
@@ -1901,29 +1905,28 @@ qedr_roce_create_kernel_qp(struct qedr_dev *dev, 
			   u32 n_sq_elems, u32 n_rq_elems)

{

	struct qed_rdma_create_qp_out_params out_params;

	struct qed_chain_init_params params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U32,

	};

	int rc;



	rc = dev->ops->common->chain_alloc(dev->cdev,

					   QED_CHAIN_USE_TO_PRODUCE,

					   QED_CHAIN_MODE_PBL,

					   QED_CHAIN_CNT_TYPE_U32,

					   n_sq_elems,

					   QEDR_SQE_ELEMENT_SIZE,

					   &qp->sq.pbl, NULL);

	params.intended_use = QED_CHAIN_USE_TO_PRODUCE;

	params.num_elems = n_sq_elems;

	params.elem_size = QEDR_SQE_ELEMENT_SIZE;



	rc = dev->ops->common->chain_alloc(dev->cdev, &qp->sq.pbl, &params);

	if (rc)

		return rc;



	in_params->sq_num_pages = qed_chain_get_page_cnt(&qp->sq.pbl);

	in_params->sq_pbl_ptr = qed_chain_get_pbl_phys(&qp->sq.pbl);



	rc = dev->ops->common->chain_alloc(dev->cdev,

					   QED_CHAIN_USE_TO_CONSUME_PRODUCE,

					   QED_CHAIN_MODE_PBL,

					   QED_CHAIN_CNT_TYPE_U32,

					   n_rq_elems,

					   QEDR_RQE_ELEMENT_SIZE,

					   &qp->rq.pbl, NULL);

	params.intended_use = QED_CHAIN_USE_TO_CONSUME_PRODUCE;

	params.elem_size = n_rq_elems;

	params.elem_size = QEDR_RQE_ELEMENT_SIZE;



	rc = dev->ops->common->chain_alloc(dev->cdev, &qp->rq.pbl, &params);

	if (rc)

		return rc;
@@ -1949,7 +1952,10 @@ qedr_iwarp_create_kernel_qp(struct qedr_dev *dev, 
			    u32 n_sq_elems, u32 n_rq_elems)

{

	struct qed_rdma_create_qp_out_params out_params;

	struct qed_chain_ext_pbl ext_pbl;

	struct qed_chain_init_params params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U32,

	};

	int rc;



	in_params->sq_num_pages = QED_CHAIN_PAGE_CNT(n_sq_elems,
@@ -1966,31 +1972,24 @@ qedr_iwarp_create_kernel_qp(struct qedr_dev *dev, 
		return -EINVAL;



	/* Now we allocate the chain */

	ext_pbl.p_pbl_virt = out_params.sq_pbl_virt;

	ext_pbl.p_pbl_phys = out_params.sq_pbl_phys;



	rc = dev->ops->common->chain_alloc(dev->cdev,

					   QED_CHAIN_USE_TO_PRODUCE,

					   QED_CHAIN_MODE_PBL,

					   QED_CHAIN_CNT_TYPE_U32,

					   n_sq_elems,

					   QEDR_SQE_ELEMENT_SIZE,

					   &qp->sq.pbl, &ext_pbl);



	params.intended_use = QED_CHAIN_USE_TO_PRODUCE;

	params.num_elems = n_sq_elems;

	params.elem_size = QEDR_SQE_ELEMENT_SIZE;

	params.ext_pbl_virt = out_params.sq_pbl_virt;

	params.ext_pbl_phys = out_params.sq_pbl_phys;



	rc = dev->ops->common->chain_alloc(dev->cdev, &qp->sq.pbl, &params);

	if (rc)

		goto err;



	ext_pbl.p_pbl_virt = out_params.rq_pbl_virt;

	ext_pbl.p_pbl_phys = out_params.rq_pbl_phys;



	rc = dev->ops->common->chain_alloc(dev->cdev,

					   QED_CHAIN_USE_TO_CONSUME_PRODUCE,

					   QED_CHAIN_MODE_PBL,

					   QED_CHAIN_CNT_TYPE_U32,

					   n_rq_elems,

					   QEDR_RQE_ELEMENT_SIZE,

					   &qp->rq.pbl, &ext_pbl);

	params.intended_use = QED_CHAIN_USE_TO_CONSUME_PRODUCE;

	params.num_elems = n_rq_elems;

	params.elem_size = QEDR_RQE_ELEMENT_SIZE;

	params.ext_pbl_virt = out_params.rq_pbl_virt;

	params.ext_pbl_phys = out_params.rq_pbl_phys;



	rc = dev->ops->common->chain_alloc(dev->cdev, &qp->rq.pbl, &params);

	if (rc)

		goto err;

drivers/net/ethernet/qlogic/qed/qed_chain.c

+45 −35
Original line number Diff line number Diff line
@@ -7,23 +7,22 @@ 


#include "qed_dev_api.h"



static void qed_chain_init_params(struct qed_chain *chain,

				  u32 page_cnt, u8 elem_size,

				  enum qed_chain_use_mode intended_use,

				  enum qed_chain_mode mode,

				  enum qed_chain_cnt_type cnt_type,

				  const struct qed_chain_ext_pbl *ext_pbl)

static void qed_chain_init(struct qed_chain *chain,

			   const struct qed_chain_init_params *params,

			   u32 page_cnt)

{

	memset(chain, 0, sizeof(*chain));



	chain->elem_size = elem_size;

	chain->intended_use = intended_use;

	chain->mode = mode;

	chain->cnt_type = cnt_type;

	chain->elem_size = params->elem_size;

	chain->intended_use = params->intended_use;

	chain->mode = params->mode;

	chain->cnt_type = params->cnt_type;



	chain->elem_per_page = ELEMS_PER_PAGE(elem_size);

	chain->usable_per_page = USABLE_ELEMS_PER_PAGE(elem_size, mode);

	chain->elem_unusable = UNUSABLE_ELEMS_PER_PAGE(elem_size, mode);

	chain->elem_per_page = ELEMS_PER_PAGE(params->elem_size);

	chain->usable_per_page = USABLE_ELEMS_PER_PAGE(params->elem_size,

						       params->mode);

	chain->elem_unusable = UNUSABLE_ELEMS_PER_PAGE(params->elem_size,

						       params->mode);



	chain->elem_per_page_mask = chain->elem_per_page - 1;

	chain->next_page_mask = chain->usable_per_page &
@@ -33,9 +32,9 @@ static void qed_chain_init_params(struct qed_chain *chain, 
	chain->capacity = chain->usable_per_page * page_cnt;

	chain->size = chain->elem_per_page * page_cnt;



	if (ext_pbl && ext_pbl->p_pbl_virt) {

		chain->pbl_sp.table_virt = ext_pbl->p_pbl_virt;

		chain->pbl_sp.table_phys = ext_pbl->p_pbl_phys;

	if (params->ext_pbl_virt) {

		chain->pbl_sp.table_virt = params->ext_pbl_virt;

		chain->pbl_sp.table_phys = params->ext_pbl_phys;



		chain->b_external_pbl = true;

	}
@@ -154,10 +153,16 @@ void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain) 


static int

qed_chain_alloc_sanity_check(struct qed_dev *cdev,

			     enum qed_chain_cnt_type cnt_type,

			     size_t elem_size, u32 page_cnt)

			     const struct qed_chain_init_params *params,

			     u32 page_cnt)

{

	u64 chain_size = ELEMS_PER_PAGE(elem_size) * page_cnt;

	u64 chain_size;



	chain_size = ELEMS_PER_PAGE(params->elem_size);

	chain_size *= page_cnt;



	if (!chain_size)

		return -EINVAL;



	/* The actual chain size can be larger than the maximal possible value

	 * after rounding up the requested elements number to pages, and after
@@ -165,7 +170,7 @@ qed_chain_alloc_sanity_check(struct qed_dev *cdev, 
	 * The size of a "u16" chain can be (U16_MAX + 1) since the chain

	 * size/capacity fields are of u32 type.

	 */

	switch (cnt_type) {

	switch (params->cnt_type) {

	case QED_CHAIN_CNT_TYPE_U16:

		if (chain_size > U16_MAX + 1)

			break;
@@ -298,37 +303,42 @@ alloc_pages: 
	return 0;

}



int qed_chain_alloc(struct qed_dev *cdev,

		    enum qed_chain_use_mode intended_use,

		    enum qed_chain_mode mode,

		    enum qed_chain_cnt_type cnt_type,

		    u32 num_elems,

		    size_t elem_size,

		    struct qed_chain *chain,

		    struct qed_chain_ext_pbl *ext_pbl)

/**

 * qed_chain_alloc() - Allocate and initialize a chain.

 *

 * @cdev: Main device structure.

 * @chain: Chain to be processed.

 * @params: Chain initialization parameters.

 *

 * Return: 0 on success, negative errno otherwise.

 */

int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain,

		    struct qed_chain_init_params *params)

{

	u32 page_cnt;

	int rc;



	if (mode == QED_CHAIN_MODE_SINGLE)

	if (params->mode == QED_CHAIN_MODE_SINGLE)

		page_cnt = 1;

	else

		page_cnt = QED_CHAIN_PAGE_CNT(num_elems, elem_size, mode);

		page_cnt = QED_CHAIN_PAGE_CNT(params->num_elems,

					      params->elem_size,

					      params->mode);



	rc = qed_chain_alloc_sanity_check(cdev, cnt_type, elem_size, page_cnt);

	rc = qed_chain_alloc_sanity_check(cdev, params, page_cnt);

	if (rc) {

		DP_NOTICE(cdev,

			  "Cannot allocate a chain with the given arguments:\n");

		DP_NOTICE(cdev,

			  "[use_mode %d, mode %d, cnt_type %d, num_elems %d, elem_size %zu]\n",

			  intended_use, mode, cnt_type, num_elems, elem_size);

			  params->intended_use, params->mode, params->cnt_type,

			  params->num_elems, params->elem_size);

		return rc;

	}



	qed_chain_init_params(chain, page_cnt, elem_size, intended_use, mode,

			      cnt_type, ext_pbl);

	qed_chain_init(chain, params, page_cnt);



	switch (mode) {

	switch (params->mode) {

	case QED_CHAIN_MODE_NEXT_PTR:

		rc = qed_chain_alloc_next_ptr(cdev, chain);

		break;

drivers/net/ethernet/qlogic/qed/qed_dev_api.h

+3 −29
Original line number Diff line number Diff line
@@ -254,35 +254,9 @@ int qed_dmae_host2host(struct qed_hwfn *p_hwfn, 
		       dma_addr_t dest_addr,

		       u32 size_in_dwords, struct qed_dmae_params *p_params);



/**

 * @brief qed_chain_alloc - Allocate and initialize a chain

 *

 * @param p_hwfn

 * @param intended_use

 * @param mode

 * @param num_elems

 * @param elem_size

 * @param p_chain

 * @param ext_pbl - a possible external PBL

 *

 * @return int

 */

int

qed_chain_alloc(struct qed_dev *cdev,

		enum qed_chain_use_mode intended_use,

		enum qed_chain_mode mode,

		enum qed_chain_cnt_type cnt_type,

		u32 num_elems,

		size_t elem_size,

		struct qed_chain *p_chain, struct qed_chain_ext_pbl *ext_pbl);



/**

 * @brief qed_chain_free - Free chain DMA memory

 *

 * @param p_hwfn

 * @param p_chain

 */

void qed_chain_free(struct qed_dev *cdev, struct qed_chain *p_chain);

int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain,

		    struct qed_chain_init_params *params);

void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain);



/**

 * @@brief qed_fw_l2_queue - Get absolute L2 queue ID

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

+17 −22
Original line number Diff line number Diff line
@@ -684,9 +684,13 @@ nomem: 
static int qed_iscsi_allocate_connection(struct qed_hwfn *p_hwfn,

					 struct qed_iscsi_conn **p_out_conn)

{

	u16 uhq_num_elements = 0, xhq_num_elements = 0, r2tq_num_elements = 0;

	struct scsi_terminate_extra_params *p_q_cnts = NULL;

	struct qed_iscsi_pf_params *p_params = NULL;

	struct qed_chain_init_params params = {

		.mode		= QED_CHAIN_MODE_PBL,

		.intended_use	= QED_CHAIN_USE_TO_CONSUME_PRODUCE,

		.cnt_type	= QED_CHAIN_CNT_TYPE_U16,

	};

	struct tcp_upload_params *p_tcp = NULL;

	struct qed_iscsi_conn *p_conn = NULL;

	int rc = 0;
@@ -727,34 +731,25 @@ static int qed_iscsi_allocate_connection(struct qed_hwfn *p_hwfn, 
		goto nomem_upload_param;

	p_conn->tcp_upload_params_virt_addr = p_tcp;



	r2tq_num_elements = p_params->num_r2tq_pages_in_ring *

			    QED_CHAIN_PAGE_SIZE / 0x80;

	rc = qed_chain_alloc(p_hwfn->cdev,

			     QED_CHAIN_USE_TO_CONSUME_PRODUCE,

			     QED_CHAIN_MODE_PBL,

			     QED_CHAIN_CNT_TYPE_U16,

			     r2tq_num_elements, 0x80, &p_conn->r2tq, NULL);

	params.num_elems = p_params->num_r2tq_pages_in_ring *

			   QED_CHAIN_PAGE_SIZE / sizeof(struct iscsi_wqe);

	params.elem_size = sizeof(struct iscsi_wqe);



	rc = qed_chain_alloc(p_hwfn->cdev, &p_conn->r2tq, &params);

	if (rc)

		goto nomem_r2tq;



	uhq_num_elements = p_params->num_uhq_pages_in_ring *

	params.num_elems = p_params->num_uhq_pages_in_ring *

			   QED_CHAIN_PAGE_SIZE / sizeof(struct iscsi_uhqe);

	rc = qed_chain_alloc(p_hwfn->cdev,

			     QED_CHAIN_USE_TO_CONSUME_PRODUCE,

			     QED_CHAIN_MODE_PBL,

			     QED_CHAIN_CNT_TYPE_U16,

			     uhq_num_elements,

			     sizeof(struct iscsi_uhqe), &p_conn->uhq, NULL);

	params.elem_size = sizeof(struct iscsi_uhqe);



	rc = qed_chain_alloc(p_hwfn->cdev, &p_conn->uhq, &params);

	if (rc)

		goto nomem_uhq;



	xhq_num_elements = uhq_num_elements;

	rc = qed_chain_alloc(p_hwfn->cdev,

			     QED_CHAIN_USE_TO_CONSUME_PRODUCE,

			     QED_CHAIN_MODE_PBL,

			     QED_CHAIN_CNT_TYPE_U16,

			     xhq_num_elements,

			     sizeof(struct iscsi_xhqe), &p_conn->xhq, NULL);

	params.elem_size = sizeof(struct iscsi_xhqe);



	rc = qed_chain_alloc(p_hwfn->cdev, &p_conn->xhq, &params);

	if (rc)

		goto nomem;

CRA Git | Maintained and supported by SUSTech CRA and CCSE