?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cap_syslog: accept CAP_SYS_ADMIN for now
[wandboard.git] / drivers / scsi / fnic / fnic_scsi.c
blob22d02404d15f6ce1a86a2b2fbccb852d8fd21003
1 /*
2 * Copyright 2008 Cisco Systems, Inc. All rights reserved.
3 * Copyright 2007 Nuova Systems, Inc. All rights reserved.
4 *
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.
8 *
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
16 * SOFTWARE.
17 */
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 <linux/gfp.h>
30 #include <scsi/scsi.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_cmnd.h>
34 #include <scsi/scsi_tcq.h>
35 #include <scsi/fc/fc_els.h>
36 #include <scsi/fc/fc_fcoe.h>
37 #include <scsi/libfc.h>
38 #include <scsi/fc_frame.h>
39 #include "fnic_io.h"
40 #include "fnic.h"
41
42 const char *fnic_state_str[] = {
43 [FNIC_IN_FC_MODE] = "FNIC_IN_FC_MODE",
44 [FNIC_IN_FC_TRANS_ETH_MODE] = "FNIC_IN_FC_TRANS_ETH_MODE",
45 [FNIC_IN_ETH_MODE] = "FNIC_IN_ETH_MODE",
46 [FNIC_IN_ETH_TRANS_FC_MODE] = "FNIC_IN_ETH_TRANS_FC_MODE",
47 };
48
49 static const char *fnic_ioreq_state_str[] = {
50 [FNIC_IOREQ_CMD_PENDING] = "FNIC_IOREQ_CMD_PENDING",
51 [FNIC_IOREQ_ABTS_PENDING] = "FNIC_IOREQ_ABTS_PENDING",
52 [FNIC_IOREQ_ABTS_COMPLETE] = "FNIC_IOREQ_ABTS_COMPLETE",
53 [FNIC_IOREQ_CMD_COMPLETE] = "FNIC_IOREQ_CMD_COMPLETE",
54 };
55
56 static const char *fcpio_status_str[] = {
57 [FCPIO_SUCCESS] = "FCPIO_SUCCESS", /*0x0*/
58 [FCPIO_INVALID_HEADER] = "FCPIO_INVALID_HEADER",
59 [FCPIO_OUT_OF_RESOURCE] = "FCPIO_OUT_OF_RESOURCE",
60 [FCPIO_INVALID_PARAM] = "FCPIO_INVALID_PARAM]",
61 [FCPIO_REQ_NOT_SUPPORTED] = "FCPIO_REQ_NOT_SUPPORTED",
62 [FCPIO_IO_NOT_FOUND] = "FCPIO_IO_NOT_FOUND",
63 [FCPIO_ABORTED] = "FCPIO_ABORTED", /*0x41*/
64 [FCPIO_TIMEOUT] = "FCPIO_TIMEOUT",
65 [FCPIO_SGL_INVALID] = "FCPIO_SGL_INVALID",
66 [FCPIO_MSS_INVALID] = "FCPIO_MSS_INVALID",
67 [FCPIO_DATA_CNT_MISMATCH] = "FCPIO_DATA_CNT_MISMATCH",
68 [FCPIO_FW_ERR] = "FCPIO_FW_ERR",
69 [FCPIO_ITMF_REJECTED] = "FCPIO_ITMF_REJECTED",
70 [FCPIO_ITMF_FAILED] = "FCPIO_ITMF_FAILED",
71 [FCPIO_ITMF_INCORRECT_LUN] = "FCPIO_ITMF_INCORRECT_LUN",
72 [FCPIO_CMND_REJECTED] = "FCPIO_CMND_REJECTED",
73 [FCPIO_NO_PATH_AVAIL] = "FCPIO_NO_PATH_AVAIL",
74 [FCPIO_PATH_FAILED] = "FCPIO_PATH_FAILED",
75 [FCPIO_LUNMAP_CHNG_PEND] = "FCPIO_LUNHMAP_CHNG_PEND",
76 };
77
78 const char *fnic_state_to_str(unsigned int state)
79 {
80 if (state >= ARRAY_SIZE(fnic_state_str) || !fnic_state_str[state])
81 return "unknown";
82
83 return fnic_state_str[state];
84 }
85
86 static const char *fnic_ioreq_state_to_str(unsigned int state)
87 {
88 if (state >= ARRAY_SIZE(fnic_ioreq_state_str) ||
89 !fnic_ioreq_state_str[state])
90 return "unknown";
91
92 return fnic_ioreq_state_str[state];
93 }
94
95 static const char *fnic_fcpio_status_to_str(unsigned int status)
96 {
97 if (status >= ARRAY_SIZE(fcpio_status_str) || !fcpio_status_str[status])
98 return "unknown";
99
100 return fcpio_status_str[status];
101 }
102
103 static void fnic_cleanup_io(struct fnic *fnic, int exclude_id);
104
105 static inline spinlock_t *fnic_io_lock_hash(struct fnic *fnic,
106 struct scsi_cmnd *sc)
107 {
108 u32 hash = sc->request->tag & (FNIC_IO_LOCKS - 1);
109
110 return &fnic->io_req_lock[hash];
111 }
112
113 /*
114 * Unmap the data buffer and sense buffer for an io_req,
115 * also unmap and free the device-private scatter/gather list.
116 */
117 static void fnic_release_ioreq_buf(struct fnic *fnic,
118 struct fnic_io_req *io_req,
119 struct scsi_cmnd *sc)
120 {
121 if (io_req->sgl_list_pa)
122 pci_unmap_single(fnic->pdev, io_req->sgl_list_pa,
123 sizeof(io_req->sgl_list[0]) * io_req->sgl_cnt,
124 PCI_DMA_TODEVICE);
125 scsi_dma_unmap(sc);
126
127 if (io_req->sgl_cnt)
128 mempool_free(io_req->sgl_list_alloc,
129 fnic->io_sgl_pool[io_req->sgl_type]);
130 if (io_req->sense_buf_pa)
131 pci_unmap_single(fnic->pdev, io_req->sense_buf_pa,
132 SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE);
133 }
134
135 /* Free up Copy Wq descriptors. Called with copy_wq lock held */
136 static int free_wq_copy_descs(struct fnic *fnic, struct vnic_wq_copy *wq)
137 {
138 /* if no Ack received from firmware, then nothing to clean */
139 if (!fnic->fw_ack_recd[0])
140 return 1;
141
142 /*
143 * Update desc_available count based on number of freed descriptors
144 * Account for wraparound
145 */
146 if (wq->to_clean_index <= fnic->fw_ack_index[0])
147 wq->ring.desc_avail += (fnic->fw_ack_index[0]
148 - wq->to_clean_index + 1);
149 else
150 wq->ring.desc_avail += (wq->ring.desc_count
151 - wq->to_clean_index
152 + fnic->fw_ack_index[0] + 1);
153
154 /*
155 * just bump clean index to ack_index+1 accounting for wraparound
156 * this will essentially free up all descriptors between
157 * to_clean_index and fw_ack_index, both inclusive
158 */
159 wq->to_clean_index =
160 (fnic->fw_ack_index[0] + 1) % wq->ring.desc_count;
161
162 /* we have processed the acks received so far */
163 fnic->fw_ack_recd[0] = 0;
164 return 0;
165 }
166
167
168 /*
169 * fnic_fw_reset_handler
170 * Routine to send reset msg to fw
171 */
172 int fnic_fw_reset_handler(struct fnic *fnic)
173 {
174 struct vnic_wq_copy *wq = &fnic->wq_copy[0];
175 int ret = 0;
176 unsigned long flags;
177
178 skb_queue_purge(&fnic->frame_queue);
179 skb_queue_purge(&fnic->tx_queue);
180
181 spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
182
183 if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
184 free_wq_copy_descs(fnic, wq);
185
186 if (!vnic_wq_copy_desc_avail(wq))
187 ret = -EAGAIN;
188 else
189 fnic_queue_wq_copy_desc_fw_reset(wq, SCSI_NO_TAG);
190
191 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
192
193 if (!ret)
194 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
195 "Issued fw reset\n");
196 else
197 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
198 "Failed to issue fw reset\n");
199 return ret;
200 }
201
202
203 /*
204 * fnic_flogi_reg_handler
205 * Routine to send flogi register msg to fw
206 */
207 int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
208 {
209 struct vnic_wq_copy *wq = &fnic->wq_copy[0];
210 enum fcpio_flogi_reg_format_type format;
211 struct fc_lport *lp = fnic->lport;
212 u8 gw_mac[ETH_ALEN];
213 int ret = 0;
214 unsigned long flags;
215
216 spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
217
218 if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
219 free_wq_copy_descs(fnic, wq);
220
221 if (!vnic_wq_copy_desc_avail(wq)) {
222 ret = -EAGAIN;
223 goto flogi_reg_ioreq_end;
224 }
225
226 if (fnic->ctlr.map_dest) {
227 memset(gw_mac, 0xff, ETH_ALEN);
228 format = FCPIO_FLOGI_REG_DEF_DEST;
229 } else {
230 memcpy(gw_mac, fnic->ctlr.dest_addr, ETH_ALEN);
231 format = FCPIO_FLOGI_REG_GW_DEST;
232 }
233
234 if ((fnic->config.flags & VFCF_FIP_CAPABLE) && !fnic->ctlr.map_dest) {
235 fnic_queue_wq_copy_desc_fip_reg(wq, SCSI_NO_TAG,
236 fc_id, gw_mac,
237 fnic->data_src_addr,
238 lp->r_a_tov, lp->e_d_tov);
239 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
240 "FLOGI FIP reg issued fcid %x src %pM dest %pM\n",
241 fc_id, fnic->data_src_addr, gw_mac);
242 } else {
243 fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
244 format, fc_id, gw_mac);
245 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
246 "FLOGI reg issued fcid %x map %d dest %pM\n",
247 fc_id, fnic->ctlr.map_dest, gw_mac);
248 }
249
250 flogi_reg_ioreq_end:
251 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
252 return ret;
253 }
254
255 /*
256 * fnic_queue_wq_copy_desc
257 * Routine to enqueue a wq copy desc
258 */
259 static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
260 struct vnic_wq_copy *wq,
261 struct fnic_io_req *io_req,
262 struct scsi_cmnd *sc,
263 int sg_count)
264 {
265 struct scatterlist *sg;
266 struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
267 struct fc_rport_libfc_priv *rp = rport->dd_data;
268 struct host_sg_desc *desc;
269 u8 pri_tag = 0;
270 unsigned int i;
271 unsigned long intr_flags;
272 int flags;
273 u8 exch_flags;
274 struct scsi_lun fc_lun;
275 char msg[2];
276
277 if (sg_count) {
278 /* For each SGE, create a device desc entry */
279 desc = io_req->sgl_list;
280 for_each_sg(scsi_sglist(sc), sg, sg_count, i) {
281 desc->addr = cpu_to_le64(sg_dma_address(sg));
282 desc->len = cpu_to_le32(sg_dma_len(sg));
283 desc->_resvd = 0;
284 desc++;
285 }
286
287 io_req->sgl_list_pa = pci_map_single
288 (fnic->pdev,
289 io_req->sgl_list,
290 sizeof(io_req->sgl_list[0]) * sg_count,
291 PCI_DMA_TODEVICE);
292 }
293
294 io_req->sense_buf_pa = pci_map_single(fnic->pdev,
295 sc->sense_buffer,
296 SCSI_SENSE_BUFFERSIZE,
297 PCI_DMA_FROMDEVICE);
298
299 int_to_scsilun(sc->device->lun, &fc_lun);
300
301 pri_tag = FCPIO_ICMND_PTA_SIMPLE;
302 msg[0] = MSG_SIMPLE_TAG;
303 scsi_populate_tag_msg(sc, msg);
304 if (msg[0] == MSG_ORDERED_TAG)
305 pri_tag = FCPIO_ICMND_PTA_ORDERED;
306
307 /* Enqueue the descriptor in the Copy WQ */
308 spin_lock_irqsave(&fnic->wq_copy_lock[0], intr_flags);
309
310 if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
311 free_wq_copy_descs(fnic, wq);
312
313 if (unlikely(!vnic_wq_copy_desc_avail(wq))) {
314 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
315 return SCSI_MLQUEUE_HOST_BUSY;
316 }
317
318 flags = 0;
319 if (sc->sc_data_direction == DMA_FROM_DEVICE)
320 flags = FCPIO_ICMND_RDDATA;
321 else if (sc->sc_data_direction == DMA_TO_DEVICE)
322 flags = FCPIO_ICMND_WRDATA;
323
324 exch_flags = 0;
325 if ((fnic->config.flags & VFCF_FCP_SEQ_LVL_ERR) &&
326 (rp->flags & FC_RP_FLAGS_RETRY))
327 exch_flags |= FCPIO_ICMND_SRFLAG_RETRY;
328
329 fnic_queue_wq_copy_desc_icmnd_16(wq, sc->request->tag,
330 0, exch_flags, io_req->sgl_cnt,
331 SCSI_SENSE_BUFFERSIZE,
332 io_req->sgl_list_pa,
333 io_req->sense_buf_pa,
334 0, /* scsi cmd ref, always 0 */
335 pri_tag, /* scsi pri and tag */
336 flags, /* command flags */
337 sc->cmnd, sc->cmd_len,
338 scsi_bufflen(sc),
339 fc_lun.scsi_lun, io_req->port_id,
340 rport->maxframe_size, rp->r_a_tov,
341 rp->e_d_tov);
342
343 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
344 return 0;
345 }
346
347 /*
348 * fnic_queuecommand
349 * Routine to send a scsi cdb
350 * Called with host_lock held and interrupts disabled.
351 */
352 static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
353 {
354 struct fc_lport *lp;
355 struct fc_rport *rport;
356 struct fnic_io_req *io_req;
357 struct fnic *fnic;
358 struct vnic_wq_copy *wq;
359 int ret;
360 int sg_count;
361 unsigned long flags;
362 unsigned long ptr;
363
364 rport = starget_to_rport(scsi_target(sc->device));
365 ret = fc_remote_port_chkready(rport);
366 if (ret) {
367 sc->result = ret;
368 done(sc);
369 return 0;
370 }
371
372 lp = shost_priv(sc->device->host);
373 if (lp->state != LPORT_ST_READY || !(lp->link_up))
374 return SCSI_MLQUEUE_HOST_BUSY;
375
376 /*
377 * Release host lock, use driver resource specific locks from here.
378 * Don't re-enable interrupts in case they were disabled prior to the
379 * caller disabling them.
380 */
381 spin_unlock(lp->host->host_lock);
382
383 /* Get a new io_req for this SCSI IO */
384 fnic = lport_priv(lp);
385
386 io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
387 if (!io_req) {
388 ret = SCSI_MLQUEUE_HOST_BUSY;
389 goto out;
390 }
391 memset(io_req, 0, sizeof(*io_req));
392
393 /* Map the data buffer */
394 sg_count = scsi_dma_map(sc);
395 if (sg_count < 0) {
396 mempool_free(io_req, fnic->io_req_pool);
397 goto out;
398 }
399
400 /* Determine the type of scatter/gather list we need */
401 io_req->sgl_cnt = sg_count;
402 io_req->sgl_type = FNIC_SGL_CACHE_DFLT;
403 if (sg_count > FNIC_DFLT_SG_DESC_CNT)
404 io_req->sgl_type = FNIC_SGL_CACHE_MAX;
405
406 if (sg_count) {
407 io_req->sgl_list =
408 mempool_alloc(fnic->io_sgl_pool[io_req->sgl_type],
409 GFP_ATOMIC | GFP_DMA);
410 if (!io_req->sgl_list) {
411 ret = SCSI_MLQUEUE_HOST_BUSY;
412 scsi_dma_unmap(sc);
413 mempool_free(io_req, fnic->io_req_pool);
414 goto out;
415 }
416
417 /* Cache sgl list allocated address before alignment */
418 io_req->sgl_list_alloc = io_req->sgl_list;
419 ptr = (unsigned long) io_req->sgl_list;
420 if (ptr % FNIC_SG_DESC_ALIGN) {
421 io_req->sgl_list = (struct host_sg_desc *)
422 (((unsigned long) ptr
423 + FNIC_SG_DESC_ALIGN - 1)
424 & ~(FNIC_SG_DESC_ALIGN - 1));
425 }
426 }
427
428 /* initialize rest of io_req */
429 io_req->port_id = rport->port_id;
430 CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
431 CMD_SP(sc) = (char *)io_req;
432 sc->scsi_done = done;
433
434 /* create copy wq desc and enqueue it */
435 wq = &fnic->wq_copy[0];
436 ret = fnic_queue_wq_copy_desc(fnic, wq, io_req, sc, sg_count);
437 if (ret) {
438 /*
439 * In case another thread cancelled the request,
440 * refetch the pointer under the lock.
441 */
442 spinlock_t *io_lock = fnic_io_lock_hash(fnic, sc);
443
444 spin_lock_irqsave(io_lock, flags);
445 io_req = (struct fnic_io_req *)CMD_SP(sc);
446 CMD_SP(sc) = NULL;
447 CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
448 spin_unlock_irqrestore(io_lock, flags);
449 if (io_req) {
450 fnic_release_ioreq_buf(fnic, io_req, sc);
451 mempool_free(io_req, fnic->io_req_pool);
452 }
453 }
454 out:
455 /* acquire host lock before returning to SCSI */
456 spin_lock(lp->host->host_lock);
457 return ret;
458 }
459
460 DEF_SCSI_QCMD(fnic_queuecommand)
461
462 /*
463 * fnic_fcpio_fw_reset_cmpl_handler
464 * Routine to handle fw reset completion
465 */
466 static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
467 struct fcpio_fw_req *desc)
468 {
469 u8 type;
470 u8 hdr_status;
471 struct fcpio_tag tag;
472 int ret = 0;
473 unsigned long flags;
474
475 fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
476
477 /* Clean up all outstanding io requests */
478 fnic_cleanup_io(fnic, SCSI_NO_TAG);
479
480 spin_lock_irqsave(&fnic->fnic_lock, flags);
481
482 /* fnic should be in FC_TRANS_ETH_MODE */
483 if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) {
484 /* Check status of reset completion */
485 if (!hdr_status) {
486 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
487 "reset cmpl success\n");
488 /* Ready to send flogi out */
489 fnic->state = FNIC_IN_ETH_MODE;
490 } else {
491 FNIC_SCSI_DBG(KERN_DEBUG,
492 fnic->lport->host,
493 "fnic fw_reset : failed %s\n",
494 fnic_fcpio_status_to_str(hdr_status));
495
496 /*
497 * Unable to change to eth mode, cannot send out flogi
498 * Change state to fc mode, so that subsequent Flogi
499 * requests from libFC will cause more attempts to
500 * reset the firmware. Free the cached flogi
501 */
502 fnic->state = FNIC_IN_FC_MODE;
503 ret = -1;
504 }
505 } else {
506 FNIC_SCSI_DBG(KERN_DEBUG,
507 fnic->lport->host,
508 "Unexpected state %s while processing"
509 " reset cmpl\n", fnic_state_to_str(fnic->state));
510 ret = -1;
511 }
512
513 /* Thread removing device blocks till firmware reset is complete */
514 if (fnic->remove_wait)
515 complete(fnic->remove_wait);
516
517 /*
518 * If fnic is being removed, or fw reset failed
519 * free the flogi frame. Else, send it out
520 */
521 if (fnic->remove_wait || ret) {
522 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
523 skb_queue_purge(&fnic->tx_queue);
524 goto reset_cmpl_handler_end;
525 }
526
527 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
528
529 fnic_flush_tx(fnic);
530
531 reset_cmpl_handler_end:
532 return ret;
533 }
534
535 /*
536 * fnic_fcpio_flogi_reg_cmpl_handler
537 * Routine to handle flogi register completion
538 */
539 static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
540 struct fcpio_fw_req *desc)
541 {
542 u8 type;
543 u8 hdr_status;
544 struct fcpio_tag tag;
545 int ret = 0;
546 unsigned long flags;
547
548 fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
549
550 /* Update fnic state based on status of flogi reg completion */
551 spin_lock_irqsave(&fnic->fnic_lock, flags);
552
553 if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) {
554
555 /* Check flogi registration completion status */
556 if (!hdr_status) {
557 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
558 "flog reg succeeded\n");
559 fnic->state = FNIC_IN_FC_MODE;
560 } else {
561 FNIC_SCSI_DBG(KERN_DEBUG,
562 fnic->lport->host,
563 "fnic flogi reg :failed %s\n",
564 fnic_fcpio_status_to_str(hdr_status));
565 fnic->state = FNIC_IN_ETH_MODE;
566 ret = -1;
567 }
568 } else {
569 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
570 "Unexpected fnic state %s while"
571 " processing flogi reg completion\n",
572 fnic_state_to_str(fnic->state));
573 ret = -1;
574 }
575
576 if (!ret) {
577 if (fnic->stop_rx_link_events) {
578 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
579 goto reg_cmpl_handler_end;
580 }
581 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
582
583 fnic_flush_tx(fnic);
584 queue_work(fnic_event_queue, &fnic->frame_work);
585 } else {
586 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
587 }
588
589 reg_cmpl_handler_end:
590 return ret;
591 }
592
593 static inline int is_ack_index_in_range(struct vnic_wq_copy *wq,
594 u16 request_out)
595 {
596 if (wq->to_clean_index <= wq->to_use_index) {
597 /* out of range, stale request_out index */
598 if (request_out < wq->to_clean_index ||
599 request_out >= wq->to_use_index)
600 return 0;
601 } else {
602 /* out of range, stale request_out index */
603 if (request_out < wq->to_clean_index &&
604 request_out >= wq->to_use_index)
605 return 0;
606 }
607 /* request_out index is in range */
608 return 1;
609 }
610
611
612 /*
613 * Mark that ack received and store the Ack index. If there are multiple
614 * acks received before Tx thread cleans it up, the latest value will be
615 * used which is correct behavior. This state should be in the copy Wq
616 * instead of in the fnic
617 */
618 static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
619 unsigned int cq_index,
620 struct fcpio_fw_req *desc)
621 {
622 struct vnic_wq_copy *wq;
623 u16 request_out = desc->u.ack.request_out;
624 unsigned long flags;
625
626 /* mark the ack state */
627 wq = &fnic->wq_copy[cq_index - fnic->raw_wq_count - fnic->rq_count];
628 spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
629
630 if (is_ack_index_in_range(wq, request_out)) {
631 fnic->fw_ack_index[0] = request_out;
632 fnic->fw_ack_recd[0] = 1;
633 }
634 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
635 }
636
637 /*
638 * fnic_fcpio_icmnd_cmpl_handler
639 * Routine to handle icmnd completions
640 */
641 static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
642 struct fcpio_fw_req *desc)
643 {
644 u8 type;
645 u8 hdr_status;
646 struct fcpio_tag tag;
647 u32 id;
648 u64 xfer_len = 0;
649 struct fcpio_icmnd_cmpl *icmnd_cmpl;
650 struct fnic_io_req *io_req;
651 struct scsi_cmnd *sc;
652 unsigned long flags;
653 spinlock_t *io_lock;
654
655 /* Decode the cmpl description to get the io_req id */
656 fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
657 fcpio_tag_id_dec(&tag, &id);
658
659 if (id >= FNIC_MAX_IO_REQ)
660 return;
661
662 sc = scsi_host_find_tag(fnic->lport->host, id);
663 WARN_ON_ONCE(!sc);
664 if (!sc)
665 return;
666
667 io_lock = fnic_io_lock_hash(fnic, sc);
668 spin_lock_irqsave(io_lock, flags);
669 io_req = (struct fnic_io_req *)CMD_SP(sc);
670 WARN_ON_ONCE(!io_req);
671 if (!io_req) {
672 spin_unlock_irqrestore(io_lock, flags);
673 return;
674 }
675
676 /* firmware completed the io */
677 io_req->io_completed = 1;
678
679 /*
680 * if SCSI-ML has already issued abort on this command,
681 * ignore completion of the IO. The abts path will clean it up
682 */
683 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
684 spin_unlock_irqrestore(io_lock, flags);
685 return;
686 }
687
688 /* Mark the IO as complete */
689 CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
690
691 icmnd_cmpl = &desc->u.icmnd_cmpl;
692
693 switch (hdr_status) {
694 case FCPIO_SUCCESS:
695 sc->result = (DID_OK << 16) | icmnd_cmpl->scsi_status;
696 xfer_len = scsi_bufflen(sc);
697 scsi_set_resid(sc, icmnd_cmpl->residual);
698
699 if (icmnd_cmpl->flags & FCPIO_ICMND_CMPL_RESID_UNDER)
700 xfer_len -= icmnd_cmpl->residual;
701
702 /*
703 * If queue_full, then try to reduce queue depth for all
704 * LUNS on the target. Todo: this should be accompanied
705 * by a periodic queue_depth rampup based on successful
706 * IO completion.
707 */
708 if (icmnd_cmpl->scsi_status == QUEUE_FULL) {
709 struct scsi_device *t_sdev;
710 int qd = 0;
711
712 shost_for_each_device(t_sdev, sc->device->host) {
713 if (t_sdev->id != sc->device->id)
714 continue;
715
716 if (t_sdev->queue_depth > 1) {
717 qd = scsi_track_queue_full
718 (t_sdev,
719 t_sdev->queue_depth - 1);
720 if (qd == -1)
721 qd = t_sdev->host->cmd_per_lun;
722 shost_printk(KERN_INFO,
723 fnic->lport->host,
724 "scsi[%d:%d:%d:%d"
725 "] queue full detected,"
726 "new depth = %d\n",
727 t_sdev->host->host_no,
728 t_sdev->channel,
729 t_sdev->id, t_sdev->lun,
730 t_sdev->queue_depth);
731 }
732 }
733 }
734 break;
735
736 case FCPIO_TIMEOUT: /* request was timed out */
737 sc->result = (DID_TIME_OUT << 16) | icmnd_cmpl->scsi_status;
738 break;
739
740 case FCPIO_ABORTED: /* request was aborted */
741 sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
742 break;
743
744 case FCPIO_DATA_CNT_MISMATCH: /* recv/sent more/less data than exp. */
745 scsi_set_resid(sc, icmnd_cmpl->residual);
746 sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
747 break;
748
749 case FCPIO_OUT_OF_RESOURCE: /* out of resources to complete request */
750 sc->result = (DID_REQUEUE << 16) | icmnd_cmpl->scsi_status;
751 break;
752 case FCPIO_INVALID_HEADER: /* header contains invalid data */
753 case FCPIO_INVALID_PARAM: /* some parameter in request invalid */
754 case FCPIO_REQ_NOT_SUPPORTED:/* request type is not supported */
755 case FCPIO_IO_NOT_FOUND: /* requested I/O was not found */
756 case FCPIO_SGL_INVALID: /* request was aborted due to sgl error */
757 case FCPIO_MSS_INVALID: /* request was aborted due to mss error */
758 case FCPIO_FW_ERR: /* request was terminated due fw error */
759 default:
760 shost_printk(KERN_ERR, fnic->lport->host, "hdr status = %s\n",
761 fnic_fcpio_status_to_str(hdr_status));
762 sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
763 break;
764 }
765
766 /* Break link with the SCSI command */
767 CMD_SP(sc) = NULL;
768
769 spin_unlock_irqrestore(io_lock, flags);
770
771 fnic_release_ioreq_buf(fnic, io_req, sc);
772
773 mempool_free(io_req, fnic->io_req_pool);
774
775 if (sc->sc_data_direction == DMA_FROM_DEVICE) {
776 fnic->lport->host_stats.fcp_input_requests++;
777 fnic->fcp_input_bytes += xfer_len;
778 } else if (sc->sc_data_direction == DMA_TO_DEVICE) {
779 fnic->lport->host_stats.fcp_output_requests++;
780 fnic->fcp_output_bytes += xfer_len;
781 } else
782 fnic->lport->host_stats.fcp_control_requests++;
783
784 /* Call SCSI completion function to complete the IO */
785 if (sc->scsi_done)
786 sc->scsi_done(sc);
787
788 }
789
790 /* fnic_fcpio_itmf_cmpl_handler
791 * Routine to handle itmf completions
792 */
793 static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
794 struct fcpio_fw_req *desc)
795 {
796 u8 type;
797 u8 hdr_status;
798 struct fcpio_tag tag;
799 u32 id;
800 struct scsi_cmnd *sc;
801 struct fnic_io_req *io_req;
802 unsigned long flags;
803 spinlock_t *io_lock;
804
805 fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
806 fcpio_tag_id_dec(&tag, &id);
807
808 if ((id & FNIC_TAG_MASK) >= FNIC_MAX_IO_REQ)
809 return;
810
811 sc = scsi_host_find_tag(fnic->lport->host, id & FNIC_TAG_MASK);
812 WARN_ON_ONCE(!sc);
813 if (!sc)
814 return;
815
816 io_lock = fnic_io_lock_hash(fnic, sc);
817 spin_lock_irqsave(io_lock, flags);
818 io_req = (struct fnic_io_req *)CMD_SP(sc);
819 WARN_ON_ONCE(!io_req);
820 if (!io_req) {
821 spin_unlock_irqrestore(io_lock, flags);
822 return;
823 }
824
825 if (id & FNIC_TAG_ABORT) {
826 /* Completion of abort cmd */
827 if (CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING) {
828 /* This is a late completion. Ignore it */
829 spin_unlock_irqrestore(io_lock, flags);
830 return;
831 }
832 CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
833 CMD_ABTS_STATUS(sc) = hdr_status;
834
835 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
836 "abts cmpl recd. id %d status %s\n",
837 (int)(id & FNIC_TAG_MASK),
838 fnic_fcpio_status_to_str(hdr_status));
839
840 /*
841 * If scsi_eh thread is blocked waiting for abts to complete,
842 * signal completion to it. IO will be cleaned in the thread
843 * else clean it in this context
844 */
845 if (io_req->abts_done) {
846 complete(io_req->abts_done);
847 spin_unlock_irqrestore(io_lock, flags);
848 } else {
849 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
850 "abts cmpl, completing IO\n");
851 CMD_SP(sc) = NULL;
852 sc->result = (DID_ERROR << 16);
853
854 spin_unlock_irqrestore(io_lock, flags);
855
856 fnic_release_ioreq_buf(fnic, io_req, sc);
857 mempool_free(io_req, fnic->io_req_pool);
858 if (sc->scsi_done)
859 sc->scsi_done(sc);
860 }
861
862 } else if (id & FNIC_TAG_DEV_RST) {
863 /* Completion of device reset */
864 CMD_LR_STATUS(sc) = hdr_status;
865 CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
866 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
867 "dev reset cmpl recd. id %d status %s\n",
868 (int)(id & FNIC_TAG_MASK),
869 fnic_fcpio_status_to_str(hdr_status));
870 if (io_req->dr_done)
871 complete(io_req->dr_done);
872 spin_unlock_irqrestore(io_lock, flags);
873
874 } else {
875 shost_printk(KERN_ERR, fnic->lport->host,
876 "Unexpected itmf io state %s tag %x\n",
877 fnic_ioreq_state_to_str(CMD_STATE(sc)), id);
878 spin_unlock_irqrestore(io_lock, flags);
879 }
880
881 }
882
883 /*
884 * fnic_fcpio_cmpl_handler
885 * Routine to service the cq for wq_copy
886 */
887 static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
888 unsigned int cq_index,
889 struct fcpio_fw_req *desc)
890 {
891 struct fnic *fnic = vnic_dev_priv(vdev);
892 int ret = 0;
893
894 switch (desc->hdr.type) {
895 case FCPIO_ACK: /* fw copied copy wq desc to its queue */
896 fnic_fcpio_ack_handler(fnic, cq_index, desc);
897 break;
898
899 case FCPIO_ICMND_CMPL: /* fw completed a command */
900 fnic_fcpio_icmnd_cmpl_handler(fnic, desc);
901 break;
902
903 case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
904 fnic_fcpio_itmf_cmpl_handler(fnic, desc);
905 break;
906
907 case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
908 case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
909 ret = fnic_fcpio_flogi_reg_cmpl_handler(fnic, desc);
910 break;
911
912 case FCPIO_RESET_CMPL: /* fw completed reset */
913 ret = fnic_fcpio_fw_reset_cmpl_handler(fnic, desc);
914 break;
915
916 default:
917 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
918 "firmware completion type %d\n",
919 desc->hdr.type);
920 break;
921 }
922
923 return ret;
924 }
925
926 /*
927 * fnic_wq_copy_cmpl_handler
928 * Routine to process wq copy
929 */
930 int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int copy_work_to_do)
931 {
932 unsigned int wq_work_done = 0;
933 unsigned int i, cq_index;
934 unsigned int cur_work_done;
935
936 for (i = 0; i < fnic->wq_copy_count; i++) {
937 cq_index = i + fnic->raw_wq_count + fnic->rq_count;
938 cur_work_done = vnic_cq_copy_service(&fnic->cq[cq_index],
939 fnic_fcpio_cmpl_handler,
940 copy_work_to_do);
941 wq_work_done += cur_work_done;
942 }
943 return wq_work_done;
944 }
945
946 static void fnic_cleanup_io(struct fnic *fnic, int exclude_id)
947 {
948 unsigned int i;
949 struct fnic_io_req *io_req;
950 unsigned long flags = 0;
951 struct scsi_cmnd *sc;
952 spinlock_t *io_lock;
953
954 for (i = 0; i < FNIC_MAX_IO_REQ; i++) {
955 if (i == exclude_id)
956 continue;
957
958 sc = scsi_host_find_tag(fnic->lport->host, i);
959 if (!sc)
960 continue;
961
962 io_lock = fnic_io_lock_hash(fnic, sc);
963 spin_lock_irqsave(io_lock, flags);
964 io_req = (struct fnic_io_req *)CMD_SP(sc);
965 if (!io_req) {
966 spin_unlock_irqrestore(io_lock, flags);
967 goto cleanup_scsi_cmd;
968 }
969
970 CMD_SP(sc) = NULL;
971
972 spin_unlock_irqrestore(io_lock, flags);
973
974 /*
975 * If there is a scsi_cmnd associated with this io_req, then
976 * free the corresponding state
977 */
978 fnic_release_ioreq_buf(fnic, io_req, sc);
979 mempool_free(io_req, fnic->io_req_pool);
980
981 cleanup_scsi_cmd:
982 sc->result = DID_TRANSPORT_DISRUPTED << 16;
983 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "fnic_cleanup_io:"
984 " DID_TRANSPORT_DISRUPTED\n");
985
986 /* Complete the command to SCSI */
987 if (sc->scsi_done)
988 sc->scsi_done(sc);
989 }
990 }
991
992 void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
993 struct fcpio_host_req *desc)
994 {
995 u32 id;
996 struct fnic *fnic = vnic_dev_priv(wq->vdev);
997 struct fnic_io_req *io_req;
998 struct scsi_cmnd *sc;
999 unsigned long flags;
1000 spinlock_t *io_lock;
1001
1002 /* get the tag reference */
1003 fcpio_tag_id_dec(&desc->hdr.tag, &id);
1004 id &= FNIC_TAG_MASK;
1005
1006 if (id >= FNIC_MAX_IO_REQ)
1007 return;
1008
1009 sc = scsi_host_find_tag(fnic->lport->host, id);
1010 if (!sc)
1011 return;
1012
1013 io_lock = fnic_io_lock_hash(fnic, sc);
1014 spin_lock_irqsave(io_lock, flags);
1015
1016 /* Get the IO context which this desc refers to */
1017 io_req = (struct fnic_io_req *)CMD_SP(sc);
1018
1019 /* fnic interrupts are turned off by now */
1020
1021 if (!io_req) {
1022 spin_unlock_irqrestore(io_lock, flags);
1023 goto wq_copy_cleanup_scsi_cmd;
1024 }
1025
1026 CMD_SP(sc) = NULL;
1027
1028 spin_unlock_irqrestore(io_lock, flags);
1029
1030 fnic_release_ioreq_buf(fnic, io_req, sc);
1031 mempool_free(io_req, fnic->io_req_pool);
1032
1033 wq_copy_cleanup_scsi_cmd:
1034 sc->result = DID_NO_CONNECT << 16;
1035 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "wq_copy_cleanup_handler:"
1036 " DID_NO_CONNECT\n");
1037
1038 if (sc->scsi_done)
1039 sc->scsi_done(sc);
1040 }
1041
1042 static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
1043 u32 task_req, u8 *fc_lun,
1044 struct fnic_io_req *io_req)
1045 {
1046 struct vnic_wq_copy *wq = &fnic->wq_copy[0];
1047 unsigned long flags;
1048
1049 spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
1050
1051 if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
1052 free_wq_copy_descs(fnic, wq);
1053
1054 if (!vnic_wq_copy_desc_avail(wq)) {
1055 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
1056 return 1;
1057 }
1058 fnic_queue_wq_copy_desc_itmf(wq, tag | FNIC_TAG_ABORT,
1059 0, task_req, tag, fc_lun, io_req->port_id,
1060 fnic->config.ra_tov, fnic->config.ed_tov);
1061
1062 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
1063 return 0;
1064 }
1065
1066 void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
1067 {
1068 int tag;
1069 struct fnic_io_req *io_req;
1070 spinlock_t *io_lock;
1071 unsigned long flags;
1072 struct scsi_cmnd *sc;
1073 struct scsi_lun fc_lun;
1074 enum fnic_ioreq_state old_ioreq_state;
1075
1076 FNIC_SCSI_DBG(KERN_DEBUG,
1077 fnic->lport->host,
1078 "fnic_rport_reset_exch called portid 0x%06x\n",
1079 port_id);
1080
1081 if (fnic->in_remove)
1082 return;
1083
1084 for (tag = 0; tag < FNIC_MAX_IO_REQ; tag++) {
1085 sc = scsi_host_find_tag(fnic->lport->host, tag);
1086 if (!sc)
1087 continue;
1088
1089 io_lock = fnic_io_lock_hash(fnic, sc);
1090 spin_lock_irqsave(io_lock, flags);
1091
1092 io_req = (struct fnic_io_req *)CMD_SP(sc);
1093
1094 if (!io_req || io_req->port_id != port_id) {
1095 spin_unlock_irqrestore(io_lock, flags);
1096 continue;
1097 }
1098
1099 /*
1100 * Found IO that is still pending with firmware and
1101 * belongs to rport that went away
1102 */
1103 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1104 spin_unlock_irqrestore(io_lock, flags);
1105 continue;
1106 }
1107 old_ioreq_state = CMD_STATE(sc);
1108 CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
1109 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1110
1111 BUG_ON(io_req->abts_done);
1112
1113 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1114 "fnic_rport_reset_exch: Issuing abts\n");
1115
1116 spin_unlock_irqrestore(io_lock, flags);
1117
1118 /* Now queue the abort command to firmware */
1119 int_to_scsilun(sc->device->lun, &fc_lun);
1120
1121 if (fnic_queue_abort_io_req(fnic, tag,
1122 FCPIO_ITMF_ABT_TASK_TERM,
1123 fc_lun.scsi_lun, io_req)) {
1124 /*
1125 * Revert the cmd state back to old state, if
1126 * it hasnt changed in between. This cmd will get
1127 * aborted later by scsi_eh, or cleaned up during
1128 * lun reset
1129 */
1130 io_lock = fnic_io_lock_hash(fnic, sc);
1131
1132 spin_lock_irqsave(io_lock, flags);
1133 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
1134 CMD_STATE(sc) = old_ioreq_state;
1135 spin_unlock_irqrestore(io_lock, flags);
1136 }
1137 }
1138
1139 }
1140
1141 void fnic_terminate_rport_io(struct fc_rport *rport)
1142 {
1143 int tag;
1144 struct fnic_io_req *io_req;
1145 spinlock_t *io_lock;
1146 unsigned long flags;
1147 struct scsi_cmnd *sc;
1148 struct scsi_lun fc_lun;
1149 struct fc_rport_libfc_priv *rdata = rport->dd_data;
1150 struct fc_lport *lport = rdata->local_port;
1151 struct fnic *fnic = lport_priv(lport);
1152 struct fc_rport *cmd_rport;
1153 enum fnic_ioreq_state old_ioreq_state;
1154
1155 FNIC_SCSI_DBG(KERN_DEBUG,
1156 fnic->lport->host, "fnic_terminate_rport_io called"
1157 " wwpn 0x%llx, wwnn0x%llx, portid 0x%06x\n",
1158 rport->port_name, rport->node_name,
1159 rport->port_id);
1160
1161 if (fnic->in_remove)
1162 return;
1163
1164 for (tag = 0; tag < FNIC_MAX_IO_REQ; tag++) {
1165 sc = scsi_host_find_tag(fnic->lport->host, tag);
1166 if (!sc)
1167 continue;
1168
1169 cmd_rport = starget_to_rport(scsi_target(sc->device));
1170 if (rport != cmd_rport)
1171 continue;
1172
1173 io_lock = fnic_io_lock_hash(fnic, sc);
1174 spin_lock_irqsave(io_lock, flags);
1175
1176 io_req = (struct fnic_io_req *)CMD_SP(sc);
1177
1178 if (!io_req || rport != cmd_rport) {
1179 spin_unlock_irqrestore(io_lock, flags);
1180 continue;
1181 }
1182
1183 /*
1184 * Found IO that is still pending with firmware and
1185 * belongs to rport that went away
1186 */
1187 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1188 spin_unlock_irqrestore(io_lock, flags);
1189 continue;
1190 }
1191 old_ioreq_state = CMD_STATE(sc);
1192 CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
1193 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1194
1195 BUG_ON(io_req->abts_done);
1196
1197 FNIC_SCSI_DBG(KERN_DEBUG,
1198 fnic->lport->host,
1199 "fnic_terminate_rport_io: Issuing abts\n");
1200
1201 spin_unlock_irqrestore(io_lock, flags);
1202
1203 /* Now queue the abort command to firmware */
1204 int_to_scsilun(sc->device->lun, &fc_lun);
1205
1206 if (fnic_queue_abort_io_req(fnic, tag,
1207 FCPIO_ITMF_ABT_TASK_TERM,
1208 fc_lun.scsi_lun, io_req)) {
1209 /*
1210 * Revert the cmd state back to old state, if
1211 * it hasnt changed in between. This cmd will get
1212 * aborted later by scsi_eh, or cleaned up during
1213 * lun reset
1214 */
1215 io_lock = fnic_io_lock_hash(fnic, sc);
1216
1217 spin_lock_irqsave(io_lock, flags);
1218 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
1219 CMD_STATE(sc) = old_ioreq_state;
1220 spin_unlock_irqrestore(io_lock, flags);
1221 }
1222 }
1223
1224 }
1225
1226 /*
1227 * This function is exported to SCSI for sending abort cmnds.
1228 * A SCSI IO is represented by a io_req in the driver.
1229 * The ioreq is linked to the SCSI Cmd, thus a link with the ULP's IO.
1230 */
1231 int fnic_abort_cmd(struct scsi_cmnd *sc)
1232 {
1233 struct fc_lport *lp;
1234 struct fnic *fnic;
1235 struct fnic_io_req *io_req;
1236 struct fc_rport *rport;
1237 spinlock_t *io_lock;
1238 unsigned long flags;
1239 int ret = SUCCESS;
1240 u32 task_req;
1241 struct scsi_lun fc_lun;
1242 DECLARE_COMPLETION_ONSTACK(tm_done);
1243
1244 /* Wait for rport to unblock */
1245 fc_block_scsi_eh(sc);
1246
1247 /* Get local-port, check ready and link up */
1248 lp = shost_priv(sc->device->host);
1249
1250 fnic = lport_priv(lp);
1251 rport = starget_to_rport(scsi_target(sc->device));
1252 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1253 "Abort Cmd called FCID 0x%x, LUN 0x%x TAG %d\n",
1254 rport->port_id, sc->device->lun, sc->request->tag);
1255
1256 if (lp->state != LPORT_ST_READY || !(lp->link_up)) {
1257 ret = FAILED;
1258 goto fnic_abort_cmd_end;
1259 }
1260
1261 /*
1262 * Avoid a race between SCSI issuing the abort and the device
1263 * completing the command.
1264 *
1265 * If the command is already completed by the fw cmpl code,
1266 * we just return SUCCESS from here. This means that the abort
1267 * succeeded. In the SCSI ML, since the timeout for command has
1268 * happened, the completion wont actually complete the command
1269 * and it will be considered as an aborted command
1270 *
1271 * The CMD_SP will not be cleared except while holding io_req_lock.
1272 */
1273 io_lock = fnic_io_lock_hash(fnic, sc);
1274 spin_lock_irqsave(io_lock, flags);
1275 io_req = (struct fnic_io_req *)CMD_SP(sc);
1276 if (!io_req) {
1277 spin_unlock_irqrestore(io_lock, flags);
1278 goto fnic_abort_cmd_end;
1279 }
1280
1281 io_req->abts_done = &tm_done;
1282
1283 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1284 spin_unlock_irqrestore(io_lock, flags);
1285 goto wait_pending;
1286 }
1287 /*
1288 * Command is still pending, need to abort it
1289 * If the firmware completes the command after this point,
1290 * the completion wont be done till mid-layer, since abort
1291 * has already started.
1292 */
1293 CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
1294 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1295
1296 spin_unlock_irqrestore(io_lock, flags);
1297
1298 /*
1299 * Check readiness of the remote port. If the path to remote
1300 * port is up, then send abts to the remote port to terminate
1301 * the IO. Else, just locally terminate the IO in the firmware
1302 */
1303 if (fc_remote_port_chkready(rport) == 0)
1304 task_req = FCPIO_ITMF_ABT_TASK;
1305 else
1306 task_req = FCPIO_ITMF_ABT_TASK_TERM;
1307
1308 /* Now queue the abort command to firmware */
1309 int_to_scsilun(sc->device->lun, &fc_lun);
1310
1311 if (fnic_queue_abort_io_req(fnic, sc->request->tag, task_req,
1312 fc_lun.scsi_lun, io_req)) {
1313 spin_lock_irqsave(io_lock, flags);
1314 io_req = (struct fnic_io_req *)CMD_SP(sc);
1315 if (io_req)
1316 io_req->abts_done = NULL;
1317 spin_unlock_irqrestore(io_lock, flags);
1318 ret = FAILED;
1319 goto fnic_abort_cmd_end;
1320 }
1321
1322 /*
1323 * We queued an abort IO, wait for its completion.
1324 * Once the firmware completes the abort command, it will
1325 * wake up this thread.
1326 */
1327 wait_pending:
1328 wait_for_completion_timeout(&tm_done,
1329 msecs_to_jiffies
1330 (2 * fnic->config.ra_tov +
1331 fnic->config.ed_tov));
1332
1333 /* Check the abort status */
1334 spin_lock_irqsave(io_lock, flags);
1335
1336 io_req = (struct fnic_io_req *)CMD_SP(sc);
1337 if (!io_req) {
1338 spin_unlock_irqrestore(io_lock, flags);
1339 ret = FAILED;
1340 goto fnic_abort_cmd_end;
1341 }
1342 io_req->abts_done = NULL;
1343
1344 /* fw did not complete abort, timed out */
1345 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1346 spin_unlock_irqrestore(io_lock, flags);
1347 ret = FAILED;
1348 goto fnic_abort_cmd_end;
1349 }
1350
1351 /*
1352 * firmware completed the abort, check the status,
1353 * free the io_req irrespective of failure or success
1354 */
1355 if (CMD_ABTS_STATUS(sc) != FCPIO_SUCCESS)
1356 ret = FAILED;
1357
1358 CMD_SP(sc) = NULL;
1359
1360 spin_unlock_irqrestore(io_lock, flags);
1361
1362 fnic_release_ioreq_buf(fnic, io_req, sc);
1363 mempool_free(io_req, fnic->io_req_pool);
1364
1365 fnic_abort_cmd_end:
1366 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1367 "Returning from abort cmd %s\n",
1368 (ret == SUCCESS) ?
1369 "SUCCESS" : "FAILED");
1370 return ret;
1371 }
1372
1373 static inline int fnic_queue_dr_io_req(struct fnic *fnic,
1374 struct scsi_cmnd *sc,
1375 struct fnic_io_req *io_req)
1376 {
1377 struct vnic_wq_copy *wq = &fnic->wq_copy[0];
1378 struct scsi_lun fc_lun;
1379 int ret = 0;
1380 unsigned long intr_flags;
1381
1382 spin_lock_irqsave(&fnic->wq_copy_lock[0], intr_flags);
1383
1384 if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
1385 free_wq_copy_descs(fnic, wq);
1386
1387 if (!vnic_wq_copy_desc_avail(wq)) {
1388 ret = -EAGAIN;
1389 goto lr_io_req_end;
1390 }
1391
1392 /* fill in the lun info */
1393 int_to_scsilun(sc->device->lun, &fc_lun);
1394
1395 fnic_queue_wq_copy_desc_itmf(wq, sc->request->tag | FNIC_TAG_DEV_RST,
1396 0, FCPIO_ITMF_LUN_RESET, SCSI_NO_TAG,
1397 fc_lun.scsi_lun, io_req->port_id,
1398 fnic->config.ra_tov, fnic->config.ed_tov);
1399
1400 lr_io_req_end:
1401 spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
1402
1403 return ret;
1404 }
1405
1406 /*
1407 * Clean up any pending aborts on the lun
1408 * For each outstanding IO on this lun, whose abort is not completed by fw,
1409 * issue a local abort. Wait for abort to complete. Return 0 if all commands
1410 * successfully aborted, 1 otherwise
1411 */
1412 static int fnic_clean_pending_aborts(struct fnic *fnic,
1413 struct scsi_cmnd *lr_sc)
1414 {
1415 int tag;
1416 struct fnic_io_req *io_req;
1417 spinlock_t *io_lock;
1418 unsigned long flags;
1419 int ret = 0;
1420 struct scsi_cmnd *sc;
1421 struct scsi_lun fc_lun;
1422 struct scsi_device *lun_dev = lr_sc->device;
1423 DECLARE_COMPLETION_ONSTACK(tm_done);
1424
1425 for (tag = 0; tag < FNIC_MAX_IO_REQ; tag++) {
1426 sc = scsi_host_find_tag(fnic->lport->host, tag);
1427 /*
1428 * ignore this lun reset cmd or cmds that do not belong to
1429 * this lun
1430 */
1431 if (!sc || sc == lr_sc || sc->device != lun_dev)
1432 continue;
1433
1434 io_lock = fnic_io_lock_hash(fnic, sc);
1435 spin_lock_irqsave(io_lock, flags);
1436
1437 io_req = (struct fnic_io_req *)CMD_SP(sc);
1438
1439 if (!io_req || sc->device != lun_dev) {
1440 spin_unlock_irqrestore(io_lock, flags);
1441 continue;
1442 }
1443
1444 /*
1445 * Found IO that is still pending with firmware and
1446 * belongs to the LUN that we are resetting
1447 */
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)));
1451
1452 BUG_ON(CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING);
1453
1454 CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1455 io_req->abts_done = &tm_done;
1456 spin_unlock_irqrestore(io_lock, flags);
1457
1458 /* Now queue the abort command to firmware */
1459 int_to_scsilun(sc->device->lun, &fc_lun);
1460
1461 if (fnic_queue_abort_io_req(fnic, tag,
1462 FCPIO_ITMF_ABT_TASK_TERM,
1463 fc_lun.scsi_lun, io_req)) {
1464 spin_lock_irqsave(io_lock, flags);
1465 io_req = (struct fnic_io_req *)CMD_SP(sc);
1466 if (io_req)
1467 io_req->abts_done = NULL;
1468 spin_unlock_irqrestore(io_lock, flags);
1469 ret = 1;
1470 goto clean_pending_aborts_end;
1471 }
1472
1473 wait_for_completion_timeout(&tm_done,
1474 msecs_to_jiffies
1475 (fnic->config.ed_tov));
1476
1477 /* Recheck cmd state to check if it is now aborted */
1478 spin_lock_irqsave(io_lock, flags);
1479 io_req = (struct fnic_io_req *)CMD_SP(sc);
1480 if (!io_req) {
1481 spin_unlock_irqrestore(io_lock, flags);
1482 ret = 1;
1483 goto clean_pending_aborts_end;
1484 }
1485
1486 io_req->abts_done = NULL;
1487
1488 /* if abort is still pending with fw, fail */
1489 if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1490 spin_unlock_irqrestore(io_lock, flags);
1491 ret = 1;
1492 goto clean_pending_aborts_end;
1493 }
1494 CMD_SP(sc) = NULL;
1495 spin_unlock_irqrestore(io_lock, flags);
1496
1497 fnic_release_ioreq_buf(fnic, io_req, sc);
1498 mempool_free(io_req, fnic->io_req_pool);
1499 }
1500
1501 clean_pending_aborts_end:
1502 return ret;
1503 }
1504
1505 /*
1506 * SCSI Eh thread issues a Lun Reset when one or more commands on a LUN
1507 * fail to get aborted. It calls driver's eh_device_reset with a SCSI command
1508 * on the LUN.
1509 */
1510 int fnic_device_reset(struct scsi_cmnd *sc)
1511 {
1512 struct fc_lport *lp;
1513 struct fnic *fnic;
1514 struct fnic_io_req *io_req;
1515 struct fc_rport *rport;
1516 int status;
1517 int ret = FAILED;
1518 spinlock_t *io_lock;
1519 unsigned long flags;
1520 DECLARE_COMPLETION_ONSTACK(tm_done);
1521
1522 /* Wait for rport to unblock */
1523 fc_block_scsi_eh(sc);
1524
1525 /* Get local-port, check ready and link up */
1526 lp = shost_priv(sc->device->host);
1527
1528 fnic = lport_priv(lp);
1529
1530 rport = starget_to_rport(scsi_target(sc->device));
1531 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1532 "Device reset called FCID 0x%x, LUN 0x%x\n",
1533 rport->port_id, sc->device->lun);
1534
1535 if (lp->state != LPORT_ST_READY || !(lp->link_up))
1536 goto fnic_device_reset_end;
1537
1538 /* Check if remote port up */
1539 if (fc_remote_port_chkready(rport))
1540 goto fnic_device_reset_end;
1541
1542 io_lock = fnic_io_lock_hash(fnic, sc);
1543 spin_lock_irqsave(io_lock, flags);
1544 io_req = (struct fnic_io_req *)CMD_SP(sc);
1545
1546 /*
1547 * If there is a io_req attached to this command, then use it,
1548 * else allocate a new one.
1549 */
1550 if (!io_req) {
1551 io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
1552 if (!io_req) {
1553 spin_unlock_irqrestore(io_lock, flags);
1554 goto fnic_device_reset_end;
1555 }
1556 memset(io_req, 0, sizeof(*io_req));
1557 io_req->port_id = rport->port_id;
1558 CMD_SP(sc) = (char *)io_req;
1559 }
1560 io_req->dr_done = &tm_done;
1561 CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
1562 CMD_LR_STATUS(sc) = FCPIO_INVALID_CODE;
1563 spin_unlock_irqrestore(io_lock, flags);
1564
1565 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "TAG %d\n",
1566 sc->request->tag);
1567
1568 /*
1569 * issue the device reset, if enqueue failed, clean up the ioreq
1570 * and break assoc with scsi cmd
1571 */
1572 if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
1573 spin_lock_irqsave(io_lock, flags);
1574 io_req = (struct fnic_io_req *)CMD_SP(sc);
1575 if (io_req)
1576 io_req->dr_done = NULL;
1577 goto fnic_device_reset_clean;
1578 }
1579
1580 /*
1581 * Wait on the local completion for LUN reset. The io_req may be
1582 * freed while we wait since we hold no lock.
1583 */
1584 wait_for_completion_timeout(&tm_done,
1585 msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
1586
1587 spin_lock_irqsave(io_lock, flags);
1588 io_req = (struct fnic_io_req *)CMD_SP(sc);
1589 if (!io_req) {
1590 spin_unlock_irqrestore(io_lock, flags);
1591 goto fnic_device_reset_end;
1592 }
1593 io_req->dr_done = NULL;
1594
1595 status = CMD_LR_STATUS(sc);
1596 spin_unlock_irqrestore(io_lock, flags);
1597
1598 /*
1599 * If lun reset not completed, bail out with failed. io_req
1600 * gets cleaned up during higher levels of EH
1601 */
1602 if (status == FCPIO_INVALID_CODE) {
1603 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1604 "Device reset timed out\n");
1605 goto fnic_device_reset_end;
1606 }
1607
1608 /* Completed, but not successful, clean up the io_req, return fail */
1609 if (status != FCPIO_SUCCESS) {
1610 spin_lock_irqsave(io_lock, flags);
1611 FNIC_SCSI_DBG(KERN_DEBUG,
1612 fnic->lport->host,
1613 "Device reset completed - failed\n");
1614 io_req = (struct fnic_io_req *)CMD_SP(sc);
1615 goto fnic_device_reset_clean;
1616 }
1617
1618 /*
1619 * Clean up any aborts on this lun that have still not
1620 * completed. If any of these fail, then LUN reset fails.
1621 * clean_pending_aborts cleans all cmds on this lun except
1622 * the lun reset cmd. If all cmds get cleaned, the lun reset
1623 * succeeds
1624 */
1625 if (fnic_clean_pending_aborts(fnic, sc)) {
1626 spin_lock_irqsave(io_lock, flags);
1627 io_req = (struct fnic_io_req *)CMD_SP(sc);
1628 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1629 "Device reset failed"
1630 " since could not abort all IOs\n");
1631 goto fnic_device_reset_clean;
1632 }
1633
1634 /* Clean lun reset command */
1635 spin_lock_irqsave(io_lock, flags);
1636 io_req = (struct fnic_io_req *)CMD_SP(sc);
1637 if (io_req)
1638 /* Completed, and successful */
1639 ret = SUCCESS;
1640
1641 fnic_device_reset_clean:
1642 if (io_req)
1643 CMD_SP(sc) = NULL;
1644
1645 spin_unlock_irqrestore(io_lock, flags);
1646
1647 if (io_req) {
1648 fnic_release_ioreq_buf(fnic, io_req, sc);
1649 mempool_free(io_req, fnic->io_req_pool);
1650 }
1651
1652 fnic_device_reset_end:
1653 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1654 "Returning from device reset %s\n",
1655 (ret == SUCCESS) ?
1656 "SUCCESS" : "FAILED");
1657 return ret;
1658 }
1659
1660 /* Clean up all IOs, clean up libFC local port */
1661 int fnic_reset(struct Scsi_Host *shost)
1662 {
1663 struct fc_lport *lp;
1664 struct fnic *fnic;
1665 int ret = SUCCESS;
1666
1667 lp = shost_priv(shost);
1668 fnic = lport_priv(lp);
1669
1670 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1671 "fnic_reset called\n");
1672
1673 /*
1674 * Reset local port, this will clean up libFC exchanges,
1675 * reset remote port sessions, and if link is up, begin flogi
1676 */
1677 if (lp->tt.lport_reset(lp))
1678 ret = FAILED;
1679
1680 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1681 "Returning from fnic reset %s\n",
1682 (ret == SUCCESS) ?
1683 "SUCCESS" : "FAILED");
1684
1685 return ret;
1686 }
1687
1688 /*
1689 * SCSI Error handling calls driver's eh_host_reset if all prior
1690 * error handling levels return FAILED. If host reset completes
1691 * successfully, and if link is up, then Fabric login begins.
1692 *
1693 * Host Reset is the highest level of error recovery. If this fails, then
1694 * host is offlined by SCSI.
1695 *
1696 */
1697 int fnic_host_reset(struct scsi_cmnd *sc)
1698 {
1699 int ret;
1700 unsigned long wait_host_tmo;
1701 struct Scsi_Host *shost = sc->device->host;
1702 struct fc_lport *lp = shost_priv(shost);
1703
1704 /*
1705 * If fnic_reset is successful, wait for fabric login to complete
1706 * scsi-ml tries to send a TUR to every device if host reset is
1707 * successful, so before returning to scsi, fabric should be up
1708 */
1709 ret = fnic_reset(shost);
1710 if (ret == SUCCESS) {
1711 wait_host_tmo = jiffies + FNIC_HOST_RESET_SETTLE_TIME * HZ;
1712 ret = FAILED;
1713 while (time_before(jiffies, wait_host_tmo)) {
1714 if ((lp->state == LPORT_ST_READY) &&
1715 (lp->link_up)) {
1716 ret = SUCCESS;
1717 break;
1718 }
1719 ssleep(1);
1720 }
1721 }
1722
1723 return ret;
1724 }
1725
1726 /*
1727 * This fxn is called from libFC when host is removed
1728 */
1729 void fnic_scsi_abort_io(struct fc_lport *lp)
1730 {
1731 int err = 0;
1732 unsigned long flags;
1733 enum fnic_state old_state;
1734 struct fnic *fnic = lport_priv(lp);
1735 DECLARE_COMPLETION_ONSTACK(remove_wait);
1736
1737 /* Issue firmware reset for fnic, wait for reset to complete */
1738 spin_lock_irqsave(&fnic->fnic_lock, flags);
1739 fnic->remove_wait = &remove_wait;
1740 old_state = fnic->state;
1741 fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
1742 fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
1743 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1744
1745 err = fnic_fw_reset_handler(fnic);
1746 if (err) {
1747 spin_lock_irqsave(&fnic->fnic_lock, flags);
1748 if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)
1749 fnic->state = old_state;
1750 fnic->remove_wait = NULL;
1751 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1752 return;
1753 }
1754
1755 /* Wait for firmware reset to complete */
1756 wait_for_completion_timeout(&remove_wait,
1757 msecs_to_jiffies(FNIC_RMDEVICE_TIMEOUT));
1758
1759 spin_lock_irqsave(&fnic->fnic_lock, flags);
1760 fnic->remove_wait = NULL;
1761 FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1762 "fnic_scsi_abort_io %s\n",
1763 (fnic->state == FNIC_IN_ETH_MODE) ?
1764 "SUCCESS" : "FAILED");
1765 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1766
1767 }
1768
1769 /*
1770 * This fxn called from libFC to clean up driver IO state on link down
1771 */
1772 void fnic_scsi_cleanup(struct fc_lport *lp)
1773 {
1774 unsigned long flags;
1775 enum fnic_state old_state;
1776 struct fnic *fnic = lport_priv(lp);
1777
1778 /* issue fw reset */
1779 spin_lock_irqsave(&fnic->fnic_lock, flags);
1780 old_state = fnic->state;
1781 fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
1782 fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
1783 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1784
1785 if (fnic_fw_reset_handler(fnic)) {
1786 spin_lock_irqsave(&fnic->fnic_lock, flags);
1787 if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)
1788 fnic->state = old_state;
1789 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1790 }
1791
1792 }
1793
1794 void fnic_empty_scsi_cleanup(struct fc_lport *lp)
1795 {
1796 }
1797
1798 void fnic_exch_mgr_reset(struct fc_lport *lp, u32 sid, u32 did)
1799 {
1800 struct fnic *fnic = lport_priv(lp);
1801
1802 /* Non-zero sid, nothing to do */
1803 if (sid)
1804 goto call_fc_exch_mgr_reset;
1805
1806 if (did) {
1807 fnic_rport_exch_reset(fnic, did);
1808 goto call_fc_exch_mgr_reset;
1809 }
1810
1811 /*
1812 * sid = 0, did = 0
1813 * link down or device being removed
1814 */
1815 if (!fnic->in_remove)
1816 fnic_scsi_cleanup(lp);
1817 else
1818 fnic_scsi_abort_io(lp);
1819
1820 /* call libFC exch mgr reset to reset its exchanges */
1821 call_fc_exch_mgr_reset:
1822 fc_exch_mgr_reset(lp, sid, did);
1823
1824 }
WandBoard kernel