2 * Copyright 2008 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
5 * This program is free software; you may redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
18 #include <linux/mempool.h>
19 #include <linux/errno.h>
20 #include <linux/init.h>
21 #include <linux/workqueue.h>
22 #include <linux/pci.h>
23 #include <linux/scatterlist.h>
24 #include <linux/skbuff.h>
25 #include <linux/spinlock.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/delay.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_cmnd.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/fc/fc_els.h>
35 #include <scsi/fc/fc_fcoe.h>
36 #include <scsi/libfc.h>
37 #include <scsi/fc_frame.h>
41 const char *fnic_state_str
[] = {
42 [FNIC_IN_FC_MODE
] = "FNIC_IN_FC_MODE",
43 [FNIC_IN_FC_TRANS_ETH_MODE
] = "FNIC_IN_FC_TRANS_ETH_MODE",
44 [FNIC_IN_ETH_MODE
] = "FNIC_IN_ETH_MODE",
45 [FNIC_IN_ETH_TRANS_FC_MODE
] = "FNIC_IN_ETH_TRANS_FC_MODE",
48 static const char *fnic_ioreq_state_str
[] = {
49 [FNIC_IOREQ_CMD_PENDING
] = "FNIC_IOREQ_CMD_PENDING",
50 [FNIC_IOREQ_ABTS_PENDING
] = "FNIC_IOREQ_ABTS_PENDING",
51 [FNIC_IOREQ_ABTS_COMPLETE
] = "FNIC_IOREQ_ABTS_COMPLETE",
52 [FNIC_IOREQ_CMD_COMPLETE
] = "FNIC_IOREQ_CMD_COMPLETE",
55 static const char *fcpio_status_str
[] = {
56 [FCPIO_SUCCESS
] = "FCPIO_SUCCESS", /*0x0*/
57 [FCPIO_INVALID_HEADER
] = "FCPIO_INVALID_HEADER",
58 [FCPIO_OUT_OF_RESOURCE
] = "FCPIO_OUT_OF_RESOURCE",
59 [FCPIO_INVALID_PARAM
] = "FCPIO_INVALID_PARAM]",
60 [FCPIO_REQ_NOT_SUPPORTED
] = "FCPIO_REQ_NOT_SUPPORTED",
61 [FCPIO_IO_NOT_FOUND
] = "FCPIO_IO_NOT_FOUND",
62 [FCPIO_ABORTED
] = "FCPIO_ABORTED", /*0x41*/
63 [FCPIO_TIMEOUT
] = "FCPIO_TIMEOUT",
64 [FCPIO_SGL_INVALID
] = "FCPIO_SGL_INVALID",
65 [FCPIO_MSS_INVALID
] = "FCPIO_MSS_INVALID",
66 [FCPIO_DATA_CNT_MISMATCH
] = "FCPIO_DATA_CNT_MISMATCH",
67 [FCPIO_FW_ERR
] = "FCPIO_FW_ERR",
68 [FCPIO_ITMF_REJECTED
] = "FCPIO_ITMF_REJECTED",
69 [FCPIO_ITMF_FAILED
] = "FCPIO_ITMF_FAILED",
70 [FCPIO_ITMF_INCORRECT_LUN
] = "FCPIO_ITMF_INCORRECT_LUN",
71 [FCPIO_CMND_REJECTED
] = "FCPIO_CMND_REJECTED",
72 [FCPIO_NO_PATH_AVAIL
] = "FCPIO_NO_PATH_AVAIL",
73 [FCPIO_PATH_FAILED
] = "FCPIO_PATH_FAILED",
74 [FCPIO_LUNMAP_CHNG_PEND
] = "FCPIO_LUNHMAP_CHNG_PEND",
77 const char *fnic_state_to_str(unsigned int state
)
79 if (state
>= ARRAY_SIZE(fnic_state_str
) || !fnic_state_str
[state
])
82 return fnic_state_str
[state
];
85 static const char *fnic_ioreq_state_to_str(unsigned int state
)
87 if (state
>= ARRAY_SIZE(fnic_ioreq_state_str
) ||
88 !fnic_ioreq_state_str
[state
])
91 return fnic_ioreq_state_str
[state
];
94 static const char *fnic_fcpio_status_to_str(unsigned int status
)
96 if (status
>= ARRAY_SIZE(fcpio_status_str
) || !fcpio_status_str
[status
])
99 return fcpio_status_str
[status
];
102 static void fnic_cleanup_io(struct fnic
*fnic
, int exclude_id
);
104 static inline spinlock_t
*fnic_io_lock_hash(struct fnic
*fnic
,
105 struct scsi_cmnd
*sc
)
107 u32 hash
= sc
->request
->tag
& (FNIC_IO_LOCKS
- 1);
109 return &fnic
->io_req_lock
[hash
];
113 * Unmap the data buffer and sense buffer for an io_req,
114 * also unmap and free the device-private scatter/gather list.
116 static void fnic_release_ioreq_buf(struct fnic
*fnic
,
117 struct fnic_io_req
*io_req
,
118 struct scsi_cmnd
*sc
)
120 if (io_req
->sgl_list_pa
)
121 pci_unmap_single(fnic
->pdev
, io_req
->sgl_list_pa
,
122 sizeof(io_req
->sgl_list
[0]) * io_req
->sgl_cnt
,
127 mempool_free(io_req
->sgl_list_alloc
,
128 fnic
->io_sgl_pool
[io_req
->sgl_type
]);
129 if (io_req
->sense_buf_pa
)
130 pci_unmap_single(fnic
->pdev
, io_req
->sense_buf_pa
,
131 SCSI_SENSE_BUFFERSIZE
, PCI_DMA_FROMDEVICE
);
134 /* Free up Copy Wq descriptors. Called with copy_wq lock held */
135 static int free_wq_copy_descs(struct fnic
*fnic
, struct vnic_wq_copy
*wq
)
137 /* if no Ack received from firmware, then nothing to clean */
138 if (!fnic
->fw_ack_recd
[0])
142 * Update desc_available count based on number of freed descriptors
143 * Account for wraparound
145 if (wq
->to_clean_index
<= fnic
->fw_ack_index
[0])
146 wq
->ring
.desc_avail
+= (fnic
->fw_ack_index
[0]
147 - wq
->to_clean_index
+ 1);
149 wq
->ring
.desc_avail
+= (wq
->ring
.desc_count
151 + fnic
->fw_ack_index
[0] + 1);
154 * just bump clean index to ack_index+1 accounting for wraparound
155 * this will essentially free up all descriptors between
156 * to_clean_index and fw_ack_index, both inclusive
159 (fnic
->fw_ack_index
[0] + 1) % wq
->ring
.desc_count
;
161 /* we have processed the acks received so far */
162 fnic
->fw_ack_recd
[0] = 0;
168 * fnic_fw_reset_handler
169 * Routine to send reset msg to fw
171 int fnic_fw_reset_handler(struct fnic
*fnic
)
173 struct vnic_wq_copy
*wq
= &fnic
->wq_copy
[0];
177 skb_queue_purge(&fnic
->frame_queue
);
178 skb_queue_purge(&fnic
->tx_queue
);
180 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], flags
);
182 if (vnic_wq_copy_desc_avail(wq
) <= fnic
->wq_copy_desc_low
[0])
183 free_wq_copy_descs(fnic
, wq
);
185 if (!vnic_wq_copy_desc_avail(wq
))
188 fnic_queue_wq_copy_desc_fw_reset(wq
, SCSI_NO_TAG
);
190 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], flags
);
193 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
194 "Issued fw reset\n");
196 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
197 "Failed to issue fw reset\n");
203 * fnic_flogi_reg_handler
204 * Routine to send flogi register msg to fw
206 int fnic_flogi_reg_handler(struct fnic
*fnic
, u32 fc_id
)
208 struct vnic_wq_copy
*wq
= &fnic
->wq_copy
[0];
209 enum fcpio_flogi_reg_format_type format
;
210 struct fc_lport
*lp
= fnic
->lport
;
215 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], flags
);
217 if (vnic_wq_copy_desc_avail(wq
) <= fnic
->wq_copy_desc_low
[0])
218 free_wq_copy_descs(fnic
, wq
);
220 if (!vnic_wq_copy_desc_avail(wq
)) {
222 goto flogi_reg_ioreq_end
;
225 if (fnic
->ctlr
.map_dest
) {
226 memset(gw_mac
, 0xff, ETH_ALEN
);
227 format
= FCPIO_FLOGI_REG_DEF_DEST
;
229 memcpy(gw_mac
, fnic
->ctlr
.dest_addr
, ETH_ALEN
);
230 format
= FCPIO_FLOGI_REG_GW_DEST
;
233 if ((fnic
->config
.flags
& VFCF_FIP_CAPABLE
) && !fnic
->ctlr
.map_dest
) {
234 fnic_queue_wq_copy_desc_fip_reg(wq
, SCSI_NO_TAG
,
237 lp
->r_a_tov
, lp
->e_d_tov
);
238 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
239 "FLOGI FIP reg issued fcid %x src %pM dest %pM\n",
240 fc_id
, fnic
->data_src_addr
, gw_mac
);
242 fnic_queue_wq_copy_desc_flogi_reg(wq
, SCSI_NO_TAG
,
243 format
, fc_id
, gw_mac
);
244 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
245 "FLOGI reg issued fcid %x map %d dest %pM\n",
246 fc_id
, fnic
->ctlr
.map_dest
, gw_mac
);
250 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], flags
);
255 * fnic_queue_wq_copy_desc
256 * Routine to enqueue a wq copy desc
258 static inline int fnic_queue_wq_copy_desc(struct fnic
*fnic
,
259 struct vnic_wq_copy
*wq
,
260 struct fnic_io_req
*io_req
,
261 struct scsi_cmnd
*sc
,
264 struct scatterlist
*sg
;
265 struct fc_rport
*rport
= starget_to_rport(scsi_target(sc
->device
));
266 struct fc_rport_libfc_priv
*rp
= rport
->dd_data
;
267 struct host_sg_desc
*desc
;
270 unsigned long intr_flags
;
273 struct scsi_lun fc_lun
;
277 /* For each SGE, create a device desc entry */
278 desc
= io_req
->sgl_list
;
279 for_each_sg(scsi_sglist(sc
), sg
, sg_count
, i
) {
280 desc
->addr
= cpu_to_le64(sg_dma_address(sg
));
281 desc
->len
= cpu_to_le32(sg_dma_len(sg
));
286 io_req
->sgl_list_pa
= pci_map_single
289 sizeof(io_req
->sgl_list
[0]) * sg_count
,
293 io_req
->sense_buf_pa
= pci_map_single(fnic
->pdev
,
295 SCSI_SENSE_BUFFERSIZE
,
298 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
300 pri_tag
= FCPIO_ICMND_PTA_SIMPLE
;
301 msg
[0] = MSG_SIMPLE_TAG
;
302 scsi_populate_tag_msg(sc
, msg
);
303 if (msg
[0] == MSG_ORDERED_TAG
)
304 pri_tag
= FCPIO_ICMND_PTA_ORDERED
;
306 /* Enqueue the descriptor in the Copy WQ */
307 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], intr_flags
);
309 if (vnic_wq_copy_desc_avail(wq
) <= fnic
->wq_copy_desc_low
[0])
310 free_wq_copy_descs(fnic
, wq
);
312 if (unlikely(!vnic_wq_copy_desc_avail(wq
))) {
313 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], intr_flags
);
314 return SCSI_MLQUEUE_HOST_BUSY
;
318 if (sc
->sc_data_direction
== DMA_FROM_DEVICE
)
319 flags
= FCPIO_ICMND_RDDATA
;
320 else if (sc
->sc_data_direction
== DMA_TO_DEVICE
)
321 flags
= FCPIO_ICMND_WRDATA
;
324 if ((fnic
->config
.flags
& VFCF_FCP_SEQ_LVL_ERR
) &&
325 (rp
->flags
& FC_RP_FLAGS_RETRY
))
326 exch_flags
|= FCPIO_ICMND_SRFLAG_RETRY
;
328 fnic_queue_wq_copy_desc_icmnd_16(wq
, sc
->request
->tag
,
329 0, exch_flags
, io_req
->sgl_cnt
,
330 SCSI_SENSE_BUFFERSIZE
,
332 io_req
->sense_buf_pa
,
333 0, /* scsi cmd ref, always 0 */
334 pri_tag
, /* scsi pri and tag */
335 flags
, /* command flags */
336 sc
->cmnd
, sc
->cmd_len
,
338 fc_lun
.scsi_lun
, io_req
->port_id
,
339 rport
->maxframe_size
, rp
->r_a_tov
,
342 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], intr_flags
);
348 * Routine to send a scsi cdb
349 * Called with host_lock held and interrupts disabled.
351 int fnic_queuecommand(struct scsi_cmnd
*sc
, void (*done
)(struct scsi_cmnd
*))
354 struct fc_rport
*rport
;
355 struct fnic_io_req
*io_req
;
357 struct vnic_wq_copy
*wq
;
363 rport
= starget_to_rport(scsi_target(sc
->device
));
364 ret
= fc_remote_port_chkready(rport
);
371 lp
= shost_priv(sc
->device
->host
);
372 if (lp
->state
!= LPORT_ST_READY
|| !(lp
->link_up
))
373 return SCSI_MLQUEUE_HOST_BUSY
;
376 * Release host lock, use driver resource specific locks from here.
377 * Don't re-enable interrupts in case they were disabled prior to the
378 * caller disabling them.
380 spin_unlock(lp
->host
->host_lock
);
382 /* Get a new io_req for this SCSI IO */
383 fnic
= lport_priv(lp
);
385 io_req
= mempool_alloc(fnic
->io_req_pool
, GFP_ATOMIC
);
387 ret
= SCSI_MLQUEUE_HOST_BUSY
;
390 memset(io_req
, 0, sizeof(*io_req
));
392 /* Map the data buffer */
393 sg_count
= scsi_dma_map(sc
);
395 mempool_free(io_req
, fnic
->io_req_pool
);
399 /* Determine the type of scatter/gather list we need */
400 io_req
->sgl_cnt
= sg_count
;
401 io_req
->sgl_type
= FNIC_SGL_CACHE_DFLT
;
402 if (sg_count
> FNIC_DFLT_SG_DESC_CNT
)
403 io_req
->sgl_type
= FNIC_SGL_CACHE_MAX
;
407 mempool_alloc(fnic
->io_sgl_pool
[io_req
->sgl_type
],
408 GFP_ATOMIC
| GFP_DMA
);
409 if (!io_req
->sgl_list
) {
410 ret
= SCSI_MLQUEUE_HOST_BUSY
;
412 mempool_free(io_req
, fnic
->io_req_pool
);
416 /* Cache sgl list allocated address before alignment */
417 io_req
->sgl_list_alloc
= io_req
->sgl_list
;
418 ptr
= (unsigned long) io_req
->sgl_list
;
419 if (ptr
% FNIC_SG_DESC_ALIGN
) {
420 io_req
->sgl_list
= (struct host_sg_desc
*)
421 (((unsigned long) ptr
422 + FNIC_SG_DESC_ALIGN
- 1)
423 & ~(FNIC_SG_DESC_ALIGN
- 1));
427 /* initialize rest of io_req */
428 io_req
->port_id
= rport
->port_id
;
429 CMD_STATE(sc
) = FNIC_IOREQ_CMD_PENDING
;
430 CMD_SP(sc
) = (char *)io_req
;
431 sc
->scsi_done
= done
;
433 /* create copy wq desc and enqueue it */
434 wq
= &fnic
->wq_copy
[0];
435 ret
= fnic_queue_wq_copy_desc(fnic
, wq
, io_req
, sc
, sg_count
);
438 * In case another thread cancelled the request,
439 * refetch the pointer under the lock.
441 spinlock_t
*io_lock
= fnic_io_lock_hash(fnic
, sc
);
443 spin_lock_irqsave(io_lock
, flags
);
444 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
446 CMD_STATE(sc
) = FNIC_IOREQ_CMD_COMPLETE
;
447 spin_unlock_irqrestore(io_lock
, flags
);
449 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
450 mempool_free(io_req
, fnic
->io_req_pool
);
454 /* acquire host lock before returning to SCSI */
455 spin_lock(lp
->host
->host_lock
);
460 * fnic_fcpio_fw_reset_cmpl_handler
461 * Routine to handle fw reset completion
463 static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic
*fnic
,
464 struct fcpio_fw_req
*desc
)
468 struct fcpio_tag tag
;
472 fcpio_header_dec(&desc
->hdr
, &type
, &hdr_status
, &tag
);
474 /* Clean up all outstanding io requests */
475 fnic_cleanup_io(fnic
, SCSI_NO_TAG
);
477 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
479 /* fnic should be in FC_TRANS_ETH_MODE */
480 if (fnic
->state
== FNIC_IN_FC_TRANS_ETH_MODE
) {
481 /* Check status of reset completion */
483 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
484 "reset cmpl success\n");
485 /* Ready to send flogi out */
486 fnic
->state
= FNIC_IN_ETH_MODE
;
488 FNIC_SCSI_DBG(KERN_DEBUG
,
490 "fnic fw_reset : failed %s\n",
491 fnic_fcpio_status_to_str(hdr_status
));
494 * Unable to change to eth mode, cannot send out flogi
495 * Change state to fc mode, so that subsequent Flogi
496 * requests from libFC will cause more attempts to
497 * reset the firmware. Free the cached flogi
499 fnic
->state
= FNIC_IN_FC_MODE
;
503 FNIC_SCSI_DBG(KERN_DEBUG
,
505 "Unexpected state %s while processing"
506 " reset cmpl\n", fnic_state_to_str(fnic
->state
));
510 /* Thread removing device blocks till firmware reset is complete */
511 if (fnic
->remove_wait
)
512 complete(fnic
->remove_wait
);
515 * If fnic is being removed, or fw reset failed
516 * free the flogi frame. Else, send it out
518 if (fnic
->remove_wait
|| ret
) {
519 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
520 skb_queue_purge(&fnic
->tx_queue
);
521 goto reset_cmpl_handler_end
;
524 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
528 reset_cmpl_handler_end
:
533 * fnic_fcpio_flogi_reg_cmpl_handler
534 * Routine to handle flogi register completion
536 static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic
*fnic
,
537 struct fcpio_fw_req
*desc
)
541 struct fcpio_tag tag
;
545 fcpio_header_dec(&desc
->hdr
, &type
, &hdr_status
, &tag
);
547 /* Update fnic state based on status of flogi reg completion */
548 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
550 if (fnic
->state
== FNIC_IN_ETH_TRANS_FC_MODE
) {
552 /* Check flogi registration completion status */
554 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
555 "flog reg succeeded\n");
556 fnic
->state
= FNIC_IN_FC_MODE
;
558 FNIC_SCSI_DBG(KERN_DEBUG
,
560 "fnic flogi reg :failed %s\n",
561 fnic_fcpio_status_to_str(hdr_status
));
562 fnic
->state
= FNIC_IN_ETH_MODE
;
566 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
567 "Unexpected fnic state %s while"
568 " processing flogi reg completion\n",
569 fnic_state_to_str(fnic
->state
));
574 if (fnic
->stop_rx_link_events
) {
575 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
576 goto reg_cmpl_handler_end
;
578 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
581 queue_work(fnic_event_queue
, &fnic
->frame_work
);
583 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
586 reg_cmpl_handler_end
:
590 static inline int is_ack_index_in_range(struct vnic_wq_copy
*wq
,
593 if (wq
->to_clean_index
<= wq
->to_use_index
) {
594 /* out of range, stale request_out index */
595 if (request_out
< wq
->to_clean_index
||
596 request_out
>= wq
->to_use_index
)
599 /* out of range, stale request_out index */
600 if (request_out
< wq
->to_clean_index
&&
601 request_out
>= wq
->to_use_index
)
604 /* request_out index is in range */
610 * Mark that ack received and store the Ack index. If there are multiple
611 * acks received before Tx thread cleans it up, the latest value will be
612 * used which is correct behavior. This state should be in the copy Wq
613 * instead of in the fnic
615 static inline void fnic_fcpio_ack_handler(struct fnic
*fnic
,
616 unsigned int cq_index
,
617 struct fcpio_fw_req
*desc
)
619 struct vnic_wq_copy
*wq
;
620 u16 request_out
= desc
->u
.ack
.request_out
;
623 /* mark the ack state */
624 wq
= &fnic
->wq_copy
[cq_index
- fnic
->raw_wq_count
- fnic
->rq_count
];
625 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], flags
);
627 if (is_ack_index_in_range(wq
, request_out
)) {
628 fnic
->fw_ack_index
[0] = request_out
;
629 fnic
->fw_ack_recd
[0] = 1;
631 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], flags
);
635 * fnic_fcpio_icmnd_cmpl_handler
636 * Routine to handle icmnd completions
638 static void fnic_fcpio_icmnd_cmpl_handler(struct fnic
*fnic
,
639 struct fcpio_fw_req
*desc
)
643 struct fcpio_tag tag
;
646 struct fcpio_icmnd_cmpl
*icmnd_cmpl
;
647 struct fnic_io_req
*io_req
;
648 struct scsi_cmnd
*sc
;
652 /* Decode the cmpl description to get the io_req id */
653 fcpio_header_dec(&desc
->hdr
, &type
, &hdr_status
, &tag
);
654 fcpio_tag_id_dec(&tag
, &id
);
656 if (id
>= FNIC_MAX_IO_REQ
)
659 sc
= scsi_host_find_tag(fnic
->lport
->host
, id
);
664 io_lock
= fnic_io_lock_hash(fnic
, sc
);
665 spin_lock_irqsave(io_lock
, flags
);
666 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
667 WARN_ON_ONCE(!io_req
);
669 spin_unlock_irqrestore(io_lock
, flags
);
673 /* firmware completed the io */
674 io_req
->io_completed
= 1;
677 * if SCSI-ML has already issued abort on this command,
678 * ignore completion of the IO. The abts path will clean it up
680 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
681 spin_unlock_irqrestore(io_lock
, flags
);
685 /* Mark the IO as complete */
686 CMD_STATE(sc
) = FNIC_IOREQ_CMD_COMPLETE
;
688 icmnd_cmpl
= &desc
->u
.icmnd_cmpl
;
690 switch (hdr_status
) {
692 sc
->result
= (DID_OK
<< 16) | icmnd_cmpl
->scsi_status
;
693 xfer_len
= scsi_bufflen(sc
);
694 scsi_set_resid(sc
, icmnd_cmpl
->residual
);
696 if (icmnd_cmpl
->flags
& FCPIO_ICMND_CMPL_RESID_UNDER
)
697 xfer_len
-= icmnd_cmpl
->residual
;
700 * If queue_full, then try to reduce queue depth for all
701 * LUNS on the target. Todo: this should be accompanied
702 * by a periodic queue_depth rampup based on successful
705 if (icmnd_cmpl
->scsi_status
== QUEUE_FULL
) {
706 struct scsi_device
*t_sdev
;
709 shost_for_each_device(t_sdev
, sc
->device
->host
) {
710 if (t_sdev
->id
!= sc
->device
->id
)
713 if (t_sdev
->queue_depth
> 1) {
714 qd
= scsi_track_queue_full
716 t_sdev
->queue_depth
- 1);
718 qd
= t_sdev
->host
->cmd_per_lun
;
719 shost_printk(KERN_INFO
,
722 "] queue full detected,"
724 t_sdev
->host
->host_no
,
726 t_sdev
->id
, t_sdev
->lun
,
727 t_sdev
->queue_depth
);
733 case FCPIO_TIMEOUT
: /* request was timed out */
734 sc
->result
= (DID_TIME_OUT
<< 16) | icmnd_cmpl
->scsi_status
;
737 case FCPIO_ABORTED
: /* request was aborted */
738 sc
->result
= (DID_ERROR
<< 16) | icmnd_cmpl
->scsi_status
;
741 case FCPIO_DATA_CNT_MISMATCH
: /* recv/sent more/less data than exp. */
742 scsi_set_resid(sc
, icmnd_cmpl
->residual
);
743 sc
->result
= (DID_ERROR
<< 16) | icmnd_cmpl
->scsi_status
;
746 case FCPIO_OUT_OF_RESOURCE
: /* out of resources to complete request */
747 sc
->result
= (DID_REQUEUE
<< 16) | icmnd_cmpl
->scsi_status
;
749 case FCPIO_INVALID_HEADER
: /* header contains invalid data */
750 case FCPIO_INVALID_PARAM
: /* some parameter in request invalid */
751 case FCPIO_REQ_NOT_SUPPORTED
:/* request type is not supported */
752 case FCPIO_IO_NOT_FOUND
: /* requested I/O was not found */
753 case FCPIO_SGL_INVALID
: /* request was aborted due to sgl error */
754 case FCPIO_MSS_INVALID
: /* request was aborted due to mss error */
755 case FCPIO_FW_ERR
: /* request was terminated due fw error */
757 shost_printk(KERN_ERR
, fnic
->lport
->host
, "hdr status = %s\n",
758 fnic_fcpio_status_to_str(hdr_status
));
759 sc
->result
= (DID_ERROR
<< 16) | icmnd_cmpl
->scsi_status
;
763 /* Break link with the SCSI command */
766 spin_unlock_irqrestore(io_lock
, flags
);
768 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
770 mempool_free(io_req
, fnic
->io_req_pool
);
772 if (sc
->sc_data_direction
== DMA_FROM_DEVICE
) {
773 fnic
->lport
->host_stats
.fcp_input_requests
++;
774 fnic
->fcp_input_bytes
+= xfer_len
;
775 } else if (sc
->sc_data_direction
== DMA_TO_DEVICE
) {
776 fnic
->lport
->host_stats
.fcp_output_requests
++;
777 fnic
->fcp_output_bytes
+= xfer_len
;
779 fnic
->lport
->host_stats
.fcp_control_requests
++;
781 /* Call SCSI completion function to complete the IO */
787 /* fnic_fcpio_itmf_cmpl_handler
788 * Routine to handle itmf completions
790 static void fnic_fcpio_itmf_cmpl_handler(struct fnic
*fnic
,
791 struct fcpio_fw_req
*desc
)
795 struct fcpio_tag tag
;
797 struct scsi_cmnd
*sc
;
798 struct fnic_io_req
*io_req
;
802 fcpio_header_dec(&desc
->hdr
, &type
, &hdr_status
, &tag
);
803 fcpio_tag_id_dec(&tag
, &id
);
805 if ((id
& FNIC_TAG_MASK
) >= FNIC_MAX_IO_REQ
)
808 sc
= scsi_host_find_tag(fnic
->lport
->host
, id
& FNIC_TAG_MASK
);
813 io_lock
= fnic_io_lock_hash(fnic
, sc
);
814 spin_lock_irqsave(io_lock
, flags
);
815 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
816 WARN_ON_ONCE(!io_req
);
818 spin_unlock_irqrestore(io_lock
, flags
);
822 if (id
& FNIC_TAG_ABORT
) {
823 /* Completion of abort cmd */
824 if (CMD_STATE(sc
) != FNIC_IOREQ_ABTS_PENDING
) {
825 /* This is a late completion. Ignore it */
826 spin_unlock_irqrestore(io_lock
, flags
);
829 CMD_STATE(sc
) = FNIC_IOREQ_ABTS_COMPLETE
;
830 CMD_ABTS_STATUS(sc
) = hdr_status
;
832 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
833 "abts cmpl recd. id %d status %s\n",
834 (int)(id
& FNIC_TAG_MASK
),
835 fnic_fcpio_status_to_str(hdr_status
));
838 * If scsi_eh thread is blocked waiting for abts to complete,
839 * signal completion to it. IO will be cleaned in the thread
840 * else clean it in this context
842 if (io_req
->abts_done
) {
843 complete(io_req
->abts_done
);
844 spin_unlock_irqrestore(io_lock
, flags
);
846 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
847 "abts cmpl, completing IO\n");
849 sc
->result
= (DID_ERROR
<< 16);
851 spin_unlock_irqrestore(io_lock
, flags
);
853 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
854 mempool_free(io_req
, fnic
->io_req_pool
);
859 } else if (id
& FNIC_TAG_DEV_RST
) {
860 /* Completion of device reset */
861 CMD_LR_STATUS(sc
) = hdr_status
;
862 CMD_STATE(sc
) = FNIC_IOREQ_CMD_COMPLETE
;
863 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
864 "dev reset cmpl recd. id %d status %s\n",
865 (int)(id
& FNIC_TAG_MASK
),
866 fnic_fcpio_status_to_str(hdr_status
));
868 complete(io_req
->dr_done
);
869 spin_unlock_irqrestore(io_lock
, flags
);
872 shost_printk(KERN_ERR
, fnic
->lport
->host
,
873 "Unexpected itmf io state %s tag %x\n",
874 fnic_ioreq_state_to_str(CMD_STATE(sc
)), id
);
875 spin_unlock_irqrestore(io_lock
, flags
);
881 * fnic_fcpio_cmpl_handler
882 * Routine to service the cq for wq_copy
884 static int fnic_fcpio_cmpl_handler(struct vnic_dev
*vdev
,
885 unsigned int cq_index
,
886 struct fcpio_fw_req
*desc
)
888 struct fnic
*fnic
= vnic_dev_priv(vdev
);
891 switch (desc
->hdr
.type
) {
892 case FCPIO_ACK
: /* fw copied copy wq desc to its queue */
893 fnic_fcpio_ack_handler(fnic
, cq_index
, desc
);
896 case FCPIO_ICMND_CMPL
: /* fw completed a command */
897 fnic_fcpio_icmnd_cmpl_handler(fnic
, desc
);
900 case FCPIO_ITMF_CMPL
: /* fw completed itmf (abort cmd, lun reset)*/
901 fnic_fcpio_itmf_cmpl_handler(fnic
, desc
);
904 case FCPIO_FLOGI_REG_CMPL
: /* fw completed flogi_reg */
905 case FCPIO_FLOGI_FIP_REG_CMPL
: /* fw completed flogi_fip_reg */
906 ret
= fnic_fcpio_flogi_reg_cmpl_handler(fnic
, desc
);
909 case FCPIO_RESET_CMPL
: /* fw completed reset */
910 ret
= fnic_fcpio_fw_reset_cmpl_handler(fnic
, desc
);
914 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
915 "firmware completion type %d\n",
924 * fnic_wq_copy_cmpl_handler
925 * Routine to process wq copy
927 int fnic_wq_copy_cmpl_handler(struct fnic
*fnic
, int copy_work_to_do
)
929 unsigned int wq_work_done
= 0;
930 unsigned int i
, cq_index
;
931 unsigned int cur_work_done
;
933 for (i
= 0; i
< fnic
->wq_copy_count
; i
++) {
934 cq_index
= i
+ fnic
->raw_wq_count
+ fnic
->rq_count
;
935 cur_work_done
= vnic_cq_copy_service(&fnic
->cq
[cq_index
],
936 fnic_fcpio_cmpl_handler
,
938 wq_work_done
+= cur_work_done
;
943 static void fnic_cleanup_io(struct fnic
*fnic
, int exclude_id
)
946 struct fnic_io_req
*io_req
;
947 unsigned long flags
= 0;
948 struct scsi_cmnd
*sc
;
951 for (i
= 0; i
< FNIC_MAX_IO_REQ
; i
++) {
955 sc
= scsi_host_find_tag(fnic
->lport
->host
, i
);
959 io_lock
= fnic_io_lock_hash(fnic
, sc
);
960 spin_lock_irqsave(io_lock
, flags
);
961 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
963 spin_unlock_irqrestore(io_lock
, flags
);
964 goto cleanup_scsi_cmd
;
969 spin_unlock_irqrestore(io_lock
, flags
);
972 * If there is a scsi_cmnd associated with this io_req, then
973 * free the corresponding state
975 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
976 mempool_free(io_req
, fnic
->io_req_pool
);
979 sc
->result
= DID_TRANSPORT_DISRUPTED
<< 16;
980 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
, "fnic_cleanup_io:"
981 " DID_TRANSPORT_DISRUPTED\n");
983 /* Complete the command to SCSI */
989 void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy
*wq
,
990 struct fcpio_host_req
*desc
)
993 struct fnic
*fnic
= vnic_dev_priv(wq
->vdev
);
994 struct fnic_io_req
*io_req
;
995 struct scsi_cmnd
*sc
;
999 /* get the tag reference */
1000 fcpio_tag_id_dec(&desc
->hdr
.tag
, &id
);
1001 id
&= FNIC_TAG_MASK
;
1003 if (id
>= FNIC_MAX_IO_REQ
)
1006 sc
= scsi_host_find_tag(fnic
->lport
->host
, id
);
1010 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1011 spin_lock_irqsave(io_lock
, flags
);
1013 /* Get the IO context which this desc refers to */
1014 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1016 /* fnic interrupts are turned off by now */
1019 spin_unlock_irqrestore(io_lock
, flags
);
1020 goto wq_copy_cleanup_scsi_cmd
;
1025 spin_unlock_irqrestore(io_lock
, flags
);
1027 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
1028 mempool_free(io_req
, fnic
->io_req_pool
);
1030 wq_copy_cleanup_scsi_cmd
:
1031 sc
->result
= DID_NO_CONNECT
<< 16;
1032 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
, "wq_copy_cleanup_handler:"
1033 " DID_NO_CONNECT\n");
1039 static inline int fnic_queue_abort_io_req(struct fnic
*fnic
, int tag
,
1040 u32 task_req
, u8
*fc_lun
,
1041 struct fnic_io_req
*io_req
)
1043 struct vnic_wq_copy
*wq
= &fnic
->wq_copy
[0];
1044 unsigned long flags
;
1046 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], flags
);
1048 if (vnic_wq_copy_desc_avail(wq
) <= fnic
->wq_copy_desc_low
[0])
1049 free_wq_copy_descs(fnic
, wq
);
1051 if (!vnic_wq_copy_desc_avail(wq
)) {
1052 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], flags
);
1055 fnic_queue_wq_copy_desc_itmf(wq
, tag
| FNIC_TAG_ABORT
,
1056 0, task_req
, tag
, fc_lun
, io_req
->port_id
,
1057 fnic
->config
.ra_tov
, fnic
->config
.ed_tov
);
1059 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], flags
);
1063 void fnic_rport_exch_reset(struct fnic
*fnic
, u32 port_id
)
1066 struct fnic_io_req
*io_req
;
1067 spinlock_t
*io_lock
;
1068 unsigned long flags
;
1069 struct scsi_cmnd
*sc
;
1070 struct scsi_lun fc_lun
;
1071 enum fnic_ioreq_state old_ioreq_state
;
1073 FNIC_SCSI_DBG(KERN_DEBUG
,
1075 "fnic_rport_reset_exch called portid 0x%06x\n",
1078 if (fnic
->in_remove
)
1081 for (tag
= 0; tag
< FNIC_MAX_IO_REQ
; tag
++) {
1082 sc
= scsi_host_find_tag(fnic
->lport
->host
, tag
);
1086 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1087 spin_lock_irqsave(io_lock
, flags
);
1089 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1091 if (!io_req
|| io_req
->port_id
!= port_id
) {
1092 spin_unlock_irqrestore(io_lock
, flags
);
1097 * Found IO that is still pending with firmware and
1098 * belongs to rport that went away
1100 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
1101 spin_unlock_irqrestore(io_lock
, flags
);
1104 old_ioreq_state
= CMD_STATE(sc
);
1105 CMD_STATE(sc
) = FNIC_IOREQ_ABTS_PENDING
;
1106 CMD_ABTS_STATUS(sc
) = FCPIO_INVALID_CODE
;
1108 BUG_ON(io_req
->abts_done
);
1110 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1111 "fnic_rport_reset_exch: Issuing abts\n");
1113 spin_unlock_irqrestore(io_lock
, flags
);
1115 /* Now queue the abort command to firmware */
1116 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
1118 if (fnic_queue_abort_io_req(fnic
, tag
,
1119 FCPIO_ITMF_ABT_TASK_TERM
,
1120 fc_lun
.scsi_lun
, io_req
)) {
1122 * Revert the cmd state back to old state, if
1123 * it hasnt changed in between. This cmd will get
1124 * aborted later by scsi_eh, or cleaned up during
1127 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1129 spin_lock_irqsave(io_lock
, flags
);
1130 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
)
1131 CMD_STATE(sc
) = old_ioreq_state
;
1132 spin_unlock_irqrestore(io_lock
, flags
);
1138 void fnic_terminate_rport_io(struct fc_rport
*rport
)
1141 struct fnic_io_req
*io_req
;
1142 spinlock_t
*io_lock
;
1143 unsigned long flags
;
1144 struct scsi_cmnd
*sc
;
1145 struct scsi_lun fc_lun
;
1146 struct fc_rport_libfc_priv
*rdata
= rport
->dd_data
;
1147 struct fc_lport
*lport
= rdata
->local_port
;
1148 struct fnic
*fnic
= lport_priv(lport
);
1149 struct fc_rport
*cmd_rport
;
1150 enum fnic_ioreq_state old_ioreq_state
;
1152 FNIC_SCSI_DBG(KERN_DEBUG
,
1153 fnic
->lport
->host
, "fnic_terminate_rport_io called"
1154 " wwpn 0x%llx, wwnn0x%llx, portid 0x%06x\n",
1155 rport
->port_name
, rport
->node_name
,
1158 if (fnic
->in_remove
)
1161 for (tag
= 0; tag
< FNIC_MAX_IO_REQ
; tag
++) {
1162 sc
= scsi_host_find_tag(fnic
->lport
->host
, tag
);
1166 cmd_rport
= starget_to_rport(scsi_target(sc
->device
));
1167 if (rport
!= cmd_rport
)
1170 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1171 spin_lock_irqsave(io_lock
, flags
);
1173 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1175 if (!io_req
|| rport
!= cmd_rport
) {
1176 spin_unlock_irqrestore(io_lock
, flags
);
1181 * Found IO that is still pending with firmware and
1182 * belongs to rport that went away
1184 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
1185 spin_unlock_irqrestore(io_lock
, flags
);
1188 old_ioreq_state
= CMD_STATE(sc
);
1189 CMD_STATE(sc
) = FNIC_IOREQ_ABTS_PENDING
;
1190 CMD_ABTS_STATUS(sc
) = FCPIO_INVALID_CODE
;
1192 BUG_ON(io_req
->abts_done
);
1194 FNIC_SCSI_DBG(KERN_DEBUG
,
1196 "fnic_terminate_rport_io: Issuing abts\n");
1198 spin_unlock_irqrestore(io_lock
, flags
);
1200 /* Now queue the abort command to firmware */
1201 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
1203 if (fnic_queue_abort_io_req(fnic
, tag
,
1204 FCPIO_ITMF_ABT_TASK_TERM
,
1205 fc_lun
.scsi_lun
, io_req
)) {
1207 * Revert the cmd state back to old state, if
1208 * it hasnt changed in between. This cmd will get
1209 * aborted later by scsi_eh, or cleaned up during
1212 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1214 spin_lock_irqsave(io_lock
, flags
);
1215 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
)
1216 CMD_STATE(sc
) = old_ioreq_state
;
1217 spin_unlock_irqrestore(io_lock
, flags
);
1224 * This function is exported to SCSI for sending abort cmnds.
1225 * A SCSI IO is represented by a io_req in the driver.
1226 * The ioreq is linked to the SCSI Cmd, thus a link with the ULP's IO.
1228 int fnic_abort_cmd(struct scsi_cmnd
*sc
)
1230 struct fc_lport
*lp
;
1232 struct fnic_io_req
*io_req
;
1233 struct fc_rport
*rport
;
1234 spinlock_t
*io_lock
;
1235 unsigned long flags
;
1238 struct scsi_lun fc_lun
;
1239 DECLARE_COMPLETION_ONSTACK(tm_done
);
1241 /* Wait for rport to unblock */
1242 fc_block_scsi_eh(sc
);
1244 /* Get local-port, check ready and link up */
1245 lp
= shost_priv(sc
->device
->host
);
1247 fnic
= lport_priv(lp
);
1248 FNIC_SCSI_DBG(KERN_DEBUG
,
1250 "Abort Cmd called FCID 0x%x, LUN 0x%x TAG %d\n",
1251 (starget_to_rport(scsi_target(sc
->device
)))->port_id
,
1252 sc
->device
->lun
, sc
->request
->tag
);
1254 if (lp
->state
!= LPORT_ST_READY
|| !(lp
->link_up
)) {
1256 goto fnic_abort_cmd_end
;
1260 * Avoid a race between SCSI issuing the abort and the device
1261 * completing the command.
1263 * If the command is already completed by the fw cmpl code,
1264 * we just return SUCCESS from here. This means that the abort
1265 * succeeded. In the SCSI ML, since the timeout for command has
1266 * happened, the completion wont actually complete the command
1267 * and it will be considered as an aborted command
1269 * The CMD_SP will not be cleared except while holding io_req_lock.
1271 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1272 spin_lock_irqsave(io_lock
, flags
);
1273 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1275 spin_unlock_irqrestore(io_lock
, flags
);
1276 goto fnic_abort_cmd_end
;
1279 io_req
->abts_done
= &tm_done
;
1281 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
1282 spin_unlock_irqrestore(io_lock
, flags
);
1286 * Command is still pending, need to abort it
1287 * If the firmware completes the command after this point,
1288 * the completion wont be done till mid-layer, since abort
1289 * has already started.
1291 CMD_STATE(sc
) = FNIC_IOREQ_ABTS_PENDING
;
1292 CMD_ABTS_STATUS(sc
) = FCPIO_INVALID_CODE
;
1294 spin_unlock_irqrestore(io_lock
, flags
);
1297 * Check readiness of the remote port. If the path to remote
1298 * port is up, then send abts to the remote port to terminate
1299 * the IO. Else, just locally terminate the IO in the firmware
1301 rport
= starget_to_rport(scsi_target(sc
->device
));
1302 if (fc_remote_port_chkready(rport
) == 0)
1303 task_req
= FCPIO_ITMF_ABT_TASK
;
1305 task_req
= FCPIO_ITMF_ABT_TASK_TERM
;
1307 /* Now queue the abort command to firmware */
1308 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
1310 if (fnic_queue_abort_io_req(fnic
, sc
->request
->tag
, task_req
,
1311 fc_lun
.scsi_lun
, io_req
)) {
1312 spin_lock_irqsave(io_lock
, flags
);
1313 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1315 io_req
->abts_done
= NULL
;
1316 spin_unlock_irqrestore(io_lock
, flags
);
1318 goto fnic_abort_cmd_end
;
1322 * We queued an abort IO, wait for its completion.
1323 * Once the firmware completes the abort command, it will
1324 * wake up this thread.
1327 wait_for_completion_timeout(&tm_done
,
1329 (2 * fnic
->config
.ra_tov
+
1330 fnic
->config
.ed_tov
));
1332 /* Check the abort status */
1333 spin_lock_irqsave(io_lock
, flags
);
1335 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1337 spin_unlock_irqrestore(io_lock
, flags
);
1339 goto fnic_abort_cmd_end
;
1341 io_req
->abts_done
= NULL
;
1343 /* fw did not complete abort, timed out */
1344 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
1345 spin_unlock_irqrestore(io_lock
, flags
);
1347 goto fnic_abort_cmd_end
;
1351 * firmware completed the abort, check the status,
1352 * free the io_req irrespective of failure or success
1354 if (CMD_ABTS_STATUS(sc
) != FCPIO_SUCCESS
)
1359 spin_unlock_irqrestore(io_lock
, flags
);
1361 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
1362 mempool_free(io_req
, fnic
->io_req_pool
);
1365 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1366 "Returning from abort cmd %s\n",
1368 "SUCCESS" : "FAILED");
1372 static inline int fnic_queue_dr_io_req(struct fnic
*fnic
,
1373 struct scsi_cmnd
*sc
,
1374 struct fnic_io_req
*io_req
)
1376 struct vnic_wq_copy
*wq
= &fnic
->wq_copy
[0];
1377 struct scsi_lun fc_lun
;
1379 unsigned long intr_flags
;
1381 spin_lock_irqsave(&fnic
->wq_copy_lock
[0], intr_flags
);
1383 if (vnic_wq_copy_desc_avail(wq
) <= fnic
->wq_copy_desc_low
[0])
1384 free_wq_copy_descs(fnic
, wq
);
1386 if (!vnic_wq_copy_desc_avail(wq
)) {
1391 /* fill in the lun info */
1392 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
1394 fnic_queue_wq_copy_desc_itmf(wq
, sc
->request
->tag
| FNIC_TAG_DEV_RST
,
1395 0, FCPIO_ITMF_LUN_RESET
, SCSI_NO_TAG
,
1396 fc_lun
.scsi_lun
, io_req
->port_id
,
1397 fnic
->config
.ra_tov
, fnic
->config
.ed_tov
);
1400 spin_unlock_irqrestore(&fnic
->wq_copy_lock
[0], intr_flags
);
1406 * Clean up any pending aborts on the lun
1407 * For each outstanding IO on this lun, whose abort is not completed by fw,
1408 * issue a local abort. Wait for abort to complete. Return 0 if all commands
1409 * successfully aborted, 1 otherwise
1411 static int fnic_clean_pending_aborts(struct fnic
*fnic
,
1412 struct scsi_cmnd
*lr_sc
)
1415 struct fnic_io_req
*io_req
;
1416 spinlock_t
*io_lock
;
1417 unsigned long flags
;
1419 struct scsi_cmnd
*sc
;
1420 struct fc_rport
*rport
;
1421 struct scsi_lun fc_lun
;
1422 struct scsi_device
*lun_dev
= lr_sc
->device
;
1423 DECLARE_COMPLETION_ONSTACK(tm_done
);
1425 for (tag
= 0; tag
< FNIC_MAX_IO_REQ
; tag
++) {
1426 sc
= scsi_host_find_tag(fnic
->lport
->host
, tag
);
1428 * ignore this lun reset cmd or cmds that do not belong to
1431 if (!sc
|| sc
== lr_sc
|| sc
->device
!= lun_dev
)
1434 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1435 spin_lock_irqsave(io_lock
, flags
);
1437 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1439 if (!io_req
|| sc
->device
!= lun_dev
) {
1440 spin_unlock_irqrestore(io_lock
, flags
);
1445 * Found IO that is still pending with firmware and
1446 * belongs to the LUN that we are resetting
1448 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1449 "Found IO in %s on lun\n",
1450 fnic_ioreq_state_to_str(CMD_STATE(sc
)));
1452 BUG_ON(CMD_STATE(sc
) != FNIC_IOREQ_ABTS_PENDING
);
1454 CMD_ABTS_STATUS(sc
) = FCPIO_INVALID_CODE
;
1455 io_req
->abts_done
= &tm_done
;
1456 spin_unlock_irqrestore(io_lock
, flags
);
1458 /* Now queue the abort command to firmware */
1459 int_to_scsilun(sc
->device
->lun
, &fc_lun
);
1460 rport
= starget_to_rport(scsi_target(sc
->device
));
1462 if (fnic_queue_abort_io_req(fnic
, tag
,
1463 FCPIO_ITMF_ABT_TASK_TERM
,
1464 fc_lun
.scsi_lun
, io_req
)) {
1465 spin_lock_irqsave(io_lock
, flags
);
1466 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1468 io_req
->abts_done
= NULL
;
1469 spin_unlock_irqrestore(io_lock
, flags
);
1471 goto clean_pending_aborts_end
;
1474 wait_for_completion_timeout(&tm_done
,
1476 (fnic
->config
.ed_tov
));
1478 /* Recheck cmd state to check if it is now aborted */
1479 spin_lock_irqsave(io_lock
, flags
);
1480 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1482 spin_unlock_irqrestore(io_lock
, flags
);
1484 goto clean_pending_aborts_end
;
1487 io_req
->abts_done
= NULL
;
1489 /* if abort is still pending with fw, fail */
1490 if (CMD_STATE(sc
) == FNIC_IOREQ_ABTS_PENDING
) {
1491 spin_unlock_irqrestore(io_lock
, flags
);
1493 goto clean_pending_aborts_end
;
1496 spin_unlock_irqrestore(io_lock
, flags
);
1498 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
1499 mempool_free(io_req
, fnic
->io_req_pool
);
1502 clean_pending_aborts_end
:
1507 * SCSI Eh thread issues a Lun Reset when one or more commands on a LUN
1508 * fail to get aborted. It calls driver's eh_device_reset with a SCSI command
1511 int fnic_device_reset(struct scsi_cmnd
*sc
)
1513 struct fc_lport
*lp
;
1515 struct fnic_io_req
*io_req
;
1516 struct fc_rport
*rport
;
1519 spinlock_t
*io_lock
;
1520 unsigned long flags
;
1521 DECLARE_COMPLETION_ONSTACK(tm_done
);
1523 /* Wait for rport to unblock */
1524 fc_block_scsi_eh(sc
);
1526 /* Get local-port, check ready and link up */
1527 lp
= shost_priv(sc
->device
->host
);
1529 fnic
= lport_priv(lp
);
1530 FNIC_SCSI_DBG(KERN_DEBUG
,
1532 "Device reset called FCID 0x%x, LUN 0x%x\n",
1533 (starget_to_rport(scsi_target(sc
->device
)))->port_id
,
1537 if (lp
->state
!= LPORT_ST_READY
|| !(lp
->link_up
))
1538 goto fnic_device_reset_end
;
1540 /* Check if remote port up */
1541 rport
= starget_to_rport(scsi_target(sc
->device
));
1542 if (fc_remote_port_chkready(rport
))
1543 goto fnic_device_reset_end
;
1545 io_lock
= fnic_io_lock_hash(fnic
, sc
);
1546 spin_lock_irqsave(io_lock
, flags
);
1547 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1550 * If there is a io_req attached to this command, then use it,
1551 * else allocate a new one.
1554 io_req
= mempool_alloc(fnic
->io_req_pool
, GFP_ATOMIC
);
1556 spin_unlock_irqrestore(io_lock
, flags
);
1557 goto fnic_device_reset_end
;
1559 memset(io_req
, 0, sizeof(*io_req
));
1560 io_req
->port_id
= rport
->port_id
;
1561 CMD_SP(sc
) = (char *)io_req
;
1563 io_req
->dr_done
= &tm_done
;
1564 CMD_STATE(sc
) = FNIC_IOREQ_CMD_PENDING
;
1565 CMD_LR_STATUS(sc
) = FCPIO_INVALID_CODE
;
1566 spin_unlock_irqrestore(io_lock
, flags
);
1568 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
, "TAG %d\n",
1572 * issue the device reset, if enqueue failed, clean up the ioreq
1573 * and break assoc with scsi cmd
1575 if (fnic_queue_dr_io_req(fnic
, sc
, io_req
)) {
1576 spin_lock_irqsave(io_lock
, flags
);
1577 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1579 io_req
->dr_done
= NULL
;
1580 goto fnic_device_reset_clean
;
1584 * Wait on the local completion for LUN reset. The io_req may be
1585 * freed while we wait since we hold no lock.
1587 wait_for_completion_timeout(&tm_done
,
1588 msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT
));
1590 spin_lock_irqsave(io_lock
, flags
);
1591 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1593 spin_unlock_irqrestore(io_lock
, flags
);
1594 goto fnic_device_reset_end
;
1596 io_req
->dr_done
= NULL
;
1598 status
= CMD_LR_STATUS(sc
);
1599 spin_unlock_irqrestore(io_lock
, flags
);
1602 * If lun reset not completed, bail out with failed. io_req
1603 * gets cleaned up during higher levels of EH
1605 if (status
== FCPIO_INVALID_CODE
) {
1606 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1607 "Device reset timed out\n");
1608 goto fnic_device_reset_end
;
1611 /* Completed, but not successful, clean up the io_req, return fail */
1612 if (status
!= FCPIO_SUCCESS
) {
1613 spin_lock_irqsave(io_lock
, flags
);
1614 FNIC_SCSI_DBG(KERN_DEBUG
,
1616 "Device reset completed - failed\n");
1617 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1618 goto fnic_device_reset_clean
;
1622 * Clean up any aborts on this lun that have still not
1623 * completed. If any of these fail, then LUN reset fails.
1624 * clean_pending_aborts cleans all cmds on this lun except
1625 * the lun reset cmd. If all cmds get cleaned, the lun reset
1628 if (fnic_clean_pending_aborts(fnic
, sc
)) {
1629 spin_lock_irqsave(io_lock
, flags
);
1630 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1631 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1632 "Device reset failed"
1633 " since could not abort all IOs\n");
1634 goto fnic_device_reset_clean
;
1637 /* Clean lun reset command */
1638 spin_lock_irqsave(io_lock
, flags
);
1639 io_req
= (struct fnic_io_req
*)CMD_SP(sc
);
1641 /* Completed, and successful */
1644 fnic_device_reset_clean
:
1648 spin_unlock_irqrestore(io_lock
, flags
);
1651 fnic_release_ioreq_buf(fnic
, io_req
, sc
);
1652 mempool_free(io_req
, fnic
->io_req_pool
);
1655 fnic_device_reset_end
:
1656 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1657 "Returning from device reset %s\n",
1659 "SUCCESS" : "FAILED");
1663 /* Clean up all IOs, clean up libFC local port */
1664 int fnic_reset(struct Scsi_Host
*shost
)
1666 struct fc_lport
*lp
;
1670 lp
= shost_priv(shost
);
1671 fnic
= lport_priv(lp
);
1673 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1674 "fnic_reset called\n");
1677 * Reset local port, this will clean up libFC exchanges,
1678 * reset remote port sessions, and if link is up, begin flogi
1680 if (lp
->tt
.lport_reset(lp
))
1683 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1684 "Returning from fnic reset %s\n",
1686 "SUCCESS" : "FAILED");
1692 * SCSI Error handling calls driver's eh_host_reset if all prior
1693 * error handling levels return FAILED. If host reset completes
1694 * successfully, and if link is up, then Fabric login begins.
1696 * Host Reset is the highest level of error recovery. If this fails, then
1697 * host is offlined by SCSI.
1700 int fnic_host_reset(struct scsi_cmnd
*sc
)
1703 unsigned long wait_host_tmo
;
1704 struct Scsi_Host
*shost
= sc
->device
->host
;
1705 struct fc_lport
*lp
= shost_priv(shost
);
1708 * If fnic_reset is successful, wait for fabric login to complete
1709 * scsi-ml tries to send a TUR to every device if host reset is
1710 * successful, so before returning to scsi, fabric should be up
1712 ret
= fnic_reset(shost
);
1713 if (ret
== SUCCESS
) {
1714 wait_host_tmo
= jiffies
+ FNIC_HOST_RESET_SETTLE_TIME
* HZ
;
1716 while (time_before(jiffies
, wait_host_tmo
)) {
1717 if ((lp
->state
== LPORT_ST_READY
) &&
1730 * This fxn is called from libFC when host is removed
1732 void fnic_scsi_abort_io(struct fc_lport
*lp
)
1735 unsigned long flags
;
1736 enum fnic_state old_state
;
1737 struct fnic
*fnic
= lport_priv(lp
);
1738 DECLARE_COMPLETION_ONSTACK(remove_wait
);
1740 /* Issue firmware reset for fnic, wait for reset to complete */
1741 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
1742 fnic
->remove_wait
= &remove_wait
;
1743 old_state
= fnic
->state
;
1744 fnic
->state
= FNIC_IN_FC_TRANS_ETH_MODE
;
1745 fnic_update_mac_locked(fnic
, fnic
->ctlr
.ctl_src_addr
);
1746 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
1748 err
= fnic_fw_reset_handler(fnic
);
1750 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
1751 if (fnic
->state
== FNIC_IN_FC_TRANS_ETH_MODE
)
1752 fnic
->state
= old_state
;
1753 fnic
->remove_wait
= NULL
;
1754 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
1758 /* Wait for firmware reset to complete */
1759 wait_for_completion_timeout(&remove_wait
,
1760 msecs_to_jiffies(FNIC_RMDEVICE_TIMEOUT
));
1762 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
1763 fnic
->remove_wait
= NULL
;
1764 FNIC_SCSI_DBG(KERN_DEBUG
, fnic
->lport
->host
,
1765 "fnic_scsi_abort_io %s\n",
1766 (fnic
->state
== FNIC_IN_ETH_MODE
) ?
1767 "SUCCESS" : "FAILED");
1768 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
1773 * This fxn called from libFC to clean up driver IO state on link down
1775 void fnic_scsi_cleanup(struct fc_lport
*lp
)
1777 unsigned long flags
;
1778 enum fnic_state old_state
;
1779 struct fnic
*fnic
= lport_priv(lp
);
1781 /* issue fw reset */
1782 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
1783 old_state
= fnic
->state
;
1784 fnic
->state
= FNIC_IN_FC_TRANS_ETH_MODE
;
1785 fnic_update_mac_locked(fnic
, fnic
->ctlr
.ctl_src_addr
);
1786 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
1788 if (fnic_fw_reset_handler(fnic
)) {
1789 spin_lock_irqsave(&fnic
->fnic_lock
, flags
);
1790 if (fnic
->state
== FNIC_IN_FC_TRANS_ETH_MODE
)
1791 fnic
->state
= old_state
;
1792 spin_unlock_irqrestore(&fnic
->fnic_lock
, flags
);
1797 void fnic_empty_scsi_cleanup(struct fc_lport
*lp
)
1801 void fnic_exch_mgr_reset(struct fc_lport
*lp
, u32 sid
, u32 did
)
1803 struct fnic
*fnic
= lport_priv(lp
);
1805 /* Non-zero sid, nothing to do */
1807 goto call_fc_exch_mgr_reset
;
1810 fnic_rport_exch_reset(fnic
, did
);
1811 goto call_fc_exch_mgr_reset
;
1816 * link down or device being removed
1818 if (!fnic
->in_remove
)
1819 fnic_scsi_cleanup(lp
);
1821 fnic_scsi_abort_io(lp
);
1823 /* call libFC exch mgr reset to reset its exchanges */
1824 call_fc_exch_mgr_reset
:
1825 fc_exch_mgr_reset(lp
, sid
, did
);