/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* tavor_qpmod.c
* Tavor Queue Pair Modify Routines
*
* This contains all the routines necessary to implement the Tavor
* 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/tavor/tavor.h>
#include <sys/ib/ib_pkt_hdrs.h>
static int tavor_qp_reset2init(tavor_state_t *state, tavor_qphdl_t qp,
ibt_qp_info_t *info_p);
static int tavor_qp_init2init(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_init2rtr(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_rtr2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_rts2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_rts2sqd(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags);
static int tavor_qp_sqd2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_sqd2sqd(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_sqerr2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
static int tavor_qp_to_error(tavor_state_t *state, tavor_qphdl_t qp);
static int tavor_qp_reset2err(tavor_state_t *state, tavor_qphdl_t qp);
static uint_t tavor_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
ibt_qp_info_t *info_p, tavor_hw_qpc_t *qpc);
static int tavor_qp_validate_resp_rsrc(tavor_state_t *state,
ibt_qp_rc_attr_t *rc, uint_t *rra_max);
static int tavor_qp_validate_init_depth(tavor_state_t *state,
ibt_qp_rc_attr_t *rc, uint_t *sra_max);
static int tavor_qp_validate_mtu(tavor_state_t *state, uint_t mtu);
/*
* tavor_qp_modify()
* Context: Can be called from interrupt or base context.
*/
/* ARGSUSED */
int
tavor_qp_modify(tavor_state_t *state, tavor_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;
char *errormsg;
TAVOR_TNF_ENTER(tavor_qp_modify);
/*
* 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 you will find 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 if
* 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 a Tavor 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 (!(TAVOR_QP_TYPE_VALID(info_p->qp_trans, qp->qp_serv_type))) {
mutex_exit(&qp->qp_lock);
TNF_PROBE_1(tavor_qp_modify_inv_qp_trans_fail,
TAVOR_TNF_ERROR, "", tnf_uint, qptrans,
info_p->qp_trans);
TAVOR_TNF_EXIT(tavor_qp_modify);
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 a Tavor 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 = TAVOR_QP_RTR; /* Ready to Receive */
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RTS)) {
/* Convert the current IBTF QP state to a Tavor QP state */
switch (info_p->qp_current_state) {
case IBT_STATE_RTR:
cur_state = TAVOR_QP_RTR; /* Ready to Receive */
break;
case IBT_STATE_RTS:
cur_state = TAVOR_QP_RTS; /* Ready to Send */
break;
case IBT_STATE_SQE:
cur_state = TAVOR_QP_SQERR; /* Send Queue Error */
break;
case IBT_STATE_SQD:
cur_state = TAVOR_QP_SQD; /* SQ Drained */
break;
default:
mutex_exit(&qp->qp_lock);
TNF_PROBE_1(tavor_qp_modify_inv_currqpstate_fail,
TAVOR_TNF_ERROR, "", tnf_uint, qpstate,
info_p->qp_current_state);
TAVOR_TNF_EXIT(tavor_qp_modify);
return (IBT_QP_STATE_INVALID);
}
} else {
cur_state = qp->qp_state;
}
switch (cur_state) {
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "reset: invalid flag");
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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"reset: ambiguous flags");
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 = tavor_qp_reset2init(state, qp, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "reset to init");
goto qpmod_fail;
}
qp->qp_state = TAVOR_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 TAVOR_QP_RESET.
*
* Note: We return here because we do not want to fall
* through to the tavor_wrid_from_reset_handling()
* routine below (since we are not really moving
* _out_ of the "Reset" state.
*/
mutex_exit(&qp->qp_lock);
TNF_PROBE_0_DEBUG(tavor_qp_modify_rst2rst,
TAVOR_TNF_TRACE, "");
TAVOR_TNF_EXIT(tavor_qp_modify);
return (DDI_SUCCESS);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "Reset" to "Error"
*/
status = tavor_qp_reset2err(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "reset to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"reset: invalid transition");
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 tavor_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 = tavor_wrid_from_reset_handling(state, qp);
if (status != DDI_SUCCESS) {
if (tavor_qp_to_reset(state, qp) != DDI_SUCCESS) {
TAVOR_WARNING(state, "failed to reset QP");
}
qp->qp_state = TAVOR_QP_RESET;
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(status, "reset: wrid_from_reset hdl");
goto qpmod_fail;
}
break;
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "init: invalid flag");
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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"init: ambiguous flags");
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 = tavor_qp_init2rtr(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "init to rtr");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RTR;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_INIT)) {
/*
* Attempt to transition from "Init" to "Init"
*/
status = tavor_qp_init2init(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "init to init");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_INIT;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RESET)) {
/*
* Attempt to transition from "Init" to "Reset"
*/
status = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "init to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "Init" to "Error"
*/
status = tavor_qp_to_error(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "init to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"init: invalid transition");
goto qpmod_fail;
}
break;
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "rtr: invalid flag");
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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"reset: ambiguous flags");
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 = tavor_qp_rtr2rts(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rtr to rts");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RTS;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RESET)) {
/*
* Attempt to transition from "RTR" to "Reset"
*/
status = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rtr to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "RTR" to "Error"
*/
status = tavor_qp_to_error(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rtr to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"rtr: invalid transition");
goto qpmod_fail;
}
break;
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "rts: invalid flag");
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 = tavor_qp_rts2rts(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rts to rts");
goto qpmod_fail;
}
/* qp->qp_state = TAVOR_QP_RTS; */
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_SQD)) {
/*
* Attempt to transition from "RTS" to "SQD"
*/
status = tavor_qp_rts2sqd(state, qp, flags);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rts to sqd");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_SQD;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RESET)) {
/*
* Attempt to transition from "RTS" to "Reset"
*/
status = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rts to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "RTS" to "Error"
*/
status = tavor_qp_to_error(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "rts to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"rts: invalid transition");
goto qpmod_fail;
}
break;
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "sqerr: invalid flag");
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 = tavor_qp_sqerr2rts(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqerr to rts");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RTS;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RESET)) {
/*
* Attempt to transition from "SQErr" to "Reset"
*/
status = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqerr to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "SQErr" to "Error"
*/
status = tavor_qp_to_error(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqerr to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"sqerr: invalid transition");
goto qpmod_fail;
}
break;
case TAVOR_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);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_ATTR_RO, "sqd: invalid flag");
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 = tavor_qp_sqd2sqd(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqd to sqd");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_SQD;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RTS)) {
/*
* If still draining SQ, then fail transition attempt
* to RTS.
*/
if (qp->qp_sqd_still_draining) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
status = IBT_QP_STATE_INVALID;
TAVOR_TNF_FAIL(status, "sqd to rts; draining");
goto qpmod_fail;
}
/*
* Attempt to transition from "SQD" to "RTS"
*/
status = tavor_qp_sqd2rts(state, qp, flags, info_p);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqd to rts");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RTS;
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_RESET)) {
/*
* Attempt to transition from "SQD" to "Reset"
*/
status = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqd to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} else if ((flags & IBT_CEP_SET_STATE) &&
(mod_state == IBT_STATE_ERROR)) {
/*
* Attempt to transition from "SQD" to "Error"
*/
status = tavor_qp_to_error(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "sqd to error");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_ERR;
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"sqd: invalid transition");
goto qpmod_fail;
}
break;
case TAVOR_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 = tavor_qp_to_reset(state, qp);
if (status != DDI_SUCCESS) {
mutex_exit(&qp->qp_lock);
/* Set "status"/"errormsg", goto failure */
TAVOR_TNF_FAIL(status, "error to reset");
goto qpmod_fail;
}
qp->qp_state = TAVOR_QP_RESET;
/*
* Do any additional handling necessary for the
* transition _to_ the "Reset" state (e.g. update the
* workQ WRID lists)
*/
tavor_wrid_to_reset_handling(state, qp);
} 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 TAVOR_QP_ERR.
*
*/
mutex_exit(&qp->qp_lock);
TNF_PROBE_0_DEBUG(tavor_qp_modify_err2err,
TAVOR_TNF_TRACE, "");
TAVOR_TNF_EXIT(tavor_qp_modify);
return (DDI_SUCCESS);
} else {
/* Invalid transition - return error */
mutex_exit(&qp->qp_lock);
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID,
"error: invalid transition");
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);
TAVOR_WARNING(state, "unknown QP state in modify");
/* Set "status" and "errormsg" and goto failure */
TAVOR_TNF_FAIL(IBT_QP_STATE_INVALID, "invalid curr QP state");
goto qpmod_fail;
}
mutex_exit(&qp->qp_lock);
TAVOR_TNF_EXIT(tavor_qp_modify);
return (DDI_SUCCESS);
qpmod_fail:
TNF_PROBE_1(tavor_qp_modify_fail, TAVOR_TNF_ERROR, "",
tnf_string, msg, errormsg);
TAVOR_TNF_EXIT(tavor_qp_modify);
return (status);
}
/*
* tavor_qp_reset2init()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_reset2init(tavor_state_t *state, tavor_qphdl_t qp,
ibt_qp_info_t *info_p)
{
tavor_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;
TAVOR_TNF_ENTER(tavor_qp_reset2init);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Fill in the common and/or Tavor-specific fields in the QPC
*/
if (qp->qp_is_special) {
qpc->serv_type = TAVOR_QP_MLX;
} else {
qpc->serv_type = qp->qp_serv_type;
}
qpc->pm_state = TAVOR_QP_PMSTATE_MIGRATED;
qpc->de = TAVOR_QP_DESC_EVT_ENABLED;
qpc->sched_q = TAVOR_QP_SCHEDQ_GET(qp->qp_qpnum);
if (qp->qp_is_umap) {
qpc->usr_page = qp->qp_uarpg;
} else {
qpc->usr_page = 0;
}
qpc->pd = qp->qp_pdhdl->pd_pdnum;
qpc->wqe_baseaddr = 0;
qpc->wqe_lkey = qp->qp_mrhdl->mr_lkey;
qpc->ssc = qp->qp_sq_sigtype;
qpc->cqn_snd = qp->qp_sq_cqhdl->cq_cqnum;
qpc->rsc = TAVOR_QP_RQ_ALL_SIGNALED;
qpc->cqn_rcv = qp->qp_rq_cqhdl->cq_cqnum;
qpc->srq_en = qp->qp_srq_en;
if (qp->qp_srq_en == TAVOR_QP_SRQ_ENABLED) {
qpc->srq_number = qp->qp_srqhdl->srq_srqnum;
} else {
qpc->srq_number = 0;
}
/*
* Now fill in the QPC fields which are specific to transport type
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
ud = &info_p->qp_transport.ud;
/* Set the QKey */
qpc->qkey = ud->ud_qkey;
/* Check for valid port number and fill it in */
portnum = ud->ud_port;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port, portnum);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (IBT_HCA_PORT_INVALID);
}
/* Check for valid PKey index and fill it in */
pkeyindx = ud->ud_pkey_ix;
if (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
qp->qp_pkeyindx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx, pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (IBT_PKEY_IX_ILLEGAL);
}
} else if (qp->qp_serv_type == TAVOR_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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port, portnum);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (IBT_HCA_PORT_INVALID);
}
/* Check for valid PKey index and fill it in */
pkeyindx = rc->rc_path.cep_pkey_ix;
if (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx, pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (IBT_PKEY_IX_ILLEGAL);
}
} else if (qp->qp_serv_type == TAVOR_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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port, portnum);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (IBT_HCA_PORT_INVALID);
}
/* Check for valid PKey index and fill it in */
pkeyindx = uc->uc_path.cep_pkey_ix;
if (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_reset2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx, pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
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
*/
TAVOR_WARNING(state, "unknown QP transport type in rst2init");
TNF_PROBE_0(tavor_qp_reset2init_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (ibc_get_ci_failure(0));
}
/*
* Post the RST2INIT_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
cmn_err(CE_CONT, "Tavor: RST2INIT_QP command failed: %08x\n",
status);
TNF_PROBE_1(tavor_qp_reset2init_cmd_fail, TAVOR_TNF_ERROR, "",
tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (ibc_get_ci_failure(0));
}
TAVOR_TNF_EXIT(tavor_qp_reset2init);
return (DDI_SUCCESS);
}
/*
* tavor_qp_init2init()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_init2init(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_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;
TAVOR_TNF_ENTER(tavor_qp_init2init);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port,
portnum);
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (IBT_HCA_PORT_INVALID);
}
opmask |= TAVOR_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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
qp->qp_pkeyindx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2init);
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port,
portnum);
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (IBT_HCA_PORT_INVALID);
}
opmask |= TAVOR_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 = rc->rc_path.cep_pkey_ix;
if (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2init);
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 |= tavor_check_rdma_enable_flags(flags, info_p, qpc);
} else if (qp->qp_serv_type == TAVOR_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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port,
portnum);
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (IBT_HCA_PORT_INVALID);
}
opmask |= TAVOR_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 = uc->uc_path.cep_pkey_ix;
if (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_init2init_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2init);
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 |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in init2init");
TNF_PROBE_0(tavor_qp_init2init_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (ibc_get_ci_failure(0));
}
/*
* Post the INIT2INIT_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, INIT2INIT_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: INIT2INIT_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_init2init_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_init2init_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_init2init);
return (DDI_SUCCESS);
}
/*
* tavor_qp_init2rtr()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_init2rtr(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_rc_attr_t *rc;
ibt_qp_ud_attr_t *ud;
ibt_qp_uc_attr_t *uc;
tavor_hw_addr_path_t *qpc_path;
ibt_adds_vect_t *adds_vect;
uint_t portnum, pkeyindx, rdma_ra_in, rra_max;
uint_t mtu;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_init2rtr);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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, Tavor HW requires us to
* set the MTU to 4 (which is the IB code for a 2K MTU).
* If this is not a special QP, then we set the MTU to the
* configured maximum (which defaults to 2K). Note: the
* QPC "msg_max" must also be set so as to correspond with
* the specified MTU value.
*/
if (qp->qp_is_special) {
qpc->mtu = 4;
} else {
qpc->mtu = state->ts_cfg_profile->cp_max_mtu;
}
qpc->msg_max = qpc->mtu + 7; /* must equal MTU plus seven */
/*
* 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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
qp->qp_pkeyindx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_init2rtr_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (status);
}
/*
* 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_path->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 = TAVOR_QP_LOG_MAX_MSGSZ;
/*
* If this QP is using an SRQ, 'ric' must be set to 1.
*/
qpc->ric = (qp->qp_srq_en == TAVOR_QP_SRQ_ENABLED) ? 1 : 0;
mtu = rc->rc_path_mtu;
if (tavor_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_init2rtr_inv_mtu_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mtu, mtu);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 Tavor. So we hardcode the
* optional flag here.
*/
qpc->min_rnr_nak = rc->rc_min_rnr_nak;
opmask |= TAVOR_CMD_OP_MINRNRNAK;
/*
* Check that the number of specified "incoming RDMA resources"
* is valid. And if it is, then setup the "rra_max" and
* "ra_buf_index" fields in the QPC to point to the
* pre-allocated RDB resources (in DDR)
*/
rdma_ra_in = rc->rc_rdma_ra_in;
if (tavor_qp_validate_resp_rsrc(state, rc, &rra_max) !=
DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_init2rtr_inv_rdma_in_fail,
TAVOR_TNF_ERROR, "", tnf_uint, rdma_ra_in,
rdma_ra_in);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (IBT_INVALID_PARAM);
}
qpc->rra_max = rra_max;
qpc->ra_buff_indx = qp->qp_rdb_ddraddr >> TAVOR_RDB_SIZE_SHIFT;
/*
* 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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 |= tavor_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_init2rtr_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (status);
}
qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
/*
* Copy the "RNR Retry count" value from the primary
* path. Just as we did above, we need to hardcode
* the optional flag here (see below).
*/
qpc_path->rnr_retry = rc->rc_rnr_retry_cnt;
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = rc->rc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= (TAVOR_CMD_OP_ALT_PATH |
TAVOR_CMD_OP_ALT_RNRRETRY);
}
} else if (qp->qp_serv_type == TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_init2rtr_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (status);
}
/*
* 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 = TAVOR_QP_LOG_MAX_MSGSZ;
mtu = uc->uc_path_mtu;
if (tavor_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_init2rtr_inv_mtu_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mtu, mtu);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_init2rtr_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (status);
}
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = uc->uc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_init2rtr_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in init2rtr");
TNF_PROBE_0(tavor_qp_init2rtr_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (ibc_get_ci_failure(0));
}
/*
* Post the INIT2RTR_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, INIT2RTR_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: INIT2RTR_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_init2rtr_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_init2rtr_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_init2rtr);
return (DDI_SUCCESS);
}
/*
* tavor_qp_rtr2rts()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_rtr2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_rc_attr_t *rc;
ibt_qp_ud_attr_t *ud;
ibt_qp_uc_attr_t *uc;
tavor_hw_addr_path_t *qpc_path;
ibt_adds_vect_t *adds_vect;
uint_t portnum, pkeyindx, rdma_ra_out, sra_max;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_rtr2rts);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Fill in the common and/or Tavor-specific fields in the QPC
*/
qpc->flight_lim = TAVOR_QP_FLIGHT_LIM_UNLIMITED;
/*
* Now fill in the QPC fields which are specific to transport type
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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_path->rnr_retry = rc->rc_rnr_retry_cnt;
qpc->retry_cnt = rc->rc_retry_cnt;
/*
* Set "ack_req_freq" based on the configuration variable
*/
qpc->ack_req_freq = state->ts_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
*/
rdma_ra_out = rc->rc_rdma_ra_out;
if (tavor_qp_validate_init_depth(state, rc, &sra_max) !=
DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_rdma_out_fail,
TAVOR_TNF_ERROR, "", tnf_uint, rdma_ra_out,
rdma_ra_out);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_INVALID_PARAM);
}
qpc->sra_max = sra_max;
/*
* Configure the QP to allow (sending of) all types of RC
* traffic. Tavor hardware allows these bits to be set to
* zero (thereby disabling certain outgoing RDMA types), but
* we do not desire to do this.
*/
qpc->sre = qpc->swe = qpc->sae = 1;
qpc->sic = 0;
/*
* 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 |= tavor_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
rc->rc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_rtr2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (status);
}
qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
/*
* Copy the "RNR Retry count" value from the primary
* path. Just as we did above, we need to hardcode
* the optional flag here (see below).
*/
qpc_path->rnr_retry = rc->rc_rnr_retry_cnt;
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = rc->rc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= (TAVOR_CMD_OP_ALT_PATH |
TAVOR_CMD_OP_ALT_RNRRETRY);
}
} else if (qp->qp_serv_type == TAVOR_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).
*/
qpc->swe = 1;
/*
* 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 |= TAVOR_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
uc->uc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_rtr2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (status);
}
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = uc->uc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_rtr2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in rtr2rts");
TNF_PROBE_0(tavor_qp_rtr2rts_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (ibc_get_ci_failure(0));
}
/*
* Post the RTR2RTS_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, RTR2RTS_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: RTR2RTS_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_rtr2rts_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_rtr2rts_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_rtr2rts);
return (DDI_SUCCESS);
}
/*
* tavor_qp_rts2rts()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_rts2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_rc_attr_t *rc;
ibt_qp_ud_attr_t *ud;
ibt_qp_uc_attr_t *uc;
tavor_hw_addr_path_t *qpc_path;
ibt_adds_vect_t *adds_vect;
uint_t portnum, pkeyindx;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_rts2rts);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 |= tavor_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
rc->rc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_rts2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
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 (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_CMD_OP_ALT_PATH;
}
} else if (qp->qp_serv_type == TAVOR_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 |= TAVOR_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
uc->uc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_rts2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (status);
}
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = uc->uc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_rts2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in rts2rts");
TNF_PROBE_0(tavor_qp_rts2rts_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (ibc_get_ci_failure(0));
}
/*
* Post the RTS2RTS_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, RTS2RTS_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: RTS2RTS_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_rts2rts_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_rts2rts_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_rts2rts);
return (DDI_SUCCESS);
}
/*
* tavor_qp_rts2sqd()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_rts2sqd(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags)
{
int status;
TAVOR_TNF_ENTER(tavor_qp_rts2sqd);
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 Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, RTS2SQD_QP, NULL, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: RTS2SQD_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_rts2sqd_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_rts2sqd);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_rts2sqd_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_rts2sqd);
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 tavor_qp.c)
*/
qp->qp_sqd_still_draining = 1;
TAVOR_TNF_EXIT(tavor_qp_rts2sqd);
return (DDI_SUCCESS);
}
/*
* tavor_qp_sqd2rts()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_sqd2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_rc_attr_t *rc;
ibt_qp_ud_attr_t *ud;
ibt_qp_uc_attr_t *uc;
tavor_hw_addr_path_t *qpc_path;
ibt_adds_vect_t *adds_vect;
uint_t portnum, pkeyindx;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_sqd2rts);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 |= tavor_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
rc->rc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
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 (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_CMD_OP_ALT_PATH;
}
/*
* 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 |= TAVOR_CMD_OP_MINRNRNAK;
}
} else if (qp->qp_serv_type == TAVOR_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 |= TAVOR_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
uc->uc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2rts_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (status);
}
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = uc->uc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_sqd2rts_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in sqd2rts");
TNF_PROBE_0(tavor_qp_sqd2rts_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (ibc_get_ci_failure(0));
}
/*
* Post the SQD2RTS_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, SQD2RTS_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: SQD2RTS_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_sqd2rts_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_sqd2rts_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_sqd2rts);
return (DDI_SUCCESS);
}
/*
* tavor_qp_sqd2sqd()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_sqd2sqd(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_rc_attr_t *rc;
ibt_qp_ud_attr_t *ud;
ibt_qp_uc_attr_t *uc;
tavor_hw_addr_path_t *qpc_path;
ibt_adds_vect_t *adds_vect;
uint_t portnum, pkeyindx, rdma_ra_out, rdma_ra_in;
uint_t rra_max, sra_max;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_sqd2sqd);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
ud = &info_p->qp_transport.ud;
/*
* 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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
qp->qp_pkeyindx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 |= tavor_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2sqd_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (status);
}
qpc_path->rnr_retry = rc->rc_rnr_retry_cnt;
qpc_path->ack_timeout = rc->rc_path.cep_timeout;
qpc->retry_cnt = rc->rc_retry_cnt;
/*
* 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 |= (TAVOR_CMD_OP_PRIM_PATH |
TAVOR_CMD_OP_RETRYCNT | TAVOR_CMD_OP_ACKTIMEOUT |
TAVOR_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (rc->rc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
rc->rc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_pkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 (tavor_portnum_is_valid(state, portnum)) {
qpc->pri_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_port_fail,
TAVOR_TNF_ERROR, "", tnf_uint, port,
portnum);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_HCA_PORT_INVALID);
}
opmask |= TAVOR_CMD_OP_PRIM_PORT;
}
/*
* 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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2sqd_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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) {
rdma_ra_out = rc->rc_rdma_ra_out;
if (tavor_qp_validate_init_depth(state, rc,
&sra_max) != DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_rdma_out_fail,
TAVOR_TNF_ERROR, "", tnf_uint, rdma_ra_out,
rdma_ra_out);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_INVALID_PARAM);
}
qpc->sra_max = sra_max;
opmask |= TAVOR_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) {
rdma_ra_in = rc->rc_rdma_ra_in;
if (tavor_qp_validate_resp_rsrc(state, rc,
&rra_max) != DDI_SUCCESS) {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_rdma_in_fail,
TAVOR_TNF_ERROR, "", tnf_uint, rdma_ra_in,
rdma_ra_in);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_INVALID_PARAM);
}
qpc->rra_max = rra_max;
qpc->ra_buff_indx = qp->qp_rdb_ddraddr >>
TAVOR_RDB_SIZE_SHIFT;
opmask |= TAVOR_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 |= TAVOR_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 |= TAVOR_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_path->rnr_retry = rc->rc_rnr_retry_cnt;
opmask |= TAVOR_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 |= TAVOR_CMD_OP_MINRNRNAK;
}
} else if (qp->qp_serv_type == TAVOR_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 |= TAVOR_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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2sqd_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (status);
}
/*
* 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 |= TAVOR_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 = TAVOR_QP_PMSTATE_MIGRATED;
} else if (uc->uc_mig_state == IBT_STATE_REARMED) {
qpc->pm_state = TAVOR_QP_PMSTATE_REARM;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_mig_state_fail,
TAVOR_TNF_ERROR, "", tnf_uint, mig_state,
uc->uc_mig_state);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_QP_APM_STATE_INVALID);
}
opmask |= TAVOR_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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->pri_addr_path.pkey_indx = pkeyindx;
opmask |= TAVOR_CMD_OP_PKEYINDX;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_pkey,
TAVOR_TNF_ERROR, "", tnf_uint, pkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 = tavor_set_addr_path(state, adds_vect, qpc_path,
TAVOR_ADDRPATH_QP, qp);
if (status != DDI_SUCCESS) {
TNF_PROBE_0(tavor_qp_sqd2sqd_setaddrpath_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (status);
}
/*
* Check for valid alternate path port number and fill
* it in
*/
portnum = uc->uc_alt_path.cep_hca_port_num;
if (tavor_portnum_is_valid(state, portnum)) {
qpc->alt_addr_path.portnum = portnum;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_altport_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altport,
portnum);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
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 (tavor_pkeyindex_is_valid(state, pkeyindx)) {
qpc->alt_addr_path.pkey_indx = pkeyindx;
} else {
TNF_PROBE_1(tavor_qp_sqd2sqd_inv_altpkey_fail,
TAVOR_TNF_ERROR, "", tnf_uint, altpkeyindx,
pkeyindx);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_PKEY_IX_ILLEGAL);
}
opmask |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in sqd2sqd");
TNF_PROBE_0(tavor_qp_sqd2sqd_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (ibc_get_ci_failure(0));
}
/*
* Post the SQD2SQD_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, SQD2SQD_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: SQD2SQD_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_sqd2sqd_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_sqd2sqd_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_sqd2sqd);
return (DDI_SUCCESS);
}
/*
* tavor_qp_sqerr2rts()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_sqerr2rts(tavor_state_t *state, tavor_qphdl_t qp,
ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
{
tavor_hw_qpc_t *qpc;
ibt_qp_ud_attr_t *ud;
uint32_t opmask = 0;
int status;
TAVOR_TNF_ENTER(tavor_qp_sqerr2rts);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Since there are no common and/or Tavor-specific fields to be filled
* in for this command, we begin with the QPC fields which are
* specific to transport type.
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
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 |= TAVOR_CMD_OP_QKEY;
}
} else if (qp->qp_serv_type == TAVOR_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 |= TAVOR_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
*/
TAVOR_WARNING(state, "unknown QP transport type in sqerr2rts");
TNF_PROBE_0(tavor_qp_sqerr2rts_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqerr2rts);
return (ibc_get_ci_failure(0));
}
/*
* Post the SQERR2RTS_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, SQERR2RTS_QP, qpc, qp->qp_qpnum,
opmask, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
if (status != TAVOR_CMD_BAD_QP_STATE) {
cmn_err(CE_CONT, "Tavor: SQERR2RTS_QP command failed: "
"%08x\n", status);
TNF_PROBE_1(tavor_qp_sqerr2rts_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_sqerr2rts);
return (ibc_get_ci_failure(0));
} else {
TNF_PROBE_0(tavor_qp_sqerr2rts_inv_qpstate_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_sqerr2rts);
return (IBT_QP_STATE_INVALID);
}
}
TAVOR_TNF_EXIT(tavor_qp_sqerr2rts);
return (DDI_SUCCESS);
}
/*
* tavor_qp_to_error()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_to_error(tavor_state_t *state, tavor_qphdl_t qp)
{
int status;
TAVOR_TNF_ENTER(tavor_qp_to_error);
ASSERT(MUTEX_HELD(&qp->qp_lock));
/*
* Post the TOERR_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
cmn_err(CE_CONT, "Tavor: TOERR_QP command failed: %08x\n",
status);
TNF_PROBE_1(tavor_qp_to_error_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_to_error);
return (ibc_get_ci_failure(0));
}
TAVOR_TNF_EXIT(tavor_qp_to_error);
return (DDI_SUCCESS);
}
/*
* tavor_qp_to_reset()
* Context: Can be called from interrupt or base context.
*/
int
tavor_qp_to_reset(tavor_state_t *state, tavor_qphdl_t qp)
{
tavor_hw_qpc_t *qpc;
int status;
TAVOR_TNF_ENTER(tavor_qp_to_reset);
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 Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, TORST_QP, qpc, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
cmn_err(CE_CONT, "Tavor: TORST_QP command failed: %08x\n",
status);
TNF_PROBE_1(tavor_qp_to_reset_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_to_reset);
return (ibc_get_ci_failure(0));
}
TAVOR_TNF_EXIT(tavor_qp_to_reset);
return (DDI_SUCCESS);
}
/*
* tavor_qp_reset2err()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_reset2err(tavor_state_t *state, tavor_qphdl_t qp)
{
tavor_hw_qpc_t *qpc;
int status;
TAVOR_TNF_ENTER(tavor_qp_reset2err);
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 Tavor 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 Tavor hardware and will be in the "Error" state.
*/
/*
* Grab the temporary QPC entry from QP software state
*/
qpc = &qp->qpc;
/*
* Fill in the common and/or Tavor-specific fields in the QPC
*/
if (qp->qp_is_special) {
qpc->serv_type = TAVOR_QP_MLX;
} else {
qpc->serv_type = qp->qp_serv_type;
}
qpc->pm_state = TAVOR_QP_PMSTATE_MIGRATED;
qpc->de = TAVOR_QP_DESC_EVT_ENABLED;
qpc->sched_q = TAVOR_QP_SCHEDQ_GET(qp->qp_qpnum);
if (qp->qp_is_umap) {
qpc->usr_page = qp->qp_uarpg;
} else {
qpc->usr_page = 0;
}
qpc->pd = qp->qp_pdhdl->pd_pdnum;
qpc->wqe_baseaddr = 0;
qpc->wqe_lkey = qp->qp_mrhdl->mr_lkey;
qpc->ssc = qp->qp_sq_sigtype;
qpc->cqn_snd = qp->qp_sq_cqhdl->cq_cqnum;
qpc->rsc = TAVOR_QP_RQ_ALL_SIGNALED;
qpc->cqn_rcv = qp->qp_rq_cqhdl->cq_cqnum;
qpc->srq_en = qp->qp_srq_en;
if (qp->qp_srq_en == TAVOR_QP_SRQ_ENABLED) {
qpc->srq_number = qp->qp_srqhdl->srq_srqnum;
} else {
qpc->srq_number = 0;
}
/*
* Now fill in the QPC fields which are specific to transport type
*/
if (qp->qp_serv_type == TAVOR_QP_UD) {
/* Set the UD parameters to an invalid default */
qpc->qkey = 0;
qpc->pri_addr_path.portnum = 1;
qpc->pri_addr_path.pkey_indx = 0;
} else if (qp->qp_serv_type == TAVOR_QP_RC) {
/* Set the RC parameters to invalid default */
qpc->rre = 0;
qpc->rwe = 0;
qpc->rae = 0;
qpc->pri_addr_path.portnum = 1;
qpc->pri_addr_path.pkey_indx = 0;
} else if (qp->qp_serv_type == TAVOR_QP_UC) {
/* Set the UC parameters to invalid default */
qpc->rwe = 0;
qpc->pri_addr_path.portnum = 1;
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
*/
TAVOR_WARNING(state, "unknown QP transport type in rst2err");
TNF_PROBE_0(tavor_qp_reset2err_inv_transtype_fail,
TAVOR_TNF_ERROR, "");
TAVOR_TNF_EXIT(tavor_qp_reset2err);
return (ibc_get_ci_failure(0));
}
/*
* Post the RST2INIT_QP command to the Tavor firmware
*
* We do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
cmn_err(CE_CONT, "Tavor: RST2INIT_QP command failed: %08x\n",
status);
TNF_PROBE_1(tavor_qp_reset2err_rst2init_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_reset2err);
return (ibc_get_ci_failure(0));
}
/*
* Now post the TOERR_QP command to the Tavor firmware
*
* We still do a TAVOR_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 = tavor_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
0, TAVOR_CMD_NOSLEEP_SPIN);
if (status != TAVOR_CMD_SUCCESS) {
cmn_err(CE_CONT, "Tavor: TOERR_QP command failed: %08x\n",
status);
if (tavor_qp_to_reset(state, qp) != DDI_SUCCESS) {
TAVOR_WARNING(state, "failed to reset QP context");
}
TNF_PROBE_1(tavor_qp_reset2err_toerr_cmd_fail,
TAVOR_TNF_ERROR, "", tnf_uint, status, status);
TAVOR_TNF_EXIT(tavor_qp_reset2err);
return (ibc_get_ci_failure(0));
}
TAVOR_TNF_EXIT(tavor_qp_reset2err);
return (DDI_SUCCESS);
}
/*
* tavor_check_rdma_enable_flags()
* Context: Can be called from interrupt or base context.
*/
static uint_t
tavor_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
ibt_qp_info_t *info_p, tavor_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 |= TAVOR_CMD_OP_RRE;
}
if (flags & IBT_CEP_SET_RDMA_W) {
qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
opmask |= TAVOR_CMD_OP_RWE;
}
if (flags & IBT_CEP_SET_ATOMIC) {
qpc->rae = (info_p->qp_flags & IBT_CEP_ATOMIC) ? 1 : 0;
opmask |= TAVOR_CMD_OP_RAE;
}
return (opmask);
}
/*
* tavor_qp_validate_resp_rsrc()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_validate_resp_rsrc(tavor_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->ts_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);
}
/*
* tavor_qp_validate_init_depth()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_validate_init_depth(tavor_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->ts_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);
}
/*
* tavor_qp_validate_mtu()
* Context: Can be called from interrupt or base context.
*/
static int
tavor_qp_validate_mtu(tavor_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->ts_cfg_profile->cp_max_mtu)) {
return (IBT_HCA_PORT_MTU_EXCEEDED);
}
return (DDI_SUCCESS);
}