xref: /linux/drivers/scsi/qla2xxx/qla_iocb.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2012 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 static void qla25xx_set_que(srb_t *, struct rsp_que **);
16 /**
17  * qla2x00_get_cmd_direction() - Determine control_flag data direction.
18  * @cmd: SCSI command
19  *
20  * Returns the proper CF_* direction based on CDB.
21  */
22 static inline uint16_t
23 qla2x00_get_cmd_direction(srb_t *sp)
24 {
25 	uint16_t cflags;
26 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
27 	struct scsi_qla_host *vha = sp->fcport->vha;
28 
29 	cflags = 0;
30 
31 	/* Set transfer direction */
32 	if (cmd->sc_data_direction == DMA_TO_DEVICE) {
33 		cflags = CF_WRITE;
34 		vha->qla_stats.output_bytes += scsi_bufflen(cmd);
35 	} else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
36 		cflags = CF_READ;
37 		vha->qla_stats.input_bytes += scsi_bufflen(cmd);
38 	}
39 	return (cflags);
40 }
41 
42 /**
43  * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and
44  * Continuation Type 0 IOCBs to allocate.
45  *
46  * @dsds: number of data segment decriptors needed
47  *
48  * Returns the number of IOCB entries needed to store @dsds.
49  */
50 uint16_t
51 qla2x00_calc_iocbs_32(uint16_t dsds)
52 {
53 	uint16_t iocbs;
54 
55 	iocbs = 1;
56 	if (dsds > 3) {
57 		iocbs += (dsds - 3) / 7;
58 		if ((dsds - 3) % 7)
59 			iocbs++;
60 	}
61 	return (iocbs);
62 }
63 
64 /**
65  * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and
66  * Continuation Type 1 IOCBs to allocate.
67  *
68  * @dsds: number of data segment decriptors needed
69  *
70  * Returns the number of IOCB entries needed to store @dsds.
71  */
72 uint16_t
73 qla2x00_calc_iocbs_64(uint16_t dsds)
74 {
75 	uint16_t iocbs;
76 
77 	iocbs = 1;
78 	if (dsds > 2) {
79 		iocbs += (dsds - 2) / 5;
80 		if ((dsds - 2) % 5)
81 			iocbs++;
82 	}
83 	return (iocbs);
84 }
85 
86 /**
87  * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB.
88  * @ha: HA context
89  *
90  * Returns a pointer to the Continuation Type 0 IOCB packet.
91  */
92 static inline cont_entry_t *
93 qla2x00_prep_cont_type0_iocb(struct scsi_qla_host *vha)
94 {
95 	cont_entry_t *cont_pkt;
96 	struct req_que *req = vha->req;
97 	/* Adjust ring index. */
98 	req->ring_index++;
99 	if (req->ring_index == req->length) {
100 		req->ring_index = 0;
101 		req->ring_ptr = req->ring;
102 	} else {
103 		req->ring_ptr++;
104 	}
105 
106 	cont_pkt = (cont_entry_t *)req->ring_ptr;
107 
108 	/* Load packet defaults. */
109 	*((uint32_t *)(&cont_pkt->entry_type)) =
110 	    __constant_cpu_to_le32(CONTINUE_TYPE);
111 
112 	return (cont_pkt);
113 }
114 
115 /**
116  * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB.
117  * @ha: HA context
118  *
119  * Returns a pointer to the continuation type 1 IOCB packet.
120  */
121 static inline cont_a64_entry_t *
122 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *vha, struct req_que *req)
123 {
124 	cont_a64_entry_t *cont_pkt;
125 
126 	/* Adjust ring index. */
127 	req->ring_index++;
128 	if (req->ring_index == req->length) {
129 		req->ring_index = 0;
130 		req->ring_ptr = req->ring;
131 	} else {
132 		req->ring_ptr++;
133 	}
134 
135 	cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
136 
137 	/* Load packet defaults. */
138 	*((uint32_t *)(&cont_pkt->entry_type)) =
139 	    __constant_cpu_to_le32(CONTINUE_A64_TYPE);
140 
141 	return (cont_pkt);
142 }
143 
144 static inline int
145 qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts)
146 {
147 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
148 	uint8_t	guard = scsi_host_get_guard(cmd->device->host);
149 
150 	/* We always use DIFF Bundling for best performance */
151 	*fw_prot_opts = 0;
152 
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;
157 		break;
158 	case SCSI_PROT_WRITE_INSERT:
159 		*fw_prot_opts |= PO_MODE_DIF_INSERT;
160 		break;
161 	case SCSI_PROT_READ_INSERT:
162 		*fw_prot_opts |= PO_MODE_DIF_INSERT;
163 		break;
164 	case SCSI_PROT_WRITE_STRIP:
165 		*fw_prot_opts |= PO_MODE_DIF_REMOVE;
166 		break;
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;
171 		else
172 			*fw_prot_opts |= PO_MODE_DIF_PASS;
173 		break;
174 	default:	/* Normal Request */
175 		*fw_prot_opts |= PO_MODE_DIF_PASS;
176 		break;
177 	}
178 
179 	return scsi_prot_sg_count(cmd);
180 }
181 
182 /*
183  * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit
184  * capable IOCB types.
185  *
186  * @sp: SRB command to process
187  * @cmd_pkt: Command type 2 IOCB
188  * @tot_dsds: Total number of segments to transfer
189  */
190 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt,
191     uint16_t tot_dsds)
192 {
193 	uint16_t	avail_dsds;
194 	uint32_t	*cur_dsd;
195 	scsi_qla_host_t	*vha;
196 	struct scsi_cmnd *cmd;
197 	struct scatterlist *sg;
198 	int i;
199 
200 	cmd = GET_CMD_SP(sp);
201 
202 	/* Update entry type to indicate Command Type 2 IOCB */
203 	*((uint32_t *)(&cmd_pkt->entry_type)) =
204 	    __constant_cpu_to_le32(COMMAND_TYPE);
205 
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);
209 		return;
210 	}
211 
212 	vha = sp->fcport->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 = 3;
217 	cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
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 = (uint32_t *)&cont_pkt->dseg_0_address;
231 			avail_dsds = 7;
232 		}
233 
234 		*cur_dsd++ = cpu_to_le32(sg_dma_address(sg));
235 		*cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
236 		avail_dsds--;
237 	}
238 }
239 
240 /**
241  * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit
242  * capable IOCB types.
243  *
244  * @sp: SRB command to process
245  * @cmd_pkt: Command type 3 IOCB
246  * @tot_dsds: Total number of segments to transfer
247  */
248 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,
249     uint16_t tot_dsds)
250 {
251 	uint16_t	avail_dsds;
252 	uint32_t	*cur_dsd;
253 	scsi_qla_host_t	*vha;
254 	struct scsi_cmnd *cmd;
255 	struct scatterlist *sg;
256 	int i;
257 
258 	cmd = GET_CMD_SP(sp);
259 
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);
263 
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);
267 		return;
268 	}
269 
270 	vha = sp->fcport->vha;
271 	cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
272 
273 	/* Two DSDs are available in the Command Type 3 IOCB */
274 	avail_dsds = 2;
275 	cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
276 
277 	/* Load data segments */
278 	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
279 		dma_addr_t	sle_dma;
280 		cont_a64_entry_t *cont_pkt;
281 
282 		/* Allocate additional continuation packets? */
283 		if (avail_dsds == 0) {
284 			/*
285 			 * Five DSDs are available in the Continuation
286 			 * Type 1 IOCB.
287 			 */
288 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
289 			cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
290 			avail_dsds = 5;
291 		}
292 
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));
297 		avail_dsds--;
298 	}
299 }
300 
301 /**
302  * qla2x00_start_scsi() - Send a SCSI command to the ISP
303  * @sp: command to send to the ISP
304  *
305  * Returns non-zero if a failure occurred, else zero.
306  */
307 int
308 qla2x00_start_scsi(srb_t *sp)
309 {
310 	int		ret, nseg;
311 	unsigned long   flags;
312 	scsi_qla_host_t	*vha;
313 	struct scsi_cmnd *cmd;
314 	uint32_t	*clr_ptr;
315 	uint32_t        index;
316 	uint32_t	handle;
317 	cmd_entry_t	*cmd_pkt;
318 	uint16_t	cnt;
319 	uint16_t	req_cnt;
320 	uint16_t	tot_dsds;
321 	struct device_reg_2xxx __iomem *reg;
322 	struct qla_hw_data *ha;
323 	struct req_que *req;
324 	struct rsp_que *rsp;
325 	char		tag[2];
326 
327 	/* Setup device pointers. */
328 	ret = 0;
329 	vha = sp->fcport->vha;
330 	ha = vha->hw;
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 */
336 	tot_dsds = 0;
337 
338 	/* Send marker if required */
339 	if (vha->marker_needed != 0) {
340 		if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
341 		    QLA_SUCCESS) {
342 			return (QLA_FUNCTION_FAILED);
343 		}
344 		vha->marker_needed = 0;
345 	}
346 
347 	/* Acquire ring specific lock */
348 	spin_lock_irqsave(&ha->hardware_lock, flags);
349 
350 	/* Check for room in outstanding command list. */
351 	handle = req->current_outstanding_cmd;
352 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
353 		handle++;
354 		if (handle == MAX_OUTSTANDING_COMMANDS)
355 			handle = 1;
356 		if (!req->outstanding_cmds[handle])
357 			break;
358 	}
359 	if (index == MAX_OUTSTANDING_COMMANDS)
360 		goto queuing_error;
361 
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);
366 		if (unlikely(!nseg))
367 			goto queuing_error;
368 	} else
369 		nseg = 0;
370 
371 	tot_dsds = nseg;
372 
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;
379 		else
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))
384 			goto queuing_error;
385 	}
386 
387 	/* Build command packet */
388 	req->current_outstanding_cmd = handle;
389 	req->outstanding_cmds[handle] = sp;
390 	sp->handle = handle;
391 	cmd->host_scribble = (unsigned char *)(unsigned long)handle;
392 	req->cnt -= req_cnt;
393 
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);
400 
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);
404 
405 	/* Update tagged queuing modifier */
406 	if (scsi_populate_tag_msg(cmd, tag)) {
407 		switch (tag[0]) {
408 		case HEAD_OF_QUEUE_TAG:
409 			cmd_pkt->control_flags =
410 			    __constant_cpu_to_le16(CF_HEAD_TAG);
411 			break;
412 		case ORDERED_QUEUE_TAG:
413 			cmd_pkt->control_flags =
414 			    __constant_cpu_to_le16(CF_ORDERED_TAG);
415 			break;
416 		default:
417 			cmd_pkt->control_flags =
418 			    __constant_cpu_to_le16(CF_SIMPLE_TAG);
419 			break;
420 		}
421 	}
422 
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));
426 
427 	/* Build IOCB segments */
428 	ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds);
429 
430 	/* Set total data segment count. */
431 	cmd_pkt->entry_count = (uint8_t)req_cnt;
432 	wmb();
433 
434 	/* Adjust ring index. */
435 	req->ring_index++;
436 	if (req->ring_index == req->length) {
437 		req->ring_index = 0;
438 		req->ring_ptr = req->ring;
439 	} else
440 		req->ring_ptr++;
441 
442 	sp->flags |= SRB_DMA_VALID;
443 
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. */
447 
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);
452 
453 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
454 	return (QLA_SUCCESS);
455 
456 queuing_error:
457 	if (tot_dsds)
458 		scsi_dma_unmap(cmd);
459 
460 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
461 
462 	return (QLA_FUNCTION_FAILED);
463 }
464 
465 /**
466  * qla2x00_start_iocbs() - Execute the IOCB command
467  */
468 void
469 qla2x00_start_iocbs(struct scsi_qla_host *vha, struct req_que *req)
470 {
471 	struct qla_hw_data *ha = vha->hw;
472 	device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id);
473 
474 	if (IS_QLA82XX(ha)) {
475 		qla82xx_start_iocbs(vha);
476 	} else {
477 		/* Adjust ring index. */
478 		req->ring_index++;
479 		if (req->ring_index == req->length) {
480 			req->ring_index = 0;
481 			req->ring_ptr = req->ring;
482 		} else
483 			req->ring_ptr++;
484 
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(&reg->isp24.req_q_in, req->ring_index);
491 			RD_REG_DWORD_RELAXED(&reg->isp24.req_q_in);
492 		} else {
493 			WRT_REG_WORD(ISP_REQ_Q_IN(ha, &reg->isp),
494 				req->ring_index);
495 			RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, &reg->isp));
496 		}
497 	}
498 }
499 
500 /**
501  * qla2x00_marker() - Send a marker IOCB to the firmware.
502  * @ha: HA context
503  * @loop_id: loop ID
504  * @lun: LUN
505  * @type: marker modifier
506  *
507  * Can be called from both normal and interrupt context.
508  *
509  * Returns non-zero if a failure occurred, else zero.
510  */
511 static int
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)
515 {
516 	mrk_entry_t *mrk;
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);
520 
521 	mrk24 = NULL;
522 	req = ha->req_q_map[0];
523 	mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, NULL);
524 	if (mrk == NULL) {
525 		ql_log(ql_log_warn, base_vha, 0x3026,
526 		    "Failed to allocate Marker IOCB.\n");
527 
528 		return (QLA_FUNCTION_FAILED);
529 	}
530 
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);
542 		} else {
543 			SET_TARGET_ID(ha, mrk->target, loop_id);
544 			mrk->lun = cpu_to_le16(lun);
545 		}
546 	}
547 	wmb();
548 
549 	qla2x00_start_iocbs(vha, req);
550 
551 	return (QLA_SUCCESS);
552 }
553 
554 int
555 qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req,
556 		struct rsp_que *rsp, uint16_t loop_id, uint16_t lun,
557 		uint8_t type)
558 {
559 	int ret;
560 	unsigned long flags = 0;
561 
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);
565 
566 	return (ret);
567 }
568 
569 /*
570  * qla2x00_issue_marker
571  *
572  * Issue marker
573  * Caller CAN have hardware lock held as specified by ha_locked parameter.
574  * Might release it, then reaquire.
575  */
576 int qla2x00_issue_marker(scsi_qla_host_t *vha, int ha_locked)
577 {
578 	if (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;
582 	} else {
583 		if (qla2x00_marker(vha, vha->req, vha->req->rsp, 0, 0,
584 					MK_SYNC_ALL) != QLA_SUCCESS)
585 			return QLA_FUNCTION_FAILED;
586 	}
587 	vha->marker_needed = 0;
588 
589 	return QLA_SUCCESS;
590 }
591 
592 /**
593  * qla24xx_calc_iocbs() - Determine number of Command Type 3 and
594  * Continuation Type 1 IOCBs to allocate.
595  *
596  * @dsds: number of data segment decriptors needed
597  *
598  * Returns the number of IOCB entries needed to store @dsds.
599  */
600 inline uint16_t
601 qla24xx_calc_iocbs(scsi_qla_host_t *vha, uint16_t dsds)
602 {
603 	uint16_t iocbs;
604 
605 	iocbs = 1;
606 	if (dsds > 1) {
607 		iocbs += (dsds - 1) / 5;
608 		if ((dsds - 1) % 5)
609 			iocbs++;
610 	}
611 	return iocbs;
612 }
613 
614 static inline int
615 qla24xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
616 	uint16_t tot_dsds)
617 {
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;
623 	uint32_t *dsd_seg;
624 	void *next_dsd;
625 	uint8_t avail_dsds;
626 	uint8_t first_iocb = 1;
627 	uint32_t dsd_list_len;
628 	struct dsd_dma *dsd_ptr;
629 	struct ct6_dsd *ctx;
630 
631 	cmd = GET_CMD_SP(sp);
632 
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);
636 
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);
640 		return 0;
641 	}
642 
643 	vha = sp->fcport->vha;
644 	ha = vha->hw;
645 
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);
655 	}
656 
657 	cur_seg = scsi_sglist(cmd);
658 	ctx = GET_CMD_CTX_SP(sp);
659 
660 	while (tot_dsds) {
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;
665 
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);
670 		ha->gbl_dsd_avail--;
671 		list_add_tail(&dsd_ptr->list, &ctx->dsd_list);
672 		ctx->dsd_use_cnt++;
673 		ha->gbl_dsd_inuse++;
674 
675 		if (first_iocb) {
676 			first_iocb = 0;
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);
681 		} else {
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);
685 		}
686 		cur_dsd = (uint32_t *)next_dsd;
687 		while (avail_dsds) {
688 			dma_addr_t	sle_dma;
689 
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);
695 			avail_dsds--;
696 		}
697 	}
698 
699 	/* Null termination */
700 	*cur_dsd++ =  0;
701 	*cur_dsd++ = 0;
702 	*cur_dsd++ = 0;
703 	cmd_pkt->control_flags |= CF_DATA_SEG_DESCR_ENABLE;
704 	return 0;
705 }
706 
707 /*
708  * qla24xx_calc_dsd_lists() - Determine number of DSD list required
709  * for Command Type 6.
710  *
711  * @dsds: number of data segment decriptors needed
712  *
713  * Returns the number of dsd list needed to store @dsds.
714  */
715 inline uint16_t
716 qla24xx_calc_dsd_lists(uint16_t dsds)
717 {
718 	uint16_t dsd_lists = 0;
719 
720 	dsd_lists = (dsds/QLA_DSDS_PER_IOCB);
721 	if (dsds % QLA_DSDS_PER_IOCB)
722 		dsd_lists++;
723 	return dsd_lists;
724 }
725 
726 
727 /**
728  * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7
729  * IOCB types.
730  *
731  * @sp: SRB command to process
732  * @cmd_pkt: Command type 3 IOCB
733  * @tot_dsds: Total number of segments to transfer
734  */
735 inline void
736 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt,
737     uint16_t tot_dsds)
738 {
739 	uint16_t	avail_dsds;
740 	uint32_t	*cur_dsd;
741 	scsi_qla_host_t	*vha;
742 	struct scsi_cmnd *cmd;
743 	struct scatterlist *sg;
744 	int i;
745 	struct req_que *req;
746 
747 	cmd = GET_CMD_SP(sp);
748 
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);
752 
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);
756 		return;
757 	}
758 
759 	vha = sp->fcport->vha;
760 	req = vha->req;
761 
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);
771 	}
772 
773 	/* One DSD is available in the Command Type 3 IOCB */
774 	avail_dsds = 1;
775 	cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
776 
777 	/* Load data segments */
778 
779 	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
780 		dma_addr_t	sle_dma;
781 		cont_a64_entry_t *cont_pkt;
782 
783 		/* Allocate additional continuation packets? */
784 		if (avail_dsds == 0) {
785 			/*
786 			 * Five DSDs are available in the Continuation
787 			 * Type 1 IOCB.
788 			 */
789 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
790 			cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
791 			avail_dsds = 5;
792 		}
793 
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));
798 		avail_dsds--;
799 	}
800 }
801 
802 struct fw_dif_context {
803 	uint32_t ref_tag;
804 	uint16_t app_tag;
805 	uint8_t ref_tag_mask[4];	/* Validation/Replacement Mask*/
806 	uint8_t app_tag_mask[2];	/* Validation/Replacement Mask*/
807 };
808 
809 /*
810  * qla24xx_set_t10dif_tags_from_cmd - Extract Ref and App tags from SCSI command
811  *
812  */
813 static inline void
814 qla24xx_set_t10dif_tags(srb_t *sp, struct fw_dif_context *pkt,
815     unsigned int protcnt)
816 {
817 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
818 
819 	switch (scsi_get_prot_type(cmd)) {
820 	case SCSI_PROT_DIF_TYPE0:
821 		/*
822 		 * No check for ql2xenablehba_err_chk, as it would be an
823 		 * I/O error if hba tag generation is not done.
824 		 */
825 		pkt->ref_tag = cpu_to_le32((uint32_t)
826 		    (0xffffffff & scsi_get_lba(cmd)));
827 
828 		if (!qla2x00_hba_err_chk_enabled(sp))
829 			break;
830 
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;
835 		break;
836 
837 	/*
838 	 * For TYPE 2 protection: 16 bit GUARD + 32 bit REF tag has to
839 	 * match LBA in CDB + N
840 	 */
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;
845 
846 		pkt->ref_tag = cpu_to_le32((uint32_t)
847 		    (0xffffffff & scsi_get_lba(cmd)));
848 
849 		if (!qla2x00_hba_err_chk_enabled(sp))
850 			break;
851 
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;
857 		break;
858 
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] =
863 								0x00;
864 		break;
865 
866 	/*
867 	 * For TYpe 1 protection: 16 bit GUARD tag, 32 bit REF tag, and
868 	 * 16 bit app tag.
869 	 */
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;
876 
877 		if (!qla2x00_hba_err_chk_enabled(sp))
878 			break;
879 
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;
885 		break;
886 	}
887 }
888 
889 struct qla2_sgx {
890 	dma_addr_t		dma_addr;	/* OUT */
891 	uint32_t		dma_len;	/* OUT */
892 
893 	uint32_t		tot_bytes;	/* IN */
894 	struct scatterlist	*cur_sg;	/* IN */
895 
896 	/* for book keeping, bzero on initial invocation */
897 	uint32_t		bytes_consumed;
898 	uint32_t		num_bytes;
899 	uint32_t		tot_partial;
900 
901 	/* for debugging */
902 	uint32_t		num_sg;
903 	srb_t			*sp;
904 };
905 
906 static int
907 qla24xx_get_one_block_sg(uint32_t blk_sz, struct qla2_sgx *sgx,
908 	uint32_t *partial)
909 {
910 	struct scatterlist *sg;
911 	uint32_t cumulative_partial, sg_len;
912 	dma_addr_t sg_dma_addr;
913 
914 	if (sgx->num_bytes == sgx->tot_bytes)
915 		return 0;
916 
917 	sg = sgx->cur_sg;
918 	cumulative_partial = sgx->tot_partial;
919 
920 	sg_dma_addr = sg_dma_address(sg);
921 	sg_len = sg_dma_len(sg);
922 
923 	sgx->dma_addr = sg_dma_addr + sgx->bytes_consumed;
924 
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;
929 		*partial = 0;
930 	} else {
931 		sgx->dma_len = sg_len - sgx->bytes_consumed;
932 		sgx->tot_partial += sgx->dma_len;
933 		*partial = 1;
934 	}
935 
936 	sgx->bytes_consumed += sgx->dma_len;
937 
938 	if (sg_len == sgx->bytes_consumed) {
939 		sg = sg_next(sg);
940 		sgx->num_sg++;
941 		sgx->cur_sg = sg;
942 		sgx->bytes_consumed = 0;
943 	}
944 
945 	return 1;
946 }
947 
948 static int
949 qla24xx_walk_and_build_sglist_no_difb(struct qla_hw_data *ha, srb_t *sp,
950 	uint32_t *dsd, uint16_t tot_dsds)
951 {
952 	void *next_dsd;
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;
959 
960 	uint32_t	prot_int;
961 	uint32_t	partial;
962 	struct qla2_sgx sgx;
963 	dma_addr_t	sle_dma;
964 	uint32_t	sle_dma_len, tot_prot_dma_len = 0;
965 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
966 
967 	prot_int = cmd->device->sector_size;
968 
969 	memset(&sgx, 0, sizeof(struct qla2_sgx));
970 	sgx.tot_bytes = scsi_bufflen(cmd);
971 	sgx.cur_sg = scsi_sglist(cmd);
972 	sgx.sp = sp;
973 
974 	sg_prot = scsi_prot_sglist(cmd);
975 
976 	while (qla24xx_get_one_block_sg(prot_int, &sgx, &partial)) {
977 
978 		sle_dma = sgx.dma_addr;
979 		sle_dma_len = sgx.dma_len;
980 alloc_and_fill:
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;
987 
988 			/* allocate tracking DS */
989 			dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
990 			if (!dsd_ptr)
991 				return 1;
992 
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);
997 
998 			if (!next_dsd) {
999 				/*
1000 				 * Need to cleanup only this dsd_ptr, rest
1001 				 * will be done by sp_free_dma()
1002 				 */
1003 				kfree(dsd_ptr);
1004 				return 1;
1005 			}
1006 
1007 			list_add_tail(&dsd_ptr->list,
1008 			    &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1009 
1010 			sp->flags |= SRB_CRC_CTX_DSD_VALID;
1011 
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;
1017 		}
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);
1021 		avail_dsds--;
1022 
1023 		if (partial == 0) {
1024 			/* Got a full protection interval */
1025 			sle_dma = sg_dma_address(sg_prot) + tot_prot_dma_len;
1026 			sle_dma_len = 8;
1027 
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);
1032 			}
1033 
1034 			partial = 1; /* So as to not re-enter this block */
1035 			goto alloc_and_fill;
1036 		}
1037 	}
1038 	/* Null termination */
1039 	*cur_dsd++ = 0;
1040 	*cur_dsd++ = 0;
1041 	*cur_dsd++ = 0;
1042 	return 0;
1043 }
1044 
1045 static int
1046 qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
1047 	uint16_t tot_dsds)
1048 {
1049 	void *next_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;
1055 	int	i;
1056 	uint16_t	used_dsds = tot_dsds;
1057 	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1058 
1059 	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
1060 		dma_addr_t	sle_dma;
1061 
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;
1068 
1069 			/* allocate tracking DS */
1070 			dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
1071 			if (!dsd_ptr)
1072 				return 1;
1073 
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);
1078 
1079 			if (!next_dsd) {
1080 				/*
1081 				 * Need to cleanup only this dsd_ptr, rest
1082 				 * will be done by sp_free_dma()
1083 				 */
1084 				kfree(dsd_ptr);
1085 				return 1;
1086 			}
1087 
1088 			list_add_tail(&dsd_ptr->list,
1089 			    &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1090 
1091 			sp->flags |= SRB_CRC_CTX_DSD_VALID;
1092 
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;
1098 		}
1099 		sle_dma = sg_dma_address(sg);
1100 
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));
1104 		avail_dsds--;
1105 
1106 	}
1107 	/* Null termination */
1108 	*cur_dsd++ = 0;
1109 	*cur_dsd++ = 0;
1110 	*cur_dsd++ = 0;
1111 	return 0;
1112 }
1113 
1114 static int
1115 qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
1116 							uint32_t *dsd,
1117 	uint16_t tot_dsds)
1118 {
1119 	void *next_dsd;
1120 	uint8_t avail_dsds = 0;
1121 	uint32_t dsd_list_len;
1122 	struct dsd_dma *dsd_ptr;
1123 	struct scatterlist *sg;
1124 	int	i;
1125 	struct scsi_cmnd *cmd;
1126 	uint32_t *cur_dsd = dsd;
1127 	uint16_t	used_dsds = tot_dsds;
1128 
1129 	cmd = GET_CMD_SP(sp);
1130 	scsi_for_each_prot_sg(cmd, sg, tot_dsds, i) {
1131 		dma_addr_t	sle_dma;
1132 
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;
1139 
1140 			/* allocate tracking DS */
1141 			dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
1142 			if (!dsd_ptr)
1143 				return 1;
1144 
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);
1149 
1150 			if (!next_dsd) {
1151 				/*
1152 				 * Need to cleanup only this dsd_ptr, rest
1153 				 * will be done by sp_free_dma()
1154 				 */
1155 				kfree(dsd_ptr);
1156 				return 1;
1157 			}
1158 
1159 			list_add_tail(&dsd_ptr->list,
1160 			    &((struct crc_context *)sp->u.scmd.ctx)->dsd_list);
1161 
1162 			sp->flags |= SRB_CRC_CTX_DSD_VALID;
1163 
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;
1169 		}
1170 		sle_dma = sg_dma_address(sg);
1171 
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));
1175 
1176 		avail_dsds--;
1177 	}
1178 	/* Null termination */
1179 	*cur_dsd++ = 0;
1180 	*cur_dsd++ = 0;
1181 	*cur_dsd++ = 0;
1182 	return 0;
1183 }
1184 
1185 /**
1186  * qla24xx_build_scsi_crc_2_iocbs() - Build IOCB command utilizing Command
1187  *							Type 6 IOCB types.
1188  *
1189  * @sp: SRB command to process
1190  * @cmd_pkt: Command type 3 IOCB
1191  * @tot_dsds: Total number of segments to transfer
1192  */
1193 static inline int
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)
1196 {
1197 	uint32_t		*cur_dsd, *fcp_dl;
1198 	scsi_qla_host_t		*vha;
1199 	struct scsi_cmnd	*cmd;
1200 	struct scatterlist	*cur_seg;
1201 	int			sgc;
1202 	uint32_t		total_bytes = 0;
1203 	uint32_t		data_bytes;
1204 	uint32_t		dif_bytes;
1205 	uint8_t			bundling = 1;
1206 	uint16_t		blk_size;
1207 	uint8_t			*clr_ptr;
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;
1214 	char			tag[2];
1215 
1216 	cmd = GET_CMD_SP(sp);
1217 
1218 	sgc = 0;
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);
1222 
1223 	vha = sp->fcport->vha;
1224 	ha = vha->hw;
1225 
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);
1230 		return QLA_SUCCESS;
1231 	}
1232 
1233 	cmd_pkt->vp_index = sp->fcport->vha->vp_idx;
1234 
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);
1242 	}
1243 
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))
1248 		bundling = 0;
1249 
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);
1253 
1254 	if (!crc_ctx_pkt)
1255 		goto crc_queuing_error;
1256 
1257 	/* Zero out CTX area. */
1258 	clr_ptr = (uint8_t *)crc_ctx_pkt;
1259 	memset(clr_ptr, 0, sizeof(*crc_ctx_pkt));
1260 
1261 	crc_ctx_pkt->crc_ctx_dma = crc_ctx_dma;
1262 
1263 	sp->flags |= SRB_CRC_CTX_DMA_VALID;
1264 
1265 	/* Set handle */
1266 	crc_ctx_pkt->handle = cmd_pkt->handle;
1267 
1268 	INIT_LIST_HEAD(&crc_ctx_pkt->dsd_list);
1269 
1270 	qla24xx_set_t10dif_tags(sp, (struct fw_dif_context *)
1271 	    &crc_ctx_pkt->ref_tag, tot_prot_dsds);
1272 
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;
1276 
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;
1283 		}
1284 		fcp_cmnd_len = 12 + cmd->cmd_len + 4;
1285 	} else {
1286 		additional_fcpcdb_len = 0;
1287 		fcp_cmnd_len = 12 + 16 + 4;
1288 	}
1289 
1290 	fcp_cmnd = &crc_ctx_pkt->fcp_cmnd;
1291 
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;
1297 
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;
1306 
1307 	/*
1308 	 * Update tagged queuing modifier if using command tag queuing
1309 	 */
1310 	if (scsi_populate_tag_msg(cmd, tag)) {
1311 		switch (tag[0]) {
1312 		case HEAD_OF_QUEUE_TAG:
1313 		    fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE;
1314 		    break;
1315 		case ORDERED_QUEUE_TAG:
1316 		    fcp_cmnd->task_attribute = TSK_ORDERED;
1317 		    break;
1318 		default:
1319 		    fcp_cmnd->task_attribute = 0;
1320 		    break;
1321 		}
1322 	} else {
1323 		fcp_cmnd->task_attribute = 0;
1324 	}
1325 
1326 	cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
1327 
1328 	/* Compute dif len and adjust data len to incude protection */
1329 	dif_bytes = 0;
1330 	blk_size = cmd->device->sector_size;
1331 	dif_bytes = (data_bytes / blk_size) * 8;
1332 
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;
1338 	    break;
1339 
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;
1345 	    break;
1346 	default:
1347 	    BUG();
1348 	}
1349 
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;
1361 	}
1362 
1363 	if (!bundling) {
1364 		cur_dsd = (uint32_t *) &crc_ctx_pkt->u.nobundling.data_address;
1365 	} else {
1366 		/*
1367 		 * Configure Bundling if we need to fetch interlaving
1368 		 * protection PCI accesses
1369 		 */
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 -
1373 							tot_prot_dsds);
1374 		cur_dsd = (uint32_t *) &crc_ctx_pkt->u.bundling.data_address;
1375 	}
1376 
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);
1387 
1388 	if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
1389 		cmd_pkt->byte_count = __constant_cpu_to_le32(0);
1390 		return QLA_SUCCESS;
1391 	}
1392 	/* Walks data segments */
1393 
1394 	cmd_pkt->control_flags |=
1395 	    __constant_cpu_to_le16(CF_DATA_SEG_DESCR_ENABLE);
1396 
1397 	if (!bundling && tot_prot_dsds) {
1398 		if (qla24xx_walk_and_build_sglist_no_difb(ha, sp,
1399 		    cur_dsd, tot_dsds))
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;
1404 
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,
1412 		    tot_prot_dsds))
1413 			goto crc_queuing_error;
1414 	}
1415 	return QLA_SUCCESS;
1416 
1417 crc_queuing_error:
1418 	/* Cleanup will be performed by the caller */
1419 
1420 	return QLA_FUNCTION_FAILED;
1421 }
1422 
1423 /**
1424  * qla24xx_start_scsi() - Send a SCSI command to the ISP
1425  * @sp: command to send to the ISP
1426  *
1427  * Returns non-zero if a failure occurred, else zero.
1428  */
1429 int
1430 qla24xx_start_scsi(srb_t *sp)
1431 {
1432 	int		ret, nseg;
1433 	unsigned long   flags;
1434 	uint32_t	*clr_ptr;
1435 	uint32_t        index;
1436 	uint32_t	handle;
1437 	struct cmd_type_7 *cmd_pkt;
1438 	uint16_t	cnt;
1439 	uint16_t	req_cnt;
1440 	uint16_t	tot_dsds;
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;
1446 	char		tag[2];
1447 
1448 	/* Setup device pointers. */
1449 	ret = 0;
1450 
1451 	qla25xx_set_que(sp, &rsp);
1452 	req = vha->req;
1453 
1454 	/* So we know we haven't pci_map'ed anything yet */
1455 	tot_dsds = 0;
1456 
1457 	/* Send marker if required */
1458 	if (vha->marker_needed != 0) {
1459 		if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
1460 		    QLA_SUCCESS)
1461 			return QLA_FUNCTION_FAILED;
1462 		vha->marker_needed = 0;
1463 	}
1464 
1465 	/* Acquire ring specific lock */
1466 	spin_lock_irqsave(&ha->hardware_lock, flags);
1467 
1468 	/* Check for room in outstanding command list. */
1469 	handle = req->current_outstanding_cmd;
1470 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1471 		handle++;
1472 		if (handle == MAX_OUTSTANDING_COMMANDS)
1473 			handle = 1;
1474 		if (!req->outstanding_cmds[handle])
1475 			break;
1476 	}
1477 	if (index == MAX_OUTSTANDING_COMMANDS) {
1478 		goto queuing_error;
1479 	}
1480 
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))
1486 			goto queuing_error;
1487 	} else
1488 		nseg = 0;
1489 
1490 	tot_dsds = 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);
1494 
1495 		if (req->ring_index < cnt)
1496 			req->cnt = cnt - req->ring_index;
1497 		else
1498 			req->cnt = req->length -
1499 				(req->ring_index - cnt);
1500 		if (req->cnt < (req_cnt + 2))
1501 			goto queuing_error;
1502 	}
1503 
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;
1510 
1511 	cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
1512 	cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
1513 
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);
1519 
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;
1526 
1527 	int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1528 	host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1529 
1530 	/* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */
1531 	if (scsi_populate_tag_msg(cmd, tag)) {
1532 		switch (tag[0]) {
1533 		case HEAD_OF_QUEUE_TAG:
1534 			cmd_pkt->task = TSK_HEAD_OF_QUEUE;
1535 			break;
1536 		case ORDERED_QUEUE_TAG:
1537 			cmd_pkt->task = TSK_ORDERED;
1538 			break;
1539 		}
1540 	}
1541 
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));
1545 
1546 	cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
1547 
1548 	/* Build IOCB segments */
1549 	qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
1550 
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;
1555 	wmb();
1556 	/* Adjust ring index. */
1557 	req->ring_index++;
1558 	if (req->ring_index == req->length) {
1559 		req->ring_index = 0;
1560 		req->ring_ptr = req->ring;
1561 	} else
1562 		req->ring_ptr++;
1563 
1564 	sp->flags |= SRB_DMA_VALID;
1565 
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);
1569 
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);
1574 
1575 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1576 	return QLA_SUCCESS;
1577 
1578 queuing_error:
1579 	if (tot_dsds)
1580 		scsi_dma_unmap(cmd);
1581 
1582 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1583 
1584 	return QLA_FUNCTION_FAILED;
1585 }
1586 
1587 
1588 /**
1589  * qla24xx_dif_start_scsi() - Send a SCSI command to the ISP
1590  * @sp: command to send to the ISP
1591  *
1592  * Returns non-zero if a failure occurred, else zero.
1593  */
1594 int
1595 qla24xx_dif_start_scsi(srb_t *sp)
1596 {
1597 	int			nseg;
1598 	unsigned long		flags;
1599 	uint32_t		*clr_ptr;
1600 	uint32_t		index;
1601 	uint32_t		handle;
1602 	uint16_t		cnt;
1603 	uint16_t		req_cnt = 0;
1604 	uint16_t		tot_dsds;
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;
1614 
1615 #define QDSS_GOT_Q_SPACE	BIT_0
1616 
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);
1621 	}
1622 
1623 	/* Setup device pointers. */
1624 
1625 	qla25xx_set_que(sp, &rsp);
1626 	req = vha->req;
1627 
1628 	/* So we know we haven't pci_map'ed anything yet */
1629 	tot_dsds = 0;
1630 
1631 	/* Send marker if required */
1632 	if (vha->marker_needed != 0) {
1633 		if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
1634 		    QLA_SUCCESS)
1635 			return QLA_FUNCTION_FAILED;
1636 		vha->marker_needed = 0;
1637 	}
1638 
1639 	/* Acquire ring specific lock */
1640 	spin_lock_irqsave(&ha->hardware_lock, flags);
1641 
1642 	/* Check for room in outstanding command list. */
1643 	handle = req->current_outstanding_cmd;
1644 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1645 		handle++;
1646 		if (handle == MAX_OUTSTANDING_COMMANDS)
1647 			handle = 1;
1648 		if (!req->outstanding_cmds[handle])
1649 			break;
1650 	}
1651 
1652 	if (index == MAX_OUTSTANDING_COMMANDS)
1653 		goto queuing_error;
1654 
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))
1661 			goto queuing_error;
1662 		else
1663 			sp->flags |= SRB_DMA_VALID;
1664 
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;
1668 			uint32_t	partial;
1669 
1670 			memset(&sgx, 0, sizeof(struct qla2_sgx));
1671 			sgx.tot_bytes = scsi_bufflen(cmd);
1672 			sgx.cur_sg = scsi_sglist(cmd);
1673 			sgx.sp = sp;
1674 
1675 			nseg = 0;
1676 			while (qla24xx_get_one_block_sg(
1677 			    cmd->device->sector_size, &sgx, &partial))
1678 				nseg++;
1679 		}
1680 	} else
1681 		nseg = 0;
1682 
1683 	/* number of required data segments */
1684 	tot_dsds = nseg;
1685 
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))
1691 			goto queuing_error;
1692 		else
1693 			sp->flags |= SRB_CRC_PROT_DMA_VALID;
1694 
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;
1698 		}
1699 	} else {
1700 		nseg = 0;
1701 	}
1702 
1703 	req_cnt = 1;
1704 	/* Total Data and protection sg segment(s) */
1705 	tot_prot_dsds = nseg;
1706 	tot_dsds += nseg;
1707 	if (req->cnt < (req_cnt + 2)) {
1708 		cnt = RD_REG_DWORD_RELAXED(req->req_q_out);
1709 
1710 		if (req->ring_index < cnt)
1711 			req->cnt = cnt - req->ring_index;
1712 		else
1713 			req->cnt = req->length -
1714 				(req->ring_index - cnt);
1715 		if (req->cnt < (req_cnt + 2))
1716 			goto queuing_error;
1717 	}
1718 
1719 	status |= QDSS_GOT_Q_SPACE;
1720 
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;
1727 
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);
1731 
1732 	clr_ptr = (uint32_t *)cmd_pkt + 2;
1733 	memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
1734 
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;
1740 
1741 	int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
1742 	host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
1743 
1744 	/* Total Data and protection segment(s) */
1745 	cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
1746 
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) !=
1750 		QLA_SUCCESS)
1751 		goto queuing_error;
1752 
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);
1757 	wmb();
1758 
1759 	/* Adjust ring index. */
1760 	req->ring_index++;
1761 	if (req->ring_index == req->length) {
1762 		req->ring_index = 0;
1763 		req->ring_ptr = req->ring;
1764 	} else
1765 		req->ring_ptr++;
1766 
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);
1770 
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);
1775 
1776 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1777 
1778 	return QLA_SUCCESS;
1779 
1780 queuing_error:
1781 	if (status & QDSS_GOT_Q_SPACE) {
1782 		req->outstanding_cmds[handle] = NULL;
1783 		req->cnt += req_cnt;
1784 	}
1785 	/* Cleanup will be performed by the caller (queuecommand) */
1786 
1787 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1788 	return QLA_FUNCTION_FAILED;
1789 }
1790 
1791 
1792 static void qla25xx_set_que(srb_t *sp, struct rsp_que **rsp)
1793 {
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;
1797 
1798 	if (ha->flags.cpu_affinity_enabled && affinity >= 0 &&
1799 		affinity < ha->max_rsp_queues - 1)
1800 		*rsp = ha->rsp_q_map[affinity + 1];
1801 	 else
1802 		*rsp = ha->rsp_q_map[0];
1803 }
1804 
1805 /* Generic Control-SRB manipulation functions. */
1806 void *
1807 qla2x00_alloc_iocbs(scsi_qla_host_t *vha, srb_t *sp)
1808 {
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;
1813 	request_t *pkt;
1814 	uint16_t cnt, req_cnt;
1815 
1816 	pkt = NULL;
1817 	req_cnt = 1;
1818 	handle = 0;
1819 
1820 	if (!sp)
1821 		goto skip_cmd_array;
1822 
1823 	/* Check for room in outstanding command list. */
1824 	handle = req->current_outstanding_cmd;
1825 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
1826 		handle++;
1827 		if (handle == MAX_OUTSTANDING_COMMANDS)
1828 			handle = 1;
1829 		if (!req->outstanding_cmds[handle])
1830 			break;
1831 	}
1832 	if (index == MAX_OUTSTANDING_COMMANDS) {
1833 		ql_log(ql_log_warn, vha, 0x700b,
1834 		    "No room on outstanding cmd array.\n");
1835 		goto queuing_error;
1836 	}
1837 
1838 	/* Prep command array. */
1839 	req->current_outstanding_cmd = handle;
1840 	req->outstanding_cmds[handle] = sp;
1841 	sp->handle = handle;
1842 
1843 	/* Adjust entry-counts as needed. */
1844 	if (sp->type != SRB_SCSI_CMD)
1845 		req_cnt = sp->iocbs;
1846 
1847 skip_cmd_array:
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(&reg->isp25mq.req_q_out);
1852 		else if (IS_QLA82XX(ha))
1853 			cnt = RD_REG_DWORD(&reg->isp82.req_q_out);
1854 		else if (IS_FWI2_CAPABLE(ha))
1855 			cnt = RD_REG_DWORD(&reg->isp24.req_q_out);
1856 		else
1857 			cnt = qla2x00_debounce_register(
1858 			    ISP_REQ_Q_OUT(ha, &reg->isp));
1859 
1860 		if  (req->ring_index < cnt)
1861 			req->cnt = cnt - req->ring_index;
1862 		else
1863 			req->cnt = req->length -
1864 			    (req->ring_index - cnt);
1865 	}
1866 	if (req->cnt < req_cnt)
1867 		goto queuing_error;
1868 
1869 	/* Prep packet */
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;
1875 
1876 queuing_error:
1877 	return pkt;
1878 }
1879 
1880 static void
1881 qla24xx_login_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1882 {
1883 	struct srb_iocb *lio = &sp->u.iocb_cmd;
1884 
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;
1896 }
1897 
1898 static void
1899 qla2x00_login_iocb(srb_t *sp, struct mbx_entry *mbx)
1900 {
1901 	struct qla_hw_data *ha = sp->fcport->vha->hw;
1902 	struct srb_iocb *lio = &sp->u.iocb_cmd;
1903 	uint16_t opts;
1904 
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);
1913 	} else {
1914 		mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | opts);
1915 	}
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);
1920 }
1921 
1922 static void
1923 qla24xx_logout_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1924 {
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;
1933 }
1934 
1935 static void
1936 qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx)
1937 {
1938 	struct qla_hw_data *ha = sp->fcport->vha->hw;
1939 
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. */
1951 }
1952 
1953 static void
1954 qla24xx_adisc_iocb(srb_t *sp, struct logio_entry_24xx *logio)
1955 {
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;
1960 }
1961 
1962 static void
1963 qla2x00_adisc_iocb(srb_t *sp, struct mbx_entry *mbx)
1964 {
1965 	struct qla_hw_data *ha = sp->fcport->vha->hw;
1966 
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);
1973 	} else {
1974 		mbx->mb1 = cpu_to_le16((sp->fcport->loop_id << 8) | BIT_0);
1975 	}
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);
1981 }
1982 
1983 static void
1984 qla24xx_tm_iocb(srb_t *sp, struct tsk_mgmt_entry *tsk)
1985 {
1986 	uint32_t flags;
1987 	unsigned int lun;
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;
1993 
1994 	flags = iocb->u.tmf.flags;
1995 	lun = iocb->u.tmf.lun;
1996 
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;
2007 
2008 	if (flags == TCF_LUN_RESET) {
2009 		int_to_scsilun(lun, &tsk->lun);
2010 		host_to_fcp_swap((uint8_t *)&tsk->lun,
2011 			sizeof(tsk->lun));
2012 	}
2013 }
2014 
2015 static void
2016 qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
2017 {
2018 	struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2019 
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);
2030 
2031 	els_iocb->opcode =
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);
2043 
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));
2050 
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));
2057 }
2058 
2059 static void
2060 qla2x00_ct_iocb(srb_t *sp, ms_iocb_entry_t *ct_iocb)
2061 {
2062 	uint16_t        avail_dsds;
2063 	uint32_t        *cur_dsd;
2064 	struct scatterlist *sg;
2065 	int index;
2066 	uint16_t tot_dsds;
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;
2073 
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);
2090 
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;
2096 
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;
2102 
2103 	avail_dsds = 1;
2104 	cur_dsd = (uint32_t *)ct_iocb->dseg_rsp_address;
2105 	index = 0;
2106 	tot_dsds = bsg_job->reply_payload.sg_cnt;
2107 
2108 	for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
2109 		dma_addr_t       sle_dma;
2110 		cont_a64_entry_t *cont_pkt;
2111 
2112 		/* Allocate additional continuation packets? */
2113 		if (avail_dsds == 0) {
2114 			/*
2115 			* Five DSDs are available in the Cont.
2116 			* Type 1 IOCB.
2117 			       */
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;
2121 			avail_dsds = 5;
2122 			cont_iocb_prsnt = 1;
2123 			entry_count++;
2124 		}
2125 
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));
2130 		loop_iterartion++;
2131 		avail_dsds--;
2132 	}
2133 	ct_iocb->entry_count = entry_count;
2134 }
2135 
2136 static void
2137 qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb)
2138 {
2139 	uint16_t        avail_dsds;
2140 	uint32_t        *cur_dsd;
2141 	struct scatterlist *sg;
2142 	int index;
2143 	uint16_t tot_dsds;
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;
2150 
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;
2155 
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);
2159 
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));
2175 
2176 	avail_dsds = 1;
2177 	cur_dsd = (uint32_t *)ct_iocb->dseg_1_address;
2178 	index = 0;
2179 	tot_dsds = bsg_job->reply_payload.sg_cnt;
2180 
2181 	for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
2182 		dma_addr_t       sle_dma;
2183 		cont_a64_entry_t *cont_pkt;
2184 
2185 		/* Allocate additional continuation packets? */
2186 		if (avail_dsds == 0) {
2187 			/*
2188 			* Five DSDs are available in the Cont.
2189 			* Type 1 IOCB.
2190 			       */
2191 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha,
2192 			    ha->req_q_map[0]);
2193 			cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2194 			avail_dsds = 5;
2195 			cont_iocb_prsnt = 1;
2196 			entry_count++;
2197 		}
2198 
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));
2203 		loop_iterartion++;
2204 		avail_dsds--;
2205 	}
2206         ct_iocb->entry_count = entry_count;
2207 }
2208 
2209 /*
2210  * qla82xx_start_scsi() - Send a SCSI command to the ISP
2211  * @sp: command to send to the ISP
2212  *
2213  * Returns non-zero if a failure occurred, else zero.
2214  */
2215 int
2216 qla82xx_start_scsi(srb_t *sp)
2217 {
2218 	int		ret, nseg;
2219 	unsigned long   flags;
2220 	struct scsi_cmnd *cmd;
2221 	uint32_t	*clr_ptr;
2222 	uint32_t        index;
2223 	uint32_t	handle;
2224 	uint16_t	cnt;
2225 	uint16_t	req_cnt;
2226 	uint16_t	tot_dsds;
2227 	struct device_reg_82xx __iomem *reg;
2228 	uint32_t dbval;
2229 	uint32_t *fcp_dl;
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;
2236 	char tag[2];
2237 
2238 	/* Setup device pointers. */
2239 	ret = 0;
2240 	reg = &ha->iobase->isp82;
2241 	cmd = GET_CMD_SP(sp);
2242 	req = vha->req;
2243 	rsp = ha->rsp_q_map[0];
2244 
2245 	/* So we know we haven't pci_map'ed anything yet */
2246 	tot_dsds = 0;
2247 
2248 	dbval = 0x04 | (ha->portnum << 5);
2249 
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;
2257 		}
2258 		vha->marker_needed = 0;
2259 	}
2260 
2261 	/* Acquire ring specific lock */
2262 	spin_lock_irqsave(&ha->hardware_lock, flags);
2263 
2264 	/* Check for room in outstanding command list. */
2265 	handle = req->current_outstanding_cmd;
2266 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
2267 		handle++;
2268 		if (handle == MAX_OUTSTANDING_COMMANDS)
2269 			handle = 1;
2270 		if (!req->outstanding_cmds[handle])
2271 			break;
2272 	}
2273 	if (index == MAX_OUTSTANDING_COMMANDS)
2274 		goto queuing_error;
2275 
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))
2281 			goto queuing_error;
2282 	} else
2283 		nseg = 0;
2284 
2285 	tot_dsds = nseg;
2286 
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;
2291 		uint16_t i;
2292 
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,
2298 			    cmd);
2299 			goto queuing_error;
2300 		}
2301 
2302 		if (more_dsd_lists <= ha->gbl_dsd_avail)
2303 			goto sufficient_dsds;
2304 		else
2305 			more_dsd_lists -= ha->gbl_dsd_avail;
2306 
2307 		for (i = 0; i < more_dsd_lists; i++) {
2308 			dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
2309 			if (!dsd_ptr) {
2310 				ql_log(ql_log_fatal, vha, 0x300e,
2311 				    "Failed to allocate memory for dsd_dma "
2312 				    "for cmd=%p.\n", cmd);
2313 				goto queuing_error;
2314 			}
2315 
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) {
2319 				kfree(dsd_ptr);
2320 				ql_log(ql_log_fatal, vha, 0x300f,
2321 				    "Failed to allocate memory for dsd_addr "
2322 				    "for cmd=%p.\n", cmd);
2323 				goto queuing_error;
2324 			}
2325 			list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list);
2326 			ha->gbl_dsd_avail++;
2327 		}
2328 
2329 sufficient_dsds:
2330 		req_cnt = 1;
2331 
2332 		if (req->cnt < (req_cnt + 2)) {
2333 			cnt = (uint16_t)RD_REG_DWORD_RELAXED(
2334 				&reg->req_q_out[0]);
2335 			if (req->ring_index < cnt)
2336 				req->cnt = cnt - req->ring_index;
2337 			else
2338 				req->cnt = req->length -
2339 					(req->ring_index - cnt);
2340 			if (req->cnt < (req_cnt + 2))
2341 				goto queuing_error;
2342 		}
2343 
2344 		ctx = sp->u.scmd.ctx =
2345 		    mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
2346 		if (!ctx) {
2347 			ql_log(ql_log_fatal, vha, 0x3010,
2348 			    "Failed to allocate ctx for cmd=%p.\n", cmd);
2349 			goto queuing_error;
2350 		}
2351 
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);
2358 			goto queuing_error;
2359 		}
2360 
2361 		/* Initialize the DSD list and dma handle */
2362 		INIT_LIST_HEAD(&ctx->dsd_list);
2363 		ctx->dsd_use_cnt = 0;
2364 
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
2369 				 * multiple of 4
2370 				 */
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;
2375 			}
2376 			ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4;
2377 		} else {
2378 			additional_cdb_len = 0;
2379 			ctx->fcp_cmnd_len = 12 + 16 + 4;
2380 		}
2381 
2382 		cmd_pkt = (struct cmd_type_6 *)req->ring_ptr;
2383 		cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2384 
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);
2390 
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;
2397 
2398 		/* Build IOCB segments */
2399 		if (qla24xx_build_scsi_type_6_iocbs(sp, cmd_pkt, tot_dsds))
2400 			goto queuing_error_fcp_cmnd;
2401 
2402 		int_to_scsilun(cmd->device->lun, &cmd_pkt->lun);
2403 		host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
2404 
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;
2409 
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;
2414 
2415 		/*
2416 		 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
2417 		 */
2418 		if (scsi_populate_tag_msg(cmd, tag)) {
2419 			switch (tag[0]) {
2420 			case HEAD_OF_QUEUE_TAG:
2421 				ctx->fcp_cmnd->task_attribute =
2422 				    TSK_HEAD_OF_QUEUE;
2423 				break;
2424 			case ORDERED_QUEUE_TAG:
2425 				ctx->fcp_cmnd->task_attribute =
2426 				    TSK_ORDERED;
2427 				break;
2428 			}
2429 		}
2430 
2431 		/* Populate the FCP_PRIO. */
2432 		if (ha->flags.fcp_prio_enabled)
2433 			ctx->fcp_cmnd->task_attribute |=
2434 			    sp->fcport->fcp_prio << 3;
2435 
2436 		memcpy(ctx->fcp_cmnd->cdb, cmd->cmnd, cmd->cmd_len);
2437 
2438 		fcp_dl = (uint32_t *)(ctx->fcp_cmnd->cdb + 16 +
2439 		    additional_cdb_len);
2440 		*fcp_dl = htonl((uint32_t)scsi_bufflen(cmd));
2441 
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));
2447 
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
2454 		 */
2455 		cmd_pkt->entry_status = (uint8_t) rsp->id;
2456 	} else {
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 			    &reg->req_q_out[0]);
2462 			if (req->ring_index < cnt)
2463 				req->cnt = cnt - req->ring_index;
2464 			else
2465 				req->cnt = req->length -
2466 					(req->ring_index - cnt);
2467 		}
2468 		if (req->cnt < (req_cnt + 2))
2469 			goto queuing_error;
2470 
2471 		cmd_pkt = (struct cmd_type_7 *)req->ring_ptr;
2472 		cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2473 
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);
2479 
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;
2486 
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));
2490 
2491 		/*
2492 		 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
2493 		 */
2494 		if (scsi_populate_tag_msg(cmd, tag)) {
2495 			switch (tag[0]) {
2496 			case HEAD_OF_QUEUE_TAG:
2497 				cmd_pkt->task = TSK_HEAD_OF_QUEUE;
2498 				break;
2499 			case ORDERED_QUEUE_TAG:
2500 				cmd_pkt->task = TSK_ORDERED;
2501 				break;
2502 			}
2503 		}
2504 
2505 		/* Populate the FCP_PRIO. */
2506 		if (ha->flags.fcp_prio_enabled)
2507 			cmd_pkt->task |= sp->fcport->fcp_prio << 3;
2508 
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));
2512 
2513 		cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
2514 
2515 		/* Build IOCB segments */
2516 		qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
2517 
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.
2522 		 */
2523 		cmd_pkt->entry_status = (uint8_t) rsp->id;
2524 
2525 	}
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;
2532 	wmb();
2533 
2534 	/* Adjust ring index. */
2535 	req->ring_index++;
2536 	if (req->ring_index == req->length) {
2537 		req->ring_index = 0;
2538 		req->ring_ptr = req->ring;
2539 	} else
2540 		req->ring_ptr++;
2541 
2542 	sp->flags |= SRB_DMA_VALID;
2543 
2544 	/* Set chip new ring index. */
2545 	/* write, read and verify logic */
2546 	dbval = dbval | (req->id << 8) | (req->ring_index << 16);
2547 	if (ql2xdbwr)
2548 		qla82xx_wr_32(ha, ha->nxdb_wr_ptr, dbval);
2549 	else {
2550 		WRT_REG_DWORD(
2551 			(unsigned long __iomem *)ha->nxdb_wr_ptr,
2552 			dbval);
2553 		wmb();
2554 		while (RD_REG_DWORD((void __iomem *)ha->nxdb_rd_ptr) != dbval) {
2555 			WRT_REG_DWORD(
2556 				(unsigned long __iomem *)ha->nxdb_wr_ptr,
2557 				dbval);
2558 			wmb();
2559 		}
2560 	}
2561 
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);
2566 
2567 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2568 	return QLA_SUCCESS;
2569 
2570 queuing_error_fcp_cmnd:
2571 	dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, ctx->fcp_cmnd_dma);
2572 queuing_error:
2573 	if (tot_dsds)
2574 		scsi_dma_unmap(cmd);
2575 
2576 	if (sp->u.scmd.ctx) {
2577 		mempool_free(sp->u.scmd.ctx, ha->ctx_mempool);
2578 		sp->u.scmd.ctx = NULL;
2579 	}
2580 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2581 
2582 	return QLA_FUNCTION_FAILED;
2583 }
2584 
2585 int
2586 qla2x00_start_sp(srb_t *sp)
2587 {
2588 	int rval;
2589 	struct qla_hw_data *ha = sp->fcport->vha->hw;
2590 	void *pkt;
2591 	unsigned long flags;
2592 
2593 	rval = QLA_FUNCTION_FAILED;
2594 	spin_lock_irqsave(&ha->hardware_lock, flags);
2595 	pkt = qla2x00_alloc_iocbs(sp->fcport->vha, sp);
2596 	if (!pkt) {
2597 		ql_log(ql_log_warn, sp->fcport->vha, 0x700c,
2598 		    "qla2x00_alloc_iocbs failed.\n");
2599 		goto done;
2600 	}
2601 
2602 	rval = QLA_SUCCESS;
2603 	switch (sp->type) {
2604 	case SRB_LOGIN_CMD:
2605 		IS_FWI2_CAPABLE(ha) ?
2606 		    qla24xx_login_iocb(sp, pkt) :
2607 		    qla2x00_login_iocb(sp, pkt);
2608 		break;
2609 	case SRB_LOGOUT_CMD:
2610 		IS_FWI2_CAPABLE(ha) ?
2611 		    qla24xx_logout_iocb(sp, pkt) :
2612 		    qla2x00_logout_iocb(sp, pkt);
2613 		break;
2614 	case SRB_ELS_CMD_RPT:
2615 	case SRB_ELS_CMD_HST:
2616 		qla24xx_els_iocb(sp, pkt);
2617 		break;
2618 	case SRB_CT_CMD:
2619 		IS_FWI2_CAPABLE(ha) ?
2620 		    qla24xx_ct_iocb(sp, pkt) :
2621 		    qla2x00_ct_iocb(sp, pkt);
2622 		break;
2623 	case SRB_ADISC_CMD:
2624 		IS_FWI2_CAPABLE(ha) ?
2625 		    qla24xx_adisc_iocb(sp, pkt) :
2626 		    qla2x00_adisc_iocb(sp, pkt);
2627 		break;
2628 	case SRB_TM_CMD:
2629 		qla24xx_tm_iocb(sp, pkt);
2630 		break;
2631 	default:
2632 		break;
2633 	}
2634 
2635 	wmb();
2636 	qla2x00_start_iocbs(sp->fcport->vha, ha->req_q_map[0]);
2637 done:
2638 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2639 	return rval;
2640 }
2641 
2642 static void
2643 qla25xx_build_bidir_iocb(srb_t *sp, struct scsi_qla_host *vha,
2644 				struct cmd_bidir *cmd_pkt, uint32_t tot_dsds)
2645 {
2646 	uint16_t avail_dsds;
2647 	uint32_t *cur_dsd;
2648 	uint32_t req_data_len = 0;
2649 	uint32_t rsp_data_len = 0;
2650 	struct scatterlist *sg;
2651 	int index;
2652 	int entry_count = 1;
2653 	struct fc_bsg_job *bsg_job = sp->u.bsg_job;
2654 
2655 	/*Update entry type to indicate bidir command */
2656 	*((uint32_t *)(&cmd_pkt->entry_type)) =
2657 		__constant_cpu_to_le32(COMMAND_BIDIRECTIONAL);
2658 
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.
2662 	 */
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 |
2667 							BD_WRAP_BACK);
2668 
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);
2673 
2674 	vha->bidi_stats.transfer_bytes += req_data_len;
2675 	vha->bidi_stats.io_count++;
2676 
2677 	/* Only one dsd is available for bidirectional IOCB, remaining dsds
2678 	 * are bundled in continuation iocb
2679 	 */
2680 	avail_dsds = 1;
2681 	cur_dsd = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
2682 
2683 	index = 0;
2684 
2685 	for_each_sg(bsg_job->request_payload.sg_list, sg,
2686 				bsg_job->request_payload.sg_cnt, index) {
2687 		dma_addr_t sle_dma;
2688 		cont_a64_entry_t *cont_pkt;
2689 
2690 		/* Allocate additional continuation packets */
2691 		if (avail_dsds == 0) {
2692 			/* Continuation type 1 IOCB can accomodate
2693 			 * 5 DSDS
2694 			 */
2695 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
2696 			cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2697 			avail_dsds = 5;
2698 			entry_count++;
2699 		}
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));
2704 		avail_dsds--;
2705 	}
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
2709 	 * allocated.
2710 	 */
2711 	for_each_sg(bsg_job->reply_payload.sg_list, sg,
2712 				bsg_job->reply_payload.sg_cnt, index) {
2713 		dma_addr_t sle_dma;
2714 		cont_a64_entry_t *cont_pkt;
2715 
2716 		/* Allocate additional continuation packets */
2717 		if (avail_dsds == 0) {
2718 			/* Continuation type 1 IOCB can accomodate
2719 			 * 5 DSDS
2720 			 */
2721 			cont_pkt = qla2x00_prep_cont_type1_iocb(vha, vha->req);
2722 			cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
2723 			avail_dsds = 5;
2724 			entry_count++;
2725 		}
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));
2730 		avail_dsds--;
2731 	}
2732 	/* This value should be same as number of IOCB required for this cmd */
2733 	cmd_pkt->entry_count = entry_count;
2734 }
2735 
2736 int
2737 qla2x00_start_bidir(srb_t *sp, struct scsi_qla_host *vha, uint32_t tot_dsds)
2738 {
2739 
2740 	struct qla_hw_data *ha = vha->hw;
2741 	unsigned long flags;
2742 	uint32_t handle;
2743 	uint32_t index;
2744 	uint16_t req_cnt;
2745 	uint16_t cnt;
2746 	uint32_t *clr_ptr;
2747 	struct cmd_bidir *cmd_pkt = NULL;
2748 	struct rsp_que *rsp;
2749 	struct req_que *req;
2750 	int rval = EXT_STATUS_OK;
2751 
2752 	rval = QLA_SUCCESS;
2753 
2754 	rsp = ha->rsp_q_map[0];
2755 	req = vha->req;
2756 
2757 	/* Send marker if required */
2758 	if (vha->marker_needed != 0) {
2759 		if (qla2x00_marker(vha, req,
2760 			rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS)
2761 			return EXT_STATUS_MAILBOX;
2762 		vha->marker_needed = 0;
2763 	}
2764 
2765 	/* Acquire ring specific lock */
2766 	spin_lock_irqsave(&ha->hardware_lock, flags);
2767 
2768 	/* Check for room in outstanding command list. */
2769 	handle = req->current_outstanding_cmd;
2770 	for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
2771 		handle++;
2772 	if (handle == MAX_OUTSTANDING_COMMANDS)
2773 		handle = 1;
2774 	if (!req->outstanding_cmds[handle])
2775 		break;
2776 	}
2777 
2778 	if (index == MAX_OUTSTANDING_COMMANDS) {
2779 		rval = EXT_STATUS_BUSY;
2780 		goto queuing_error;
2781 	}
2782 
2783 	/* Calculate number of IOCB required */
2784 	req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
2785 
2786 	/* Check for room on request queue. */
2787 	if (req->cnt < req_cnt + 2) {
2788 		cnt = RD_REG_DWORD_RELAXED(req->req_q_out);
2789 
2790 		if  (req->ring_index < cnt)
2791 			req->cnt = cnt - req->ring_index;
2792 		else
2793 			req->cnt = req->length -
2794 				(req->ring_index - cnt);
2795 	}
2796 	if (req->cnt < req_cnt + 2) {
2797 		rval = EXT_STATUS_BUSY;
2798 		goto queuing_error;
2799 	}
2800 
2801 	cmd_pkt = (struct cmd_bidir *)req->ring_ptr;
2802 	cmd_pkt->handle = MAKE_HANDLE(req->id, handle);
2803 
2804 	/* Zero out remaining portion of packet. */
2805 	/* tagged queuing modifier -- default is TSK_SIMPLE (0).*/
2806 	clr_ptr = (uint32_t *)cmd_pkt + 2;
2807 	memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
2808 
2809 	/* Set NPORT-ID  (of vha)*/
2810 	cmd_pkt->nport_handle = cpu_to_le16(vha->self_login_loop_id);
2811 	cmd_pkt->port_id[0] = vha->d_id.b.al_pa;
2812 	cmd_pkt->port_id[1] = vha->d_id.b.area;
2813 	cmd_pkt->port_id[2] = vha->d_id.b.domain;
2814 
2815 	qla25xx_build_bidir_iocb(sp, vha, cmd_pkt, tot_dsds);
2816 	cmd_pkt->entry_status = (uint8_t) rsp->id;
2817 	/* Build command packet. */
2818 	req->current_outstanding_cmd = handle;
2819 	req->outstanding_cmds[handle] = sp;
2820 	sp->handle = handle;
2821 	req->cnt -= req_cnt;
2822 
2823 	/* Send the command to the firmware */
2824 	wmb();
2825 	qla2x00_start_iocbs(vha, req);
2826 queuing_error:
2827 	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2828 	return rval;
2829 }
2830