Merge branch 'qed-qede-improve-chain-API-and-add-XDP_REDIRECT-support' (7fc3b978) · Commits · 戴 / test

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

+49 −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,14 +1952,19 @@ 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,
		QEDR_SQE_ELEMENT_SIZE,
		QED_CHAIN_PAGE_SIZE,
		QED_CHAIN_MODE_PBL);
		in_params->rq_num_pages = QED_CHAIN_PAGE_CNT(n_rq_elems,
		QEDR_RQE_ELEMENT_SIZE,
		QED_CHAIN_PAGE_SIZE,
		QED_CHAIN_MODE_PBL);

		qp->qed_qp = dev->ops->rdma_create_qp(dev->rdma_ctx,
		@@ -1966,31 +1974,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/Makefile

+30 −7

Original line number	Diff line number	Diff line
		@@ -3,12 +3,35 @@

		obj-$(CONFIG_QED) := qed.o

		qed-y := qed_cxt.o qed_dev.o qed_hw.o qed_init_fw_funcs.o qed_init_ops.o \
		qed_int.o qed_main.o qed_mcp.o qed_sp_commands.o qed_spq.o qed_l2.o \
		qed_selftest.o qed_dcbx.o qed_debug.o qed_ptp.o qed_mng_tlv.o
		qed-$(CONFIG_QED_SRIOV) += qed_sriov.o qed_vf.o
		qed-$(CONFIG_QED_LL2) += qed_ll2.o
		qed-$(CONFIG_QED_RDMA) += qed_roce.o qed_rdma.o qed_iwarp.o
		qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o
		qed-y := \
		qed_chain.o \
		qed_cxt.o \
		qed_dcbx.o \
		qed_debug.o \
		qed_dev.o \
		qed_hw.o \
		qed_init_fw_funcs.o \
		qed_init_ops.o \
		qed_int.o \
		qed_l2.o \
		qed_main.o \
		qed_mcp.o \
		qed_mng_tlv.o \
		qed_ptp.o \
		qed_selftest.o \
		qed_sp_commands.o \
		qed_spq.o

		qed-$(CONFIG_QED_FCOE) += qed_fcoe.o
		qed-$(CONFIG_QED_ISCSI) += qed_iscsi.o
		qed-$(CONFIG_QED_LL2) += qed_ll2.o
		qed-$(CONFIG_QED_OOO) += qed_ooo.o

		qed-$(CONFIG_QED_RDMA) += \
		qed_iwarp.o \
		qed_rdma.o \
		qed_roce.o

		qed-$(CONFIG_QED_SRIOV) += \
		qed_sriov.o \
		qed_vf.o

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

0 → 100644

+369 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
		/* Copyright (c) 2020 Marvell International Ltd. */

		#include <linux/dma-mapping.h>
		#include <linux/qed/qed_chain.h>
		#include <linux/vmalloc.h>

		#include "qed_dev_api.h"

		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 = 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(params->elem_size,
		params->page_size);
		chain->usable_per_page = USABLE_ELEMS_PER_PAGE(params->elem_size,
		params->page_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 &
		chain->elem_per_page_mask;

		chain->page_size = params->page_size;
		chain->page_cnt = page_cnt;
		chain->capacity = chain->usable_per_page * page_cnt;
		chain->size = chain->elem_per_page * page_cnt;

		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;
		}
		}

		static void qed_chain_init_next_ptr_elem(const struct qed_chain *chain,
		void virt_curr, void virt_next,
		dma_addr_t phys_next)
		{
		struct qed_chain_next *next;
		u32 size;

		size = chain->elem_size * chain->usable_per_page;
		next = virt_curr + size;

		DMA_REGPAIR_LE(next->next_phys, phys_next);
		next->next_virt = virt_next;
		}

		static void qed_chain_init_mem(struct qed_chain chain, void virt_addr,
		dma_addr_t phys_addr)
		{
		chain->p_virt_addr = virt_addr;
		chain->p_phys_addr = phys_addr;
		}

		static void qed_chain_free_next_ptr(struct qed_dev *cdev,
		struct qed_chain *chain)
		{
		struct device *dev = &cdev->pdev->dev;
		struct qed_chain_next *next;
		dma_addr_t phys, phys_next;
		void virt, virt_next;
		u32 size, i;

		size = chain->elem_size * chain->usable_per_page;
		virt = chain->p_virt_addr;
		phys = chain->p_phys_addr;

		for (i = 0; i < chain->page_cnt; i++) {
		if (!virt)
		break;

		next = virt + size;
		virt_next = next->next_virt;
		phys_next = HILO_DMA_REGPAIR(next->next_phys);

		dma_free_coherent(dev, chain->page_size, virt, phys);

		virt = virt_next;
		phys = phys_next;
		}
		}

		static void qed_chain_free_single(struct qed_dev *cdev,
		struct qed_chain *chain)
		{
		if (!chain->p_virt_addr)
		return;

		dma_free_coherent(&cdev->pdev->dev, chain->page_size,
		chain->p_virt_addr, chain->p_phys_addr);
		}

		static void qed_chain_free_pbl(struct qed_dev cdev, struct qed_chain chain)
		{
		struct device *dev = &cdev->pdev->dev;
		struct addr_tbl_entry *entry;
		u32 i;

		if (!chain->pbl.pp_addr_tbl)
		return;

		for (i = 0; i < chain->page_cnt; i++) {
		entry = chain->pbl.pp_addr_tbl + i;
		if (!entry->virt_addr)
		break;

		dma_free_coherent(dev, chain->page_size, entry->virt_addr,
		entry->dma_map);
		}

		if (!chain->b_external_pbl)
		dma_free_coherent(dev, chain->pbl_sp.table_size,
		chain->pbl_sp.table_virt,
		chain->pbl_sp.table_phys);

		vfree(chain->pbl.pp_addr_tbl);
		chain->pbl.pp_addr_tbl = NULL;
		}

		/**
		* qed_chain_free() - Free chain DMA memory.
		*
		* @cdev: Main device structure.
		* @chain: Chain to free.
		*/
		void qed_chain_free(struct qed_dev cdev, struct qed_chain chain)
		{
		switch (chain->mode) {
		case QED_CHAIN_MODE_NEXT_PTR:
		qed_chain_free_next_ptr(cdev, chain);
		break;
		case QED_CHAIN_MODE_SINGLE:
		qed_chain_free_single(cdev, chain);
		break;
		case QED_CHAIN_MODE_PBL:
		qed_chain_free_pbl(cdev, chain);
		break;
		default:
		return;
		}

		qed_chain_init_mem(chain, NULL, 0);
		}

		static int
		qed_chain_alloc_sanity_check(struct qed_dev *cdev,
		const struct qed_chain_init_params *params,
		u32 page_cnt)
		{
		u64 chain_size;

		chain_size = ELEMS_PER_PAGE(params->elem_size, params->page_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
		* taking into account the unusuable elements (next-ptr elements).
		* The size of a "u16" chain can be (U16_MAX + 1) since the chain
		* size/capacity fields are of u32 type.
		*/
		switch (params->cnt_type) {
		case QED_CHAIN_CNT_TYPE_U16:
		if (chain_size > U16_MAX + 1)
		break;

		return 0;
		case QED_CHAIN_CNT_TYPE_U32:
		if (chain_size > U32_MAX)
		break;

		return 0;
		default:
		return -EINVAL;
		}

		DP_NOTICE(cdev,
		"The actual chain size (0x%llx) is larger than the maximal possible value\n",
		chain_size);

		return -EINVAL;
		}

		static int qed_chain_alloc_next_ptr(struct qed_dev *cdev,
		struct qed_chain *chain)
		{
		struct device *dev = &cdev->pdev->dev;
		void virt, virt_prev = NULL;
		dma_addr_t phys;
		u32 i;

		for (i = 0; i < chain->page_cnt; i++) {
		virt = dma_alloc_coherent(dev, chain->page_size, &phys,
		GFP_KERNEL);
		if (!virt)
		return -ENOMEM;

		if (i == 0) {
		qed_chain_init_mem(chain, virt, phys);
		qed_chain_reset(chain);
		} else {
		qed_chain_init_next_ptr_elem(chain, virt_prev, virt,
		phys);
		}

		virt_prev = virt;
		}

		/* Last page's next element should point to the beginning of the
		* chain.
		*/
		qed_chain_init_next_ptr_elem(chain, virt_prev, chain->p_virt_addr,
		chain->p_phys_addr);

		return 0;
		}

		static int qed_chain_alloc_single(struct qed_dev *cdev,
		struct qed_chain *chain)
		{
		dma_addr_t phys;
		void *virt;

		virt = dma_alloc_coherent(&cdev->pdev->dev, chain->page_size,
		&phys, GFP_KERNEL);
		if (!virt)
		return -ENOMEM;

		qed_chain_init_mem(chain, virt, phys);
		qed_chain_reset(chain);

		return 0;
		}

		static int qed_chain_alloc_pbl(struct qed_dev cdev, struct qed_chain chain)
		{
		struct device *dev = &cdev->pdev->dev;
		struct addr_tbl_entry *addr_tbl;
		dma_addr_t phys, pbl_phys;
		__le64 *pbl_virt;
		u32 page_cnt, i;
		size_t size;
		void *virt;

		page_cnt = chain->page_cnt;

		size = array_size(page_cnt, sizeof(*addr_tbl));
		if (unlikely(size == SIZE_MAX))
		return -EOVERFLOW;

		addr_tbl = vzalloc(size);
		if (!addr_tbl)
		return -ENOMEM;

		chain->pbl.pp_addr_tbl = addr_tbl;

		if (chain->b_external_pbl)
		goto alloc_pages;

		size = array_size(page_cnt, sizeof(*pbl_virt));
		if (unlikely(size == SIZE_MAX))
		return -EOVERFLOW;

		pbl_virt = dma_alloc_coherent(dev, size, &pbl_phys, GFP_KERNEL);
		if (!pbl_virt)
		return -ENOMEM;

		chain->pbl_sp.table_virt = pbl_virt;
		chain->pbl_sp.table_phys = pbl_phys;
		chain->pbl_sp.table_size = size;

		alloc_pages:
		for (i = 0; i < page_cnt; i++) {
		virt = dma_alloc_coherent(dev, chain->page_size, &phys,
		GFP_KERNEL);
		if (!virt)
		return -ENOMEM;

		if (i == 0) {
		qed_chain_init_mem(chain, virt, phys);
		qed_chain_reset(chain);
		}

		/* Fill the PBL table with the physical address of the page */
		pbl_virt[i] = cpu_to_le64(phys);

		/* Keep the virtual address of the page */
		addr_tbl[i].virt_addr = virt;
		addr_tbl[i].dma_map = phys;
		}

		return 0;
		}

		/**
		* 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 (!params->page_size)
		params->page_size = QED_CHAIN_PAGE_SIZE;

		if (params->mode == QED_CHAIN_MODE_SINGLE)
		page_cnt = 1;
		else
		page_cnt = QED_CHAIN_PAGE_CNT(params->num_elems,
		params->elem_size,
		params->page_size,
		params->mode);

		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, page_size %u]\n",
		params->intended_use, params->mode, params->cnt_type,
		params->num_elems, params->elem_size,
		params->page_size);
		return rc;
		}

		qed_chain_init(chain, params, page_cnt);

		switch (params->mode) {
		case QED_CHAIN_MODE_NEXT_PTR:
		rc = qed_chain_alloc_next_ptr(cdev, chain);
		break;
		case QED_CHAIN_MODE_SINGLE:
		rc = qed_chain_alloc_single(cdev, chain);
		break;
		case QED_CHAIN_MODE_PBL:
		rc = qed_chain_alloc_pbl(cdev, chain);
		break;
		default:
		return -EINVAL;
		}

		if (!rc)
		return 0;

		qed_chain_free(cdev, chain);

		return rc;
		}

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

+0 −273

Original line number	Diff line number	Diff line
		@@ -4716,279 +4716,6 @@ void qed_hw_remove(struct qed_dev *cdev)
		qed_mcp_nvm_info_free(p_hwfn);
		}

		static void qed_chain_free_next_ptr(struct qed_dev *cdev,
		struct qed_chain *p_chain)
		{
		void p_virt = p_chain->p_virt_addr, p_virt_next = NULL;
		dma_addr_t p_phys = p_chain->p_phys_addr, p_phys_next = 0;
		struct qed_chain_next *p_next;
		u32 size, i;

		if (!p_virt)
		return;

		size = p_chain->elem_size * p_chain->usable_per_page;

		for (i = 0; i < p_chain->page_cnt; i++) {
		if (!p_virt)
		break;

		p_next = (struct qed_chain_next )((u8 )p_virt + size);
		p_virt_next = p_next->next_virt;
		p_phys_next = HILO_DMA_REGPAIR(p_next->next_phys);

		dma_free_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE, p_virt, p_phys);

		p_virt = p_virt_next;
		p_phys = p_phys_next;
		}
		}

		static void qed_chain_free_single(struct qed_dev *cdev,
		struct qed_chain *p_chain)
		{
		if (!p_chain->p_virt_addr)
		return;

		dma_free_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE,
		p_chain->p_virt_addr, p_chain->p_phys_addr);
		}

		static void qed_chain_free_pbl(struct qed_dev cdev, struct qed_chain p_chain)
		{
		struct addr_tbl_entry *pp_addr_tbl = p_chain->pbl.pp_addr_tbl;
		u32 page_cnt = p_chain->page_cnt, i, pbl_size;

		if (!pp_addr_tbl)
		return;

		for (i = 0; i < page_cnt; i++) {
		if (!pp_addr_tbl[i].virt_addr \|\| !pp_addr_tbl[i].dma_map)
		break;

		dma_free_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE,
		pp_addr_tbl[i].virt_addr,
		pp_addr_tbl[i].dma_map);
		}

		pbl_size = page_cnt * QED_CHAIN_PBL_ENTRY_SIZE;

		if (!p_chain->b_external_pbl)
		dma_free_coherent(&cdev->pdev->dev,
		pbl_size,
		p_chain->pbl_sp.p_virt_table,
		p_chain->pbl_sp.p_phys_table);

		vfree(p_chain->pbl.pp_addr_tbl);
		p_chain->pbl.pp_addr_tbl = NULL;
		}

		void qed_chain_free(struct qed_dev cdev, struct qed_chain p_chain)
		{
		switch (p_chain->mode) {
		case QED_CHAIN_MODE_NEXT_PTR:
		qed_chain_free_next_ptr(cdev, p_chain);
		break;
		case QED_CHAIN_MODE_SINGLE:
		qed_chain_free_single(cdev, p_chain);
		break;
		case QED_CHAIN_MODE_PBL:
		qed_chain_free_pbl(cdev, p_chain);
		break;
		}
		}

		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)
		{
		u64 chain_size = ELEMS_PER_PAGE(elem_size) * page_cnt;

		/* The actual chain size can be larger than the maximal possible value
		* after rounding up the requested elements number to pages, and after
		* taking into acount the unusuable elements (next-ptr elements).
		* The size of a "u16" chain can be (U16_MAX + 1) since the chain
		* size/capacity fields are of a u32 type.
		*/
		if ((cnt_type == QED_CHAIN_CNT_TYPE_U16 &&
		chain_size > ((u32)U16_MAX + 1)) \|\|
		(cnt_type == QED_CHAIN_CNT_TYPE_U32 && chain_size > U32_MAX)) {
		DP_NOTICE(cdev,
		"The actual chain size (0x%llx) is larger than the maximal possible value\n",
		chain_size);
		return -EINVAL;
		}

		return 0;
		}

		static int
		qed_chain_alloc_next_ptr(struct qed_dev cdev, struct qed_chain p_chain)
		{
		void p_virt = NULL, p_virt_prev = NULL;
		dma_addr_t p_phys = 0;
		u32 i;

		for (i = 0; i < p_chain->page_cnt; i++) {
		p_virt = dma_alloc_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE,
		&p_phys, GFP_KERNEL);
		if (!p_virt)
		return -ENOMEM;

		if (i == 0) {
		qed_chain_init_mem(p_chain, p_virt, p_phys);
		qed_chain_reset(p_chain);
		} else {
		qed_chain_init_next_ptr_elem(p_chain, p_virt_prev,
		p_virt, p_phys);
		}

		p_virt_prev = p_virt;
		}
		/* Last page's next element should point to the beginning of the
		* chain.
		*/
		qed_chain_init_next_ptr_elem(p_chain, p_virt_prev,
		p_chain->p_virt_addr,
		p_chain->p_phys_addr);

		return 0;
		}

		static int
		qed_chain_alloc_single(struct qed_dev cdev, struct qed_chain p_chain)
		{
		dma_addr_t p_phys = 0;
		void *p_virt = NULL;

		p_virt = dma_alloc_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE, &p_phys, GFP_KERNEL);
		if (!p_virt)
		return -ENOMEM;

		qed_chain_init_mem(p_chain, p_virt, p_phys);
		qed_chain_reset(p_chain);

		return 0;
		}

		static int
		qed_chain_alloc_pbl(struct qed_dev *cdev,
		struct qed_chain *p_chain,
		struct qed_chain_ext_pbl *ext_pbl)
		{
		u32 page_cnt = p_chain->page_cnt, size, i;
		dma_addr_t p_phys = 0, p_pbl_phys = 0;
		struct addr_tbl_entry *pp_addr_tbl;
		u8 *p_pbl_virt = NULL;
		void *p_virt = NULL;

		size = page_cnt * sizeof(*pp_addr_tbl);
		pp_addr_tbl = vzalloc(size);
		if (!pp_addr_tbl)
		return -ENOMEM;

		/* The allocation of the PBL table is done with its full size, since it
		* is expected to be successive.
		* qed_chain_init_pbl_mem() is called even in a case of an allocation
		* failure, since tbl was previously allocated, and it
		* should be saved to allow its freeing during the error flow.
		*/
		size = page_cnt * QED_CHAIN_PBL_ENTRY_SIZE;

		if (!ext_pbl) {
		p_pbl_virt = dma_alloc_coherent(&cdev->pdev->dev,
		size, &p_pbl_phys, GFP_KERNEL);
		} else {
		p_pbl_virt = ext_pbl->p_pbl_virt;
		p_pbl_phys = ext_pbl->p_pbl_phys;
		p_chain->b_external_pbl = true;
		}

		qed_chain_init_pbl_mem(p_chain, p_pbl_virt, p_pbl_phys, pp_addr_tbl);
		if (!p_pbl_virt)
		return -ENOMEM;

		for (i = 0; i < page_cnt; i++) {
		p_virt = dma_alloc_coherent(&cdev->pdev->dev,
		QED_CHAIN_PAGE_SIZE,
		&p_phys, GFP_KERNEL);
		if (!p_virt)
		return -ENOMEM;

		if (i == 0) {
		qed_chain_init_mem(p_chain, p_virt, p_phys);
		qed_chain_reset(p_chain);
		}

		/* Fill the PBL table with the physical address of the page */
		(dma_addr_t )p_pbl_virt = p_phys;
		/* Keep the virtual address of the page */
		p_chain->pbl.pp_addr_tbl[i].virt_addr = p_virt;
		p_chain->pbl.pp_addr_tbl[i].dma_map = p_phys;

		p_pbl_virt += QED_CHAIN_PBL_ENTRY_SIZE;
		}

		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 *p_chain,
		struct qed_chain_ext_pbl *ext_pbl)
		{
		u32 page_cnt;
		int rc = 0;

		if (mode == QED_CHAIN_MODE_SINGLE)
		page_cnt = 1;
		else
		page_cnt = QED_CHAIN_PAGE_CNT(num_elems, elem_size, mode);

		rc = qed_chain_alloc_sanity_check(cdev, cnt_type, elem_size, 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);
		return rc;
		}

		qed_chain_init_params(p_chain, page_cnt, (u8) elem_size, intended_use,
		mode, cnt_type);

		switch (mode) {
		case QED_CHAIN_MODE_NEXT_PTR:
		rc = qed_chain_alloc_next_ptr(cdev, p_chain);
		break;
		case QED_CHAIN_MODE_SINGLE:
		rc = qed_chain_alloc_single(cdev, p_chain);
		break;
		case QED_CHAIN_MODE_PBL:
		rc = qed_chain_alloc_pbl(cdev, p_chain, ext_pbl);
		break;
		}
		if (rc)
		goto nomem;

		return 0;

		nomem:
		qed_chain_free(cdev, p_chain);
		return rc;
		}

		int qed_fw_l2_queue(struct qed_hwfn p_hwfn, u16 src_id, u16 dst_id)
		{
		if (src_id >= RESC_NUM(p_hwfn, QED_L2_QUEUE)) {

Admin message