2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2012 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
8 #include "qla_target.h"
10 #include <linux/blkdev.h>
11 #include <linux/delay.h>
13 #include <scsi/scsi_tcq.h>
15 static void qla25xx_set_que(srb_t *, struct rsp_que **);
17 * qla2x00_get_cmd_direction() - Determine control_flag data direction.
20 * Returns the proper CF_* direction based on CDB.
22 static inline uint16_t
23 qla2x00_get_cmd_direction(srb_t *sp)
26 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
27 struct scsi_qla_host *vha = sp->fcport->vha;
31 /* Set transfer direction */
32 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
34 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
35 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
37 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
43 * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and
44 * Continuation Type 0 IOCBs to allocate.
46 * @dsds: number of data segment decriptors needed
48 * Returns the number of IOCB entries needed to store @dsds.
51 qla2x00_calc_iocbs_32(uint16_t dsds)
57 iocbs += (dsds - 3) / 7;
65 * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and
66 * Continuation Type 1 IOCBs to allocate.
68 * @dsds: number of data segment decriptors needed
70 * Returns the number of IOCB entries needed to store @dsds.
73 qla2x00_calc_iocbs_64(uint16_t dsds)
79 iocbs += (dsds - 2) / 5;
87 * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB.
90 * Returns a pointer to the Continuation Type 0 IOCB packet.
92 static inline cont_entry_t *
93 qla2x00_prep_cont_type0_iocb(struct scsi_qla_host *vha)
95 cont_entry_t *cont_pkt;
96 struct req_que *req = vha->req;
97 /* Adjust ring index. */
99 if (req->ring_index == req->length) {
101 req->ring_ptr = req->ring;
106 cont_pkt = (cont_entry_t *)req->ring_ptr;
108 /* Load packet defaults. */
109 *((uint32_t *)(&cont_pkt->entry_type)) =
110 __constant_cpu_to_le32(CONTINUE_TYPE);
116 * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB.
119 * Returns a pointer to the continuation type 1 IOCB packet.
121 static inline cont_a64_entry_t *
122 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *vha, struct req_que *req)
124 cont_a64_entry_t *cont_pkt;
126 /* Adjust ring index. */
128 if (req->ring_index == req->length) {
130 req->ring_ptr = req->ring;
135 cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
137 /* Load packet defaults. */
138 *((uint32_t *)(&cont_pkt->entry_type)) =
139 __constant_cpu_to_le32(CONTINUE_A64_TYPE);
145 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts)
147 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
148 uint8_t guard = scsi_host_get_guard(cmd->device->host);
150 /* We always use DIFF Bundling for best performance */
153 /* Translate SCSI opcode to a protection opcode */
154 switch (scsi_get_prot_op(cmd)) {
155 case SCSI_PROT_READ_STRIP:
156 *fw_prot_opts |= PO_MODE_DIF_REMOVE;
158 case SCSI_PROT_WRITE_INSERT:
159 *fw_prot_opts |= PO_MODE_DIF_INSERT;
161 case SCSI_PROT_READ_INSERT:
162 *fw_prot_opts |= PO_MODE_DIF_INSERT;
164 case SCSI_PROT_WRITE_STRIP:
165 *fw_prot_opts |= PO_MODE_DIF_REMOVE;
167 case SCSI_PROT_READ_PASS:
168 case SCSI_PROT_WRITE_PASS:
169 if (guard & SHOST_DIX_GUARD_IP)
170 *fw_prot_opts |= PO_MODE_DIF_TCP_CKSUM;
172 *fw_prot_opts |= PO_MODE_DIF_PASS;
174 default: /* Normal Request */
175 *fw_prot_opts |= PO_MODE_DIF_PASS;
179 return scsi_prot_sg_count(cmd);
183 * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit
184 * capable IOCB types.
186 * @sp: SRB command to process
187 * @cmd_pkt: Command type 2 IOCB
188 * @tot_dsds: Total number of segments to transfer
190 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt,
195 scsi_qla_host_t *vha;
196 struct scsi_cmnd *cmd;
197 struct scatterlist *sg;
200 cmd = GET_CMD_SP(sp);
202 /* Update entry type to indicate Command Type 2 IOCB */
203 *((uint32_t *)(&cmd_pkt->entry_type)) =
204 __constant_cpu_to_le32(COMMAND_TYPE);
206 /* No data transfer */
207 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
208 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
212 vha = sp->fcport->vha;
213 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
215 /* Three DSDs are available in the Command Type 2 IOCB */
217 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
219 /* Load data segments */
220 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
221 cont_entry_t *cont_pkt;
223 /* Allocate additional continuation packets? */
224 if (avail_dsds == 0) {
226 * Seven DSDs are available in the Continuation
229 cont_pkt = qla2x00_prep_cont_type0_iocb(vha);
230 cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address;
234 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg));
235 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
241 * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit
242 * capable IOCB types.
244 * @sp: SRB command to process
245 * @cmd_pkt: Command type 3 IOCB
246 * @tot_dsds: Total number of segments to transfer
248 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,
253 scsi_qla_host_t *vha;
254 struct scsi_cmnd *cmd;
255 struct scatterlist *sg;
258 cmd = GET_CMD_SP(sp);
260 /* Update entry type to indicate Command Type 3 IOCB */
261 *((uint32_t *)(&cmd_pkt->entry_type)) =
262 __constant_cpu_to_le32(COMMAND_A64_TYPE);
264 /* No data transfer */
265 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
266 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
270 vha = sp->fcport->vha;
271 cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
273 /* Two DSDs are available in the Command Type 3 IOCB */
275 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
277 /* Load data segments */
278 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
280 cont_a64_entry_t *cont_pkt;
282 /* Allocate additional continuation packets? */
283 if (avail_dsds == 0) {
285 * Five DSDs are available in the Continuation
288 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
289 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
293 sle_dma = sg_dma_address(sg);
294 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
295 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
296 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
302 * qla2x00_start_scsi() - Send a SCSI command to the ISP
303 * @sp: command to send to the ISP
305 * Returns non-zero if a failure occurred, else zero.
308 qla2x00_start_scsi(srb_t *sp)
312 scsi_qla_host_t *vha;
313 struct scsi_cmnd *cmd;
317 cmd_entry_t *cmd_pkt;
321 struct device_reg_2xxx __iomem *reg;
322 struct qla_hw_data *ha;
327 /* Setup device pointers. */
329 vha = sp->fcport->vha;
331 reg = &ha->iobase->isp;
332 cmd = GET_CMD_SP(sp);
333 req = ha->req_q_map[0];
334 rsp = ha->rsp_q_map[0];
335 /* So we know we haven't pci_map'ed anything yet */
338 /* Send marker if required */
339 if (vha->marker_needed != 0) {
340 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
342 return (QLA_FUNCTION_FAILED);
344 vha->marker_needed = 0;
347 /* Acquire ring specific lock */
348 spin_lock_irqsave(&ha->hardware_lock, flags);
350 /* Check for room in outstanding command list. */
351 handle = req->current_outstanding_cmd;
352 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
354 if (handle == MAX_OUTSTANDING_COMMANDS)
356 if (!req->outstanding_cmds[handle])
359 if (index == MAX_OUTSTANDING_COMMANDS)
362 /* Map the sg table so we have an accurate count of sg entries needed */
363 if (scsi_sg_count(cmd)) {
364 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
365 scsi_sg_count(cmd), cmd->sc_data_direction);
373 /* Calculate the number of request entries needed. */
374 req_cnt = ha->isp_ops->calc_req_entries(tot_dsds);
375 if (req->cnt < (req_cnt + 2)) {
376 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg));
377 if (req->ring_index < cnt)
378 req->cnt = cnt - req->ring_index;
380 req->cnt = req->length -
381 (req->ring_index - cnt);
382 /* If still no head room then bail out */
383 if (req->cnt < (req_cnt + 2))
387 /* Build command packet */
388 req->current_outstanding_cmd = handle;
389 req->outstanding_cmds[handle] = sp;
391 cmd->host_scribble = (unsigned char *)(unsigned long)handle;
394 cmd_pkt = (cmd_entry_t *)req->ring_ptr;
395 cmd_pkt->handle = handle;
396 /* Zero out remaining portion of packet. */
397 clr_ptr = (uint32_t *)cmd_pkt + 2;
398 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
399 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
401 /* Set target ID and LUN number*/
402 SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id);
403 cmd_pkt->lun = cpu_to_le16(cmd->device->lun);
405 /* Update tagged queuing modifier */
406 if (scsi_populate_tag_msg(cmd, tag)) {
408 case HEAD_OF_QUEUE_TAG:
409 cmd_pkt->control_flags =
410 __constant_cpu_to_le16(CF_HEAD_TAG);
412 case ORDERED_QUEUE_TAG:
413 cmd_pkt->control_flags =
414 __constant_cpu_to_le16(CF_ORDERED_TAG);
417 cmd_pkt->control_flags =
418 __constant_cpu_to_le16(CF_SIMPLE_TAG);
423 /* Load SCSI command packet. */
424 memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
425 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
427 /* Build IOCB segments */
428 ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds);
430 /* Set total data segment count. */
431 cmd_pkt->entry_count = (uint8_t)req_cnt;
434 /* Adjust ring index. */
436 if (req->ring_index == req->length) {
438 req->ring_ptr = req->ring;
442 sp->flags |= SRB_DMA_VALID;
444 /* Set chip new ring index. */
445 WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), req->ring_index);
446 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg)); /* PCI Posting. */
448 /* Manage unprocessed RIO/ZIO commands in response queue. */
449 if (vha->flags.process_response_queue &&
450 rsp->ring_ptr->signature != RESPONSE_PROCESSED)
451 qla2x00_process_response_queue(rsp);
453 spin_unlock_irqrestore(&ha->hardware_lock, flags);
454 return (QLA_SUCCESS);
460 spin_unlock_irqrestore(&ha->hardware_lock, flags);
462 return (QLA_FUNCTION_FAILED);
466 * qla2x00_start_iocbs() - Execute the IOCB command
469 qla2x00_start_iocbs(struct scsi_qla_host *vha, struct req_que *req)
471 struct qla_hw_data *ha = vha->hw;
472 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id);
474 if (IS_QLA82XX(ha)) {
475 qla82xx_start_iocbs(vha);
477 /* Adjust ring index. */
479 if (req->ring_index == req->length) {
481 req->ring_ptr = req->ring;
485 /* Set chip new ring index. */
486 if (ha->mqenable || IS_QLA83XX(ha)) {
487 WRT_REG_DWORD(req->req_q_in, req->ring_index);
488 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr);
489 } else if (IS_FWI2_CAPABLE(ha)) {
490 WRT_REG_DWORD(®->isp24.req_q_in, req->ring_index);
491 RD_REG_DWORD_RELAXED(®->isp24.req_q_in);
493 WRT_REG_WORD(ISP_REQ_Q_IN(ha, ®->isp),
495 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, ®->isp));
501 * qla2x00_marker() - Send a marker IOCB to the firmware.
505 * @type: marker modifier
507 * Can be called from both normal and interrupt context.
509 * Returns non-zero if a failure occurred, else zero.
512 __qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req,
513 struct rsp_que *rsp, uint16_t loop_id,
514 uint16_t lun, uint8_t type)
517 struct mrk_entry_24xx *mrk24;
518 struct qla_hw_data *ha = vha->hw;
519 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
522 req = ha->req_q_map[0];
523 mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, 0);
525 ql_log(ql_log_warn, base_vha, 0x3026,
526 "Failed to allocate Marker IOCB.\n");
528 return (QLA_FUNCTION_FAILED);
531 mrk->entry_type = MARKER_TYPE;
532 mrk->modifier = type;
533 if (type != MK_SYNC_ALL) {
534 if (IS_FWI2_CAPABLE(ha)) {
535 mrk24 = (struct mrk_entry_24xx *) mrk;
536 mrk24->nport_handle = cpu_to_le16(loop_id);
537 mrk24->lun[1] = LSB(lun);
538 mrk24->lun[2] = MSB(lun);
539 host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun));
540 mrk24->vp_index = vha->vp_idx;
541 mrk24->handle = MAKE_HANDLE(req->id, mrk24->handle);
543 SET_TARGET_ID(ha, mrk->target, loop_id);
544 mrk->lun = cpu_to_le16(lun);
549 qla2x00_start_iocbs(vha, req);
551 return (QLA_SUCCESS);
555 qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req,
556 struct rsp_que *rsp, uint16_t loop_id, uint16_t lun,
560 unsigned long flags = 0;
562 spin_lock_irqsave(&vha->hw->hardware_lock, flags);
563 ret = __qla2x00_marker(vha, req, rsp, loop_id, lun, type);
564 spin_unlock_irqrestore(&vha->hw->hardware_lock, flags);
570 * qla2x00_issue_marker
573 * Caller CAN have hardware lock held as specified by ha_locked parameter.
574 * Might release it, then reaquire.
576 int qla2x00_issue_marker(scsi_qla_host_t *vha, int ha_locked)
579 if (__qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0,
580 MK_SYNC_ALL) != QLA_SUCCESS)
581 return QLA_FUNCTION_FAILED;
583 if (qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0,
584 MK_SYNC_ALL) != QLA_SUCCESS)
585 return QLA_FUNCTION_FAILED;
587 vha->marker_needed = 0;
593 * qla24xx_calc_iocbs() - Determine number of Command Type 3 and
594 * Continuation Type 1 IOCBs to allocate.
596 * @dsds: number of data segment decriptors needed
598 * Returns the number of IOCB entries needed to store @dsds.
601 qla24xx_calc_iocbs(scsi_qla_host_t *vha, uint16_t dsds)
607 iocbs += (dsds - 1) / 5;
615 qla24xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
618 uint32_t *cur_dsd = NULL;
619 scsi_qla_host_t *vha;
620 struct qla_hw_data *ha;
621 struct scsi_cmnd *cmd;
622 struct scatterlist *cur_seg;
626 uint8_t first_iocb = 1;
627 uint32_t dsd_list_len;
628 struct dsd_dma *dsd_ptr;
631 cmd = GET_CMD_SP(sp);
633 /* Update entry type to indicate Command Type 3 IOCB */
634 *((uint32_t *)(&cmd_pkt->entry_type)) =
635 __constant_cpu_to_le32(COMMAND_TYPE_6);
637 /* No data transfer */
638 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
639 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
643 vha = sp->fcport->vha;
646 /* Set transfer direction */
647 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
648 cmd_pkt->control_flags =
649 __constant_cpu_to_le16(CF_WRITE_DATA);
650 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
651 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
652 cmd_pkt->control_flags =
653 __constant_cpu_to_le16(CF_READ_DATA);
654 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
657 cur_seg = scsi_sglist(cmd);
658 ctx = GET_CMD_CTX_SP(sp);
661 avail_dsds = (tot_dsds > QLA_DSDS_PER_IOCB) ?
662 QLA_DSDS_PER_IOCB : tot_dsds;
663 tot_dsds -= avail_dsds;
664 dsd_list_len = (avail_dsds + 1) * QLA_DSD_SIZE;
666 dsd_ptr = list_first_entry(&ha->gbl_dsd_list,
667 struct dsd_dma, list);
668 next_dsd = dsd_ptr->dsd_addr;
669 list_del(&dsd_ptr->list);
671 list_add_tail(&dsd_ptr->list, &ctx->dsd_list);
677 dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
678 *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
679 *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
680 cmd_pkt->fcp_data_dseg_len = cpu_to_le32(dsd_list_len);
682 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
683 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
684 *cur_dsd++ = cpu_to_le32(dsd_list_len);
686 cur_dsd = (uint32_t *)next_dsd;
690 sle_dma = sg_dma_address(cur_seg);
691 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
692 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
693 *cur_dsd++ = cpu_to_le32(sg_dma_len(cur_seg));
694 cur_seg = sg_next(cur_seg);
699 /* Null termination */
703 cmd_pkt->control_flags |= CF_DATA_SEG_DESCR_ENABLE;
708 * qla24xx_calc_dsd_lists() - Determine number of DSD list required
709 * for Command Type 6.
711 * @dsds: number of data segment decriptors needed
713 * Returns the number of dsd list needed to store @dsds.
716 qla24xx_calc_dsd_lists(uint16_t dsds)
718 uint16_t dsd_lists = 0;
720 dsd_lists = (dsds/QLA_DSDS_PER_IOCB);
721 if (dsds % QLA_DSDS_PER_IOCB)
728 * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7
731 * @sp: SRB command to process
732 * @cmd_pkt: Command type 3 IOCB
733 * @tot_dsds: Total number of segments to transfer
736 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt,
741 scsi_qla_host_t *vha;
742 struct scsi_cmnd *cmd;
743 struct scatterlist *sg;
747 cmd = GET_CMD_SP(sp);
749 /* Update entry type to indicate Command Type 3 IOCB */
750 *((uint32_t *)(&cmd_pkt->entry_type)) =
751 __constant_cpu_to_le32(COMMAND_TYPE_7);
753 /* No data transfer */
754 if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
755 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
759 vha = sp->fcport->vha;
762 /* Set transfer direction */
763 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
764 cmd_pkt->task_mgmt_flags =
765 __constant_cpu_to_le16(TMF_WRITE_DATA);
766 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
767 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
768 cmd_pkt->task_mgmt_flags =
769 __constant_cpu_to_le16(TMF_READ_DATA);
770 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
773 /* One DSD is available in the Command Type 3 IOCB */
775 cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
777 /* Load data segments */
779 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
781 cont_a64_entry_t *cont_pkt;
783 /* Allocate additional continuation packets? */
784 if (avail_dsds == 0) {
786 * Five DSDs are available in the Continuation
789 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
790 cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
794 sle_dma = sg_dma_address(sg);
795 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
796 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
797 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
802 struct fw_dif_context {
805 uint8_t ref_tag_mask[4]; /* Validation/Replacement Mask*/
806 uint8_t app_tag_mask[2]; /* Validation/Replacement Mask*/
810 * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command
814 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt,
815 unsigned int protcnt)
817 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
819 switch (scsi_get_prot_type(cmd)) {
820 case SCSI_PROT_DIF_TYPE0:
822 * No check for ql2xenablehba_err_chk, as it would be an
823 * I/O error if hba tag generation is not done.
825 pkt->ref_tag = cpu_to_le32((uint32_t)
826 (0xffffffff & scsi_get_lba(cmd)));
828 if (!qla2x00_hba_err_chk_enabled(sp))
831 pkt->ref_tag_mask[0] = 0xff;
832 pkt->ref_tag_mask[1] = 0xff;
833 pkt->ref_tag_mask[2] = 0xff;
834 pkt->ref_tag_mask[3] = 0xff;
838 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to
839 * match LBA in CDB + N
841 case SCSI_PROT_DIF_TYPE2:
842 pkt->app_tag = __constant_cpu_to_le16(0);
843 pkt->app_tag_mask[0] = 0x0;
844 pkt->app_tag_mask[1] = 0x0;
846 pkt->ref_tag = cpu_to_le32((uint32_t)
847 (0xffffffff & scsi_get_lba(cmd)));
849 if (!qla2x00_hba_err_chk_enabled(sp))
852 /* enable ALL bytes of the ref tag */
853 pkt->ref_tag_mask[0] = 0xff;
854 pkt->ref_tag_mask[1] = 0xff;
855 pkt->ref_tag_mask[2] = 0xff;
856 pkt->ref_tag_mask[3] = 0xff;
859 /* For Type 3 protection: 16 bit GUARD only */
860 case SCSI_PROT_DIF_TYPE3:
861 pkt->ref_tag_mask[0] = pkt->ref_tag_mask[1] =
862 pkt->ref_tag_mask[2] = pkt->ref_tag_mask[3] =
867 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and
870 case SCSI_PROT_DIF_TYPE1:
871 pkt->ref_tag = cpu_to_le32((uint32_t)
872 (0xffffffff & scsi_get_lba(cmd)));
873 pkt->app_tag = __constant_cpu_to_le16(0);
874 pkt->app_tag_mask[0] = 0x0;
875 pkt->app_tag_mask[1] = 0x0;
877 if (!qla2x00_hba_err_chk_enabled(sp))
880 /* enable ALL bytes of the ref tag */
881 pkt->ref_tag_mask[0] = 0xff;
882 pkt->ref_tag_mask[1] = 0xff;
883 pkt->ref_tag_mask[2] = 0xff;
884 pkt->ref_tag_mask[3] = 0xff;
890 dma_addr_t dma_addr; /* OUT */
891 uint32_t dma_len; /* OUT */
893 uint32_t tot_bytes; /* IN */
894 struct scatterlist *cur_sg; /* IN */
896 /* for book keeping, bzero on initial invocation */
897 uint32_t bytes_consumed;
899 uint32_t tot_partial;
907 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx,
910 struct scatterlist *sg;
911 uint32_t cumulative_partial, sg_len;
912 dma_addr_t sg_dma_addr;
914 if (sgx->num_bytes == sgx->tot_bytes)
918 cumulative_partial = sgx->tot_partial;
920 sg_dma_addr = sg_dma_address(sg);
921 sg_len = sg_dma_len(sg);
923 sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed;
925 if ((cumulative_partial + (sg_len - sgx->bytes_consumed)) >= blk_sz) {
926 sgx->dma_len = (blk_sz - cumulative_partial);
927 sgx->tot_partial = 0;
928 sgx->num_bytes += blk_sz;
931 sgx->dma_len = sg_len - sgx->bytes_consumed;
932 sgx->tot_partial += sgx->dma_len;
936 sgx->bytes_consumed += sgx->dma_len;
938 if (sg_len == sgx->bytes_consumed) {
942 sgx->bytes_consumed = 0;
949 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp,
950 uint32_t *dsd, uint16_t tot_dsds)
953 uint8_t avail_dsds = 0;
954 uint32_t dsd_list_len;
955 struct dsd_dma *dsd_ptr;
956 struct scatterlist *sg_prot;
957 uint32_t *cur_dsd = dsd;
958 uint16_t used_dsds = tot_dsds;
964 uint32_t sle_dma_len, tot_prot_dma_len = 0;
965 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
967 prot_int = cmd->device->sector_size;
969 memset(&sgx, 0, sizeof(struct qla2_sgx));
970 sgx.tot_bytes = scsi_bufflen(cmd);
971 sgx.cur_sg = scsi_sglist(cmd);
974 sg_prot = scsi_prot_sglist(cmd);
976 while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) {
978 sle_dma = sgx.dma_addr;
979 sle_dma_len = sgx.dma_len;
981 /* Allocate additional continuation packets? */
982 if (avail_dsds == 0) {
983 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
984 QLA_DSDS_PER_IOCB : used_dsds;
985 dsd_list_len = (avail_dsds + 1) * 12;
986 used_dsds -= avail_dsds;
988 /* allocate tracking DS */
989 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
993 /* allocate new list */
994 dsd_ptr->dsd_addr = next_dsd =
995 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
996 &dsd_ptr->dsd_list_dma);
1000 * Need to cleanup only this dsd_ptr, rest
1001 * will be done by sp_free_dma()
1007 list_add_tail(&dsd_ptr->list,
1008 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1010 sp->flags |= SRB_CRC_CTX_DSD_VALID;
1012 /* add new list to cmd iocb or last list */
1013 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
1014 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
1015 *cur_dsd++ = dsd_list_len;
1016 cur_dsd = (uint32_t *)next_dsd;
1018 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
1019 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
1020 *cur_dsd++ = cpu_to_le32(sle_dma_len);
1024 /* Got a full protection interval */
1025 sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len;
1028 tot_prot_dma_len += sle_dma_len;
1029 if (tot_prot_dma_len == sg_dma_len(sg_prot)) {
1030 tot_prot_dma_len = 0;
1031 sg_prot = sg_next(sg_prot);
1034 partial = 1; /* So as to not re-enter this block */
1035 goto alloc_and_fill;
1038 /* Null termination */
1046 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
1050 uint8_t avail_dsds = 0;
1051 uint32_t dsd_list_len;
1052 struct dsd_dma *dsd_ptr;
1053 struct scatterlist *sg;
1054 uint32_t *cur_dsd = dsd;
1056 uint16_t used_dsds = tot_dsds;
1057 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1059 scsi_for_each_sg(cmd, sg, tot_dsds, i) {
1062 /* Allocate additional continuation packets? */
1063 if (avail_dsds == 0) {
1064 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
1065 QLA_DSDS_PER_IOCB : used_dsds;
1066 dsd_list_len = (avail_dsds + 1) * 12;
1067 used_dsds -= avail_dsds;
1069 /* allocate tracking DS */
1070 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
1074 /* allocate new list */
1075 dsd_ptr->dsd_addr = next_dsd =
1076 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
1077 &dsd_ptr->dsd_list_dma);
1081 * Need to cleanup only this dsd_ptr, rest
1082 * will be done by sp_free_dma()
1088 list_add_tail(&dsd_ptr->list,
1089 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1091 sp->flags |= SRB_CRC_CTX_DSD_VALID;
1093 /* add new list to cmd iocb or last list */
1094 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
1095 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
1096 *cur_dsd++ = dsd_list_len;
1097 cur_dsd = (uint32_t *)next_dsd;
1099 sle_dma = sg_dma_address(sg);
1101 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
1102 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
1103 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
1107 /* Null termination */
1115 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
1120 uint8_t avail_dsds = 0;
1121 uint32_t dsd_list_len;
1122 struct dsd_dma *dsd_ptr;
1123 struct scatterlist *sg;
1125 struct scsi_cmnd *cmd;
1126 uint32_t *cur_dsd = dsd;
1127 uint16_t used_dsds = tot_dsds;
1129 cmd = GET_CMD_SP(sp);
1130 scsi_for_each_prot_sg(cmd, sg, tot_dsds, i) {
1133 /* Allocate additional continuation packets? */
1134 if (avail_dsds == 0) {
1135 avail_dsds = (used_dsds > QLA_DSDS_PER_IOCB) ?
1136 QLA_DSDS_PER_IOCB : used_dsds;
1137 dsd_list_len = (avail_dsds + 1) * 12;
1138 used_dsds -= avail_dsds;
1140 /* allocate tracking DS */
1141 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
1145 /* allocate new list */
1146 dsd_ptr->dsd_addr = next_dsd =
1147 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC,
1148 &dsd_ptr->dsd_list_dma);
1152 * Need to cleanup only this dsd_ptr, rest
1153 * will be done by sp_free_dma()
1159 list_add_tail(&dsd_ptr->list,
1160 &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1162 sp->flags |= SRB_CRC_CTX_DSD_VALID;
1164 /* add new list to cmd iocb or last list */
1165 *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
1166 *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
1167 *cur_dsd++ = dsd_list_len;
1168 cur_dsd = (uint32_t *)next_dsd;
1170 sle_dma = sg_dma_address(sg);
1172 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
1173 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
1174 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
1178 /* Null termination */
1186 * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command
1187 * Type 6 IOCB types.
1189 * @sp: SRB command to process
1190 * @cmd_pkt: Command type 3 IOCB
1191 * @tot_dsds: Total number of segments to transfer
1194 qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
1195 uint16_t tot_dsds, uint16_t tot_prot_dsds, uint16_t fw_prot_opts)
1197 uint32_t *cur_dsd, *fcp_dl;
1198 scsi_qla_host_t *vha;
1199 struct scsi_cmnd *cmd;
1200 struct scatterlist *cur_seg;
1202 uint32_t total_bytes = 0;
1203 uint32_t data_bytes;
1205 uint8_t bundling = 1;
1208 struct crc_context *crc_ctx_pkt = NULL;
1209 struct qla_hw_data *ha;
1210 uint8_t additional_fcpcdb_len;
1211 uint16_t fcp_cmnd_len;
1212 struct fcp_cmnd *fcp_cmnd;
1213 dma_addr_t crc_ctx_dma;
1216 cmd = GET_CMD_SP(sp);
1219 /* Update entry type to indicate Command Type CRC_2 IOCB */
1220 *((uint32_t *)(&cmd_pkt->entry_type)) =
1221 __constant_cpu_to_le32(COMMAND_TYPE_CRC_2);
1223 vha = sp->fcport->vha;
1226 /* No data transfer */
1227 data_bytes = scsi_bufflen(cmd);
1228 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
1229 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
1233 cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
1235 /* Set transfer direction */
1236 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1237 cmd_pkt->control_flags =
1238 __constant_cpu_to_le16(CF_WRITE_DATA);
1239 } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
1240 cmd_pkt->control_flags =
1241 __constant_cpu_to_le16(CF_READ_DATA);
1244 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1245 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP) ||
1246 (scsi_get_prot_op(cmd) == SCSI_PROT_READ_STRIP) ||
1247 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_INSERT))
1250 /* Allocate CRC context from global pool */
1251 crc_ctx_pkt = sp->u.scmd.ctx =
1252 dma_pool_alloc(ha->dl_dma_pool, GFP_ATOMIC, &crc_ctx_dma);
1255 goto crc_queuing_error;
1257 /* Zero out CTX area. */
1258 clr_ptr = (uint8_t *)crc_ctx_pkt;
1259 memset(clr_ptr, 0, sizeof(*crc_ctx_pkt));
1261 crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma;
1263 sp->flags |= SRB_CRC_CTX_DMA_VALID;
1266 crc_ctx_pkt->handle = cmd_pkt->handle;
1268 INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list);
1270 qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *)
1271 &crc_ctx_pkt->ref_tag, tot_prot_dsds);
1273 cmd_pkt->crc_context_address[0] = cpu_to_le32(LSD(crc_ctx_dma));
1274 cmd_pkt->crc_context_address[1] = cpu_to_le32(MSD(crc_ctx_dma));
1275 cmd_pkt->crc_context_len = CRC_CONTEXT_LEN_FW;
1277 /* Determine SCSI command length -- align to 4 byte boundary */
1278 if (cmd->cmd_len > 16) {
1279 additional_fcpcdb_len = cmd->cmd_len - 16;
1280 if ((cmd->cmd_len % 4) != 0) {
1281 /* SCSI cmd > 16 bytes must be multiple of 4 */
1282 goto crc_queuing_error;
1284 fcp_cmnd_len = 12 + cmd->cmd_len + 4;
1286 additional_fcpcdb_len = 0;
1287 fcp_cmnd_len = 12 + 16 + 4;
1290 fcp_cmnd = &crc_ctx_pkt->fcp_cmnd;
1292 fcp_cmnd->additional_cdb_len = additional_fcpcdb_len;
1293 if (cmd->sc_data_direction == DMA_TO_DEVICE)
1294 fcp_cmnd->additional_cdb_len |= 1;
1295 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
1296 fcp_cmnd->additional_cdb_len |= 2;
1298 int_to_scsilun(cmd->device->lun, &fcp_cmnd->lun);
1299 memcpy(fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
1300 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(fcp_cmnd_len);
1301 cmd_pkt->fcp_cmnd_dseg_address[0] = cpu_to_le32(
1302 LSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF));
1303 cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32(
1304 MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF));
1305 fcp_cmnd->task_management = 0;
1308 * Update tagged queuing modifier if using command tag queuing
1310 if (scsi_populate_tag_msg(cmd, tag)) {
1312 case HEAD_OF_QUEUE_TAG:
1313 fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE;
1315 case ORDERED_QUEUE_TAG:
1316 fcp_cmnd->task_attribute = TSK_ORDERED;
1319 fcp_cmnd->task_attribute = 0;
1323 fcp_cmnd->task_attribute = 0;
1326 cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
1328 /* Compute dif len and adjust data len to incude protection */
1330 blk_size = cmd->device->sector_size;
1331 dif_bytes = (data_bytes / blk_size) * 8;
1333 switch (scsi_get_prot_op(GET_CMD_SP(sp))) {
1334 case SCSI_PROT_READ_INSERT:
1335 case SCSI_PROT_WRITE_STRIP:
1336 total_bytes = data_bytes;
1337 data_bytes += dif_bytes;
1340 case SCSI_PROT_READ_STRIP:
1341 case SCSI_PROT_WRITE_INSERT:
1342 case SCSI_PROT_READ_PASS:
1343 case SCSI_PROT_WRITE_PASS:
1344 total_bytes = data_bytes + dif_bytes;
1350 if (!qla2x00_hba_err_chk_enabled(sp))
1351 fw_prot_opts |= 0x10; /* Disable Guard tag checking */
1352 /* HBA error checking enabled */
1353 else if (IS_PI_UNINIT_CAPABLE(ha)) {
1354 if ((scsi_get_prot_type(GET_CMD_SP(sp)) == SCSI_PROT_DIF_TYPE1)
1355 || (scsi_get_prot_type(GET_CMD_SP(sp)) ==
1356 SCSI_PROT_DIF_TYPE2))
1357 fw_prot_opts |= BIT_10;
1358 else if (scsi_get_prot_type(GET_CMD_SP(sp)) ==
1359 SCSI_PROT_DIF_TYPE3)
1360 fw_prot_opts |= BIT_11;
1364 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.nobundling.data_address;
1367 * Configure Bundling if we need to fetch interlaving
1368 * protection PCI accesses
1370 fw_prot_opts |= PO_ENABLE_DIF_BUNDLING;
1371 crc_ctx_pkt->u.bundling.dif_byte_count = cpu_to_le32(dif_bytes);
1372 crc_ctx_pkt->u.bundling.dseg_count = cpu_to_le16(tot_dsds -
1374 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.data_address;
1377 /* Finish the common fields of CRC pkt */
1378 crc_ctx_pkt->blk_size = cpu_to_le16(blk_size);
1379 crc_ctx_pkt->prot_opts = cpu_to_le16(fw_prot_opts);
1380 crc_ctx_pkt->byte_count = cpu_to_le32(data_bytes);
1381 crc_ctx_pkt->guard_seed = __constant_cpu_to_le16(0);
1382 /* Fibre channel byte count */
1383 cmd_pkt->byte_count = cpu_to_le32(total_bytes);
1384 fcp_dl = (uint32_t *)(crc_ctx_pkt->fcp_cmnd.cdb + 16 +
1385 additional_fcpcdb_len);
1386 *fcp_dl = htonl(total_bytes);
1388 if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
1389 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
1392 /* Walks data segments */
1394 cmd_pkt->control_flags |=
1395 __constant_cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE);
1397 if (!bundling && tot_prot_dsds) {
1398 if (qla24xx_walk_and_build_sglist_no_difb(ha, sp,
1400 goto crc_queuing_error;
1401 } else if (qla24xx_walk_and_build_sglist(ha, sp, cur_dsd,
1402 (tot_dsds - tot_prot_dsds)))
1403 goto crc_queuing_error;
1405 if (bundling && tot_prot_dsds) {
1406 /* Walks dif segments */
1407 cur_seg = scsi_prot_sglist(cmd);
1408 cmd_pkt->control_flags |=
1409 __constant_cpu_to_le16(CF_DIF_SEG_DESCR_ENABLE);
1410 cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.dif_address;
1411 if (qla24xx_walk_and_build_prot_sglist(ha, sp, cur_dsd,
1413 goto crc_queuing_error;
1418 /* Cleanup will be performed by the caller */
1420 return QLA_FUNCTION_FAILED;
1424 * qla24xx_start_scsi() - Send a SCSI command to the ISP
1425 * @sp: command to send to the ISP
1427 * Returns non-zero if a failure occurred, else zero.
1430 qla24xx_start_scsi(srb_t *sp)
1433 unsigned long flags;
1437 struct cmd_type_7 *cmd_pkt;
1441 struct req_que *req = NULL;
1442 struct rsp_que *rsp = NULL;
1443 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1444 struct scsi_qla_host *vha = sp->fcport->vha;
1445 struct qla_hw_data *ha = vha->hw;
1448 /* Setup device pointers. */
1451 qla25xx_set_que(sp, &rsp);
1454 /* So we know we haven't pci_map'ed anything yet */
1457 /* Send marker if required */
1458 if (vha->marker_needed != 0) {
1459 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
1461 return QLA_FUNCTION_FAILED;
1462 vha->marker_needed = 0;
1465 /* Acquire ring specific lock */
1466 spin_lock_irqsave(&ha->hardware_lock, flags);
1468 /* Check for room in outstanding command list. */
1469 handle = req->current_outstanding_cmd;
1470 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1472 if (handle == MAX_OUTSTANDING_COMMANDS)
1474 if (!req->outstanding_cmds[handle])
1477 if (index == MAX_OUTSTANDING_COMMANDS) {
1481 /* Map the sg table so we have an accurate count of sg entries needed */
1482 if (scsi_sg_count(cmd)) {
1483 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
1484 scsi_sg_count(cmd), cmd->sc_data_direction);
1485 if (unlikely(!nseg))
1491 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
1492 if (req->cnt < (req_cnt + 2)) {
1493 cnt = RD_REG_DWORD_RELAXED(req->req_q_out);
1495 if (req->ring_index < cnt)
1496 req->cnt = cnt - req->ring_index;
1498 req->cnt = req->length -
1499 (req->ring_index - cnt);
1500 if (req->cnt < (req_cnt + 2))
1504 /* Build command packet. */
1505 req->current_outstanding_cmd = handle;
1506 req->outstanding_cmds[handle] = sp;
1507 sp->handle = handle;
1508 cmd->host_scribble = (unsigned char *)(unsigned long)handle;
1509 req->cnt -= req_cnt;
1511 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
1512 cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
1514 /* Zero out remaining portion of packet. */
1515 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */
1516 clr_ptr = (uint32_t *)cmd_pkt + 2;
1517 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1518 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1520 /* Set NPORT-ID and LUN number*/
1521 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1522 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
1523 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
1524 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
1525 cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
1527 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1528 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1530 /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */
1531 if (scsi_populate_tag_msg(cmd, tag)) {
1533 case HEAD_OF_QUEUE_TAG:
1534 cmd_pkt->task = TSK_HEAD_OF_QUEUE;
1536 case ORDERED_QUEUE_TAG:
1537 cmd_pkt->task = TSK_ORDERED;
1542 /* Load SCSI command packet. */
1543 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
1544 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
1546 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
1548 /* Build IOCB segments */
1549 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
1551 /* Set total data segment count. */
1552 cmd_pkt->entry_count = (uint8_t)req_cnt;
1553 /* Specify response queue number where completion should happen */
1554 cmd_pkt->entry_status = (uint8_t) rsp->id;
1556 /* Adjust ring index. */
1558 if (req->ring_index == req->length) {
1559 req->ring_index = 0;
1560 req->ring_ptr = req->ring;
1564 sp->flags |= SRB_DMA_VALID;
1566 /* Set chip new ring index. */
1567 WRT_REG_DWORD(req->req_q_in, req->ring_index);
1568 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr);
1570 /* Manage unprocessed RIO/ZIO commands in response queue. */
1571 if (vha->flags.process_response_queue &&
1572 rsp->ring_ptr->signature != RESPONSE_PROCESSED)
1573 qla24xx_process_response_queue(vha, rsp);
1575 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1580 scsi_dma_unmap(cmd);
1582 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1584 return QLA_FUNCTION_FAILED;
1589 * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP
1590 * @sp: command to send to the ISP
1592 * Returns non-zero if a failure occurred, else zero.
1595 qla24xx_dif_start_scsi(srb_t *sp)
1598 unsigned long flags;
1603 uint16_t req_cnt = 0;
1605 uint16_t tot_prot_dsds;
1606 uint16_t fw_prot_opts = 0;
1607 struct req_que *req = NULL;
1608 struct rsp_que *rsp = NULL;
1609 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1610 struct scsi_qla_host *vha = sp->fcport->vha;
1611 struct qla_hw_data *ha = vha->hw;
1612 struct cmd_type_crc_2 *cmd_pkt;
1613 uint32_t status = 0;
1615 #define QDSS_GOT_Q_SPACE BIT_0
1617 /* Only process protection or >16 cdb in this routine */
1618 if (scsi_get_prot_op(cmd) == SCSI_PROT_NORMAL) {
1619 if (cmd->cmd_len <= 16)
1620 return qla24xx_start_scsi(sp);
1623 /* Setup device pointers. */
1625 qla25xx_set_que(sp, &rsp);
1628 /* So we know we haven't pci_map'ed anything yet */
1631 /* Send marker if required */
1632 if (vha->marker_needed != 0) {
1633 if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
1635 return QLA_FUNCTION_FAILED;
1636 vha->marker_needed = 0;
1639 /* Acquire ring specific lock */
1640 spin_lock_irqsave(&ha->hardware_lock, flags);
1642 /* Check for room in outstanding command list. */
1643 handle = req->current_outstanding_cmd;
1644 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1646 if (handle == MAX_OUTSTANDING_COMMANDS)
1648 if (!req->outstanding_cmds[handle])
1652 if (index == MAX_OUTSTANDING_COMMANDS)
1655 /* Compute number of required data segments */
1656 /* Map the sg table so we have an accurate count of sg entries needed */
1657 if (scsi_sg_count(cmd)) {
1658 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
1659 scsi_sg_count(cmd), cmd->sc_data_direction);
1660 if (unlikely(!nseg))
1663 sp->flags |= SRB_DMA_VALID;
1665 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1666 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
1667 struct qla2_sgx sgx;
1670 memset(&sgx, 0, sizeof(struct qla2_sgx));
1671 sgx.tot_bytes = scsi_bufflen(cmd);
1672 sgx.cur_sg = scsi_sglist(cmd);
1676 while (qla24xx_get_one_block_sg(
1677 cmd->device->sector_size, &sgx, &partial))
1683 /* number of required data segments */
1686 /* Compute number of required protection segments */
1687 if (qla24xx_configure_prot_mode(sp, &fw_prot_opts)) {
1688 nseg = dma_map_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
1689 scsi_prot_sg_count(cmd), cmd->sc_data_direction);
1690 if (unlikely(!nseg))
1693 sp->flags |= SRB_CRC_PROT_DMA_VALID;
1695 if ((scsi_get_prot_op(cmd) == SCSI_PROT_READ_INSERT) ||
1696 (scsi_get_prot_op(cmd) == SCSI_PROT_WRITE_STRIP)) {
1697 nseg = scsi_bufflen(cmd) / cmd->device->sector_size;
1704 /* Total Data and protection sg segment(s) */
1705 tot_prot_dsds = nseg;
1707 if (req->cnt < (req_cnt + 2)) {
1708 cnt = RD_REG_DWORD_RELAXED(req->req_q_out);
1710 if (req->ring_index < cnt)
1711 req->cnt = cnt - req->ring_index;
1713 req->cnt = req->length -
1714 (req->ring_index - cnt);
1715 if (req->cnt < (req_cnt + 2))
1719 status |= QDSS_GOT_Q_SPACE;
1721 /* Build header part of command packet (excluding the OPCODE). */
1722 req->current_outstanding_cmd = handle;
1723 req->outstanding_cmds[handle] = sp;
1724 sp->handle = handle;
1725 cmd->host_scribble = (unsigned char *)(unsigned long)handle;
1726 req->cnt -= req_cnt;
1728 /* Fill-in common area */
1729 cmd_pkt = (struct cmd_type_crc_2 *)req->ring_ptr;
1730 cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
1732 clr_ptr = (uint32_t *)cmd_pkt + 2;
1733 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1735 /* Set NPORT-ID and LUN number*/
1736 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1737 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
1738 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
1739 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
1741 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1742 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1744 /* Total Data and protection segment(s) */
1745 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1747 /* Build IOCB segments and adjust for data protection segments */
1748 if (qla24xx_build_scsi_crc_2_iocbs(sp, (struct cmd_type_crc_2 *)
1749 req->ring_ptr, tot_dsds, tot_prot_dsds, fw_prot_opts) !=
1753 cmd_pkt->entry_count = (uint8_t)req_cnt;
1754 /* Specify response queue number where completion should happen */
1755 cmd_pkt->entry_status = (uint8_t) rsp->id;
1756 cmd_pkt->timeout = __constant_cpu_to_le16(0);
1759 /* Adjust ring index. */
1761 if (req->ring_index == req->length) {
1762 req->ring_index = 0;
1763 req->ring_ptr = req->ring;
1767 /* Set chip new ring index. */
1768 WRT_REG_DWORD(req->req_q_in, req->ring_index);
1769 RD_REG_DWORD_RELAXED(&ha->iobase->isp24.hccr);
1771 /* Manage unprocessed RIO/ZIO commands in response queue. */
1772 if (vha->flags.process_response_queue &&
1773 rsp->ring_ptr->signature != RESPONSE_PROCESSED)
1774 qla24xx_process_response_queue(vha, rsp);
1776 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1781 if (status & QDSS_GOT_Q_SPACE) {
1782 req->outstanding_cmds[handle] = NULL;
1783 req->cnt += req_cnt;
1785 /* Cleanup will be performed by the caller (queuecommand) */
1787 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1788 return QLA_FUNCTION_FAILED;
1792 static void qla25xx_set_que(srb_t *sp, struct rsp_que **rsp)
1794 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1795 struct qla_hw_data *ha = sp->fcport->vha->hw;
1796 int affinity = cmd->request->cpu;
1798 if (ha->flags.cpu_affinity_enabled && affinity >= 0 &&
1799 affinity < ha->max_rsp_queues - 1)
1800 *rsp = ha->rsp_q_map[affinity + 1];
1802 *rsp = ha->rsp_q_map[0];
1805 /* Generic Control-SRB manipulation functions. */
1807 qla2x00_alloc_iocbs(scsi_qla_host_t *vha, srb_t *sp)
1809 struct qla_hw_data *ha = vha->hw;
1810 struct req_que *req = ha->req_q_map[0];
1811 device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id);
1812 uint32_t index, handle;
1814 uint16_t cnt, req_cnt;
1821 goto skip_cmd_array;
1823 /* Check for room in outstanding command list. */
1824 handle = req->current_outstanding_cmd;
1825 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1827 if (handle == MAX_OUTSTANDING_COMMANDS)
1829 if (!req->outstanding_cmds[handle])
1832 if (index == MAX_OUTSTANDING_COMMANDS) {
1833 ql_log(ql_log_warn, vha, 0x700b,
1834 "No room on outstanding cmd array.\n");
1838 /* Prep command array. */
1839 req->current_outstanding_cmd = handle;
1840 req->outstanding_cmds[handle] = sp;
1841 sp->handle = handle;
1843 /* Adjust entry-counts as needed. */
1844 if (sp->type != SRB_SCSI_CMD)
1845 req_cnt = sp->iocbs;
1848 /* Check for room on request queue. */
1849 if (req->cnt < req_cnt) {
1850 if (ha->mqenable || IS_QLA83XX(ha))
1851 cnt = RD_REG_DWORD(®->isp25mq.req_q_out);
1852 else if (IS_QLA82XX(ha))
1853 cnt = RD_REG_DWORD(®->isp82.req_q_out);
1854 else if (IS_FWI2_CAPABLE(ha))
1855 cnt = RD_REG_DWORD(®->isp24.req_q_out);
1857 cnt = qla2x00_debounce_register(
1858 ISP_REQ_Q_OUT(ha, ®->isp));
1860 if (req->ring_index < cnt)
1861 req->cnt = cnt - req->ring_index;
1863 req->cnt = req->length -
1864 (req->ring_index - cnt);
1866 if (req->cnt < req_cnt)
1870 req->cnt -= req_cnt;
1871 pkt = req->ring_ptr;
1872 memset(pkt, 0, REQUEST_ENTRY_SIZE);
1873 pkt->entry_count = req_cnt;
1874 pkt->handle = handle;
1881 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1883 struct srb_iocb *lio = &sp->u.iocb_cmd;
1885 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1886 logio->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI);
1887 if (lio->u.logio.flags & SRB_LOGIN_COND_PLOGI)
1888 logio->control_flags |= cpu_to_le16(LCF_COND_PLOGI);
1889 if (lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI)
1890 logio->control_flags |= cpu_to_le16(LCF_SKIP_PRLI);
1891 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1892 logio->port_id[0] = sp->fcport->d_id.b.al_pa;
1893 logio->port_id[1] = sp->fcport->d_id.b.area;
1894 logio->port_id[2] = sp->fcport->d_id.b.domain;
1895 logio->vp_index = sp->fcport->vha->vp_idx;
1899 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx)
1901 struct qla_hw_data *ha = sp->fcport->vha->hw;
1902 struct srb_iocb *lio = &sp->u.iocb_cmd;
1905 mbx->entry_type = MBX_IOCB_TYPE;
1906 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
1907 mbx->mb0 = cpu_to_le16(MBC_LOGIN_FABRIC_PORT);
1908 opts = lio->u.logio.flags & SRB_LOGIN_COND_PLOGI ? BIT_0 : 0;
1909 opts |= lio->u.logio.flags & SRB_LOGIN_SKIP_PRLI ? BIT_1 : 0;
1910 if (HAS_EXTENDED_IDS(ha)) {
1911 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id);
1912 mbx->mb10 = cpu_to_le16(opts);
1914 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts);
1916 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain);
1917 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 |
1918 sp->fcport->d_id.b.al_pa);
1919 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx);
1923 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1925 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1926 logio->control_flags =
1927 cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
1928 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1929 logio->port_id[0] = sp->fcport->d_id.b.al_pa;
1930 logio->port_id[1] = sp->fcport->d_id.b.area;
1931 logio->port_id[2] = sp->fcport->d_id.b.domain;
1932 logio->vp_index = sp->fcport->vha->vp_idx;
1936 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx)
1938 struct qla_hw_data *ha = sp->fcport->vha->hw;
1940 mbx->entry_type = MBX_IOCB_TYPE;
1941 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
1942 mbx->mb0 = cpu_to_le16(MBC_LOGOUT_FABRIC_PORT);
1943 mbx->mb1 = HAS_EXTENDED_IDS(ha) ?
1944 cpu_to_le16(sp->fcport->loop_id):
1945 cpu_to_le16(sp->fcport->loop_id << 8);
1946 mbx->mb2 = cpu_to_le16(sp->fcport->d_id.b.domain);
1947 mbx->mb3 = cpu_to_le16(sp->fcport->d_id.b.area << 8 |
1948 sp->fcport->d_id.b.al_pa);
1949 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx);
1950 /* Implicit: mbx->mbx10 = 0. */
1954 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1956 logio->entry_type = LOGINOUT_PORT_IOCB_TYPE;
1957 logio->control_flags = cpu_to_le16(LCF_COMMAND_ADISC);
1958 logio->nport_handle = cpu_to_le16(sp->fcport->loop_id);
1959 logio->vp_index = sp->fcport->vha->vp_idx;
1963 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx)
1965 struct qla_hw_data *ha = sp->fcport->vha->hw;
1967 mbx->entry_type = MBX_IOCB_TYPE;
1968 SET_TARGET_ID(ha, mbx->loop_id, sp->fcport->loop_id);
1969 mbx->mb0 = cpu_to_le16(MBC_GET_PORT_DATABASE);
1970 if (HAS_EXTENDED_IDS(ha)) {
1971 mbx->mb1 = cpu_to_le16(sp->fcport->loop_id);
1972 mbx->mb10 = cpu_to_le16(BIT_0);
1974 mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0);
1976 mbx->mb2 = cpu_to_le16(MSW(ha->async_pd_dma));
1977 mbx->mb3 = cpu_to_le16(LSW(ha->async_pd_dma));
1978 mbx->mb6 = cpu_to_le16(MSW(MSD(ha->async_pd_dma)));
1979 mbx->mb7 = cpu_to_le16(LSW(MSD(ha->async_pd_dma)));
1980 mbx->mb9 = cpu_to_le16(sp->fcport->vha->vp_idx);
1984 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk)
1988 struct fc_port *fcport = sp->fcport;
1989 scsi_qla_host_t *vha = fcport->vha;
1990 struct qla_hw_data *ha = vha->hw;
1991 struct srb_iocb *iocb = &sp->u.iocb_cmd;
1992 struct req_que *req = vha->req;
1994 flags = iocb->u.tmf.flags;
1995 lun = iocb->u.tmf.lun;
1997 tsk->entry_type = TSK_MGMT_IOCB_TYPE;
1998 tsk->entry_count = 1;
1999 tsk->handle = MAKE_HANDLE(req->id, tsk->handle);
2000 tsk->nport_handle = cpu_to_le16(fcport->loop_id);
2001 tsk->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2002 tsk->control_flags = cpu_to_le32(flags);
2003 tsk->port_id[0] = fcport->d_id.b.al_pa;
2004 tsk->port_id[1] = fcport->d_id.b.area;
2005 tsk->port_id[2] = fcport->d_id.b.domain;
2006 tsk->vp_index = fcport->vha->vp_idx;
2008 if (flags == TCF_LUN_RESET) {
2009 int_to_scsilun(lun, &tsk->lun);
2010 host_to_fcp_swap((uint8_t *)&tsk->lun,
2016 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
2018 struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2020 els_iocb->entry_type = ELS_IOCB_TYPE;
2021 els_iocb->entry_count = 1;
2022 els_iocb->sys_define = 0;
2023 els_iocb->entry_status = 0;
2024 els_iocb->handle = sp->handle;
2025 els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2026 els_iocb->tx_dsd_count = __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
2027 els_iocb->vp_index = sp->fcport->vha->vp_idx;
2028 els_iocb->sof_type = EST_SOFI3;
2029 els_iocb->rx_dsd_count = __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
2032 sp->type == SRB_ELS_CMD_RPT ?
2033 bsg_job->request->rqst_data.r_els.els_code :
2034 bsg_job->request->rqst_data.h_els.command_code;
2035 els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
2036 els_iocb->port_id[1] = sp->fcport->d_id.b.area;
2037 els_iocb->port_id[2] = sp->fcport->d_id.b.domain;
2038 els_iocb->control_flags = 0;
2039 els_iocb->rx_byte_count =
2040 cpu_to_le32(bsg_job->reply_payload.payload_len);
2041 els_iocb->tx_byte_count =
2042 cpu_to_le32(bsg_job->request_payload.payload_len);
2044 els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address
2045 (bsg_job->request_payload.sg_list)));
2046 els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address
2047 (bsg_job->request_payload.sg_list)));
2048 els_iocb->tx_len = cpu_to_le32(sg_dma_len
2049 (bsg_job->request_payload.sg_list));
2051 els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address
2052 (bsg_job->reply_payload.sg_list)));
2053 els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address
2054 (bsg_job->reply_payload.sg_list)));
2055 els_iocb->rx_len = cpu_to_le32(sg_dma_len
2056 (bsg_job->reply_payload.sg_list));
2060 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb)
2062 uint16_t avail_dsds;
2064 struct scatterlist *sg;
2067 scsi_qla_host_t *vha = sp->fcport->vha;
2068 struct qla_hw_data *ha = vha->hw;
2069 struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2070 int loop_iterartion = 0;
2071 int cont_iocb_prsnt = 0;
2072 int entry_count = 1;
2074 memset(ct_iocb, 0, sizeof(ms_iocb_entry_t));
2075 ct_iocb->entry_type = CT_IOCB_TYPE;
2076 ct_iocb->entry_status = 0;
2077 ct_iocb->handle1 = sp->handle;
2078 SET_TARGET_ID(ha, ct_iocb->loop_id, sp->fcport->loop_id);
2079 ct_iocb->status = __constant_cpu_to_le16(0);
2080 ct_iocb->control_flags = __constant_cpu_to_le16(0);
2081 ct_iocb->timeout = 0;
2082 ct_iocb->cmd_dsd_count =
2083 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
2084 ct_iocb->total_dsd_count =
2085 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt + 1);
2086 ct_iocb->req_bytecount =
2087 cpu_to_le32(bsg_job->request_payload.payload_len);
2088 ct_iocb->rsp_bytecount =
2089 cpu_to_le32(bsg_job->reply_payload.payload_len);
2091 ct_iocb->dseg_req_address[0] = cpu_to_le32(LSD(sg_dma_address
2092 (bsg_job->request_payload.sg_list)));
2093 ct_iocb->dseg_req_address[1] = cpu_to_le32(MSD(sg_dma_address
2094 (bsg_job->request_payload.sg_list)));
2095 ct_iocb->dseg_req_length = ct_iocb->req_bytecount;
2097 ct_iocb->dseg_rsp_address[0] = cpu_to_le32(LSD(sg_dma_address
2098 (bsg_job->reply_payload.sg_list)));
2099 ct_iocb->dseg_rsp_address[1] = cpu_to_le32(MSD(sg_dma_address
2100 (bsg_job->reply_payload.sg_list)));
2101 ct_iocb->dseg_rsp_length = ct_iocb->rsp_bytecount;
2104 cur_dsd = (uint32_t *)ct_iocb->dseg_rsp_address;
2106 tot_dsds = bsg_job->reply_payload.sg_cnt;
2108 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
2110 cont_a64_entry_t *cont_pkt;
2112 /* Allocate additional continuation packets? */
2113 if (avail_dsds == 0) {
2115 * Five DSDs are available in the Cont.
2118 cont_pkt = qla2x00_prep_cont_type1_iocb(vha,
2119 vha->hw->req_q_map[0]);
2120 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2122 cont_iocb_prsnt = 1;
2126 sle_dma = sg_dma_address(sg);
2127 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
2128 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
2129 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
2133 ct_iocb->entry_count = entry_count;
2137 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb)
2139 uint16_t avail_dsds;
2141 struct scatterlist *sg;
2144 scsi_qla_host_t *vha = sp->fcport->vha;
2145 struct qla_hw_data *ha = vha->hw;
2146 struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2147 int loop_iterartion = 0;
2148 int cont_iocb_prsnt = 0;
2149 int entry_count = 1;
2151 ct_iocb->entry_type = CT_IOCB_TYPE;
2152 ct_iocb->entry_status = 0;
2153 ct_iocb->sys_define = 0;
2154 ct_iocb->handle = sp->handle;
2156 ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2157 ct_iocb->vp_index = sp->fcport->vha->vp_idx;
2158 ct_iocb->comp_status = __constant_cpu_to_le16(0);
2160 ct_iocb->cmd_dsd_count =
2161 __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
2162 ct_iocb->timeout = 0;
2163 ct_iocb->rsp_dsd_count =
2164 __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
2165 ct_iocb->rsp_byte_count =
2166 cpu_to_le32(bsg_job->reply_payload.payload_len);
2167 ct_iocb->cmd_byte_count =
2168 cpu_to_le32(bsg_job->request_payload.payload_len);
2169 ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address
2170 (bsg_job->request_payload.sg_list)));
2171 ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address
2172 (bsg_job->request_payload.sg_list)));
2173 ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len
2174 (bsg_job->request_payload.sg_list));
2177 cur_dsd = (uint32_t *)ct_iocb->dseg_1_address;
2179 tot_dsds = bsg_job->reply_payload.sg_cnt;
2181 for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
2183 cont_a64_entry_t *cont_pkt;
2185 /* Allocate additional continuation packets? */
2186 if (avail_dsds == 0) {
2188 * Five DSDs are available in the Cont.
2191 cont_pkt = qla2x00_prep_cont_type1_iocb(vha,
2193 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2195 cont_iocb_prsnt = 1;
2199 sle_dma = sg_dma_address(sg);
2200 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
2201 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
2202 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
2206 ct_iocb->entry_count = entry_count;
2210 * qla82xx_start_scsi() - Send a SCSI command to the ISP
2211 * @sp: command to send to the ISP
2213 * Returns non-zero if a failure occurred, else zero.
2216 qla82xx_start_scsi(srb_t *sp)
2219 unsigned long flags;
2220 struct scsi_cmnd *cmd;
2227 struct device_reg_82xx __iomem *reg;
2230 uint8_t additional_cdb_len;
2231 struct ct6_dsd *ctx;
2232 struct scsi_qla_host *vha = sp->fcport->vha;
2233 struct qla_hw_data *ha = vha->hw;
2234 struct req_que *req = NULL;
2235 struct rsp_que *rsp = NULL;
2238 /* Setup device pointers. */
2240 reg = &ha->iobase->isp82;
2241 cmd = GET_CMD_SP(sp);
2243 rsp = ha->rsp_q_map[0];
2245 /* So we know we haven't pci_map'ed anything yet */
2248 dbval = 0x04 | (ha->portnum << 5);
2250 /* Send marker if required */
2251 if (vha->marker_needed != 0) {
2252 if (qla2x00_marker(vha, req,
2253 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
2254 ql_log(ql_log_warn, vha, 0x300c,
2255 "qla2x00_marker failed for cmd=%p.\n", cmd);
2256 return QLA_FUNCTION_FAILED;
2258 vha->marker_needed = 0;
2261 /* Acquire ring specific lock */
2262 spin_lock_irqsave(&ha->hardware_lock, flags);
2264 /* Check for room in outstanding command list. */
2265 handle = req->current_outstanding_cmd;
2266 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
2268 if (handle == MAX_OUTSTANDING_COMMANDS)
2270 if (!req->outstanding_cmds[handle])
2273 if (index == MAX_OUTSTANDING_COMMANDS)
2276 /* Map the sg table so we have an accurate count of sg entries needed */
2277 if (scsi_sg_count(cmd)) {
2278 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
2279 scsi_sg_count(cmd), cmd->sc_data_direction);
2280 if (unlikely(!nseg))
2287 if (tot_dsds > ql2xshiftctondsd) {
2288 struct cmd_type_6 *cmd_pkt;
2289 uint16_t more_dsd_lists = 0;
2290 struct dsd_dma *dsd_ptr;
2293 more_dsd_lists = qla24xx_calc_dsd_lists(tot_dsds);
2294 if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN) {
2295 ql_dbg(ql_dbg_io, vha, 0x300d,
2296 "Num of DSD list %d is than %d for cmd=%p.\n",
2297 more_dsd_lists + ha->gbl_dsd_inuse, NUM_DSD_CHAIN,
2302 if (more_dsd_lists <= ha->gbl_dsd_avail)
2303 goto sufficient_dsds;
2305 more_dsd_lists -= ha->gbl_dsd_avail;
2307 for (i = 0; i < more_dsd_lists; i++) {
2308 dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
2310 ql_log(ql_log_fatal, vha, 0x300e,
2311 "Failed to allocate memory for dsd_dma "
2312 "for cmd=%p.\n", cmd);
2316 dsd_ptr->dsd_addr = dma_pool_alloc(ha->dl_dma_pool,
2317 GFP_ATOMIC, &dsd_ptr->dsd_list_dma);
2318 if (!dsd_ptr->dsd_addr) {
2320 ql_log(ql_log_fatal, vha, 0x300f,
2321 "Failed to allocate memory for dsd_addr "
2322 "for cmd=%p.\n", cmd);
2325 list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list);
2326 ha->gbl_dsd_avail++;
2332 if (req->cnt < (req_cnt + 2)) {
2333 cnt = (uint16_t)RD_REG_DWORD_RELAXED(
2334 ®->req_q_out[0]);
2335 if (req->ring_index < cnt)
2336 req->cnt = cnt - req->ring_index;
2338 req->cnt = req->length -
2339 (req->ring_index - cnt);
2340 if (req->cnt < (req_cnt + 2))
2344 ctx = sp->u.scmd.ctx =
2345 mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
2347 ql_log(ql_log_fatal, vha, 0x3010,
2348 "Failed to allocate ctx for cmd=%p.\n", cmd);
2352 memset(ctx, 0, sizeof(struct ct6_dsd));
2353 ctx->fcp_cmnd = dma_pool_alloc(ha->fcp_cmnd_dma_pool,
2354 GFP_ATOMIC, &ctx->fcp_cmnd_dma);
2355 if (!ctx->fcp_cmnd) {
2356 ql_log(ql_log_fatal, vha, 0x3011,
2357 "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd);
2361 /* Initialize the DSD list and dma handle */
2362 INIT_LIST_HEAD(&ctx->dsd_list);
2363 ctx->dsd_use_cnt = 0;
2365 if (cmd->cmd_len > 16) {
2366 additional_cdb_len = cmd->cmd_len - 16;
2367 if ((cmd->cmd_len % 4) != 0) {
2368 /* SCSI command bigger than 16 bytes must be
2371 ql_log(ql_log_warn, vha, 0x3012,
2372 "scsi cmd len %d not multiple of 4 "
2373 "for cmd=%p.\n", cmd->cmd_len, cmd);
2374 goto queuing_error_fcp_cmnd;
2376 ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4;
2378 additional_cdb_len = 0;
2379 ctx->fcp_cmnd_len = 12 + 16 + 4;
2382 cmd_pkt = (struct cmd_type_6 *)req->ring_ptr;
2383 cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2385 /* Zero out remaining portion of packet. */
2386 /* tagged queuing modifier -- default is TSK_SIMPLE (0). */
2387 clr_ptr = (uint32_t *)cmd_pkt + 2;
2388 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
2389 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
2391 /* Set NPORT-ID and LUN number*/
2392 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2393 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
2394 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
2395 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
2396 cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
2398 /* Build IOCB segments */
2399 if (qla24xx_build_scsi_type_6_iocbs(sp, cmd_pkt, tot_dsds))
2400 goto queuing_error_fcp_cmnd;
2402 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
2403 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
2405 /* build FCP_CMND IU */
2406 memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd));
2407 int_to_scsilun(cmd->device->lun, &ctx->fcp_cmnd->lun);
2408 ctx->fcp_cmnd->additional_cdb_len = additional_cdb_len;
2410 if (cmd->sc_data_direction == DMA_TO_DEVICE)
2411 ctx->fcp_cmnd->additional_cdb_len |= 1;
2412 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
2413 ctx->fcp_cmnd->additional_cdb_len |= 2;
2416 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
2418 if (scsi_populate_tag_msg(cmd, tag)) {
2420 case HEAD_OF_QUEUE_TAG:
2421 ctx->fcp_cmnd->task_attribute =
2424 case ORDERED_QUEUE_TAG:
2425 ctx->fcp_cmnd->task_attribute =
2431 /* Populate the FCP_PRIO. */
2432 if (ha->flags.fcp_prio_enabled)
2433 ctx->fcp_cmnd->task_attribute |=
2434 sp->fcport->fcp_prio << 3;
2436 memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
2438 fcp_dl = (uint32_t *)(ctx->fcp_cmnd->cdb + 16 +
2439 additional_cdb_len);
2440 *fcp_dl = htonl((uint32_t)scsi_bufflen(cmd));
2442 cmd_pkt->fcp_cmnd_dseg_len = cpu_to_le16(ctx->fcp_cmnd_len);
2443 cmd_pkt->fcp_cmnd_dseg_address[0] =
2444 cpu_to_le32(LSD(ctx->fcp_cmnd_dma));
2445 cmd_pkt->fcp_cmnd_dseg_address[1] =
2446 cpu_to_le32(MSD(ctx->fcp_cmnd_dma));
2448 sp->flags |= SRB_FCP_CMND_DMA_VALID;
2449 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
2450 /* Set total data segment count. */
2451 cmd_pkt->entry_count = (uint8_t)req_cnt;
2452 /* Specify response queue number where
2453 * completion should happen
2455 cmd_pkt->entry_status = (uint8_t) rsp->id;
2457 struct cmd_type_7 *cmd_pkt;
2458 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
2459 if (req->cnt < (req_cnt + 2)) {
2460 cnt = (uint16_t)RD_REG_DWORD_RELAXED(
2461 ®->req_q_out[0]);
2462 if (req->ring_index < cnt)
2463 req->cnt = cnt - req->ring_index;
2465 req->cnt = req->length -
2466 (req->ring_index - cnt);
2468 if (req->cnt < (req_cnt + 2))
2471 cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
2472 cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2474 /* Zero out remaining portion of packet. */
2475 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/
2476 clr_ptr = (uint32_t *)cmd_pkt + 2;
2477 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
2478 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
2480 /* Set NPORT-ID and LUN number*/
2481 cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
2482 cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
2483 cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
2484 cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
2485 cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
2487 int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
2488 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun,
2489 sizeof(cmd_pkt->lun));
2492 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
2494 if (scsi_populate_tag_msg(cmd, tag)) {
2496 case HEAD_OF_QUEUE_TAG:
2497 cmd_pkt->task = TSK_HEAD_OF_QUEUE;
2499 case ORDERED_QUEUE_TAG:
2500 cmd_pkt->task = TSK_ORDERED;
2505 /* Populate the FCP_PRIO. */
2506 if (ha->flags.fcp_prio_enabled)
2507 cmd_pkt->task |= sp->fcport->fcp_prio << 3;
2509 /* Load SCSI command packet. */
2510 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
2511 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
2513 cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
2515 /* Build IOCB segments */
2516 qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
2518 /* Set total data segment count. */
2519 cmd_pkt->entry_count = (uint8_t)req_cnt;
2520 /* Specify response queue number where
2521 * completion should happen.
2523 cmd_pkt->entry_status = (uint8_t) rsp->id;
2526 /* Build command packet. */
2527 req->current_outstanding_cmd = handle;
2528 req->outstanding_cmds[handle] = sp;
2529 sp->handle = handle;
2530 cmd->host_scribble = (unsigned char *)(unsigned long)handle;
2531 req->cnt -= req_cnt;
2534 /* Adjust ring index. */
2536 if (req->ring_index == req->length) {
2537 req->ring_index = 0;
2538 req->ring_ptr = req->ring;
2542 sp->flags |= SRB_DMA_VALID;
2544 /* Set chip new ring index. */
2545 /* write, read and verify logic */
2546 dbval = dbval | (req->id << 8) | (req->ring_index << 16);
2548 qla82xx_wr_32(ha, ha->nxdb_wr_ptr, dbval);
2551 (unsigned long __iomem *)ha->nxdb_wr_ptr,
2554 while (RD_REG_DWORD(ha->nxdb_rd_ptr) != dbval) {
2556 (unsigned long __iomem *)ha->nxdb_wr_ptr,
2562 /* Manage unprocessed RIO/ZIO commands in response queue. */
2563 if (vha->flags.process_response_queue &&
2564 rsp->ring_ptr->signature != RESPONSE_PROCESSED)
2565 qla24xx_process_response_queue(vha, rsp);
2567 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2570 queuing_error_fcp_cmnd:
2571 dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma);
2574 scsi_dma_unmap(cmd);
2576 if (sp->u.scmd.ctx) {
2577 mempool_free(sp->u.scmd.ctx, ha->ctx_mempool);
2578 sp->u.scmd.ctx = NULL;
2580 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2582 return QLA_FUNCTION_FAILED;
2586 qla2x00_start_sp(srb_t *sp)
2589 struct qla_hw_data *ha = sp->fcport->vha->hw;
2591 unsigned long flags;
2593 rval = QLA_FUNCTION_FAILED;
2594 spin_lock_irqsave(&ha->hardware_lock, flags);
2595 pkt = qla2x00_alloc_iocbs(sp->fcport->vha, sp);
2597 ql_log(ql_log_warn, sp->fcport->vha, 0x700c,
2598 "qla2x00_alloc_iocbs failed.\n");
2605 IS_FWI2_CAPABLE(ha) ?
2606 qla24xx_login_iocb(sp, pkt) :
2607 qla2x00_login_iocb(sp, pkt);
2609 case SRB_LOGOUT_CMD:
2610 IS_FWI2_CAPABLE(ha) ?
2611 qla24xx_logout_iocb(sp, pkt) :
2612 qla2x00_logout_iocb(sp, pkt);
2614 case SRB_ELS_CMD_RPT:
2615 case SRB_ELS_CMD_HST:
2616 qla24xx_els_iocb(sp, pkt);
2619 IS_FWI2_CAPABLE(ha) ?
2620 qla24xx_ct_iocb(sp, pkt) :
2621 qla2x00_ct_iocb(sp, pkt);
2624 IS_FWI2_CAPABLE(ha) ?
2625 qla24xx_adisc_iocb(sp, pkt) :
2626 qla2x00_adisc_iocb(sp, pkt);
2629 qla24xx_tm_iocb(sp, pkt);
2636 qla2x00_start_iocbs(sp->fcport->vha, ha->req_q_map[0]);
2638 spin_unlock_irqrestore(&ha->hardware_lock, flags);
2643 qla25xx_build_bidir_iocb(srb_t *sp, struct scsi_qla_host *vha,
2644 struct cmd_bidir *cmd_pkt, uint32_t tot_dsds)
2646 uint16_t avail_dsds;
2648 uint32_t req_data_len = 0;
2649 uint32_t rsp_data_len = 0;
2650 struct scatterlist *sg;
2652 int entry_count = 1;
2653 struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2655 /*Update entry type to indicate bidir command */
2656 *((uint32_t *)(&cmd_pkt->entry_type)) =
2657 __constant_cpu_to_le32(COMMAND_BIDIRECTIONAL);
2659 /* Set the transfer direction, in this set both flags
2660 * Also set the BD_WRAP_BACK flag, firmware will take care
2661 * assigning DID=SID for outgoing pkts.
2663 cmd_pkt->wr_dseg_count = cpu_to_le16(bsg_job->request_payload.sg_cnt);
2664 cmd_pkt->rd_dseg_count = cpu_to_le16(bsg_job->reply_payload.sg_cnt);
2665 cmd_pkt->control_flags =
2666 __constant_cpu_to_le16(BD_WRITE_DATA | BD_READ_DATA |
2669 req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
2670 cmd_pkt->wr_byte_count = cpu_to_le32(req_data_len);
2671 cmd_pkt->rd_byte_count = cpu_to_le32(rsp_data_len);
2672 cmd_pkt->timeout = cpu_to_le16(qla2x00_get_async_timeout(vha) + 2);
2674 vha->bidi_stats.transfer_bytes += req_data_len;
2675 vha->bidi_stats.io_count++;
2677 /* Only one dsd is available for bidirectional IOCB, remaining dsds
2678 * are bundled in continuation iocb
2681 cur_dsd = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
2685 for_each_sg(bsg_job->request_payload.sg_list, sg,
2686 bsg_job->request_payload.sg_cnt, index) {
2688 cont_a64_entry_t *cont_pkt;
2690 /* Allocate additional continuation packets */
2691 if (avail_dsds == 0) {
2692 /* Continuation type 1 IOCB can accomodate
2695 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
2696 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2700 sle_dma = sg_dma_address(sg);
2701 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
2702 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
2703 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
2706 /* For read request DSD will always goes to continuation IOCB
2707 * and follow the write DSD. If there is room on the current IOCB
2708 * then it is added to that IOCB else new continuation IOCB is
2711 for_each_sg(bsg_job->reply_payload.sg_list, sg,
2712 bsg_job->reply_payload.sg_cnt, index) {
2714 cont_a64_entry_t *cont_pkt;
2716 /* Allocate additional continuation packets */
2717 if (avail_dsds == 0) {
2718 /* Continuation type 1 IOCB can accomodate
2721 cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
2722 cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2726 sle_dma = sg_dma_address(sg);
2727 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
2728 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
2729 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
2732 /* This value should be same as number of IOCB required for this cmd */
2733 cmd_pkt->entry_count = entry_count;
2737 qla2x00_start_bidir(srb_t *sp, struct scsi_qla_host *vha, uint32_t tot_dsds)
2740 struct qla_hw_data *ha = vha->hw;
2741 unsigned long flags;
2747 struct cmd_bidir *cmd_pkt = NULL;
2748 struct rsp_que *rsp;
2749 struct req_que *req;
2750 int rval = EXT_STATUS_OK;
2751 device_reg_t __iomem *reg = ISP_QUE_REG(ha, vha->req->id);
2755 rsp = ha->rsp_q_map[0];
2758 /* Send marker if required */
2759 if (vha->marker_needed != 0) {
2760 if (qla2x00_marker(vha, req,
2761 rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS)
2762 return EXT_STATUS_MAILBOX;
2763 vha->marker_needed = 0;
2766 /* Acquire ring specific lock */
2767 spin_lock_irqsave(&ha->hardware_lock, flags);
2769 /* Check for room in outstanding command list. */
2770 handle = req->current_outstanding_cmd;
2771 for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
2773 if (handle == MAX_OUTSTANDING_COMMANDS)
2775 if (!req->outstanding_cmds[handle])
2779 if (index == MAX_OUTSTANDING_COMMANDS) {
2780 rval = EXT_STATUS_BUSY;
2784 /* Calculate number of IOCB required */
2785 req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
2787 /* Check for room on request queue. */
2788 if (req->cnt < req_cnt + 2) {
2790 cnt = RD_REG_DWORD(®->isp25mq.req_q_out);
2791 else if (IS_QLA82XX(ha))
2792 cnt = RD_REG_DWORD(®->isp82.req_q_out);
2793 else if (IS_FWI2_CAPABLE(ha))
2794 cnt = RD_REG_DWORD(®->isp24.req_q_out);
2796 cnt = qla2x00_debounce_register(
2797 ISP_REQ_Q_OUT(ha, ®->isp));
2799 if (req->ring_index < cnt)
2800 req->cnt = cnt - req->ring_index;
2802 req->cnt = req->length -
2803 (req->ring_index - cnt);
2805 if (req->cnt < req_cnt + 2) {
2806 rval = EXT_STATUS_BUSY;
2810 cmd_pkt = (struct cmd_bidir *)req->ring_ptr;
2811 cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2813 /* Zero out remaining portion of packet. */
2814 /* tagged queuing modifier -- default is TSK_SIMPLE (0).*/
2815 clr_ptr = (uint32_t *)cmd_pkt + 2;
2816 memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
2818 /* Set NPORT-ID (of vha)*/
2819 cmd_pkt->nport_handle = cpu_to_le16(vha->self_login_loop_id);
2820 cmd_pkt->port_id[0] = vha->d_id.b.al_pa;
2821 cmd_pkt->port_id[1] = vha->d_id.b.area;
2822 cmd_pkt->port_id[2] = vha->d_id.b.domain;
2824 qla25xx_build_bidir_iocb(sp, vha, cmd_pkt, tot_dsds);
2825 cmd_pkt->entry_status = (uint8_t) rsp->id;
2826 /* Build command packet. */
2827 req->current_outstanding_cmd = handle;
2828 req->outstanding_cmds[handle] = sp;
2829 sp->handle = handle;
2830 req->cnt -= req_cnt;
2832 /* Send the command to the firmware */
2834 qla2x00_start_iocbs(vha, req);
2836 spin_unlock_irqrestore(&ha->hardware_lock, flags);