5255 uts shouldn't open-code ISP2

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 /*
  27  * hermon_qpmod.c
  28  *    Hermon Queue Pair Modify Routines
  29  *
  30  *    This contains all the routines necessary to implement the
  31  *    ModifyQP() verb.  This includes all the code for legal
  32  *    transitions to and from Reset, Init, RTR, RTS, SQD, SQErr,
  33  *    and Error.
  34  */
  35 
  36 #include <sys/sysmacros.h>
  37 #include <sys/types.h>
  38 #include <sys/conf.h>
  39 #include <sys/ddi.h>
  40 #include <sys/sunddi.h>
  41 #include <sys/modctl.h>
  42 #include <sys/bitmap.h>
  43 
  44 #include <sys/ib/adapters/hermon/hermon.h>
  45 #include <sys/ib/ib_pkt_hdrs.h>
  46 
  47 static int hermon_qp_reset2init(hermon_state_t *state, hermon_qphdl_t qp,
  48     ibt_qp_info_t *info_p);
  49 static int hermon_qp_init2init(hermon_state_t *state, hermon_qphdl_t qp,
  50     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  51 static int hermon_qp_init2rtr(hermon_state_t *state, hermon_qphdl_t qp,
  52     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  53 static int hermon_qp_rtr2rts(hermon_state_t *state, hermon_qphdl_t qp,
  54     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  55 static int hermon_qp_rts2rts(hermon_state_t *state, hermon_qphdl_t qp,
  56     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  57 #ifdef HERMON_NOTNOW
  58 static int hermon_qp_rts2sqd(hermon_state_t *state, hermon_qphdl_t qp,
  59     ibt_cep_modify_flags_t flags);
  60 #endif
  61 static int hermon_qp_sqd2rts(hermon_state_t *state, hermon_qphdl_t qp,
  62     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  63 static int hermon_qp_sqd2sqd(hermon_state_t *state, hermon_qphdl_t qp,
  64     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  65 static int hermon_qp_sqerr2rts(hermon_state_t *state, hermon_qphdl_t qp,
  66     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p);
  67 static int hermon_qp_to_error(hermon_state_t *state, hermon_qphdl_t qp);
  68 static int hermon_qp_reset2err(hermon_state_t *state, hermon_qphdl_t qp);
  69 
  70 static uint_t hermon_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
  71     ibt_qp_info_t *info_p, hermon_hw_qpc_t *qpc);
  72 static int hermon_qp_validate_resp_rsrc(hermon_state_t *state,
  73     ibt_qp_rc_attr_t *rc, uint_t *rra_max);
  74 static int hermon_qp_validate_init_depth(hermon_state_t *state,
  75     ibt_qp_rc_attr_t *rc, uint_t *sra_max);
  76 static int hermon_qp_validate_mtu(hermon_state_t *state, uint_t mtu);
  77 
  78 /*
  79  * hermon_qp_modify()
  80  *    Context: Can be called from interrupt or base context.
  81  */
  82 /* ARGSUSED */
  83 int
  84 hermon_qp_modify(hermon_state_t *state, hermon_qphdl_t qp,
  85     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p,
  86     ibt_queue_sizes_t *actual_sz)
  87 {
  88         ibt_cep_state_t         cur_state, mod_state;
  89         ibt_cep_modify_flags_t  okflags;
  90         int                     status;
  91 
  92         /*
  93          * TODO add support for SUSPEND and RESUME
  94          */
  95 
  96         /*
  97          * Lock the QP so that we can modify it atomically.  After grabbing
  98          * the lock, get the current QP state.  We will use this current QP
  99          * state to determine the legal transitions (and the checks that need
 100          * to be performed.)
 101          * Below is a case for every possible QP state.  In each case, we
 102          * check that no flags are set which are not valid for the possible
 103          * transitions from that state.  If these tests pass and the
 104          * state transition we are attempting is legal, then we call one
 105          * of the helper functions.  Each of these functions does some
 106          * additional setup before posting the firmware command for the
 107          * appropriate state transition.
 108          */
 109         mutex_enter(&qp->qp_lock);
 110 
 111         /*
 112          * Verify that the transport type matches between the serv_type and the
 113          * qp_trans.  A caller to IBT must specify the qp_trans field as
 114          * IBT_UD_SRV, IBT_RC_SRV, or IBT_UC_SRV, depending on the QP.  We
 115          * check here that the correct value was specified, based on our
 116          * understanding of the QP serv type.
 117          *
 118          * Because callers specify part of a 'union' based on what QP type they
 119          * think they're working with, this ensures that we do not pickup bogus
 120          * data if the caller thought they were working with a different QP
 121          * type.
 122          */
 123         if (!(HERMON_QP_TYPE_VALID(info_p->qp_trans, qp->qp_serv_type))) {
 124                 mutex_exit(&qp->qp_lock);
 125                 return (IBT_QP_SRV_TYPE_INVALID);
 126         }
 127 
 128         /*
 129          * If this is a transition to RTS (which is valid from RTR, RTS,
 130          * SQError, and SQ Drain) then we should honor the "current QP state"
 131          * specified by the consumer.  This means converting the IBTF QP state
 132          * in "info_p->qp_current_state" to an Hermon QP state.  Otherwise, we
 133          * assume that we already know the current state (i.e. whatever it was
 134          * last modified to or queried as - in "qp->qp_state").
 135          */
 136         mod_state = info_p->qp_state;
 137 
 138         if (flags & IBT_CEP_SET_RTR_RTS) {
 139                 cur_state = HERMON_QP_RTR;              /* Ready to Receive */
 140 
 141         } else if ((flags & IBT_CEP_SET_STATE) &&
 142             (mod_state == IBT_STATE_RTS)) {
 143 
 144                 /* Convert the current IBTF QP state to an Hermon QP state */
 145                 switch (info_p->qp_current_state) {
 146                 case IBT_STATE_RTR:
 147                         cur_state = HERMON_QP_RTR;      /* Ready to Receive */
 148                         break;
 149                 case IBT_STATE_RTS:
 150                         cur_state = HERMON_QP_RTS;      /* Ready to Send */
 151                         break;
 152                 case IBT_STATE_SQE:
 153                         cur_state = HERMON_QP_SQERR;    /* Send Queue Error */
 154                         break;
 155                 case IBT_STATE_SQD:
 156                         cur_state = HERMON_QP_SQD;      /* SQ Drained */
 157                         break;
 158                 default:
 159                         mutex_exit(&qp->qp_lock);
 160                         return (IBT_QP_STATE_INVALID);
 161                 }
 162         } else {
 163                 cur_state = qp->qp_state;
 164         }
 165 
 166         switch (cur_state) {
 167         case HERMON_QP_RESET:
 168                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RESET_INIT |
 169                     IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
 170                     IBT_CEP_SET_ATOMIC | IBT_CEP_SET_PKEY_IX |
 171                     IBT_CEP_SET_PORT | IBT_CEP_SET_QKEY);
 172 
 173                 /*
 174                  * Check for attempts to modify invalid attributes from the
 175                  * "Reset" state
 176                  */
 177                 if (flags & ~okflags) {
 178                         mutex_exit(&qp->qp_lock);
 179                         status = IBT_QP_ATTR_RO;
 180                         goto qpmod_fail;
 181                 }
 182 
 183                 /*
 184                  * Verify state transition is to either "Init", back to
 185                  * "Reset", or to "Error".
 186                  */
 187                 if ((flags & IBT_CEP_SET_RESET_INIT) &&
 188                     (flags & IBT_CEP_SET_STATE) &&
 189                     (mod_state != IBT_STATE_INIT)) {
 190                         /* Invalid transition - ambiguous flags */
 191                         mutex_exit(&qp->qp_lock);
 192                         status = IBT_QP_STATE_INVALID;
 193                         goto qpmod_fail;
 194 
 195                 } else if ((flags & IBT_CEP_SET_RESET_INIT) ||
 196                     ((flags & IBT_CEP_SET_STATE) &&
 197                     (mod_state == IBT_STATE_INIT))) {
 198                         /*
 199                          * Attempt to transition from "Reset" to "Init"
 200                          */
 201                         status = hermon_qp_reset2init(state, qp, info_p);
 202                         if (status != DDI_SUCCESS) {
 203                                 mutex_exit(&qp->qp_lock);
 204                                 goto qpmod_fail;
 205                         }
 206                         qp->qp_state = HERMON_QP_INIT;
 207                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_INIT);
 208 
 209                 } else if ((flags & IBT_CEP_SET_STATE) &&
 210                     (mod_state == IBT_STATE_RESET)) {
 211                         /*
 212                          * Attempt to transition from "Reset" back to "Reset"
 213                          *    Nothing to do here really... just drop the lock
 214                          *    and return success.  The qp->qp_state should
 215                          *    already be set to HERMON_QP_RESET.
 216                          *
 217                          * Note: We return here because we do not want to fall
 218                          *    through to the hermon_wrid_from_reset_handling()
 219                          *    routine below (since we are not really moving
 220                          *    _out_ of the "Reset" state.
 221                          */
 222                         mutex_exit(&qp->qp_lock);
 223                         return (DDI_SUCCESS);
 224 
 225                 } else if ((flags & IBT_CEP_SET_STATE) &&
 226                     (mod_state == IBT_STATE_ERROR)) {
 227                         /*
 228                          * Attempt to transition from "Reset" to "Error"
 229                          */
 230                         status = hermon_qp_reset2err(state, qp);
 231                         if (status != DDI_SUCCESS) {
 232                                 mutex_exit(&qp->qp_lock);
 233                                 goto qpmod_fail;
 234                         }
 235                         qp->qp_state = HERMON_QP_ERR;
 236                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 237 
 238                 } else {
 239                         /* Invalid transition - return error */
 240                         mutex_exit(&qp->qp_lock);
 241                         status = IBT_QP_STATE_INVALID;
 242                         goto qpmod_fail;
 243                 }
 244 
 245                 /*
 246                  * Do any additional handling necessary here for the transition
 247                  * from the "Reset" state (e.g. re-initialize the workQ WRID
 248                  * lists).  Note: If hermon_wrid_from_reset_handling() fails,
 249                  * then we attempt to transition the QP back to the "Reset"
 250                  * state.  If that fails, then it is an indication of a serious
 251                  * problem (either HW or SW).  So we print out a warning
 252                  * message and return failure.
 253                  */
 254                 status = hermon_wrid_from_reset_handling(state, qp);
 255                 if (status != DDI_SUCCESS) {
 256                         if (hermon_qp_to_reset(state, qp) != DDI_SUCCESS) {
 257                                 HERMON_WARNING(state, "failed to reset QP");
 258                         }
 259                         qp->qp_state = HERMON_QP_RESET;
 260                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 261 
 262                         mutex_exit(&qp->qp_lock);
 263                         goto qpmod_fail;
 264                 }
 265                 break;
 266 
 267         case HERMON_QP_INIT:
 268                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_INIT_RTR |
 269                     IBT_CEP_SET_ADDS_VECT | IBT_CEP_SET_RDMARA_IN |
 270                     IBT_CEP_SET_MIN_RNR_NAK | IBT_CEP_SET_ALT_PATH |
 271                     IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
 272                     IBT_CEP_SET_ATOMIC | IBT_CEP_SET_PKEY_IX |
 273                     IBT_CEP_SET_QKEY | IBT_CEP_SET_PORT);
 274 
 275                 /*
 276                  * Check for attempts to modify invalid attributes from the
 277                  * "Init" state
 278                  */
 279                 if (flags & ~okflags) {
 280                         mutex_exit(&qp->qp_lock);
 281                         status = IBT_QP_ATTR_RO;
 282                         goto qpmod_fail;
 283                 }
 284 
 285                 /*
 286                  * Verify state transition is to either "RTR", back to "Init",
 287                  * to "Reset", or to "Error"
 288                  */
 289                 if ((flags & IBT_CEP_SET_INIT_RTR) &&
 290                     (flags & IBT_CEP_SET_STATE) &&
 291                     (mod_state != IBT_STATE_RTR)) {
 292                         /* Invalid transition - ambiguous flags */
 293                         mutex_exit(&qp->qp_lock);
 294                         status = IBT_QP_STATE_INVALID;
 295                         goto qpmod_fail;
 296 
 297                 } else if ((flags & IBT_CEP_SET_INIT_RTR) ||
 298                     ((flags & IBT_CEP_SET_STATE) &&
 299                     (mod_state == IBT_STATE_RTR))) {
 300                         /*
 301                          * Attempt to transition from "Init" to "RTR"
 302                          */
 303                         status = hermon_qp_init2rtr(state, qp, flags, info_p);
 304                         if (status != DDI_SUCCESS) {
 305                                 mutex_exit(&qp->qp_lock);
 306                                 goto qpmod_fail;
 307                         }
 308                         qp->qp_state = HERMON_QP_RTR;
 309                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTR);
 310 
 311                 } else if ((flags & IBT_CEP_SET_STATE) &&
 312                     (mod_state == IBT_STATE_INIT)) {
 313                         /*
 314                          * Attempt to transition from "Init" to "Init"
 315                          */
 316                         status = hermon_qp_init2init(state, qp, flags, info_p);
 317                         if (status != DDI_SUCCESS) {
 318                                 mutex_exit(&qp->qp_lock);
 319                                 goto qpmod_fail;
 320                         }
 321                         qp->qp_state = HERMON_QP_INIT;
 322                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_INIT);
 323 
 324                 } else if ((flags & IBT_CEP_SET_STATE) &&
 325                     (mod_state == IBT_STATE_RESET)) {
 326                         /*
 327                          * Attempt to transition from "Init" to "Reset"
 328                          */
 329                         status = hermon_qp_to_reset(state, qp);
 330                         if (status != DDI_SUCCESS) {
 331                                 mutex_exit(&qp->qp_lock);
 332                                 goto qpmod_fail;
 333                         }
 334                         qp->qp_state = HERMON_QP_RESET;
 335                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 336 
 337                         /*
 338                          * Do any additional handling necessary for the
 339                          * transition _to_ the "Reset" state (e.g. update the
 340                          * workQ WRID lists)
 341                          */
 342                         status = hermon_wrid_to_reset_handling(state, qp);
 343                         if (status != IBT_SUCCESS) {
 344                                 mutex_exit(&qp->qp_lock);
 345                                 goto qpmod_fail;
 346                         }
 347 
 348                 } else if ((flags & IBT_CEP_SET_STATE) &&
 349                     (mod_state == IBT_STATE_ERROR)) {
 350                         /*
 351                          * Attempt to transition from "Init" to "Error"
 352                          */
 353                         status = hermon_qp_to_error(state, qp);
 354                         if (status != DDI_SUCCESS) {
 355                                 mutex_exit(&qp->qp_lock);
 356                                 goto qpmod_fail;
 357                         }
 358                         qp->qp_state = HERMON_QP_ERR;
 359                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 360 
 361                 } else {
 362                         /* Invalid transition - return error */
 363                         mutex_exit(&qp->qp_lock);
 364                         status = IBT_QP_STATE_INVALID;
 365                         goto qpmod_fail;
 366                 }
 367                 break;
 368 
 369         case HERMON_QP_RTR:
 370                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RTR_RTS |
 371                     IBT_CEP_SET_TIMEOUT | IBT_CEP_SET_RETRY |
 372                     IBT_CEP_SET_RNR_NAK_RETRY | IBT_CEP_SET_RDMARA_OUT |
 373                     IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W |
 374                     IBT_CEP_SET_ATOMIC | IBT_CEP_SET_QKEY |
 375                     IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_MIG |
 376                     IBT_CEP_SET_MIN_RNR_NAK);
 377 
 378                 /*
 379                  * Check for attempts to modify invalid attributes from the
 380                  * "RTR" state
 381                  */
 382                 if (flags & ~okflags) {
 383                         mutex_exit(&qp->qp_lock);
 384                         status = IBT_QP_ATTR_RO;
 385                         goto qpmod_fail;
 386                 }
 387 
 388                 /*
 389                  * Verify state transition is to either "RTS", "Reset",
 390                  * or "Error"
 391                  */
 392                 if ((flags & IBT_CEP_SET_RTR_RTS) &&
 393                     (flags & IBT_CEP_SET_STATE) &&
 394                     (mod_state != IBT_STATE_RTS)) {
 395                         /* Invalid transition - ambiguous flags */
 396                         mutex_exit(&qp->qp_lock);
 397                         status = IBT_QP_STATE_INVALID;
 398                         goto qpmod_fail;
 399 
 400                 } else if ((flags & IBT_CEP_SET_RTR_RTS) ||
 401                     ((flags & IBT_CEP_SET_STATE) &&
 402                     (mod_state == IBT_STATE_RTS))) {
 403                         /*
 404                          * Attempt to transition from "RTR" to "RTS"
 405                          */
 406                         status = hermon_qp_rtr2rts(state, qp, flags, info_p);
 407                         if (status != DDI_SUCCESS) {
 408                                 mutex_exit(&qp->qp_lock);
 409                                 goto qpmod_fail;
 410                         }
 411                         qp->qp_state = HERMON_QP_RTS;
 412                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);
 413 
 414                 } else if ((flags & IBT_CEP_SET_STATE) &&
 415                     (mod_state == IBT_STATE_RESET)) {
 416                         /*
 417                          * Attempt to transition from "RTR" to "Reset"
 418                          */
 419                         status = hermon_qp_to_reset(state, qp);
 420                         if (status != DDI_SUCCESS) {
 421                                 mutex_exit(&qp->qp_lock);
 422                                 goto qpmod_fail;
 423                         }
 424                         qp->qp_state = HERMON_QP_RESET;
 425                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 426 
 427                         /*
 428                          * Do any additional handling necessary for the
 429                          * transition _to_ the "Reset" state (e.g. update the
 430                          * workQ WRID lists)
 431                          */
 432                         status = hermon_wrid_to_reset_handling(state, qp);
 433                         if (status != IBT_SUCCESS) {
 434                                 mutex_exit(&qp->qp_lock);
 435                                 goto qpmod_fail;
 436                         }
 437 
 438                 } else if ((flags & IBT_CEP_SET_STATE) &&
 439                     (mod_state == IBT_STATE_ERROR)) {
 440                         /*
 441                          * Attempt to transition from "RTR" to "Error"
 442                          */
 443                         status = hermon_qp_to_error(state, qp);
 444                         if (status != DDI_SUCCESS) {
 445                                 mutex_exit(&qp->qp_lock);
 446                                 goto qpmod_fail;
 447                         }
 448                         qp->qp_state = HERMON_QP_ERR;
 449                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 450 
 451                 } else {
 452                         /* Invalid transition - return error */
 453                         mutex_exit(&qp->qp_lock);
 454                         status = IBT_QP_STATE_INVALID;
 455                         goto qpmod_fail;
 456                 }
 457                 break;
 458 
 459         case HERMON_QP_RTS:
 460                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RDMA_R |
 461                     IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC |
 462                     IBT_CEP_SET_QKEY | IBT_CEP_SET_ALT_PATH |
 463                     IBT_CEP_SET_MIG | IBT_CEP_SET_MIN_RNR_NAK |
 464                     IBT_CEP_SET_SQD_EVENT);
 465 
 466                 /*
 467                  * Check for attempts to modify invalid attributes from the
 468                  * "RTS" state
 469                  */
 470                 if (flags & ~okflags) {
 471                         mutex_exit(&qp->qp_lock);
 472                         status = IBT_QP_ATTR_RO;
 473                         goto qpmod_fail;
 474                 }
 475 
 476                 /*
 477                  * Verify state transition is to either "RTS", "SQD", "Reset",
 478                  * or "Error"
 479                  */
 480                 if ((flags & IBT_CEP_SET_STATE) &&
 481                     (mod_state == IBT_STATE_RTS)) {
 482                         /*
 483                          * Attempt to transition from "RTS" to "RTS"
 484                          */
 485                         status = hermon_qp_rts2rts(state, qp, flags, info_p);
 486                         if (status != DDI_SUCCESS) {
 487                                 mutex_exit(&qp->qp_lock);
 488                                 goto qpmod_fail;
 489                         }
 490                         qp->qp_state = HERMON_QP_RTS;
 491                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);
 492 
 493                 } else if ((flags & IBT_CEP_SET_STATE) &&
 494                     (mod_state == IBT_STATE_SQD)) {
 495 #ifdef HERMON_NOTNOW
 496                         /*
 497                          * Attempt to transition from "RTS" to "SQD"
 498                          */
 499                         status = hermon_qp_rts2sqd(state, qp, flags);
 500                         if (status != DDI_SUCCESS) {
 501                                 mutex_exit(&qp->qp_lock);
 502                                 goto qpmod_fail;
 503                         }
 504                         qp->qp_state = HERMON_QP_SQD;
 505                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);
 506 #else
 507                         /* hack because of the lack of fw support for SQD */
 508                         mutex_exit(&qp->qp_lock);
 509                         status = IBT_QP_STATE_INVALID;
 510                         goto qpmod_fail;
 511 #endif
 512 
 513                 } else if ((flags & IBT_CEP_SET_STATE) &&
 514                     (mod_state == IBT_STATE_RESET)) {
 515                         /*
 516                          * Attempt to transition from "RTS" to "Reset"
 517                          */
 518                         status = hermon_qp_to_reset(state, qp);
 519                         if (status != DDI_SUCCESS) {
 520                                 mutex_exit(&qp->qp_lock);
 521                                 goto qpmod_fail;
 522                         }
 523                         qp->qp_state = HERMON_QP_RESET;
 524                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 525 
 526                         /*
 527                          * Do any additional handling necessary for the
 528                          * transition _to_ the "Reset" state (e.g. update the
 529                          * workQ WRID lists)
 530                          */
 531                         status = hermon_wrid_to_reset_handling(state, qp);
 532                         if (status != IBT_SUCCESS) {
 533                                 mutex_exit(&qp->qp_lock);
 534                                 goto qpmod_fail;
 535                         }
 536 
 537                 } else if ((flags & IBT_CEP_SET_STATE) &&
 538                     (mod_state == IBT_STATE_ERROR)) {
 539                         /*
 540                          * Attempt to transition from "RTS" to "Error"
 541                          */
 542                         status = hermon_qp_to_error(state, qp);
 543                         if (status != DDI_SUCCESS) {
 544                                 mutex_exit(&qp->qp_lock);
 545                                 goto qpmod_fail;
 546                         }
 547                         qp->qp_state = HERMON_QP_ERR;
 548                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 549 
 550                 } else {
 551                         /* Invalid transition - return error */
 552                         mutex_exit(&qp->qp_lock);
 553                         status = IBT_QP_STATE_INVALID;
 554                         goto qpmod_fail;
 555                 }
 556                 break;
 557 
 558         case HERMON_QP_SQERR:
 559                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_RDMA_R |
 560                     IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC |
 561                     IBT_CEP_SET_QKEY | IBT_CEP_SET_MIN_RNR_NAK);
 562 
 563                 /*
 564                  * Check for attempts to modify invalid attributes from the
 565                  * "SQErr" state
 566                  */
 567                 if (flags & ~okflags) {
 568                         mutex_exit(&qp->qp_lock);
 569                         status = IBT_QP_ATTR_RO;
 570                         goto qpmod_fail;
 571                 }
 572 
 573                 /*
 574                  * Verify state transition is to either "RTS", "Reset", or
 575                  * "Error"
 576                  */
 577                 if ((flags & IBT_CEP_SET_STATE) &&
 578                     (mod_state == IBT_STATE_RTS)) {
 579                         /*
 580                          * Attempt to transition from "SQErr" to "RTS"
 581                          */
 582                         status = hermon_qp_sqerr2rts(state, qp, flags, info_p);
 583                         if (status != DDI_SUCCESS) {
 584                                 mutex_exit(&qp->qp_lock);
 585                                 goto qpmod_fail;
 586                         }
 587                         qp->qp_state = HERMON_QP_RTS;
 588                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);
 589 
 590                 } else if ((flags & IBT_CEP_SET_STATE) &&
 591                     (mod_state == IBT_STATE_RESET)) {
 592                         /*
 593                          * Attempt to transition from "SQErr" to "Reset"
 594                          */
 595                         status = hermon_qp_to_reset(state, qp);
 596                         if (status != DDI_SUCCESS) {
 597                                 mutex_exit(&qp->qp_lock);
 598                                 goto qpmod_fail;
 599                         }
 600                         qp->qp_state = HERMON_QP_RESET;
 601                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 602 
 603                         /*
 604                          * Do any additional handling necessary for the
 605                          * transition _to_ the "Reset" state (e.g. update the
 606                          * workQ WRID lists)
 607                          */
 608                         status = hermon_wrid_to_reset_handling(state, qp);
 609                         if (status != IBT_SUCCESS) {
 610                                 mutex_exit(&qp->qp_lock);
 611                                 goto qpmod_fail;
 612                         }
 613 
 614                 } else if ((flags & IBT_CEP_SET_STATE) &&
 615                     (mod_state == IBT_STATE_ERROR)) {
 616                         /*
 617                          * Attempt to transition from "SQErr" to "Error"
 618                          */
 619                         status = hermon_qp_to_error(state, qp);
 620                         if (status != DDI_SUCCESS) {
 621                                 mutex_exit(&qp->qp_lock);
 622                                 goto qpmod_fail;
 623                         }
 624                         qp->qp_state = HERMON_QP_ERR;
 625                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 626 
 627                 } else {
 628                         /* Invalid transition - return error */
 629                         mutex_exit(&qp->qp_lock);
 630                         status = IBT_QP_STATE_INVALID;
 631                         goto qpmod_fail;
 632                 }
 633                 break;
 634 
 635         case HERMON_QP_SQD:
 636                 okflags = (IBT_CEP_SET_STATE | IBT_CEP_SET_ADDS_VECT |
 637                     IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_MIG |
 638                     IBT_CEP_SET_RDMARA_OUT | IBT_CEP_SET_RDMARA_IN |
 639                     IBT_CEP_SET_QKEY | IBT_CEP_SET_PKEY_IX |
 640                     IBT_CEP_SET_TIMEOUT | IBT_CEP_SET_RETRY |
 641                     IBT_CEP_SET_RNR_NAK_RETRY | IBT_CEP_SET_PORT |
 642                     IBT_CEP_SET_MIN_RNR_NAK | IBT_CEP_SET_RDMA_R |
 643                     IBT_CEP_SET_RDMA_W | IBT_CEP_SET_ATOMIC);
 644 
 645                 /*
 646                  * Check for attempts to modify invalid attributes from the
 647                  * "SQD" state
 648                  */
 649                 if (flags & ~okflags) {
 650                         mutex_exit(&qp->qp_lock);
 651                         status = IBT_QP_ATTR_RO;
 652                         goto qpmod_fail;
 653                 }
 654 
 655                 /*
 656                  * Verify state transition is to either "SQD", "RTS", "Reset",
 657                  * or "Error"
 658                  */
 659 
 660                 if ((flags & IBT_CEP_SET_STATE) &&
 661                     (mod_state == IBT_STATE_SQD)) {
 662                         /*
 663                          * Attempt to transition from "SQD" to "SQD"
 664                          */
 665                         status = hermon_qp_sqd2sqd(state, qp, flags, info_p);
 666                         if (status != DDI_SUCCESS) {
 667                                 mutex_exit(&qp->qp_lock);
 668                                 goto qpmod_fail;
 669                         }
 670                         qp->qp_state = HERMON_QP_SQD;
 671                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);
 672 
 673                 } else if ((flags & IBT_CEP_SET_STATE) &&
 674                     (mod_state == IBT_STATE_RTS)) {
 675                         /*
 676                          * If still draining SQ, then fail transition attempt
 677                          * to RTS, even though this is now done is two steps
 678                          * (see below) if the consumer has tried this before
 679                          * it's drained, let him fail and wait appropriately
 680                          */
 681                         if (qp->qp_sqd_still_draining) {
 682                                 mutex_exit(&qp->qp_lock);
 683                                 goto qpmod_fail;
 684                         }
 685                         /*
 686                          * IBA 1.2 has changed - most/all the things that were
 687                          * done in SQD2RTS can be done in SQD2SQD.  So make this
 688                          * a 2-step process.  First, set any attributes requsted
 689                          * w/ SQD2SQD, but no real transition.
 690                          *
 691                          * First, Attempt to transition from "SQD" to "SQD"
 692                          */
 693                         status = hermon_qp_sqd2sqd(state, qp, flags, info_p);
 694                         if (status != DDI_SUCCESS) {
 695                                 mutex_exit(&qp->qp_lock);
 696                                 goto qpmod_fail;
 697                         }
 698                         qp->qp_state = HERMON_QP_SQD;
 699                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_SQD);
 700 
 701                         /*
 702                          * The, attempt to transition from "SQD" to "RTS", but
 703                          * request only the state transition, no attributes
 704                          */
 705 
 706                         status = hermon_qp_sqd2rts(state, qp,
 707                             IBT_CEP_SET_STATE, info_p);
 708                         if (status != DDI_SUCCESS) {
 709                                 mutex_exit(&qp->qp_lock);
 710                                 goto qpmod_fail;
 711                         }
 712                         qp->qp_state = HERMON_QP_RTS;
 713                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RTS);
 714 
 715                 } else if ((flags & IBT_CEP_SET_STATE) &&
 716                     (mod_state == IBT_STATE_RESET)) {
 717                         /*
 718                          * Attempt to transition from "SQD" to "Reset"
 719                          */
 720                         status = hermon_qp_to_reset(state, qp);
 721                         if (status != DDI_SUCCESS) {
 722                                 mutex_exit(&qp->qp_lock);
 723                                 goto qpmod_fail;
 724                         }
 725                         qp->qp_state = HERMON_QP_RESET;
 726                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 727 
 728                         /*
 729                          * Do any additional handling necessary for the
 730                          * transition _to_ the "Reset" state (e.g. update the
 731                          * workQ WRID lists)
 732                          */
 733                         status = hermon_wrid_to_reset_handling(state, qp);
 734                         if (status != IBT_SUCCESS) {
 735                                 mutex_exit(&qp->qp_lock);
 736                                 goto qpmod_fail;
 737                         }
 738 
 739                 } else if ((flags & IBT_CEP_SET_STATE) &&
 740                     (mod_state == IBT_STATE_ERROR)) {
 741                         /*
 742                          * Attempt to transition from "SQD" to "Error"
 743                          */
 744                         status = hermon_qp_to_error(state, qp);
 745                         if (status != DDI_SUCCESS) {
 746                                 mutex_exit(&qp->qp_lock);
 747                                 goto qpmod_fail;
 748                         }
 749                         qp->qp_state = HERMON_QP_ERR;
 750                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_ERR);
 751 
 752                 } else {
 753                         /* Invalid transition - return error */
 754                         mutex_exit(&qp->qp_lock);
 755                         status = IBT_QP_STATE_INVALID;
 756                         goto qpmod_fail;
 757                 }
 758                 break;
 759 
 760         case HERMON_QP_ERR:
 761                 /*
 762                  * Verify state transition is to either "Reset" or back to
 763                  * "Error"
 764                  */
 765                 if ((flags & IBT_CEP_SET_STATE) &&
 766                     (mod_state == IBT_STATE_RESET)) {
 767                         /*
 768                          * Attempt to transition from "Error" to "Reset"
 769                          */
 770                         status = hermon_qp_to_reset(state, qp);
 771                         if (status != DDI_SUCCESS) {
 772                                 mutex_exit(&qp->qp_lock);
 773                                 goto qpmod_fail;
 774                         }
 775                         qp->qp_state = HERMON_QP_RESET;
 776                         HERMON_SET_QP_POST_SEND_STATE(qp, HERMON_QP_RESET);
 777 
 778                         /*
 779                          * Do any additional handling necessary for the
 780                          * transition _to_ the "Reset" state (e.g. update the
 781                          * workQ WRID lists)
 782                          */
 783                         status = hermon_wrid_to_reset_handling(state, qp);
 784                         if (status != IBT_SUCCESS) {
 785                                 mutex_exit(&qp->qp_lock);
 786                                 goto qpmod_fail;
 787                         }
 788 
 789                 } else if ((flags & IBT_CEP_SET_STATE) &&
 790                     (mod_state == IBT_STATE_ERROR)) {
 791                         /*
 792                          * Attempt to transition from "Error" back to "Error"
 793                          *    Nothing to do here really... just drop the lock
 794                          *    and return success.  The qp->qp_state should
 795                          *    already be set to HERMON_QP_ERR.
 796                          *
 797                          */
 798                         mutex_exit(&qp->qp_lock);
 799                         return (DDI_SUCCESS);
 800 
 801                 } else {
 802                         /* Invalid transition - return error */
 803                         mutex_exit(&qp->qp_lock);
 804                         status = IBT_QP_STATE_INVALID;
 805                         goto qpmod_fail;
 806                 }
 807                 break;
 808 
 809         default:
 810                 /*
 811                  * Invalid QP state.  If we got here then it's a warning of
 812                  * a probably serious problem.  So print a message and return
 813                  * failure
 814                  */
 815                 mutex_exit(&qp->qp_lock);
 816                 HERMON_WARNING(state, "unknown QP state in modify");
 817                 status = IBT_QP_STATE_INVALID;
 818                 goto qpmod_fail;
 819         }
 820 
 821         mutex_exit(&qp->qp_lock);
 822         return (DDI_SUCCESS);
 823 
 824 qpmod_fail:
 825         return (status);
 826 }
 827 
 828 
 829 /*
 830  * hermon_qp_reset2init()
 831  *    Context: Can be called from interrupt or base context.
 832  */
 833 static int
 834 hermon_qp_reset2init(hermon_state_t *state, hermon_qphdl_t qp,
 835     ibt_qp_info_t *info_p)
 836 {
 837         hermon_hw_qpc_t         *qpc;
 838         ibt_qp_rc_attr_t        *rc;
 839         ibt_qp_ud_attr_t        *ud;
 840         ibt_qp_uc_attr_t        *uc;
 841         uint_t                  portnum, pkeyindx;
 842         int                     status;
 843         uint32_t                cqnmask;
 844         int                     qp_srq_en;
 845 
 846         ASSERT(MUTEX_HELD(&qp->qp_lock));
 847 
 848         /*
 849          * Grab the temporary QPC entry from QP software state
 850          */
 851         qpc = &qp->qpc;
 852 
 853         /*
 854          * Fill in the common fields in the QPC
 855          */
 856 
 857         if (qp->qp_is_special) {
 858                 qpc->serv_type       = HERMON_QP_MLX;
 859         } else {
 860                 qpc->serv_type       = qp->qp_serv_type;
 861         }
 862         qpc->pm_state                = HERMON_QP_PMSTATE_MIGRATED;
 863 
 864         qpc->pd                      = qp->qp_pdhdl->pd_pdnum;
 865 
 866         qpc->log_sq_stride   = qp->qp_sq_log_wqesz - 4;
 867         qpc->log_rq_stride   = qp->qp_rq_log_wqesz - 4;
 868         qpc->sq_no_prefetch  = qp->qp_no_prefetch;
 869         qpc->log_sq_size     = highbit(qp->qp_sq_bufsz) - 1;
 870         qpc->log_rq_size     = highbit(qp->qp_rq_bufsz) - 1;
 871 
 872         qpc->usr_page                = qp->qp_uarpg;
 873 
 874         cqnmask = (1 << state->hs_cfg_profile->cp_log_num_cq) - 1;
 875         qpc->cqn_snd         =
 876             (qp->qp_sq_cqhdl == NULL) ? 0 : qp->qp_sq_cqhdl->cq_cqnum & cqnmask;
 877         qpc->page_offs               = qp->qp_wqinfo.qa_pgoffs >> 6;
 878         qpc->cqn_rcv         =
 879             (qp->qp_rq_cqhdl == NULL) ? 0 : qp->qp_rq_cqhdl->cq_cqnum & cqnmask;
 880 
 881         /* dbr is now an address, not an index */
 882         qpc->dbr_addrh               = ((uint64_t)qp->qp_rq_pdbr >> 32);
 883         qpc->dbr_addrl               = ((uint64_t)qp->qp_rq_pdbr & 0xFFFFFFFC) >> 2;
 884         qpc->sq_wqe_counter  = 0;
 885         qpc->rq_wqe_counter  = 0;
 886         /*
 887          * HERMON:
 888          * qpc->wqe_baseaddr is replaced by LKey from the cMPT, and
 889          * page_offset, mtt_base_addr_h/l, and log2_page_size will
 890          * be used to map the WQE buffer
 891          * NOTE that the cMPT is created implicitly when the QP is
 892          * transitioned from reset to init
 893          */
 894         qpc->log2_pgsz               = qp->qp_mrhdl->mr_log2_pgsz;
 895         qpc->mtt_base_addrl  = (qp->qp_mrhdl->mr_mttaddr) >> 3;
 896         qpc->mtt_base_addrh  = (uint32_t)((qp->qp_mrhdl->mr_mttaddr >> 32) &
 897             0xFF);
 898         qp_srq_en               = (qp->qp_alloc_flags & IBT_QP_USES_SRQ) != 0;
 899         qpc->srq_en          = qp_srq_en;
 900 
 901         if (qp_srq_en) {
 902                 qpc->srq_number      = qp->qp_srqhdl->srq_srqnum;
 903         } else {
 904                 qpc->srq_number = 0;
 905         }
 906 
 907         /*
 908          * Fast Registration Work Requests and Reserved Lkey are enabled
 909          * with the single IBT bit stored in qp_rlky.
 910          */
 911         qpc->fre             = qp->qp_rlky;
 912         qpc->rlky            = qp->qp_rlky;
 913 
 914         /* 1.2 verbs extensions disabled for now */
 915         qpc->header_sep              = 0; /* disable header separation for now */
 916         qpc->rss             = qp->qp_alloc_flags & IBT_QP_USES_RSS ? 1 : 0;
 917         qpc->inline_scatter  = 0; /* disable inline scatter for now */
 918 
 919         /*
 920          * Now fill in the QPC fields which are specific to transport type
 921          */
 922         if (qp->qp_type == IBT_UD_RQP) {
 923                 int my_fc_id_idx, exch_base;
 924 
 925                 ud = &info_p->qp_transport.ud;
 926 
 927                 /* Set the QKey */
 928                 qpc->qkey = ud->ud_qkey;
 929 
 930                 /*
 931                  * Set MTU and message max. Hermon checks the QPC
 932                  * MTU settings rather than just the port MTU,
 933                  * so set it to maximum size.
 934                  */
 935                 qpc->mtu = HERMON_MAX_MTU;
 936                 if (qp->qp_uses_lso)
 937                         qpc->msg_max = state->hs_devlim.log_max_gso_sz;
 938                 else if (qp->qp_is_special)
 939                         qpc->msg_max = HERMON_MAX_MTU + 6;
 940                 else
 941                         qpc->msg_max = HERMON_QP_LOG_MAX_MSGSZ;
 942 
 943                 /* Check for valid port number and fill it in */
 944                 portnum = ud->ud_port;
 945                 if (hermon_portnum_is_valid(state, portnum)) {
 946                         qp->qp_portnum = portnum - 1;
 947                         qpc->pri_addr_path.sched_q =
 948                             HERMON_QP_SCHEDQ_GET(portnum - 1,
 949                             0, qp->qp_is_special);
 950                 } else {
 951                         return (IBT_HCA_PORT_INVALID);
 952                 }
 953 
 954 
 955                 /* Check for valid PKey index and fill it in */
 956                 pkeyindx = ud->ud_pkey_ix;
 957                 if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
 958                         qpc->pri_addr_path.pkey_indx = pkeyindx;
 959                         qp->qp_pkeyindx = pkeyindx;
 960                 } else {
 961                         return (IBT_PKEY_IX_ILLEGAL);
 962                 }
 963 
 964                 /* fill in the RSS fields */
 965                 if (qpc->rss) {
 966                         struct hermon_hw_rss_s *rssp;
 967                         ibt_rss_flags_t flags = ud->ud_rss.rss_flags;
 968 
 969                         rssp = (struct hermon_hw_rss_s *)&qpc->pri_addr_path;
 970                         rssp->log2_tbl_sz = ud->ud_rss.rss_log2_table;
 971                         rssp->base_qpn = ud->ud_rss.rss_base_qpn;
 972                         rssp->default_qpn = ud->ud_rss.rss_def_qpn;
 973                         if (flags & IBT_RSS_ALG_XOR)
 974                                 rssp->hash_fn = 0;   /* XOR Hash Function */
 975                         else if (flags & IBT_RSS_ALG_TPL)
 976                                 rssp->hash_fn = 1;   /* Toeplitz Hash Fn */
 977                         else
 978                                 return (IBT_INVALID_PARAM);
 979                         rssp->ipv4 = (flags & IBT_RSS_HASH_IPV4) != 0;
 980                         rssp->tcp_ipv4 = (flags & IBT_RSS_HASH_TCP_IPV4) != 0;
 981                         rssp->ipv6 = (flags & IBT_RSS_HASH_IPV6) != 0;
 982                         rssp->tcp_ipv4 = (flags & IBT_RSS_HASH_TCP_IPV6) != 0;
 983                         bcopy(ud->ud_rss.rss_toe_key, rssp->rss_key, 40);
 984                 } else if (qp->qp_serv_type == HERMON_QP_RFCI) {
 985                         status = hermon_fcoib_set_id(state, portnum,
 986                             qp->qp_qpnum, ud->ud_fc.fc_src_id);
 987                         if (status != DDI_SUCCESS)
 988                                 return (status);
 989                         qp->qp_fc_attr = ud->ud_fc;
 990                 } else if (qp->qp_serv_type == HERMON_QP_FEXCH) {
 991                         my_fc_id_idx = hermon_fcoib_get_id_idx(state,
 992                             portnum, &ud->ud_fc);
 993                         if (my_fc_id_idx == -1)
 994                                 return (IBT_INVALID_PARAM);
 995                         qpc->my_fc_id_idx = my_fc_id_idx;
 996 
 997                         status = hermon_fcoib_fexch_mkey_init(state,
 998                             qp->qp_pdhdl, ud->ud_fc.fc_hca_port,
 999                             qp->qp_qpnum, HERMON_CMD_NOSLEEP_SPIN);
1000                         if (status != DDI_SUCCESS)
1001                                 return (status);
1002                         qp->qp_fc_attr = ud->ud_fc;
1003                 } else if (qp->qp_serv_type == HERMON_QP_FCMND) {
1004                         my_fc_id_idx = hermon_fcoib_get_id_idx(state,
1005                             portnum, &ud->ud_fc);
1006                         if (my_fc_id_idx == -1)
1007                                 return (IBT_INVALID_PARAM);
1008                         qpc->my_fc_id_idx = my_fc_id_idx;
1009                         exch_base = hermon_fcoib_check_exch_base_off(state,
1010                             portnum, &ud->ud_fc);
1011                         if (exch_base == -1)
1012                                 return (IBT_INVALID_PARAM);
1013                         qpc->exch_base = exch_base;
1014                         qpc->exch_size = ud->ud_fc.fc_exch_log2_sz;
1015                         qp->qp_fc_attr = ud->ud_fc;
1016                 }
1017 
1018         } else if (qp->qp_serv_type == HERMON_QP_RC) {
1019                 rc = &info_p->qp_transport.rc;
1020 
1021                 /* Set the RDMA (recv) enable/disable flags */
1022                 qpc->rre = (info_p->qp_flags & IBT_CEP_RDMA_RD) ? 1 : 0;
1023                 qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
1024                 qpc->rae = (info_p->qp_flags & IBT_CEP_ATOMIC)  ? 1 : 0;
1025 
1026                 /* Check for valid port number and fill it in */
1027                 portnum = rc->rc_path.cep_hca_port_num;
1028                 if (hermon_portnum_is_valid(state, portnum)) {
1029                         qp->qp_portnum = portnum - 1;
1030                         qpc->pri_addr_path.sched_q =
1031                             HERMON_QP_SCHEDQ_GET(portnum - 1,
1032                             0, qp->qp_is_special);
1033                 } else {
1034                         return (IBT_HCA_PORT_INVALID);
1035                 }
1036 
1037                 /* Check for valid PKey index and fill it in */
1038                 pkeyindx = rc->rc_path.cep_pkey_ix;
1039                 if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1040                         qpc->pri_addr_path.pkey_indx = pkeyindx;
1041                 } else {
1042                         return (IBT_PKEY_IX_ILLEGAL);
1043                 }
1044 
1045         } else if (qp->qp_serv_type == HERMON_QP_UC) {
1046                 uc = &info_p->qp_transport.uc;
1047 
1048                 /*
1049                  * Set the RDMA (recv) enable/disable flags.  Note: RDMA Read
1050                  * and Atomic are ignored by default.
1051                  */
1052                 qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
1053 
1054                 /* Check for valid port number and fill it in */
1055                 portnum = uc->uc_path.cep_hca_port_num;
1056                 if (hermon_portnum_is_valid(state, portnum)) {
1057                         qp->qp_portnum = portnum - 1;
1058                         qpc->pri_addr_path.sched_q =
1059                             HERMON_QP_SCHEDQ_GET(portnum - 1,
1060                             0, qp->qp_is_special);
1061                 } else {
1062                         return (IBT_HCA_PORT_INVALID);
1063                 }
1064 
1065                 /* Check for valid PKey index and fill it in */
1066                 pkeyindx = uc->uc_path.cep_pkey_ix;
1067                 if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1068                         qpc->pri_addr_path.pkey_indx = pkeyindx;
1069                 } else {
1070                         return (IBT_PKEY_IX_ILLEGAL);
1071                 }
1072 
1073         } else {
1074                 /*
1075                  * Invalid QP transport type. If we got here then it's a
1076                  * warning of a probably serious problem.  So print a message
1077                  * and return failure
1078                  */
1079                 HERMON_WARNING(state, "unknown QP transport type in rst2init");
1080                 return (ibc_get_ci_failure(0));
1081         }
1082 
1083         /*
1084          * Post the RST2INIT_QP command to the Hermon firmware
1085          *
1086          * We do a HERMON_NOSLEEP here because we are still holding the
1087          * "qp_lock".  If we got raised to interrupt level by priority
1088          * inversion, we do not want to block in this routine waiting for
1089          * success.
1090          */
1091         status = hermon_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
1092             0, HERMON_CMD_NOSLEEP_SPIN);
1093         if (status != HERMON_CMD_SUCCESS) {
1094                 cmn_err(CE_NOTE, "hermon%d: RST2INIT_QP command failed: %08x\n",
1095                     state->hs_instance, status);
1096                 if (status == HERMON_CMD_INVALID_STATUS) {
1097                         hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
1098                 }
1099                 return (ibc_get_ci_failure(0));
1100         }
1101 
1102         return (DDI_SUCCESS);
1103 }
1104 
1105 
1106 /*
1107  * hermon_qp_init2init()
1108  *    Context: Can be called from interrupt or base context.
1109  */
1110 static int
1111 hermon_qp_init2init(hermon_state_t *state, hermon_qphdl_t qp,
1112     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
1113 {
1114         hermon_hw_qpc_t         *qpc;
1115         ibt_qp_rc_attr_t        *rc;
1116         ibt_qp_ud_attr_t        *ud;
1117         ibt_qp_uc_attr_t        *uc;
1118         uint_t                  portnum, pkeyindx;
1119         uint32_t                opmask = 0;
1120         int                     status;
1121 
1122         ASSERT(MUTEX_HELD(&qp->qp_lock));
1123 
1124         /*
1125          * Grab the temporary QPC entry from QP software state
1126          */
1127         qpc = &qp->qpc;
1128 
1129         /*
1130          * Since there are no common fields to be filled in for this command,
1131          * we begin with the QPC fields which are specific to transport type.
1132          */
1133         if (qp->qp_type == IBT_UD_RQP) {
1134                 ud = &info_p->qp_transport.ud;
1135 
1136                 /*
1137                  * If we are attempting to modify the port for this QP, then
1138                  * check for valid port number and fill it in.  Also set the
1139                  * appropriate flag in the "opmask" parameter.
1140                  */
1141         /*
1142          * set port is not supported in init2init - however, in init2rtr it will
1143          * take the entire qpc, including the embedded sched_q in the path
1144          * structure - so, we can just skip setting the opmask for it explicitly
1145          * and allow it to be set later on
1146          */
1147                 if (flags & IBT_CEP_SET_PORT) {
1148                         portnum = ud->ud_port;
1149                         if (hermon_portnum_is_valid(state, portnum)) {
1150                                 qp->qp_portnum = portnum - 1; /* save it away */
1151                                 qpc->pri_addr_path.sched_q =
1152                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1153                                     0, qp->qp_is_special);
1154                         } else {
1155                                 return (IBT_HCA_PORT_INVALID);
1156                         }
1157                 }
1158 
1159                 /*
1160                  * If we are attempting to modify the PKey index for this QP,
1161                  * then check for valid PKey index and fill it in.  Also set
1162                  * the appropriate flag in the "opmask" parameter.
1163                  */
1164                 if (flags & IBT_CEP_SET_PKEY_IX) {
1165                         pkeyindx = ud->ud_pkey_ix;
1166                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1167                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1168                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1169                                 qp->qp_pkeyindx = pkeyindx;
1170                         } else {
1171                                 return (IBT_PKEY_IX_ILLEGAL);
1172                         }
1173                 }
1174 
1175                 /*
1176                  * If we are attempting to modify the QKey for this QP, then
1177                  * fill it in and set the appropriate flag in the "opmask"
1178                  * parameter.
1179                  */
1180                 if (flags & IBT_CEP_SET_QKEY) {
1181                         qpc->qkey = ud->ud_qkey;
1182                         opmask |= HERMON_CMD_OP_QKEY;
1183                 }
1184 
1185         } else if (qp->qp_serv_type == HERMON_QP_RC) {
1186                 rc = &info_p->qp_transport.rc;
1187 
1188                 /*
1189                  * If we are attempting to modify the port for this QP, then
1190                  * check for valid port number and fill it in.  Also set the
1191                  * appropriate flag in the "opmask" parameter.
1192                  */
1193                 if (flags & IBT_CEP_SET_PORT) {
1194                         portnum = rc->rc_path.cep_hca_port_num;
1195                         if (hermon_portnum_is_valid(state, portnum)) {
1196                                 qp->qp_portnum = portnum - 1;
1197                                 qpc->pri_addr_path.sched_q =
1198                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1199                                     0, qp->qp_is_special);
1200                         } else {
1201                                 return (IBT_HCA_PORT_INVALID);
1202                         }
1203 
1204                 }
1205 
1206                 /*
1207                  * If we are attempting to modify the PKey index for this QP,
1208                  * then check for valid PKey index and fill it in.  Also set
1209                  * the appropriate flag in the "opmask" parameter.
1210                  */
1211                 if (flags & IBT_CEP_SET_PKEY_IX) {
1212                         pkeyindx = rc->rc_path.cep_pkey_ix;
1213                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1214                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1215                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1216                         } else {
1217                                 return (IBT_PKEY_IX_ILLEGAL);
1218                         }
1219                 }
1220 
1221                 /*
1222                  * Check if any of the flags indicate a change in the RDMA
1223                  * (recv) enable/disable flags and set the appropriate flag in
1224                  * the "opmask" parameter
1225                  */
1226                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
1227 
1228         } else if (qp->qp_serv_type == HERMON_QP_UC) {
1229                 uc = &info_p->qp_transport.uc;
1230 
1231                 /*
1232                  * If we are attempting to modify the port for this QP, then
1233                  * check for valid port number and fill it in.  Also set the
1234                  * appropriate flag in the "opmask" parameter.
1235                  */
1236                 if (flags & IBT_CEP_SET_PORT) {
1237                         portnum = uc->uc_path.cep_hca_port_num;
1238                         if (hermon_portnum_is_valid(state, portnum)) {
1239                                 qp->qp_portnum = portnum - 1;
1240                                 qpc->pri_addr_path.sched_q =
1241                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1242                                     0, qp->qp_is_special);
1243                         } else {
1244                                 return (IBT_HCA_PORT_INVALID);
1245                         }
1246                 /* port# cannot be set in this transition - defer to init2rtr */
1247                 }
1248 
1249                 /*
1250                  * If we are attempting to modify the PKey index for this QP,
1251                  * then check for valid PKey index and fill it in.  Also set
1252                  * the appropriate flag in the "opmask" parameter.
1253                  */
1254                 if (flags & IBT_CEP_SET_PKEY_IX) {
1255                         pkeyindx = uc->uc_path.cep_pkey_ix;
1256                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1257                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1258                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1259                         } else {
1260                                 return (IBT_PKEY_IX_ILLEGAL);
1261                         }
1262                 }
1263 
1264                 /*
1265                  * Check if any of the flags indicate a change in the RDMA
1266                  * Write (recv) enable/disable and set the appropriate flag
1267                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
1268                  * not valid for UC transport.
1269                  */
1270                 if (flags & IBT_CEP_SET_RDMA_W) {
1271                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
1272                         opmask |= HERMON_CMD_OP_RWE;
1273                 }
1274         } else {
1275                 /*
1276                  * Invalid QP transport type. If we got here then it's a
1277                  * warning of a probably serious problem.  So print a message
1278                  * and return failure
1279                  */
1280                 HERMON_WARNING(state, "unknown QP transport type in init2init");
1281                 return (ibc_get_ci_failure(0));
1282         }
1283 
1284         /*
1285          * Post the INIT2INIT_QP command to the Hermon firmware
1286          *
1287          * We do a HERMON_NOSLEEP here because we are still holding the
1288          * "qp_lock".  If we got raised to interrupt level by priority
1289          * inversion, we do not want to block in this routine waiting for
1290          * success.
1291          */
1292         status = hermon_cmn_qp_cmd_post(state, INIT2INIT_QP, qpc, qp->qp_qpnum,
1293             opmask, HERMON_CMD_NOSLEEP_SPIN);
1294         if (status != HERMON_CMD_SUCCESS) {
1295                 if (status != HERMON_CMD_BAD_QP_STATE) {
1296                         cmn_err(CE_NOTE, "hermon%d: INIT2INIT_QP command "
1297                             "failed: %08x\n", state->hs_instance, status);
1298                         if (status == HERMON_CMD_INVALID_STATUS) {
1299                                 hermon_fm_ereport(state, HCA_SYS_ERR,
1300                                     HCA_ERR_SRV_LOST);
1301                         }
1302                         return (ibc_get_ci_failure(0));
1303                 } else {
1304                         return (IBT_QP_STATE_INVALID);
1305                 }
1306         }
1307 
1308         return (DDI_SUCCESS);
1309 }
1310 
1311 
1312 /*
1313  * hermon_qp_init2rtr()
1314  *    Context: Can be called from interrupt or base context.
1315  */
1316 static int
1317 hermon_qp_init2rtr(hermon_state_t *state, hermon_qphdl_t qp,
1318     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
1319 {
1320         hermon_hw_qpc_t         *qpc;
1321         ibt_qp_rc_attr_t        *rc;
1322         ibt_qp_ud_attr_t        *ud;
1323         ibt_qp_uc_attr_t        *uc;
1324         hermon_hw_addr_path_t   *qpc_path;
1325         ibt_adds_vect_t         *adds_vect;
1326         uint_t                  portnum, pkeyindx, rra_max;
1327         uint_t                  mtu;
1328         uint32_t                opmask = 0;
1329         int                     status;
1330 
1331         ASSERT(MUTEX_HELD(&qp->qp_lock));
1332 
1333         /*
1334          * Grab the temporary QPC entry from QP software state
1335          */
1336         qpc = &qp->qpc;
1337 
1338         /*
1339          * Since there are few common fields to be filled in for this command,
1340          * we just do the QPC fields that are specific to transport type.
1341          */
1342         if (qp->qp_type == IBT_UD_RQP) {
1343                 ud = &info_p->qp_transport.ud;
1344 
1345                 /*
1346                  * If this UD QP is also a "special QP" (QP0 or QP1), then
1347                  * the MTU is 256 bytes.  However, Hermon checks the QPC
1348                  * MTU settings rather than just the port MTU, so we will
1349                  * set it to maximum size for all UD.
1350                  */
1351                 qpc->mtu = HERMON_MAX_MTU;
1352                 if (qp->qp_uses_lso)
1353                         qpc->msg_max = state->hs_devlim.log_max_gso_sz;
1354                 else
1355                         qpc->msg_max = HERMON_QP_LOG_MAX_MSGSZ;
1356 
1357                 /*
1358                  * Save away the MTU value.  This is used in future sqd2sqd
1359                  * transitions, as the MTU must remain the same in future
1360                  * changes.
1361                  */
1362                 qp->qp_save_mtu = qpc->mtu;
1363 
1364                 /*
1365                  * If we are attempting to modify the PKey index for this QP,
1366                  * then check for valid PKey index and fill it in.  Also set
1367                  * the appropriate flag in the "opmask" parameter.
1368                  */
1369                 if (flags & IBT_CEP_SET_PKEY_IX) {
1370                         pkeyindx = ud->ud_pkey_ix;
1371                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1372                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1373                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1374                                 qp->qp_pkeyindx = pkeyindx;
1375                         } else {
1376                                 return (IBT_PKEY_IX_ILLEGAL);
1377                         }
1378                 }
1379 
1380                 /*
1381                  * If we are attempting to modify the QKey for this QP, then
1382                  * fill it in and set the appropriate flag in the "opmask"
1383                  * parameter.
1384                  */
1385                 if (flags & IBT_CEP_SET_QKEY) {
1386                         qpc->qkey = ud->ud_qkey;
1387                         opmask |= HERMON_CMD_OP_QKEY;
1388                 }
1389 
1390         } else if (qp->qp_serv_type == HERMON_QP_RC) {
1391                 rc = &info_p->qp_transport.rc;
1392                 qpc_path = &qpc->pri_addr_path;
1393                 adds_vect = &rc->rc_path.cep_adds_vect;
1394 
1395                 /*
1396                  * Set the common primary address path fields
1397                  */
1398                 status = hermon_set_addr_path(state, adds_vect, qpc_path,
1399                     HERMON_ADDRPATH_QP);
1400                 if (status != DDI_SUCCESS) {
1401                         return (status);
1402                 }
1403                 /* set the primary port number/sched_q */
1404                 portnum = qp->qp_portnum + 1;
1405                 if (hermon_portnum_is_valid(state, portnum)) {
1406                         qpc->pri_addr_path.sched_q  =
1407                             HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
1408                             adds_vect->av_srvl, qp->qp_is_special);
1409                 } else {
1410                         return (IBT_HCA_PORT_INVALID);
1411                 }
1412 
1413                 /*
1414                  * The following values are apparently "required" here (as
1415                  * they are part of the IBA-defined "Remote Node Address
1416                  * Vector").  However, they are also going to be "required"
1417                  * later - at RTR2RTS_QP time.  Not sure why.  But we set
1418                  * them here anyway.
1419                  */
1420                 qpc->rnr_retry               = rc->rc_rnr_retry_cnt;
1421                 qpc->retry_cnt               = rc->rc_retry_cnt;
1422                 qpc_path->ack_timeout        = rc->rc_path.cep_timeout;
1423 
1424                 /*
1425                  * Setup the destination QP, recv PSN, MTU, max msg size,etc.
1426                  * Note max message size is defined to be the maximum IB
1427                  * allowed message size (which is 2^31 bytes).  Also max
1428                  * MTU is defined by HCA port properties.
1429                  */
1430                 qpc->rem_qpn   = rc->rc_dst_qpn;
1431                 qpc->next_rcv_psn = rc->rc_rq_psn;
1432                 qpc->msg_max   = HERMON_QP_LOG_MAX_MSGSZ;
1433                 qpc->ric       = 0;
1434                 mtu               = rc->rc_path_mtu;
1435 
1436                 if (hermon_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
1437                         return (IBT_HCA_PORT_MTU_EXCEEDED);
1438                 }
1439                 qpc->mtu = mtu;
1440 
1441                 /*
1442                  * Save away the MTU value.  This is used in future sqd2sqd
1443                  * transitions, as the MTU must remain the same in future
1444                  * changes.
1445                  */
1446                 qp->qp_save_mtu = qpc->mtu;
1447 
1448                 /*
1449                  * Though it is a "required" parameter, "min_rnr_nak" is
1450                  * optionally specifiable in Hermon.  So we force the
1451                  * optional flag here.
1452                  */
1453                 qpc->min_rnr_nak = rc->rc_min_rnr_nak;
1454                 opmask |= HERMON_CMD_OP_MINRNRNAK;
1455 
1456                 /*
1457                  * Check that the number of specified "incoming RDMA resources"
1458                  * is valid.  And if it is, then setup the "rra_max
1459                  */
1460                 if (hermon_qp_validate_resp_rsrc(state, rc, &rra_max) !=
1461                     DDI_SUCCESS) {
1462                         return (IBT_INVALID_PARAM);
1463                 }
1464                 qpc->rra_max = rra_max;
1465 
1466                 /* don't need to set up ra_buff_indx, implicit for hermon */
1467 
1468                 /*
1469                  * If we are attempting to modify the PKey index for this QP,
1470                  * then check for valid PKey index and fill it in.  Also set
1471                  * the appropriate flag in the "opmask" parameter.
1472                  */
1473                 if (flags & IBT_CEP_SET_PKEY_IX) {
1474                         pkeyindx = rc->rc_path.cep_pkey_ix;
1475                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1476                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1477                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1478                         } else {
1479                                 return (IBT_PKEY_IX_ILLEGAL);
1480                         }
1481                 }
1482 
1483                 /*
1484                  * Check if any of the flags indicate a change in the RDMA
1485                  * (recv) enable/disable flags and set the appropriate flag in
1486                  * the "opmask" parameter
1487                  */
1488                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
1489 
1490                 /*
1491                  * Check for optional alternate path and fill in the
1492                  * appropriate QPC fields if one is specified
1493                  */
1494                 if (flags & IBT_CEP_SET_ALT_PATH) {
1495                         qpc_path = &qpc->alt_addr_path;
1496                         adds_vect = &rc->rc_alt_path.cep_adds_vect;
1497 
1498                         /* Set the common alternate address path fields */
1499                         status = hermon_set_addr_path(state, adds_vect,
1500                             qpc_path, HERMON_ADDRPATH_QP);
1501                         if (status != DDI_SUCCESS) {
1502                                 return (status);
1503                         }
1504                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
1505 
1506 
1507                         /*
1508                          * Check for valid alternate path port number and fill
1509                          * it in
1510                          */
1511                         portnum = rc->rc_alt_path.cep_hca_port_num;
1512                         if (hermon_portnum_is_valid(state, portnum)) {
1513                                 qp->qp_portnum_alt = portnum - 1;
1514                                 qpc->alt_addr_path.sched_q =
1515                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1516                                     adds_vect->av_srvl, qp->qp_is_special);
1517                         } else {
1518                                 return (IBT_HCA_PORT_INVALID);
1519                         }
1520                         /*
1521                          * Check for valid alternate path PKey index and fill
1522                          * it in
1523                          */
1524                         pkeyindx = rc->rc_alt_path.cep_pkey_ix;
1525                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1526                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
1527                         } else {
1528                                 return (IBT_PKEY_IX_ILLEGAL);
1529                         }
1530                         opmask |= HERMON_CMD_OP_ALT_PATH;
1531                 }
1532 
1533         } else if (qp->qp_serv_type == HERMON_QP_UC) {
1534                 uc = &info_p->qp_transport.uc;
1535                 qpc_path = &qpc->pri_addr_path;
1536                 adds_vect = &uc->uc_path.cep_adds_vect;
1537 
1538                 /*
1539                  * Set the common primary address path fields
1540                  */
1541                 status = hermon_set_addr_path(state, adds_vect, qpc_path,
1542                     HERMON_ADDRPATH_QP);
1543                 if (status != DDI_SUCCESS) {
1544                         return (status);
1545                 }
1546 
1547                 /* set the primary port num/schedq */
1548                 portnum = qp->qp_portnum + 1;
1549                 if (hermon_portnum_is_valid(state, portnum)) {
1550                         qpc->pri_addr_path.sched_q  =
1551                             HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
1552                             adds_vect->av_srvl, qp->qp_is_special);
1553                 } else {
1554                         return (IBT_HCA_PORT_INVALID);
1555                 }
1556 
1557                 /*
1558                  * Setup the destination QP, recv PSN, MTU, max msg size,etc.
1559                  * Note max message size is defined to be the maximum IB
1560                  * allowed message size (which is 2^31 bytes).  Also max
1561                  * MTU is defined by HCA port properties.
1562                  */
1563                 qpc->rem_qpn   = uc->uc_dst_qpn;
1564                 qpc->next_rcv_psn = uc->uc_rq_psn;
1565                 qpc->msg_max   = HERMON_QP_LOG_MAX_MSGSZ;
1566                 mtu = uc->uc_path_mtu;
1567                 if (hermon_qp_validate_mtu(state, mtu) != DDI_SUCCESS) {
1568                         return (IBT_HCA_PORT_MTU_EXCEEDED);
1569                 }
1570                 qpc->mtu = mtu;
1571 
1572                 /*
1573                  * Save away the MTU value.  This is used in future sqd2sqd
1574                  * transitions, as the MTU must remain the same in future
1575                  * changes.
1576                  */
1577                 qp->qp_save_mtu = qpc->mtu;
1578 
1579                 /*
1580                  * If we are attempting to modify the PKey index for this QP,
1581                  * then check for valid PKey index and fill it in.  Also set
1582                  * the appropriate flag in the "opmask" parameter.
1583                  */
1584                 if (flags & IBT_CEP_SET_PKEY_IX) {
1585                         pkeyindx = uc->uc_path.cep_pkey_ix;
1586                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1587                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
1588                                 opmask |= HERMON_CMD_OP_PKEYINDX;
1589                         } else {
1590                                 return (IBT_PKEY_IX_ILLEGAL);
1591                         }
1592                 }
1593 
1594                 /*
1595                  * Check if any of the flags indicate a change in the RDMA
1596                  * Write (recv) enable/disable and set the appropriate flag
1597                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
1598                  * not valid for UC transport.
1599                  */
1600                 if (flags & IBT_CEP_SET_RDMA_W) {
1601                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
1602                         opmask |= HERMON_CMD_OP_RWE;
1603                 }
1604 
1605                 /*
1606                  * Check for optional alternate path and fill in the
1607                  * appropriate QPC fields if one is specified
1608                  */
1609                 if (flags & IBT_CEP_SET_ALT_PATH) {
1610                         qpc_path = &qpc->alt_addr_path;
1611                         adds_vect = &uc->uc_alt_path.cep_adds_vect;
1612 
1613                         /* Set the common alternate address path fields */
1614                         status = hermon_set_addr_path(state, adds_vect,
1615                             qpc_path, HERMON_ADDRPATH_QP);
1616                         if (status != DDI_SUCCESS) {
1617                                 return (status);
1618                         }
1619 
1620                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
1621 
1622                         /*
1623                          * Check for valid alternate path port number and fill
1624                          * it in
1625                          */
1626                         portnum = uc->uc_alt_path.cep_hca_port_num;
1627                         if (hermon_portnum_is_valid(state, portnum)) {
1628                                 qp->qp_portnum_alt = portnum - 1;
1629                                 qpc->alt_addr_path.sched_q =
1630                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1631                                     adds_vect->av_srvl, qp->qp_is_special);
1632                         } else {
1633                                 return (IBT_HCA_PORT_INVALID);
1634                         }
1635 
1636                         /*
1637                          * Check for valid alternate path PKey index and fill
1638                          * it in
1639                          */
1640                         pkeyindx = uc->uc_alt_path.cep_pkey_ix;
1641                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1642                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
1643                         } else {
1644                                 return (IBT_PKEY_IX_ILLEGAL);
1645                         }
1646                         opmask |= HERMON_CMD_OP_ALT_PATH;
1647                 }
1648         } else {
1649                 /*
1650                  * Invalid QP transport type. If we got here then it's a
1651                  * warning of a probably serious problem.  So print a message
1652                  * and return failure
1653                  */
1654                 HERMON_WARNING(state, "unknown QP transport type in init2rtr");
1655                 return (ibc_get_ci_failure(0));
1656         }
1657 
1658         /*
1659          * Post the INIT2RTR_QP command to the Hermon firmware
1660          *
1661          * We do a HERMON_NOSLEEP here because we are still holding the
1662          * "qp_lock".  If we got raised to interrupt level by priority
1663          * inversion, we do not want to block in this routine waiting for
1664          * success.
1665          */
1666         status = hermon_cmn_qp_cmd_post(state, INIT2RTR_QP, qpc, qp->qp_qpnum,
1667             opmask, HERMON_CMD_NOSLEEP_SPIN);
1668         if (status != HERMON_CMD_SUCCESS) {
1669                 if (status != HERMON_CMD_BAD_QP_STATE) {
1670                         cmn_err(CE_NOTE, "hermon%d: INIT2RTR_QP command "
1671                             "failed: %08x\n", state->hs_instance, status);
1672                         if (status == HERMON_CMD_INVALID_STATUS) {
1673                                 hermon_fm_ereport(state, HCA_SYS_ERR,
1674                                     HCA_ERR_SRV_LOST);
1675                         }
1676                         return (ibc_get_ci_failure(0));
1677                 } else {
1678                         return (IBT_QP_STATE_INVALID);
1679                 }
1680         }
1681 
1682         return (DDI_SUCCESS);
1683 }
1684 
1685 
1686 /*
1687  * hermon_qp_rtr2rts()
1688  *    Context: Can be called from interrupt or base context.
1689  */
1690 static int
1691 hermon_qp_rtr2rts(hermon_state_t *state, hermon_qphdl_t qp,
1692     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
1693 {
1694         hermon_hw_qpc_t         *qpc;
1695         ibt_qp_rc_attr_t        *rc;
1696         ibt_qp_ud_attr_t        *ud;
1697         ibt_qp_uc_attr_t        *uc;
1698         hermon_hw_addr_path_t   *qpc_path;
1699         ibt_adds_vect_t         *adds_vect;
1700         uint_t                  portnum, pkeyindx, sra_max;
1701         uint32_t                opmask = 0;
1702         int                     status;
1703 
1704         ASSERT(MUTEX_HELD(&qp->qp_lock));
1705 
1706         /*
1707          * Grab the temporary QPC entry from QP software state
1708          */
1709         qpc = &qp->qpc;
1710 
1711         /*
1712          * Now fill in the QPC fields which are specific to transport type
1713          */
1714         if (qp->qp_type == IBT_UD_RQP) {
1715                 ud = &info_p->qp_transport.ud;
1716 
1717                 /* Set the send PSN */
1718                 qpc->next_snd_psn = ud->ud_sq_psn;
1719 
1720                 /*
1721                  * If we are attempting to modify the QKey for this QP, then
1722                  * fill it in and set the appropriate flag in the "opmask"
1723                  * parameter.
1724                  */
1725                 if (flags & IBT_CEP_SET_QKEY) {
1726                         qpc->qkey = ud->ud_qkey;
1727                         opmask |= HERMON_CMD_OP_QKEY;
1728                 }
1729 
1730         } else if (qp->qp_serv_type == HERMON_QP_RC) {
1731                 rc = &info_p->qp_transport.rc;
1732                 qpc_path = &qpc->pri_addr_path;
1733 
1734                 /*
1735                  * Setup the send PSN, ACK timeout, and retry counts
1736                  */
1737                 qpc->next_snd_psn    = rc->rc_sq_psn;
1738                 qpc_path->ack_timeout        = rc->rc_path.cep_timeout;
1739                 qpc->rnr_retry               = rc->rc_rnr_retry_cnt;
1740                                                 /* in qpc now, not path */
1741                 qpc->retry_cnt               = rc->rc_retry_cnt;
1742 
1743                 /*
1744                  * Set "ack_req_freq" based on the configuration variable
1745                  */
1746                 qpc->ack_req_freq = state->hs_cfg_profile->cp_ackreq_freq;
1747 
1748                 /*
1749                  * Check that the number of specified "outgoing RDMA resources"
1750                  * is valid.  And if it is, then setup the "sra_max"
1751                  * appropriately
1752                  */
1753                 if (hermon_qp_validate_init_depth(state, rc, &sra_max) !=
1754                     DDI_SUCCESS) {
1755                         return (IBT_INVALID_PARAM);
1756                 }
1757                 qpc->sra_max = sra_max;
1758 
1759 
1760                 /*
1761                  * Check if any of the flags indicate a change in the RDMA
1762                  * (recv) enable/disable flags and set the appropriate flag in
1763                  * the "opmask" parameter
1764                  */
1765                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
1766 
1767                 /*
1768                  * If we are attempting to modify the path migration state for
1769                  * this QP, then check for valid state and fill it in.  Also
1770                  * set the appropriate flag in the "opmask" parameter.
1771                  */
1772                 if (flags & IBT_CEP_SET_MIG) {
1773                         if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
1774                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
1775                         } else if (rc->rc_mig_state == IBT_STATE_REARMED) {
1776                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
1777                         } else {
1778                                 return (IBT_QP_APM_STATE_INVALID);
1779                         }
1780                         opmask |= HERMON_CMD_OP_PM_STATE;
1781                 }
1782 
1783                 /*
1784                  * If we are attempting to modify the "Minimum RNR NAK" value
1785                  * for this QP, then fill it in and set the appropriate flag
1786                  * in the "opmask" parameter.
1787                  */
1788                 if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
1789                         qpc->min_rnr_nak = rc->rc_min_rnr_nak;
1790                         opmask |= HERMON_CMD_OP_MINRNRNAK;
1791                 }
1792 
1793                 /*
1794                  * Check for optional alternate path and fill in the
1795                  * appropriate QPC fields if one is specified
1796                  */
1797                 if (flags & IBT_CEP_SET_ALT_PATH) {
1798                         qpc_path = &qpc->alt_addr_path;
1799                         adds_vect = &rc->rc_alt_path.cep_adds_vect;
1800 
1801                         /* Set the common alternate address path fields */
1802                         status = hermon_set_addr_path(state, adds_vect,
1803                             qpc_path, HERMON_ADDRPATH_QP);
1804                         if (status != DDI_SUCCESS) {
1805                                 return (status);
1806                         }
1807 
1808                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
1809 
1810                         /*
1811                          * Check for valid alternate path port number and fill
1812                          * it in
1813                          */
1814                         portnum = rc->rc_alt_path.cep_hca_port_num;
1815                         if (hermon_portnum_is_valid(state, portnum)) {
1816                                 qp->qp_portnum_alt = portnum - 1;
1817                                 qpc->alt_addr_path.sched_q =
1818                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1819                                     adds_vect->av_srvl, qp->qp_is_special);
1820                         } else {
1821                                 return (IBT_HCA_PORT_INVALID);
1822                         }
1823 
1824                         /*
1825                          * Check for valid alternate path PKey index and fill
1826                          * it in
1827                          */
1828                         pkeyindx = rc->rc_alt_path.cep_pkey_ix;
1829                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1830                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
1831                         } else {
1832                                 return (IBT_PKEY_IX_ILLEGAL);
1833                         }
1834                         opmask |= HERMON_CMD_OP_ALT_PATH;
1835                 }
1836 
1837         } else if (qp->qp_serv_type == HERMON_QP_UC) {
1838                 uc = &info_p->qp_transport.uc;
1839 
1840                 /* Set the send PSN */
1841                 qpc->next_snd_psn = uc->uc_sq_psn;
1842 
1843                 /*
1844                  * Configure the QP to allow (sending of) all types of allowable
1845                  * UC traffic (i.e. RDMA Write).
1846                  */
1847 
1848 
1849                 /*
1850                  * Check if any of the flags indicate a change in the RDMA
1851                  * Write (recv) enable/disable and set the appropriate flag
1852                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
1853                  * not valid for UC transport.
1854                  */
1855                 if (flags & IBT_CEP_SET_RDMA_W) {
1856                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
1857                         opmask |= HERMON_CMD_OP_RWE;
1858                 }
1859 
1860                 /*
1861                  * If we are attempting to modify the path migration state for
1862                  * this QP, then check for valid state and fill it in.  Also
1863                  * set the appropriate flag in the "opmask" parameter.
1864                  */
1865                 if (flags & IBT_CEP_SET_MIG) {
1866                         if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
1867                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
1868                         } else if (uc->uc_mig_state == IBT_STATE_REARMED) {
1869                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
1870                         } else {
1871                                 return (IBT_QP_APM_STATE_INVALID);
1872                         }
1873                         opmask |= HERMON_CMD_OP_PM_STATE;
1874                 }
1875 
1876                 /*
1877                  * Check for optional alternate path and fill in the
1878                  * appropriate QPC fields if one is specified
1879                  */
1880                 if (flags & IBT_CEP_SET_ALT_PATH) {
1881                         qpc_path = &qpc->alt_addr_path;
1882                         adds_vect = &uc->uc_alt_path.cep_adds_vect;
1883 
1884                         /* Set the common alternate address path fields */
1885                         status = hermon_set_addr_path(state, adds_vect,
1886                             qpc_path, HERMON_ADDRPATH_QP);
1887                         if (status != DDI_SUCCESS) {
1888                                 return (status);
1889                         }
1890                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
1891 
1892                         /*
1893                          * Check for valid alternate path port number and fill
1894                          * it in
1895                          */
1896                         portnum = uc->uc_alt_path.cep_hca_port_num;
1897                         if (hermon_portnum_is_valid(state, portnum)) {
1898                                 qpc->alt_addr_path.sched_q =
1899                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
1900                                     adds_vect->av_srvl, qp->qp_is_special);
1901                         } else {
1902                                 return (IBT_HCA_PORT_INVALID);
1903                         }
1904 
1905                         /*
1906                          * Check for valid alternate path PKey index and fill
1907                          * it in
1908                          */
1909                         pkeyindx = uc->uc_alt_path.cep_pkey_ix;
1910                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
1911                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
1912                         } else {
1913                                 return (IBT_PKEY_IX_ILLEGAL);
1914                         }
1915                         opmask |= HERMON_CMD_OP_ALT_PATH;
1916                 }
1917         } else {
1918                 /*
1919                  * Invalid QP transport type. If we got here then it's a
1920                  * warning of a probably serious problem.  So print a message
1921                  * and return failure
1922                  */
1923                 HERMON_WARNING(state, "unknown QP transport type in rtr2rts");
1924                 return (ibc_get_ci_failure(0));
1925         }
1926 
1927         /*
1928          * Post the RTR2RTS_QP command to the Hermon firmware
1929          *
1930          * We do a HERMON_NOSLEEP here because we are still holding the
1931          * "qp_lock".  If we got raised to interrupt level by priority
1932          * inversion, we do not want to block in this routine waiting for
1933          * success.
1934          */
1935         status = hermon_cmn_qp_cmd_post(state, RTR2RTS_QP, qpc, qp->qp_qpnum,
1936             opmask, HERMON_CMD_NOSLEEP_SPIN);
1937         if (status != HERMON_CMD_SUCCESS) {
1938                 if (status != HERMON_CMD_BAD_QP_STATE) {
1939                         cmn_err(CE_NOTE, "hermon%d: RTR2RTS_QP command failed: "
1940                             "%08x\n", state->hs_instance, status);
1941                         if (status == HERMON_CMD_INVALID_STATUS) {
1942                                 hermon_fm_ereport(state, HCA_SYS_ERR,
1943                                     HCA_ERR_SRV_LOST);
1944                         }
1945                         return (ibc_get_ci_failure(0));
1946                 } else {
1947                         return (IBT_QP_STATE_INVALID);
1948                 }
1949         }
1950 
1951         return (DDI_SUCCESS);
1952 }
1953 
1954 
1955 /*
1956  * hermon_qp_rts2rts()
1957  *    Context: Can be called from interrupt or base context.
1958  */
1959 static int
1960 hermon_qp_rts2rts(hermon_state_t *state, hermon_qphdl_t qp,
1961     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
1962 {
1963         hermon_hw_qpc_t         *qpc;
1964         ibt_qp_rc_attr_t        *rc;
1965         ibt_qp_ud_attr_t        *ud;
1966         ibt_qp_uc_attr_t        *uc;
1967         hermon_hw_addr_path_t   *qpc_path;
1968         ibt_adds_vect_t         *adds_vect;
1969         uint_t                  portnum, pkeyindx;
1970         uint32_t                opmask = 0;
1971         int                     status;
1972 
1973         ASSERT(MUTEX_HELD(&qp->qp_lock));
1974 
1975         /*
1976          * Grab the temporary QPC entry from QP software state
1977          */
1978 
1979         qpc = &qp->qpc;
1980 
1981         /*
1982          * Since there are no common fields to be filled in for this command,
1983          * we begin with the QPC fields which are specific to transport type.
1984          */
1985         if (qp->qp_type == IBT_UD_RQP) {
1986                 ud = &info_p->qp_transport.ud;
1987 
1988                 /*
1989                  * If we are attempting to modify the QKey for this QP, then
1990                  * fill it in and set the appropriate flag in the "opmask"
1991                  * parameter.
1992                  */
1993                 if (flags & IBT_CEP_SET_QKEY) {
1994                         qpc->qkey = ud->ud_qkey;
1995                         opmask |= HERMON_CMD_OP_QKEY;
1996                 }
1997 
1998         } else if (qp->qp_serv_type == HERMON_QP_RC) {
1999                 rc = &info_p->qp_transport.rc;
2000 
2001                 /*
2002                  * Check if any of the flags indicate a change in the RDMA
2003                  * (recv) enable/disable flags and set the appropriate flag in
2004                  * the "opmask" parameter
2005                  */
2006                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
2007 
2008                 /*
2009                  * If we are attempting to modify the path migration state for
2010                  * this QP, then check for valid state and fill it in.  Also
2011                  * set the appropriate flag in the "opmask" parameter.
2012                  */
2013                 if (flags & IBT_CEP_SET_MIG) {
2014                         if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
2015                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2016                         } else if (rc->rc_mig_state == IBT_STATE_REARMED) {
2017                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2018                         } else {
2019                                 return (IBT_QP_APM_STATE_INVALID);
2020                         }
2021                         opmask |= HERMON_CMD_OP_PM_STATE;
2022                 }
2023 
2024                 /*
2025                  * If we are attempting to modify the "Minimum RNR NAK" value
2026                  * for this QP, then fill it in and set the appropriate flag
2027                  * in the "opmask" parameter.
2028                  */
2029                 if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
2030                         qpc->min_rnr_nak = rc->rc_min_rnr_nak;
2031                         opmask |= HERMON_CMD_OP_MINRNRNAK;
2032                 }
2033 
2034                 /*
2035                  * Check for optional alternate path and fill in the
2036                  * appropriate QPC fields if one is specified
2037                  */
2038                 if (flags & IBT_CEP_SET_ALT_PATH) {
2039                         qpc_path = &qpc->alt_addr_path;
2040                         adds_vect = &rc->rc_alt_path.cep_adds_vect;
2041 
2042                         /* Set the common alternate address path fields */
2043                         status = hermon_set_addr_path(state, adds_vect,
2044                             qpc_path, HERMON_ADDRPATH_QP);
2045                         if (status != DDI_SUCCESS) {
2046                                 return (status);
2047                         }
2048                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
2049 
2050                         /*
2051                          * Check for valid alternate path port number and fill
2052                          * it in
2053                          */
2054                         portnum = rc->rc_alt_path.cep_hca_port_num;
2055                         if (hermon_portnum_is_valid(state, portnum)) {
2056                                 qp->qp_portnum_alt = portnum - 1;
2057                                 qpc->alt_addr_path.sched_q =
2058                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2059                                     adds_vect->av_srvl, qp->qp_is_special);
2060                         } else {
2061                                 return (IBT_HCA_PORT_INVALID);
2062                         }
2063 
2064                         /*
2065                          * Check for valid alternate path PKey index and fill
2066                          * it in
2067                          */
2068                         pkeyindx = rc->rc_alt_path.cep_pkey_ix;
2069                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2070                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2071                         } else {
2072                                 return (IBT_PKEY_IX_ILLEGAL);
2073                         }
2074                         opmask |= HERMON_CMD_OP_ALT_PATH;
2075                 }
2076 
2077         } else if (qp->qp_serv_type == HERMON_QP_UC) {
2078                 uc = &info_p->qp_transport.uc;
2079 
2080                 /*
2081                  * Check if any of the flags indicate a change in the RDMA
2082                  * Write (recv) enable/disable and set the appropriate flag
2083                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
2084                  * not valid for UC transport.
2085                  */
2086                 if (flags & IBT_CEP_SET_RDMA_W) {
2087                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
2088                         opmask |= HERMON_CMD_OP_RWE;
2089                 }
2090 
2091                 /*
2092                  * If we are attempting to modify the path migration state for
2093                  * this QP, then check for valid state and fill it in.  Also
2094                  * set the appropriate flag in the "opmask" parameter.
2095                  */
2096                 if (flags & IBT_CEP_SET_MIG) {
2097                         if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
2098                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2099                         } else if (uc->uc_mig_state == IBT_STATE_REARMED) {
2100                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2101                         } else {
2102                                 return (IBT_QP_APM_STATE_INVALID);
2103                         }
2104                         opmask |= HERMON_CMD_OP_PM_STATE;
2105                 }
2106 
2107                 /*
2108                  * Check for optional alternate path and fill in the
2109                  * appropriate QPC fields if one is specified
2110                  */
2111                 if (flags & IBT_CEP_SET_ALT_PATH) {
2112                         qpc_path = &qpc->alt_addr_path;
2113                         adds_vect = &uc->uc_alt_path.cep_adds_vect;
2114 
2115                         /* Set the common alternate address path fields */
2116                         status = hermon_set_addr_path(state, adds_vect,
2117                             qpc_path, HERMON_ADDRPATH_QP);
2118                         if (status != DDI_SUCCESS) {
2119                                 return (status);
2120                         }
2121 
2122                         /*
2123                          * Check for valid alternate path port number and fill
2124                          * it in
2125                          */
2126                         portnum = uc->uc_alt_path.cep_hca_port_num;
2127                         if (hermon_portnum_is_valid(state, portnum)) {
2128                                 qp->qp_portnum_alt = portnum - 1;
2129                                 qpc->alt_addr_path.sched_q =
2130                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2131                                     adds_vect->av_srvl, qp->qp_is_special);
2132                         } else {
2133                                 return (IBT_HCA_PORT_INVALID);
2134                         }
2135 
2136                         /*
2137                          * Check for valid alternate path PKey index and fill
2138                          * it in
2139                          */
2140                         pkeyindx = uc->uc_alt_path.cep_pkey_ix;
2141                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2142                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2143                         } else {
2144                                 return (IBT_PKEY_IX_ILLEGAL);
2145                         }
2146                         opmask |= HERMON_CMD_OP_ALT_PATH;
2147                 }
2148         } else {
2149                 /*
2150                  * Invalid QP transport type. If we got here then it's a
2151                  * warning of a probably serious problem.  So print a message
2152                  * and return failure
2153                  */
2154                 HERMON_WARNING(state, "unknown QP transport type in rts2rts");
2155                 return (ibc_get_ci_failure(0));
2156         }
2157 
2158         /*
2159          * Post the RTS2RTS_QP command to the Hermon firmware
2160          *
2161          * We do a HERMON_NOSLEEP here because we are still holding the
2162          * "qp_lock".  If we got raised to interrupt level by priority
2163          * inversion, we do not want to block in this routine waiting for
2164          * success.
2165          */
2166         status = hermon_cmn_qp_cmd_post(state, RTS2RTS_QP, qpc, qp->qp_qpnum,
2167             opmask, HERMON_CMD_NOSLEEP_SPIN);
2168         if (status != HERMON_CMD_SUCCESS) {
2169                 if (status != HERMON_CMD_BAD_QP_STATE) {
2170                         cmn_err(CE_NOTE, "hermon%d: RTS2RTS_QP command failed: "
2171                             "%08x\n", state->hs_instance, status);
2172                         if (status == HERMON_CMD_INVALID_STATUS) {
2173                                 hermon_fm_ereport(state, HCA_SYS_ERR,
2174                                     HCA_ERR_SRV_LOST);
2175                         }
2176                         return (ibc_get_ci_failure(0));
2177                 } else {
2178                         return (IBT_QP_STATE_INVALID);
2179                 }
2180         }
2181 
2182         return (DDI_SUCCESS);
2183 }
2184 
2185 
2186 #ifdef HERMON_NOTNOW
2187 /*
2188  * hermon_qp_rts2sqd()
2189  *    Context: Can be called from interrupt or base context.
2190  */
2191 static int
2192 hermon_qp_rts2sqd(hermon_state_t *state, hermon_qphdl_t qp,
2193     ibt_cep_modify_flags_t flags)
2194 {
2195         int                     status;
2196 
2197         ASSERT(MUTEX_HELD(&qp->qp_lock));
2198 
2199         /*
2200          * Set a flag to indicate whether or not the consumer is interested
2201          * in receiving the SQ drained event.  Since we are going to always
2202          * request hardware generation of the SQD event, we use the value in
2203          * "qp_forward_sqd_event" to determine whether or not to pass the event
2204          * to the IBTF or to silently consume it.
2205          */
2206         qp->qp_forward_sqd_event = (flags & IBT_CEP_SET_SQD_EVENT) ? 1 : 0;
2207 
2208         /*
2209          * Post the RTS2SQD_QP command to the Hermon firmware
2210          *
2211          * We do a HERMON_NOSLEEP here because we are still holding the
2212          * "qp_lock".  If we got raised to interrupt level by priority
2213          * inversion, we do not want to block in this routine waiting for
2214          * success.
2215          */
2216         status = hermon_cmn_qp_cmd_post(state, RTS2SQD_QP, NULL, qp->qp_qpnum,
2217             0, HERMON_CMD_NOSLEEP_SPIN);
2218         if (status != HERMON_CMD_SUCCESS) {
2219                 if (status != HERMON_CMD_BAD_QP_STATE) {
2220                         cmn_err(CE_NOTE, "hermon%d: RTS2SQD_QP command failed: "
2221                             "%08x\n", state->hs_instance, status);
2222                         if (status == HERMON_CMD_INVALID_STATUS) {
2223                                 hermon_fm_ereport(state, HCA_SYS_ERR,
2224                                     HCA_ERR_SRV_LOST);
2225                         }
2226                         return (ibc_get_ci_failure(0));
2227                 } else {
2228                         return (IBT_QP_STATE_INVALID);
2229                 }
2230         }
2231 
2232         /*
2233          * Mark the current QP state as "SQ Draining".  This allows us to
2234          * distinguish between the two underlying states in SQD. (see QueryQP()
2235          * code in hermon_qp.c)
2236          */
2237         qp->qp_sqd_still_draining = 1;
2238 
2239         return (DDI_SUCCESS);
2240 }
2241 #endif
2242 
2243 
2244 /*
2245  * hermon_qp_sqd2rts()
2246  *    Context: Can be called from interrupt or base context.
2247  */
2248 static int
2249 hermon_qp_sqd2rts(hermon_state_t *state, hermon_qphdl_t qp,
2250     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
2251 {
2252         hermon_hw_qpc_t         *qpc;
2253         ibt_qp_rc_attr_t        *rc;
2254         ibt_qp_ud_attr_t        *ud;
2255         ibt_qp_uc_attr_t        *uc;
2256         hermon_hw_addr_path_t   *qpc_path;
2257         ibt_adds_vect_t         *adds_vect;
2258         uint_t                  portnum, pkeyindx;
2259         uint_t                  rra_max, sra_max;
2260         uint32_t                opmask = 0;
2261         int                     status;
2262 
2263         ASSERT(MUTEX_HELD(&qp->qp_lock));
2264 
2265         /*
2266          * Grab the temporary QPC entry from QP software state
2267          */
2268         qpc = &qp->qpc;
2269 
2270         /*
2271          * Fill in the common fields in the QPC
2272          */
2273 
2274         /*
2275          * Now fill in the QPC fields which are specific to transport type
2276          */
2277         if (qp->qp_type == IBT_UD_RQP) {
2278                 ud = &info_p->qp_transport.ud;
2279 
2280                 /*
2281                  * If we are attempting to modify the port for this QP, then
2282                  * check for valid port number and fill it in.  Also set the
2283                  * appropriate flag in the "opmask" parameter.
2284                  */
2285                 if (flags & IBT_CEP_SET_PORT) {
2286                         portnum = ud->ud_port;
2287                         if (hermon_portnum_is_valid(state, portnum)) {
2288                                 qp->qp_portnum = portnum - 1;
2289                                 qpc->pri_addr_path.sched_q =
2290                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2291                                     0, qp->qp_is_special);
2292                         } else {
2293                                 return (IBT_HCA_PORT_INVALID);
2294                         }
2295                         opmask |= HERMON_CMD_OP_PRIM_PORT;
2296                 }
2297 
2298                 /*
2299                  * If we are attempting to modify the PKey index for this QP,
2300                  * then check for valid PKey index and fill it in.  Also set
2301                  * the appropriate flag in the "opmask" parameter.
2302                  */
2303                 if (flags & IBT_CEP_SET_PKEY_IX) {
2304                         pkeyindx = ud->ud_pkey_ix;
2305                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2306                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
2307                                 opmask |= HERMON_CMD_OP_PKEYINDX;
2308                                 qp->qp_pkeyindx = pkeyindx;
2309                         } else {
2310                                 return (IBT_PKEY_IX_ILLEGAL);
2311                         }
2312                 }
2313 
2314                 /*
2315                  * If we are attempting to modify the QKey for this QP, then
2316                  * fill it in and set the appropriate flag in the "opmask"
2317                  * parameter.
2318                  */
2319                 if (flags & IBT_CEP_SET_QKEY) {
2320                         qpc->qkey = ud->ud_qkey;
2321                         opmask |= HERMON_CMD_OP_QKEY;
2322                 }
2323 
2324         } else if (qp->qp_serv_type == HERMON_QP_RC) {
2325                 rc = &info_p->qp_transport.rc;
2326 
2327                 /*
2328                  * Check if any of the flags indicate a change in the RDMA
2329                  * (recv) enable/disable flags and set the appropriate flag in
2330                  * the "opmask" parameter
2331                  */
2332                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
2333 
2334                 qpc->retry_cnt = rc->rc_retry_cnt;
2335 
2336                 /*
2337                  * If we are attempting to modify the path migration state for
2338                  * this QP, then check for valid state and fill it in.  Also
2339                  * set the appropriate flag in the "opmask" parameter.
2340                  */
2341                 if (flags & IBT_CEP_SET_MIG) {
2342                         if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
2343                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2344                         } else if (rc->rc_mig_state == IBT_STATE_REARMED) {
2345                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2346                         } else {
2347                                 return (IBT_QP_APM_STATE_INVALID);
2348                         }
2349                         opmask |= HERMON_CMD_OP_PM_STATE;
2350                 }
2351 
2352                 /*
2353                  * Check for optional alternate path and fill in the
2354                  * appropriate QPC fields if one is specified
2355                  */
2356                 if (flags & IBT_CEP_SET_ALT_PATH) {
2357                         qpc_path = &qpc->alt_addr_path;
2358                         adds_vect = &rc->rc_alt_path.cep_adds_vect;
2359 
2360                         /* Set the common alternate address path fields */
2361                         status = hermon_set_addr_path(state, adds_vect,
2362                             qpc_path, HERMON_ADDRPATH_QP);
2363                         if (status != DDI_SUCCESS) {
2364                                 return (status);
2365                         }
2366                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
2367                         /*
2368                          * Check for valid alternate path port number and fill
2369                          * it in
2370                          */
2371                         portnum = rc->rc_alt_path.cep_hca_port_num;
2372                         if (hermon_portnum_is_valid(state, portnum)) {
2373                                 qp->qp_portnum_alt = portnum - 1;
2374                                 qpc->alt_addr_path.sched_q =
2375                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2376                                     adds_vect->av_srvl, qp->qp_is_special);
2377                         } else {
2378                                 return (IBT_HCA_PORT_INVALID);
2379                         }
2380 
2381                         /*
2382                          * Check for valid alternate path PKey index and fill
2383                          * it in
2384                          */
2385                         pkeyindx = rc->rc_alt_path.cep_pkey_ix;
2386                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2387                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2388                         } else {
2389                                 return (IBT_PKEY_IX_ILLEGAL);
2390                         }
2391                         opmask |= HERMON_CMD_OP_ALT_PATH;
2392                 }
2393 
2394                 /*
2395                  * If we are attempting to modify the number of "outgoing
2396                  * RDMA resources" for this QP, then check for valid value and
2397                  * fill it in.  Also set the appropriate flag in the "opmask"
2398                  * parameter.
2399                  */
2400                 if (flags & IBT_CEP_SET_RDMARA_OUT) {
2401                         if (hermon_qp_validate_init_depth(state, rc,
2402                             &sra_max) != DDI_SUCCESS) {
2403                                 return (IBT_INVALID_PARAM);
2404                         }
2405                         qpc->sra_max = sra_max;
2406                         opmask |= HERMON_CMD_OP_SRA_SET;
2407                 }
2408 
2409                 /*
2410                  * If we are attempting to modify the number of "incoming
2411                  * RDMA resources" for this QP, then check for valid value and
2412                  * update the "rra_max" and "ra_buf_index" fields in the QPC to
2413                  * point to the pre-allocated RDB resources (in DDR).  Also set
2414                  * the appropriate flag in the "opmask" parameter.
2415                  */
2416                 if (flags & IBT_CEP_SET_RDMARA_IN) {
2417                         if (hermon_qp_validate_resp_rsrc(state, rc,
2418                             &rra_max) != DDI_SUCCESS) {
2419                                 return (IBT_INVALID_PARAM);
2420                         }
2421                         qpc->rra_max = rra_max;
2422                         opmask |= HERMON_CMD_OP_RRA_SET;
2423                 }
2424 
2425 
2426                 /*
2427                  * If we are attempting to modify the "Minimum RNR NAK" value
2428                  * for this QP, then fill it in and set the appropriate flag
2429                  * in the "opmask" parameter.
2430                  */
2431                 if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
2432                         qpc->min_rnr_nak = rc->rc_min_rnr_nak;
2433                         opmask |= HERMON_CMD_OP_MINRNRNAK;
2434                 }
2435 
2436         } else if (qp->qp_serv_type == HERMON_QP_UC) {
2437                 uc = &info_p->qp_transport.uc;
2438 
2439                 /*
2440                  * Check if any of the flags indicate a change in the RDMA
2441                  * Write (recv) enable/disable and set the appropriate flag
2442                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
2443                  * not valid for UC transport.
2444                  */
2445                 if (flags & IBT_CEP_SET_RDMA_W) {
2446                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
2447                         opmask |= HERMON_CMD_OP_RWE;
2448                 }
2449 
2450                 /*
2451                  * If we are attempting to modify the path migration state for
2452                  * this QP, then check for valid state and fill it in.  Also
2453                  * set the appropriate flag in the "opmask" parameter.
2454                  */
2455                 if (flags & IBT_CEP_SET_MIG) {
2456                         if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
2457                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2458                         } else if (uc->uc_mig_state == IBT_STATE_REARMED) {
2459                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2460                         } else {
2461                                 return (IBT_QP_APM_STATE_INVALID);
2462                         }
2463                         opmask |= HERMON_CMD_OP_PM_STATE;
2464                 }
2465 
2466                 /*
2467                  * Check for optional alternate path and fill in the
2468                  * appropriate QPC fields if one is specified
2469                  */
2470                 if (flags & IBT_CEP_SET_ALT_PATH) {
2471                         qpc_path = &qpc->alt_addr_path;
2472                         adds_vect = &uc->uc_alt_path.cep_adds_vect;
2473 
2474                         /* Set the common alternate address path fields */
2475                         status = hermon_set_addr_path(state, adds_vect,
2476                             qpc_path, HERMON_ADDRPATH_QP);
2477                         if (status != DDI_SUCCESS) {
2478                                 return (status);
2479                         }
2480 
2481                         /*
2482                          * Check for valid alternate path port number and fill
2483                          * it in
2484                          */
2485                         portnum = uc->uc_alt_path.cep_hca_port_num;
2486                         if (hermon_portnum_is_valid(state, portnum)) {
2487                                 qp->qp_portnum_alt = portnum - 1;
2488                                 qpc->alt_addr_path.sched_q =
2489                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2490                                     adds_vect->av_srvl, qp->qp_is_special);
2491                         } else {
2492                                 return (IBT_HCA_PORT_INVALID);
2493                         }
2494 
2495                         /*
2496                          * Check for valid alternate path PKey index and fill
2497                          * it in
2498                          */
2499                         pkeyindx = uc->uc_alt_path.cep_pkey_ix;
2500                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2501                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2502                         } else {
2503                                 return (IBT_PKEY_IX_ILLEGAL);
2504                         }
2505                         opmask |= HERMON_CMD_OP_ALT_PATH;
2506                 }
2507         } else {
2508                 /*
2509                  * Invalid QP transport type. If we got here then it's a
2510                  * warning of a probably serious problem.  So print a message
2511                  * and return failure
2512                  */
2513                 HERMON_WARNING(state, "unknown QP transport type in sqd2rts");
2514                 return (ibc_get_ci_failure(0));
2515         }
2516 
2517         /*
2518          * Post the SQD2RTS_QP command to the Hermon firmware
2519          *
2520          * We do a HERMON_NOSLEEP here because we are still holding the
2521          * "qp_lock".  If we got raised to interrupt level by priority
2522          * inversion, we do not want to block in this routine waiting for
2523          * success.
2524          */
2525         status = hermon_cmn_qp_cmd_post(state, SQD2RTS_QP, qpc, qp->qp_qpnum,
2526             opmask, HERMON_CMD_NOSLEEP_SPIN);
2527         if (status != HERMON_CMD_SUCCESS) {
2528                 if (status != HERMON_CMD_BAD_QP_STATE) {
2529                         cmn_err(CE_NOTE, "hermon%d: SQD2RTS_QP command failed: "
2530                             "%08x\n", state->hs_instance, status);
2531                         if (status == HERMON_CMD_INVALID_STATUS) {
2532                                 hermon_fm_ereport(state, HCA_SYS_ERR,
2533                                     HCA_ERR_SRV_LOST);
2534                         }
2535                         return (ibc_get_ci_failure(0));
2536                 } else {
2537                         return (IBT_QP_STATE_INVALID);
2538                 }
2539         }
2540 
2541         return (DDI_SUCCESS);
2542 }
2543 
2544 
2545 /*
2546  * hermon_qp_sqd2sqd()
2547  *    Context: Can be called from interrupt or base context.
2548  */
2549 static int
2550 hermon_qp_sqd2sqd(hermon_state_t *state, hermon_qphdl_t qp,
2551     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
2552 {
2553         hermon_hw_qpc_t         *qpc;
2554         ibt_qp_rc_attr_t        *rc;
2555         ibt_qp_ud_attr_t        *ud;
2556         ibt_qp_uc_attr_t        *uc;
2557         hermon_hw_addr_path_t   *qpc_path;
2558         ibt_adds_vect_t         *adds_vect;
2559         uint_t                  portnum, pkeyindx;
2560         uint_t                  rra_max, sra_max;
2561         uint32_t                opmask = 0;
2562         int                     status;
2563 
2564         ASSERT(MUTEX_HELD(&qp->qp_lock));
2565 
2566         /*
2567          * Grab the temporary QPC entry from QP software state
2568          */
2569         qpc = &qp->qpc;
2570 
2571         /*
2572          * Fill in the common fields in the QPC
2573          */
2574 
2575         /*
2576          * Now fill in the QPC fields which are specific to transport type
2577          */
2578         if (qp->qp_type == IBT_UD_RQP) {
2579                 ud = &info_p->qp_transport.ud;
2580 
2581                 /*
2582                  * If we are attempting to modify the port for this QP, then
2583                  * check for valid port number and fill it in.  Also set the
2584                  * appropriate flag in the "opmask" parameter.
2585                  */
2586                 if (flags & IBT_CEP_SET_PORT) {
2587                         portnum = ud->ud_port;
2588                         if (hermon_portnum_is_valid(state, portnum)) {
2589                                 qp->qp_portnum = portnum - 1;
2590                                 qpc->pri_addr_path.sched_q =
2591                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2592                                     0, qp->qp_is_special);
2593                         } else {
2594                                 return (IBT_HCA_PORT_INVALID);
2595                         }
2596                         opmask |= HERMON_CMD_OP_SCHEDQUEUE;
2597                 }
2598 
2599                 /*
2600                  * If we are attempting to modify the PKey index for this QP,
2601                  * then check for valid PKey index and fill it in.  Also set
2602                  * the appropriate flag in the "opmask" parameter.
2603                  */
2604                 if (flags & IBT_CEP_SET_PKEY_IX) {
2605                         pkeyindx = ud->ud_pkey_ix;
2606                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2607                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
2608                                 opmask |= HERMON_CMD_OP_PKEYINDX;
2609                                 qp->qp_pkeyindx = pkeyindx;
2610                         } else {
2611                                 return (IBT_PKEY_IX_ILLEGAL);
2612                         }
2613                 }
2614 
2615                 /*
2616                  * If we are attempting to modify the QKey for this QP, then
2617                  * fill it in and set the appropriate flag in the "opmask"
2618                  * parameter.
2619                  */
2620                 if (flags & IBT_CEP_SET_QKEY) {
2621                         qpc->qkey = ud->ud_qkey;
2622                         opmask |= HERMON_CMD_OP_QKEY;
2623                 }
2624 
2625         } else if (qp->qp_serv_type == HERMON_QP_RC) {
2626                 rc = &info_p->qp_transport.rc;
2627 
2628                 /*
2629                  * Check if any of the flags indicate a change in the RDMA
2630                  * (recv) enable/disable flags and set the appropriate flag in
2631                  * the "opmask" parameter
2632                  */
2633                 opmask |= hermon_check_rdma_enable_flags(flags, info_p, qpc);
2634 
2635                 /*
2636                  * Check for optional primary path and fill in the
2637                  * appropriate QPC fields if one is specified
2638                  */
2639                 if (flags & IBT_CEP_SET_ADDS_VECT) {
2640                         qpc_path = &qpc->pri_addr_path;
2641                         adds_vect = &rc->rc_path.cep_adds_vect;
2642 
2643                         /* Set the common primary address path fields */
2644                         status = hermon_set_addr_path(state, adds_vect,
2645                             qpc_path, HERMON_ADDRPATH_QP);
2646                         if (status != DDI_SUCCESS) {
2647                                 return (status);
2648                         }
2649                         qpc->rnr_retry = rc->rc_rnr_retry_cnt;
2650                         qpc_path->ack_timeout = rc->rc_path.cep_timeout;
2651                         qpc->retry_cnt = rc->rc_retry_cnt;
2652 
2653                         portnum = qp->qp_portnum + 1;
2654                         if (hermon_portnum_is_valid(state, portnum)) {
2655                                 qpc->pri_addr_path.sched_q  =
2656                                     HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
2657                                     adds_vect->av_srvl, qp->qp_is_special);
2658                         } else {
2659                                 return (IBT_HCA_PORT_INVALID);
2660                         }
2661 
2662                         /*
2663                          * MTU changes as part of sqd2sqd are not allowed.
2664                          * Simply keep the same MTU value here, stored in the
2665                          * qphdl from init2rtr time.
2666                          */
2667                         qpc->mtu = qp->qp_save_mtu;
2668 
2669                         opmask |= (HERMON_CMD_OP_PRIM_PATH |
2670                             HERMON_CMD_OP_RETRYCNT | HERMON_CMD_OP_ACKTIMEOUT |
2671                             HERMON_CMD_OP_PRIM_RNRRETRY);
2672                 }
2673 
2674                 /*
2675                  * If we are attempting to modify the path migration state for
2676                  * this QP, then check for valid state and fill it in.  Also
2677                  * set the appropriate flag in the "opmask" parameter.
2678                  */
2679                 if (flags & IBT_CEP_SET_MIG) {
2680                         if (rc->rc_mig_state == IBT_STATE_MIGRATED) {
2681                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2682                         } else if (rc->rc_mig_state == IBT_STATE_REARMED) {
2683                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2684                         } else {
2685                                 return (IBT_QP_APM_STATE_INVALID);
2686                         }
2687                         opmask |= HERMON_CMD_OP_PM_STATE;
2688                 }
2689 
2690                 /*
2691                  * If we are attempting to modify the PKey index for this QP,
2692                  * then check for valid PKey index and fill it in.  Also set
2693                  * the appropriate flag in the "opmask" parameter.
2694                  */
2695                 if (flags & IBT_CEP_SET_PKEY_IX) {
2696                         pkeyindx = rc->rc_path.cep_pkey_ix;
2697                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2698                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
2699                                 opmask |= HERMON_CMD_OP_PKEYINDX;
2700                         } else {
2701                                 return (IBT_PKEY_IX_ILLEGAL);
2702                         }
2703                 }
2704 
2705                 /*
2706                  * If we are attempting to modify the port for this QP, then
2707                  * check for valid port number and fill it in.  Also set the
2708                  * appropriate flag in the "opmask" parameter.
2709                  */
2710                 if (flags & IBT_CEP_SET_PORT) {
2711                         portnum = rc->rc_path.cep_hca_port_num;
2712                         if (hermon_portnum_is_valid(state, portnum)) {
2713                                 qp->qp_portnum = portnum - 1;
2714                                 qpc->pri_addr_path.sched_q =
2715                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2716                                     adds_vect->av_srvl, qp->qp_is_special);
2717                         } else {
2718                                 return (IBT_HCA_PORT_INVALID);
2719                         }
2720                         opmask |= HERMON_CMD_OP_SCHEDQUEUE;
2721                 }
2722 
2723                 /*
2724                  * Check for optional alternate path and fill in the
2725                  * appropriate QPC fields if one is specified
2726                  */
2727                 if (flags & IBT_CEP_SET_ALT_PATH) {
2728                         qpc_path = &qpc->alt_addr_path;
2729                         adds_vect = &rc->rc_alt_path.cep_adds_vect;
2730 
2731                         /* Set the common alternate address path fields */
2732                         status = hermon_set_addr_path(state, adds_vect,
2733                             qpc_path, HERMON_ADDRPATH_QP);
2734                         if (status != DDI_SUCCESS) {
2735                                 return (status);
2736                         }
2737                         qpc_path->ack_timeout = rc->rc_alt_path.cep_timeout;
2738 
2739                         /*
2740                          * Check for valid alternate path port number and fill
2741                          * it in
2742                          */
2743                         portnum = rc->rc_alt_path.cep_hca_port_num;
2744                         if (hermon_portnum_is_valid(state, portnum)) {
2745                                 qp->qp_portnum_alt = portnum - 1;
2746                                 qpc->alt_addr_path.sched_q =
2747                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2748                                     adds_vect->av_srvl, qp->qp_is_special);
2749                         } else {
2750                                 return (IBT_HCA_PORT_INVALID);
2751                         }
2752 
2753                         /*
2754                          * Check for valid alternate path PKey index and fill
2755                          * it in
2756                          */
2757                         pkeyindx = rc->rc_alt_path.cep_pkey_ix;
2758                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2759                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2760                         } else {
2761                                 return (IBT_PKEY_IX_ILLEGAL);
2762                         }
2763                         opmask |= HERMON_CMD_OP_ALT_PATH;
2764                 }
2765 
2766                 /*
2767                  * If we are attempting to modify the number of "outgoing
2768                  * RDMA resources" for this QP, then check for valid value and
2769                  * fill it in.  Also set the appropriate flag in the "opmask"
2770                  * parameter.
2771                  */
2772                 if (flags & IBT_CEP_SET_RDMARA_OUT) {
2773                         if (hermon_qp_validate_init_depth(state, rc,
2774                             &sra_max) != DDI_SUCCESS) {
2775                                 return (IBT_INVALID_PARAM);
2776                         }
2777                         qpc->sra_max = sra_max;
2778                         opmask |= HERMON_CMD_OP_SRA_SET;
2779                 }
2780 
2781                 /*
2782                  * If we are attempting to modify the number of "incoming
2783                  * RDMA resources" for this QP, then check for valid value and
2784                  * update the "rra_max" and "ra_buf_index" fields in the QPC to
2785                  * point to the pre-allocated RDB resources (in DDR).  Also set
2786                  * the appropriate flag in the "opmask" parameter.
2787                  */
2788                 if (flags & IBT_CEP_SET_RDMARA_IN) {
2789                         if (hermon_qp_validate_resp_rsrc(state, rc,
2790                             &rra_max) != DDI_SUCCESS) {
2791                                 return (IBT_INVALID_PARAM);
2792                         }
2793                         qpc->rra_max = rra_max;
2794                         opmask |= HERMON_CMD_OP_RRA_SET;
2795                 }
2796 
2797                 /*
2798                  * If we are attempting to modify the "Local Ack Timeout" value
2799                  * for this QP, then fill it in and set the appropriate flag in
2800                  * the "opmask" parameter.
2801                  */
2802                 if (flags & IBT_CEP_SET_TIMEOUT) {
2803                         qpc_path = &qpc->pri_addr_path;
2804                         qpc_path->ack_timeout = rc->rc_path.cep_timeout;
2805                         opmask |= HERMON_CMD_OP_ACKTIMEOUT;
2806                 }
2807 
2808                 /*
2809                  * If we are attempting to modify the "Retry Count" for this QP,
2810                  * then fill it in and set the appropriate flag in the "opmask"
2811                  * parameter.
2812                  */
2813                 if (flags & IBT_CEP_SET_RETRY) {
2814                         qpc->retry_cnt = rc->rc_retry_cnt;
2815                         opmask |= HERMON_CMD_OP_PRIM_RNRRETRY;
2816                 }
2817 
2818                 /*
2819                  * If we are attempting to modify the "RNR Retry Count" for this
2820                  * QP, then fill it in and set the appropriate flag in the
2821                  * "opmask" parameter.
2822                  */
2823                 if (flags & IBT_CEP_SET_RNR_NAK_RETRY) {
2824                         qpc_path = &qpc->pri_addr_path;
2825                         qpc->rnr_retry = rc->rc_rnr_retry_cnt;
2826                         opmask |= HERMON_CMD_OP_RETRYCNT;
2827                 }
2828 
2829                 /*
2830                  * If we are attempting to modify the "Minimum RNR NAK" value
2831                  * for this QP, then fill it in and set the appropriate flag
2832                  * in the "opmask" parameter.
2833                  */
2834                 if (flags & IBT_CEP_SET_MIN_RNR_NAK) {
2835                         qpc->min_rnr_nak = rc->rc_min_rnr_nak;
2836                         opmask |= HERMON_CMD_OP_MINRNRNAK;
2837                 }
2838 
2839         } else if (qp->qp_serv_type == HERMON_QP_UC) {
2840                 uc = &info_p->qp_transport.uc;
2841 
2842                 /*
2843                  * Check if any of the flags indicate a change in the RDMA
2844                  * Write (recv) enable/disable and set the appropriate flag
2845                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
2846                  * not valid for UC transport.
2847                  */
2848                 if (flags & IBT_CEP_SET_RDMA_W) {
2849                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
2850                         opmask |= HERMON_CMD_OP_RWE;
2851                 }
2852 
2853                 /*
2854                  * Check for optional primary path and fill in the
2855                  * appropriate QPC fields if one is specified
2856                  */
2857                 if (flags & IBT_CEP_SET_ADDS_VECT) {
2858                         qpc_path = &qpc->pri_addr_path;
2859                         adds_vect = &uc->uc_path.cep_adds_vect;
2860 
2861                         /* Set the common primary address path fields */
2862                         status = hermon_set_addr_path(state, adds_vect,
2863                             qpc_path, HERMON_ADDRPATH_QP);
2864                         if (status != DDI_SUCCESS) {
2865                                 return (status);
2866                         }
2867                         portnum = qp->qp_portnum + 1;
2868                         if (hermon_portnum_is_valid(state, portnum)) {
2869                                 qpc->pri_addr_path.sched_q =
2870                                     HERMON_QP_SCHEDQ_GET(qp->qp_portnum,
2871                                     adds_vect->av_srvl, qp->qp_is_special);
2872                         } else {
2873                                 return (IBT_HCA_PORT_INVALID);
2874                         }
2875 
2876                         /*
2877                          * MTU changes as part of sqd2sqd are not allowed.
2878                          * Simply keep the same MTU value here, stored in the
2879                          * qphdl from init2rtr time.
2880                          */
2881                         qpc->mtu = qp->qp_save_mtu;
2882 
2883                         opmask |= HERMON_CMD_OP_PRIM_PATH;
2884                 }
2885 
2886                 /*
2887                  * If we are attempting to modify the path migration state for
2888                  * this QP, then check for valid state and fill it in.  Also
2889                  * set the appropriate flag in the "opmask" parameter.
2890                  */
2891                 if (flags & IBT_CEP_SET_MIG) {
2892                         if (uc->uc_mig_state == IBT_STATE_MIGRATED) {
2893                                 qpc->pm_state = HERMON_QP_PMSTATE_MIGRATED;
2894                         } else if (uc->uc_mig_state == IBT_STATE_REARMED) {
2895                                 qpc->pm_state = HERMON_QP_PMSTATE_REARM;
2896                         } else {
2897                                 return (IBT_QP_APM_STATE_INVALID);
2898                         }
2899                         opmask |= HERMON_CMD_OP_PM_STATE;
2900                 }
2901 
2902                 /*
2903                  * If we are attempting to modify the PKey index for this QP,
2904                  * then check for valid PKey index and fill it in.  Also set
2905                  * the appropriate flag in the "opmask" parameter.
2906                  */
2907                 if (flags & IBT_CEP_SET_PKEY_IX) {
2908                         pkeyindx = uc->uc_path.cep_pkey_ix;
2909                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2910                                 qpc->pri_addr_path.pkey_indx = pkeyindx;
2911                                 opmask |= HERMON_CMD_OP_PKEYINDX;
2912                         } else {
2913                                 return (IBT_PKEY_IX_ILLEGAL);
2914                         }
2915                 }
2916 
2917                 /*
2918                  * Check for optional alternate path and fill in the
2919                  * appropriate QPC fields if one is specified
2920                  */
2921                 if (flags & IBT_CEP_SET_ALT_PATH) {
2922                         qpc_path = &qpc->alt_addr_path;
2923                         adds_vect = &uc->uc_alt_path.cep_adds_vect;
2924 
2925                         /* Set the common alternate address path fields */
2926                         status = hermon_set_addr_path(state, adds_vect,
2927                             qpc_path, HERMON_ADDRPATH_QP);
2928                         if (status != DDI_SUCCESS) {
2929                                 return (status);
2930                         }
2931 
2932                         /*
2933                          * Check for valid alternate path port number and fill
2934                          * it in
2935                          */
2936                         portnum = uc->uc_alt_path.cep_hca_port_num;
2937                         if (hermon_portnum_is_valid(state, portnum)) {
2938                                 qp->qp_portnum_alt = portnum - 1;
2939                                 qpc->alt_addr_path.sched_q =
2940                                     HERMON_QP_SCHEDQ_GET(portnum - 1,
2941                                     adds_vect->av_srvl, qp->qp_is_special);
2942                         } else {
2943                                 return (IBT_HCA_PORT_INVALID);
2944                         }
2945 
2946                         /*
2947                          * Check for valid alternate path PKey index and fill
2948                          * it in
2949                          */
2950                         pkeyindx = uc->uc_alt_path.cep_pkey_ix;
2951                         if (hermon_pkeyindex_is_valid(state, pkeyindx)) {
2952                                 qpc->alt_addr_path.pkey_indx = pkeyindx;
2953                         } else {
2954                                 return (IBT_PKEY_IX_ILLEGAL);
2955                         }
2956                         opmask |= HERMON_CMD_OP_ALT_PATH;
2957                 }
2958         } else {
2959                 /*
2960                  * Invalid QP transport type. If we got here then it's a
2961                  * warning of a probably serious problem.  So print a message
2962                  * and return failure
2963                  */
2964                 HERMON_WARNING(state, "unknown QP transport type in sqd2sqd");
2965                 return (ibc_get_ci_failure(0));
2966         }
2967 
2968         /*
2969          * Post the SQD2SQD_QP command to the Hermon firmware
2970          *
2971          * We do a HERMON_NOSLEEP here because we are still holding the
2972          * "qp_lock".  If we got raised to interrupt level by priority
2973          * inversion, we do not want to block in this routine waiting for
2974          * success.
2975          */
2976         status = hermon_cmn_qp_cmd_post(state, SQD2SQD_QP, qpc, qp->qp_qpnum,
2977             opmask, HERMON_CMD_NOSLEEP_SPIN);
2978         if (status != HERMON_CMD_SUCCESS) {
2979                 if (status != HERMON_CMD_BAD_QP_STATE) {
2980                         cmn_err(CE_NOTE, "hermon%d: SQD2SQD_QP command failed: "
2981                             "%08x\n", state->hs_instance, status);
2982                         if (status == HERMON_CMD_INVALID_STATUS) {
2983                                 hermon_fm_ereport(state, HCA_SYS_ERR,
2984                                     HCA_ERR_SRV_LOST);
2985                         }
2986                         return (ibc_get_ci_failure(0));
2987                 } else {
2988                         return (IBT_QP_STATE_INVALID);
2989                 }
2990         }
2991 
2992         return (DDI_SUCCESS);
2993 }
2994 
2995 
2996 /*
2997  * hermon_qp_sqerr2rts()
2998  *    Context: Can be called from interrupt or base context.
2999  */
3000 static int
3001 hermon_qp_sqerr2rts(hermon_state_t *state, hermon_qphdl_t qp,
3002     ibt_cep_modify_flags_t flags, ibt_qp_info_t *info_p)
3003 {
3004         hermon_hw_qpc_t         *qpc;
3005         ibt_qp_ud_attr_t        *ud;
3006         uint32_t                opmask = 0;
3007         int                     status;
3008 
3009         ASSERT(MUTEX_HELD(&qp->qp_lock));
3010 
3011         /*
3012          * Grab the temporary QPC entry from QP software state
3013          */
3014         qpc = &qp->qpc;
3015 
3016         /*
3017          * Since there are no common fields to be filled in for this command,
3018          * we begin with the QPC fields which are specific to transport type.
3019          */
3020         if (qp->qp_type == IBT_UD_RQP) {
3021                 ud = &info_p->qp_transport.ud;
3022 
3023                 /*
3024                  * If we are attempting to modify the QKey for this QP, then
3025                  * fill it in and set the appropriate flag in the "opmask"
3026                  * parameter.
3027                  */
3028                 if (flags & IBT_CEP_SET_QKEY) {
3029                         qpc->qkey = ud->ud_qkey;
3030                         opmask |= HERMON_CMD_OP_QKEY;
3031                 }
3032 
3033         } else if (qp->qp_serv_type == HERMON_QP_UC) {
3034 
3035                 /*
3036                  * Check if any of the flags indicate a change in the RDMA
3037                  * Write (recv) enable/disable and set the appropriate flag
3038                  * in the "opmask" parameter. Note: RDMA Read and Atomic are
3039                  * not valid for UC transport.
3040                  */
3041                 if (flags & IBT_CEP_SET_RDMA_W) {
3042                         qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
3043                         opmask |= HERMON_CMD_OP_RWE;
3044                 }
3045         } else {
3046                 /*
3047                  * Invalid QP transport type. If we got here then it's a
3048                  * warning of a probably serious problem.  So print a message
3049                  * and return failure
3050                  */
3051                 HERMON_WARNING(state, "unknown QP transport type in sqerr2rts");
3052                 return (ibc_get_ci_failure(0));
3053         }
3054 
3055         /*
3056          * Post the SQERR2RTS_QP command to the Hermon firmware
3057          *
3058          * We do a HERMON_NOSLEEP here because we are still holding the
3059          * "qp_lock".  If we got raised to interrupt level by priority
3060          * inversion, we do not want to block in this routine waiting for
3061          * success.
3062          */
3063         status = hermon_cmn_qp_cmd_post(state, SQERR2RTS_QP, qpc, qp->qp_qpnum,
3064             opmask, HERMON_CMD_NOSLEEP_SPIN);
3065         if (status != HERMON_CMD_SUCCESS) {
3066                 if (status != HERMON_CMD_BAD_QP_STATE) {
3067                         cmn_err(CE_NOTE, "hermon%d: SQERR2RTS_QP command "
3068                             "failed: %08x\n", state->hs_instance, status);
3069                         if (status == HERMON_CMD_INVALID_STATUS) {
3070                                 hermon_fm_ereport(state, HCA_SYS_ERR,
3071                                     HCA_ERR_SRV_LOST);
3072                         }
3073                         return (ibc_get_ci_failure(0));
3074                 } else {
3075                         return (IBT_QP_STATE_INVALID);
3076                 }
3077         }
3078 
3079         return (DDI_SUCCESS);
3080 }
3081 
3082 
3083 /*
3084  * hermon_qp_to_error()
3085  *    Context: Can be called from interrupt or base context.
3086  */
3087 static int
3088 hermon_qp_to_error(hermon_state_t *state, hermon_qphdl_t qp)
3089 {
3090         int     status;
3091 
3092         ASSERT(MUTEX_HELD(&qp->qp_lock));
3093 
3094         /*
3095          * Post the TOERR_QP command to the Hermon firmware
3096          *
3097          * We do a HERMON_NOSLEEP here because we are still holding the
3098          * "qp_lock".  If we got raised to interrupt level by priority
3099          * inversion, we do not want to block in this routine waiting for
3100          * success.
3101          */
3102         status = hermon_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
3103             0, HERMON_CMD_NOSLEEP_SPIN);
3104         if (status != HERMON_CMD_SUCCESS) {
3105                 cmn_err(CE_NOTE, "hermon%d: TOERR_QP command failed: %08x\n",
3106                     state->hs_instance, status);
3107                 if (status == HERMON_CMD_INVALID_STATUS) {
3108                         hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
3109                 }
3110                 return (ibc_get_ci_failure(0));
3111         }
3112 
3113         return (DDI_SUCCESS);
3114 }
3115 
3116 
3117 /*
3118  * hermon_qp_to_reset()
3119  *    Context: Can be called from interrupt or base context.
3120  */
3121 int
3122 hermon_qp_to_reset(hermon_state_t *state, hermon_qphdl_t qp)
3123 {
3124         hermon_hw_qpc_t *qpc;
3125         int             status;
3126 
3127         ASSERT(MUTEX_HELD(&qp->qp_lock));
3128 
3129         /*
3130          * Grab the temporary QPC entry from QP software state
3131          */
3132         qpc = &qp->qpc;
3133 
3134         /*
3135          * Post the TORST_QP command to the Hermon firmware
3136          *
3137          * We do a HERMON_NOSLEEP here because we are still holding the
3138          * "qp_lock".  If we got raised to interrupt level by priority
3139          * inversion, we do not want to block in this routine waiting for
3140          * success.
3141          */
3142         status = hermon_cmn_qp_cmd_post(state, TORST_QP, qpc, qp->qp_qpnum,
3143             0, HERMON_CMD_NOSLEEP_SPIN);
3144         if (status != HERMON_CMD_SUCCESS) {
3145                 cmn_err(CE_NOTE, "hermon%d: TORST_QP command failed: %08x\n",
3146                     state->hs_instance, status);
3147                 if (status == HERMON_CMD_INVALID_STATUS) {
3148                         hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
3149                 }
3150                 return (ibc_get_ci_failure(0));
3151         }
3152         if (qp->qp_serv_type == HERMON_QP_FEXCH) {
3153                 status = hermon_fcoib_fexch_mkey_fini(state, qp->qp_pdhdl,
3154                     qp->qp_qpnum, HERMON_CMD_NOSLEEP_SPIN);
3155                 if (status != DDI_SUCCESS)
3156                         cmn_err(CE_NOTE, "hermon%d: fexch_mkey_fini failed "
3157                             "%08x\n", state->hs_instance, status);
3158         }
3159         return (DDI_SUCCESS);
3160 }
3161 
3162 
3163 /*
3164  * hermon_qp_reset2err()
3165  *    Context: Can be called from interrupt or base context.
3166  */
3167 static int
3168 hermon_qp_reset2err(hermon_state_t *state, hermon_qphdl_t qp)
3169 {
3170         hermon_hw_qpc_t *qpc;
3171         int             status;
3172         uint32_t        cqnmask;
3173 
3174         ASSERT(MUTEX_HELD(&qp->qp_lock));
3175 
3176         /*
3177          * In order to implement the transition from "Reset" directly to the
3178          * "Error" state, it is necessary to first give ownership of the QP
3179          * context to the Hermon hardware.  This is accomplished by
3180          * transitioning the QP to "Init" as an intermediate step and then,
3181          * immediately transitioning to "Error".
3182          *
3183          * When this function returns success, the QP context will be owned by
3184          * the Hermon hardware and will be in the "Error" state.
3185          */
3186 
3187         /*
3188          * Grab the temporary QPC entry from QP software state
3189          */
3190         qpc = &qp->qpc;
3191 
3192         /*
3193          * Fill in the common fields in the QPC
3194          */
3195         if (qp->qp_is_special) {
3196                 qpc->serv_type       = HERMON_QP_MLX;
3197         } else {
3198                 qpc->serv_type       = qp->qp_serv_type;
3199         }
3200         qpc->pm_state                = HERMON_QP_PMSTATE_MIGRATED;
3201         qpc->usr_page                = qp->qp_uarpg;
3202         /* dbr is now an address, not an index */
3203         qpc->dbr_addrh               = ((uint64_t)qp->qp_rq_pdbr >> 32);
3204         qpc->dbr_addrl               = ((uint64_t)qp->qp_rq_pdbr & 0xFFFFFFFC) >> 2;
3205         qpc->pd                      = qp->qp_pdhdl->pd_pdnum;
3206         /*
3207          * HERMON:
3208          * qpc->wqe_baseaddr is replaced by LKey from the cMPT, and
3209          * page_offset, mtt_base_addr_h/l, and log2_page_size will
3210          * be used to map the WQE buffer
3211          * NOTE that the cMPT is created implicitly when the QP is
3212          * transitioned from reset to init
3213          */
3214         qpc->log2_pgsz               = qp->qp_mrhdl->mr_log2_pgsz;
3215         qpc->mtt_base_addrh  = (qp->qp_mrhdl->mr_mttaddr) >> 32 & 0xFF;
3216         qpc->mtt_base_addrl  = (qp->qp_mrhdl->mr_mttaddr) >> 3 & 0xFFFFFFFF;
3217         cqnmask = (1 << state->hs_cfg_profile->cp_log_num_cq) - 1;
3218         qpc->cqn_snd         =
3219             (qp->qp_sq_cqhdl == NULL) ? 0 : qp->qp_sq_cqhdl->cq_cqnum & cqnmask;
3220         qpc->page_offs               = qp->qp_wqinfo.qa_pgoffs >> 6;
3221         qpc->cqn_rcv         =
3222             (qp->qp_rq_cqhdl == NULL) ? 0 : qp->qp_rq_cqhdl->cq_cqnum & cqnmask;
3223 
3224         qpc->sq_wqe_counter  = 0;
3225         qpc->rq_wqe_counter  = 0;
3226         qpc->log_sq_stride   = qp->qp_sq_log_wqesz - 4;
3227         qpc->log_rq_stride   = qp->qp_rq_log_wqesz - 4;
3228         qpc->log_sq_size     = highbit(qp->qp_sq_bufsz) - 1;
3229         qpc->log_rq_size     = highbit(qp->qp_rq_bufsz) - 1;
3230         qpc->srq_en          = (qp->qp_alloc_flags & IBT_QP_USES_SRQ) != 0;
3231         qpc->sq_no_prefetch  = qp->qp_no_prefetch;
3232 
3233         if (qp->qp_alloc_flags & IBT_QP_USES_SRQ) {
3234                 qpc->srq_number      = qp->qp_srqhdl->srq_srqnum;
3235         } else {
3236                 qpc->srq_number = 0;
3237         }
3238 
3239         qpc->fre             = 0; /* default disable fast registration WR */
3240         qpc->rlky            = 0; /* default disable reserved lkey */
3241 
3242         /*
3243          * Now fill in the QPC fields which are specific to transport type
3244          */
3245         if (qp->qp_type == IBT_UD_RQP) {
3246                 /* Set the UD parameters to an invalid default */
3247                 qpc->qkey = 0;
3248                 qpc->pri_addr_path.sched_q =
3249                     HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
3250                 qpc->pri_addr_path.pkey_indx = 0;
3251 
3252         } else if (qp->qp_serv_type == HERMON_QP_RC) {
3253                 /* Set the RC parameters to invalid default */
3254                 qpc->rre = 0;
3255                 qpc->rwe = 0;
3256                 qpc->rae = 0;
3257                 qpc->alt_addr_path.sched_q =
3258                     HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
3259                 qpc->pri_addr_path.pkey_indx = 0;
3260 
3261         } else if (qp->qp_serv_type == HERMON_QP_UC) {
3262                 /* Set the UC parameters to invalid default */
3263                 qpc->rwe = 0;
3264                 qpc->alt_addr_path.sched_q =
3265                     HERMON_QP_SCHEDQ_GET(0, 0, qp->qp_is_special);
3266                 qpc->pri_addr_path.pkey_indx = 0;
3267 
3268         } else {
3269                 /*
3270                  * Invalid QP transport type. If we got here then it's a
3271                  * warning of a probably serious problem.  So print a message
3272                  * and return failure
3273                  */
3274                 HERMON_WARNING(state, "unknown QP transport type in rst2err");
3275                 return (ibc_get_ci_failure(0));
3276         }
3277 
3278         /*
3279          * Post the RST2INIT_QP command to the Hermon firmware
3280          *
3281          * We do a HERMON_NOSLEEP here because we are still holding the
3282          * "qp_lock".  If we got raised to interrupt level by priority
3283          * inversion, we do not want to block in this routine waiting for
3284          * success.
3285          */
3286         status = hermon_cmn_qp_cmd_post(state, RST2INIT_QP, qpc, qp->qp_qpnum,
3287             0, HERMON_CMD_NOSLEEP_SPIN);
3288         if (status != HERMON_CMD_SUCCESS) {
3289                 cmn_err(CE_NOTE, "hermon%d: RST2INIT_QP command failed: %08x\n",
3290                     state->hs_instance, status);
3291                 if (status == HERMON_CMD_INVALID_STATUS) {
3292                         hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
3293                 }
3294                 return (ibc_get_ci_failure(0));
3295         }
3296 
3297         /*
3298          * Now post the TOERR_QP command to the Hermon firmware
3299          *
3300          * We still do a HERMON_NOSLEEP here because we are still holding the
3301          * "qp_lock".  Note:  If this fails (which it really never should),
3302          * it indicates a serious problem in the HW or SW.  We try to move
3303          * the QP back to the "Reset" state if possible and print a warning
3304          * message if not.  In any case, we return an error here.
3305          */
3306         status = hermon_cmn_qp_cmd_post(state, TOERR_QP, NULL, qp->qp_qpnum,
3307             0, HERMON_CMD_NOSLEEP_SPIN);
3308         if (status != HERMON_CMD_SUCCESS) {
3309                 cmn_err(CE_NOTE, "hermon%d: TOERR_QP command failed: %08x\n",
3310                     state->hs_instance, status);
3311                 if (status == HERMON_CMD_INVALID_STATUS) {
3312                         hermon_fm_ereport(state, HCA_SYS_ERR, HCA_ERR_SRV_LOST);
3313                 }
3314                 if (hermon_qp_to_reset(state, qp) != DDI_SUCCESS) {
3315                         HERMON_WARNING(state, "failed to reset QP context");
3316                 }
3317                 return (ibc_get_ci_failure(0));
3318         }
3319 
3320         return (DDI_SUCCESS);
3321 }
3322 
3323 
3324 /*
3325  * hermon_check_rdma_enable_flags()
3326  *    Context: Can be called from interrupt or base context.
3327  */
3328 static uint_t
3329 hermon_check_rdma_enable_flags(ibt_cep_modify_flags_t flags,
3330     ibt_qp_info_t *info_p, hermon_hw_qpc_t *qpc)
3331 {
3332         uint_t  opmask = 0;
3333 
3334         if (flags & IBT_CEP_SET_RDMA_R) {
3335                 qpc->rre = (info_p->qp_flags & IBT_CEP_RDMA_RD) ? 1 : 0;
3336                 opmask |= HERMON_CMD_OP_RRE;
3337         }
3338 
3339         if (flags & IBT_CEP_SET_RDMA_W) {
3340                 qpc->rwe = (info_p->qp_flags & IBT_CEP_RDMA_WR) ? 1 : 0;
3341                 opmask |= HERMON_CMD_OP_RWE;
3342         }
3343 
3344         if (flags & IBT_CEP_SET_ATOMIC) {
3345                 qpc->rae = (info_p->qp_flags & IBT_CEP_ATOMIC) ? 1 : 0;
3346                 opmask |= HERMON_CMD_OP_RAE;
3347         }
3348 
3349         return (opmask);
3350 }
3351 
3352 /*
3353  * hermon_qp_validate_resp_rsrc()
3354  *    Context: Can be called from interrupt or base context.
3355  */
3356 static int
3357 hermon_qp_validate_resp_rsrc(hermon_state_t *state, ibt_qp_rc_attr_t *rc,
3358     uint_t *rra_max)
3359 {
3360         uint_t  rdma_ra_in;
3361 
3362         rdma_ra_in = rc->rc_rdma_ra_in;
3363 
3364         /*
3365          * Check if number of responder resources is too large.  Return an
3366          * error if it is
3367          */
3368         if (rdma_ra_in > state->hs_cfg_profile->cp_hca_max_rdma_in_qp) {
3369                 return (IBT_INVALID_PARAM);
3370         }
3371 
3372         /*
3373          * If the number of responder resources is too small, round it up.
3374          * Then find the next highest power-of-2
3375          */
3376         if (rdma_ra_in == 0) {
3377                 rdma_ra_in = 1;
3378         }
3379         if (ISP2(rdma_ra_in)) {
3380                 *rra_max = highbit(rdma_ra_in) - 1;
3381         } else {
3382                 *rra_max = highbit(rdma_ra_in);
3383         }
3384         return (DDI_SUCCESS);
3385 }
3386 
3387 
3388 /*
3389  * hermon_qp_validate_init_depth()
3390  *    Context: Can be called from interrupt or base context.
3391  */
3392 static int
3393 hermon_qp_validate_init_depth(hermon_state_t *state, ibt_qp_rc_attr_t *rc,
3394     uint_t *sra_max)
3395 {
3396         uint_t  rdma_ra_out;
3397 
3398         rdma_ra_out = rc->rc_rdma_ra_out;
3399 
3400         /*
3401          * Check if requested initiator depth is too large.  Return an error
3402          * if it is
3403          */
3404         if (rdma_ra_out > state->hs_cfg_profile->cp_hca_max_rdma_out_qp) {
3405                 return (IBT_INVALID_PARAM);
3406         }
3407 
3408         /*
3409          * If the requested initiator depth is too small, round it up.
3410          * Then find the next highest power-of-2
3411          */
3412         if (rdma_ra_out == 0) {
3413                 rdma_ra_out = 1;
3414         }
3415         if (ISP2(rdma_ra_out)) {
3416                 *sra_max = highbit(rdma_ra_out) - 1;
3417         } else {
3418                 *sra_max = highbit(rdma_ra_out);
3419         }
3420         return (DDI_SUCCESS);
3421 }
3422 
3423 
3424 /*
3425  * hermon_qp_validate_mtu()
3426  *    Context: Can be called from interrupt or base context.
3427  */
3428 static int
3429 hermon_qp_validate_mtu(hermon_state_t *state, uint_t mtu)
3430 {
3431         /*
3432          * Check for invalid MTU values (i.e. zero or any value larger than
3433          * the HCA's port maximum).
3434          */
3435         if ((mtu == 0) || (mtu > state->hs_cfg_profile->cp_max_mtu)) {
3436                 return (IBT_HCA_PORT_MTU_EXCEEDED);
3437         }
3438         return (DDI_SUCCESS);
3439 }
--- EOF ---