drivers/scsi/qla2xxx/qla_nvme.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * QLogic Fibre Channel HBA Driver
   4  * Copyright (c)  2003-2017 QLogic Corporation
   5  */
   6 #include "qla_nvme.h"
   7 #include <linux/scatterlist.h>
   8 #include <linux/delay.h>
   9 #include <linux/nvme.h>
  10 #include <linux/nvme-fc.h>
  11 #include <linux/blk-mq-pci.h>
  12 #include <linux/blk-mq.h>
  13
  14 static struct nvme_fc_port_template qla_nvme_fc_transport;
  15 static int qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha,
  16                                    struct qla_qpair *qp,
  17                                    struct qla_nvme_lsrjt_pt_arg *a,
  18                                    bool is_xchg_terminate);
  19
  20 struct qla_nvme_unsol_ctx {
  21         struct list_head elem;
  22         struct scsi_qla_host *vha;
  23         struct fc_port *fcport;
  24         struct srb *sp;
  25         struct nvmefc_ls_rsp lsrsp;
  26         struct nvmefc_ls_rsp *fd_rsp;
  27         struct work_struct lsrsp_work;
  28         struct work_struct abort_work;
  29         __le32 exchange_address;
  30         __le16 nport_handle;
  31         __le16 ox_id;
  32         int comp_status;
  33         spinlock_t cmd_lock;
  34 };
  35
  36 int qla_nvme_register_remote(struct scsi_qla_host *vha, struct fc_port *fcport)
  37 {
  38         struct qla_nvme_rport *rport;
  39         struct nvme_fc_port_info req;
  40         int ret;
  41
  42         if (!IS_ENABLED(CONFIG_NVME_FC))
  43                 return 0;
  44
  45         if (!vha->flags.nvme_enabled) {
  46                 ql_log(ql_log_info, vha, 0x2100,
  47                     "%s: Not registering target since Host NVME is not enabled\n",
  48                     __func__);
  49                 return 0;
  50         }
  51
  52         if (!vha->nvme_local_port && qla_nvme_register_hba(vha))
  53                 return 0;
  54
  55         if (!(fcport->nvme_prli_service_param &
  56             (NVME_PRLI_SP_TARGET | NVME_PRLI_SP_DISCOVERY)) ||
  57                 (fcport->nvme_flag & NVME_FLAG_REGISTERED))
  58                 return 0;
  59
  60         fcport->nvme_flag &= ~NVME_FLAG_RESETTING;
  61
  62         memset(&req, 0, sizeof(struct nvme_fc_port_info));
  63         req.port_name = wwn_to_u64(fcport->port_name);
  64         req.node_name = wwn_to_u64(fcport->node_name);
  65         req.port_role = 0;
  66         req.dev_loss_tmo = fcport->dev_loss_tmo;
  67
  68         if (fcport->nvme_prli_service_param & NVME_PRLI_SP_INITIATOR)
  69                 req.port_role = FC_PORT_ROLE_NVME_INITIATOR;
  70
  71         if (fcport->nvme_prli_service_param & NVME_PRLI_SP_TARGET)
  72                 req.port_role |= FC_PORT_ROLE_NVME_TARGET;
  73
  74         if (fcport->nvme_prli_service_param & NVME_PRLI_SP_DISCOVERY)
  75                 req.port_role |= FC_PORT_ROLE_NVME_DISCOVERY;
  76
  77         req.port_id = fcport->d_id.b24;
  78
  79         ql_log(ql_log_info, vha, 0x2102,
  80             "%s: traddr=nn-0x%016llx:pn-0x%016llx PortID:%06x\n",
  81             __func__, req.node_name, req.port_name,
  82             req.port_id);
  83
  84         ret = nvme_fc_register_remoteport(vha->nvme_local_port, &req,
  85             &fcport->nvme_remote_port);
  86         if (ret) {
  87                 ql_log(ql_log_warn, vha, 0x212e,
  88                     "Failed to register remote port. Transport returned %d\n",
  89                     ret);
  90                 return ret;
  91         }
  92
  93         nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port,
  94                                        fcport->dev_loss_tmo);
  95
  96         if (fcport->nvme_prli_service_param & NVME_PRLI_SP_SLER)
  97                 ql_log(ql_log_info, vha, 0x212a,
  98                        "PortID:%06x Supports SLER\n", req.port_id);
  99
 100         if (fcport->nvme_prli_service_param & NVME_PRLI_SP_PI_CTRL)
 101                 ql_log(ql_log_info, vha, 0x212b,
 102                        "PortID:%06x Supports PI control\n", req.port_id);
 103
 104         rport = fcport->nvme_remote_port->private;
 105         rport->fcport = fcport;
 106
 107         fcport->nvme_flag |= NVME_FLAG_REGISTERED;
 108         return 0;
 109 }
 110
 111 /* Allocate a queue for NVMe traffic */
 112 static int qla_nvme_alloc_queue(struct nvme_fc_local_port *lport,
 113     unsigned int qidx, u16 qsize, void **handle)
 114 {
 115         struct scsi_qla_host *vha;
 116         struct qla_hw_data *ha;
 117         struct qla_qpair *qpair;
 118
 119         /* Map admin queue and 1st IO queue to index 0 */
 120         if (qidx)
 121                 qidx--;
 122
 123         vha = (struct scsi_qla_host *)lport->private;
 124         ha = vha->hw;
 125
 126         ql_log(ql_log_info, vha, 0x2104,
 127             "%s: handle %p, idx =%d, qsize %d\n",
 128             __func__, handle, qidx, qsize);
 129
 130         if (qidx > qla_nvme_fc_transport.max_hw_queues) {
 131                 ql_log(ql_log_warn, vha, 0x212f,
 132                     "%s: Illegal qidx=%d. Max=%d\n",
 133                     __func__, qidx, qla_nvme_fc_transport.max_hw_queues);
 134                 return -EINVAL;
 135         }
 136
 137         /* Use base qpair if max_qpairs is 0 */
 138         if (!ha->max_qpairs) {
 139                 qpair = ha->base_qpair;
 140         } else {
 141                 if (ha->queue_pair_map[qidx]) {
 142                         *handle = ha->queue_pair_map[qidx];
 143                         ql_log(ql_log_info, vha, 0x2121,
 144                                "Returning existing qpair of %p for idx=%x\n",
 145                                *handle, qidx);
 146                         return 0;
 147                 }
 148
 149                 qpair = qla2xxx_create_qpair(vha, 5, vha->vp_idx, true);
 150                 if (!qpair) {
 151                         ql_log(ql_log_warn, vha, 0x2122,
 152                                "Failed to allocate qpair\n");
 153                         return -EINVAL;
 154                 }
 155                 qla_adjust_iocb_limit(vha);
 156         }
 157         *handle = qpair;
 158
 159         return 0;
 160 }
 161
 162 static void qla_nvme_release_fcp_cmd_kref(struct kref *kref)
 163 {
 164         struct srb *sp = container_of(kref, struct srb, cmd_kref);
 165         struct nvme_private *priv = (struct nvme_private *)sp->priv;
 166         struct nvmefc_fcp_req *fd;
 167         struct srb_iocb *nvme;
 168         unsigned long flags;
 169
 170         if (!priv)
 171                 goto out;
 172
 173         nvme = &sp->u.iocb_cmd;
 174         fd = nvme->u.nvme.desc;
 175
 176         spin_lock_irqsave(&priv->cmd_lock, flags);
 177         priv->sp = NULL;
 178         sp->priv = NULL;
 179         if (priv->comp_status == QLA_SUCCESS) {
 180                 fd->rcv_rsplen = le16_to_cpu(nvme->u.nvme.rsp_pyld_len);
 181                 fd->status = NVME_SC_SUCCESS;
 182         } else {
 183                 fd->rcv_rsplen = 0;
 184                 fd->transferred_length = 0;
 185                 fd->status = NVME_SC_INTERNAL;
 186         }
 187         spin_unlock_irqrestore(&priv->cmd_lock, flags);
 188
 189         fd->done(fd);
 190 out:
 191         qla2xxx_rel_qpair_sp(sp->qpair, sp);
 192 }
 193
 194 static void qla_nvme_release_ls_cmd_kref(struct kref *kref)
 195 {
 196         struct srb *sp = container_of(kref, struct srb, cmd_kref);
 197         struct nvme_private *priv = (struct nvme_private *)sp->priv;
 198         struct nvmefc_ls_req *fd;
 199         unsigned long flags;
 200
 201         if (!priv)
 202                 goto out;
 203
 204         spin_lock_irqsave(&priv->cmd_lock, flags);
 205         priv->sp = NULL;
 206         sp->priv = NULL;
 207         spin_unlock_irqrestore(&priv->cmd_lock, flags);
 208
 209         fd = priv->fd;
 210
 211         fd->done(fd, priv->comp_status);
 212 out:
 213         qla2x00_rel_sp(sp);
 214 }
 215
 216 static void qla_nvme_ls_complete(struct work_struct *work)
 217 {
 218         struct nvme_private *priv =
 219                 container_of(work, struct nvme_private, ls_work);
 220
 221         kref_put(&priv->sp->cmd_kref, qla_nvme_release_ls_cmd_kref);
 222 }
 223
 224 static void qla_nvme_sp_ls_done(srb_t *sp, int res)
 225 {
 226         struct nvme_private *priv = sp->priv;
 227
 228         if (WARN_ON_ONCE(kref_read(&sp->cmd_kref) == 0))
 229                 return;
 230
 231         if (res)
 232                 res = -EINVAL;
 233
 234         priv->comp_status = res;
 235         INIT_WORK(&priv->ls_work, qla_nvme_ls_complete);
 236         schedule_work(&priv->ls_work);
 237 }
 238
 239 static void qla_nvme_release_lsrsp_cmd_kref(struct kref *kref)
 240 {
 241         struct srb *sp = container_of(kref, struct srb, cmd_kref);
 242         struct qla_nvme_unsol_ctx *uctx = sp->priv;
 243         struct nvmefc_ls_rsp *fd_rsp;
 244         unsigned long flags;
 245
 246         if (!uctx) {
 247                 qla2x00_rel_sp(sp);
 248                 return;
 249         }
 250
 251         spin_lock_irqsave(&uctx->cmd_lock, flags);
 252         uctx->sp = NULL;
 253         sp->priv = NULL;
 254         spin_unlock_irqrestore(&uctx->cmd_lock, flags);
 255
 256         fd_rsp = uctx->fd_rsp;
 257
 258         list_del(&uctx->elem);
 259
 260         fd_rsp->done(fd_rsp);
 261         kfree(uctx);
 262         qla2x00_rel_sp(sp);
 263 }
 264
 265 static void qla_nvme_lsrsp_complete(struct work_struct *work)
 266 {
 267         struct qla_nvme_unsol_ctx *uctx =
 268                 container_of(work, struct qla_nvme_unsol_ctx, lsrsp_work);
 269
 270         kref_put(&uctx->sp->cmd_kref, qla_nvme_release_lsrsp_cmd_kref);
 271 }
 272
 273 static void qla_nvme_sp_lsrsp_done(srb_t *sp, int res)
 274 {
 275         struct qla_nvme_unsol_ctx *uctx = sp->priv;
 276
 277         if (WARN_ON_ONCE(kref_read(&sp->cmd_kref) == 0))
 278                 return;
 279
 280         if (res)
 281                 res = -EINVAL;
 282
 283         uctx->comp_status = res;
 284         INIT_WORK(&uctx->lsrsp_work, qla_nvme_lsrsp_complete);
 285         schedule_work(&uctx->lsrsp_work);
 286 }
 287
 288 /* it assumed that QPair lock is held. */
 289 static void qla_nvme_sp_done(srb_t *sp, int res)
 290 {
 291         struct nvme_private *priv = sp->priv;
 292
 293         priv->comp_status = res;
 294         kref_put(&sp->cmd_kref, qla_nvme_release_fcp_cmd_kref);
 295
 296         return;
 297 }
 298
 299 static void qla_nvme_abort_work(struct work_struct *work)
 300 {
 301         struct nvme_private *priv =
 302                 container_of(work, struct nvme_private, abort_work);
 303         srb_t *sp = priv->sp;
 304         fc_port_t *fcport = sp->fcport;
 305         struct qla_hw_data *ha = fcport->vha->hw;
 306         int rval, abts_done_called = 1;
 307         bool io_wait_for_abort_done;
 308         uint32_t handle;
 309
 310         ql_dbg(ql_dbg_io, fcport->vha, 0xffff,
 311                "%s called for sp=%p, hndl=%x on fcport=%p desc=%p deleted=%d\n",
 312                __func__, sp, sp->handle, fcport, sp->u.iocb_cmd.u.nvme.desc, fcport->deleted);
 313
 314         if (!ha->flags.fw_started || fcport->deleted == QLA_SESS_DELETED)
 315                 goto out;
 316
 317         if (ha->flags.host_shutting_down) {
 318                 ql_log(ql_log_info, sp->fcport->vha, 0xffff,
 319                     "%s Calling done on sp: %p, type: 0x%x\n",
 320                     __func__, sp, sp->type);
 321                 sp->done(sp, 0);
 322                 goto out;
 323         }
 324
 325         /*
 326          * sp may not be valid after abort_command if return code is either
 327          * SUCCESS or ERR_FROM_FW codes, so cache the value here.
 328          */
 329         io_wait_for_abort_done = ql2xabts_wait_nvme &&
 330                                         QLA_ABTS_WAIT_ENABLED(sp);
 331         handle = sp->handle;
 332
 333         rval = ha->isp_ops->abort_command(sp);
 334
 335         ql_dbg(ql_dbg_io, fcport->vha, 0x212b,
 336             "%s: %s command for sp=%p, handle=%x on fcport=%p rval=%x\n",
 337             __func__, (rval != QLA_SUCCESS) ? "Failed to abort" : "Aborted",
 338             sp, handle, fcport, rval);
 339
 340         /*
 341          * If async tmf is enabled, the abort callback is called only on
 342          * return codes QLA_SUCCESS and QLA_ERR_FROM_FW.
 343          */
 344         if (ql2xasynctmfenable &&
 345             rval != QLA_SUCCESS && rval != QLA_ERR_FROM_FW)
 346                 abts_done_called = 0;
 347
 348         /*
 349          * Returned before decreasing kref so that I/O requests
 350          * are waited until ABTS complete. This kref is decreased
 351          * at qla24xx_abort_sp_done function.
 352          */
 353         if (abts_done_called && io_wait_for_abort_done)
 354                 return;
 355 out:
 356         /* kref_get was done before work was schedule. */
 357         kref_put(&sp->cmd_kref, sp->put_fn);
 358 }
 359
 360 static int qla_nvme_xmt_ls_rsp(struct nvme_fc_local_port *lport,
 361                                struct nvme_fc_remote_port *rport,
 362                                struct nvmefc_ls_rsp *fd_resp)
 363 {
 364         struct qla_nvme_unsol_ctx *uctx = container_of(fd_resp,
 365                                 struct qla_nvme_unsol_ctx, lsrsp);
 366         struct qla_nvme_rport *qla_rport = rport->private;
 367         fc_port_t *fcport = qla_rport->fcport;
 368         struct scsi_qla_host *vha = uctx->vha;
 369         struct qla_hw_data *ha = vha->hw;
 370         struct qla_nvme_lsrjt_pt_arg a;
 371         struct srb_iocb *nvme;
 372         srb_t *sp;
 373         int rval = QLA_FUNCTION_FAILED;
 374         uint8_t cnt = 0;
 375
 376         if (!fcport || fcport->deleted)
 377                 goto out;
 378
 379         if (!ha->flags.fw_started)
 380                 goto out;
 381
 382         /* Alloc SRB structure */
 383         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
 384         if (!sp)
 385                 goto out;
 386
 387         sp->type = SRB_NVME_LS;
 388         sp->name = "nvme_ls";
 389         sp->done = qla_nvme_sp_lsrsp_done;
 390         sp->put_fn = qla_nvme_release_lsrsp_cmd_kref;
 391         sp->priv = (void *)uctx;
 392         sp->unsol_rsp = 1;
 393         uctx->sp = sp;
 394         spin_lock_init(&uctx->cmd_lock);
 395         nvme = &sp->u.iocb_cmd;
 396         uctx->fd_rsp = fd_resp;
 397         nvme->u.nvme.desc = fd_resp;
 398         nvme->u.nvme.dir = 0;
 399         nvme->u.nvme.dl = 0;
 400         nvme->u.nvme.timeout_sec = 0;
 401         nvme->u.nvme.cmd_dma = fd_resp->rspdma;
 402         nvme->u.nvme.cmd_len = cpu_to_le32(fd_resp->rsplen);
 403         nvme->u.nvme.rsp_len = 0;
 404         nvme->u.nvme.rsp_dma = 0;
 405         nvme->u.nvme.exchange_address = uctx->exchange_address;
 406         nvme->u.nvme.nport_handle = uctx->nport_handle;
 407         nvme->u.nvme.ox_id = uctx->ox_id;
 408         dma_sync_single_for_device(&ha->pdev->dev, nvme->u.nvme.cmd_dma,
 409                                    fd_resp->rsplen, DMA_TO_DEVICE);
 410
 411         ql_dbg(ql_dbg_unsol, vha, 0x2122,
 412                "Unsol lsreq portid=%06x %8phC exchange_address 0x%x ox_id 0x%x hdl 0x%x\n",
 413                fcport->d_id.b24, fcport->port_name, uctx->exchange_address,
 414                uctx->ox_id, uctx->nport_handle);
 415 retry:
 416         rval = qla2x00_start_sp(sp);
 417         switch (rval) {
 418         case QLA_SUCCESS:
 419                 break;
 420         case EAGAIN:
 421                 msleep(PURLS_MSLEEP_INTERVAL);
 422                 cnt++;
 423                 if (cnt < PURLS_RETRY_COUNT)
 424                         goto retry;
 425
 426                 fallthrough;
 427         default:
 428                 ql_dbg(ql_log_warn, vha, 0x2123,
 429                        "Failed to xmit Unsol ls response = %d\n", rval);
 430                 rval = -EIO;
 431                 qla2x00_rel_sp(sp);
 432                 goto out;
 433         }
 434
 435         return 0;
 436 out:
 437         memset((void *)&a, 0, sizeof(a));
 438         a.vp_idx = vha->vp_idx;
 439         a.nport_handle = uctx->nport_handle;
 440         a.xchg_address = uctx->exchange_address;
 441         qla_nvme_ls_reject_iocb(vha, ha->base_qpair, &a, true);
 442         kfree(uctx);
 443         return rval;
 444 }
 445
 446 static void qla_nvme_ls_abort(struct nvme_fc_local_port *lport,
 447     struct nvme_fc_remote_port *rport, struct nvmefc_ls_req *fd)
 448 {
 449         struct nvme_private *priv = fd->private;
 450         unsigned long flags;
 451
 452         spin_lock_irqsave(&priv->cmd_lock, flags);
 453         if (!priv->sp) {
 454                 spin_unlock_irqrestore(&priv->cmd_lock, flags);
 455                 return;
 456         }
 457
 458         if (!kref_get_unless_zero(&priv->sp->cmd_kref)) {
 459                 spin_unlock_irqrestore(&priv->cmd_lock, flags);
 460                 return;
 461         }
 462         spin_unlock_irqrestore(&priv->cmd_lock, flags);
 463
 464         INIT_WORK(&priv->abort_work, qla_nvme_abort_work);
 465         schedule_work(&priv->abort_work);
 466 }
 467
 468 static int qla_nvme_ls_req(struct nvme_fc_local_port *lport,
 469     struct nvme_fc_remote_port *rport, struct nvmefc_ls_req *fd)
 470 {
 471         struct qla_nvme_rport *qla_rport = rport->private;
 472         fc_port_t *fcport = qla_rport->fcport;
 473         struct srb_iocb   *nvme;
 474         struct nvme_private *priv = fd->private;
 475         struct scsi_qla_host *vha;
 476         int     rval = QLA_FUNCTION_FAILED;
 477         struct qla_hw_data *ha;
 478         srb_t           *sp;
 479
 480         if (!fcport || fcport->deleted)
 481                 return rval;
 482
 483         vha = fcport->vha;
 484         ha = vha->hw;
 485
 486         if (!ha->flags.fw_started)
 487                 return rval;
 488
 489         /* Alloc SRB structure */
 490         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
 491         if (!sp)
 492                 return rval;
 493
 494         sp->type = SRB_NVME_LS;
 495         sp->name = "nvme_ls";
 496         sp->done = qla_nvme_sp_ls_done;
 497         sp->put_fn = qla_nvme_release_ls_cmd_kref;
 498         sp->priv = priv;
 499         priv->sp = sp;
 500         kref_init(&sp->cmd_kref);
 501         spin_lock_init(&priv->cmd_lock);
 502         nvme = &sp->u.iocb_cmd;
 503         priv->fd = fd;
 504         nvme->u.nvme.desc = fd;
 505         nvme->u.nvme.dir = 0;
 506         nvme->u.nvme.dl = 0;
 507         nvme->u.nvme.cmd_len = cpu_to_le32(fd->rqstlen);
 508         nvme->u.nvme.rsp_len = cpu_to_le32(fd->rsplen);
 509         nvme->u.nvme.rsp_dma = fd->rspdma;
 510         nvme->u.nvme.timeout_sec = fd->timeout;
 511         nvme->u.nvme.cmd_dma = fd->rqstdma;
 512         dma_sync_single_for_device(&ha->pdev->dev, nvme->u.nvme.cmd_dma,
 513             fd->rqstlen, DMA_TO_DEVICE);
 514
 515         rval = qla2x00_start_sp(sp);
 516         if (rval != QLA_SUCCESS) {
 517                 ql_log(ql_log_warn, vha, 0x700e,
 518                     "qla2x00_start_sp failed = %d\n", rval);
 519                 sp->priv = NULL;
 520                 priv->sp = NULL;
 521                 qla2x00_rel_sp(sp);
 522                 return rval;
 523         }
 524
 525         return rval;
 526 }
 527
 528 static void qla_nvme_fcp_abort(struct nvme_fc_local_port *lport,
 529     struct nvme_fc_remote_port *rport, void *hw_queue_handle,
 530     struct nvmefc_fcp_req *fd)
 531 {
 532         struct nvme_private *priv = fd->private;
 533         unsigned long flags;
 534
 535         spin_lock_irqsave(&priv->cmd_lock, flags);
 536         if (!priv->sp) {
 537                 spin_unlock_irqrestore(&priv->cmd_lock, flags);
 538                 return;
 539         }
 540         if (!kref_get_unless_zero(&priv->sp->cmd_kref)) {
 541                 spin_unlock_irqrestore(&priv->cmd_lock, flags);
 542                 return;
 543         }
 544         spin_unlock_irqrestore(&priv->cmd_lock, flags);
 545
 546         INIT_WORK(&priv->abort_work, qla_nvme_abort_work);
 547         schedule_work(&priv->abort_work);
 548 }
 549
 550 static inline int qla2x00_start_nvme_mq(srb_t *sp)
 551 {
 552         unsigned long   flags;
 553         uint32_t        *clr_ptr;
 554         uint32_t        handle;
 555         struct cmd_nvme *cmd_pkt;
 556         uint16_t        cnt, i;
 557         uint16_t        req_cnt;
 558         uint16_t        tot_dsds;
 559         uint16_t        avail_dsds;
 560         struct dsd64    *cur_dsd;
 561         struct req_que *req = NULL;
 562         struct rsp_que *rsp = NULL;
 563         struct scsi_qla_host *vha = sp->fcport->vha;
 564         struct qla_hw_data *ha = vha->hw;
 565         struct qla_qpair *qpair = sp->qpair;
 566         struct srb_iocb *nvme = &sp->u.iocb_cmd;
 567         struct scatterlist *sgl, *sg;
 568         struct nvmefc_fcp_req *fd = nvme->u.nvme.desc;
 569         struct nvme_fc_cmd_iu *cmd = fd->cmdaddr;
 570         uint32_t        rval = QLA_SUCCESS;
 571
 572         /* Setup qpair pointers */
 573         req = qpair->req;
 574         rsp = qpair->rsp;
 575         tot_dsds = fd->sg_cnt;
 576
 577         /* Acquire qpair specific lock */
 578         spin_lock_irqsave(&qpair->qp_lock, flags);
 579
 580         handle = qla2xxx_get_next_handle(req);
 581         if (handle == 0) {
 582                 rval = -EBUSY;
 583                 goto queuing_error;
 584         }
 585         req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
 586
 587         sp->iores.res_type = RESOURCE_IOCB | RESOURCE_EXCH;
 588         sp->iores.exch_cnt = 1;
 589         sp->iores.iocb_cnt = req_cnt;
 590         if (qla_get_fw_resources(sp->qpair, &sp->iores)) {
 591                 rval = -EBUSY;
 592                 goto queuing_error;
 593         }
 594
 595         if (req->cnt < (req_cnt + 2)) {
 596                 if (IS_SHADOW_REG_CAPABLE(ha)) {
 597                         cnt = *req->out_ptr;
 598                 } else {
 599                         cnt = rd_reg_dword_relaxed(req->req_q_out);
 600                         if (qla2x00_check_reg16_for_disconnect(vha, cnt)) {
 601                                 rval = -EBUSY;
 602                                 goto queuing_error;
 603                         }
 604                 }
 605
 606                 if (req->ring_index < cnt)
 607                         req->cnt = cnt - req->ring_index;
 608                 else
 609                         req->cnt = req->length - (req->ring_index - cnt);
 610
 611                 if (req->cnt < (req_cnt + 2)){
 612                         rval = -EBUSY;
 613                         goto queuing_error;
 614                 }
 615         }
 616
 617         if (unlikely(!fd->sqid)) {
 618                 if (cmd->sqe.common.opcode == nvme_admin_async_event) {
 619                         nvme->u.nvme.aen_op = 1;
 620                         atomic_inc(&ha->nvme_active_aen_cnt);
 621                 }
 622         }
 623
 624         /* Build command packet. */
 625         req->current_outstanding_cmd = handle;
 626         req->outstanding_cmds[handle] = sp;
 627         sp->handle = handle;
 628         req->cnt -= req_cnt;
 629
 630         cmd_pkt = (struct cmd_nvme *)req->ring_ptr;
 631         cmd_pkt->handle = make_handle(req->id, handle);
 632
 633         /* Zero out remaining portion of packet. */
 634         clr_ptr = (uint32_t *)cmd_pkt + 2;
 635         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
 636
 637         cmd_pkt->entry_status = 0;
 638
 639         /* Update entry type to indicate Command NVME IOCB */
 640         cmd_pkt->entry_type = COMMAND_NVME;
 641
 642         /* No data transfer how do we check buffer len == 0?? */
 643         if (fd->io_dir == NVMEFC_FCP_READ) {
 644                 cmd_pkt->control_flags = cpu_to_le16(CF_READ_DATA);
 645                 qpair->counters.input_bytes += fd->payload_length;
 646                 qpair->counters.input_requests++;
 647         } else if (fd->io_dir == NVMEFC_FCP_WRITE) {
 648                 cmd_pkt->control_flags = cpu_to_le16(CF_WRITE_DATA);
 649                 if ((vha->flags.nvme_first_burst) &&
 650                     (sp->fcport->nvme_prli_service_param &
 651                         NVME_PRLI_SP_FIRST_BURST)) {
 652                         if ((fd->payload_length <=
 653                             sp->fcport->nvme_first_burst_size) ||
 654                                 (sp->fcport->nvme_first_burst_size == 0))
 655                                 cmd_pkt->control_flags |=
 656                                         cpu_to_le16(CF_NVME_FIRST_BURST_ENABLE);
 657                 }
 658                 qpair->counters.output_bytes += fd->payload_length;
 659                 qpair->counters.output_requests++;
 660         } else if (fd->io_dir == 0) {
 661                 cmd_pkt->control_flags = 0;
 662         }
 663
 664         if (sp->fcport->edif.enable && fd->io_dir != 0)
 665                 cmd_pkt->control_flags |= cpu_to_le16(CF_EN_EDIF);
 666
 667         /* Set BIT_13 of control flags for Async event */
 668         if (vha->flags.nvme2_enabled &&
 669             cmd->sqe.common.opcode == nvme_admin_async_event) {
 670                 cmd_pkt->control_flags |= cpu_to_le16(CF_ADMIN_ASYNC_EVENT);
 671         }
 672
 673         /* Set NPORT-ID */
 674         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
 675         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
 676         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
 677         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
 678         cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
 679
 680         /* NVME RSP IU */
 681         cmd_pkt->nvme_rsp_dsd_len = cpu_to_le16(fd->rsplen);
 682         put_unaligned_le64(fd->rspdma, &cmd_pkt->nvme_rsp_dseg_address);
 683
 684         /* NVME CNMD IU */
 685         cmd_pkt->nvme_cmnd_dseg_len = cpu_to_le16(fd->cmdlen);
 686         cmd_pkt->nvme_cmnd_dseg_address = cpu_to_le64(fd->cmddma);
 687
 688         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
 689         cmd_pkt->byte_count = cpu_to_le32(fd->payload_length);
 690
 691         /* One DSD is available in the Command Type NVME IOCB */
 692         avail_dsds = 1;
 693         cur_dsd = &cmd_pkt->nvme_dsd;
 694         sgl = fd->first_sgl;
 695
 696         /* Load data segments */
 697         for_each_sg(sgl, sg, tot_dsds, i) {
 698                 cont_a64_entry_t *cont_pkt;
 699
 700                 /* Allocate additional continuation packets? */
 701                 if (avail_dsds == 0) {
 702                         /*
 703                          * Five DSDs are available in the Continuation
 704                          * Type 1 IOCB.
 705                          */
 706
 707                         /* Adjust ring index */
 708                         req->ring_index++;
 709                         if (req->ring_index == req->length) {
 710                                 req->ring_index = 0;
 711                                 req->ring_ptr = req->ring;
 712                         } else {
 713                                 req->ring_ptr++;
 714                         }
 715                         cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
 716                         put_unaligned_le32(CONTINUE_A64_TYPE,
 717                                            &cont_pkt->entry_type);
 718
 719                         cur_dsd = cont_pkt->dsd;
 720                         avail_dsds = ARRAY_SIZE(cont_pkt->dsd);
 721                 }
 722
 723                 append_dsd64(&cur_dsd, sg);
 724                 avail_dsds--;
 725         }
 726
 727         /* Set total entry count. */
 728         cmd_pkt->entry_count = (uint8_t)req_cnt;
 729         wmb();
 730
 731         /* Adjust ring index. */
 732         req->ring_index++;
 733         if (req->ring_index == req->length) {
 734                 req->ring_index = 0;
 735                 req->ring_ptr = req->ring;
 736         } else {
 737                 req->ring_ptr++;
 738         }
 739
 740         /* ignore nvme async cmd due to long timeout */
 741         if (!nvme->u.nvme.aen_op)
 742                 sp->qpair->cmd_cnt++;
 743
 744         /* Set chip new ring index. */
 745         wrt_reg_dword(req->req_q_in, req->ring_index);
 746
 747         if (vha->flags.process_response_queue &&
 748             rsp->ring_ptr->signature != RESPONSE_PROCESSED)
 749                 qla24xx_process_response_queue(vha, rsp);
 750
 751 queuing_error:
 752         if (rval)
 753                 qla_put_fw_resources(sp->qpair, &sp->iores);
 754         spin_unlock_irqrestore(&qpair->qp_lock, flags);
 755
 756         return rval;
 757 }
 758
 759 /* Post a command */
 760 static int qla_nvme_post_cmd(struct nvme_fc_local_port *lport,
 761     struct nvme_fc_remote_port *rport, void *hw_queue_handle,
 762     struct nvmefc_fcp_req *fd)
 763 {
 764         fc_port_t *fcport;
 765         struct srb_iocb *nvme;
 766         struct scsi_qla_host *vha;
 767         struct qla_hw_data *ha;
 768         int rval;
 769         srb_t *sp;
 770         struct qla_qpair *qpair = hw_queue_handle;
 771         struct nvme_private *priv = fd->private;
 772         struct qla_nvme_rport *qla_rport = rport->private;
 773
 774         if (!priv) {
 775                 /* nvme association has been torn down */
 776                 return -ENODEV;
 777         }
 778
 779         fcport = qla_rport->fcport;
 780
 781         if (unlikely(!qpair || !fcport || fcport->deleted))
 782                 return -EBUSY;
 783
 784         if (!(fcport->nvme_flag & NVME_FLAG_REGISTERED))
 785                 return -ENODEV;
 786
 787         vha = fcport->vha;
 788         ha = vha->hw;
 789
 790         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
 791                 return -EBUSY;
 792
 793         /*
 794          * If we know the dev is going away while the transport is still sending
 795          * IO's return busy back to stall the IO Q.  This happens when the
 796          * link goes away and fw hasn't notified us yet, but IO's are being
 797          * returned. If the dev comes back quickly we won't exhaust the IO
 798          * retry count at the core.
 799          */
 800         if (fcport->nvme_flag & NVME_FLAG_RESETTING)
 801                 return -EBUSY;
 802
 803         qpair = qla_mapq_nvme_select_qpair(ha, qpair);
 804
 805         /* Alloc SRB structure */
 806         sp = qla2xxx_get_qpair_sp(vha, qpair, fcport, GFP_ATOMIC);
 807         if (!sp)
 808                 return -EBUSY;
 809
 810         kref_init(&sp->cmd_kref);
 811         spin_lock_init(&priv->cmd_lock);
 812         sp->priv = priv;
 813         priv->sp = sp;
 814         sp->type = SRB_NVME_CMD;
 815         sp->name = "nvme_cmd";
 816         sp->done = qla_nvme_sp_done;
 817         sp->put_fn = qla_nvme_release_fcp_cmd_kref;
 818         sp->qpair = qpair;
 819         sp->vha = vha;
 820         sp->cmd_sp = sp;
 821         nvme = &sp->u.iocb_cmd;
 822         nvme->u.nvme.desc = fd;
 823
 824         rval = qla2x00_start_nvme_mq(sp);
 825         if (rval != QLA_SUCCESS) {
 826                 ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x212d,
 827                     "qla2x00_start_nvme_mq failed = %d\n", rval);
 828                 sp->priv = NULL;
 829                 priv->sp = NULL;
 830                 qla2xxx_rel_qpair_sp(sp->qpair, sp);
 831         }
 832
 833         return rval;
 834 }
 835
 836 static void qla_nvme_map_queues(struct nvme_fc_local_port *lport,
 837                 struct blk_mq_queue_map *map)
 838 {
 839         struct scsi_qla_host *vha = lport->private;
 840
 841         blk_mq_pci_map_queues(map, vha->hw->pdev, vha->irq_offset);
 842 }
 843
 844 static void qla_nvme_localport_delete(struct nvme_fc_local_port *lport)
 845 {
 846         struct scsi_qla_host *vha = lport->private;
 847
 848         ql_log(ql_log_info, vha, 0x210f,
 849             "localport delete of %p completed.\n", vha->nvme_local_port);
 850         vha->nvme_local_port = NULL;
 851         complete(&vha->nvme_del_done);
 852 }
 853
 854 static void qla_nvme_remoteport_delete(struct nvme_fc_remote_port *rport)
 855 {
 856         fc_port_t *fcport;
 857         struct qla_nvme_rport *qla_rport = rport->private;
 858
 859         fcport = qla_rport->fcport;
 860         fcport->nvme_remote_port = NULL;
 861         fcport->nvme_flag &= ~NVME_FLAG_REGISTERED;
 862         fcport->nvme_flag &= ~NVME_FLAG_DELETING;
 863         ql_log(ql_log_info, fcport->vha, 0x2110,
 864             "remoteport_delete of %p %8phN completed.\n",
 865             fcport, fcport->port_name);
 866         complete(&fcport->nvme_del_done);
 867 }
 868
 869 static struct nvme_fc_port_template qla_nvme_fc_transport = {
 870         .localport_delete = qla_nvme_localport_delete,
 871         .remoteport_delete = qla_nvme_remoteport_delete,
 872         .create_queue   = qla_nvme_alloc_queue,
 873         .delete_queue   = NULL,
 874         .ls_req         = qla_nvme_ls_req,
 875         .ls_abort       = qla_nvme_ls_abort,
 876         .fcp_io         = qla_nvme_post_cmd,
 877         .fcp_abort      = qla_nvme_fcp_abort,
 878         .xmt_ls_rsp     = qla_nvme_xmt_ls_rsp,
 879         .map_queues     = qla_nvme_map_queues,
 880         .max_hw_queues  = DEF_NVME_HW_QUEUES,
 881         .max_sgl_segments = 1024,
 882         .max_dif_sgl_segments = 64,
 883         .dma_boundary = 0xFFFFFFFF,
 884         .local_priv_sz  = 8,
 885         .remote_priv_sz = sizeof(struct qla_nvme_rport),
 886         .lsrqst_priv_sz = sizeof(struct nvme_private),
 887         .fcprqst_priv_sz = sizeof(struct nvme_private),
 888 };
 889
 890 void qla_nvme_unregister_remote_port(struct fc_port *fcport)
 891 {
 892         int ret;
 893
 894         if (!IS_ENABLED(CONFIG_NVME_FC))
 895                 return;
 896
 897         ql_log(ql_log_warn, fcport->vha, 0x2112,
 898             "%s: unregister remoteport on %p %8phN\n",
 899             __func__, fcport, fcport->port_name);
 900
 901         if (test_bit(PFLG_DRIVER_REMOVING, &fcport->vha->pci_flags))
 902                 nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port, 0);
 903
 904         init_completion(&fcport->nvme_del_done);
 905         ret = nvme_fc_unregister_remoteport(fcport->nvme_remote_port);
 906         if (ret)
 907                 ql_log(ql_log_info, fcport->vha, 0x2114,
 908                         "%s: Failed to unregister nvme_remote_port (%d)\n",
 909                             __func__, ret);
 910         wait_for_completion(&fcport->nvme_del_done);
 911 }
 912
 913 void qla_nvme_delete(struct scsi_qla_host *vha)
 914 {
 915         int nv_ret;
 916
 917         if (!IS_ENABLED(CONFIG_NVME_FC))
 918                 return;
 919
 920         if (vha->nvme_local_port) {
 921                 init_completion(&vha->nvme_del_done);
 922                 ql_log(ql_log_info, vha, 0x2116,
 923                         "unregister localport=%p\n",
 924                         vha->nvme_local_port);
 925                 nv_ret = nvme_fc_unregister_localport(vha->nvme_local_port);
 926                 if (nv_ret)
 927                         ql_log(ql_log_info, vha, 0x2115,
 928                             "Unregister of localport failed\n");
 929                 else
 930                         wait_for_completion(&vha->nvme_del_done);
 931         }
 932 }
 933
 934 int qla_nvme_register_hba(struct scsi_qla_host *vha)
 935 {
 936         struct nvme_fc_port_template *tmpl;
 937         struct qla_hw_data *ha;
 938         struct nvme_fc_port_info pinfo;
 939         int ret = -EINVAL;
 940
 941         if (!IS_ENABLED(CONFIG_NVME_FC))
 942                 return ret;
 943
 944         ha = vha->hw;
 945         tmpl = &qla_nvme_fc_transport;
 946
 947         if (ql2xnvme_queues < MIN_NVME_HW_QUEUES) {
 948                 ql_log(ql_log_warn, vha, 0xfffd,
 949                     "ql2xnvme_queues=%d is lower than minimum queues: %d. Resetting ql2xnvme_queues to:%d\n",
 950                     ql2xnvme_queues, MIN_NVME_HW_QUEUES, DEF_NVME_HW_QUEUES);
 951                 ql2xnvme_queues = DEF_NVME_HW_QUEUES;
 952         } else if (ql2xnvme_queues > (ha->max_qpairs - 1)) {
 953                 ql_log(ql_log_warn, vha, 0xfffd,
 954                        "ql2xnvme_queues=%d is greater than available IRQs: %d. Resetting ql2xnvme_queues to: %d\n",
 955                        ql2xnvme_queues, (ha->max_qpairs - 1),
 956                        (ha->max_qpairs - 1));
 957                 ql2xnvme_queues = ((ha->max_qpairs - 1));
 958         }
 959
 960         qla_nvme_fc_transport.max_hw_queues =
 961             min((uint8_t)(ql2xnvme_queues),
 962                 (uint8_t)((ha->max_qpairs - 1) ? (ha->max_qpairs - 1) : 1));
 963
 964         ql_log(ql_log_info, vha, 0xfffb,
 965                "Number of NVME queues used for this port: %d\n",
 966             qla_nvme_fc_transport.max_hw_queues);
 967
 968         pinfo.node_name = wwn_to_u64(vha->node_name);
 969         pinfo.port_name = wwn_to_u64(vha->port_name);
 970         pinfo.port_role = FC_PORT_ROLE_NVME_INITIATOR;
 971         pinfo.port_id = vha->d_id.b24;
 972
 973         mutex_lock(&ha->vport_lock);
 974         /*
 975          * Check again for nvme_local_port to see if any other thread raced
 976          * with this one and finished registration.
 977          */
 978         if (!vha->nvme_local_port) {
 979                 ql_log(ql_log_info, vha, 0xffff,
 980                     "register_localport: host-traddr=nn-0x%llx:pn-0x%llx on portID:%x\n",
 981                     pinfo.node_name, pinfo.port_name, pinfo.port_id);
 982                 qla_nvme_fc_transport.dma_boundary = vha->host->dma_boundary;
 983
 984                 ret = nvme_fc_register_localport(&pinfo, tmpl,
 985                                                  get_device(&ha->pdev->dev),
 986                                                  &vha->nvme_local_port);
 987                 mutex_unlock(&ha->vport_lock);
 988         } else {
 989                 mutex_unlock(&ha->vport_lock);
 990                 return 0;
 991         }
 992         if (ret) {
 993                 ql_log(ql_log_warn, vha, 0xffff,
 994                     "register_localport failed: ret=%x\n", ret);
 995         } else {
 996                 vha->nvme_local_port->private = vha;
 997         }
 998
 999         return ret;
1000 }
1001
1002 void qla_nvme_abort_set_option(struct abort_entry_24xx *abt, srb_t *orig_sp)
1003 {
1004         struct qla_hw_data *ha;
1005
1006         if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1007                 return;
1008
1009         ha = orig_sp->fcport->vha->hw;
1010
1011         WARN_ON_ONCE(abt->options & cpu_to_le16(BIT_0));
1012         /* Use Driver Specified Retry Count */
1013         abt->options |= cpu_to_le16(AOF_ABTS_RTY_CNT);
1014         abt->drv.abts_rty_cnt = cpu_to_le16(2);
1015         /* Use specified response timeout */
1016         abt->options |= cpu_to_le16(AOF_RSP_TIMEOUT);
1017         /* set it to 2 * r_a_tov in secs */
1018         abt->drv.rsp_timeout = cpu_to_le16(2 * (ha->r_a_tov / 10));
1019 }
1020
1021 void qla_nvme_abort_process_comp_status(struct abort_entry_24xx *abt, srb_t *orig_sp)
1022 {
1023         u16     comp_status;
1024         struct scsi_qla_host *vha;
1025
1026         if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1027                 return;
1028
1029         vha = orig_sp->fcport->vha;
1030
1031         comp_status = le16_to_cpu(abt->comp_status);
1032         switch (comp_status) {
1033         case CS_RESET:          /* reset event aborted */
1034         case CS_ABORTED:        /* IOCB was cleaned */
1035         /* N_Port handle is not currently logged in */
1036         case CS_TIMEOUT:
1037         /* N_Port handle was logged out while waiting for ABTS to complete */
1038         case CS_PORT_UNAVAILABLE:
1039         /* Firmware found that the port name changed */
1040         case CS_PORT_LOGGED_OUT:
1041         /* BA_RJT was received for the ABTS */
1042         case CS_PORT_CONFIG_CHG:
1043                 ql_dbg(ql_dbg_async, vha, 0xf09d,
1044                        "Abort I/O IOCB completed with error, comp_status=%x\n",
1045                 comp_status);
1046                 break;
1047
1048         /* BA_RJT was received for the ABTS */
1049         case CS_REJECT_RECEIVED:
1050                 ql_dbg(ql_dbg_async, vha, 0xf09e,
1051                        "BA_RJT was received for the ABTS rjt_vendorUnique = %u",
1052                         abt->fw.ba_rjt_vendorUnique);
1053                 ql_dbg(ql_dbg_async + ql_dbg_mbx, vha, 0xf09e,
1054                        "ba_rjt_reasonCodeExpl = %u, ba_rjt_reasonCode = %u\n",
1055                        abt->fw.ba_rjt_reasonCodeExpl, abt->fw.ba_rjt_reasonCode);
1056                 break;
1057
1058         case CS_COMPLETE:
1059                 ql_dbg(ql_dbg_async + ql_dbg_verbose, vha, 0xf09f,
1060                        "IOCB request is completed successfully comp_status=%x\n",
1061                 comp_status);
1062                 break;
1063
1064         case CS_IOCB_ERROR:
1065                 ql_dbg(ql_dbg_async, vha, 0xf0a0,
1066                        "IOCB request is failed, comp_status=%x\n", comp_status);
1067                 break;
1068
1069         default:
1070                 ql_dbg(ql_dbg_async, vha, 0xf0a1,
1071                        "Invalid Abort IO IOCB Completion Status %x\n",
1072                 comp_status);
1073                 break;
1074         }
1075 }
1076
1077 inline void qla_wait_nvme_release_cmd_kref(srb_t *orig_sp)
1078 {
1079         if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
1080                 return;
1081         kref_put(&orig_sp->cmd_kref, orig_sp->put_fn);
1082 }
1083
1084 static void qla_nvme_fc_format_rjt(void *buf, u8 ls_cmd, u8 reason,
1085                                    u8 explanation, u8 vendor)
1086 {
1087         struct fcnvme_ls_rjt *rjt = buf;
1088
1089         rjt->w0.ls_cmd = FCNVME_LSDESC_RQST;
1090         rjt->desc_list_len = fcnvme_lsdesc_len(sizeof(struct fcnvme_ls_rjt));
1091         rjt->rqst.desc_tag = cpu_to_be32(FCNVME_LSDESC_RQST);
1092         rjt->rqst.desc_len =
1093                 fcnvme_lsdesc_len(sizeof(struct fcnvme_lsdesc_rqst));
1094         rjt->rqst.w0.ls_cmd = ls_cmd;
1095         rjt->rjt.desc_tag = cpu_to_be32(FCNVME_LSDESC_RJT);
1096         rjt->rjt.desc_len = fcnvme_lsdesc_len(sizeof(struct fcnvme_lsdesc_rjt));
1097         rjt->rjt.reason_code = reason;
1098         rjt->rjt.reason_explanation = explanation;
1099         rjt->rjt.vendor = vendor;
1100 }
1101
1102 static void qla_nvme_lsrjt_pt_iocb(struct scsi_qla_host *vha,
1103                                    struct pt_ls4_request *lsrjt_iocb,
1104                                    struct qla_nvme_lsrjt_pt_arg *a)
1105 {
1106         lsrjt_iocb->entry_type = PT_LS4_REQUEST;
1107         lsrjt_iocb->entry_count = 1;
1108         lsrjt_iocb->sys_define = 0;
1109         lsrjt_iocb->entry_status = 0;
1110         lsrjt_iocb->handle = QLA_SKIP_HANDLE;
1111         lsrjt_iocb->nport_handle = a->nport_handle;
1112         lsrjt_iocb->exchange_address = a->xchg_address;
1113         lsrjt_iocb->vp_index = a->vp_idx;
1114
1115         lsrjt_iocb->control_flags = cpu_to_le16(a->control_flags);
1116
1117         put_unaligned_le64(a->tx_addr, &lsrjt_iocb->dsd[0].address);
1118         lsrjt_iocb->dsd[0].length = cpu_to_le32(a->tx_byte_count);
1119         lsrjt_iocb->tx_dseg_count = cpu_to_le16(1);
1120         lsrjt_iocb->tx_byte_count = cpu_to_le32(a->tx_byte_count);
1121
1122         put_unaligned_le64(a->rx_addr, &lsrjt_iocb->dsd[1].address);
1123         lsrjt_iocb->dsd[1].length = 0;
1124         lsrjt_iocb->rx_dseg_count = 0;
1125         lsrjt_iocb->rx_byte_count = 0;
1126 }
1127
1128 static int
1129 qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha, struct qla_qpair *qp,
1130                         struct qla_nvme_lsrjt_pt_arg *a, bool is_xchg_terminate)
1131 {
1132         struct pt_ls4_request *lsrjt_iocb;
1133
1134         lsrjt_iocb = __qla2x00_alloc_iocbs(qp, NULL);
1135         if (!lsrjt_iocb) {
1136                 ql_log(ql_log_warn, vha, 0x210e,
1137                        "qla2x00_alloc_iocbs failed.\n");
1138                 return QLA_FUNCTION_FAILED;
1139         }
1140
1141         if (!is_xchg_terminate) {
1142                 qla_nvme_fc_format_rjt((void *)vha->hw->lsrjt.c, a->opcode,
1143                                        a->reason, a->explanation, 0);
1144
1145                 a->tx_byte_count = sizeof(struct fcnvme_ls_rjt);
1146                 a->tx_addr = vha->hw->lsrjt.cdma;
1147                 a->control_flags = CF_LS4_RESPONDER << CF_LS4_SHIFT;
1148
1149                 ql_dbg(ql_dbg_unsol, vha, 0x211f,
1150                        "Sending nvme fc ls reject ox_id %04x op %04x\n",
1151                        a->ox_id, a->opcode);
1152                 ql_dump_buffer(ql_dbg_unsol + ql_dbg_verbose, vha, 0x210f,
1153                                vha->hw->lsrjt.c, sizeof(*vha->hw->lsrjt.c));
1154         } else {
1155                 a->tx_byte_count = 0;
1156                 a->control_flags = CF_LS4_RESPONDER_TERM << CF_LS4_SHIFT;
1157                 ql_dbg(ql_dbg_unsol, vha, 0x2110,
1158                        "Terminate nvme ls xchg 0x%x\n", a->xchg_address);
1159         }
1160
1161         qla_nvme_lsrjt_pt_iocb(vha, lsrjt_iocb, a);
1162         /* flush iocb to mem before notifying hw doorbell */
1163         wmb();
1164         qla2x00_start_iocbs(vha, qp->req);
1165         return 0;
1166 }
1167
1168 /*
1169  * qla2xxx_process_purls_pkt() - Pass-up Unsolicited
1170  * Received FC-NVMe Link Service pkt to nvme_fc_rcv_ls_req().
1171  * LLDD need to provide memory for response buffer, which
1172  * will be used to reference the exchange corresponding
1173  * to the LS when issuing an ls response. LLDD will have to free
1174  * response buffer in lport->ops->xmt_ls_rsp().
1175  *
1176  * @vha: SCSI qla host
1177  * @item: ptr to purex_item
1178  */
1179 static void
1180 qla2xxx_process_purls_pkt(struct scsi_qla_host *vha, struct purex_item *item)
1181 {
1182         struct qla_nvme_unsol_ctx *uctx = item->purls_context;
1183         struct qla_nvme_lsrjt_pt_arg a;
1184         int ret = 1;
1185
1186 #if (IS_ENABLED(CONFIG_NVME_FC))
1187         ret = nvme_fc_rcv_ls_req(uctx->fcport->nvme_remote_port, &uctx->lsrsp,
1188                                  &item->iocb, item->size);
1189 #endif
1190         if (ret) {
1191                 ql_dbg(ql_dbg_unsol, vha, 0x2125, "NVMe transport ls_req failed\n");
1192                 memset((void *)&a, 0, sizeof(a));
1193                 a.vp_idx = vha->vp_idx;
1194                 a.nport_handle = uctx->nport_handle;
1195                 a.xchg_address = uctx->exchange_address;
1196                 qla_nvme_ls_reject_iocb(vha, vha->hw->base_qpair, &a, true);
1197                 list_del(&uctx->elem);
1198                 kfree(uctx);
1199         }
1200 }
1201
1202 static scsi_qla_host_t *
1203 qla2xxx_get_vha_from_vp_idx(struct qla_hw_data *ha, uint16_t vp_index)
1204 {
1205         scsi_qla_host_t *base_vha, *vha, *tvp;
1206         unsigned long flags;
1207
1208         base_vha = pci_get_drvdata(ha->pdev);
1209
1210         if (!vp_index && !ha->num_vhosts)
1211                 return base_vha;
1212
1213         spin_lock_irqsave(&ha->vport_slock, flags);
1214         list_for_each_entry_safe(vha, tvp, &ha->vp_list, list) {
1215                 if (vha->vp_idx == vp_index) {
1216                         spin_unlock_irqrestore(&ha->vport_slock, flags);
1217                         return vha;
1218                 }
1219         }
1220         spin_unlock_irqrestore(&ha->vport_slock, flags);
1221
1222         return NULL;
1223 }
1224
1225 void qla2xxx_process_purls_iocb(void **pkt, struct rsp_que **rsp)
1226 {
1227         struct nvme_fc_remote_port *rport;
1228         struct qla_nvme_rport *qla_rport;
1229         struct qla_nvme_lsrjt_pt_arg a;
1230         struct pt_ls4_rx_unsol *p = *pkt;
1231         struct qla_nvme_unsol_ctx *uctx;
1232         struct rsp_que *rsp_q = *rsp;
1233         struct qla_hw_data *ha;
1234         scsi_qla_host_t *vha;
1235         fc_port_t *fcport = NULL;
1236         struct purex_item *item;
1237         port_id_t d_id = {0};
1238         port_id_t id = {0};
1239         u8 *opcode;
1240         bool xmt_reject = false;
1241
1242         ha = rsp_q->hw;
1243
1244         vha = qla2xxx_get_vha_from_vp_idx(ha, p->vp_index);
1245         if (!vha) {
1246                 ql_log(ql_log_warn, NULL, 0x2110, "Invalid vp index %d\n", p->vp_index);
1247                 WARN_ON_ONCE(1);
1248                 return;
1249         }
1250
1251         memset((void *)&a, 0, sizeof(a));
1252         opcode = (u8 *)&p->payload[0];
1253         a.opcode = opcode[3];
1254         a.vp_idx = p->vp_index;
1255         a.nport_handle = p->nport_handle;
1256         a.ox_id = p->ox_id;
1257         a.xchg_address = p->exchange_address;
1258
1259         id.b.domain = p->s_id.domain;
1260         id.b.area   = p->s_id.area;
1261         id.b.al_pa  = p->s_id.al_pa;
1262         d_id.b.domain = p->d_id[2];
1263         d_id.b.area   = p->d_id[1];
1264         d_id.b.al_pa  = p->d_id[0];
1265
1266         fcport = qla2x00_find_fcport_by_nportid(vha, &id, 0);
1267         if (!fcport) {
1268                 ql_dbg(ql_dbg_unsol, vha, 0x211e,
1269                        "Failed to find sid=%06x did=%06x\n",
1270                        id.b24, d_id.b24);
1271                 a.reason = FCNVME_RJT_RC_INV_ASSOC;
1272                 a.explanation = FCNVME_RJT_EXP_NONE;
1273                 xmt_reject = true;
1274                 goto out;
1275         }
1276         rport = fcport->nvme_remote_port;
1277         qla_rport = rport->private;
1278
1279         item = qla27xx_copy_multiple_pkt(vha, pkt, rsp, true, false);
1280         if (!item) {
1281                 a.reason = FCNVME_RJT_RC_LOGIC;
1282                 a.explanation = FCNVME_RJT_EXP_NONE;
1283                 xmt_reject = true;
1284                 goto out;
1285         }
1286
1287         uctx = kzalloc(sizeof(*uctx), GFP_ATOMIC);
1288         if (!uctx) {
1289                 ql_log(ql_log_info, vha, 0x2126, "Failed allocate memory\n");
1290                 a.reason = FCNVME_RJT_RC_LOGIC;
1291                 a.explanation = FCNVME_RJT_EXP_NONE;
1292                 xmt_reject = true;
1293                 kfree(item);
1294                 goto out;
1295         }
1296
1297         uctx->vha = vha;
1298         uctx->fcport = fcport;
1299         uctx->exchange_address = p->exchange_address;
1300         uctx->nport_handle = p->nport_handle;
1301         uctx->ox_id = p->ox_id;
1302         qla_rport->uctx = uctx;
1303         INIT_LIST_HEAD(&uctx->elem);
1304         list_add_tail(&uctx->elem, &fcport->unsol_ctx_head);
1305         item->purls_context = (void *)uctx;
1306
1307         ql_dbg(ql_dbg_unsol, vha, 0x2121,
1308                "PURLS OP[%01x] size %d xchg addr 0x%x portid %06x\n",
1309                item->iocb.iocb[3], item->size, uctx->exchange_address,
1310                fcport->d_id.b24);
1311         /* +48    0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
1312          * ----- -----------------------------------------------
1313          * 0000: 00 00 00 05 28 00 00 00 07 00 00 00 08 00 00 00
1314          * 0010: ab ec 0f cc 00 00 8d 7d 05 00 00 00 10 00 00 00
1315          * 0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
1316          */
1317         ql_dump_buffer(ql_dbg_unsol + ql_dbg_verbose, vha, 0x2120,
1318                        &item->iocb, item->size);
1319
1320         qla24xx_queue_purex_item(vha, item, qla2xxx_process_purls_pkt);
1321 out:
1322         if (xmt_reject) {
1323                 qla_nvme_ls_reject_iocb(vha, (*rsp)->qpair, &a, false);
1324                 __qla_consume_iocb(vha, pkt, rsp);
1325         }
1326 }