/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Emulex.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Source file containing Queue handling functions

 *

 */

#include <oce_impl.h>

int oce_destroy_q(struct oce_dev  *oce, struct oce_mbx  *mbx, size_t req_size,

    enum qtype  qtype);

/*

 * function to create an event queue

 *

 * dev - software handle to the device

 * eqcfg - pointer to a config structure containg the eq parameters

 *

 * return pointer to EQ; NULL on failure

 */

struct oce_eq *

oce_eq_create(struct oce_dev *dev, uint32_t q_len, uint32_t item_size,

    uint32_t eq_delay)

{

	struct oce_eq *eq;

	struct oce_mbx mbx;

	struct mbx_create_common_eq *fwcmd;

	int ret = 0;

	bzero(&mbx, sizeof (struct oce_mbx));

	/* allocate mbx */

	fwcmd = (struct mbx_create_common_eq *)&mbx.payload;

	eq->ring = create_ring_buffer(dev, q_len,

	    item_size, DDI_DMA_CONSISTENT);

	if (eq->ring == NULL) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    (void *)eq->ring);

		kmem_free(eq, sizeof (struct oce_eq));

		return (NULL);

	}

	mbx_common_req_hdr_init(&fwcmd->hdr, 0, 0,

	    MBX_SUBSYSTEM_COMMON,

	    OPCODE_CREATE_COMMON_EQ, MBX_TIMEOUT_SEC,

	    sizeof (struct mbx_create_common_eq));

	fwcmd->params.req.num_pages = eq->ring->dbuf->num_pages;

	oce_page_list(eq->ring->dbuf, &fwcmd->params.req.pages[0],

	    eq->ring->dbuf->num_pages);

	/* dw 0 */

	fwcmd->params.req.eq_ctx.size = (item_size == 4) ? 0 : 1;

	fwcmd->params.req.eq_ctx.valid = 1;

	/* dw 1 */

	fwcmd->params.req.eq_ctx.armed = 0;

	fwcmd->params.req.eq_ctx.pd = 0;

	fwcmd->params.req.eq_ctx.count = OCE_LOG2(q_len/256);

	/* dw 2 */

	fwcmd->params.req.eq_ctx.function = dev->fn;

	fwcmd->params.req.eq_ctx.nodelay  = 0;

	fwcmd->params.req.eq_ctx.phase = 0;

	/* todo: calculate multiplier from max min and cur */

	fwcmd->params.req.eq_ctx.delay_mult = eq_delay;

	/* fill rest of mbx */

	mbx.u0.s.embedded = 1;

	mbx.payload_length = sizeof (struct mbx_create_common_eq);

	DW_SWAP(u32ptr(&mbx), mbx.payload_length + OCE_BMBX_RHDR_SZ);

	/* now post the command */

	ret = oce_mbox_post(dev, &mbx, NULL);

	if (ret != 0) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "EQ create failed: %d", ret);

		destroy_ring_buffer(dev, eq->ring);

		kmem_free(eq, sizeof (struct oce_eq));

		return (NULL);

	}

	/* interpret the response */

	eq->eq_id = LE_16(fwcmd->params.rsp.eq_id);

	eq->eq_cfg.q_len = q_len;

	eq->eq_cfg.item_size = item_size;

	eq->eq_cfg.cur_eqd = (uint8_t)eq_delay;

	eq->parent = (void *)dev;

	atomic_inc_32(&dev->neqs);

	oce_log(dev, CE_NOTE, MOD_CONFIG,

	    "EQ created, eq=0x%p eq_id=0x%x", (void *)eq, eq->eq_id);

	return (eq);

} /* oce_eq_create */

/*

 * function to delete an event queue

 *

 * dev - software handle to the device

 * eq - handle to the eq to be deleted

 *

 * return 0=>success, failure otherwise

 */

oce_eq_del(struct oce_dev *dev, struct oce_eq *eq)

{

	/* destroy the ring */

	destroy_ring_buffer(dev, eq->ring);

	eq->ring = NULL;

	kmem_free(eq, sizeof (struct oce_eq));

	atomic_dec_32(&dev->neqs);

/*

 * function to create a completion queue

 *

 * dev - software handle to the device

 * eq - optional eq to be associated with to the cq

 * cqcfg - configuration for this queue

 *

 * return pointer to the cq created. NULL on failure

 */

struct oce_cq *

oce_cq_create(struct oce_dev *dev, struct oce_eq *eq, uint32_t q_len,

    uint32_t item_size, boolean_t sol_event, boolean_t is_eventable,

    boolean_t nodelay, uint32_t ncoalesce)

{

	struct oce_cq *cq = NULL;

	struct oce_mbx mbx;

	struct mbx_create_common_cq *fwcmd;

	int ret = 0;

	/* create cq */

	cq = kmem_zalloc(sizeof (struct oce_cq), KM_NOSLEEP);

	if (cq == NULL) {

		oce_log(dev, CE_NOTE, MOD_CONFIG, "%s",

		    "CQ allocation failed");

		return (NULL);

	}

	/* create the ring buffer for this queue */

	cq->ring = create_ring_buffer(dev, q_len,

	    item_size, DDI_DMA_CONSISTENT);

	if (cq->ring == NULL) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "CQ ring alloc failed:0x%p",

		    (void *)cq->ring);

		kmem_free(cq, sizeof (struct oce_cq));

		return (NULL);

	}

	fwcmd = (struct mbx_create_common_cq *)&mbx.payload;

	/* fill the command header */

	mbx_common_req_hdr_init(&fwcmd->hdr, 0, 0,

	    MBX_SUBSYSTEM_COMMON,

	    OPCODE_CREATE_COMMON_CQ, MBX_TIMEOUT_SEC,

	    sizeof (struct mbx_create_common_cq));

	/* fill command context */

	/* dw0 */

	fwcmd->params.req.cq_ctx.eventable = is_eventable;

	fwcmd->params.req.cq_ctx.sol_event = sol_event;

	fwcmd->params.req.cq_ctx.valid = 1;

	fwcmd->params.req.cq_ctx.count = OCE_LOG2(q_len/256);

	fwcmd->params.req.cq_ctx.nodelay = nodelay;

	fwcmd->params.req.cq_ctx.coalesce_wm = ncoalesce;

	/* dw1 */

	fwcmd->params.req.cq_ctx.eq_id = eq->eq_id;

	fwcmd->params.req.cq_ctx.pd = 0;

	/* dw2 */

	fwcmd->params.req.cq_ctx.function = dev->fn;

	/* fill the rest of the command */

	fwcmd->params.req.num_pages = cq->ring->dbuf->num_pages;

	oce_page_list(cq->ring->dbuf, &fwcmd->params.req.pages[0],

	    cq->ring->dbuf->num_pages);

	/* fill rest of mbx */

	mbx.u0.s.embedded = 1;

	mbx.payload_length = sizeof (struct mbx_create_common_cq);

	DW_SWAP(u32ptr(&mbx), mbx.payload_length + OCE_BMBX_RHDR_SZ);

	/* now send the mail box */

	ret = oce_mbox_post(dev, &mbx, NULL);

	if (ret != 0) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "CQ create failed: 0x%x", ret);

		destroy_ring_buffer(dev, cq->ring);

		kmem_free(cq, sizeof (struct oce_cq));

		return (NULL);

	}

	cq->parent = dev;

	cq->eq = eq; /* eq array index */

	cq->cq_cfg.q_len = q_len;

	cq->cq_cfg.item_size = item_size;

	cq->cq_cfg.sol_eventable = (uint8_t)sol_event;

	cq->cq_cfg.nodelay = (uint8_t)nodelay;

	/* interpret the response */

	cq->cq_id = LE_16(fwcmd->params.rsp.cq_id);

	dev->cq[cq->cq_id] = cq;

	atomic_inc_32(&eq->ref_count);

	return (cq);

} /* oce_cq_create */

/*

 * function to delete a completion queue

 *

 * dev - software handle to the device

 * cq - handle to the CQ to delete

 *

 */

oce_cq_del(struct oce_dev *dev, struct oce_cq *cq)

{

	/* destroy the ring */

	destroy_ring_buffer(dev, cq->ring);

	cq->ring = NULL;

	atomic_dec_32(&cq->eq->ref_count);

	mutex_destroy(&cq->lock);

	/* release the eq */

	kmem_free(cq, sizeof (struct oce_cq));

} /* oce_cq_del */

/*

 * function to create an MQ

 *

 * dev - software handle to the device

 * eq - the EQ to associate with the MQ for event notification

 * q_len - the number of entries to create in the MQ

 *

 * return pointer to the created MQ, failure otherwise

 */

struct oce_mq *

oce_mq_create(struct oce_dev *dev, struct oce_eq *eq, uint32_t q_len)

{

	struct oce_mbx mbx;

	struct mbx_create_common_mq *fwcmd;

	struct oce_mq *mq = NULL;

	int ret = 0;

	struct oce_cq  *cq;

	/* Create the Completion Q */

	cq = oce_cq_create(dev, eq, CQ_LEN_256,

	    sizeof (struct oce_mq_cqe),

	    B_FALSE, B_TRUE, B_TRUE, 0);

	if (cq == NULL) {

		return (NULL);

	}

	/* allocate the mq */

	mq = kmem_zalloc(sizeof (struct oce_mq), KM_NOSLEEP);

	if (mq == NULL) {

	}

	/* create the ring buffer for this queue */

	mq->ring = create_ring_buffer(dev, q_len,

	    sizeof (struct oce_mbx), DDI_DMA_CONSISTENT);

	if (mq->ring == NULL) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "MQ ring alloc failed:0x%p",

		    (void *)mq->ring);

		goto mq_ring_alloc;

	}

	mbx_common_req_hdr_init(&fwcmd->hdr, 0, 0,

	    MBX_SUBSYSTEM_COMMON,

	    OPCODE_CREATE_COMMON_MQ, MBX_TIMEOUT_SEC,

	    sizeof (struct mbx_create_common_mq));

	fwcmd->params.req.num_pages = mq->ring->dbuf->num_pages;

	oce_page_list(mq->ring->dbuf, fwcmd->params.req.pages,

	    mq->ring->dbuf->num_pages);

	fwcmd->params.req.context.u0.s.cq_id = cq->cq_id;

	fwcmd->params.req.context.u0.s.ring_size =

	    OCE_LOG2(q_len) + 1;

	fwcmd->params.req.context.u0.s.valid = 1;

	fwcmd->params.req.context.u0.s.fid = dev->fn;

	/* fill rest of mbx */

	mbx.u0.s.embedded = 1;

	mbx.payload_length = sizeof (struct mbx_create_common_mq);

	DW_SWAP(u32ptr(&mbx), mbx.payload_length + OCE_BMBX_RHDR_SZ);

	/* now send the mail box */

	ret = oce_mbox_post(dev, &mbx, NULL);

	if (ret != DDI_SUCCESS) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "MQ create failed: 0x%x", ret);

		goto mq_fail;

	}

	/* interpret the response */

	mq->mq_id = LE_16(fwcmd->params.rsp.mq_id);

	mq->cq = cq;

	mq->cfg.q_len = (uint8_t)q_len;

	mq->cfg.eqd = 0;

	/* fill rest of the mq */

	mq->parent = dev;

	/* set the MQCQ handlers */

	cq->cq_handler = oce_drain_mq_cq;

	cq->cb_arg = (void *)mq;

	return (mq);

mq_fail:

	destroy_ring_buffer(dev, mq->ring);

mq_ring_alloc:

	kmem_free(mq, sizeof (struct oce_mq));

	return (NULL);

} /* oce_mq_create */

/*

 * function to delete an MQ

 *

 * dev - software handle to the device

 * mq - pointer to the MQ to delete

 *

 */

oce_mq_del(struct oce_dev *dev, struct oce_mq *mq)

{

	/* destroy the ring */

	destroy_ring_buffer(dev, mq->ring);

	mq->ring = NULL;

	kmem_free(mq, sizeof (struct oce_mq));

} /* oce_mq_del */

/*

 * function to create a WQ for NIC Tx

 *

 * dev - software handle to the device

 * wqcfg - configuration structure providing WQ config parameters

 *

 * return pointer to the WQ created. NULL on failure

 */

{

	struct oce_wq *wq;

	char str[MAX_POOL_NAME];

	int ret;

	ASSERT(dev != NULL);

	/* q_len must be min 256 and max 2k */

	if (q_len < 256 || q_len > 2048) {

		oce_log(dev, CE_WARN, MOD_CONFIG,

		    "Invalid q length. Must be "

		    "[256, 2000]: 0x%x", q_len);

		return (NULL);

	}

	/* allocate wq */

	wq = kmem_zalloc(sizeof (struct oce_wq), KM_NOSLEEP);

	if (wq == NULL) {

		oce_log(dev, CE_WARN, MOD_CONFIG, "%s",

		    "WQ allocation failed");

	}

	/* Set the wq config */

	wq->cfg.q_len = q_len;

	wq->cfg.wq_type = (uint8_t)wq_type;

	wq->cfg.eqd = OCE_DEFAULT_WQ_EQD;

	wq->cfg.nbufs = 2 * wq->cfg.q_len;

	wq->cfg.nhdl = 2 * wq->cfg.q_len;

	/* assign parent */

	wq->parent = (void *)dev;

	/* Create the WQ Buffer pool */

	if (ret != DDI_SUCCESS) {

		oce_log(dev, CE_WARN, MOD_CONFIG, "%s",

		    "WQ Buffer Pool create failed ");

		goto wqb_fail;

	}

	/* Create a pool of memory handles */

	ret = oce_wqm_cache_create(wq);

	if (ret != DDI_SUCCESS) {

		oce_log(dev, CE_WARN, MOD_CONFIG, "%s",

		    "WQ MAP Handles Pool create failed ");

		goto wqm_fail;

	}

	(void) snprintf(str, MAX_POOL_NAME, "%s%d", "oce_wqed_", dev->dev_id);

	wq->wqed_cache = kmem_cache_create(str, sizeof (oce_wqe_desc_t),

	    0, oce_wqe_desc_ctor,

	    oce_wqe_desc_dtor, NULL, NULL, NULL, 0);

	if (wq->wqed_cache == NULL) {

		oce_log(dev, CE_WARN, MOD_CONFIG, "%s",

		    "WQ Packet Desc Pool create failed ");

		goto wqed_fail;

	}

	/* create the ring buffer */