Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / drivers / scsi / qla2xxx / qla_iocb.c
1 /*
2  * QLogic Fibre Channel HBA Driver
3  * Copyright (c)  2003-2008 QLogic Corporation
4  *
5  * See LICENSE.qla2xxx for copyright and licensing details.
6  */
7 #include "qla_def.h"
8
9 #include <linux/blkdev.h>
10 #include <linux/delay.h>
11
12 #include <scsi/scsi_tcq.h>
13
14 static request_t *qla2x00_req_pkt(scsi_qla_host_t *ha);
15 static void qla2x00_isp_cmd(scsi_qla_host_t *ha);
16
17 /**
18  * qla2x00_get_cmd_direction() - Determine control_flag data direction.
19  * @cmd: SCSI command
20  *
21  * Returns the proper CF_* direction based on CDB.
22  */
23 static inline uint16_t
24 qla2x00_get_cmd_direction(srb_t *sp)
25 {
26         uint16_t cflags;
27
28         cflags = 0;
29
30         /* Set transfer direction */
31         if (sp->cmd->sc_data_direction == DMA_TO_DEVICE) {
32                 cflags = CF_WRITE;
33                 sp->fcport->ha->qla_stats.output_bytes +=
34                     scsi_bufflen(sp->cmd);
35         } else if (sp->cmd->sc_data_direction == DMA_FROM_DEVICE) {
36                 cflags = CF_READ;
37                 sp->fcport->ha->qla_stats.input_bytes +=
38                     scsi_bufflen(sp->cmd);
39         }
40         return (cflags);
41 }
42
43 /**
44  * qla2x00_calc_iocbs_32() - Determine number of Command Type 2 and
45  * Continuation Type 0 IOCBs to allocate.
46  *
47  * @dsds: number of data segment decriptors needed
48  *
49  * Returns the number of IOCB entries needed to store @dsds.
50  */
51 uint16_t
52 qla2x00_calc_iocbs_32(uint16_t dsds)
53 {
54         uint16_t iocbs;
55
56         iocbs = 1;
57         if (dsds > 3) {
58                 iocbs += (dsds - 3) / 7;
59                 if ((dsds - 3) % 7)
60                         iocbs++;
61         }
62         return (iocbs);
63 }
64
65 /**
66  * qla2x00_calc_iocbs_64() - Determine number of Command Type 3 and
67  * Continuation Type 1 IOCBs to allocate.
68  *
69  * @dsds: number of data segment decriptors needed
70  *
71  * Returns the number of IOCB entries needed to store @dsds.
72  */
73 uint16_t
74 qla2x00_calc_iocbs_64(uint16_t dsds)
75 {
76         uint16_t iocbs;
77
78         iocbs = 1;
79         if (dsds > 2) {
80                 iocbs += (dsds - 2) / 5;
81                 if ((dsds - 2) % 5)
82                         iocbs++;
83         }
84         return (iocbs);
85 }
86
87 /**
88  * qla2x00_prep_cont_type0_iocb() - Initialize a Continuation Type 0 IOCB.
89  * @ha: HA context
90  *
91  * Returns a pointer to the Continuation Type 0 IOCB packet.
92  */
93 static inline cont_entry_t *
94 qla2x00_prep_cont_type0_iocb(scsi_qla_host_t *ha)
95 {
96         cont_entry_t *cont_pkt;
97
98         /* Adjust ring index. */
99         ha->req_ring_index++;
100         if (ha->req_ring_index == ha->request_q_length) {
101                 ha->req_ring_index = 0;
102                 ha->request_ring_ptr = ha->request_ring;
103         } else {
104                 ha->request_ring_ptr++;
105         }
106
107         cont_pkt = (cont_entry_t *)ha->request_ring_ptr;
108
109         /* Load packet defaults. */
110         *((uint32_t *)(&cont_pkt->entry_type)) =
111             __constant_cpu_to_le32(CONTINUE_TYPE);
112
113         return (cont_pkt);
114 }
115
116 /**
117  * qla2x00_prep_cont_type1_iocb() - Initialize a Continuation Type 1 IOCB.
118  * @ha: HA context
119  *
120  * Returns a pointer to the continuation type 1 IOCB packet.
121  */
122 static inline cont_a64_entry_t *
123 qla2x00_prep_cont_type1_iocb(scsi_qla_host_t *ha)
124 {
125         cont_a64_entry_t *cont_pkt;
126
127         /* Adjust ring index. */
128         ha->req_ring_index++;
129         if (ha->req_ring_index == ha->request_q_length) {
130                 ha->req_ring_index = 0;
131                 ha->request_ring_ptr = ha->request_ring;
132         } else {
133                 ha->request_ring_ptr++;
134         }
135
136         cont_pkt = (cont_a64_entry_t *)ha->request_ring_ptr;
137
138         /* Load packet defaults. */
139         *((uint32_t *)(&cont_pkt->entry_type)) =
140             __constant_cpu_to_le32(CONTINUE_A64_TYPE);
141
142         return (cont_pkt);
143 }
144
145 /**
146  * qla2x00_build_scsi_iocbs_32() - Build IOCB command utilizing 32bit
147  * capable IOCB types.
148  *
149  * @sp: SRB command to process
150  * @cmd_pkt: Command type 2 IOCB
151  * @tot_dsds: Total number of segments to transfer
152  */
153 void qla2x00_build_scsi_iocbs_32(srb_t *sp, cmd_entry_t *cmd_pkt,
154     uint16_t tot_dsds)
155 {
156         uint16_t        avail_dsds;
157         uint32_t        *cur_dsd;
158         scsi_qla_host_t *ha;
159         struct scsi_cmnd *cmd;
160         struct scatterlist *sg;
161         int i;
162
163         cmd = sp->cmd;
164
165         /* Update entry type to indicate Command Type 2 IOCB */
166         *((uint32_t *)(&cmd_pkt->entry_type)) =
167             __constant_cpu_to_le32(COMMAND_TYPE);
168
169         /* No data transfer */
170         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
171                 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
172                 return;
173         }
174
175         ha = sp->ha;
176
177         cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
178
179         /* Three DSDs are available in the Command Type 2 IOCB */
180         avail_dsds = 3;
181         cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
182
183         /* Load data segments */
184         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
185                 cont_entry_t *cont_pkt;
186
187                 /* Allocate additional continuation packets? */
188                 if (avail_dsds == 0) {
189                         /*
190                          * Seven DSDs are available in the Continuation
191                          * Type 0 IOCB.
192                          */
193                         cont_pkt = qla2x00_prep_cont_type0_iocb(ha);
194                         cur_dsd = (uint32_t *)&cont_pkt->dseg_0_address;
195                         avail_dsds = 7;
196                 }
197
198                 *cur_dsd++ = cpu_to_le32(sg_dma_address(sg));
199                 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
200                 avail_dsds--;
201         }
202 }
203
204 /**
205  * qla2x00_build_scsi_iocbs_64() - Build IOCB command utilizing 64bit
206  * capable IOCB types.
207  *
208  * @sp: SRB command to process
209  * @cmd_pkt: Command type 3 IOCB
210  * @tot_dsds: Total number of segments to transfer
211  */
212 void qla2x00_build_scsi_iocbs_64(srb_t *sp, cmd_entry_t *cmd_pkt,
213     uint16_t tot_dsds)
214 {
215         uint16_t        avail_dsds;
216         uint32_t        *cur_dsd;
217         scsi_qla_host_t *ha;
218         struct scsi_cmnd *cmd;
219         struct scatterlist *sg;
220         int i;
221
222         cmd = sp->cmd;
223
224         /* Update entry type to indicate Command Type 3 IOCB */
225         *((uint32_t *)(&cmd_pkt->entry_type)) =
226             __constant_cpu_to_le32(COMMAND_A64_TYPE);
227
228         /* No data transfer */
229         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
230                 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
231                 return;
232         }
233
234         ha = sp->ha;
235
236         cmd_pkt->control_flags |= cpu_to_le16(qla2x00_get_cmd_direction(sp));
237
238         /* Two DSDs are available in the Command Type 3 IOCB */
239         avail_dsds = 2;
240         cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
241
242         /* Load data segments */
243         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
244                 dma_addr_t      sle_dma;
245                 cont_a64_entry_t *cont_pkt;
246
247                 /* Allocate additional continuation packets? */
248                 if (avail_dsds == 0) {
249                         /*
250                          * Five DSDs are available in the Continuation
251                          * Type 1 IOCB.
252                          */
253                         cont_pkt = qla2x00_prep_cont_type1_iocb(ha);
254                         cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
255                         avail_dsds = 5;
256                 }
257
258                 sle_dma = sg_dma_address(sg);
259                 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
260                 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
261                 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
262                 avail_dsds--;
263         }
264 }
265
266 /**
267  * qla2x00_start_scsi() - Send a SCSI command to the ISP
268  * @sp: command to send to the ISP
269  *
270  * Returns non-zero if a failure occurred, else zero.
271  */
272 int
273 qla2x00_start_scsi(srb_t *sp)
274 {
275         int             ret, nseg;
276         unsigned long   flags;
277         scsi_qla_host_t *ha;
278         struct scsi_cmnd *cmd;
279         uint32_t        *clr_ptr;
280         uint32_t        index;
281         uint32_t        handle;
282         cmd_entry_t     *cmd_pkt;
283         uint16_t        cnt;
284         uint16_t        req_cnt;
285         uint16_t        tot_dsds;
286         struct device_reg_2xxx __iomem *reg;
287
288         /* Setup device pointers. */
289         ret = 0;
290         ha = sp->ha;
291         reg = &ha->iobase->isp;
292         cmd = sp->cmd;
293         /* So we know we haven't pci_map'ed anything yet */
294         tot_dsds = 0;
295
296         /* Send marker if required */
297         if (ha->marker_needed != 0) {
298                 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
299                         return (QLA_FUNCTION_FAILED);
300                 }
301                 ha->marker_needed = 0;
302         }
303
304         /* Acquire ring specific lock */
305         spin_lock_irqsave(&ha->hardware_lock, flags);
306
307         /* Check for room in outstanding command list. */
308         handle = ha->current_outstanding_cmd;
309         for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
310                 handle++;
311                 if (handle == MAX_OUTSTANDING_COMMANDS)
312                         handle = 1;
313                 if (!ha->outstanding_cmds[handle])
314                         break;
315         }
316         if (index == MAX_OUTSTANDING_COMMANDS)
317                 goto queuing_error;
318
319         /* Map the sg table so we have an accurate count of sg entries needed */
320         if (scsi_sg_count(cmd)) {
321                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
322                     scsi_sg_count(cmd), cmd->sc_data_direction);
323                 if (unlikely(!nseg))
324                         goto queuing_error;
325         } else
326                 nseg = 0;
327
328         tot_dsds = nseg;
329
330         /* Calculate the number of request entries needed. */
331         req_cnt = ha->isp_ops->calc_req_entries(tot_dsds);
332         if (ha->req_q_cnt < (req_cnt + 2)) {
333                 cnt = RD_REG_WORD_RELAXED(ISP_REQ_Q_OUT(ha, reg));
334                 if (ha->req_ring_index < cnt)
335                         ha->req_q_cnt = cnt - ha->req_ring_index;
336                 else
337                         ha->req_q_cnt = ha->request_q_length -
338                             (ha->req_ring_index - cnt);
339         }
340         if (ha->req_q_cnt < (req_cnt + 2))
341                 goto queuing_error;
342
343         /* Build command packet */
344         ha->current_outstanding_cmd = handle;
345         ha->outstanding_cmds[handle] = sp;
346         sp->ha = ha;
347         sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle;
348         ha->req_q_cnt -= req_cnt;
349
350         cmd_pkt = (cmd_entry_t *)ha->request_ring_ptr;
351         cmd_pkt->handle = handle;
352         /* Zero out remaining portion of packet. */
353         clr_ptr = (uint32_t *)cmd_pkt + 2;
354         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
355         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
356
357         /* Set target ID and LUN number*/
358         SET_TARGET_ID(ha, cmd_pkt->target, sp->fcport->loop_id);
359         cmd_pkt->lun = cpu_to_le16(sp->cmd->device->lun);
360
361         /* Update tagged queuing modifier */
362         cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG);
363
364         /* Load SCSI command packet. */
365         memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
366         cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
367
368         /* Build IOCB segments */
369         ha->isp_ops->build_iocbs(sp, cmd_pkt, tot_dsds);
370
371         /* Set total data segment count. */
372         cmd_pkt->entry_count = (uint8_t)req_cnt;
373         wmb();
374
375         /* Adjust ring index. */
376         ha->req_ring_index++;
377         if (ha->req_ring_index == ha->request_q_length) {
378                 ha->req_ring_index = 0;
379                 ha->request_ring_ptr = ha->request_ring;
380         } else
381                 ha->request_ring_ptr++;
382
383         sp->flags |= SRB_DMA_VALID;
384
385         /* Set chip new ring index. */
386         WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), ha->req_ring_index);
387         RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, reg));     /* PCI Posting. */
388
389         /* Manage unprocessed RIO/ZIO commands in response queue. */
390         if (ha->flags.process_response_queue &&
391             ha->response_ring_ptr->signature != RESPONSE_PROCESSED)
392                 qla2x00_process_response_queue(ha);
393
394         spin_unlock_irqrestore(&ha->hardware_lock, flags);
395         return (QLA_SUCCESS);
396
397 queuing_error:
398         if (tot_dsds)
399                 scsi_dma_unmap(cmd);
400
401         spin_unlock_irqrestore(&ha->hardware_lock, flags);
402
403         return (QLA_FUNCTION_FAILED);
404 }
405
406 /**
407  * qla2x00_marker() - Send a marker IOCB to the firmware.
408  * @ha: HA context
409  * @loop_id: loop ID
410  * @lun: LUN
411  * @type: marker modifier
412  *
413  * Can be called from both normal and interrupt context.
414  *
415  * Returns non-zero if a failure occurred, else zero.
416  */
417 int
418 __qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun,
419     uint8_t type)
420 {
421         mrk_entry_t *mrk;
422         struct mrk_entry_24xx *mrk24;
423         scsi_qla_host_t *pha = to_qla_parent(ha);
424
425         mrk24 = NULL;
426         mrk = (mrk_entry_t *)qla2x00_req_pkt(pha);
427         if (mrk == NULL) {
428                 DEBUG2_3(printk("%s(%ld): failed to allocate Marker IOCB.\n",
429                     __func__, ha->host_no));
430
431                 return (QLA_FUNCTION_FAILED);
432         }
433
434         mrk->entry_type = MARKER_TYPE;
435         mrk->modifier = type;
436         if (type != MK_SYNC_ALL) {
437                 if (IS_FWI2_CAPABLE(ha)) {
438                         mrk24 = (struct mrk_entry_24xx *) mrk;
439                         mrk24->nport_handle = cpu_to_le16(loop_id);
440                         mrk24->lun[1] = LSB(lun);
441                         mrk24->lun[2] = MSB(lun);
442                         host_to_fcp_swap(mrk24->lun, sizeof(mrk24->lun));
443                         mrk24->vp_index = ha->vp_idx;
444                 } else {
445                         SET_TARGET_ID(ha, mrk->target, loop_id);
446                         mrk->lun = cpu_to_le16(lun);
447                 }
448         }
449         wmb();
450
451         qla2x00_isp_cmd(pha);
452
453         return (QLA_SUCCESS);
454 }
455
456 int
457 qla2x00_marker(scsi_qla_host_t *ha, uint16_t loop_id, uint16_t lun,
458     uint8_t type)
459 {
460         int ret;
461         unsigned long flags = 0;
462         scsi_qla_host_t *pha = to_qla_parent(ha);
463
464         spin_lock_irqsave(&pha->hardware_lock, flags);
465         ret = __qla2x00_marker(ha, loop_id, lun, type);
466         spin_unlock_irqrestore(&pha->hardware_lock, flags);
467
468         return (ret);
469 }
470
471 /**
472  * qla2x00_req_pkt() - Retrieve a request packet from the request ring.
473  * @ha: HA context
474  *
475  * Note: The caller must hold the hardware lock before calling this routine.
476  *
477  * Returns NULL if function failed, else, a pointer to the request packet.
478  */
479 static request_t *
480 qla2x00_req_pkt(scsi_qla_host_t *ha)
481 {
482         device_reg_t __iomem *reg = ha->iobase;
483         request_t       *pkt = NULL;
484         uint16_t        cnt;
485         uint32_t        *dword_ptr;
486         uint32_t        timer;
487         uint16_t        req_cnt = 1;
488
489         /* Wait 1 second for slot. */
490         for (timer = HZ; timer; timer--) {
491                 if ((req_cnt + 2) >= ha->req_q_cnt) {
492                         /* Calculate number of free request entries. */
493                         if (IS_FWI2_CAPABLE(ha))
494                                 cnt = (uint16_t)RD_REG_DWORD(
495                                     &reg->isp24.req_q_out);
496                         else
497                                 cnt = qla2x00_debounce_register(
498                                     ISP_REQ_Q_OUT(ha, &reg->isp));
499                         if  (ha->req_ring_index < cnt)
500                                 ha->req_q_cnt = cnt - ha->req_ring_index;
501                         else
502                                 ha->req_q_cnt = ha->request_q_length -
503                                     (ha->req_ring_index - cnt);
504                 }
505                 /* If room for request in request ring. */
506                 if ((req_cnt + 2) < ha->req_q_cnt) {
507                         ha->req_q_cnt--;
508                         pkt = ha->request_ring_ptr;
509
510                         /* Zero out packet. */
511                         dword_ptr = (uint32_t *)pkt;
512                         for (cnt = 0; cnt < REQUEST_ENTRY_SIZE / 4; cnt++)
513                                 *dword_ptr++ = 0;
514
515                         /* Set system defined field. */
516                         pkt->sys_define = (uint8_t)ha->req_ring_index;
517
518                         /* Set entry count. */
519                         pkt->entry_count = 1;
520
521                         break;
522                 }
523
524                 /* Release ring specific lock */
525                 spin_unlock(&ha->hardware_lock);
526
527                 udelay(2);   /* 2 us */
528
529                 /* Check for pending interrupts. */
530                 /* During init we issue marker directly */
531                 if (!ha->marker_needed && !ha->flags.init_done)
532                         qla2x00_poll(ha);
533
534                 spin_lock_irq(&ha->hardware_lock);
535         }
536         if (!pkt) {
537                 DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
538         }
539
540         return (pkt);
541 }
542
543 /**
544  * qla2x00_isp_cmd() - Modify the request ring pointer.
545  * @ha: HA context
546  *
547  * Note: The caller must hold the hardware lock before calling this routine.
548  */
549 static void
550 qla2x00_isp_cmd(scsi_qla_host_t *ha)
551 {
552         device_reg_t __iomem *reg = ha->iobase;
553
554         DEBUG5(printk("%s(): IOCB data:\n", __func__));
555         DEBUG5(qla2x00_dump_buffer(
556             (uint8_t *)ha->request_ring_ptr, REQUEST_ENTRY_SIZE));
557
558         /* Adjust ring index. */
559         ha->req_ring_index++;
560         if (ha->req_ring_index == ha->request_q_length) {
561                 ha->req_ring_index = 0;
562                 ha->request_ring_ptr = ha->request_ring;
563         } else
564                 ha->request_ring_ptr++;
565
566         /* Set chip new ring index. */
567         if (IS_FWI2_CAPABLE(ha)) {
568                 WRT_REG_DWORD(&reg->isp24.req_q_in, ha->req_ring_index);
569                 RD_REG_DWORD_RELAXED(&reg->isp24.req_q_in);
570         } else {
571                 WRT_REG_WORD(ISP_REQ_Q_IN(ha, &reg->isp), ha->req_ring_index);
572                 RD_REG_WORD_RELAXED(ISP_REQ_Q_IN(ha, &reg->isp));
573         }
574
575 }
576
577 /**
578  * qla24xx_calc_iocbs() - Determine number of Command Type 3 and
579  * Continuation Type 1 IOCBs to allocate.
580  *
581  * @dsds: number of data segment decriptors needed
582  *
583  * Returns the number of IOCB entries needed to store @dsds.
584  */
585 static inline uint16_t
586 qla24xx_calc_iocbs(uint16_t dsds)
587 {
588         uint16_t iocbs;
589
590         iocbs = 1;
591         if (dsds > 1) {
592                 iocbs += (dsds - 1) / 5;
593                 if ((dsds - 1) % 5)
594                         iocbs++;
595         }
596         return iocbs;
597 }
598
599 /**
600  * qla24xx_build_scsi_iocbs() - Build IOCB command utilizing Command Type 7
601  * IOCB types.
602  *
603  * @sp: SRB command to process
604  * @cmd_pkt: Command type 3 IOCB
605  * @tot_dsds: Total number of segments to transfer
606  */
607 static inline void
608 qla24xx_build_scsi_iocbs(srb_t *sp, struct cmd_type_7 *cmd_pkt,
609     uint16_t tot_dsds)
610 {
611         uint16_t        avail_dsds;
612         uint32_t        *cur_dsd;
613         scsi_qla_host_t *ha;
614         struct scsi_cmnd *cmd;
615         struct scatterlist *sg;
616         int i;
617
618         cmd = sp->cmd;
619
620         /* Update entry type to indicate Command Type 3 IOCB */
621         *((uint32_t *)(&cmd_pkt->entry_type)) =
622             __constant_cpu_to_le32(COMMAND_TYPE_7);
623
624         /* No data transfer */
625         if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
626                 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
627                 return;
628         }
629
630         ha = sp->ha;
631
632         /* Set transfer direction */
633         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
634                 cmd_pkt->task_mgmt_flags =
635                     __constant_cpu_to_le16(TMF_WRITE_DATA);
636                 sp->fcport->ha->qla_stats.output_bytes +=
637                     scsi_bufflen(sp->cmd);
638         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
639                 cmd_pkt->task_mgmt_flags =
640                     __constant_cpu_to_le16(TMF_READ_DATA);
641                 sp->fcport->ha->qla_stats.input_bytes +=
642                     scsi_bufflen(sp->cmd);
643         }
644
645         /* One DSD is available in the Command Type 3 IOCB */
646         avail_dsds = 1;
647         cur_dsd = (uint32_t *)&cmd_pkt->dseg_0_address;
648
649         /* Load data segments */
650
651         scsi_for_each_sg(cmd, sg, tot_dsds, i) {
652                 dma_addr_t      sle_dma;
653                 cont_a64_entry_t *cont_pkt;
654
655                 /* Allocate additional continuation packets? */
656                 if (avail_dsds == 0) {
657                         /*
658                          * Five DSDs are available in the Continuation
659                          * Type 1 IOCB.
660                          */
661                         cont_pkt = qla2x00_prep_cont_type1_iocb(ha);
662                         cur_dsd = (uint32_t *)cont_pkt->dseg_0_address;
663                         avail_dsds = 5;
664                 }
665
666                 sle_dma = sg_dma_address(sg);
667                 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
668                 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
669                 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
670                 avail_dsds--;
671         }
672 }
673
674
675 /**
676  * qla24xx_start_scsi() - Send a SCSI command to the ISP
677  * @sp: command to send to the ISP
678  *
679  * Returns non-zero if a failure occurred, else zero.
680  */
681 int
682 qla24xx_start_scsi(srb_t *sp)
683 {
684         int             ret, nseg;
685         unsigned long   flags;
686         scsi_qla_host_t *ha, *pha;
687         struct scsi_cmnd *cmd;
688         uint32_t        *clr_ptr;
689         uint32_t        index;
690         uint32_t        handle;
691         struct cmd_type_7 *cmd_pkt;
692         uint16_t        cnt;
693         uint16_t        req_cnt;
694         uint16_t        tot_dsds;
695         struct device_reg_24xx __iomem *reg;
696
697         /* Setup device pointers. */
698         ret = 0;
699         ha = sp->ha;
700         pha = to_qla_parent(ha);
701         reg = &ha->iobase->isp24;
702         cmd = sp->cmd;
703         /* So we know we haven't pci_map'ed anything yet */
704         tot_dsds = 0;
705
706         /* Send marker if required */
707         if (ha->marker_needed != 0) {
708                 if (qla2x00_marker(ha, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
709                         return QLA_FUNCTION_FAILED;
710                 }
711                 ha->marker_needed = 0;
712         }
713
714         /* Acquire ring specific lock */
715         spin_lock_irqsave(&pha->hardware_lock, flags);
716
717         /* Check for room in outstanding command list. */
718         handle = ha->current_outstanding_cmd;
719         for (index = 1; index < MAX_OUTSTANDING_COMMANDS; index++) {
720                 handle++;
721                 if (handle == MAX_OUTSTANDING_COMMANDS)
722                         handle = 1;
723                 if (!ha->outstanding_cmds[handle])
724                         break;
725         }
726         if (index == MAX_OUTSTANDING_COMMANDS)
727                 goto queuing_error;
728
729         /* Map the sg table so we have an accurate count of sg entries needed */
730         if (scsi_sg_count(cmd)) {
731                 nseg = dma_map_sg(&ha->pdev->dev, scsi_sglist(cmd),
732                     scsi_sg_count(cmd), cmd->sc_data_direction);
733                 if (unlikely(!nseg))
734                         goto queuing_error;
735         } else
736                 nseg = 0;
737
738         tot_dsds = nseg;
739
740         req_cnt = qla24xx_calc_iocbs(tot_dsds);
741         if (ha->req_q_cnt < (req_cnt + 2)) {
742                 cnt = (uint16_t)RD_REG_DWORD_RELAXED(&reg->req_q_out);
743                 if (ha->req_ring_index < cnt)
744                         ha->req_q_cnt = cnt - ha->req_ring_index;
745                 else
746                         ha->req_q_cnt = ha->request_q_length -
747                                 (ha->req_ring_index - cnt);
748         }
749         if (ha->req_q_cnt < (req_cnt + 2))
750                 goto queuing_error;
751
752         /* Build command packet. */
753         ha->current_outstanding_cmd = handle;
754         ha->outstanding_cmds[handle] = sp;
755         sp->ha = ha;
756         sp->cmd->host_scribble = (unsigned char *)(unsigned long)handle;
757         ha->req_q_cnt -= req_cnt;
758
759         cmd_pkt = (struct cmd_type_7 *)ha->request_ring_ptr;
760         cmd_pkt->handle = handle;
761
762         /* Zero out remaining portion of packet. */
763         /*    tagged queuing modifier -- default is TSK_SIMPLE (0). */
764         clr_ptr = (uint32_t *)cmd_pkt + 2;
765         memset(clr_ptr, 0, REQUEST_ENTRY_SIZE - 8);
766         cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
767
768         /* Set NPORT-ID and LUN number*/
769         cmd_pkt->nport_handle = cpu_to_le16(sp->fcport->loop_id);
770         cmd_pkt->port_id[0] = sp->fcport->d_id.b.al_pa;
771         cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
772         cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
773         cmd_pkt->vp_index = sp->fcport->vp_idx;
774
775         int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
776         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
777
778         /* Load SCSI command packet. */
779         memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
780         host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
781
782         cmd_pkt->byte_count = cpu_to_le32((uint32_t)scsi_bufflen(cmd));
783
784         /* Build IOCB segments */
785         qla24xx_build_scsi_iocbs(sp, cmd_pkt, tot_dsds);
786
787         /* Set total data segment count. */
788         cmd_pkt->entry_count = (uint8_t)req_cnt;
789         wmb();
790
791         /* Adjust ring index. */
792         ha->req_ring_index++;
793         if (ha->req_ring_index == ha->request_q_length) {
794                 ha->req_ring_index = 0;
795                 ha->request_ring_ptr = ha->request_ring;
796         } else
797                 ha->request_ring_ptr++;
798
799         sp->flags |= SRB_DMA_VALID;
800
801         /* Set chip new ring index. */
802         WRT_REG_DWORD(&reg->req_q_in, ha->req_ring_index);
803         RD_REG_DWORD_RELAXED(&reg->req_q_in);           /* PCI Posting. */
804
805         /* Manage unprocessed RIO/ZIO commands in response queue. */
806         if (ha->flags.process_response_queue &&
807             ha->response_ring_ptr->signature != RESPONSE_PROCESSED)
808                 qla24xx_process_response_queue(ha);
809
810         spin_unlock_irqrestore(&pha->hardware_lock, flags);
811         return QLA_SUCCESS;
812
813 queuing_error:
814         if (tot_dsds)
815                 scsi_dma_unmap(cmd);
816
817         spin_unlock_irqrestore(&pha->hardware_lock, flags);
818
819         return QLA_FUNCTION_FAILED;
820 }