drivers/scsi/qla2xxx/qla_iocb.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2014 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8 #include "qla_target.h"
   9
  10 #include <linux/blkdev.h>
  11 #include <linux/delay.h>
  12
  13 #include <scsi/scsi_tcq.h>
  14
  15 /**
  16  * qla2x00_get_cmd_direction() - Determine control_flag data direction.
  17  * @sp: SCSI command
  18  *
  19  * Returns the proper CF_* direction based on CDB.
  20  */
  21 static inline uint16_t
  22 qla2x00_get_cmd_direction(srb_t *sp)
  23 {
  24         uint16_t cflags;
  25         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
  26         struct scsi_qla_host *vha = sp->vha;
  27
  28         cflags = 0;
  29
  30         /* Set transfer direction */
  31         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
  32                 cflags = CF_WRITE;
  33                 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
  34                 vha->qla_stats.output_requests++;
  35         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
  36                 cflags = CF_READ;
  37                 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
  38                 vha->qla_stats.input_requests++;
  39         }
  40         return (cflags);
  41 }
  42
  43 /**
  44  * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and
  45  * Continuation Type 0 IOCBs to allocate.
  46  *
  47  * @dsds: number of data segment descriptors needed
  48  *
  49  * Returns the number of IOCB entries needed to store @dsds.
  50  */
  51 uint16_t
  52 qla2x00_calc_iocbs_32(uint16_t dsds)
  53 {
  54         uint16_t iocbs;
  55
  56         iocbs = 1;
  57         if (dsds > 3) {
  58                 iocbs += (dsds - 3) / 7;
  59                 if ((dsds - 3) % 7)
  60                         iocbs++;
  61         }
  62         return (iocbs);
  63 }
  64
  65 /**
  66  * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and
  67  * Continuation Type 1 IOCBs to allocate.
  68  *
  69  * @dsds: number of data segment descriptors needed
  70  *
  71  * Returns the number of IOCB entries needed to store @dsds.
  72  */
  73 uint16_t
  74 qla2x00_calc_iocbs_64(uint16_t dsds)
  75 {
  76         uint16_t iocbs;
  77
  78         iocbs = 1;
  79         if (dsds > 2) {
  80                 iocbs += (dsds - 2) / 5;
  81                 if ((dsds - 2) % 5)
  82                         iocbs++;
  83         }
  84         return (iocbs);
  85 }
  86
  87 /**
  88  * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB.
  89  * @vha: HA context
  90  *
  91  * Returns a pointer to the Continuation Type 0 IOCB packet.
  92  */
  93 static inline cont_entry_t *
  94 qla2x00_prep_cont_type0_iocb(struct scsi_qla_host *vha)
  95 {
  96         cont_entry_t *cont_pkt;
  97         struct req_que *req = vha->req;
  98         /* Adjust ring index. */
  99         req->ring_index++;
 100         if (req->ring_index == req->length) {
 101                 req->ring_index = 0;
 102                 req->ring_ptr = req->ring;
 103         } else {
 104                 req->ring_ptr++;
 105         }
 106
 107         cont_pkt = (cont_entry_t *)req->ring_ptr;
 108
 109         /* Load packet defaults. */
 110         put_unaligned_le32(CONTINUE_TYPE, &cont_pkt->entry_type);
 111
 112         return (cont_pkt);
 113 }
 114
 115 /**
 116  * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB.
 117  * @vha: HA context
 118  * @req: request queue
 119  *
 120  * Returns a pointer to the continuation type 1 IOCB packet.
 121  */
 122 static inline cont_a64_entry_t *
 123 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *vha, struct req_que *req)
 124 {
 125         cont_a64_entry_t *cont_pkt;
 126
 127         /* Adjust ring index. */
 128         req->ring_index++;
 129         if (req->ring_index == req->length) {
 130                 req->ring_index = 0;
 131                 req->ring_ptr = req->ring;
 132         } else {
 133                 req->ring_ptr++;
 134         }
 135
 136         cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
 137
 138         /* Load packet defaults. */
 139         put_unaligned_le32(IS_QLAFX00(vha->hw) ? CONTINUE_A64_TYPE_FX00 :
 140                            CONTINUE_A64_TYPE, &cont_pkt->entry_type);
 141
 142         return (cont_pkt);
 143 }
 144
 145 inline int
 146 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts)
 147 {
 148         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
 149         uint8_t guard = scsi_host_get_guard(cmd->device->host);
 150
 151         /* We always use DIFF Bundling for best performance */
 152         *fw_prot_opts = 0;
 153
 154         /* Translate SCSI opcode to a protection opcode */
 155         switch (scsi_get_prot_op(cmd)) {
 156         case SCSI_PROT_READ_STRIP:
 157                 *fw_prot_opts |= PO_MODE_DIF_REMOVE;
 158                 break;
 159         case SCSI_PROT_WRITE_INSERT:
 160                 *fw_prot_opts |= PO_MODE_DIF_INSERT;
 161                 break;
 162         case SCSI_PROT_READ_INSERT:
 163                 *fw_prot_opts |= PO_MODE_DIF_INSERT;
 164                 break;
 165         case SCSI_PROT_WRITE_STRIP:
 166                 *fw_prot_opts |= PO_MODE_DIF_REMOVE;
 167                 break;
 168         case SCSI_PROT_READ_PASS:
 169         case SCSI_PROT_WRITE_PASS:
 170                 if (guard & SHOST_DIX_GUARD_IP)
 171                         *fw_prot_opts |= PO_MODE_DIF_TCP_CKSUM;
 172                 else
 173                         *fw_prot_opts |= PO_MODE_DIF_PASS;
 174                 break;
 175         default:        /* Normal Request */
 176                 *fw_prot_opts |= PO_MODE_DIF_PASS;
 177                 break;
 178         }
 179
 180         return scsi_prot_sg_count(cmd);
 181 }
 182
 183 /*
 184  * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit
 185  * capable IOCB types.
 186  *
 187  * @sp: SRB command to process
 188  * @cmd_pkt: Command type 2 IOCB
 189  * @tot_dsds: Total number of segments to transfer
 190  */
 191 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt,
 192     uint16_t tot_dsds)
 193 {
 194         uint16_t        avail_dsds;
 195         struct dsd32    *cur_dsd;
 196         scsi_qla_host_t *vha;
 197         struct scsi_cmnd *cmd;
 198         struct scatterlist *sg;
 199         int i;
 200
 201         cmd = GET_CMD_SP(sp);
 202
 203         /* Update entry type to indicate Command Type 2 IOCB */
 204         put_unaligned_le32(COMMAND_TYPE, &cmd_pkt->entry_type);
 205
 206         /* No data transfer */
 207         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 208                 cmd_pkt->byte_count = cpu_to_le32(0);
 209                 return;
 210         }
 211
 212         vha = sp->vha;
 213         cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
 214
 215         /* Three DSDs are available in the Command Type 2 IOCB */
 216         avail_dsds = ARRAY_SIZE(cmd_pkt->dsd32);
 217         cur_dsd = cmd_pkt->dsd32;
 218
 219         /* Load data segments */
 220         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
 221                 cont_entry_t *cont_pkt;
 222
 223                 /* Allocate additional continuation packets? */
 224                 if (avail_dsds == 0) {
 225                         /*
 226                          * Seven DSDs are available in the Continuation
 227                          * Type 0 IOCB.
 228                          */
 229                         cont_pkt = qla2x00_prep_cont_type0_iocb(vha);
 230                         cur_dsd = cont_pkt->dsd;
 231                         avail_dsds = ARRAY_SIZE(cont_pkt->dsd);
 232                 }
 233
 234                 append_dsd32(&cur_dsd, sg);
 235                 avail_dsds--;
 236         }
 237 }
 238
 239 /**
 240  * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit
 241  * capable IOCB types.
 242  *
 243  * @sp: SRB command to process
 244  * @cmd_pkt: Command type 3 IOCB
 245  * @tot_dsds: Total number of segments to transfer
 246  */
 247 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,
 248     uint16_t tot_dsds)
 249 {
 250         uint16_t        avail_dsds;
 251         struct dsd64    *cur_dsd;
 252         scsi_qla_host_t *vha;
 253         struct scsi_cmnd *cmd;
 254         struct scatterlist *sg;
 255         int i;
 256
 257         cmd = GET_CMD_SP(sp);
 258
 259         /* Update entry type to indicate Command Type 3 IOCB */
 260         put_unaligned_le32(COMMAND_A64_TYPE, &cmd_pkt->entry_type);
 261
 262         /* No data transfer */
 263         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 264                 cmd_pkt->byte_count = cpu_to_le32(0);
 265                 return;
 266         }
 267
 268         vha = sp->vha;
 269         cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
 270
 271         /* Two DSDs are available in the Command Type 3 IOCB */
 272         avail_dsds = ARRAY_SIZE(cmd_pkt->dsd64);
 273         cur_dsd = cmd_pkt->dsd64;
 274
 275         /* Load data segments */
 276         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
 277                 cont_a64_entry_t *cont_pkt;
 278
 279                 /* Allocate additional continuation packets? */
 280                 if (avail_dsds == 0) {
 281                         /*
 282                          * Five DSDs are available in the Continuation
 283                          * Type 1 IOCB.
 284                          */
 285                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
 286                         cur_dsd = cont_pkt->dsd;
 287                         avail_dsds = ARRAY_SIZE(cont_pkt->dsd);
 288                 }
 289
 290                 append_dsd64(&cur_dsd, sg);
 291                 avail_dsds--;
 292         }
 293 }
 294
 295 /*
 296  * Find the first handle that is not in use, starting from
 297  * req->current_outstanding_cmd + 1. The caller must hold the lock that is
 298  * associated with @req.
 299  */
 300 uint32_t qla2xxx_get_next_handle(struct req_que *req)
 301 {
 302         uint32_t index, handle = req->current_outstanding_cmd;
 303
 304         for (index = 1; index < req->num_outstanding_cmds; index++) {
 305                 handle++;
 306                 if (handle == req->num_outstanding_cmds)
 307                         handle = 1;
 308                 if (!req->outstanding_cmds[handle])
 309                         return handle;
 310         }
 311
 312         return 0;
 313 }
 314
 315 /**
 316  * qla2x00_start_scsi() - Send a SCSI command to the ISP
 317  * @sp: command to send to the ISP
 318  *
 319  * Returns non-zero if a failure occurred, else zero.
 320  */
 321 int
 322 qla2x00_start_scsi(srb_t *sp)
 323 {
 324         int             nseg;
 325         unsigned long   flags;
 326         scsi_qla_host_t *vha;
 327         struct scsi_cmnd *cmd;
 328         uint32_t        *clr_ptr;
 329         uint32_t        handle;
 330         cmd_entry_t     *cmd_pkt;
 331         uint16_t        cnt;
 332         uint16_t        req_cnt;
 333         uint16_t        tot_dsds;
 334         struct device_reg_2xxx __iomem *reg;
 335         struct qla_hw_data *ha;
 336         struct req_que *req;
 337         struct rsp_que *rsp;
 338
 339         /* Setup device pointers. */
 340         vha = sp->vha;
 341         ha = vha->hw;
 342         reg = &ha->iobase->isp;
 343         cmd = GET_CMD_SP(sp);
 344         req = ha->req_q_map[0];
 345         rsp = ha->rsp_q_map[0];
 346         /* So we know we haven't pci_map'ed anything yet */
 347         tot_dsds = 0;
 348
 349         /* Send marker if required */
 350         if (vha->marker_needed != 0) {
 351                 if (qla2x00_marker(vha, ha->base_qpair, 0, 0, MK_SYNC_ALL) !=
 352                     QLA_SUCCESS) {
 353                         return (QLA_FUNCTION_FAILED);
 354                 }
 355                 vha->marker_needed = 0;
 356         }
 357
 358         /* Acquire ring specific lock */
 359         spin_lock_irqsave(&ha->hardware_lock, flags);
 360
 361         handle = qla2xxx_get_next_handle(req);
 362         if (handle == 0)
 363                 goto queuing_error;
 364
 365         /* Map the sg table so we have an accurate count of sg entries needed */
 366         if (scsi_sg_count(cmd)) {
 367                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
 368                     scsi_sg_count(cmd), cmd->sc_data_direction);
 369                 if (unlikely(!nseg))
 370                         goto queuing_error;
 371         } else
 372                 nseg = 0;
 373
 374         tot_dsds = nseg;
 375
 376         /* Calculate the number of request entries needed. */
 377         req_cnt = ha->isp_ops->calc_req_entries(tot_dsds);
 378         if (req->cnt < (req_cnt + 2)) {
 379                 cnt = rd_reg_word_relaxed(ISP_REQ_Q_OUT(ha, reg));
 380                 if (req->ring_index < cnt)
 381                         req->cnt = cnt - req->ring_index;
 382                 else
 383                         req->cnt = req->length -
 384                             (req->ring_index - cnt);
 385                 /* If still no head room then bail out */
 386                 if (req->cnt < (req_cnt + 2))
 387                         goto queuing_error;
 388         }
 389
 390         /* Build command packet */
 391         req->current_outstanding_cmd = handle;
 392         req->outstanding_cmds[handle] = sp;
 393         sp->handle = handle;
 394         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
 395         req->cnt -= req_cnt;
 396
 397         cmd_pkt = (cmd_entry_t *)req->ring_ptr;
 398         cmd_pkt->handle = handle;
 399         /* Zero out remaining portion of packet. */
 400         clr_ptr = (uint32_t *)cmd_pkt + 2;
 401         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
 402         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
 403
 404         /* Set target ID and LUN number*/
 405         SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id);
 406         cmd_pkt->lun = cpu_to_le16(cmd->device->lun);
 407         cmd_pkt->control_flags = cpu_to_le16(CF_SIMPLE_TAG);
 408
 409         /* Load SCSI command packet. */
 410         memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
 411         cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
 412
 413         /* Build IOCB segments */
 414         ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds);
 415
 416         /* Set total data segment count. */
 417         cmd_pkt->entry_count = (uint8_t)req_cnt;
 418         wmb();
 419
 420         /* Adjust ring index. */
 421         req->ring_index++;
 422         if (req->ring_index == req->length) {
 423                 req->ring_index = 0;
 424                 req->ring_ptr = req->ring;
 425         } else
 426                 req->ring_ptr++;
 427
 428         sp->flags |= SRB_DMA_VALID;
 429
 430         /* Set chip new ring index. */
 431         wrt_reg_word(ISP_REQ_Q_IN(ha, reg), req->ring_index);
 432         rd_reg_word_relaxed(ISP_REQ_Q_IN(ha, reg));     /* PCI Posting. */
 433
 434         /* Manage unprocessed RIO/ZIO commands in response queue. */
 435         if (vha->flags.process_response_queue &&
 436             rsp->ring_ptr->signature != RESPONSE_PROCESSED)
 437                 qla2x00_process_response_queue(rsp);
 438
 439         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 440         return (QLA_SUCCESS);
 441
 442 queuing_error:
 443         if (tot_dsds)
 444                 scsi_dma_unmap(cmd);
 445
 446         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 447
 448         return (QLA_FUNCTION_FAILED);
 449 }
 450
 451 /**
 452  * qla2x00_start_iocbs() - Execute the IOCB command
 453  * @vha: HA context
 454  * @req: request queue
 455  */
 456 void
 457 qla2x00_start_iocbs(struct scsi_qla_host *vha, struct req_que *req)
 458 {
 459         struct qla_hw_data *ha = vha->hw;
 460         device_reg_t *reg = ISP_QUE_REG(ha, req->id);
 461
 462         if (IS_P3P_TYPE(ha)) {
 463                 qla82xx_start_iocbs(vha);
 464         } else {
 465                 /* Adjust ring index. */
 466                 req->ring_index++;
 467                 if (req->ring_index == req->length) {
 468                         req->ring_index = 0;
 469                         req->ring_ptr = req->ring;
 470                 } else
 471                         req->ring_ptr++;
 472
 473                 /* Set chip new ring index. */
 474                 if (ha->mqenable || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
 475                         wrt_reg_dword(req->req_q_in, req->ring_index);
 476                 } else if (IS_QLA83XX(ha)) {
 477                         wrt_reg_dword(req->req_q_in, req->ring_index);
 478                         rd_reg_dword_relaxed(&ha->iobase->isp24.hccr);
 479                 } else if (IS_QLAFX00(ha)) {
 480                         wrt_reg_dword(&reg->ispfx00.req_q_in, req->ring_index);
 481                         rd_reg_dword_relaxed(&reg->ispfx00.req_q_in);
 482                         QLAFX00_SET_HST_INTR(ha, ha->rqstq_intr_code);
 483                 } else if (IS_FWI2_CAPABLE(ha)) {
 484                         wrt_reg_dword(&reg->isp24.req_q_in, req->ring_index);
 485                         rd_reg_dword_relaxed(&reg->isp24.req_q_in);
 486                 } else {
 487                         wrt_reg_word(ISP_REQ_Q_IN(ha, &reg->isp),
 488                                 req->ring_index);
 489                         rd_reg_word_relaxed(ISP_REQ_Q_IN(ha, &reg->isp));
 490                 }
 491         }
 492 }
 493
 494 /**
 495  * qla2x00_marker() - Send a marker IOCB to the firmware.
 496  * @vha: HA context
 497  * @qpair: queue pair pointer
 498  * @loop_id: loop ID
 499  * @lun: LUN
 500  * @type: marker modifier
 501  *
 502  * Can be called from both normal and interrupt context.
 503  *
 504  * Returns non-zero if a failure occurred, else zero.
 505  */
 506 static int
 507 __qla2x00_marker(struct scsi_qla_host *vha, struct qla_qpair *qpair,
 508     uint16_t loop_id, uint64_t lun, uint8_t type)
 509 {
 510         mrk_entry_t *mrk;
 511         struct mrk_entry_24xx *mrk24 = NULL;
 512         struct req_que *req = qpair->req;
 513         struct qla_hw_data *ha = vha->hw;
 514         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 515
 516         mrk = (mrk_entry_t *)__qla2x00_alloc_iocbs(qpair, NULL);
 517         if (mrk == NULL) {
 518                 ql_log(ql_log_warn, base_vha, 0x3026,
 519                     "Failed to allocate Marker IOCB.\n");
 520
 521                 return (QLA_FUNCTION_FAILED);
 522         }
 523
 524         mrk->entry_type = MARKER_TYPE;
 525         mrk->modifier = type;
 526         if (type != MK_SYNC_ALL) {
 527                 if (IS_FWI2_CAPABLE(ha)) {
 528                         mrk24 = (struct mrk_entry_24xx *) mrk;
 529                         mrk24->nport_handle = cpu_to_le16(loop_id);
 530                         int_to_scsilun(lun, (struct scsi_lun *)&mrk24->lun);
 531                         host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun));
 532                         mrk24->vp_index = vha->vp_idx;
 533                         mrk24->handle = make_handle(req->id, mrk24->handle);
 534                 } else {
 535                         SET_TARGET_ID(ha, mrk->target, loop_id);
 536                         mrk->lun = cpu_to_le16((uint16_t)lun);
 537                 }
 538         }
 539         wmb();
 540
 541         qla2x00_start_iocbs(vha, req);
 542
 543         return (QLA_SUCCESS);
 544 }
 545
 546 int
 547 qla2x00_marker(struct scsi_qla_host *vha, struct qla_qpair *qpair,
 548     uint16_t loop_id, uint64_t lun, uint8_t type)
 549 {
 550         int ret;
 551         unsigned long flags = 0;
 552
 553         spin_lock_irqsave(qpair->qp_lock_ptr, flags);
 554         ret = __qla2x00_marker(vha, qpair, loop_id, lun, type);
 555         spin_unlock_irqrestore(qpair->qp_lock_ptr, flags);
 556
 557         return (ret);
 558 }
 559
 560 /*
 561  * qla2x00_issue_marker
 562  *
 563  * Issue marker
 564  * Caller CAN have hardware lock held as specified by ha_locked parameter.
 565  * Might release it, then reaquire.
 566  */
 567 int qla2x00_issue_marker(scsi_qla_host_t *vha, int ha_locked)
 568 {
 569         if (ha_locked) {
 570                 if (__qla2x00_marker(vha, vha->hw->base_qpair, 0, 0,
 571                                         MK_SYNC_ALL) != QLA_SUCCESS)
 572                         return QLA_FUNCTION_FAILED;
 573         } else {
 574                 if (qla2x00_marker(vha, vha->hw->base_qpair, 0, 0,
 575                                         MK_SYNC_ALL) != QLA_SUCCESS)
 576                         return QLA_FUNCTION_FAILED;
 577         }
 578         vha->marker_needed = 0;
 579
 580         return QLA_SUCCESS;
 581 }
 582
 583 static inline int
 584 qla24xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
 585         uint16_t tot_dsds)
 586 {
 587         struct dsd64 *cur_dsd = NULL, *next_dsd;
 588         scsi_qla_host_t *vha;
 589         struct qla_hw_data *ha;
 590         struct scsi_cmnd *cmd;
 591         struct  scatterlist *cur_seg;
 592         uint8_t avail_dsds;
 593         uint8_t first_iocb = 1;
 594         uint32_t dsd_list_len;
 595         struct dsd_dma *dsd_ptr;
 596         struct ct6_dsd *ctx;
 597
 598         cmd = GET_CMD_SP(sp);
 599
 600         /* Update entry type to indicate Command Type 3 IOCB */
 601         put_unaligned_le32(COMMAND_TYPE_6, &cmd_pkt->entry_type);
 602
 603         /* No data transfer */
 604         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 605                 cmd_pkt->byte_count = cpu_to_le32(0);
 606                 return 0;
 607         }
 608
 609         vha = sp->vha;
 610         ha = vha->hw;
 611
 612         /* Set transfer direction */
 613         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
 614                 cmd_pkt->control_flags = cpu_to_le16(CF_WRITE_DATA);
 615                 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
 616                 vha->qla_stats.output_requests++;
 617         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
 618                 cmd_pkt->control_flags = cpu_to_le16(CF_READ_DATA);
 619                 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
 620                 vha->qla_stats.input_requests++;
 621         }
 622
 623         cur_seg = scsi_sglist(cmd);
 624         ctx = sp->u.scmd.ct6_ctx;
 625
 626         while (tot_dsds) {
 627                 avail_dsds = (tot_dsds > QLA_DSDS_PER_IOCB) ?
 628                     QLA_DSDS_PER_IOCB : tot_dsds;
 629                 tot_dsds -= avail_dsds;
 630                 dsd_list_len = (avail_dsds + 1) * QLA_DSD_SIZE;
 631
 632                 dsd_ptr = list_first_entry(&ha->gbl_dsd_list,
 633                     struct dsd_dma, list);
 634                 next_dsd = dsd_ptr->dsd_addr;
 635                 list_del(&dsd_ptr->list);
 636                 ha->gbl_dsd_avail--;
 637                 list_add_tail(&dsd_ptr->list, &ctx->dsd_list);
 638                 ctx->dsd_use_cnt++;
 639                 ha->gbl_dsd_inuse++;
 640
 641                 if (first_iocb) {
 642                         first_iocb = 0;
 643                         put_unaligned_le64(dsd_ptr->dsd_list_dma,
 644                                            &cmd_pkt->fcp_dsd.address);
 645                         cmd_pkt->fcp_dsd.length = cpu_to_le32(dsd_list_len);
 646                 } else {
 647                         put_unaligned_le64(dsd_ptr->dsd_list_dma,
 648                                            &cur_dsd->address);
 649                         cur_dsd->length = cpu_to_le32(dsd_list_len);
 650                         cur_dsd++;
 651                 }
 652                 cur_dsd = next_dsd;
 653                 while (avail_dsds) {
 654                         append_dsd64(&cur_dsd, cur_seg);
 655                         cur_seg = sg_next(cur_seg);
 656                         avail_dsds--;
 657                 }
 658         }
 659
 660         /* Null termination */
 661         cur_dsd->address = 0;
 662         cur_dsd->length = 0;
 663         cur_dsd++;
 664         cmd_pkt->control_flags |= cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE);
 665         return 0;
 666 }
 667
 668 /*
 669  * qla24xx_calc_dsd_lists() - Determine number of DSD list required
 670  * for Command Type 6.
 671  *
 672  * @dsds: number of data segment descriptors needed
 673  *
 674  * Returns the number of dsd list needed to store @dsds.
 675  */
 676 static inline uint16_t
 677 qla24xx_calc_dsd_lists(uint16_t dsds)
 678 {
 679         uint16_t dsd_lists = 0;
 680
 681         dsd_lists = (dsds/QLA_DSDS_PER_IOCB);
 682         if (dsds % QLA_DSDS_PER_IOCB)
 683                 dsd_lists++;
 684         return dsd_lists;
 685 }
 686
 687
 688 /**
 689  * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7
 690  * IOCB types.
 691  *
 692  * @sp: SRB command to process
 693  * @cmd_pkt: Command type 3 IOCB
 694  * @tot_dsds: Total number of segments to transfer
 695  * @req: pointer to request queue
 696  */
 697 inline void
 698 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt,
 699         uint16_t tot_dsds, struct req_que *req)
 700 {
 701         uint16_t        avail_dsds;
 702         struct dsd64    *cur_dsd;
 703         scsi_qla_host_t *vha;
 704         struct scsi_cmnd *cmd;
 705         struct scatterlist *sg;
 706         int i;
 707
 708         cmd = GET_CMD_SP(sp);
 709
 710         /* Update entry type to indicate Command Type 3 IOCB */
 711         put_unaligned_le32(COMMAND_TYPE_7, &cmd_pkt->entry_type);
 712
 713         /* No data transfer */
 714         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
 715                 cmd_pkt->byte_count = cpu_to_le32(0);
 716                 return;
 717         }
 718
 719         vha = sp->vha;
 720
 721         /* Set transfer direction */
 722         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
 723                 cmd_pkt->task_mgmt_flags = cpu_to_le16(TMF_WRITE_DATA);
 724                 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
 725                 vha->qla_stats.output_requests++;
 726         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
 727                 cmd_pkt->task_mgmt_flags = cpu_to_le16(TMF_READ_DATA);
 728                 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
 729                 vha->qla_stats.input_requests++;
 730         }
 731
 732         /* One DSD is available in the Command Type 3 IOCB */
 733         avail_dsds = 1;
 734         cur_dsd = &cmd_pkt->dsd;
 735
 736         /* Load data segments */
 737
 738         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
 739                 cont_a64_entry_t *cont_pkt;
 740
 741                 /* Allocate additional continuation packets? */
 742                 if (avail_dsds == 0) {
 743                         /*
 744                          * Five DSDs are available in the Continuation
 745                          * Type 1 IOCB.
 746                          */
 747                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha, req);
 748                         cur_dsd = cont_pkt->dsd;
 749                         avail_dsds = ARRAY_SIZE(cont_pkt->dsd);
 750                 }
 751
 752                 append_dsd64(&cur_dsd, sg);
 753                 avail_dsds--;
 754         }
 755 }
 756
 757 struct fw_dif_context {
 758         __le32  ref_tag;
 759         __le16  app_tag;
 760         uint8_t ref_tag_mask[4];        /* Validation/Replacement Mask*/
 761         uint8_t app_tag_mask[2];        /* Validation/Replacement Mask*/
 762 };
 763
 764 /*
 765  * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command
 766  *
 767  */
 768 static inline void
 769 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt,
 770     unsigned int protcnt)
 771 {
 772         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
 773
 774         switch (scsi_get_prot_type(cmd)) {
 775         case SCSI_PROT_DIF_TYPE0:
 776                 /*
 777                  * No check for ql2xenablehba_err_chk, as it would be an
 778                  * I/O error if hba tag generation is not done.
 779                  */
 780                 pkt->ref_tag = cpu_to_le32((uint32_t)
 781                     (0xffffffff & scsi_get_lba(cmd)));
 782
 783                 if (!qla2x00_hba_err_chk_enabled(sp))
 784                         break;
 785
 786                 pkt->ref_tag_mask[0] = 0xff;
 787                 pkt->ref_tag_mask[1] = 0xff;
 788                 pkt->ref_tag_mask[2] = 0xff;
 789                 pkt->ref_tag_mask[3] = 0xff;
 790                 break;
 791
 792         /*
 793          * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to
 794          * match LBA in CDB + N
 795          */
 796         case SCSI_PROT_DIF_TYPE2:
 797                 pkt->app_tag = cpu_to_le16(0);
 798                 pkt->app_tag_mask[0] = 0x0;
 799                 pkt->app_tag_mask[1] = 0x0;
 800
 801                 pkt->ref_tag = cpu_to_le32((uint32_t)
 802                     (0xffffffff & scsi_get_lba(cmd)));
 803
 804                 if (!qla2x00_hba_err_chk_enabled(sp))
 805                         break;
 806
 807                 /* enable ALL bytes of the ref tag */
 808                 pkt->ref_tag_mask[0] = 0xff;
 809                 pkt->ref_tag_mask[1] = 0xff;
 810                 pkt->ref_tag_mask[2] = 0xff;
 811                 pkt->ref_tag_mask[3] = 0xff;
 812                 break;
 813
 814         /* For Type 3 protection: 16 bit GUARD only */
 815         case SCSI_PROT_DIF_TYPE3:
 816                 pkt->ref_tag_mask[0] = pkt->ref_tag_mask[1] =
 817                         pkt->ref_tag_mask[2] = pkt->ref_tag_mask[3] =
 818                                                                 0x00;
 819                 break;
 820
 821         /*
 822          * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and
 823          * 16 bit app tag.
 824          */
 825         case SCSI_PROT_DIF_TYPE1:
 826                 pkt->ref_tag = cpu_to_le32((uint32_t)
 827                     (0xffffffff & scsi_get_lba(cmd)));
 828                 pkt->app_tag = cpu_to_le16(0);
 829                 pkt->app_tag_mask[0] = 0x0;
 830                 pkt->app_tag_mask[1] = 0x0;
 831
 832                 if (!qla2x00_hba_err_chk_enabled(sp))
 833                         break;
 834
 835                 /* enable ALL bytes of the ref tag */
 836                 pkt->ref_tag_mask[0] = 0xff;
 837                 pkt->ref_tag_mask[1] = 0xff;
 838                 pkt->ref_tag_mask[2] = 0xff;
 839                 pkt->ref_tag_mask[3] = 0xff;
 840                 break;
 841         }
 842 }
 843
 844 int
 845 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx,
 846         uint32_t *partial)
 847 {
 848         struct scatterlist *sg;
 849         uint32_t cumulative_partial, sg_len;
 850         dma_addr_t sg_dma_addr;
 851
 852         if (sgx->num_bytes == sgx->tot_bytes)
 853                 return 0;
 854
 855         sg = sgx->cur_sg;
 856         cumulative_partial = sgx->tot_partial;
 857
 858         sg_dma_addr = sg_dma_address(sg);
 859         sg_len = sg_dma_len(sg);
 860
 861         sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed;
 862
 863         if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) {
 864                 sgx->dma_len = (blk_sz - cumulative_partial);
 865                 sgx->tot_partial = 0;
 866                 sgx->num_bytes += blk_sz;
 867                 *partial = 0;
 868         } else {
 869                 sgx->dma_len = sg_len - sgx->bytes_consumed;
 870                 sgx->tot_partial += sgx->dma_len;
 871                 *partial = 1;
 872         }
 873
 874         sgx->bytes_consumed += sgx->dma_len;
 875
 876         if (sg_len == sgx->bytes_consumed) {
 877                 sg = sg_next(sg);
 878                 sgx->num_sg++;
 879                 sgx->cur_sg = sg;
 880                 sgx->bytes_consumed = 0;
 881         }
 882
 883         return 1;
 884 }
 885
 886 int
 887 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp,
 888         struct dsd64 *dsd, uint16_t tot_dsds, struct qla_tc_param *tc)
 889 {
 890         void *next_dsd;
 891         uint8_t avail_dsds = 0;
 892         uint32_t dsd_list_len;
 893         struct dsd_dma *dsd_ptr;
 894         struct scatterlist *sg_prot;
 895         struct dsd64 *cur_dsd = dsd;
 896         uint16_t        used_dsds = tot_dsds;
 897         uint32_t        prot_int; /* protection interval */
 898         uint32_t        partial;
 899         struct qla2_sgx sgx;
 900         dma_addr_t      sle_dma;
 901         uint32_t        sle_dma_len, tot_prot_dma_len = 0;
 902         struct scsi_cmnd *cmd;
 903
 904         memset(&sgx, 0, sizeof(struct qla2_sgx));
 905         if (sp) {
 906                 cmd = GET_CMD_SP(sp);
 907                 prot_int = cmd->device->sector_size;
 908
 909                 sgx.tot_bytes = scsi_bufflen(cmd);
 910                 sgx.cur_sg = scsi_sglist(cmd);
 911                 sgx.sp = sp;
 912
 913                 sg_prot = scsi_prot_sglist(cmd);
 914         } else if (tc) {
 915                 prot_int      = tc->blk_sz;
 916                 sgx.tot_bytes = tc->bufflen;
 917                 sgx.cur_sg    = tc->sg;
 918                 sg_prot       = tc->prot_sg;
 919         } else {
 920                 BUG();
 921                 return 1;
 922         }
 923
 924         while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) {
 925
 926                 sle_dma = sgx.dma_addr;
 927                 sle_dma_len = sgx.dma_len;
 928 alloc_and_fill:
 929                 /* Allocate additional continuation packets? */
 930                 if (avail_dsds == 0) {
 931                         avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
 932                                         QLA_DSDS_PER_IOCB : used_dsds;
 933                         dsd_list_len = (avail_dsds + 1) * 12;
 934                         used_dsds -= avail_dsds;
 935
 936                         /* allocate tracking DS */
 937                         dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
 938                         if (!dsd_ptr)
 939                                 return 1;
 940
 941                         /* allocate new list */
 942                         dsd_ptr->dsd_addr = next_dsd =
 943                             dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
 944                                 &dsd_ptr->dsd_list_dma);
 945
 946                         if (!next_dsd) {
 947                                 /*
 948                                  * Need to cleanup only this dsd_ptr, rest
 949                                  * will be done by sp_free_dma()
 950                                  */
 951                                 kfree(dsd_ptr);
 952                                 return 1;
 953                         }
 954
 955                         if (sp) {
 956                                 list_add_tail(&dsd_ptr->list,
 957                                               &sp->u.scmd.crc_ctx->dsd_list);
 958
 959                                 sp->flags |= SRB_CRC_CTX_DSD_VALID;
 960                         } else {
 961                                 list_add_tail(&dsd_ptr->list,
 962                                     &(tc->ctx->dsd_list));
 963                                 *tc->ctx_dsd_alloced = 1;
 964                         }
 965
 966
 967                         /* add new list to cmd iocb or last list */
 968                         put_unaligned_le64(dsd_ptr->dsd_list_dma,
 969                                            &cur_dsd->address);
 970                         cur_dsd->length = cpu_to_le32(dsd_list_len);
 971                         cur_dsd = next_dsd;
 972                 }
 973                 put_unaligned_le64(sle_dma, &cur_dsd->address);
 974                 cur_dsd->length = cpu_to_le32(sle_dma_len);
 975                 cur_dsd++;
 976                 avail_dsds--;
 977
 978                 if (partial == 0) {
 979                         /* Got a full protection interval */
 980                         sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len;
 981                         sle_dma_len = 8;
 982
 983                         tot_prot_dma_len += sle_dma_len;
 984                         if (tot_prot_dma_len == sg_dma_len(sg_prot)) {
 985                                 tot_prot_dma_len = 0;
 986                                 sg_prot = sg_next(sg_prot);
 987                         }
 988
 989                         partial = 1; /* So as to not re-enter this block */
 990                         goto alloc_and_fill;
 991                 }
 992         }
 993         /* Null termination */
 994         cur_dsd->address = 0;
 995         cur_dsd->length = 0;
 996         cur_dsd++;
 997         return 0;
 998 }
 999
1000 int
1001 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp,
1002         struct dsd64 *dsd, uint16_t tot_dsds, struct qla_tc_param *tc)
1003 {
1004         void *next_dsd;
1005         uint8_t avail_dsds = 0;
1006         uint32_t dsd_list_len;
1007         struct dsd_dma *dsd_ptr;
1008         struct scatterlist *sg, *sgl;
1009         struct dsd64 *cur_dsd = dsd;
1010         int     i;
1011         uint16_t        used_dsds = tot_dsds;
1012         struct scsi_cmnd *cmd;
1013
1014         if (sp) {
1015                 cmd = GET_CMD_SP(sp);
1016                 sgl = scsi_sglist(cmd);
1017         } else if (tc) {
1018                 sgl = tc->sg;
1019         } else {
1020                 BUG();
1021                 return 1;
1022         }
1023
1024
1025         for_each_sg(sgl, sg, tot_dsds, i) {
1026                 /* Allocate additional continuation packets? */
1027                 if (avail_dsds == 0) {
1028                         avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
1029                                         QLA_DSDS_PER_IOCB : used_dsds;
1030                         dsd_list_len = (avail_dsds + 1) * 12;
1031                         used_dsds -= avail_dsds;
1032
1033                         /* allocate tracking DS */
1034                         dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
1035                         if (!dsd_ptr)
1036                                 return 1;
1037
1038                         /* allocate new list */
1039                         dsd_ptr->dsd_addr = next_dsd =
1040                             dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
1041                                 &dsd_ptr->dsd_list_dma);
1042
1043                         if (!next_dsd) {
1044                                 /*
1045                                  * Need to cleanup only this dsd_ptr, rest
1046                                  * will be done by sp_free_dma()
1047                                  */
1048                                 kfree(dsd_ptr);
1049                                 return 1;
1050                         }
1051
1052                         if (sp) {
1053                                 list_add_tail(&dsd_ptr->list,
1054                                               &sp->u.scmd.crc_ctx->dsd_list);
1055
1056                                 sp->flags |= SRB_CRC_CTX_DSD_VALID;
1057                         } else {
1058                                 list_add_tail(&dsd_ptr->list,
1059                                     &(tc->ctx->dsd_list));
1060                                 *tc->ctx_dsd_alloced = 1;
1061                         }
1062
1063                         /* add new list to cmd iocb or last list */
1064                         put_unaligned_le64(dsd_ptr->dsd_list_dma,
1065                                            &cur_dsd->address);
1066                         cur_dsd->length = cpu_to_le32(dsd_list_len);
1067                         cur_dsd = next_dsd;
1068                 }
1069                 append_dsd64(&cur_dsd, sg);
1070                 avail_dsds--;
1071
1072         }
1073         /* Null termination */
1074         cur_dsd->address = 0;
1075         cur_dsd->length = 0;
1076         cur_dsd++;
1077         return 0;
1078 }
1079
1080 int
1081 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
1082         struct dsd64 *cur_dsd, uint16_t tot_dsds, struct qla_tgt_cmd *tc)
1083 {
1084         struct dsd_dma *dsd_ptr = NULL, *dif_dsd, *nxt_dsd;
1085         struct scatterlist *sg, *sgl;
1086         struct crc_context *difctx = NULL;
1087         struct scsi_qla_host *vha;
1088         uint dsd_list_len;
1089         uint avail_dsds = 0;
1090         uint used_dsds = tot_dsds;
1091         bool dif_local_dma_alloc = false;
1092         bool direction_to_device = false;
1093         int i;
1094
1095         if (sp) {
1096                 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1097
1098                 sgl = scsi_prot_sglist(cmd);
1099                 vha = sp->vha;
1100                 difctx = sp->u.scmd.crc_ctx;
1101                 direction_to_device = cmd->sc_data_direction == DMA_TO_DEVICE;
1102                 ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe021,
1103                   "%s: scsi_cmnd: %p, crc_ctx: %p, sp: %p\n",
1104                         __func__, cmd, difctx, sp);
1105         } else if (tc) {
1106                 vha = tc->vha;
1107                 sgl = tc->prot_sg;
1108                 difctx = tc->ctx;
1109                 direction_to_device = tc->dma_data_direction == DMA_TO_DEVICE;
1110         } else {
1111                 BUG();
1112                 return 1;
1113         }
1114
1115         ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe021,
1116             "%s: enter (write=%u)\n", __func__, direction_to_device);
1117
1118         /* if initiator doing write or target doing read */
1119         if (direction_to_device) {
1120                 for_each_sg(sgl, sg, tot_dsds, i) {
1121                         u64 sle_phys = sg_phys(sg);
1122
1123                         /* If SGE addr + len flips bits in upper 32-bits */
1124                         if (MSD(sle_phys + sg->length) ^ MSD(sle_phys)) {
1125                                 ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe022,
1126                                     "%s: page boundary crossing (phys=%llx len=%x)\n",
1127                                     __func__, sle_phys, sg->length);
1128
1129                                 if (difctx) {
1130                                         ha->dif_bundle_crossed_pages++;
1131                                         dif_local_dma_alloc = true;
1132                                 } else {
1133                                         ql_dbg(ql_dbg_tgt + ql_dbg_verbose,
1134                                             vha, 0xe022,
1135                                             "%s: difctx pointer is NULL\n",
1136                                             __func__);
1137                                 }
1138                                 break;
1139                         }
1140                 }
1141                 ha->dif_bundle_writes++;
1142         } else {
1143                 ha->dif_bundle_reads++;
1144         }
1145
1146         if (ql2xdifbundlinginternalbuffers)
1147                 dif_local_dma_alloc = direction_to_device;
1148
1149         if (dif_local_dma_alloc) {
1150                 u32 track_difbundl_buf = 0;
1151                 u32 ldma_sg_len = 0;
1152                 u8 ldma_needed = 1;
1153
1154                 difctx->no_dif_bundl = 0;
1155                 difctx->dif_bundl_len = 0;
1156
1157                 /* Track DSD buffers */
1158                 INIT_LIST_HEAD(&difctx->ldif_dsd_list);
1159                 /* Track local DMA buffers */
1160                 INIT_LIST_HEAD(&difctx->ldif_dma_hndl_list);
1161
1162                 for_each_sg(sgl, sg, tot_dsds, i) {
1163                         u32 sglen = sg_dma_len(sg);
1164
1165                         ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe023,
1166                             "%s: sg[%x] (phys=%llx sglen=%x) ldma_sg_len: %x dif_bundl_len: %x ldma_needed: %x\n",
1167                             __func__, i, (u64)sg_phys(sg), sglen, ldma_sg_len,
1168                             difctx->dif_bundl_len, ldma_needed);
1169
1170                         while (sglen) {
1171                                 u32 xfrlen = 0;
1172
1173                                 if (ldma_needed) {
1174                                         /*
1175                                          * Allocate list item to store
1176                                          * the DMA buffers
1177                                          */
1178                                         dsd_ptr = kzalloc(sizeof(*dsd_ptr),
1179                                             GFP_ATOMIC);
1180                                         if (!dsd_ptr) {
1181                                                 ql_dbg(ql_dbg_tgt, vha, 0xe024,
1182                                                     "%s: failed alloc dsd_ptr\n",
1183                                                     __func__);
1184                                                 return 1;
1185                                         }
1186                                         ha->dif_bundle_kallocs++;
1187
1188                                         /* allocate dma buffer */
1189                                         dsd_ptr->dsd_addr = dma_pool_alloc
1190                                                 (ha->dif_bundl_pool, GFP_ATOMIC,
1191                                                  &dsd_ptr->dsd_list_dma);
1192                                         if (!dsd_ptr->dsd_addr) {
1193                                                 ql_dbg(ql_dbg_tgt, vha, 0xe024,
1194                                                     "%s: failed alloc ->dsd_ptr\n",
1195                                                     __func__);
1196                                                 /*
1197                                                  * need to cleanup only this
1198                                                  * dsd_ptr rest will be done
1199                                                  * by sp_free_dma()
1200                                                  */
1201                                                 kfree(dsd_ptr);
1202                                                 ha->dif_bundle_kallocs--;
1203                                                 return 1;
1204                                         }
1205                                         ha->dif_bundle_dma_allocs++;
1206                                         ldma_needed = 0;
1207                                         difctx->no_dif_bundl++;
1208                                         list_add_tail(&dsd_ptr->list,
1209                                             &difctx->ldif_dma_hndl_list);
1210                                 }
1211
1212                                 /* xfrlen is min of dma pool size and sglen */
1213                                 xfrlen = (sglen >
1214                                    (DIF_BUNDLING_DMA_POOL_SIZE - ldma_sg_len)) ?
1215                                     DIF_BUNDLING_DMA_POOL_SIZE - ldma_sg_len :
1216                                     sglen;
1217
1218                                 /* replace with local allocated dma buffer */
1219                                 sg_pcopy_to_buffer(sgl, sg_nents(sgl),
1220                                     dsd_ptr->dsd_addr + ldma_sg_len, xfrlen,
1221                                     difctx->dif_bundl_len);
1222                                 difctx->dif_bundl_len += xfrlen;
1223                                 sglen -= xfrlen;
1224                                 ldma_sg_len += xfrlen;
1225                                 if (ldma_sg_len == DIF_BUNDLING_DMA_POOL_SIZE ||
1226                                     sg_is_last(sg)) {
1227                                         ldma_needed = 1;
1228                                         ldma_sg_len = 0;
1229                                 }
1230                         }
1231                 }
1232
1233                 track_difbundl_buf = used_dsds = difctx->no_dif_bundl;
1234                 ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe025,
1235                     "dif_bundl_len=%x, no_dif_bundl=%x track_difbundl_buf: %x\n",
1236                     difctx->dif_bundl_len, difctx->no_dif_bundl,
1237                     track_difbundl_buf);
1238
1239                 if (sp)
1240                         sp->flags |= SRB_DIF_BUNDL_DMA_VALID;
1241                 else
1242                         tc->prot_flags = DIF_BUNDL_DMA_VALID;
1243
1244                 list_for_each_entry_safe(dif_dsd, nxt_dsd,
1245                     &difctx->ldif_dma_hndl_list, list) {
1246                         u32 sglen = (difctx->dif_bundl_len >
1247                             DIF_BUNDLING_DMA_POOL_SIZE) ?
1248                             DIF_BUNDLING_DMA_POOL_SIZE : difctx->dif_bundl_len;
1249
1250                         BUG_ON(track_difbundl_buf == 0);
1251
1252                         /* Allocate additional continuation packets? */
1253                         if (avail_dsds == 0) {
1254                                 ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha,
1255                                     0xe024,
1256                                     "%s: adding continuation iocb's\n",
1257                                     __func__);
1258                                 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
1259                                     QLA_DSDS_PER_IOCB : used_dsds;
1260                                 dsd_list_len = (avail_dsds + 1) * 12;
1261                                 used_dsds -= avail_dsds;
1262
1263                                 /* allocate tracking DS */
1264                                 dsd_ptr = kzalloc(sizeof(*dsd_ptr), GFP_ATOMIC);
1265                                 if (!dsd_ptr) {
1266                                         ql_dbg(ql_dbg_tgt, vha, 0xe026,
1267                                             "%s: failed alloc dsd_ptr\n",
1268                                             __func__);
1269                                         return 1;
1270                                 }
1271                                 ha->dif_bundle_kallocs++;
1272
1273                                 difctx->no_ldif_dsd++;
1274                                 /* allocate new list */
1275                                 dsd_ptr->dsd_addr =
1276                                     dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
1277                                         &dsd_ptr->dsd_list_dma);
1278                                 if (!dsd_ptr->dsd_addr) {
1279                                         ql_dbg(ql_dbg_tgt, vha, 0xe026,
1280                                             "%s: failed alloc ->dsd_addr\n",
1281                                             __func__);
1282                                         /*
1283                                          * need to cleanup only this dsd_ptr
1284                                          *  rest will be done by sp_free_dma()
1285                                          */
1286                                         kfree(dsd_ptr);
1287                                         ha->dif_bundle_kallocs--;
1288                                         return 1;
1289                                 }
1290                                 ha->dif_bundle_dma_allocs++;
1291
1292                                 if (sp) {
1293                                         list_add_tail(&dsd_ptr->list,
1294                                             &difctx->ldif_dsd_list);
1295                                         sp->flags |= SRB_CRC_CTX_DSD_VALID;
1296                                 } else {
1297                                         list_add_tail(&dsd_ptr->list,
1298                                             &difctx->ldif_dsd_list);
1299                                         tc->ctx_dsd_alloced = 1;
1300                                 }
1301
1302                                 /* add new list to cmd iocb or last list */
1303                                 put_unaligned_le64(dsd_ptr->dsd_list_dma,
1304                                                    &cur_dsd->address);
1305                                 cur_dsd->length = cpu_to_le32(dsd_list_len);
1306                                 cur_dsd = dsd_ptr->dsd_addr;
1307                         }
1308                         put_unaligned_le64(dif_dsd->dsd_list_dma,
1309                                            &cur_dsd->address);
1310                         cur_dsd->length = cpu_to_le32(sglen);
1311                         cur_dsd++;
1312                         avail_dsds--;
1313                         difctx->dif_bundl_len -= sglen;
1314                         track_difbundl_buf--;
1315                 }
1316
1317                 ql_dbg(ql_dbg_tgt + ql_dbg_verbose, vha, 0xe026,
1318                     "%s: no_ldif_dsd:%x, no_dif_bundl:%x\n", __func__,
1319                         difctx->no_ldif_dsd, difctx->no_dif_bundl);
1320         } else {
1321                 for_each_sg(sgl, sg, tot_dsds, i) {
1322                         /* Allocate additional continuation packets? */
1323                         if (avail_dsds == 0) {
1324                                 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
1325                                     QLA_DSDS_PER_IOCB : used_dsds;
1326                                 dsd_list_len = (avail_dsds + 1) * 12;
1327                                 used_dsds -= avail_dsds;
1328
1329                                 /* allocate tracking DS */
1330                                 dsd_ptr = kzalloc(sizeof(*dsd_ptr), GFP_ATOMIC);
1331                                 if (!dsd_ptr) {
1332                                         ql_dbg(ql_dbg_tgt + ql_dbg_verbose,
1333                                             vha, 0xe027,
1334                                             "%s: failed alloc dsd_dma...\n",
1335                                             __func__);
1336                                         return 1;
1337                                 }
1338
1339                                 /* allocate new list */
1340                                 dsd_ptr->dsd_addr =
1341                                     dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
1342                                         &dsd_ptr->dsd_list_dma);
1343                                 if (!dsd_ptr->dsd_addr) {
1344                                         /* need to cleanup only this dsd_ptr */
1345                                         /* rest will be done by sp_free_dma() */
1346                                         kfree(dsd_ptr);
1347                                         return 1;
1348                                 }
1349
1350                                 if (sp) {
1351                                         list_add_tail(&dsd_ptr->list,
1352                                             &difctx->dsd_list);
1353                                         sp->flags |= SRB_CRC_CTX_DSD_VALID;
1354                                 } else {
1355                                         list_add_tail(&dsd_ptr->list,
1356                                             &difctx->dsd_list);
1357                                         tc->ctx_dsd_alloced = 1;
1358                                 }
1359
1360                                 /* add new list to cmd iocb or last list */
1361                                 put_unaligned_le64(dsd_ptr->dsd_list_dma,
1362                                                    &cur_dsd->address);
1363                                 cur_dsd->length = cpu_to_le32(dsd_list_len);
1364                                 cur_dsd = dsd_ptr->dsd_addr;
1365                         }
1366                         append_dsd64(&cur_dsd, sg);
1367                         avail_dsds--;
1368                 }
1369         }
1370         /* Null termination */
1371         cur_dsd->address = 0;
1372         cur_dsd->length = 0;
1373         cur_dsd++;
1374         return 0;
1375 }
1376
1377 /**
1378  * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command
1379  *                                                      Type 6 IOCB types.
1380  *
1381  * @sp: SRB command to process
1382  * @cmd_pkt: Command type 3 IOCB
1383  * @tot_dsds: Total number of segments to transfer
1384  * @tot_prot_dsds: Total number of segments with protection information
1385  * @fw_prot_opts: Protection options to be passed to firmware
1386  */
1387 static inline int
1388 qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
1389     uint16_t tot_dsds, uint16_t tot_prot_dsds, uint16_t fw_prot_opts)
1390 {
1391         struct dsd64            *cur_dsd;
1392         __be32                  *fcp_dl;
1393         scsi_qla_host_t         *vha;
1394         struct scsi_cmnd        *cmd;
1395         uint32_t                total_bytes = 0;
1396         uint32_t                data_bytes;
1397         uint32_t                dif_bytes;
1398         uint8_t                 bundling = 1;
1399         uint16_t                blk_size;
1400         struct crc_context      *crc_ctx_pkt = NULL;
1401         struct qla_hw_data      *ha;
1402         uint8_t                 additional_fcpcdb_len;
1403         uint16_t                fcp_cmnd_len;
1404         struct fcp_cmnd         *fcp_cmnd;
1405         dma_addr_t              crc_ctx_dma;
1406
1407         cmd = GET_CMD_SP(sp);
1408
1409         /* Update entry type to indicate Command Type CRC_2 IOCB */
1410         put_unaligned_le32(COMMAND_TYPE_CRC_2, &cmd_pkt->entry_type);
1411
1412         vha = sp->vha;
1413         ha = vha->hw;
1414
1415         /* No data transfer */
1416         data_bytes = scsi_bufflen(cmd);
1417         if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
1418                 cmd_pkt->byte_count = cpu_to_le32(0);
1419                 return QLA_SUCCESS;
1420         }
1421
1422         cmd_pkt->vp_index = sp->vha->vp_idx;
1423
1424         /* Set transfer direction */
1425         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1426                 cmd_pkt->control_flags =
1427                     cpu_to_le16(CF_WRITE_DATA);
1428         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
1429                 cmd_pkt->control_flags =
1430                     cpu_to_le16(CF_READ_DATA);
1431         }
1432
1433         if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1434             (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP) ||
1435             (scsi_get_prot_op(cmd) == SCSI_PROT_READ_STRIP) ||
1436             (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_INSERT))
1437                 bundling = 0;
1438
1439         /* Allocate CRC context from global pool */
1440         crc_ctx_pkt = sp->u.scmd.crc_ctx =
1441             dma_pool_zalloc(ha->dl_dma_pool, GFP_ATOMIC, &crc_ctx_dma);
1442
1443         if (!crc_ctx_pkt)
1444                 goto crc_queuing_error;
1445
1446         crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma;
1447
1448         sp->flags |= SRB_CRC_CTX_DMA_VALID;
1449
1450         /* Set handle */
1451         crc_ctx_pkt->handle = cmd_pkt->handle;
1452
1453         INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list);
1454
1455         qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *)
1456             &crc_ctx_pkt->ref_tag, tot_prot_dsds);
1457
1458         put_unaligned_le64(crc_ctx_dma, &cmd_pkt->crc_context_address);
1459         cmd_pkt->crc_context_len = cpu_to_le16(CRC_CONTEXT_LEN_FW);
1460
1461         /* Determine SCSI command length -- align to 4 byte boundary */
1462         if (cmd->cmd_len > 16) {
1463                 additional_fcpcdb_len = cmd->cmd_len - 16;
1464                 if ((cmd->cmd_len % 4) != 0) {
1465                         /* SCSI cmd > 16 bytes must be multiple of 4 */
1466                         goto crc_queuing_error;
1467                 }
1468                 fcp_cmnd_len = 12 + cmd->cmd_len + 4;
1469         } else {
1470                 additional_fcpcdb_len = 0;
1471                 fcp_cmnd_len = 12 + 16 + 4;
1472         }
1473
1474         fcp_cmnd = &crc_ctx_pkt->fcp_cmnd;
1475
1476         fcp_cmnd->additional_cdb_len = additional_fcpcdb_len;
1477         if (cmd->sc_data_direction == DMA_TO_DEVICE)
1478                 fcp_cmnd->additional_cdb_len |= 1;
1479         else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1480                 fcp_cmnd->additional_cdb_len |= 2;
1481
1482         int_to_scsilun(cmd->device->lun, &fcp_cmnd->lun);
1483         memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
1484         cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len);
1485         put_unaligned_le64(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF,
1486                            &cmd_pkt->fcp_cmnd_dseg_address);
1487         fcp_cmnd->task_management = 0;
1488         fcp_cmnd->task_attribute = TSK_SIMPLE;
1489
1490         cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
1491
1492         /* Compute dif len and adjust data len to incude protection */
1493         dif_bytes = 0;
1494         blk_size = cmd->device->sector_size;
1495         dif_bytes = (data_bytes / blk_size) * 8;
1496
1497         switch (scsi_get_prot_op(GET_CMD_SP(sp))) {
1498         case SCSI_PROT_READ_INSERT:
1499         case SCSI_PROT_WRITE_STRIP:
1500                 total_bytes = data_bytes;
1501                 data_bytes += dif_bytes;
1502                 break;
1503
1504         case SCSI_PROT_READ_STRIP:
1505         case SCSI_PROT_WRITE_INSERT:
1506         case SCSI_PROT_READ_PASS:
1507         case SCSI_PROT_WRITE_PASS:
1508                 total_bytes = data_bytes + dif_bytes;
1509                 break;
1510         default:
1511                 BUG();
1512         }
1513
1514         if (!qla2x00_hba_err_chk_enabled(sp))
1515                 fw_prot_opts |= 0x10; /* Disable Guard tag checking */
1516         /* HBA error checking enabled */
1517         else if (IS_PI_UNINIT_CAPABLE(ha)) {
1518                 if ((scsi_get_prot_type(GET_CMD_SP(sp)) == SCSI_PROT_DIF_TYPE1)
1519                     || (scsi_get_prot_type(GET_CMD_SP(sp)) ==
1520                         SCSI_PROT_DIF_TYPE2))
1521                         fw_prot_opts |= BIT_10;
1522                 else if (scsi_get_prot_type(GET_CMD_SP(sp)) ==
1523                     SCSI_PROT_DIF_TYPE3)
1524                         fw_prot_opts |= BIT_11;
1525         }
1526
1527         if (!bundling) {
1528                 cur_dsd = &crc_ctx_pkt->u.nobundling.data_dsd[0];
1529         } else {
1530                 /*
1531                  * Configure Bundling if we need to fetch interlaving
1532                  * protection PCI accesses
1533                  */
1534                 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING;
1535                 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes);
1536                 crc_ctx_pkt->u.bundling.dseg_count = cpu_to_le16(tot_dsds -
1537                                                         tot_prot_dsds);
1538                 cur_dsd = &crc_ctx_pkt->u.bundling.data_dsd[0];
1539         }
1540
1541         /* Finish the common fields of CRC pkt */
1542         crc_ctx_pkt->blk_size = cpu_to_le16(blk_size);
1543         crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts);
1544         crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes);
1545         crc_ctx_pkt->guard_seed = cpu_to_le16(0);
1546         /* Fibre channel byte count */
1547         cmd_pkt->byte_count = cpu_to_le32(total_bytes);
1548         fcp_dl = (__be32 *)(crc_ctx_pkt->fcp_cmnd.cdb + 16 +
1549             additional_fcpcdb_len);
1550         *fcp_dl = htonl(total_bytes);
1551
1552         if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
1553                 cmd_pkt->byte_count = cpu_to_le32(0);
1554                 return QLA_SUCCESS;
1555         }
1556         /* Walks data segments */
1557
1558         cmd_pkt->control_flags |= cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE);
1559
1560         if (!bundling && tot_prot_dsds) {
1561                 if (qla24xx_walk_and_build_sglist_no_difb(ha, sp,
1562                         cur_dsd, tot_dsds, NULL))
1563                         goto crc_queuing_error;
1564         } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd,
1565                         (tot_dsds - tot_prot_dsds), NULL))
1566                 goto crc_queuing_error;
1567
1568         if (bundling && tot_prot_dsds) {
1569                 /* Walks dif segments */
1570                 cmd_pkt->control_flags |= cpu_to_le16(CF_DIF_SEG_DESCR_ENABLE);
1571                 cur_dsd = &crc_ctx_pkt->u.bundling.dif_dsd;
1572                 if (qla24xx_walk_and_build_prot_sglist(ha, sp, cur_dsd,
1573                                 tot_prot_dsds, NULL))
1574                         goto crc_queuing_error;
1575         }
1576         return QLA_SUCCESS;
1577
1578 crc_queuing_error:
1579         /* Cleanup will be performed by the caller */
1580
1581         return QLA_FUNCTION_FAILED;
1582 }
1583
1584 /**
1585  * qla24xx_start_scsi() - Send a SCSI command to the ISP
1586  * @sp: command to send to the ISP
1587  *
1588  * Returns non-zero if a failure occurred, else zero.
1589  */
1590 int
1591 qla24xx_start_scsi(srb_t *sp)
1592 {
1593         int             nseg;
1594         unsigned long   flags;
1595         uint32_t        *clr_ptr;
1596         uint32_t        handle;
1597         struct cmd_type_7 *cmd_pkt;
1598         uint16_t        cnt;
1599         uint16_t        req_cnt;
1600         uint16_t        tot_dsds;
1601         struct req_que *req = NULL;
1602         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1603         struct scsi_qla_host *vha = sp->vha;
1604         struct qla_hw_data *ha = vha->hw;
1605
1606         /* Setup device pointers. */
1607         req = vha->req;
1608
1609         /* So we know we haven't pci_map'ed anything yet */
1610         tot_dsds = 0;
1611
1612         /* Send marker if required */
1613         if (vha->marker_needed != 0) {
1614                 if (qla2x00_marker(vha, ha->base_qpair, 0, 0, MK_SYNC_ALL) !=
1615                     QLA_SUCCESS)
1616                         return QLA_FUNCTION_FAILED;
1617                 vha->marker_needed = 0;
1618         }
1619
1620         /* Acquire ring specific lock */
1621         spin_lock_irqsave(&ha->hardware_lock, flags);
1622
1623         handle = qla2xxx_get_next_handle(req);
1624         if (handle == 0)
1625                 goto queuing_error;
1626
1627         /* Map the sg table so we have an accurate count of sg entries needed */
1628         if (scsi_sg_count(cmd)) {
1629                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
1630                     scsi_sg_count(cmd), cmd->sc_data_direction);
1631                 if (unlikely(!nseg))
1632                         goto queuing_error;
1633         } else
1634                 nseg = 0;
1635
1636         tot_dsds = nseg;
1637         req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
1638         if (req->cnt < (req_cnt + 2)) {
1639                 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
1640                     rd_reg_dword_relaxed(req->req_q_out);
1641                 if (req->ring_index < cnt)
1642                         req->cnt = cnt - req->ring_index;
1643                 else
1644                         req->cnt = req->length -
1645                                 (req->ring_index - cnt);
1646                 if (req->cnt < (req_cnt + 2))
1647                         goto queuing_error;
1648         }
1649
1650         /* Build command packet. */
1651         req->current_outstanding_cmd = handle;
1652         req->outstanding_cmds[handle] = sp;
1653         sp->handle = handle;
1654         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
1655         req->cnt -= req_cnt;
1656
1657         cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
1658         cmd_pkt->handle = make_handle(req->id, handle);
1659
1660         /* Zero out remaining portion of packet. */
1661         /*    tagged queuing modifier -- default is TSK_SIMPLE (0). */
1662         clr_ptr = (uint32_t *)cmd_pkt + 2;
1663         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1664         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1665
1666         /* Set NPORT-ID and LUN number*/
1667         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1668         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
1669         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
1670         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
1671         cmd_pkt->vp_index = sp->vha->vp_idx;
1672
1673         int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1674         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1675
1676         cmd_pkt->task = TSK_SIMPLE;
1677
1678         /* Load SCSI command packet. */
1679         memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
1680         host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
1681
1682         cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
1683
1684         /* Build IOCB segments */
1685         qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req);
1686
1687         /* Set total data segment count. */
1688         cmd_pkt->entry_count = (uint8_t)req_cnt;
1689         wmb();
1690         /* Adjust ring index. */
1691         req->ring_index++;
1692         if (req->ring_index == req->length) {
1693                 req->ring_index = 0;
1694                 req->ring_ptr = req->ring;
1695         } else
1696                 req->ring_ptr++;
1697
1698         sp->flags |= SRB_DMA_VALID;
1699
1700         /* Set chip new ring index. */
1701         wrt_reg_dword(req->req_q_in, req->ring_index);
1702
1703         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1704         return QLA_SUCCESS;
1705
1706 queuing_error:
1707         if (tot_dsds)
1708                 scsi_dma_unmap(cmd);
1709
1710         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1711
1712         return QLA_FUNCTION_FAILED;
1713 }
1714
1715 /**
1716  * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP
1717  * @sp: command to send to the ISP
1718  *
1719  * Returns non-zero if a failure occurred, else zero.
1720  */
1721 int
1722 qla24xx_dif_start_scsi(srb_t *sp)
1723 {
1724         int                     nseg;
1725         unsigned long           flags;
1726         uint32_t                *clr_ptr;
1727         uint32_t                handle;
1728         uint16_t                cnt;
1729         uint16_t                req_cnt = 0;
1730         uint16_t                tot_dsds;
1731         uint16_t                tot_prot_dsds;
1732         uint16_t                fw_prot_opts = 0;
1733         struct req_que          *req = NULL;
1734         struct rsp_que          *rsp = NULL;
1735         struct scsi_cmnd        *cmd = GET_CMD_SP(sp);
1736         struct scsi_qla_host    *vha = sp->vha;
1737         struct qla_hw_data      *ha = vha->hw;
1738         struct cmd_type_crc_2   *cmd_pkt;
1739         uint32_t                status = 0;
1740
1741 #define QDSS_GOT_Q_SPACE        BIT_0
1742
1743         /* Only process protection or >16 cdb in this routine */
1744         if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) {
1745                 if (cmd->cmd_len <= 16)
1746                         return qla24xx_start_scsi(sp);
1747         }
1748
1749         /* Setup device pointers. */
1750         req = vha->req;
1751         rsp = req->rsp;
1752
1753         /* So we know we haven't pci_map'ed anything yet */
1754         tot_dsds = 0;
1755
1756         /* Send marker if required */
1757         if (vha->marker_needed != 0) {
1758                 if (qla2x00_marker(vha, ha->base_qpair, 0, 0, MK_SYNC_ALL) !=
1759                     QLA_SUCCESS)
1760                         return QLA_FUNCTION_FAILED;
1761                 vha->marker_needed = 0;
1762         }
1763
1764         /* Acquire ring specific lock */
1765         spin_lock_irqsave(&ha->hardware_lock, flags);
1766
1767         handle = qla2xxx_get_next_handle(req);
1768         if (handle == 0)
1769                 goto queuing_error;
1770
1771         /* Compute number of required data segments */
1772         /* Map the sg table so we have an accurate count of sg entries needed */
1773         if (scsi_sg_count(cmd)) {
1774                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
1775                     scsi_sg_count(cmd), cmd->sc_data_direction);
1776                 if (unlikely(!nseg))
1777                         goto queuing_error;
1778                 else
1779                         sp->flags |= SRB_DMA_VALID;
1780
1781                 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1782                     (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
1783                         struct qla2_sgx sgx;
1784                         uint32_t        partial;
1785
1786                         memset(&sgx, 0, sizeof(struct qla2_sgx));
1787                         sgx.tot_bytes = scsi_bufflen(cmd);
1788                         sgx.cur_sg = scsi_sglist(cmd);
1789                         sgx.sp = sp;
1790
1791                         nseg = 0;
1792                         while (qla24xx_get_one_block_sg(
1793                             cmd->device->sector_size, &sgx, &partial))
1794                                 nseg++;
1795                 }
1796         } else
1797                 nseg = 0;
1798
1799         /* number of required data segments */
1800         tot_dsds = nseg;
1801
1802         /* Compute number of required protection segments */
1803         if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) {
1804                 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
1805                     scsi_prot_sg_count(cmd), cmd->sc_data_direction);
1806                 if (unlikely(!nseg))
1807                         goto queuing_error;
1808                 else
1809                         sp->flags |= SRB_CRC_PROT_DMA_VALID;
1810
1811                 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1812                     (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
1813                         nseg = scsi_bufflen(cmd) / cmd->device->sector_size;
1814                 }
1815         } else {
1816                 nseg = 0;
1817         }
1818
1819         req_cnt = 1;
1820         /* Total Data and protection sg segment(s) */
1821         tot_prot_dsds = nseg;
1822         tot_dsds += nseg;
1823         if (req->cnt < (req_cnt + 2)) {
1824                 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
1825                     rd_reg_dword_relaxed(req->req_q_out);
1826                 if (req->ring_index < cnt)
1827                         req->cnt = cnt - req->ring_index;
1828                 else
1829                         req->cnt = req->length -
1830                                 (req->ring_index - cnt);
1831                 if (req->cnt < (req_cnt + 2))
1832                         goto queuing_error;
1833         }
1834
1835         status |= QDSS_GOT_Q_SPACE;
1836
1837         /* Build header part of command packet (excluding the OPCODE). */
1838         req->current_outstanding_cmd = handle;
1839         req->outstanding_cmds[handle] = sp;
1840         sp->handle = handle;
1841         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
1842         req->cnt -= req_cnt;
1843
1844         /* Fill-in common area */
1845         cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr;
1846         cmd_pkt->handle = make_handle(req->id, handle);
1847
1848         clr_ptr = (uint32_t *)cmd_pkt + 2;
1849         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1850
1851         /* Set NPORT-ID and LUN number*/
1852         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1853         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
1854         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
1855         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
1856
1857         int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1858         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1859
1860         /* Total Data and protection segment(s) */
1861         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1862
1863         /* Build IOCB segments and adjust for data protection segments */
1864         if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *)
1865             req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) !=
1866                 QLA_SUCCESS)
1867                 goto queuing_error;
1868
1869         cmd_pkt->entry_count = (uint8_t)req_cnt;
1870         /* Specify response queue number where completion should happen */
1871         cmd_pkt->entry_status = (uint8_t) rsp->id;
1872         cmd_pkt->timeout = cpu_to_le16(0);
1873         wmb();
1874
1875         /* Adjust ring index. */
1876         req->ring_index++;
1877         if (req->ring_index == req->length) {
1878                 req->ring_index = 0;
1879                 req->ring_ptr = req->ring;
1880         } else
1881                 req->ring_ptr++;
1882
1883         /* Set chip new ring index. */
1884         wrt_reg_dword(req->req_q_in, req->ring_index);
1885
1886         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1887
1888         return QLA_SUCCESS;
1889
1890 queuing_error:
1891         if (status & QDSS_GOT_Q_SPACE) {
1892                 req->outstanding_cmds[handle] = NULL;
1893                 req->cnt += req_cnt;
1894         }
1895         /* Cleanup will be performed by the caller (queuecommand) */
1896
1897         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1898         return QLA_FUNCTION_FAILED;
1899 }
1900
1901 /**
1902  * qla2xxx_start_scsi_mq() - Send a SCSI command to the ISP
1903  * @sp: command to send to the ISP
1904  *
1905  * Returns non-zero if a failure occurred, else zero.
1906  */
1907 static int
1908 qla2xxx_start_scsi_mq(srb_t *sp)
1909 {
1910         int             nseg;
1911         unsigned long   flags;
1912         uint32_t        *clr_ptr;
1913         uint32_t        handle;
1914         struct cmd_type_7 *cmd_pkt;
1915         uint16_t        cnt;
1916         uint16_t        req_cnt;
1917         uint16_t        tot_dsds;
1918         struct req_que *req = NULL;
1919         struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1920         struct scsi_qla_host *vha = sp->fcport->vha;
1921         struct qla_hw_data *ha = vha->hw;
1922         struct qla_qpair *qpair = sp->qpair;
1923
1924         /* Acquire qpair specific lock */
1925         spin_lock_irqsave(&qpair->qp_lock, flags);
1926
1927         /* Setup qpair pointers */
1928         req = qpair->req;
1929
1930         /* So we know we haven't pci_map'ed anything yet */
1931         tot_dsds = 0;
1932
1933         /* Send marker if required */
1934         if (vha->marker_needed != 0) {
1935                 if (__qla2x00_marker(vha, qpair, 0, 0, MK_SYNC_ALL) !=
1936                     QLA_SUCCESS) {
1937                         spin_unlock_irqrestore(&qpair->qp_lock, flags);
1938                         return QLA_FUNCTION_FAILED;
1939                 }
1940                 vha->marker_needed = 0;
1941         }
1942
1943         handle = qla2xxx_get_next_handle(req);
1944         if (handle == 0)
1945                 goto queuing_error;
1946
1947         /* Map the sg table so we have an accurate count of sg entries needed */
1948         if (scsi_sg_count(cmd)) {
1949                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
1950                     scsi_sg_count(cmd), cmd->sc_data_direction);
1951                 if (unlikely(!nseg))
1952                         goto queuing_error;
1953         } else
1954                 nseg = 0;
1955
1956         tot_dsds = nseg;
1957         req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
1958         if (req->cnt < (req_cnt + 2)) {
1959                 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
1960                     rd_reg_dword_relaxed(req->req_q_out);
1961                 if (req->ring_index < cnt)
1962                         req->cnt = cnt - req->ring_index;
1963                 else
1964                         req->cnt = req->length -
1965                                 (req->ring_index - cnt);
1966                 if (req->cnt < (req_cnt + 2))
1967                         goto queuing_error;
1968         }
1969
1970         /* Build command packet. */
1971         req->current_outstanding_cmd = handle;
1972         req->outstanding_cmds[handle] = sp;
1973         sp->handle = handle;
1974         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
1975         req->cnt -= req_cnt;
1976
1977         cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
1978         cmd_pkt->handle = make_handle(req->id, handle);
1979
1980         /* Zero out remaining portion of packet. */
1981         /*    tagged queuing modifier -- default is TSK_SIMPLE (0). */
1982         clr_ptr = (uint32_t *)cmd_pkt + 2;
1983         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1984         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1985
1986         /* Set NPORT-ID and LUN number*/
1987         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1988         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
1989         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
1990         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
1991         cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
1992
1993         int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1994         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1995
1996         cmd_pkt->task = TSK_SIMPLE;
1997
1998         /* Load SCSI command packet. */
1999         memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
2000         host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
2001
2002         cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
2003
2004         /* Build IOCB segments */
2005         qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req);
2006
2007         /* Set total data segment count. */
2008         cmd_pkt->entry_count = (uint8_t)req_cnt;
2009         wmb();
2010         /* Adjust ring index. */
2011         req->ring_index++;
2012         if (req->ring_index == req->length) {
2013                 req->ring_index = 0;
2014                 req->ring_ptr = req->ring;
2015         } else
2016                 req->ring_ptr++;
2017
2018         sp->flags |= SRB_DMA_VALID;
2019
2020         /* Set chip new ring index. */
2021         wrt_reg_dword(req->req_q_in, req->ring_index);
2022
2023         spin_unlock_irqrestore(&qpair->qp_lock, flags);
2024         return QLA_SUCCESS;
2025
2026 queuing_error:
2027         if (tot_dsds)
2028                 scsi_dma_unmap(cmd);
2029
2030         spin_unlock_irqrestore(&qpair->qp_lock, flags);
2031
2032         return QLA_FUNCTION_FAILED;
2033 }
2034
2035
2036 /**
2037  * qla2xxx_dif_start_scsi_mq() - Send a SCSI command to the ISP
2038  * @sp: command to send to the ISP
2039  *
2040  * Returns non-zero if a failure occurred, else zero.
2041  */
2042 int
2043 qla2xxx_dif_start_scsi_mq(srb_t *sp)
2044 {
2045         int                     nseg;
2046         unsigned long           flags;
2047         uint32_t                *clr_ptr;
2048         uint32_t                handle;
2049         uint16_t                cnt;
2050         uint16_t                req_cnt = 0;
2051         uint16_t                tot_dsds;
2052         uint16_t                tot_prot_dsds;
2053         uint16_t                fw_prot_opts = 0;
2054         struct req_que          *req = NULL;
2055         struct rsp_que          *rsp = NULL;
2056         struct scsi_cmnd        *cmd = GET_CMD_SP(sp);
2057         struct scsi_qla_host    *vha = sp->fcport->vha;
2058         struct qla_hw_data      *ha = vha->hw;
2059         struct cmd_type_crc_2   *cmd_pkt;
2060         uint32_t                status = 0;
2061         struct qla_qpair        *qpair = sp->qpair;
2062
2063 #define QDSS_GOT_Q_SPACE        BIT_0
2064
2065         /* Check for host side state */
2066         if (!qpair->online) {
2067                 cmd->result = DID_NO_CONNECT << 16;
2068                 return QLA_INTERFACE_ERROR;
2069         }
2070
2071         if (!qpair->difdix_supported &&
2072                 scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
2073                 cmd->result = DID_NO_CONNECT << 16;
2074                 return QLA_INTERFACE_ERROR;
2075         }
2076
2077         /* Only process protection or >16 cdb in this routine */
2078         if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) {
2079                 if (cmd->cmd_len <= 16)
2080                         return qla2xxx_start_scsi_mq(sp);
2081         }
2082
2083         spin_lock_irqsave(&qpair->qp_lock, flags);
2084
2085         /* Setup qpair pointers */
2086         rsp = qpair->rsp;
2087         req = qpair->req;
2088
2089         /* So we know we haven't pci_map'ed anything yet */
2090         tot_dsds = 0;
2091
2092         /* Send marker if required */
2093         if (vha->marker_needed != 0) {
2094                 if (__qla2x00_marker(vha, qpair, 0, 0, MK_SYNC_ALL) !=
2095                     QLA_SUCCESS) {
2096                         spin_unlock_irqrestore(&qpair->qp_lock, flags);
2097                         return QLA_FUNCTION_FAILED;
2098                 }
2099                 vha->marker_needed = 0;
2100         }
2101
2102         handle = qla2xxx_get_next_handle(req);
2103         if (handle == 0)
2104                 goto queuing_error;
2105
2106         /* Compute number of required data segments */
2107         /* Map the sg table so we have an accurate count of sg entries needed */
2108         if (scsi_sg_count(cmd)) {
2109                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
2110                     scsi_sg_count(cmd), cmd->sc_data_direction);
2111                 if (unlikely(!nseg))
2112                         goto queuing_error;
2113                 else
2114                         sp->flags |= SRB_DMA_VALID;
2115
2116                 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
2117                     (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
2118                         struct qla2_sgx sgx;
2119                         uint32_t        partial;
2120
2121                         memset(&sgx, 0, sizeof(struct qla2_sgx));
2122                         sgx.tot_bytes = scsi_bufflen(cmd);
2123                         sgx.cur_sg = scsi_sglist(cmd);
2124                         sgx.sp = sp;
2125
2126                         nseg = 0;
2127                         while (qla24xx_get_one_block_sg(
2128                             cmd->device->sector_size, &sgx, &partial))
2129                                 nseg++;
2130                 }
2131         } else
2132                 nseg = 0;
2133
2134         /* number of required data segments */
2135         tot_dsds = nseg;
2136
2137         /* Compute number of required protection segments */
2138         if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) {
2139                 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
2140                     scsi_prot_sg_count(cmd), cmd->sc_data_direction);
2141                 if (unlikely(!nseg))
2142                         goto queuing_error;
2143                 else
2144                         sp->flags |= SRB_CRC_PROT_DMA_VALID;
2145
2146                 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
2147                     (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
2148                         nseg = scsi_bufflen(cmd) / cmd->device->sector_size;
2149                 }
2150         } else {
2151                 nseg = 0;
2152         }
2153
2154         req_cnt = 1;
2155         /* Total Data and protection sg segment(s) */
2156         tot_prot_dsds = nseg;
2157         tot_dsds += nseg;
2158         if (req->cnt < (req_cnt + 2)) {
2159                 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
2160                     rd_reg_dword_relaxed(req->req_q_out);
2161                 if (req->ring_index < cnt)
2162                         req->cnt = cnt - req->ring_index;
2163                 else
2164                         req->cnt = req->length -
2165                                 (req->ring_index - cnt);
2166                 if (req->cnt < (req_cnt + 2))
2167                         goto queuing_error;
2168         }
2169
2170         status |= QDSS_GOT_Q_SPACE;
2171
2172         /* Build header part of command packet (excluding the OPCODE). */
2173         req->current_outstanding_cmd = handle;
2174         req->outstanding_cmds[handle] = sp;
2175         sp->handle = handle;
2176         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
2177         req->cnt -= req_cnt;
2178
2179         /* Fill-in common area */
2180         cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr;
2181         cmd_pkt->handle = make_handle(req->id, handle);
2182
2183         clr_ptr = (uint32_t *)cmd_pkt + 2;
2184         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
2185
2186         /* Set NPORT-ID and LUN number*/
2187         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2188         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
2189         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
2190         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
2191
2192         int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
2193         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
2194
2195         /* Total Data and protection segment(s) */
2196         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
2197
2198         /* Build IOCB segments and adjust for data protection segments */
2199         if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *)
2200             req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) !=
2201                 QLA_SUCCESS)
2202                 goto queuing_error;
2203
2204         cmd_pkt->entry_count = (uint8_t)req_cnt;
2205         cmd_pkt->timeout = cpu_to_le16(0);
2206         wmb();
2207
2208         /* Adjust ring index. */
2209         req->ring_index++;
2210         if (req->ring_index == req->length) {
2211                 req->ring_index = 0;
2212                 req->ring_ptr = req->ring;
2213         } else
2214                 req->ring_ptr++;
2215
2216         /* Set chip new ring index. */
2217         wrt_reg_dword(req->req_q_in, req->ring_index);
2218
2219         /* Manage unprocessed RIO/ZIO commands in response queue. */
2220         if (vha->flags.process_response_queue &&
2221             rsp->ring_ptr->signature != RESPONSE_PROCESSED)
2222                 qla24xx_process_response_queue(vha, rsp);
2223
2224         spin_unlock_irqrestore(&qpair->qp_lock, flags);
2225
2226         return QLA_SUCCESS;
2227
2228 queuing_error:
2229         if (status & QDSS_GOT_Q_SPACE) {
2230                 req->outstanding_cmds[handle] = NULL;
2231                 req->cnt += req_cnt;
2232         }
2233         /* Cleanup will be performed by the caller (queuecommand) */
2234
2235         spin_unlock_irqrestore(&qpair->qp_lock, flags);
2236         return QLA_FUNCTION_FAILED;
2237 }
2238
2239 /* Generic Control-SRB manipulation functions. */
2240
2241 /* hardware_lock assumed to be held. */
2242
2243 void *
2244 __qla2x00_alloc_iocbs(struct qla_qpair *qpair, srb_t *sp)
2245 {
2246         scsi_qla_host_t *vha = qpair->vha;
2247         struct qla_hw_data *ha = vha->hw;
2248         struct req_que *req = qpair->req;
2249         device_reg_t *reg = ISP_QUE_REG(ha, req->id);
2250         uint32_t handle;
2251         request_t *pkt;
2252         uint16_t cnt, req_cnt;
2253
2254         pkt = NULL;
2255         req_cnt = 1;
2256         handle = 0;
2257
2258         if (sp && (sp->type != SRB_SCSI_CMD)) {
2259                 /* Adjust entry-counts as needed. */
2260                 req_cnt = sp->iocbs;
2261         }
2262
2263         /* Check for room on request queue. */
2264         if (req->cnt < req_cnt + 2) {
2265                 if (qpair->use_shadow_reg)
2266                         cnt = *req->out_ptr;
2267                 else if (ha->mqenable || IS_QLA83XX(ha) || IS_QLA27XX(ha) ||
2268                     IS_QLA28XX(ha))
2269                         cnt = rd_reg_dword(&reg->isp25mq.req_q_out);
2270                 else if (IS_P3P_TYPE(ha))
2271                         cnt = rd_reg_dword(reg->isp82.req_q_out);
2272                 else if (IS_FWI2_CAPABLE(ha))
2273                         cnt = rd_reg_dword(&reg->isp24.req_q_out);
2274                 else if (IS_QLAFX00(ha))
2275                         cnt = rd_reg_dword(&reg->ispfx00.req_q_out);
2276                 else
2277                         cnt = qla2x00_debounce_register(
2278                             ISP_REQ_Q_OUT(ha, &reg->isp));
2279
2280                 if  (req->ring_index < cnt)
2281                         req->cnt = cnt - req->ring_index;
2282                 else
2283                         req->cnt = req->length -
2284                             (req->ring_index - cnt);
2285         }
2286         if (req->cnt < req_cnt + 2)
2287                 goto queuing_error;
2288
2289         if (sp) {
2290                 handle = qla2xxx_get_next_handle(req);
2291                 if (handle == 0) {
2292                         ql_log(ql_log_warn, vha, 0x700b,
2293                             "No room on outstanding cmd array.\n");
2294                         goto queuing_error;
2295                 }
2296
2297                 /* Prep command array. */
2298                 req->current_outstanding_cmd = handle;
2299                 req->outstanding_cmds[handle] = sp;
2300                 sp->handle = handle;
2301         }
2302
2303         /* Prep packet */
2304         req->cnt -= req_cnt;
2305         pkt = req->ring_ptr;
2306         memset(pkt, 0, REQUEST_ENTRY_SIZE);
2307         if (IS_QLAFX00(ha)) {
2308                 wrt_reg_byte((u8 __force __iomem *)&pkt->entry_count, req_cnt);
2309                 wrt_reg_dword((__le32 __force __iomem *)&pkt->handle, handle);
2310         } else {
2311                 pkt->entry_count = req_cnt;
2312                 pkt->handle = handle;
2313         }
2314
2315         return pkt;
2316
2317 queuing_error:
2318         qpair->tgt_counters.num_alloc_iocb_failed++;
2319         return pkt;
2320 }
2321
2322 void *
2323 qla2x00_alloc_iocbs_ready(struct qla_qpair *qpair, srb_t *sp)
2324 {
2325         scsi_qla_host_t *vha = qpair->vha;
2326
2327         if (qla2x00_reset_active(vha))
2328                 return NULL;
2329
2330         return __qla2x00_alloc_iocbs(qpair, sp);
2331 }
2332
2333 void *
2334 qla2x00_alloc_iocbs(struct scsi_qla_host *vha, srb_t *sp)
2335 {
2336         return __qla2x00_alloc_iocbs(vha->hw->base_qpair, sp);
2337 }
2338
2339 static void
2340 qla24xx_prli_iocb(srb_t *sp, struct logio_entry_24xx *logio)
2341 {
2342         struct srb_iocb *lio = &sp->u.iocb_cmd;
2343
2344         logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2345         logio->control_flags = cpu_to_le16(LCF_COMMAND_PRLI);
2346         if (lio->u.logio.flags & SRB_LOGIN_NVME_PRLI) {
2347                 logio->control_flags |= cpu_to_le16(LCF_NVME_PRLI);
2348                 if (sp->vha->flags.nvme_first_burst)
2349                         logio->io_parameter[0] =
2350                                 cpu_to_le32(NVME_PRLI_SP_FIRST_BURST);
2351         }
2352
2353         logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2354         logio->port_id[0] = sp->fcport->d_id.b.al_pa;
2355         logio->port_id[1] = sp->fcport->d_id.b.area;
2356         logio->port_id[2] = sp->fcport->d_id.b.domain;
2357         logio->vp_index = sp->vha->vp_idx;
2358 }
2359
2360 static void
2361 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio)
2362 {
2363         struct srb_iocb *lio = &sp->u.iocb_cmd;
2364
2365         logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2366         logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI);
2367
2368         if (lio->u.logio.flags & SRB_LOGIN_PRLI_ONLY) {
2369                 logio->control_flags = cpu_to_le16(LCF_COMMAND_PRLI);
2370         } else {
2371                 logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI);
2372                 if (lio->u.logio.flags & SRB_LOGIN_COND_PLOGI)
2373                         logio->control_flags |= cpu_to_le16(LCF_COND_PLOGI);
2374                 if (lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI)
2375                         logio->control_flags |= cpu_to_le16(LCF_SKIP_PRLI);
2376         }
2377         logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2378         logio->port_id[0] = sp->fcport->d_id.b.al_pa;
2379         logio->port_id[1] = sp->fcport->d_id.b.area;
2380         logio->port_id[2] = sp->fcport->d_id.b.domain;
2381         logio->vp_index = sp->vha->vp_idx;
2382 }
2383
2384 static void
2385 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx)
2386 {
2387         struct qla_hw_data *ha = sp->vha->hw;
2388         struct srb_iocb *lio = &sp->u.iocb_cmd;
2389         uint16_t opts;
2390
2391         mbx->entry_type = MBX_IOCB_TYPE;
2392         SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
2393         mbx->mb0 = cpu_to_le16(MBC_LOGIN_FABRIC_PORT);
2394         opts = lio->u.logio.flags & SRB_LOGIN_COND_PLOGI ? BIT_0 : 0;
2395         opts |= lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI ? BIT_1 : 0;
2396         if (HAS_EXTENDED_IDS(ha)) {
2397                 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id);
2398                 mbx->mb10 = cpu_to_le16(opts);
2399         } else {
2400                 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts);
2401         }
2402         mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain);
2403         mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 |
2404             sp->fcport->d_id.b.al_pa);
2405         mbx->mb9 = cpu_to_le16(sp->vha->vp_idx);
2406 }
2407
2408 static void
2409 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio)
2410 {
2411         u16 control_flags = LCF_COMMAND_LOGO;
2412         logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2413
2414         if (sp->fcport->explicit_logout) {
2415                 control_flags |= LCF_EXPL_LOGO|LCF_FREE_NPORT;
2416         } else {
2417                 control_flags |= LCF_IMPL_LOGO;
2418
2419                 if (!sp->fcport->keep_nport_handle)
2420                         control_flags |= LCF_FREE_NPORT;
2421         }
2422
2423         logio->control_flags = cpu_to_le16(control_flags);
2424         logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2425         logio->port_id[0] = sp->fcport->d_id.b.al_pa;
2426         logio->port_id[1] = sp->fcport->d_id.b.area;
2427         logio->port_id[2] = sp->fcport->d_id.b.domain;
2428         logio->vp_index = sp->vha->vp_idx;
2429 }
2430
2431 static void
2432 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx)
2433 {
2434         struct qla_hw_data *ha = sp->vha->hw;
2435
2436         mbx->entry_type = MBX_IOCB_TYPE;
2437         SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
2438         mbx->mb0 = cpu_to_le16(MBC_LOGOUT_FABRIC_PORT);
2439         mbx->mb1 = HAS_EXTENDED_IDS(ha) ?
2440             cpu_to_le16(sp->fcport->loop_id) :
2441             cpu_to_le16(sp->fcport->loop_id << 8);
2442         mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain);
2443         mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 |
2444             sp->fcport->d_id.b.al_pa);
2445         mbx->mb9 = cpu_to_le16(sp->vha->vp_idx);
2446         /* Implicit: mbx->mbx10 = 0. */
2447 }
2448
2449 static void
2450 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio)
2451 {
2452         logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
2453         logio->control_flags = cpu_to_le16(LCF_COMMAND_ADISC);
2454         logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2455         logio->vp_index = sp->vha->vp_idx;
2456 }
2457
2458 static void
2459 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx)
2460 {
2461         struct qla_hw_data *ha = sp->vha->hw;
2462
2463         mbx->entry_type = MBX_IOCB_TYPE;
2464         SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
2465         mbx->mb0 = cpu_to_le16(MBC_GET_PORT_DATABASE);
2466         if (HAS_EXTENDED_IDS(ha)) {
2467                 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id);
2468                 mbx->mb10 = cpu_to_le16(BIT_0);
2469         } else {
2470                 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0);
2471         }
2472         mbx->mb2 = cpu_to_le16(MSW(ha->async_pd_dma));
2473         mbx->mb3 = cpu_to_le16(LSW(ha->async_pd_dma));
2474         mbx->mb6 = cpu_to_le16(MSW(MSD(ha->async_pd_dma)));
2475         mbx->mb7 = cpu_to_le16(LSW(MSD(ha->async_pd_dma)));
2476         mbx->mb9 = cpu_to_le16(sp->vha->vp_idx);
2477 }
2478
2479 static void
2480 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk)
2481 {
2482         uint32_t flags;
2483         uint64_t lun;
2484         struct fc_port *fcport = sp->fcport;
2485         scsi_qla_host_t *vha = fcport->vha;
2486         struct qla_hw_data *ha = vha->hw;
2487         struct srb_iocb *iocb = &sp->u.iocb_cmd;
2488         struct req_que *req = vha->req;
2489
2490         flags = iocb->u.tmf.flags;
2491         lun = iocb->u.tmf.lun;
2492
2493         tsk->entry_type = TSK_MGMT_IOCB_TYPE;
2494         tsk->entry_count = 1;
2495         tsk->handle = make_handle(req->id, tsk->handle);
2496         tsk->nport_handle = cpu_to_le16(fcport->loop_id);
2497         tsk->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2498         tsk->control_flags = cpu_to_le32(flags);
2499         tsk->port_id[0] = fcport->d_id.b.al_pa;
2500         tsk->port_id[1] = fcport->d_id.b.area;
2501         tsk->port_id[2] = fcport->d_id.b.domain;
2502         tsk->vp_index = fcport->vha->vp_idx;
2503
2504         if (flags == TCF_LUN_RESET) {
2505                 int_to_scsilun(lun, &tsk->lun);
2506                 host_to_fcp_swap((uint8_t *)&tsk->lun,
2507                         sizeof(tsk->lun));
2508         }
2509 }
2510
2511 void qla2x00_init_timer(srb_t *sp, unsigned long tmo)
2512 {
2513         timer_setup(&sp->u.iocb_cmd.timer, qla2x00_sp_timeout, 0);
2514         sp->u.iocb_cmd.timer.expires = jiffies + tmo * HZ;
2515         sp->free = qla2x00_sp_free;
2516         if (IS_QLAFX00(sp->vha->hw) && sp->type == SRB_FXIOCB_DCMD)
2517                 init_completion(&sp->u.iocb_cmd.u.fxiocb.fxiocb_comp);
2518         sp->start_timer = 1;
2519 }
2520
2521 static void qla2x00_els_dcmd_sp_free(srb_t *sp)
2522 {
2523         struct srb_iocb *elsio = &sp->u.iocb_cmd;
2524
2525         kfree(sp->fcport);
2526
2527         if (elsio->u.els_logo.els_logo_pyld)
2528                 dma_free_coherent(&sp->vha->hw->pdev->dev, DMA_POOL_SIZE,
2529                     elsio->u.els_logo.els_logo_pyld,
2530                     elsio->u.els_logo.els_logo_pyld_dma);
2531
2532         del_timer(&elsio->timer);
2533         qla2x00_rel_sp(sp);
2534 }
2535
2536 static void
2537 qla2x00_els_dcmd_iocb_timeout(void *data)
2538 {
2539         srb_t *sp = data;
2540         fc_port_t *fcport = sp->fcport;
2541         struct scsi_qla_host *vha = sp->vha;
2542         struct srb_iocb *lio = &sp->u.iocb_cmd;
2543         unsigned long flags = 0;
2544         int res, h;
2545
2546         ql_dbg(ql_dbg_io, vha, 0x3069,
2547             "%s Timeout, hdl=%x, portid=%02x%02x%02x\n",
2548             sp->name, sp->handle, fcport->d_id.b.domain, fcport->d_id.b.area,
2549             fcport->d_id.b.al_pa);
2550
2551         /* Abort the exchange */
2552         res = qla24xx_async_abort_cmd(sp, false);
2553         if (res) {
2554                 ql_dbg(ql_dbg_io, vha, 0x3070,
2555                     "mbx abort_command failed.\n");
2556                 spin_lock_irqsave(sp->qpair->qp_lock_ptr, flags);
2557                 for (h = 1; h < sp->qpair->req->num_outstanding_cmds; h++) {
2558                         if (sp->qpair->req->outstanding_cmds[h] == sp) {
2559                                 sp->qpair->req->outstanding_cmds[h] = NULL;
2560                                 break;
2561                         }
2562                 }
2563                 spin_unlock_irqrestore(sp->qpair->qp_lock_ptr, flags);
2564                 complete(&lio->u.els_logo.comp);
2565         } else {
2566                 ql_dbg(ql_dbg_io, vha, 0x3071,
2567                     "mbx abort_command success.\n");
2568         }
2569 }
2570
2571 static void qla2x00_els_dcmd_sp_done(srb_t *sp, int res)
2572 {
2573         fc_port_t *fcport = sp->fcport;
2574         struct srb_iocb *lio = &sp->u.iocb_cmd;
2575         struct scsi_qla_host *vha = sp->vha;
2576
2577         ql_dbg(ql_dbg_io, vha, 0x3072,
2578             "%s hdl=%x, portid=%02x%02x%02x done\n",
2579             sp->name, sp->handle, fcport->d_id.b.domain,
2580             fcport->d_id.b.area, fcport->d_id.b.al_pa);
2581
2582         complete(&lio->u.els_logo.comp);
2583 }
2584
2585 int
2586 qla24xx_els_dcmd_iocb(scsi_qla_host_t *vha, int els_opcode,
2587     port_id_t remote_did)
2588 {
2589         srb_t *sp;
2590         fc_port_t *fcport = NULL;
2591         struct srb_iocb *elsio = NULL;
2592         struct qla_hw_data *ha = vha->hw;
2593         struct els_logo_payload logo_pyld;
2594         int rval = QLA_SUCCESS;
2595
2596         fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
2597         if (!fcport) {
2598                ql_log(ql_log_info, vha, 0x70e5, "fcport allocation failed\n");
2599                return -ENOMEM;
2600         }
2601
2602         /* Alloc SRB structure */
2603         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
2604         if (!sp) {
2605                 kfree(fcport);
2606                 ql_log(ql_log_info, vha, 0x70e6,
2607                  "SRB allocation failed\n");
2608                 return -ENOMEM;
2609         }
2610
2611         elsio = &sp->u.iocb_cmd;
2612         fcport->loop_id = 0xFFFF;
2613         fcport->d_id.b.domain = remote_did.b.domain;
2614         fcport->d_id.b.area = remote_did.b.area;
2615         fcport->d_id.b.al_pa = remote_did.b.al_pa;
2616
2617         ql_dbg(ql_dbg_io, vha, 0x3073, "portid=%02x%02x%02x done\n",
2618             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa);
2619
2620         sp->type = SRB_ELS_DCMD;
2621         sp->name = "ELS_DCMD";
2622         sp->fcport = fcport;
2623         elsio->timeout = qla2x00_els_dcmd_iocb_timeout;
2624         qla2x00_init_timer(sp, ELS_DCMD_TIMEOUT);
2625         init_completion(&sp->u.iocb_cmd.u.els_logo.comp);
2626         sp->done = qla2x00_els_dcmd_sp_done;
2627         sp->free = qla2x00_els_dcmd_sp_free;
2628
2629         elsio->u.els_logo.els_logo_pyld = dma_alloc_coherent(&ha->pdev->dev,
2630                             DMA_POOL_SIZE, &elsio->u.els_logo.els_logo_pyld_dma,
2631                             GFP_KERNEL);
2632
2633         if (!elsio->u.els_logo.els_logo_pyld) {
2634                 sp->free(sp);
2635                 return QLA_FUNCTION_FAILED;
2636         }
2637
2638         memset(&logo_pyld, 0, sizeof(struct els_logo_payload));
2639
2640         elsio->u.els_logo.els_cmd = els_opcode;
2641         logo_pyld.opcode = els_opcode;
2642         logo_pyld.s_id[0] = vha->d_id.b.al_pa;
2643         logo_pyld.s_id[1] = vha->d_id.b.area;
2644         logo_pyld.s_id[2] = vha->d_id.b.domain;
2645         host_to_fcp_swap(logo_pyld.s_id, sizeof(uint32_t));
2646         memcpy(&logo_pyld.wwpn, vha->port_name, WWN_SIZE);
2647
2648         memcpy(elsio->u.els_logo.els_logo_pyld, &logo_pyld,
2649             sizeof(struct els_logo_payload));
2650         ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x3075, "LOGO buffer:");
2651         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x010a,
2652                        elsio->u.els_logo.els_logo_pyld,
2653                        sizeof(*elsio->u.els_logo.els_logo_pyld));
2654
2655         rval = qla2x00_start_sp(sp);
2656         if (rval != QLA_SUCCESS) {
2657                 sp->free(sp);
2658                 return QLA_FUNCTION_FAILED;
2659         }
2660
2661         ql_dbg(ql_dbg_io, vha, 0x3074,
2662             "%s LOGO sent, hdl=%x, loopid=%x, portid=%02x%02x%02x.\n",
2663             sp->name, sp->handle, fcport->loop_id, fcport->d_id.b.domain,
2664             fcport->d_id.b.area, fcport->d_id.b.al_pa);
2665
2666         wait_for_completion(&elsio->u.els_logo.comp);
2667
2668         sp->free(sp);
2669         return rval;
2670 }
2671
2672 static void
2673 qla24xx_els_logo_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
2674 {
2675         scsi_qla_host_t *vha = sp->vha;
2676         struct srb_iocb *elsio = &sp->u.iocb_cmd;
2677
2678         els_iocb->entry_type = ELS_IOCB_TYPE;
2679         els_iocb->entry_count = 1;
2680         els_iocb->sys_define = 0;
2681         els_iocb->entry_status = 0;
2682         els_iocb->handle = sp->handle;
2683         els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2684         els_iocb->tx_dsd_count = cpu_to_le16(1);
2685         els_iocb->vp_index = vha->vp_idx;
2686         els_iocb->sof_type = EST_SOFI3;
2687         els_iocb->rx_dsd_count = 0;
2688         els_iocb->opcode = elsio->u.els_logo.els_cmd;
2689
2690         els_iocb->d_id[0] = sp->fcport->d_id.b.al_pa;
2691         els_iocb->d_id[1] = sp->fcport->d_id.b.area;
2692         els_iocb->d_id[2] = sp->fcport->d_id.b.domain;
2693         /* For SID the byte order is different than DID */
2694         els_iocb->s_id[1] = vha->d_id.b.al_pa;
2695         els_iocb->s_id[2] = vha->d_id.b.area;
2696         els_iocb->s_id[0] = vha->d_id.b.domain;
2697
2698         if (elsio->u.els_logo.els_cmd == ELS_DCMD_PLOGI) {
2699                 els_iocb->control_flags = 0;
2700                 els_iocb->tx_byte_count = els_iocb->tx_len =
2701                         cpu_to_le32(sizeof(struct els_plogi_payload));
2702                 put_unaligned_le64(elsio->u.els_plogi.els_plogi_pyld_dma,
2703                                    &els_iocb->tx_address);
2704                 els_iocb->rx_dsd_count = cpu_to_le16(1);
2705                 els_iocb->rx_byte_count = els_iocb->rx_len =
2706                         cpu_to_le32(sizeof(struct els_plogi_payload));
2707                 put_unaligned_le64(elsio->u.els_plogi.els_resp_pyld_dma,
2708                                    &els_iocb->rx_address);
2709
2710                 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x3073,
2711                     "PLOGI ELS IOCB:\n");
2712                 ql_dump_buffer(ql_log_info, vha, 0x0109,
2713                     (uint8_t *)els_iocb,
2714                     sizeof(*els_iocb));
2715         } else {
2716                 els_iocb->control_flags = cpu_to_le16(1 << 13);
2717                 els_iocb->tx_byte_count =
2718                         cpu_to_le32(sizeof(struct els_logo_payload));
2719                 put_unaligned_le64(elsio->u.els_logo.els_logo_pyld_dma,
2720                                    &els_iocb->tx_address);
2721                 els_iocb->tx_len = cpu_to_le32(sizeof(struct els_logo_payload));
2722
2723                 els_iocb->rx_byte_count = 0;
2724                 els_iocb->rx_address = 0;
2725                 els_iocb->rx_len = 0;
2726                 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x3076,
2727                        "LOGO ELS IOCB:");
2728                 ql_dump_buffer(ql_log_info, vha, 0x010b,
2729                                els_iocb,
2730                                sizeof(*els_iocb));
2731         }
2732
2733         sp->vha->qla_stats.control_requests++;
2734 }
2735
2736 static void
2737 qla2x00_els_dcmd2_iocb_timeout(void *data)
2738 {
2739         srb_t *sp = data;
2740         fc_port_t *fcport = sp->fcport;
2741         struct scsi_qla_host *vha = sp->vha;
2742         unsigned long flags = 0;
2743         int res, h;
2744
2745         ql_dbg(ql_dbg_io + ql_dbg_disc, vha, 0x3069,
2746             "%s hdl=%x ELS Timeout, %8phC portid=%06x\n",
2747             sp->name, sp->handle, fcport->port_name, fcport->d_id.b24);
2748
2749         /* Abort the exchange */
2750         res = qla24xx_async_abort_cmd(sp, false);
2751         ql_dbg(ql_dbg_io, vha, 0x3070,
2752             "mbx abort_command %s\n",
2753             (res == QLA_SUCCESS) ? "successful" : "failed");
2754         if (res) {
2755                 spin_lock_irqsave(sp->qpair->qp_lock_ptr, flags);
2756                 for (h = 1; h < sp->qpair->req->num_outstanding_cmds; h++) {
2757                         if (sp->qpair->req->outstanding_cmds[h] == sp) {
2758                                 sp->qpair->req->outstanding_cmds[h] = NULL;
2759                                 break;
2760                         }
2761                 }
2762                 spin_unlock_irqrestore(sp->qpair->qp_lock_ptr, flags);
2763                 sp->done(sp, QLA_FUNCTION_TIMEOUT);
2764         }
2765 }
2766
2767 void qla2x00_els_dcmd2_free(scsi_qla_host_t *vha, struct els_plogi *els_plogi)
2768 {
2769         if (els_plogi->els_plogi_pyld)
2770                 dma_free_coherent(&vha->hw->pdev->dev,
2771                                   els_plogi->tx_size,
2772                                   els_plogi->els_plogi_pyld,
2773                                   els_plogi->els_plogi_pyld_dma);
2774
2775         if (els_plogi->els_resp_pyld)
2776                 dma_free_coherent(&vha->hw->pdev->dev,
2777                                   els_plogi->rx_size,
2778                                   els_plogi->els_resp_pyld,
2779                                   els_plogi->els_resp_pyld_dma);
2780 }
2781
2782 static void qla2x00_els_dcmd2_sp_done(srb_t *sp, int res)
2783 {
2784         fc_port_t *fcport = sp->fcport;
2785         struct srb_iocb *lio = &sp->u.iocb_cmd;
2786         struct scsi_qla_host *vha = sp->vha;
2787         struct event_arg ea;
2788         struct qla_work_evt *e;
2789         struct fc_port *conflict_fcport;
2790         port_id_t cid;  /* conflict Nport id */
2791         const __le32 *fw_status = sp->u.iocb_cmd.u.els_plogi.fw_status;
2792         u16 lid;
2793
2794         ql_dbg(ql_dbg_disc, vha, 0x3072,
2795             "%s ELS done rc %d hdl=%x, portid=%06x %8phC\n",
2796             sp->name, res, sp->handle, fcport->d_id.b24, fcport->port_name);
2797
2798         fcport->flags &= ~(FCF_ASYNC_SENT|FCF_ASYNC_ACTIVE);
2799         del_timer(&sp->u.iocb_cmd.timer);
2800
2801         if (sp->flags & SRB_WAKEUP_ON_COMP)
2802                 complete(&lio->u.els_plogi.comp);
2803         else {
2804                 switch (le32_to_cpu(fw_status[0])) {
2805                 case CS_DATA_UNDERRUN:
2806                 case CS_COMPLETE:
2807                         memset(&ea, 0, sizeof(ea));
2808                         ea.fcport = fcport;
2809                         ea.rc = res;
2810                         qla_handle_els_plogi_done(vha, &ea);
2811                         break;
2812
2813                 case CS_IOCB_ERROR:
2814                         switch (le32_to_cpu(fw_status[1])) {
2815                         case LSC_SCODE_PORTID_USED:
2816                                 lid = le32_to_cpu(fw_status[2]) & 0xffff;
2817                                 qlt_find_sess_invalidate_other(vha,
2818                                     wwn_to_u64(fcport->port_name),
2819                                     fcport->d_id, lid, &conflict_fcport);
2820                                 if (conflict_fcport) {
2821                                         /*
2822                                          * Another fcport shares the same
2823                                          * loop_id & nport id; conflict
2824                                          * fcport needs to finish cleanup
2825                                          * before this fcport can proceed
2826                                          * to login.
2827                                          */
2828                                         conflict_fcport->conflict = fcport;
2829                                         fcport->login_pause = 1;
2830                                         ql_dbg(ql_dbg_disc, vha, 0x20ed,
2831                                             "%s %d %8phC pid %06x inuse with lid %#x post gidpn\n",
2832                                             __func__, __LINE__,
2833                                             fcport->port_name,
2834                                             fcport->d_id.b24, lid);
2835                                 } else {
2836                                         ql_dbg(ql_dbg_disc, vha, 0x20ed,
2837                                             "%s %d %8phC pid %06x inuse with lid %#x sched del\n",
2838                                             __func__, __LINE__,
2839                                             fcport->port_name,
2840                                             fcport->d_id.b24, lid);
2841                                         qla2x00_clear_loop_id(fcport);
2842                                         set_bit(lid, vha->hw->loop_id_map);
2843                                         fcport->loop_id = lid;
2844                                         fcport->keep_nport_handle = 0;
2845                                         qlt_schedule_sess_for_deletion(fcport);
2846                                 }
2847                                 break;
2848
2849                         case LSC_SCODE_NPORT_USED:
2850                                 cid.b.domain = (le32_to_cpu(fw_status[2]) >> 16)
2851                                         & 0xff;
2852                                 cid.b.area   = (le32_to_cpu(fw_status[2]) >>  8)
2853                                         & 0xff;
2854                                 cid.b.al_pa  = le32_to_cpu(fw_status[2]) & 0xff;
2855                                 cid.b.rsvd_1 = 0;
2856
2857                                 ql_dbg(ql_dbg_disc, vha, 0x20ec,
2858                                     "%s %d %8phC lid %#x in use with pid %06x post gnl\n",
2859                                     __func__, __LINE__, fcport->port_name,
2860                                     fcport->loop_id, cid.b24);
2861                                 set_bit(fcport->loop_id,
2862                                     vha->hw->loop_id_map);
2863                                 fcport->loop_id = FC_NO_LOOP_ID;
2864                                 qla24xx_post_gnl_work(vha, fcport);
2865                                 break;
2866
2867                         case LSC_SCODE_NOXCB:
2868                                 vha->hw->exch_starvation++;
2869                                 if (vha->hw->exch_starvation > 5) {
2870                                         ql_log(ql_log_warn, vha, 0xd046,
2871                                             "Exchange starvation. Resetting RISC\n");
2872                                         vha->hw->exch_starvation = 0;
2873                                         set_bit(ISP_ABORT_NEEDED,
2874                                             &vha->dpc_flags);
2875                                         qla2xxx_wake_dpc(vha);
2876                                 }
2877                                 fallthrough;
2878                         default:
2879                                 ql_dbg(ql_dbg_disc, vha, 0x20eb,
2880                                     "%s %8phC cmd error fw_status 0x%x 0x%x 0x%x\n",
2881                                     __func__, sp->fcport->port_name,
2882                                     fw_status[0], fw_status[1], fw_status[2]);
2883
2884                                 fcport->flags &= ~FCF_ASYNC_SENT;
2885                                 qla2x00_set_fcport_disc_state(fcport,
2886                                     DSC_LOGIN_FAILED);
2887                                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
2888                                 break;
2889                         }
2890                         break;
2891
2892                 default:
2893                         ql_dbg(ql_dbg_disc, vha, 0x20eb,
2894                             "%s %8phC cmd error 2 fw_status 0x%x 0x%x 0x%x\n",
2895                             __func__, sp->fcport->port_name,
2896                             fw_status[0], fw_status[1], fw_status[2]);
2897
2898                         sp->fcport->flags &= ~FCF_ASYNC_SENT;
2899                         qla2x00_set_fcport_disc_state(fcport, DSC_LOGIN_FAILED);
2900                         set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
2901                         break;
2902                 }
2903
2904                 e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
2905                 if (!e) {
2906                         struct srb_iocb *elsio = &sp->u.iocb_cmd;
2907
2908                         qla2x00_els_dcmd2_free(vha, &elsio->u.els_plogi);
2909                         sp->free(sp);
2910                         return;
2911                 }
2912                 e->u.iosb.sp = sp;
2913                 qla2x00_post_work(vha, e);
2914         }
2915 }
2916
2917 int
2918 qla24xx_els_dcmd2_iocb(scsi_qla_host_t *vha, int els_opcode,
2919     fc_port_t *fcport, bool wait)
2920 {
2921         srb_t *sp;
2922         struct srb_iocb *elsio = NULL;
2923         struct qla_hw_data *ha = vha->hw;
2924         int rval = QLA_SUCCESS;
2925         void    *ptr, *resp_ptr;
2926
2927         /* Alloc SRB structure */
2928         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
2929         if (!sp) {
2930                 ql_log(ql_log_info, vha, 0x70e6,
2931                  "SRB allocation failed\n");
2932                 fcport->flags &= ~FCF_ASYNC_ACTIVE;
2933                 return -ENOMEM;
2934         }
2935
2936         fcport->flags |= FCF_ASYNC_SENT;
2937         qla2x00_set_fcport_disc_state(fcport, DSC_LOGIN_PEND);
2938         elsio = &sp->u.iocb_cmd;
2939         ql_dbg(ql_dbg_io, vha, 0x3073,
2940             "Enter: PLOGI portid=%06x\n", fcport->d_id.b24);
2941
2942         sp->type = SRB_ELS_DCMD;
2943         sp->name = "ELS_DCMD";
2944         sp->fcport = fcport;
2945
2946         elsio->timeout = qla2x00_els_dcmd2_iocb_timeout;
2947         if (wait)
2948                 sp->flags = SRB_WAKEUP_ON_COMP;
2949
2950         qla2x00_init_timer(sp, ELS_DCMD_TIMEOUT + 2);
2951
2952         sp->done = qla2x00_els_dcmd2_sp_done;
2953         elsio->u.els_plogi.tx_size = elsio->u.els_plogi.rx_size = DMA_POOL_SIZE;
2954
2955         ptr = elsio->u.els_plogi.els_plogi_pyld =
2956             dma_alloc_coherent(&ha->pdev->dev, elsio->u.els_plogi.tx_size,
2957                 &elsio->u.els_plogi.els_plogi_pyld_dma, GFP_KERNEL);
2958
2959         if (!elsio->u.els_plogi.els_plogi_pyld) {
2960                 rval = QLA_FUNCTION_FAILED;
2961                 goto out;
2962         }
2963
2964         resp_ptr = elsio->u.els_plogi.els_resp_pyld =
2965             dma_alloc_coherent(&ha->pdev->dev, elsio->u.els_plogi.rx_size,
2966                 &elsio->u.els_plogi.els_resp_pyld_dma, GFP_KERNEL);
2967
2968         if (!elsio->u.els_plogi.els_resp_pyld) {
2969                 rval = QLA_FUNCTION_FAILED;
2970                 goto out;
2971         }
2972
2973         ql_dbg(ql_dbg_io, vha, 0x3073, "PLOGI %p %p\n", ptr, resp_ptr);
2974
2975         memset(ptr, 0, sizeof(struct els_plogi_payload));
2976         memset(resp_ptr, 0, sizeof(struct els_plogi_payload));
2977         memcpy(elsio->u.els_plogi.els_plogi_pyld->data,
2978             &ha->plogi_els_payld.data,
2979             sizeof(elsio->u.els_plogi.els_plogi_pyld->data));
2980
2981         elsio->u.els_plogi.els_cmd = els_opcode;
2982         elsio->u.els_plogi.els_plogi_pyld->opcode = els_opcode;
2983
2984         ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x3073, "PLOGI buffer:\n");
2985         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x0109,
2986             (uint8_t *)elsio->u.els_plogi.els_plogi_pyld,
2987             sizeof(*elsio->u.els_plogi.els_plogi_pyld));
2988
2989         init_completion(&elsio->u.els_plogi.comp);
2990         rval = qla2x00_start_sp(sp);
2991         if (rval != QLA_SUCCESS) {
2992                 rval = QLA_FUNCTION_FAILED;
2993         } else {
2994                 ql_dbg(ql_dbg_disc, vha, 0x3074,
2995                     "%s PLOGI sent, hdl=%x, loopid=%x, to port_id %06x from port_id %06x\n",
2996                     sp->name, sp->handle, fcport->loop_id,
2997                     fcport->d_id.b24, vha->d_id.b24);
2998         }
2999
3000         if (wait) {
3001                 wait_for_completion(&elsio->u.els_plogi.comp);
3002
3003                 if (elsio->u.els_plogi.comp_status != CS_COMPLETE)
3004                         rval = QLA_FUNCTION_FAILED;
3005         } else {
3006                 goto done;
3007         }
3008
3009 out:
3010         fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
3011         qla2x00_els_dcmd2_free(vha, &elsio->u.els_plogi);
3012         sp->free(sp);
3013 done:
3014         return rval;
3015 }
3016
3017 static void
3018 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
3019 {
3020         struct bsg_job *bsg_job = sp->u.bsg_job;
3021         struct fc_bsg_request *bsg_request = bsg_job->request;
3022
3023         els_iocb->entry_type = ELS_IOCB_TYPE;
3024         els_iocb->entry_count = 1;
3025         els_iocb->sys_define = 0;
3026         els_iocb->entry_status = 0;
3027         els_iocb->handle = sp->handle;
3028         els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3029         els_iocb->tx_dsd_count = cpu_to_le16(bsg_job->request_payload.sg_cnt);
3030         els_iocb->vp_index = sp->vha->vp_idx;
3031         els_iocb->sof_type = EST_SOFI3;
3032         els_iocb->rx_dsd_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt);
3033
3034         els_iocb->opcode =
3035             sp->type == SRB_ELS_CMD_RPT ?
3036             bsg_request->rqst_data.r_els.els_code :
3037             bsg_request->rqst_data.h_els.command_code;
3038         els_iocb->d_id[0] = sp->fcport->d_id.b.al_pa;
3039         els_iocb->d_id[1] = sp->fcport->d_id.b.area;
3040         els_iocb->d_id[2] = sp->fcport->d_id.b.domain;
3041         els_iocb->control_flags = 0;
3042         els_iocb->rx_byte_count =
3043             cpu_to_le32(bsg_job->reply_payload.payload_len);
3044         els_iocb->tx_byte_count =
3045             cpu_to_le32(bsg_job->request_payload.payload_len);
3046
3047         put_unaligned_le64(sg_dma_address(bsg_job->request_payload.sg_list),
3048                            &els_iocb->tx_address);
3049         els_iocb->tx_len = cpu_to_le32(sg_dma_len
3050             (bsg_job->request_payload.sg_list));
3051
3052         put_unaligned_le64(sg_dma_address(bsg_job->reply_payload.sg_list),
3053                            &els_iocb->rx_address);
3054         els_iocb->rx_len = cpu_to_le32(sg_dma_len
3055             (bsg_job->reply_payload.sg_list));
3056
3057         sp->vha->qla_stats.control_requests++;
3058 }
3059
3060 static void
3061 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb)
3062 {
3063         uint16_t        avail_dsds;
3064         struct dsd64    *cur_dsd;
3065         struct scatterlist *sg;
3066         int index;
3067         uint16_t tot_dsds;
3068         scsi_qla_host_t *vha = sp->vha;
3069         struct qla_hw_data *ha = vha->hw;
3070         struct bsg_job *bsg_job = sp->u.bsg_job;
3071         int entry_count = 1;
3072
3073         memset(ct_iocb, 0, sizeof(ms_iocb_entry_t));
3074         ct_iocb->entry_type = CT_IOCB_TYPE;
3075         ct_iocb->entry_status = 0;
3076         ct_iocb->handle1 = sp->handle;
3077         SET_TARGET_ID(ha, ct_iocb->loop_id, sp->fcport->loop_id);
3078         ct_iocb->status = cpu_to_le16(0);
3079         ct_iocb->control_flags = cpu_to_le16(0);
3080         ct_iocb->timeout = 0;
3081         ct_iocb->cmd_dsd_count =
3082             cpu_to_le16(bsg_job->request_payload.sg_cnt);
3083         ct_iocb->total_dsd_count =
3084             cpu_to_le16(bsg_job->request_payload.sg_cnt + 1);
3085         ct_iocb->req_bytecount =
3086             cpu_to_le32(bsg_job->request_payload.payload_len);
3087         ct_iocb->rsp_bytecount =
3088             cpu_to_le32(bsg_job->reply_payload.payload_len);
3089
3090         put_unaligned_le64(sg_dma_address(bsg_job->request_payload.sg_list),
3091                            &ct_iocb->req_dsd.address);
3092         ct_iocb->req_dsd.length = ct_iocb->req_bytecount;
3093
3094         put_unaligned_le64(sg_dma_address(bsg_job->reply_payload.sg_list),
3095                            &ct_iocb->rsp_dsd.address);
3096         ct_iocb->rsp_dsd.length = ct_iocb->rsp_bytecount;
3097
3098         avail_dsds = 1;
3099         cur_dsd = &ct_iocb->rsp_dsd;
3100         index = 0;
3101         tot_dsds = bsg_job->reply_payload.sg_cnt;
3102
3103         for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
3104                 cont_a64_entry_t *cont_pkt;
3105
3106                 /* Allocate additional continuation packets? */
3107                 if (avail_dsds == 0) {
3108                         /*
3109                         * Five DSDs are available in the Cont.
3110                         * Type 1 IOCB.
3111                                */
3112                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha,
3113                             vha->hw->req_q_map[0]);
3114                         cur_dsd = cont_pkt->dsd;
3115                         avail_dsds = 5;
3116                         entry_count++;
3117                 }
3118
3119                 append_dsd64(&cur_dsd, sg);
3120                 avail_dsds--;
3121         }
3122         ct_iocb->entry_count = entry_count;
3123
3124         sp->vha->qla_stats.control_requests++;
3125 }
3126
3127 static void
3128 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb)
3129 {
3130         uint16_t        avail_dsds;
3131         struct dsd64    *cur_dsd;
3132         struct scatterlist *sg;
3133         int index;
3134         uint16_t cmd_dsds, rsp_dsds;
3135         scsi_qla_host_t *vha = sp->vha;
3136         struct qla_hw_data *ha = vha->hw;
3137         struct bsg_job *bsg_job = sp->u.bsg_job;
3138         int entry_count = 1;
3139         cont_a64_entry_t *cont_pkt = NULL;
3140
3141         ct_iocb->entry_type = CT_IOCB_TYPE;
3142         ct_iocb->entry_status = 0;
3143         ct_iocb->sys_define = 0;
3144         ct_iocb->handle = sp->handle;
3145
3146         ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3147         ct_iocb->vp_index = sp->vha->vp_idx;
3148         ct_iocb->comp_status = cpu_to_le16(0);
3149
3150         cmd_dsds = bsg_job->request_payload.sg_cnt;
3151         rsp_dsds = bsg_job->reply_payload.sg_cnt;
3152
3153         ct_iocb->cmd_dsd_count = cpu_to_le16(cmd_dsds);
3154         ct_iocb->timeout = 0;
3155         ct_iocb->rsp_dsd_count = cpu_to_le16(rsp_dsds);
3156         ct_iocb->cmd_byte_count =
3157             cpu_to_le32(bsg_job->request_payload.payload_len);
3158
3159         avail_dsds = 2;
3160         cur_dsd = ct_iocb->dsd;
3161         index = 0;
3162
3163         for_each_sg(bsg_job->request_payload.sg_list, sg, cmd_dsds, index) {
3164                 /* Allocate additional continuation packets? */
3165                 if (avail_dsds == 0) {
3166                         /*
3167                          * Five DSDs are available in the Cont.
3168                          * Type 1 IOCB.
3169                          */
3170                         cont_pkt = qla2x00_prep_cont_type1_iocb(
3171                             vha, ha->req_q_map[0]);
3172                         cur_dsd = cont_pkt->dsd;
3173                         avail_dsds = 5;
3174                         entry_count++;
3175                 }
3176
3177                 append_dsd64(&cur_dsd, sg);
3178                 avail_dsds--;
3179         }
3180
3181         index = 0;
3182
3183         for_each_sg(bsg_job->reply_payload.sg_list, sg, rsp_dsds, index) {
3184                 /* Allocate additional continuation packets? */
3185                 if (avail_dsds == 0) {
3186                         /*
3187                         * Five DSDs are available in the Cont.
3188                         * Type 1 IOCB.
3189                                */
3190                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha,
3191                             ha->req_q_map[0]);
3192                         cur_dsd = cont_pkt->dsd;
3193                         avail_dsds = 5;
3194                         entry_count++;
3195                 }
3196
3197                 append_dsd64(&cur_dsd, sg);
3198                 avail_dsds--;
3199         }
3200         ct_iocb->entry_count = entry_count;
3201 }
3202
3203 /*
3204  * qla82xx_start_scsi() - Send a SCSI command to the ISP
3205  * @sp: command to send to the ISP
3206  *
3207  * Returns non-zero if a failure occurred, else zero.
3208  */
3209 int
3210 qla82xx_start_scsi(srb_t *sp)
3211 {
3212         int             nseg;
3213         unsigned long   flags;
3214         struct scsi_cmnd *cmd;
3215         uint32_t        *clr_ptr;
3216         uint32_t        handle;
3217         uint16_t        cnt;
3218         uint16_t        req_cnt;
3219         uint16_t        tot_dsds;
3220         struct device_reg_82xx __iomem *reg;
3221         uint32_t dbval;
3222         __be32 *fcp_dl;
3223         uint8_t additional_cdb_len;
3224         struct ct6_dsd *ctx;
3225         struct scsi_qla_host *vha = sp->vha;
3226         struct qla_hw_data *ha = vha->hw;
3227         struct req_que *req = NULL;
3228         struct rsp_que *rsp = NULL;
3229
3230         /* Setup device pointers. */
3231         reg = &ha->iobase->isp82;
3232         cmd = GET_CMD_SP(sp);
3233         req = vha->req;
3234         rsp = ha->rsp_q_map[0];
3235
3236         /* So we know we haven't pci_map'ed anything yet */
3237         tot_dsds = 0;
3238
3239         dbval = 0x04 | (ha->portnum << 5);
3240
3241         /* Send marker if required */
3242         if (vha->marker_needed != 0) {
3243                 if (qla2x00_marker(vha, ha->base_qpair,
3244                         0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
3245                         ql_log(ql_log_warn, vha, 0x300c,
3246                             "qla2x00_marker failed for cmd=%p.\n", cmd);
3247                         return QLA_FUNCTION_FAILED;
3248                 }
3249                 vha->marker_needed = 0;
3250         }
3251
3252         /* Acquire ring specific lock */
3253         spin_lock_irqsave(&ha->hardware_lock, flags);
3254
3255         handle = qla2xxx_get_next_handle(req);
3256         if (handle == 0)
3257                 goto queuing_error;
3258
3259         /* Map the sg table so we have an accurate count of sg entries needed */
3260         if (scsi_sg_count(cmd)) {
3261                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
3262                     scsi_sg_count(cmd), cmd->sc_data_direction);
3263                 if (unlikely(!nseg))
3264                         goto queuing_error;
3265         } else
3266                 nseg = 0;
3267
3268         tot_dsds = nseg;
3269
3270         if (tot_dsds > ql2xshiftctondsd) {
3271                 struct cmd_type_6 *cmd_pkt;
3272                 uint16_t more_dsd_lists = 0;
3273                 struct dsd_dma *dsd_ptr;
3274                 uint16_t i;
3275
3276                 more_dsd_lists = qla24xx_calc_dsd_lists(tot_dsds);
3277                 if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN) {
3278                         ql_dbg(ql_dbg_io, vha, 0x300d,
3279                             "Num of DSD list %d is than %d for cmd=%p.\n",
3280                             more_dsd_lists + ha->gbl_dsd_inuse, NUM_DSD_CHAIN,
3281                             cmd);
3282                         goto queuing_error;
3283                 }
3284
3285                 if (more_dsd_lists <= ha->gbl_dsd_avail)
3286                         goto sufficient_dsds;
3287                 else
3288                         more_dsd_lists -= ha->gbl_dsd_avail;
3289
3290                 for (i = 0; i < more_dsd_lists; i++) {
3291                         dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
3292                         if (!dsd_ptr) {
3293                                 ql_log(ql_log_fatal, vha, 0x300e,
3294                                     "Failed to allocate memory for dsd_dma "
3295                                     "for cmd=%p.\n", cmd);
3296                                 goto queuing_error;
3297                         }
3298
3299                         dsd_ptr->dsd_addr = dma_pool_alloc(ha->dl_dma_pool,
3300                                 GFP_ATOMIC, &dsd_ptr->dsd_list_dma);
3301                         if (!dsd_ptr->dsd_addr) {
3302                                 kfree(dsd_ptr);
3303                                 ql_log(ql_log_fatal, vha, 0x300f,
3304                                     "Failed to allocate memory for dsd_addr "
3305                                     "for cmd=%p.\n", cmd);
3306                                 goto queuing_error;
3307                         }
3308                         list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list);
3309                         ha->gbl_dsd_avail++;
3310                 }
3311
3312 sufficient_dsds:
3313                 req_cnt = 1;
3314
3315                 if (req->cnt < (req_cnt + 2)) {
3316                         cnt = (uint16_t)rd_reg_dword_relaxed(
3317                                 &reg->req_q_out[0]);
3318                         if (req->ring_index < cnt)
3319                                 req->cnt = cnt - req->ring_index;
3320                         else
3321                                 req->cnt = req->length -
3322                                         (req->ring_index - cnt);
3323                         if (req->cnt < (req_cnt + 2))
3324                                 goto queuing_error;
3325                 }
3326
3327                 ctx = sp->u.scmd.ct6_ctx =
3328                     mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
3329                 if (!ctx) {
3330                         ql_log(ql_log_fatal, vha, 0x3010,
3331                             "Failed to allocate ctx for cmd=%p.\n", cmd);
3332                         goto queuing_error;
3333                 }
3334
3335                 memset(ctx, 0, sizeof(struct ct6_dsd));
3336                 ctx->fcp_cmnd = dma_pool_zalloc(ha->fcp_cmnd_dma_pool,
3337                         GFP_ATOMIC, &ctx->fcp_cmnd_dma);
3338                 if (!ctx->fcp_cmnd) {
3339                         ql_log(ql_log_fatal, vha, 0x3011,
3340                             "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd);
3341                         goto queuing_error;
3342                 }
3343
3344                 /* Initialize the DSD list and dma handle */
3345                 INIT_LIST_HEAD(&ctx->dsd_list);
3346                 ctx->dsd_use_cnt = 0;
3347
3348                 if (cmd->cmd_len > 16) {
3349                         additional_cdb_len = cmd->cmd_len - 16;
3350                         if ((cmd->cmd_len % 4) != 0) {
3351                                 /* SCSI command bigger than 16 bytes must be
3352                                  * multiple of 4
3353                                  */
3354                                 ql_log(ql_log_warn, vha, 0x3012,
3355                                     "scsi cmd len %d not multiple of 4 "
3356                                     "for cmd=%p.\n", cmd->cmd_len, cmd);
3357                                 goto queuing_error_fcp_cmnd;
3358                         }
3359                         ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4;
3360                 } else {
3361                         additional_cdb_len = 0;
3362                         ctx->fcp_cmnd_len = 12 + 16 + 4;
3363                 }
3364
3365                 cmd_pkt = (struct cmd_type_6 *)req->ring_ptr;
3366                 cmd_pkt->handle = make_handle(req->id, handle);
3367
3368                 /* Zero out remaining portion of packet. */
3369                 /*    tagged queuing modifier -- default is TSK_SIMPLE (0). */
3370                 clr_ptr = (uint32_t *)cmd_pkt + 2;
3371                 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
3372                 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
3373
3374                 /* Set NPORT-ID and LUN number*/
3375                 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3376                 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
3377                 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
3378                 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
3379                 cmd_pkt->vp_index = sp->vha->vp_idx;
3380
3381                 /* Build IOCB segments */
3382                 if (qla24xx_build_scsi_type_6_iocbs(sp, cmd_pkt, tot_dsds))
3383                         goto queuing_error_fcp_cmnd;
3384
3385                 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
3386                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
3387
3388                 /* build FCP_CMND IU */
3389                 int_to_scsilun(cmd->device->lun, &ctx->fcp_cmnd->lun);
3390                 ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len;
3391
3392                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
3393                         ctx->fcp_cmnd->additional_cdb_len |= 1;
3394                 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
3395                         ctx->fcp_cmnd->additional_cdb_len |= 2;
3396
3397                 /* Populate the FCP_PRIO. */
3398                 if (ha->flags.fcp_prio_enabled)
3399                         ctx->fcp_cmnd->task_attribute |=
3400                             sp->fcport->fcp_prio << 3;
3401
3402                 memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
3403
3404                 fcp_dl = (__be32 *)(ctx->fcp_cmnd->cdb + 16 +
3405                     additional_cdb_len);
3406                 *fcp_dl = htonl((uint32_t)scsi_bufflen(cmd));
3407
3408                 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len);
3409                 put_unaligned_le64(ctx->fcp_cmnd_dma,
3410                                    &cmd_pkt->fcp_cmnd_dseg_address);
3411
3412                 sp->flags |= SRB_FCP_CMND_DMA_VALID;
3413                 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
3414                 /* Set total data segment count. */
3415                 cmd_pkt->entry_count = (uint8_t)req_cnt;
3416                 /* Specify response queue number where
3417                  * completion should happen
3418                  */
3419                 cmd_pkt->entry_status = (uint8_t) rsp->id;
3420         } else {
3421                 struct cmd_type_7 *cmd_pkt;
3422
3423                 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
3424                 if (req->cnt < (req_cnt + 2)) {
3425                         cnt = (uint16_t)rd_reg_dword_relaxed(
3426                             &reg->req_q_out[0]);
3427                         if (req->ring_index < cnt)
3428                                 req->cnt = cnt - req->ring_index;
3429                         else
3430                                 req->cnt = req->length -
3431                                         (req->ring_index - cnt);
3432                 }
3433                 if (req->cnt < (req_cnt + 2))
3434                         goto queuing_error;
3435
3436                 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
3437                 cmd_pkt->handle = make_handle(req->id, handle);
3438
3439                 /* Zero out remaining portion of packet. */
3440                 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/
3441                 clr_ptr = (uint32_t *)cmd_pkt + 2;
3442                 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
3443                 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
3444
3445                 /* Set NPORT-ID and LUN number*/
3446                 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3447                 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
3448                 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
3449                 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
3450                 cmd_pkt->vp_index = sp->vha->vp_idx;
3451
3452                 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
3453                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun,
3454                     sizeof(cmd_pkt->lun));
3455
3456                 /* Populate the FCP_PRIO. */
3457                 if (ha->flags.fcp_prio_enabled)
3458                         cmd_pkt->task |= sp->fcport->fcp_prio << 3;
3459
3460                 /* Load SCSI command packet. */
3461                 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
3462                 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
3463
3464                 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
3465
3466                 /* Build IOCB segments */
3467                 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds, req);
3468
3469                 /* Set total data segment count. */
3470                 cmd_pkt->entry_count = (uint8_t)req_cnt;
3471                 /* Specify response queue number where
3472                  * completion should happen.
3473                  */
3474                 cmd_pkt->entry_status = (uint8_t) rsp->id;
3475
3476         }
3477         /* Build command packet. */
3478         req->current_outstanding_cmd = handle;
3479         req->outstanding_cmds[handle] = sp;
3480         sp->handle = handle;
3481         cmd->host_scribble = (unsigned char *)(unsigned long)handle;
3482         req->cnt -= req_cnt;
3483         wmb();
3484
3485         /* Adjust ring index. */
3486         req->ring_index++;
3487         if (req->ring_index == req->length) {
3488                 req->ring_index = 0;
3489                 req->ring_ptr = req->ring;
3490         } else
3491                 req->ring_ptr++;
3492
3493         sp->flags |= SRB_DMA_VALID;
3494
3495         /* Set chip new ring index. */
3496         /* write, read and verify logic */
3497         dbval = dbval | (req->id << 8) | (req->ring_index << 16);
3498         if (ql2xdbwr)
3499                 qla82xx_wr_32(ha, (uintptr_t __force)ha->nxdb_wr_ptr, dbval);
3500         else {
3501                 wrt_reg_dword(ha->nxdb_wr_ptr, dbval);
3502                 wmb();
3503                 while (rd_reg_dword(ha->nxdb_rd_ptr) != dbval) {
3504                         wrt_reg_dword(ha->nxdb_wr_ptr, dbval);
3505                         wmb();
3506                 }
3507         }
3508
3509         /* Manage unprocessed RIO/ZIO commands in response queue. */
3510         if (vha->flags.process_response_queue &&
3511             rsp->ring_ptr->signature != RESPONSE_PROCESSED)
3512                 qla24xx_process_response_queue(vha, rsp);
3513
3514         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3515         return QLA_SUCCESS;
3516
3517 queuing_error_fcp_cmnd:
3518         dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma);
3519 queuing_error:
3520         if (tot_dsds)
3521                 scsi_dma_unmap(cmd);
3522
3523         if (sp->u.scmd.crc_ctx) {
3524                 mempool_free(sp->u.scmd.crc_ctx, ha->ctx_mempool);
3525                 sp->u.scmd.crc_ctx = NULL;
3526         }
3527         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3528
3529         return QLA_FUNCTION_FAILED;
3530 }
3531
3532 static void
3533 qla24xx_abort_iocb(srb_t *sp, struct abort_entry_24xx *abt_iocb)
3534 {
3535         struct srb_iocb *aio = &sp->u.iocb_cmd;
3536         scsi_qla_host_t *vha = sp->vha;
3537         struct req_que *req = sp->qpair->req;
3538
3539         memset(abt_iocb, 0, sizeof(struct abort_entry_24xx));
3540         abt_iocb->entry_type = ABORT_IOCB_TYPE;
3541         abt_iocb->entry_count = 1;
3542         abt_iocb->handle = make_handle(req->id, sp->handle);
3543         if (sp->fcport) {
3544                 abt_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3545                 abt_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
3546                 abt_iocb->port_id[1] = sp->fcport->d_id.b.area;
3547                 abt_iocb->port_id[2] = sp->fcport->d_id.b.domain;
3548         }
3549         abt_iocb->handle_to_abort =
3550                 make_handle(le16_to_cpu(aio->u.abt.req_que_no),
3551                             aio->u.abt.cmd_hndl);
3552         abt_iocb->vp_index = vha->vp_idx;
3553         abt_iocb->req_que_no = aio->u.abt.req_que_no;
3554         /* Send the command to the firmware */
3555         wmb();
3556 }
3557
3558 static void
3559 qla2x00_mb_iocb(srb_t *sp, struct mbx_24xx_entry *mbx)
3560 {
3561         int i, sz;
3562
3563         mbx->entry_type = MBX_IOCB_TYPE;
3564         mbx->handle = sp->handle;
3565         sz = min(ARRAY_SIZE(mbx->mb), ARRAY_SIZE(sp->u.iocb_cmd.u.mbx.out_mb));
3566
3567         for (i = 0; i < sz; i++)
3568                 mbx->mb[i] = sp->u.iocb_cmd.u.mbx.out_mb[i];
3569 }
3570
3571 static void
3572 qla2x00_ctpthru_cmd_iocb(srb_t *sp, struct ct_entry_24xx *ct_pkt)
3573 {
3574         sp->u.iocb_cmd.u.ctarg.iocb = ct_pkt;
3575         qla24xx_prep_ms_iocb(sp->vha, &sp->u.iocb_cmd.u.ctarg);
3576         ct_pkt->handle = sp->handle;
3577 }
3578
3579 static void qla2x00_send_notify_ack_iocb(srb_t *sp,
3580         struct nack_to_isp *nack)
3581 {
3582         struct imm_ntfy_from_isp *ntfy = sp->u.iocb_cmd.u.nack.ntfy;
3583
3584         nack->entry_type = NOTIFY_ACK_TYPE;
3585         nack->entry_count = 1;
3586         nack->ox_id = ntfy->ox_id;
3587
3588         nack->u.isp24.handle = sp->handle;
3589         nack->u.isp24.nport_handle = ntfy->u.isp24.nport_handle;
3590         if (le16_to_cpu(ntfy->u.isp24.status) == IMM_NTFY_ELS) {
3591                 nack->u.isp24.flags = ntfy->u.isp24.flags &
3592                         cpu_to_le16(NOTIFY24XX_FLAGS_PUREX_IOCB);
3593         }
3594         nack->u.isp24.srr_rx_id = ntfy->u.isp24.srr_rx_id;
3595         nack->u.isp24.status = ntfy->u.isp24.status;
3596         nack->u.isp24.status_subcode = ntfy->u.isp24.status_subcode;
3597         nack->u.isp24.fw_handle = ntfy->u.isp24.fw_handle;
3598         nack->u.isp24.exchange_address = ntfy->u.isp24.exchange_address;
3599         nack->u.isp24.srr_rel_offs = ntfy->u.isp24.srr_rel_offs;
3600         nack->u.isp24.srr_ui = ntfy->u.isp24.srr_ui;
3601         nack->u.isp24.srr_flags = 0;
3602         nack->u.isp24.srr_reject_code = 0;
3603         nack->u.isp24.srr_reject_code_expl = 0;
3604         nack->u.isp24.vp_index = ntfy->u.isp24.vp_index;
3605 }
3606
3607 /*
3608  * Build NVME LS request
3609  */
3610 static void
3611 qla_nvme_ls(srb_t *sp, struct pt_ls4_request *cmd_pkt)
3612 {
3613         struct srb_iocb *nvme;
3614
3615         nvme = &sp->u.iocb_cmd;
3616         cmd_pkt->entry_type = PT_LS4_REQUEST;
3617         cmd_pkt->entry_count = 1;
3618         cmd_pkt->control_flags = cpu_to_le16(CF_LS4_ORIGINATOR << CF_LS4_SHIFT);
3619
3620         cmd_pkt->timeout = cpu_to_le16(nvme->u.nvme.timeout_sec);
3621         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3622         cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
3623
3624         cmd_pkt->tx_dseg_count = cpu_to_le16(1);
3625         cmd_pkt->tx_byte_count = cpu_to_le32(nvme->u.nvme.cmd_len);
3626         cmd_pkt->dsd[0].length = cpu_to_le32(nvme->u.nvme.cmd_len);
3627         put_unaligned_le64(nvme->u.nvme.cmd_dma, &cmd_pkt->dsd[0].address);
3628
3629         cmd_pkt->rx_dseg_count = cpu_to_le16(1);
3630         cmd_pkt->rx_byte_count = cpu_to_le32(nvme->u.nvme.rsp_len);
3631         cmd_pkt->dsd[1].length = cpu_to_le32(nvme->u.nvme.rsp_len);
3632         put_unaligned_le64(nvme->u.nvme.rsp_dma, &cmd_pkt->dsd[1].address);
3633 }
3634
3635 static void
3636 qla25xx_ctrlvp_iocb(srb_t *sp, struct vp_ctrl_entry_24xx *vce)
3637 {
3638         int map, pos;
3639
3640         vce->entry_type = VP_CTRL_IOCB_TYPE;
3641         vce->handle = sp->handle;
3642         vce->entry_count = 1;
3643         vce->command = cpu_to_le16(sp->u.iocb_cmd.u.ctrlvp.cmd);
3644         vce->vp_count = cpu_to_le16(1);
3645
3646         /*
3647          * index map in firmware starts with 1; decrement index
3648          * this is ok as we never use index 0
3649          */
3650         map = (sp->u.iocb_cmd.u.ctrlvp.vp_index - 1) / 8;
3651         pos = (sp->u.iocb_cmd.u.ctrlvp.vp_index - 1) & 7;
3652         vce->vp_idx_map[map] |= 1 << pos;
3653 }
3654
3655 static void
3656 qla24xx_prlo_iocb(srb_t *sp, struct logio_entry_24xx *logio)
3657 {
3658         logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
3659         logio->control_flags =
3660             cpu_to_le16(LCF_COMMAND_PRLO|LCF_IMPL_PRLO);
3661
3662         logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
3663         logio->port_id[0] = sp->fcport->d_id.b.al_pa;
3664         logio->port_id[1] = sp->fcport->d_id.b.area;
3665         logio->port_id[2] = sp->fcport->d_id.b.domain;
3666         logio->vp_index = sp->fcport->vha->vp_idx;
3667 }
3668
3669 int
3670 qla2x00_start_sp(srb_t *sp)
3671 {
3672         int rval = QLA_SUCCESS;
3673         scsi_qla_host_t *vha = sp->vha;
3674         struct qla_hw_data *ha = vha->hw;
3675         struct qla_qpair *qp = sp->qpair;
3676         void *pkt;
3677         unsigned long flags;
3678
3679         spin_lock_irqsave(qp->qp_lock_ptr, flags);
3680         pkt = __qla2x00_alloc_iocbs(sp->qpair, sp);
3681         if (!pkt) {
3682                 rval = EAGAIN;
3683                 ql_log(ql_log_warn, vha, 0x700c,
3684                     "qla2x00_alloc_iocbs failed.\n");
3685                 goto done;
3686         }
3687
3688         switch (sp->type) {
3689         case SRB_LOGIN_CMD:
3690                 IS_FWI2_CAPABLE(ha) ?
3691                     qla24xx_login_iocb(sp, pkt) :
3692                     qla2x00_login_iocb(sp, pkt);
3693                 break;
3694         case SRB_PRLI_CMD:
3695                 qla24xx_prli_iocb(sp, pkt);
3696                 break;
3697         case SRB_LOGOUT_CMD:
3698                 IS_FWI2_CAPABLE(ha) ?
3699                     qla24xx_logout_iocb(sp, pkt) :
3700                     qla2x00_logout_iocb(sp, pkt);
3701                 break;
3702         case SRB_ELS_CMD_RPT:
3703         case SRB_ELS_CMD_HST:
3704                 qla24xx_els_iocb(sp, pkt);
3705                 break;
3706         case SRB_CT_CMD:
3707                 IS_FWI2_CAPABLE(ha) ?
3708                     qla24xx_ct_iocb(sp, pkt) :
3709                     qla2x00_ct_iocb(sp, pkt);
3710                 break;
3711         case SRB_ADISC_CMD:
3712                 IS_FWI2_CAPABLE(ha) ?
3713                     qla24xx_adisc_iocb(sp, pkt) :
3714                     qla2x00_adisc_iocb(sp, pkt);
3715                 break;
3716         case SRB_TM_CMD:
3717                 IS_QLAFX00(ha) ?
3718                     qlafx00_tm_iocb(sp, pkt) :
3719                     qla24xx_tm_iocb(sp, pkt);
3720                 break;
3721         case SRB_FXIOCB_DCMD:
3722         case SRB_FXIOCB_BCMD:
3723                 qlafx00_fxdisc_iocb(sp, pkt);
3724                 break;
3725         case SRB_NVME_LS:
3726                 qla_nvme_ls(sp, pkt);
3727                 break;
3728         case SRB_ABT_CMD:
3729                 IS_QLAFX00(ha) ?
3730                         qlafx00_abort_iocb(sp, pkt) :
3731                         qla24xx_abort_iocb(sp, pkt);
3732                 break;
3733         case SRB_ELS_DCMD:
3734                 qla24xx_els_logo_iocb(sp, pkt);
3735                 break;
3736         case SRB_CT_PTHRU_CMD:
3737                 qla2x00_ctpthru_cmd_iocb(sp, pkt);
3738                 break;
3739         case SRB_MB_IOCB:
3740                 qla2x00_mb_iocb(sp, pkt);
3741                 break;
3742         case SRB_NACK_PLOGI:
3743         case SRB_NACK_PRLI:
3744         case SRB_NACK_LOGO:
3745                 qla2x00_send_notify_ack_iocb(sp, pkt);
3746                 break;
3747         case SRB_CTRL_VP:
3748                 qla25xx_ctrlvp_iocb(sp, pkt);
3749                 break;
3750         case SRB_PRLO_CMD:
3751                 qla24xx_prlo_iocb(sp, pkt);
3752                 break;
3753         default:
3754                 break;
3755         }
3756
3757         if (sp->start_timer)
3758                 add_timer(&sp->u.iocb_cmd.timer);
3759
3760         wmb();
3761         qla2x00_start_iocbs(vha, qp->req);
3762 done:
3763         spin_unlock_irqrestore(qp->qp_lock_ptr, flags);
3764         return rval;
3765 }
3766
3767 static void
3768 qla25xx_build_bidir_iocb(srb_t *sp, struct scsi_qla_host *vha,
3769                                 struct cmd_bidir *cmd_pkt, uint32_t tot_dsds)
3770 {
3771         uint16_t avail_dsds;
3772         struct dsd64 *cur_dsd;
3773         uint32_t req_data_len = 0;
3774         uint32_t rsp_data_len = 0;
3775         struct scatterlist *sg;
3776         int index;
3777         int entry_count = 1;
3778         struct bsg_job *bsg_job = sp->u.bsg_job;
3779
3780         /*Update entry type to indicate bidir command */
3781         put_unaligned_le32(COMMAND_BIDIRECTIONAL, &cmd_pkt->entry_type);
3782
3783         /* Set the transfer direction, in this set both flags
3784          * Also set the BD_WRAP_BACK flag, firmware will take care
3785          * assigning DID=SID for outgoing pkts.
3786          */
3787         cmd_pkt->wr_dseg_count = cpu_to_le16(bsg_job->request_payload.sg_cnt);
3788         cmd_pkt->rd_dseg_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt);
3789         cmd_pkt->control_flags = cpu_to_le16(BD_WRITE_DATA | BD_READ_DATA |
3790                                                         BD_WRAP_BACK);
3791
3792         req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
3793         cmd_pkt->wr_byte_count = cpu_to_le32(req_data_len);
3794         cmd_pkt->rd_byte_count = cpu_to_le32(rsp_data_len);
3795         cmd_pkt->timeout = cpu_to_le16(qla2x00_get_async_timeout(vha) + 2);
3796
3797         vha->bidi_stats.transfer_bytes += req_data_len;
3798         vha->bidi_stats.io_count++;
3799
3800         vha->qla_stats.output_bytes += req_data_len;
3801         vha->qla_stats.output_requests++;
3802
3803         /* Only one dsd is available for bidirectional IOCB, remaining dsds
3804          * are bundled in continuation iocb
3805          */
3806         avail_dsds = 1;
3807         cur_dsd = &cmd_pkt->fcp_dsd;
3808
3809         index = 0;
3810
3811         for_each_sg(bsg_job->request_payload.sg_list, sg,
3812                                 bsg_job->request_payload.sg_cnt, index) {
3813                 cont_a64_entry_t *cont_pkt;
3814
3815                 /* Allocate additional continuation packets */
3816                 if (avail_dsds == 0) {
3817                         /* Continuation type 1 IOCB can accomodate
3818                          * 5 DSDS
3819                          */
3820                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
3821                         cur_dsd = cont_pkt->dsd;
3822                         avail_dsds = 5;
3823                         entry_count++;
3824                 }
3825                 append_dsd64(&cur_dsd, sg);
3826                 avail_dsds--;
3827         }
3828         /* For read request DSD will always goes to continuation IOCB
3829          * and follow the write DSD. If there is room on the current IOCB
3830          * then it is added to that IOCB else new continuation IOCB is
3831          * allocated.
3832          */
3833         for_each_sg(bsg_job->reply_payload.sg_list, sg,
3834                                 bsg_job->reply_payload.sg_cnt, index) {
3835                 cont_a64_entry_t *cont_pkt;
3836
3837                 /* Allocate additional continuation packets */
3838                 if (avail_dsds == 0) {
3839                         /* Continuation type 1 IOCB can accomodate
3840                          * 5 DSDS
3841                          */
3842                         cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
3843                         cur_dsd = cont_pkt->dsd;
3844                         avail_dsds = 5;
3845                         entry_count++;
3846                 }
3847                 append_dsd64(&cur_dsd, sg);
3848                 avail_dsds--;
3849         }
3850         /* This value should be same as number of IOCB required for this cmd */
3851         cmd_pkt->entry_count = entry_count;
3852 }
3853
3854 int
3855 qla2x00_start_bidir(srb_t *sp, struct scsi_qla_host *vha, uint32_t tot_dsds)
3856 {
3857
3858         struct qla_hw_data *ha = vha->hw;
3859         unsigned long flags;
3860         uint32_t handle;
3861         uint16_t req_cnt;
3862         uint16_t cnt;
3863         uint32_t *clr_ptr;
3864         struct cmd_bidir *cmd_pkt = NULL;
3865         struct rsp_que *rsp;
3866         struct req_que *req;
3867         int rval = EXT_STATUS_OK;
3868
3869         rval = QLA_SUCCESS;
3870
3871         rsp = ha->rsp_q_map[0];
3872         req = vha->req;
3873
3874         /* Send marker if required */
3875         if (vha->marker_needed != 0) {
3876                 if (qla2x00_marker(vha, ha->base_qpair,
3877                         0, 0, MK_SYNC_ALL) != QLA_SUCCESS)
3878                         return EXT_STATUS_MAILBOX;
3879                 vha->marker_needed = 0;
3880         }
3881
3882         /* Acquire ring specific lock */
3883         spin_lock_irqsave(&ha->hardware_lock, flags);
3884
3885         handle = qla2xxx_get_next_handle(req);
3886         if (handle == 0) {
3887                 rval = EXT_STATUS_BUSY;
3888                 goto queuing_error;
3889         }
3890
3891         /* Calculate number of IOCB required */
3892         req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
3893
3894         /* Check for room on request queue. */
3895         if (req->cnt < req_cnt + 2) {
3896                 cnt = IS_SHADOW_REG_CAPABLE(ha) ? *req->out_ptr :
3897                     rd_reg_dword_relaxed(req->req_q_out);
3898                 if  (req->ring_index < cnt)
3899                         req->cnt = cnt - req->ring_index;
3900                 else
3901                         req->cnt = req->length -
3902                                 (req->ring_index - cnt);
3903         }
3904         if (req->cnt < req_cnt + 2) {
3905                 rval = EXT_STATUS_BUSY;
3906                 goto queuing_error;
3907         }
3908
3909         cmd_pkt = (struct cmd_bidir *)req->ring_ptr;
3910         cmd_pkt->handle = make_handle(req->id, handle);
3911
3912         /* Zero out remaining portion of packet. */
3913         /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/
3914         clr_ptr = (uint32_t *)cmd_pkt + 2;
3915         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
3916
3917         /* Set NPORT-ID  (of vha)*/
3918         cmd_pkt->nport_handle = cpu_to_le16(vha->self_login_loop_id);
3919         cmd_pkt->port_id[0] = vha->d_id.b.al_pa;
3920         cmd_pkt->port_id[1] = vha->d_id.b.area;
3921         cmd_pkt->port_id[2] = vha->d_id.b.domain;
3922
3923         qla25xx_build_bidir_iocb(sp, vha, cmd_pkt, tot_dsds);
3924         cmd_pkt->entry_status = (uint8_t) rsp->id;
3925         /* Build command packet. */
3926         req->current_outstanding_cmd = handle;
3927         req->outstanding_cmds[handle] = sp;
3928         sp->handle = handle;
3929         req->cnt -= req_cnt;
3930
3931         /* Send the command to the firmware */
3932         wmb();
3933         qla2x00_start_iocbs(vha, req);
3934 queuing_error:
3935         spin_unlock_irqrestore(&ha->hardware_lock, flags);
3936         return rval;
3937 }