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