/*
 * 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

/*
 * hermon_qpmod.c
 *    Hermon Queue Pair Modify Routines
 *
 *    This contains all the routines necessary to implement the
 *    ModifyQP() verb.  This includes all the code for legal
 *    transitions to and from Reset, Init, RTR, RTS, SQD, SQErr,
 *    and Error.
 */

#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/bitmap.h>

#include <sys/ib/adapters/hermon/hermon.h>
#include <sys/ib/ib_pkt_hdrs.h>

static int hermon_qp_reset2init(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_qp_info_t *info_p);
static int hermon_qp_init2init(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_init2rtr(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_rtr2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_rts2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
#ifdef HERMON_NOTNOW
static int hermon_qp_rts2sqd(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags);
#endif
static int hermon_qp_sqd2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_sqd2sqd(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_sqerr2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int hermon_qp_to_error(hermon_state_t *state, hermon_qphdl_t qp);
static int hermon_qp_reset2err(hermon_state_t *state, hermon_qphdl_t qp);

static uint_t hermon_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
    ibt_qp_info_t *info_p, hermon_hw_qpc_t *qpc);
static int hermon_qp_validate_resp_rsrc(hermon_state_t *state,
    ibt_qp_rc_attr_t *rc, uint_t *rra_max);
static int hermon_qp_validate_init_depth(hermon_state_t *state,
    ibt_qp_rc_attr_t *rc, uint_t *sra_max);
static int hermon_qp_validate_mtu(hermon_state_t *state, uint_t mtu);

/*
 * hermon_qp_modify()
 *    Context: Can be called from interrupt or base context.
 */
/* ARGSUSED */
int
hermon_qp_modify(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p,
    ibt_queue_sizes_t *actual_sz)
{
	ibt_cep_state_t		cur_state, mod_state;
	ibt_cep_modify_flags_t	okflags;
	int			status;

	/*
	 * TODO add support for SUSPEND and RESUME
	 */

	/*
	 * Lock the QP so that we can modify it atomically.  After grabbing
	 * the lock, get the current QP state.  We will use this current QP
	 * state to determine the legal transitions (and the checks that need
	 * to be performed.)
	 * Below is a case for every possible QP state.  In each case, we
	 * check that no flags are set which are not valid for the possible
	 * transitions from that state.  If these tests pass and the
	 * state transition we are attempting is legal, then we call one
	 * of the helper functions.  Each of these functions does some
	 * additional setup before posting the firmware command for the
	 * appropriate state transition.
	 */
	mutex_enter(&qp->qp_lock);

	/*
	 * Verify that the transport type matches between the serv_type and the
	 * qp_trans.  A caller to IBT must specify the qp_trans field as
	 * IBT_UD_SRV, IBT_RC_SRV, or IBT_UC_SRV, depending on the QP.  We
	 * check here that the correct value was specified, based on our
	 * understanding of the QP serv type.
	 *
	 * Because callers specify part of a 'union' based on what QP type they
	 * think they're working with, this ensures that we do not pickup bogus
	 * data if the caller thought they were working with a different QP
	 * type.
	 */
	if (!(HERMON_QP_TYPE_VALID(info_p->qp_trans, qp->qp_serv_type))) {
		mutex_exit(&qp->qp_lock);
		return (IBT_QP_SRV_TYPE_INVALID);
	}

	/*
	 * If this is a transition to RTS (which is valid from RTR, RTS,
	 * SQError, and SQ Drain) then we should honor the "current QP state"
	 * specified by the consumer.  This means converting the IBTF QP state
	 * in "info_p->qp_current_state" to an Hermon QP state.  Otherwise, we
	 * assume that we already know the current state (i.e. whatever it was
	 * last modified to or queried as - in "qp->qp_state").
	 */
	mod_state = info_p->qp_state;

	if (flags & IBT_CEP_SET_RTR_RTS) {
		cur_state = HERMON_QP_RTR;		/* Ready to Receive */

	} else if ((flags & IBT_CEP_SET_STATE) &&
	    (mod_state == IBT_STATE_RTS)) {

		/* Convert the current IBTF QP state to an Hermon QP state */
		switch (info_p->qp_current_state) {
		case IBT_STATE_RTR:
			cur_state = HERMON_QP_RTR;	/* Ready to Receive */
			break;
		case IBT_STATE_RTS:
			cur_state = HERMON_QP_RTS;	/* Ready to Send */
			break;
		case IBT_STATE_SQE:
			cur_state = HERMON_QP_SQERR;	/* Send Queue Error */
			break;
		case IBT_STATE_SQD:
			cur_state = HERMON_QP_SQD;	/* SQ Drained */
			break;
		default:
			mutex_exit(&qp->qp_lock);
			return (IBT_QP_STATE_INVALID);
		}
	} else {
		cur_state = qp->qp_state;
	}

	switch (cur_state) {
	case HERMON_QP_RESET:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RESET_INIT |
		    IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
		    IBT_CEP_SET_ATOMIC | IBT_CEP_SET_PKEY_IX |
		    IBT_CEP_SET_PORT | IBT_CEP_SET_QKEY);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "Reset" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "Init", back to
		 * "Reset", or to "Error".
		 */
		if ((flags & IBT_CEP_SET_RESET_INIT) &&
		    (flags & IBT_CEP_SET_STATE) &&
		    (mod_state != IBT_STATE_INIT)) {
			/* Invalid transition - ambiguous flags */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;

		} else if ((flags & IBT_CEP_SET_RESET_INIT) ||
		    ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_INIT))) {
			/*
			 * Attempt to transition from "Reset" to "Init"
			 */
			status = hermon_qp_reset2init(state, qp, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_INIT;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_INIT);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "Reset" back to "Reset"
			 *    Nothing to do here really... just drop the lock
			 *    and return success.  The qp->qp_state should
			 *    already be set to HERMON_QP_RESET.
			 *
			 * Note: We return here because we do not want to fall
			 *    through to the hermon_wrid_from_reset_handling()
			 *    routine below (since we are not really moving
			 *    _out_ of the "Reset" state.
			 */
			mutex_exit(&qp->qp_lock);
			return (DDI_SUCCESS);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "Reset" to "Error"
			 */
			status = hermon_qp_reset2err(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}

		/*
		 * Do any additional handling necessary here for the transition
		 * from the "Reset" state (e.g. re-initialize the workQ WRID
		 * lists).  Note: If hermon_wrid_from_reset_handling() fails,
		 * then we attempt to transition the QP back to the "Reset"
		 * state.  If that fails, then it is an indication of a serious
		 * problem (either HW or SW).  So we print out a warning
		 * message and return failure.
		 */
		status = hermon_wrid_from_reset_handling(state, qp);
		if (status != DDI_SUCCESS) {
			if (hermon_qp_to_reset(state, qp) != DDI_SUCCESS) {
				HERMON_WARNING(state, "failed to reset QP");
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			mutex_exit(&qp->qp_lock);
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_INIT:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_INIT_RTR |
		    IBT_CEP_SET_ADDS_VECT | IBT_CEP_SET_RDMARA_IN |
		    IBT_CEP_SET_MIN_RNR_NAK | IBT_CEP_SET_ALT_PATH |
		    IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
		    IBT_CEP_SET_ATOMIC | IBT_CEP_SET_PKEY_IX |
		    IBT_CEP_SET_QKEY | IBT_CEP_SET_PORT);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "Init" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "RTR", back to "Init",
		 * to "Reset", or to "Error"
		 */
		if ((flags & IBT_CEP_SET_INIT_RTR) &&
		    (flags & IBT_CEP_SET_STATE) &&
		    (mod_state != IBT_STATE_RTR)) {
			/* Invalid transition - ambiguous flags */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;

		} else if ((flags & IBT_CEP_SET_INIT_RTR) ||
		    ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RTR))) {
			/*
			 * Attempt to transition from "Init" to "RTR"
			 */
			status = hermon_qp_init2rtr(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RTR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTR);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_INIT)) {
			/*
			 * Attempt to transition from "Init" to "Init"
			 */
			status = hermon_qp_init2init(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_INIT;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_INIT);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "Init" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "Init" to "Error"
			 */
			status = hermon_qp_to_error(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_RTR:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RTR_RTS |
		    IBT_CEP_SET_TIMEOUT | IBT_CEP_SET_RETRY |
		    IBT_CEP_SET_RNR_NAK_RETRY | IBT_CEP_SET_RDMARA_OUT |
		    IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
		    IBT_CEP_SET_ATOMIC | IBT_CEP_SET_QKEY |
		    IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_MIG |
		    IBT_CEP_SET_MIN_RNR_NAK);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "RTR" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "RTS", "Reset",
		 * or "Error"
		 */
		if ((flags & IBT_CEP_SET_RTR_RTS) &&
		    (flags & IBT_CEP_SET_STATE) &&
		    (mod_state != IBT_STATE_RTS)) {
			/* Invalid transition - ambiguous flags */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;

		} else if ((flags & IBT_CEP_SET_RTR_RTS) ||
		    ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RTS))) {
			/*
			 * Attempt to transition from "RTR" to "RTS"
			 */
			status = hermon_qp_rtr2rts(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RTS;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "RTR" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "RTR" to "Error"
			 */
			status = hermon_qp_to_error(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_RTS:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RDMA_R |
		    IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC |
		    IBT_CEP_SET_QKEY | IBT_CEP_SET_ALT_PATH |
		    IBT_CEP_SET_MIG | IBT_CEP_SET_MIN_RNR_NAK |
		    IBT_CEP_SET_SQD_EVENT);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "RTS" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "RTS", "SQD", "Reset",
		 * or "Error"
		 */
		if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RTS)) {
			/*
			 * Attempt to transition from "RTS" to "RTS"
			 */
			status = hermon_qp_rts2rts(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RTS;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_SQD)) {
#ifdef HERMON_NOTNOW
			/*
			 * Attempt to transition from "RTS" to "SQD"
			 */
			status = hermon_qp_rts2sqd(state, qp, flags);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_SQD;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);
#else
			/* hack because of the lack of fw support for SQD */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
#endif

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "RTS" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "RTS" to "Error"
			 */
			status = hermon_qp_to_error(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_SQERR:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RDMA_R |
		    IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC |
		    IBT_CEP_SET_QKEY | IBT_CEP_SET_MIN_RNR_NAK);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "SQErr" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "RTS", "Reset", or
		 * "Error"
		 */
		if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RTS)) {
			/*
			 * Attempt to transition from "SQErr" to "RTS"
			 */
			status = hermon_qp_sqerr2rts(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RTS;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "SQErr" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "SQErr" to "Error"
			 */
			status = hermon_qp_to_error(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_SQD:
		okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_ADDS_VECT |
		    IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_MIG |
		    IBT_CEP_SET_RDMARA_OUT | IBT_CEP_SET_RDMARA_IN |
		    IBT_CEP_SET_QKEY | IBT_CEP_SET_PKEY_IX |
		    IBT_CEP_SET_TIMEOUT | IBT_CEP_SET_RETRY |
		    IBT_CEP_SET_RNR_NAK_RETRY | IBT_CEP_SET_PORT |
		    IBT_CEP_SET_MIN_RNR_NAK | IBT_CEP_SET_RDMA_R |
		    IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC);

		/*
		 * Check for attempts to modify invalid attributes from the
		 * "SQD" state
		 */
		if (flags & ~okflags) {
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_ATTR_RO;
			goto qpmod_fail;
		}

		/*
		 * Verify state transition is to either "SQD", "RTS", "Reset",
		 * or "Error"
		 */

		if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_SQD)) {
			/*
			 * Attempt to transition from "SQD" to "SQD"
			 */
			status = hermon_qp_sqd2sqd(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_SQD;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RTS)) {
			/*
			 * If still draining SQ, then fail transition attempt
			 * to RTS, even though this is now done is two steps
			 * (see below) if the consumer has tried this before
			 * it's drained, let it fail and wait appropriately
			 */
			if (qp->qp_sqd_still_draining) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			/*
			 * IBA 1.2 has changed - most/all the things that were
			 * done in SQD2RTS can be done in SQD2SQD.  So make this
			 * a 2-step process.  First, set any attributes requsted
			 * w/ SQD2SQD, but no real transition.
			 *
			 * First, Attempt to transition from "SQD" to "SQD"
			 */
			status = hermon_qp_sqd2sqd(state, qp, flags, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_SQD;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);

			/*
			 * The, attempt to transition from "SQD" to "RTS", but
			 * request only the state transition, no attributes
			 */

			status = hermon_qp_sqd2rts(state, qp,
			    IBT_CEP_SET_STATE, info_p);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RTS;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "SQD" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "SQD" to "Error"
			 */
			status = hermon_qp_to_error(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_ERR;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	case HERMON_QP_ERR:
		/*
		 * Verify state transition is to either "Reset" or back to
		 * "Error"
		 */
		if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_RESET)) {
			/*
			 * Attempt to transition from "Error" to "Reset"
			 */
			status = hermon_qp_to_reset(state, qp);
			if (status != DDI_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}
			qp->qp_state = HERMON_QP_RESET;
			HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);

			/*
			 * Do any additional handling necessary for the
			 * transition _to_ the "Reset" state (e.g. update the
			 * workQ WRID lists)
			 */
			status = hermon_wrid_to_reset_handling(state, qp);
			if (status != IBT_SUCCESS) {
				mutex_exit(&qp->qp_lock);
				goto qpmod_fail;
			}

		} else if ((flags & IBT_CEP_SET_STATE) &&
		    (mod_state == IBT_STATE_ERROR)) {
			/*
			 * Attempt to transition from "Error" back to "Error"
			 *    Nothing to do here really... just drop the lock
			 *    and return success.  The qp->qp_state should
			 *    already be set to HERMON_QP_ERR.
			 *
			 */
			mutex_exit(&qp->qp_lock);
			return (DDI_SUCCESS);

		} else {
			/* Invalid transition - return error */
			mutex_exit(&qp->qp_lock);
			status = IBT_QP_STATE_INVALID;
			goto qpmod_fail;
		}
		break;

	default:
		/*
		 * Invalid QP state.  If we got here then it's a warning of
		 * a probably serious problem.  So print a message and return
		 * failure
		 */
		mutex_exit(&qp->qp_lock);
		HERMON_WARNING(state, "unknown QP state in modify");
		status = IBT_QP_STATE_INVALID;
		goto qpmod_fail;
	}

	mutex_exit(&qp->qp_lock);
	return (DDI_SUCCESS);

qpmod_fail:
	return (status);
}


/*
 * hermon_qp_reset2init()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_reset2init(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	uint_t			portnum, pkeyindx;
	int			status;
	uint32_t		cqnmask;
	int			qp_srq_en;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Fill in the common fields in the QPC
	 */

	if (qp->qp_is_special) {
		qpc->serv_type	= HERMON_QP_MLX;
	} else {
		qpc->serv_type	= qp->qp_serv_type;
	}
	qpc->pm_state		= HERMON_QP_PMSTATE_MIGRATED;

	qpc->pd			= qp->qp_pdhdl->pd_pdnum;

	qpc->log_sq_stride	= qp->qp_sq_log_wqesz - 4;
	qpc->log_rq_stride	= qp->qp_rq_log_wqesz - 4;
	qpc->sq_no_prefetch	= qp->qp_no_prefetch;
	qpc->log_sq_size	= highbit(qp->qp_sq_bufsz) - 1;
	qpc->log_rq_size	= highbit(qp->qp_rq_bufsz) - 1;

	qpc->usr_page		= qp->qp_uarpg;

	cqnmask = (1 << state->hs_cfg_profile->cp_log_num_cq) - 1;
	qpc->cqn_snd		=
	    (qp->qp_sq_cqhdl == NULL) ? 0 : qp->qp_sq_cqhdl->cq_cqnum & cqnmask;
	qpc->page_offs		= qp->qp_wqinfo.qa_pgoffs >> 6;
	qpc->cqn_rcv		=
	    (qp->qp_rq_cqhdl == NULL) ? 0 : qp->qp_rq_cqhdl->cq_cqnum & cqnmask;

	/* dbr is now an address, not an index */
	qpc->dbr_addrh		= ((uint64_t)qp->qp_rq_pdbr >> 32);
	qpc->dbr_addrl		= ((uint64_t)qp->qp_rq_pdbr & 0xFFFFFFFC) >> 2;
	qpc->sq_wqe_counter	= 0;
	qpc->rq_wqe_counter	= 0;
	/*
	 * HERMON:
	 * qpc->wqe_baseaddr is replaced by LKey from the cMPT, and
	 * page_offset, mtt_base_addr_h/l, and log2_page_size will
	 * be used to map the WQE buffer
	 * NOTE that the cMPT is created implicitly when the QP is
	 * transitioned from reset to init
	 */
	qpc->log2_pgsz		= qp->qp_mrhdl->mr_log2_pgsz;
	qpc->mtt_base_addrl	= (qp->qp_mrhdl->mr_mttaddr) >> 3;
	qpc->mtt_base_addrh	= (uint32_t)((qp->qp_mrhdl->mr_mttaddr >> 32) &
	    0xFF);
	qp_srq_en		= (qp->qp_alloc_flags & IBT_QP_USES_SRQ) != 0;
	qpc->srq_en		= qp_srq_en;

	if (qp_srq_en) {
		qpc->srq_number	= qp->qp_srqhdl->srq_srqnum;
	} else {
		qpc->srq_number = 0;
	}

	/*
	 * Fast Registration Work Requests and Reserved Lkey are enabled
	 * with the single IBT bit stored in qp_rlky.
	 */
	qpc->fre		= qp->qp_rlky;
	qpc->rlky		= qp->qp_rlky;

	/* 1.2 verbs extensions disabled for now */
	qpc->header_sep		= 0; /* disable header separation for now */
	qpc->rss		= qp->qp_alloc_flags & IBT_QP_USES_RSS ? 1 : 0;
	qpc->inline_scatter	= 0; /* disable inline scatter for now */

	/*
	 * Now fill in the QPC fields which are specific to transport type
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		int my_fc_id_idx, exch_base;

		ud = &info_p->qp_transport.ud;

		/* Set the QKey */
		qpc->qkey = ud->ud_qkey;

		/*
		 * Set MTU and message max. Hermon checks the QPC
		 * MTU settings rather than just the port MTU,
		 * so set it to maximum size.
		 */
		qpc->mtu = HERMON_MAX_MTU;
		if (qp->qp_uses_lso)
			qpc->msg_max = state->hs_devlim.log_max_gso_sz;
		else if (qp->qp_is_special)
			qpc->msg_max = HERMON_MAX_MTU + 6;
		else
			qpc->msg_max = HERMON_QP_LOG_MAX_MSGSZ;

		/* Check for valid port number and fill it in */
		portnum = ud->ud_port;
		if (hermon_portnum_is_valid(state, portnum)) {
			qp->qp_portnum = portnum - 1;
			qpc->pri_addr_path.sched_q =
			    HERMON_QP_SCHEDQ_GET(portnum - 1,
			    0, qp->qp_is_special);
		} else {
			return (IBT_HCA_PORT_INVALID);
		}


		/* Check for valid PKey index and fill it in */
		pkeyindx = ud->ud_pkey_ix;
		if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
			qpc->pri_addr_path.pkey_indx = pkeyindx;
			qp->qp_pkeyindx = pkeyindx;
		} else {
			return (IBT_PKEY_IX_ILLEGAL);
		}

		/* fill in the RSS fields */
		if (qpc->rss) {
			struct hermon_hw_rss_s *rssp;
			ibt_rss_flags_t flags = ud->ud_rss.rss_flags;

			rssp = (struct hermon_hw_rss_s *)&qpc->pri_addr_path;
			rssp->log2_tbl_sz = ud->ud_rss.rss_log2_table;
			rssp->base_qpn = ud->ud_rss.rss_base_qpn;
			rssp->default_qpn = ud->ud_rss.rss_def_qpn;
			if (flags & IBT_RSS_ALG_XOR)
				rssp->hash_fn = 0;	/* XOR Hash Function */
			else if (flags & IBT_RSS_ALG_TPL)
				rssp->hash_fn = 1;	/* Toeplitz Hash Fn */
			else
				return (IBT_INVALID_PARAM);
			rssp->ipv4 = (flags & IBT_RSS_HASH_IPV4) != 0;
			rssp->tcp_ipv4 = (flags & IBT_RSS_HASH_TCP_IPV4) != 0;
			rssp->ipv6 = (flags & IBT_RSS_HASH_IPV6) != 0;
			rssp->tcp_ipv4 = (flags & IBT_RSS_HASH_TCP_IPV6) != 0;
			bcopy(ud->ud_rss.rss_toe_key, rssp->rss_key, 40);
		} else if (qp->qp_serv_type == HERMON_QP_RFCI) {
			status = hermon_fcoib_set_id(state, portnum,
			    qp->qp_qpnum, ud->ud_fc.fc_src_id);
			if (status != DDI_SUCCESS)
				return (status);
			qp->qp_fc_attr = ud->ud_fc;
		} else if (qp->qp_serv_type == HERMON_QP_FEXCH) {
			my_fc_id_idx = hermon_fcoib_get_id_idx(state,
			    portnum, &ud->ud_fc);
			if (my_fc_id_idx == -1)
				return (IBT_INVALID_PARAM);
			qpc->my_fc_id_idx = my_fc_id_idx;

			status = hermon_fcoib_fexch_mkey_init(state,
			    qp->qp_pdhdl, ud->ud_fc.fc_hca_port,
			    qp->qp_qpnum, HERMON_CMD_NOSLEEP_SPIN);
			if (status != DDI_SUCCESS)
				return (status);
			qp->qp_fc_attr = ud->ud_fc;
		} else if (qp->qp_serv_type == HERMON_QP_FCMND) {
			my_fc_id_idx = hermon_fcoib_get_id_idx(state,
			    portnum, &ud->ud_fc);
			if (my_fc_id_idx == -1)
				return (IBT_INVALID_PARAM);
			qpc->my_fc_id_idx = my_fc_id_idx;
			exch_base = hermon_fcoib_check_exch_base_off(state,
			    portnum, &ud->ud_fc);
			if (exch_base == -1)
				return (IBT_INVALID_PARAM);
			qpc->exch_base = exch_base;
			qpc->exch_size = ud->ud_fc.fc_exch_log2_sz;
			qp->qp_fc_attr = ud->ud_fc;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;

		/* Set the RDMA (recv) enable/disable flags */
		qpc->rre = (info_p->qp_flags & IBT_CEP_RDMA_RD) ? 1 : 0;
		qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
		qpc->rae = (info_p->qp_flags & IBT_CEP_ATOMIC)  ? 1 : 0;

		/* Check for valid port number and fill it in */
		portnum = rc->rc_path.cep_hca_port_num;
		if (hermon_portnum_is_valid(state, portnum)) {
			qp->qp_portnum = portnum - 1;
			qpc->pri_addr_path.sched_q =
			    HERMON_QP_SCHEDQ_GET(portnum - 1,
			    0, qp->qp_is_special);
		} else {
			return (IBT_HCA_PORT_INVALID);
		}

		/* Check for valid PKey index and fill it in */
		pkeyindx = rc->rc_path.cep_pkey_ix;
		if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
			qpc->pri_addr_path.pkey_indx = pkeyindx;
		} else {
			return (IBT_PKEY_IX_ILLEGAL);
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/*
		 * Set the RDMA (recv) enable/disable flags.  Note: RDMA Read
		 * and Atomic are ignored by default.
		 */
		qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;

		/* Check for valid port number and fill it in */
		portnum = uc->uc_path.cep_hca_port_num;
		if (hermon_portnum_is_valid(state, portnum)) {
			qp->qp_portnum = portnum - 1;
			qpc->pri_addr_path.sched_q =
			    HERMON_QP_SCHEDQ_GET(portnum - 1,
			    0, qp->qp_is_special);
		} else {
			return (IBT_HCA_PORT_INVALID);
		}

		/* Check for valid PKey index and fill it in */
		pkeyindx = uc->uc_path.cep_pkey_ix;
		if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
			qpc->pri_addr_path.pkey_indx = pkeyindx;
		} else {
			return (IBT_PKEY_IX_ILLEGAL);
		}

	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in rst2init");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the RST2INIT_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		cmn_err(CE_NOTE, "hermon%d: RST2INIT_QP command failed: %08x\n",
		    state->hs_instance, status);
		if (status == HERMON_CMD_INVALID_STATUS) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
		}
		return (ibc_get_ci_failure(0));
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_init2init()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_init2init(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	uint_t			portnum, pkeyindx;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Since there are no common fields to be filled in for this command,
	 * we begin with the QPC fields which are specific to transport type.
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
	/*
	 * set port is not supported in init2init - however, in init2rtr it will
	 * take the entire qpc, including the embedded sched_q in the path
	 * structure - so, we can just skip setting the opmask for it explicitly
	 * and allow it to be set later on
	 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = ud->ud_port;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1; /* save it away */
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    0, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = ud->ud_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
				qp->qp_pkeyindx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = rc->rc_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1;
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    0, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = rc->rc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = uc->uc_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1;
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    0, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
		/* port# cannot be set in this transition - defer to init2rtr */
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = uc->uc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in init2init");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the INIT2INIT_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, INIT2INIT_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: INIT2INIT_QP command "
			    "failed: %08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_init2rtr()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_init2rtr(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	hermon_hw_addr_path_t	*qpc_path;
	ibt_adds_vect_t		*adds_vect;
	uint_t			portnum, pkeyindx, rra_max;
	uint_t			mtu;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Since there are few common fields to be filled in for this command,
	 * we just do the QPC fields that are specific to transport type.
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If this UD QP is also a "special QP" (QP0 or QP1), then
		 * the MTU is 256 bytes.  However, Hermon checks the QPC
		 * MTU settings rather than just the port MTU, so we will
		 * set it to maximum size for all UD.
		 */
		qpc->mtu = HERMON_MAX_MTU;
		if (qp->qp_uses_lso)
			qpc->msg_max = state->hs_devlim.log_max_gso_sz;
		else
			qpc->msg_max = HERMON_QP_LOG_MAX_MSGSZ;

		/*
		 * Save away the MTU value.  This is used in future sqd2sqd
		 * transitions, as the MTU must remain the same in future
		 * changes.
		 */
		qp->qp_save_mtu = qpc->mtu;

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = ud->ud_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
				qp->qp_pkeyindx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;
		qpc_path = &qpc->pri_addr_path;
		adds_vect = &rc->rc_path.cep_adds_vect;

		/*
		 * Set the common primary address path fields
		 */
		status = hermon_set_addr_path(state, adds_vect, qpc_path,
		    HERMON_ADDRPATH_QP);
		if (status != DDI_SUCCESS) {
			return (status);
		}
		/* set the primary port number/sched_q */
		portnum = qp->qp_portnum + 1;
		if (hermon_portnum_is_valid(state, portnum)) {
			qpc->pri_addr_path.sched_q  =
			    HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
			    adds_vect->av_srvl, qp->qp_is_special);
		} else {
			return (IBT_HCA_PORT_INVALID);
		}

		/*
		 * The following values are apparently "required" here (as
		 * they are part of the IBA-defined "Remote Node Address
		 * Vector").  However, they are also going to be "required"
		 * later - at RTR2RTS_QP time.  Not sure why.  But we set
		 * them here anyway.
		 */
		qpc->rnr_retry		= rc->rc_rnr_retry_cnt;
		qpc->retry_cnt		= rc->rc_retry_cnt;
		qpc_path->ack_timeout	= rc->rc_path.cep_timeout;

		/*
		 * Setup the destination QP, recv PSN, MTU, max msg size,etc.
		 * Note max message size is defined to be the maximum IB
		 * allowed message size (which is 2^31 bytes).  Also max
		 * MTU is defined by HCA port properties.
		 */
		qpc->rem_qpn	  = rc->rc_dst_qpn;
		qpc->next_rcv_psn = rc->rc_rq_psn;
		qpc->msg_max	  = HERMON_QP_LOG_MAX_MSGSZ;
		qpc->ric	  = 0;
		mtu		  = rc->rc_path_mtu;

		if (hermon_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
			return (IBT_HCA_PORT_MTU_EXCEEDED);
		}
		qpc->mtu = mtu;

		/*
		 * Save away the MTU value.  This is used in future sqd2sqd
		 * transitions, as the MTU must remain the same in future
		 * changes.
		 */
		qp->qp_save_mtu = qpc->mtu;

		/*
		 * Though it is a "required" parameter, "min_rnr_nak" is
		 * optionally specifiable in Hermon.  So we force the
		 * optional flag here.
		 */
		qpc->min_rnr_nak = rc->rc_min_rnr_nak;
		opmask |= HERMON_CMD_OP_MINRNRNAK;

		/*
		 * Check that the number of specified "incoming RDMA resources"
		 * is valid.  And if it is, then setup the "rra_max
		 */
		if (hermon_qp_validate_resp_rsrc(state, rc, &rra_max) !=
		    DDI_SUCCESS) {
			return (IBT_INVALID_PARAM);
		}
		qpc->rra_max = rra_max;

		/* don't need to set up ra_buff_indx, implicit for hermon */

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = rc->rc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &rc->rc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;


			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = rc->rc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = rc->rc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;
		qpc_path = &qpc->pri_addr_path;
		adds_vect = &uc->uc_path.cep_adds_vect;

		/*
		 * Set the common primary address path fields
		 */
		status = hermon_set_addr_path(state, adds_vect, qpc_path,
		    HERMON_ADDRPATH_QP);
		if (status != DDI_SUCCESS) {
			return (status);
		}

		/* set the primary port num/schedq */
		portnum = qp->qp_portnum + 1;
		if (hermon_portnum_is_valid(state, portnum)) {
			qpc->pri_addr_path.sched_q  =
			    HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
			    adds_vect->av_srvl, qp->qp_is_special);
		} else {
			return (IBT_HCA_PORT_INVALID);
		}

		/*
		 * Setup the destination QP, recv PSN, MTU, max msg size,etc.
		 * Note max message size is defined to be the maximum IB
		 * allowed message size (which is 2^31 bytes).  Also max
		 * MTU is defined by HCA port properties.
		 */
		qpc->rem_qpn	  = uc->uc_dst_qpn;
		qpc->next_rcv_psn = uc->uc_rq_psn;
		qpc->msg_max	  = HERMON_QP_LOG_MAX_MSGSZ;
		mtu = uc->uc_path_mtu;
		if (hermon_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
			return (IBT_HCA_PORT_MTU_EXCEEDED);
		}
		qpc->mtu = mtu;

		/*
		 * Save away the MTU value.  This is used in future sqd2sqd
		 * transitions, as the MTU must remain the same in future
		 * changes.
		 */
		qp->qp_save_mtu = qpc->mtu;

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = uc->uc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &uc->uc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}

			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = uc->uc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = uc->uc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in init2rtr");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the INIT2RTR_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, INIT2RTR_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: INIT2RTR_QP command "
			    "failed: %08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_rtr2rts()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_rtr2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	hermon_hw_addr_path_t	*qpc_path;
	ibt_adds_vect_t		*adds_vect;
	uint_t			portnum, pkeyindx, sra_max;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Now fill in the QPC fields which are specific to transport type
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/* Set the send PSN */
		qpc->next_snd_psn = ud->ud_sq_psn;

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;
		qpc_path = &qpc->pri_addr_path;

		/*
		 * Setup the send PSN, ACK timeout, and retry counts
		 */
		qpc->next_snd_psn	= rc->rc_sq_psn;
		qpc_path->ack_timeout	= rc->rc_path.cep_timeout;
		qpc->rnr_retry		= rc->rc_rnr_retry_cnt;
						/* in qpc now, not path */
		qpc->retry_cnt		= rc->rc_retry_cnt;

		/*
		 * Set "ack_req_freq" based on the configuration variable
		 */
		qpc->ack_req_freq = state->hs_cfg_profile->cp_ackreq_freq;

		/*
		 * Check that the number of specified "outgoing RDMA resources"
		 * is valid.  And if it is, then setup the "sra_max"
		 * appropriately
		 */
		if (hermon_qp_validate_init_depth(state, rc, &sra_max) !=
		    DDI_SUCCESS) {
			return (IBT_INVALID_PARAM);
		}
		qpc->sra_max = sra_max;


		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * If we are attempting to modify the "Minimum RNR NAK" value
		 * for this QP, then fill it in and set the appropriate flag
		 * in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
			qpc->min_rnr_nak = rc->rc_min_rnr_nak;
			opmask |= HERMON_CMD_OP_MINRNRNAK;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &rc->rc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}

			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = rc->rc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = rc->rc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/* Set the send PSN */
		qpc->next_snd_psn = uc->uc_sq_psn;

		/*
		 * Configure the QP to allow (sending of) all types of allowable
		 * UC traffic (i.e. RDMA Write).
		 */


		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &uc->uc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = uc->uc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = uc->uc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in rtr2rts");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the RTR2RTS_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, RTR2RTS_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: RTR2RTS_QP command failed: "
			    "%08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_rts2rts()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_rts2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	hermon_hw_addr_path_t	*qpc_path;
	ibt_adds_vect_t		*adds_vect;
	uint_t			portnum, pkeyindx;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */

	qpc = &qp->qpc;

	/*
	 * Since there are no common fields to be filled in for this command,
	 * we begin with the QPC fields which are specific to transport type.
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * If we are attempting to modify the "Minimum RNR NAK" value
		 * for this QP, then fill it in and set the appropriate flag
		 * in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
			qpc->min_rnr_nak = rc->rc_min_rnr_nak;
			opmask |= HERMON_CMD_OP_MINRNRNAK;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &rc->rc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = rc->rc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = rc->rc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &uc->uc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = uc->uc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = uc->uc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in rts2rts");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the RTS2RTS_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, RTS2RTS_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: RTS2RTS_QP command failed: "
			    "%08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


#ifdef HERMON_NOTNOW
/*
 * hermon_qp_rts2sqd()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_rts2sqd(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags)
{
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Set a flag to indicate whether or not the consumer is interested
	 * in receiving the SQ drained event.  Since we are going to always
	 * request hardware generation of the SQD event, we use the value in
	 * "qp_forward_sqd_event" to determine whether or not to pass the event
	 * to the IBTF or to silently consume it.
	 */
	qp->qp_forward_sqd_event = (flags & IBT_CEP_SET_SQD_EVENT) ? 1 : 0;

	/*
	 * Post the RTS2SQD_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, RTS2SQD_QP, NULL, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: RTS2SQD_QP command failed: "
			    "%08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	/*
	 * Mark the current QP state as "SQ Draining".  This allows us to
	 * distinguish between the two underlying states in SQD. (see QueryQP()
	 * code in hermon_qp.c)
	 */
	qp->qp_sqd_still_draining = 1;

	return (DDI_SUCCESS);
}
#endif


/*
 * hermon_qp_sqd2rts()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_sqd2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	hermon_hw_addr_path_t	*qpc_path;
	ibt_adds_vect_t		*adds_vect;
	uint_t			portnum, pkeyindx;
	uint_t			rra_max, sra_max;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Fill in the common fields in the QPC
	 */

	/*
	 * Now fill in the QPC fields which are specific to transport type
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = ud->ud_port;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1;
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    0, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
			opmask |= HERMON_CMD_OP_PRIM_PORT;
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = ud->ud_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
				qp->qp_pkeyindx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

		qpc->retry_cnt = rc->rc_retry_cnt;

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &rc->rc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = rc->rc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = rc->rc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}

		/*
		 * If we are attempting to modify the number of "outgoing
		 * RDMA resources" for this QP, then check for valid value and
		 * fill it in.  Also set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_RDMARA_OUT) {
			if (hermon_qp_validate_init_depth(state, rc,
			    &sra_max) != DDI_SUCCESS) {
				return (IBT_INVALID_PARAM);
			}
			qpc->sra_max = sra_max;
			opmask |= HERMON_CMD_OP_SRA_SET;
		}

		/*
		 * If we are attempting to modify the number of "incoming
		 * RDMA resources" for this QP, then check for valid value and
		 * update the "rra_max" and "ra_buf_index" fields in the QPC to
		 * point to the pre-allocated RDB resources (in DDR).  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_RDMARA_IN) {
			if (hermon_qp_validate_resp_rsrc(state, rc,
			    &rra_max) != DDI_SUCCESS) {
				return (IBT_INVALID_PARAM);
			}
			qpc->rra_max = rra_max;
			opmask |= HERMON_CMD_OP_RRA_SET;
		}


		/*
		 * If we are attempting to modify the "Minimum RNR NAK" value
		 * for this QP, then fill it in and set the appropriate flag
		 * in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
			qpc->min_rnr_nak = rc->rc_min_rnr_nak;
			opmask |= HERMON_CMD_OP_MINRNRNAK;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &uc->uc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = uc->uc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = uc->uc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in sqd2rts");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the SQD2RTS_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, SQD2RTS_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: SQD2RTS_QP command failed: "
			    "%08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_sqd2sqd()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_sqd2sqd(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_rc_attr_t	*rc;
	ibt_qp_ud_attr_t	*ud;
	ibt_qp_uc_attr_t	*uc;
	hermon_hw_addr_path_t	*qpc_path;
	ibt_adds_vect_t		*adds_vect;
	uint_t			portnum, pkeyindx;
	uint_t			rra_max, sra_max;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Fill in the common fields in the QPC
	 */

	/*
	 * Now fill in the QPC fields which are specific to transport type
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = ud->ud_port;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1;
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    0, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
			opmask |= HERMON_CMD_OP_SCHEDQUEUE;
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = ud->ud_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
				qp->qp_pkeyindx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		rc = &info_p->qp_transport.rc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * (recv) enable/disable flags and set the appropriate flag in
		 * the "opmask" parameter
		 */
		opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);

		/*
		 * Check for optional primary path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ADDS_VECT) {
			qpc_path = &qpc->pri_addr_path;
			adds_vect = &rc->rc_path.cep_adds_vect;

			/* Set the common primary address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc->rnr_retry = rc->rc_rnr_retry_cnt;
			qpc_path->ack_timeout = rc->rc_path.cep_timeout;
			qpc->retry_cnt = rc->rc_retry_cnt;

			portnum = qp->qp_portnum + 1;
			if (hermon_portnum_is_valid(state, portnum)) {
				qpc->pri_addr_path.sched_q  =
				    HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * MTU changes as part of sqd2sqd are not allowed.
			 * Simply keep the same MTU value here, stored in the
			 * qphdl from init2rtr time.
			 */
			qpc->mtu = qp->qp_save_mtu;

			opmask |= (HERMON_CMD_OP_PRIM_PATH |
			    HERMON_CMD_OP_RETRYCNT | HERMON_CMD_OP_ACKTIMEOUT |
			    HERMON_CMD_OP_PRIM_RNRRETRY);
		}

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = rc->rc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * If we are attempting to modify the port for this QP, then
		 * check for valid port number and fill it in.  Also set the
		 * appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PORT) {
			portnum = rc->rc_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum = portnum - 1;
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}
			opmask |= HERMON_CMD_OP_SCHEDQUEUE;
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &rc->rc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = rc->rc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = rc->rc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}

		/*
		 * If we are attempting to modify the number of "outgoing
		 * RDMA resources" for this QP, then check for valid value and
		 * fill it in.  Also set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_RDMARA_OUT) {
			if (hermon_qp_validate_init_depth(state, rc,
			    &sra_max) != DDI_SUCCESS) {
				return (IBT_INVALID_PARAM);
			}
			qpc->sra_max = sra_max;
			opmask |= HERMON_CMD_OP_SRA_SET;
		}

		/*
		 * If we are attempting to modify the number of "incoming
		 * RDMA resources" for this QP, then check for valid value and
		 * update the "rra_max" and "ra_buf_index" fields in the QPC to
		 * point to the pre-allocated RDB resources (in DDR).  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_RDMARA_IN) {
			if (hermon_qp_validate_resp_rsrc(state, rc,
			    &rra_max) != DDI_SUCCESS) {
				return (IBT_INVALID_PARAM);
			}
			qpc->rra_max = rra_max;
			opmask |= HERMON_CMD_OP_RRA_SET;
		}

		/*
		 * If we are attempting to modify the "Local Ack Timeout" value
		 * for this QP, then fill it in and set the appropriate flag in
		 * the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_TIMEOUT) {
			qpc_path = &qpc->pri_addr_path;
			qpc_path->ack_timeout = rc->rc_path.cep_timeout;
			opmask |= HERMON_CMD_OP_ACKTIMEOUT;
		}

		/*
		 * If we are attempting to modify the "Retry Count" for this QP,
		 * then fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_RETRY) {
			qpc->retry_cnt = rc->rc_retry_cnt;
			opmask |= HERMON_CMD_OP_PRIM_RNRRETRY;
		}

		/*
		 * If we are attempting to modify the "RNR Retry Count" for this
		 * QP, then fill it in and set the appropriate flag in the
		 * "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_RNR_NAK_RETRY) {
			qpc_path = &qpc->pri_addr_path;
			qpc->rnr_retry = rc->rc_rnr_retry_cnt;
			opmask |= HERMON_CMD_OP_RETRYCNT;
		}

		/*
		 * If we are attempting to modify the "Minimum RNR NAK" value
		 * for this QP, then fill it in and set the appropriate flag
		 * in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
			qpc->min_rnr_nak = rc->rc_min_rnr_nak;
			opmask |= HERMON_CMD_OP_MINRNRNAK;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		uc = &info_p->qp_transport.uc;

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}

		/*
		 * Check for optional primary path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ADDS_VECT) {
			qpc_path = &qpc->pri_addr_path;
			adds_vect = &uc->uc_path.cep_adds_vect;

			/* Set the common primary address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}
			portnum = qp->qp_portnum + 1;
			if (hermon_portnum_is_valid(state, portnum)) {
				qpc->pri_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * MTU changes as part of sqd2sqd are not allowed.
			 * Simply keep the same MTU value here, stored in the
			 * qphdl from init2rtr time.
			 */
			qpc->mtu = qp->qp_save_mtu;

			opmask |= HERMON_CMD_OP_PRIM_PATH;
		}

		/*
		 * If we are attempting to modify the path migration state for
		 * this QP, then check for valid state and fill it in.  Also
		 * set the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_MIG) {
			if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
				qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
			} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
				qpc->pm_state = HERMON_QP_PMSTATE_REARM;
			} else {
				return (IBT_QP_APM_STATE_INVALID);
			}
			opmask |= HERMON_CMD_OP_PM_STATE;
		}

		/*
		 * If we are attempting to modify the PKey index for this QP,
		 * then check for valid PKey index and fill it in.  Also set
		 * the appropriate flag in the "opmask" parameter.
		 */
		if (flags & IBT_CEP_SET_PKEY_IX) {
			pkeyindx = uc->uc_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->pri_addr_path.pkey_indx = pkeyindx;
				opmask |= HERMON_CMD_OP_PKEYINDX;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
		}

		/*
		 * Check for optional alternate path and fill in the
		 * appropriate QPC fields if one is specified
		 */
		if (flags & IBT_CEP_SET_ALT_PATH) {
			qpc_path = &qpc->alt_addr_path;
			adds_vect = &uc->uc_alt_path.cep_adds_vect;

			/* Set the common alternate address path fields */
			status = hermon_set_addr_path(state, adds_vect,
			    qpc_path, HERMON_ADDRPATH_QP);
			if (status != DDI_SUCCESS) {
				return (status);
			}

			/*
			 * Check for valid alternate path port number and fill
			 * it in
			 */
			portnum = uc->uc_alt_path.cep_hca_port_num;
			if (hermon_portnum_is_valid(state, portnum)) {
				qp->qp_portnum_alt = portnum - 1;
				qpc->alt_addr_path.sched_q =
				    HERMON_QP_SCHEDQ_GET(portnum - 1,
				    adds_vect->av_srvl, qp->qp_is_special);
			} else {
				return (IBT_HCA_PORT_INVALID);
			}

			/*
			 * Check for valid alternate path PKey index and fill
			 * it in
			 */
			pkeyindx = uc->uc_alt_path.cep_pkey_ix;
			if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
				qpc->alt_addr_path.pkey_indx = pkeyindx;
			} else {
				return (IBT_PKEY_IX_ILLEGAL);
			}
			opmask |= HERMON_CMD_OP_ALT_PATH;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in sqd2sqd");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the SQD2SQD_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, SQD2SQD_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: SQD2SQD_QP command failed: "
			    "%08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_sqerr2rts()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_sqerr2rts(hermon_state_t *state, hermon_qphdl_t qp,
    ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
	hermon_hw_qpc_t		*qpc;
	ibt_qp_ud_attr_t	*ud;
	uint32_t		opmask = 0;
	int			status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Since there are no common fields to be filled in for this command,
	 * we begin with the QPC fields which are specific to transport type.
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		ud = &info_p->qp_transport.ud;

		/*
		 * If we are attempting to modify the QKey for this QP, then
		 * fill it in and set the appropriate flag in the "opmask"
		 * parameter.
		 */
		if (flags & IBT_CEP_SET_QKEY) {
			qpc->qkey = ud->ud_qkey;
			opmask |= HERMON_CMD_OP_QKEY;
		}

	} else if (qp->qp_serv_type == HERMON_QP_UC) {

		/*
		 * Check if any of the flags indicate a change in the RDMA
		 * Write (recv) enable/disable and set the appropriate flag
		 * in the "opmask" parameter. Note: RDMA Read and Atomic are
		 * not valid for UC transport.
		 */
		if (flags & IBT_CEP_SET_RDMA_W) {
			qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
			opmask |= HERMON_CMD_OP_RWE;
		}
	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in sqerr2rts");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the SQERR2RTS_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, SQERR2RTS_QP, qpc, qp->qp_qpnum,
	    opmask, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		if (status != HERMON_CMD_BAD_QP_STATE) {
			cmn_err(CE_NOTE, "hermon%d: SQERR2RTS_QP command "
			    "failed: %08x\n", state->hs_instance, status);
			if (status == HERMON_CMD_INVALID_STATUS) {
				hermon_fm_ereport(state, HCA_SYS_ERR,
				    HCA_ERR_SRV_LOST);
			}
			return (ibc_get_ci_failure(0));
		} else {
			return (IBT_QP_STATE_INVALID);
		}
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_to_error()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_to_error(hermon_state_t *state, hermon_qphdl_t qp)
{
	int	status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Post the TOERR_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		cmn_err(CE_NOTE, "hermon%d: TOERR_QP command failed: %08x\n",
		    state->hs_instance, status);
		if (status == HERMON_CMD_INVALID_STATUS) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
		}
		return (ibc_get_ci_failure(0));
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_qp_to_reset()
 *    Context: Can be called from interrupt or base context.
 */
int
hermon_qp_to_reset(hermon_state_t *state, hermon_qphdl_t qp)
{
	hermon_hw_qpc_t	*qpc;
	int		status;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Post the TORST_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, TORST_QP, qpc, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		cmn_err(CE_NOTE, "hermon%d: TORST_QP command failed: %08x\n",
		    state->hs_instance, status);
		if (status == HERMON_CMD_INVALID_STATUS) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
		}
		return (ibc_get_ci_failure(0));
	}
	if (qp->qp_serv_type == HERMON_QP_FEXCH) {
		status = hermon_fcoib_fexch_mkey_fini(state, qp->qp_pdhdl,
		    qp->qp_qpnum, HERMON_CMD_NOSLEEP_SPIN);
		if (status != DDI_SUCCESS)
			cmn_err(CE_NOTE, "hermon%d: fexch_mkey_fini failed "
			    "%08x\n", state->hs_instance, status);
	}
	return (DDI_SUCCESS);
}


/*
 * hermon_qp_reset2err()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_reset2err(hermon_state_t *state, hermon_qphdl_t qp)
{
	hermon_hw_qpc_t	*qpc;
	int		status;
	uint32_t	cqnmask;

	ASSERT(MUTEX_HELD(&qp->qp_lock));

	/*
	 * In order to implement the transition from "Reset" directly to the
	 * "Error" state, it is necessary to first give ownership of the QP
	 * context to the Hermon hardware.  This is accomplished by
	 * transitioning the QP to "Init" as an intermediate step and then,
	 * immediately transitioning to "Error".
	 *
	 * When this function returns success, the QP context will be owned by
	 * the Hermon hardware and will be in the "Error" state.
	 */

	/*
	 * Grab the temporary QPC entry from QP software state
	 */
	qpc = &qp->qpc;

	/*
	 * Fill in the common fields in the QPC
	 */
	if (qp->qp_is_special) {
		qpc->serv_type	= HERMON_QP_MLX;
	} else {
		qpc->serv_type	= qp->qp_serv_type;
	}
	qpc->pm_state		= HERMON_QP_PMSTATE_MIGRATED;
	qpc->usr_page		= qp->qp_uarpg;
	/* dbr is now an address, not an index */
	qpc->dbr_addrh		= ((uint64_t)qp->qp_rq_pdbr >> 32);
	qpc->dbr_addrl		= ((uint64_t)qp->qp_rq_pdbr & 0xFFFFFFFC) >> 2;
	qpc->pd			= qp->qp_pdhdl->pd_pdnum;
	/*
	 * HERMON:
	 * qpc->wqe_baseaddr is replaced by LKey from the cMPT, and
	 * page_offset, mtt_base_addr_h/l, and log2_page_size will
	 * be used to map the WQE buffer
	 * NOTE that the cMPT is created implicitly when the QP is
	 * transitioned from reset to init
	 */
	qpc->log2_pgsz		= qp->qp_mrhdl->mr_log2_pgsz;
	qpc->mtt_base_addrh	= (qp->qp_mrhdl->mr_mttaddr) >> 32 & 0xFF;
	qpc->mtt_base_addrl	= (qp->qp_mrhdl->mr_mttaddr) >> 3 & 0xFFFFFFFF;
	cqnmask = (1 << state->hs_cfg_profile->cp_log_num_cq) - 1;
	qpc->cqn_snd		=
	    (qp->qp_sq_cqhdl == NULL) ? 0 : qp->qp_sq_cqhdl->cq_cqnum & cqnmask;
	qpc->page_offs		= qp->qp_wqinfo.qa_pgoffs >> 6;
	qpc->cqn_rcv		=
	    (qp->qp_rq_cqhdl == NULL) ? 0 : qp->qp_rq_cqhdl->cq_cqnum & cqnmask;

	qpc->sq_wqe_counter	= 0;
	qpc->rq_wqe_counter	= 0;
	qpc->log_sq_stride	= qp->qp_sq_log_wqesz - 4;
	qpc->log_rq_stride	= qp->qp_rq_log_wqesz - 4;
	qpc->log_sq_size	= highbit(qp->qp_sq_bufsz) - 1;
	qpc->log_rq_size	= highbit(qp->qp_rq_bufsz) - 1;
	qpc->srq_en		= (qp->qp_alloc_flags & IBT_QP_USES_SRQ) != 0;
	qpc->sq_no_prefetch	= qp->qp_no_prefetch;

	if (qp->qp_alloc_flags & IBT_QP_USES_SRQ) {
		qpc->srq_number	= qp->qp_srqhdl->srq_srqnum;
	} else {
		qpc->srq_number = 0;
	}

	qpc->fre		= 0; /* default disable fast registration WR */
	qpc->rlky		= 0; /* default disable reserved lkey */

	/*
	 * Now fill in the QPC fields which are specific to transport type
	 */
	if (qp->qp_type == IBT_UD_RQP) {
		/* Set the UD parameters to an invalid default */
		qpc->qkey = 0;
		qpc->pri_addr_path.sched_q =
		    HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
		qpc->pri_addr_path.pkey_indx = 0;

	} else if (qp->qp_serv_type == HERMON_QP_RC) {
		/* Set the RC parameters to invalid default */
		qpc->rre = 0;
		qpc->rwe = 0;
		qpc->rae = 0;
		qpc->alt_addr_path.sched_q =
		    HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
		qpc->pri_addr_path.pkey_indx = 0;

	} else if (qp->qp_serv_type == HERMON_QP_UC) {
		/* Set the UC parameters to invalid default */
		qpc->rwe = 0;
		qpc->alt_addr_path.sched_q =
		    HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
		qpc->pri_addr_path.pkey_indx = 0;

	} else {
		/*
		 * Invalid QP transport type. If we got here then it's a
		 * warning of a probably serious problem.  So print a message
		 * and return failure
		 */
		HERMON_WARNING(state, "unknown QP transport type in rst2err");
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Post the RST2INIT_QP command to the Hermon firmware
	 *
	 * We do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  If we got raised to interrupt level by priority
	 * inversion, we do not want to block in this routine waiting for
	 * success.
	 */
	status = hermon_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		cmn_err(CE_NOTE, "hermon%d: RST2INIT_QP command failed: %08x\n",
		    state->hs_instance, status);
		if (status == HERMON_CMD_INVALID_STATUS) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
		}
		return (ibc_get_ci_failure(0));
	}

	/*
	 * Now post the TOERR_QP command to the Hermon firmware
	 *
	 * We still do a HERMON_NOSLEEP here because we are still holding the
	 * "qp_lock".  Note:  If this fails (which it really never should),
	 * it indicates a serious problem in the HW or SW.  We try to move
	 * the QP back to the "Reset" state if possible and print a warning
	 * message if not.  In any case, we return an error here.
	 */
	status = hermon_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
	    0, HERMON_CMD_NOSLEEP_SPIN);
	if (status != HERMON_CMD_SUCCESS) {
		cmn_err(CE_NOTE, "hermon%d: TOERR_QP command failed: %08x\n",
		    state->hs_instance, status);
		if (status == HERMON_CMD_INVALID_STATUS) {
			hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
		}
		if (hermon_qp_to_reset(state, qp) != DDI_SUCCESS) {
			HERMON_WARNING(state, "failed to reset QP context");
		}
		return (ibc_get_ci_failure(0));
	}

	return (DDI_SUCCESS);
}


/*
 * hermon_check_rdma_enable_flags()
 *    Context: Can be called from interrupt or base context.
 */
static uint_t
hermon_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
    ibt_qp_info_t *info_p, hermon_hw_qpc_t *qpc)
{
	uint_t	opmask = 0;

	if (flags & IBT_CEP_SET_RDMA_R) {
		qpc->rre = (info_p->qp_flags & IBT_CEP_RDMA_RD) ? 1 : 0;
		opmask |= HERMON_CMD_OP_RRE;
	}

	if (flags & IBT_CEP_SET_RDMA_W) {
		qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
		opmask |= HERMON_CMD_OP_RWE;
	}

	if (flags & IBT_CEP_SET_ATOMIC) {
		qpc->rae = (info_p->qp_flags & IBT_CEP_ATOMIC) ? 1 : 0;
		opmask |= HERMON_CMD_OP_RAE;
	}

	return (opmask);
}

/*
 * hermon_qp_validate_resp_rsrc()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_validate_resp_rsrc(hermon_state_t *state, ibt_qp_rc_attr_t *rc,
    uint_t *rra_max)
{
	uint_t	rdma_ra_in;

	rdma_ra_in = rc->rc_rdma_ra_in;

	/*
	 * Check if number of responder resources is too large.  Return an
	 * error if it is
	 */
	if (rdma_ra_in > state->hs_cfg_profile->cp_hca_max_rdma_in_qp) {
		return (IBT_INVALID_PARAM);
	}

	/*
	 * If the number of responder resources is too small, round it up.
	 * Then find the next highest power-of-2
	 */
	if (rdma_ra_in == 0) {
		rdma_ra_in = 1;
	}
	if (ISP2(rdma_ra_in)) {
		*rra_max = highbit(rdma_ra_in) - 1;
	} else {
		*rra_max = highbit(rdma_ra_in);
	}
	return (DDI_SUCCESS);
}


/*
 * hermon_qp_validate_init_depth()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_validate_init_depth(hermon_state_t *state, ibt_qp_rc_attr_t *rc,
    uint_t *sra_max)
{
	uint_t	rdma_ra_out;

	rdma_ra_out = rc->rc_rdma_ra_out;

	/*
	 * Check if requested initiator depth is too large.  Return an error
	 * if it is
	 */
	if (rdma_ra_out > state->hs_cfg_profile->cp_hca_max_rdma_out_qp) {
		return (IBT_INVALID_PARAM);
	}

	/*
	 * If the requested initiator depth is too small, round it up.
	 * Then find the next highest power-of-2
	 */
	if (rdma_ra_out == 0) {
		rdma_ra_out = 1;
	}
	if (ISP2(rdma_ra_out)) {
		*sra_max = highbit(rdma_ra_out) - 1;
	} else {
		*sra_max = highbit(rdma_ra_out);
	}
	return (DDI_SUCCESS);
}


/*
 * hermon_qp_validate_mtu()
 *    Context: Can be called from interrupt or base context.
 */
static int
hermon_qp_validate_mtu(hermon_state_t *state, uint_t mtu)
{
	/*
	 * Check for invalid MTU values (i.e. zero or any value larger than
	 * the HCA's port maximum).
	 */
	if ((mtu == 0) || (mtu > state->hs_cfg_profile->cp_max_mtu)) {
		return (IBT_HCA_PORT_MTU_EXCEEDED);
	}
	return (DDI_SUCCESS);
}