?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.16.11
[linux/fpc-iii.git] / drivers / scsi / snic / snic_scsi.c
blobd8a376b7882de5003b2d31f59fd1ac22082acc97
1 /*
2 * Copyright 2014 Cisco Systems, Inc. All rights reserved.
3 *
4 * This program is free software; you may redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; version 2 of the License.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
15 * SOFTWARE.
16 */
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/spinlock.h>
24 #include <linux/delay.h>
25 #include <linux/gfp.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_host.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_tcq.h>
31 #include <scsi/scsi_dbg.h>
32
33 #include "snic_io.h"
34 #include "snic.h"
35
36 #define snic_cmd_tag(sc) (((struct scsi_cmnd *) sc)->request->tag)
37
38 const char *snic_state_str[] = {
39 [SNIC_INIT] = "SNIC_INIT",
40 [SNIC_ERROR] = "SNIC_ERROR",
41 [SNIC_ONLINE] = "SNIC_ONLINE",
42 [SNIC_OFFLINE] = "SNIC_OFFLINE",
43 [SNIC_FWRESET] = "SNIC_FWRESET",
44 };
45
46 static const char * const snic_req_state_str[] = {
47 [SNIC_IOREQ_NOT_INITED] = "SNIC_IOREQ_NOT_INITED",
48 [SNIC_IOREQ_PENDING] = "SNIC_IOREQ_PENDING",
49 [SNIC_IOREQ_ABTS_PENDING] = "SNIC_IOREQ_ABTS_PENDING",
50 [SNIC_IOREQ_ABTS_COMPLETE] = "SNIC_IOREQ_ABTS_COMPELTE",
51 [SNIC_IOREQ_LR_PENDING] = "SNIC_IOREQ_LR_PENDING",
52 [SNIC_IOREQ_LR_COMPLETE] = "SNIC_IOREQ_LR_COMPELTE",
53 [SNIC_IOREQ_COMPLETE] = "SNIC_IOREQ_CMD_COMPELTE",
54 };
55
56 /* snic cmd status strings */
57 static const char * const snic_io_status_str[] = {
58 [SNIC_STAT_IO_SUCCESS] = "SNIC_STAT_IO_SUCCESS", /* 0x0 */
59 [SNIC_STAT_INVALID_HDR] = "SNIC_STAT_INVALID_HDR",
60 [SNIC_STAT_OUT_OF_RES] = "SNIC_STAT_OUT_OF_RES",
61 [SNIC_STAT_INVALID_PARM] = "SNIC_STAT_INVALID_PARM",
62 [SNIC_STAT_REQ_NOT_SUP] = "SNIC_STAT_REQ_NOT_SUP",
63 [SNIC_STAT_IO_NOT_FOUND] = "SNIC_STAT_IO_NOT_FOUND",
64 [SNIC_STAT_ABORTED] = "SNIC_STAT_ABORTED",
65 [SNIC_STAT_TIMEOUT] = "SNIC_STAT_TIMEOUT",
66 [SNIC_STAT_SGL_INVALID] = "SNIC_STAT_SGL_INVALID",
67 [SNIC_STAT_DATA_CNT_MISMATCH] = "SNIC_STAT_DATA_CNT_MISMATCH",
68 [SNIC_STAT_FW_ERR] = "SNIC_STAT_FW_ERR",
69 [SNIC_STAT_ITMF_REJECT] = "SNIC_STAT_ITMF_REJECT",
70 [SNIC_STAT_ITMF_FAIL] = "SNIC_STAT_ITMF_FAIL",
71 [SNIC_STAT_ITMF_INCORRECT_LUN] = "SNIC_STAT_ITMF_INCORRECT_LUN",
72 [SNIC_STAT_CMND_REJECT] = "SNIC_STAT_CMND_REJECT",
73 [SNIC_STAT_DEV_OFFLINE] = "SNIC_STAT_DEV_OFFLINE",
74 [SNIC_STAT_NO_BOOTLUN] = "SNIC_STAT_NO_BOOTLUN",
75 [SNIC_STAT_SCSI_ERR] = "SNIC_STAT_SCSI_ERR",
76 [SNIC_STAT_NOT_READY] = "SNIC_STAT_NOT_READY",
77 [SNIC_STAT_FATAL_ERROR] = "SNIC_STAT_FATAL_ERROR",
78 };
79
80 static void snic_scsi_cleanup(struct snic *, int);
81
82 const char *
83 snic_state_to_str(unsigned int state)
84 {
85 if (state >= ARRAY_SIZE(snic_state_str) || !snic_state_str[state])
86 return "Unknown";
87
88 return snic_state_str[state];
89 }
90
91 static const char *
92 snic_io_status_to_str(unsigned int state)
93 {
94 if ((state >= ARRAY_SIZE(snic_io_status_str)) ||
95 (!snic_io_status_str[state]))
96 return "Unknown";
97
98 return snic_io_status_str[state];
99 }
100
101 static const char *
102 snic_ioreq_state_to_str(unsigned int state)
103 {
104 if (state >= ARRAY_SIZE(snic_req_state_str) ||
105 !snic_req_state_str[state])
106 return "Unknown";
107
108 return snic_req_state_str[state];
109 }
110
111 static inline spinlock_t *
112 snic_io_lock_hash(struct snic *snic, struct scsi_cmnd *sc)
113 {
114 u32 hash = snic_cmd_tag(sc) & (SNIC_IO_LOCKS - 1);
115
116 return &snic->io_req_lock[hash];
117 }
118
119 static inline spinlock_t *
120 snic_io_lock_tag(struct snic *snic, int tag)
121 {
122 return &snic->io_req_lock[tag & (SNIC_IO_LOCKS - 1)];
123 }
124
125 /* snic_release_req_buf : Releases snic_req_info */
126 static void
127 snic_release_req_buf(struct snic *snic,
128 struct snic_req_info *rqi,
129 struct scsi_cmnd *sc)
130 {
131 struct snic_host_req *req = rqi_to_req(rqi);
132
133 /* Freeing cmd without marking completion, not okay */
134 SNIC_BUG_ON(!((CMD_STATE(sc) == SNIC_IOREQ_COMPLETE) ||
135 (CMD_STATE(sc) == SNIC_IOREQ_ABTS_COMPLETE) ||
136 (CMD_FLAGS(sc) & SNIC_DEV_RST_NOTSUP) ||
137 (CMD_FLAGS(sc) & SNIC_IO_INTERNAL_TERM_ISSUED) ||
138 (CMD_FLAGS(sc) & SNIC_DEV_RST_TERM_ISSUED) ||
139 (CMD_FLAGS(sc) & SNIC_SCSI_CLEANUP) ||
140 (CMD_STATE(sc) == SNIC_IOREQ_LR_COMPLETE)));
141
142 SNIC_SCSI_DBG(snic->shost,
143 "Rel_req:sc %p:tag %x:rqi %p:ioreq %p:abt %p:dr %p: state %s:flags 0x%llx\n",
144 sc, snic_cmd_tag(sc), rqi, rqi->req, rqi->abort_req,
145 rqi->dr_req, snic_ioreq_state_to_str(CMD_STATE(sc)),
146 CMD_FLAGS(sc));
147
148 if (req->u.icmnd.sense_addr)
149 pci_unmap_single(snic->pdev,
150 le64_to_cpu(req->u.icmnd.sense_addr),
151 SCSI_SENSE_BUFFERSIZE,
152 PCI_DMA_FROMDEVICE);
153
154 scsi_dma_unmap(sc);
155
156 snic_req_free(snic, rqi);
157 } /* end of snic_release_req_buf */
158
159 /*
160 * snic_queue_icmnd_req : Queues snic_icmnd request
161 */
162 static int
163 snic_queue_icmnd_req(struct snic *snic,
164 struct snic_req_info *rqi,
165 struct scsi_cmnd *sc,
166 int sg_cnt)
167 {
168 struct scatterlist *sg;
169 struct snic_sg_desc *sgd;
170 dma_addr_t pa = 0;
171 struct scsi_lun lun;
172 u16 flags = 0;
173 int ret = 0;
174 unsigned int i;
175
176 if (sg_cnt) {
177 flags = SNIC_ICMND_ESGL;
178 sgd = (struct snic_sg_desc *) req_to_sgl(rqi->req);
179
180 for_each_sg(scsi_sglist(sc), sg, sg_cnt, i) {
181 sgd->addr = cpu_to_le64(sg_dma_address(sg));
182 sgd->len = cpu_to_le32(sg_dma_len(sg));
183 sgd->_resvd = 0;
184 sgd++;
185 }
186 }
187
188 pa = pci_map_single(snic->pdev,
189 sc->sense_buffer,
190 SCSI_SENSE_BUFFERSIZE,
191 PCI_DMA_FROMDEVICE);
192
193 if (pci_dma_mapping_error(snic->pdev, pa)) {
194 SNIC_HOST_ERR(snic->shost,
195 "QIcmnd:PCI Map Failed for sns buf %p tag %x\n",
196 sc->sense_buffer, snic_cmd_tag(sc));
197 ret = -ENOMEM;
198
199 return ret;
200 }
201
202 int_to_scsilun(sc->device->lun, &lun);
203 if (sc->sc_data_direction == DMA_FROM_DEVICE)
204 flags |= SNIC_ICMND_RD;
205 if (sc->sc_data_direction == DMA_TO_DEVICE)
206 flags |= SNIC_ICMND_WR;
207
208 /* Initialize icmnd */
209 snic_icmnd_init(rqi->req,
210 snic_cmd_tag(sc),
211 snic->config.hid, /* hid */
212 (ulong) rqi,
213 flags, /* command flags */
214 rqi->tgt_id,
215 lun.scsi_lun,
216 sc->cmnd,
217 sc->cmd_len,
218 scsi_bufflen(sc),
219 sg_cnt,
220 (ulong) req_to_sgl(rqi->req),
221 pa, /* sense buffer pa */
222 SCSI_SENSE_BUFFERSIZE);
223
224 atomic64_inc(&snic->s_stats.io.active);
225 ret = snic_queue_wq_desc(snic, rqi->req, rqi->req_len);
226 if (ret) {
227 atomic64_dec(&snic->s_stats.io.active);
228 SNIC_HOST_ERR(snic->shost,
229 "QIcmnd: Queuing Icmnd Failed. ret = %d\n",
230 ret);
231 } else
232 snic_stats_update_active_ios(&snic->s_stats);
233
234 return ret;
235 } /* end of snic_queue_icmnd_req */
236
237 /*
238 * snic_issue_scsi_req : Prepares IO request and Issues to FW.
239 */
240 static int
241 snic_issue_scsi_req(struct snic *snic,
242 struct snic_tgt *tgt,
243 struct scsi_cmnd *sc)
244 {
245 struct snic_req_info *rqi = NULL;
246 int sg_cnt = 0;
247 int ret = 0;
248 u32 tag = snic_cmd_tag(sc);
249 u64 cmd_trc = 0, cmd_st_flags = 0;
250 spinlock_t *io_lock = NULL;
251 unsigned long flags;
252
253 CMD_STATE(sc) = SNIC_IOREQ_NOT_INITED;
254 CMD_FLAGS(sc) = SNIC_NO_FLAGS;
255 sg_cnt = scsi_dma_map(sc);
256 if (sg_cnt < 0) {
257 SNIC_TRC((u16)snic->shost->host_no, tag, (ulong) sc, 0,
258 sc->cmnd[0], sg_cnt, CMD_STATE(sc));
259
260 SNIC_HOST_ERR(snic->shost, "issue_sc:Failed to map SG List.\n");
261 ret = -ENOMEM;
262
263 goto issue_sc_end;
264 }
265
266 rqi = snic_req_init(snic, sg_cnt);
267 if (!rqi) {
268 scsi_dma_unmap(sc);
269 ret = -ENOMEM;
270
271 goto issue_sc_end;
272 }
273
274 rqi->tgt_id = tgt->id;
275 rqi->sc = sc;
276
277 CMD_STATE(sc) = SNIC_IOREQ_PENDING;
278 CMD_SP(sc) = (char *) rqi;
279 cmd_trc = SNIC_TRC_CMD(sc);
280 CMD_FLAGS(sc) |= (SNIC_IO_INITIALIZED | SNIC_IO_ISSUED);
281 cmd_st_flags = SNIC_TRC_CMD_STATE_FLAGS(sc);
282 io_lock = snic_io_lock_hash(snic, sc);
283
284 /* create wq desc and enqueue it */
285 ret = snic_queue_icmnd_req(snic, rqi, sc, sg_cnt);
286 if (ret) {
287 SNIC_HOST_ERR(snic->shost,
288 "issue_sc: icmnd qing Failed for sc %p, err %d\n",
289 sc, ret);
290
291 spin_lock_irqsave(io_lock, flags);
292 rqi = (struct snic_req_info *) CMD_SP(sc);
293 CMD_SP(sc) = NULL;
294 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE;
295 CMD_FLAGS(sc) &= ~SNIC_IO_ISSUED; /* turn off the flag */
296 spin_unlock_irqrestore(io_lock, flags);
297
298 if (rqi)
299 snic_release_req_buf(snic, rqi, sc);
300
301 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 0, 0, 0,
302 SNIC_TRC_CMD_STATE_FLAGS(sc));
303 } else {
304 u32 io_sz = scsi_bufflen(sc) >> 9;
305 u32 qtime = jiffies - rqi->start_time;
306 struct snic_io_stats *iostats = &snic->s_stats.io;
307
308 if (io_sz > atomic64_read(&iostats->max_io_sz))
309 atomic64_set(&iostats->max_io_sz, io_sz);
310
311 if (qtime > atomic64_read(&iostats->max_qtime))
312 atomic64_set(&iostats->max_qtime, qtime);
313
314 SNIC_SCSI_DBG(snic->shost,
315 "issue_sc:sc %p, tag %d queued to WQ.\n",
316 sc, tag);
317
318 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, (ulong) rqi,
319 sg_cnt, cmd_trc, cmd_st_flags);
320 }
321
322 issue_sc_end:
323
324 return ret;
325 } /* end of snic_issue_scsi_req */
326
327
328 /*
329 * snic_queuecommand
330 * Routine to send a scsi cdb to LLD
331 * Called with host_lock held and interrupts disabled
332 */
333 int
334 snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
335 {
336 struct snic_tgt *tgt = NULL;
337 struct snic *snic = shost_priv(shost);
338 int ret;
339
340 tgt = starget_to_tgt(scsi_target(sc->device));
341 ret = snic_tgt_chkready(tgt);
342 if (ret) {
343 SNIC_HOST_ERR(shost, "Tgt %p id %d Not Ready.\n", tgt, tgt->id);
344 atomic64_inc(&snic->s_stats.misc.tgt_not_rdy);
345 sc->result = ret;
346 sc->scsi_done(sc);
347
348 return 0;
349 }
350
351 if (snic_get_state(snic) != SNIC_ONLINE) {
352 SNIC_HOST_ERR(shost, "snic state is %s\n",
353 snic_state_str[snic_get_state(snic)]);
354
355 return SCSI_MLQUEUE_HOST_BUSY;
356 }
357 atomic_inc(&snic->ios_inflight);
358
359 SNIC_SCSI_DBG(shost, "sc %p Tag %d (sc %0x) lun %lld in snic_qcmd\n",
360 sc, snic_cmd_tag(sc), sc->cmnd[0], sc->device->lun);
361
362 ret = snic_issue_scsi_req(snic, tgt, sc);
363 if (ret) {
364 SNIC_HOST_ERR(shost, "Failed to Q, Scsi Req w/ err %d.\n", ret);
365 ret = SCSI_MLQUEUE_HOST_BUSY;
366 }
367
368 atomic_dec(&snic->ios_inflight);
369
370 return ret;
371 } /* end of snic_queuecommand */
372
373 /*
374 * snic_process_abts_pending_state:
375 * caller should hold IO lock
376 */
377 static void
378 snic_proc_tmreq_pending_state(struct snic *snic,
379 struct scsi_cmnd *sc,
380 u8 cmpl_status)
381 {
382 int state = CMD_STATE(sc);
383
384 if (state == SNIC_IOREQ_ABTS_PENDING)
385 CMD_FLAGS(sc) |= SNIC_IO_ABTS_PENDING;
386 else if (state == SNIC_IOREQ_LR_PENDING)
387 CMD_FLAGS(sc) |= SNIC_DEV_RST_PENDING;
388 else
389 SNIC_BUG_ON(1);
390
391 switch (cmpl_status) {
392 case SNIC_STAT_IO_SUCCESS:
393 CMD_FLAGS(sc) |= SNIC_IO_DONE;
394 break;
395
396 case SNIC_STAT_ABORTED:
397 CMD_FLAGS(sc) |= SNIC_IO_ABORTED;
398 break;
399
400 default:
401 SNIC_BUG_ON(1);
402 }
403 }
404
405 /*
406 * snic_process_io_failed_state:
407 * Processes IO's error states
408 */
409 static void
410 snic_process_io_failed_state(struct snic *snic,
411 struct snic_icmnd_cmpl *icmnd_cmpl,
412 struct scsi_cmnd *sc,
413 u8 cmpl_stat)
414 {
415 int res = 0;
416
417 switch (cmpl_stat) {
418 case SNIC_STAT_TIMEOUT: /* Req was timedout */
419 atomic64_inc(&snic->s_stats.misc.io_tmo);
420 res = DID_TIME_OUT;
421 break;
422
423 case SNIC_STAT_ABORTED: /* Req was aborted */
424 atomic64_inc(&snic->s_stats.misc.io_aborted);
425 res = DID_ABORT;
426 break;
427
428 case SNIC_STAT_DATA_CNT_MISMATCH:/* Recv/Sent more/less data than exp */
429 atomic64_inc(&snic->s_stats.misc.data_cnt_mismat);
430 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid));
431 res = DID_ERROR;
432 break;
433
434 case SNIC_STAT_OUT_OF_RES: /* Out of resources to complete request */
435 atomic64_inc(&snic->s_stats.fw.out_of_res);
436 res = DID_REQUEUE;
437 break;
438
439 case SNIC_STAT_IO_NOT_FOUND: /* Requested I/O was not found */
440 atomic64_inc(&snic->s_stats.io.io_not_found);
441 res = DID_ERROR;
442 break;
443
444 case SNIC_STAT_SGL_INVALID: /* Req was aborted to due to sgl error*/
445 atomic64_inc(&snic->s_stats.misc.sgl_inval);
446 res = DID_ERROR;
447 break;
448
449 case SNIC_STAT_FW_ERR: /* Req terminated due to FW Error */
450 atomic64_inc(&snic->s_stats.fw.io_errs);
451 res = DID_ERROR;
452 break;
453
454 case SNIC_STAT_SCSI_ERR: /* FW hits SCSI Error */
455 atomic64_inc(&snic->s_stats.fw.scsi_errs);
456 break;
457
458 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */
459 case SNIC_STAT_DEV_OFFLINE: /* Device offline */
460 res = DID_NO_CONNECT;
461 break;
462
463 case SNIC_STAT_INVALID_HDR: /* Hdr contains invalid data */
464 case SNIC_STAT_INVALID_PARM: /* Some param in req is invalid */
465 case SNIC_STAT_REQ_NOT_SUP: /* Req type is not supported */
466 case SNIC_STAT_CMND_REJECT: /* Req rejected */
467 case SNIC_STAT_FATAL_ERROR: /* XPT Error */
468 default:
469 SNIC_SCSI_DBG(snic->shost,
470 "Invalid Hdr/Param or Req Not Supported or Cmnd Rejected or Device Offline. or Unknown\n");
471 res = DID_ERROR;
472 break;
473 }
474
475 SNIC_HOST_ERR(snic->shost, "fw returns failed status %s flags 0x%llx\n",
476 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc));
477
478 /* Set sc->result */
479 sc->result = (res << 16) | icmnd_cmpl->scsi_status;
480 } /* end of snic_process_io_failed_state */
481
482 /*
483 * snic_tmreq_pending : is task management in progress.
484 */
485 static int
486 snic_tmreq_pending(struct scsi_cmnd *sc)
487 {
488 int state = CMD_STATE(sc);
489
490 return ((state == SNIC_IOREQ_ABTS_PENDING) ||
491 (state == SNIC_IOREQ_LR_PENDING));
492 }
493
494 /*
495 * snic_process_icmnd_cmpl_status:
496 * Caller should hold io_lock
497 */
498 static int
499 snic_process_icmnd_cmpl_status(struct snic *snic,
500 struct snic_icmnd_cmpl *icmnd_cmpl,
501 u8 cmpl_stat,
502 struct scsi_cmnd *sc)
503 {
504 u8 scsi_stat = icmnd_cmpl->scsi_status;
505 u64 xfer_len = 0;
506 int ret = 0;
507
508 /* Mark the IO as complete */
509 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE;
510
511 if (likely(cmpl_stat == SNIC_STAT_IO_SUCCESS)) {
512 sc->result = (DID_OK << 16) | scsi_stat;
513
514 xfer_len = scsi_bufflen(sc);
515
516 /* Update SCSI Cmd with resid value */
517 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid));
518
519 if (icmnd_cmpl->flags & SNIC_ICMND_CMPL_UNDR_RUN) {
520 xfer_len -= le32_to_cpu(icmnd_cmpl->resid);
521 atomic64_inc(&snic->s_stats.misc.io_under_run);
522 }
523
524 if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL)
525 atomic64_inc(&snic->s_stats.misc.qfull);
526
527 ret = 0;
528 } else {
529 snic_process_io_failed_state(snic, icmnd_cmpl, sc, cmpl_stat);
530 atomic64_inc(&snic->s_stats.io.fail);
531 SNIC_HOST_ERR(snic->shost,
532 "icmnd_cmpl: IO Failed : Hdr Status %s flags 0x%llx\n",
533 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc));
534 ret = 1;
535 }
536
537 return ret;
538 } /* end of snic_process_icmnd_cmpl_status */
539
540
541 /*
542 * snic_icmnd_cmpl_handler
543 * Routine to handle icmnd completions
544 */
545 static void
546 snic_icmnd_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
547 {
548 u8 typ, hdr_stat;
549 u32 cmnd_id, hid;
550 ulong ctx;
551 struct scsi_cmnd *sc = NULL;
552 struct snic_icmnd_cmpl *icmnd_cmpl = NULL;
553 struct snic_host_req *req = NULL;
554 struct snic_req_info *rqi = NULL;
555 unsigned long flags, start_time;
556 spinlock_t *io_lock;
557 u8 sc_stat = 0;
558
559 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
560 icmnd_cmpl = &fwreq->u.icmnd_cmpl;
561 sc_stat = icmnd_cmpl->scsi_status;
562
563 SNIC_SCSI_DBG(snic->shost,
564 "Icmnd_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,i ctx = %lx\n",
565 typ, hdr_stat, cmnd_id, hid, ctx);
566
567 if (cmnd_id >= snic->max_tag_id) {
568 SNIC_HOST_ERR(snic->shost,
569 "Icmnd_cmpl:Tag Error:Out of Range Tag %d, hdr status = %s\n",
570 cmnd_id, snic_io_status_to_str(hdr_stat));
571 return;
572 }
573
574 sc = scsi_host_find_tag(snic->shost, cmnd_id);
575 WARN_ON_ONCE(!sc);
576
577 if (!sc) {
578 atomic64_inc(&snic->s_stats.io.sc_null);
579 SNIC_HOST_ERR(snic->shost,
580 "Icmnd_cmpl: Scsi Cmnd Not found, sc = NULL Hdr Status = %s tag = 0x%x fwreq = 0x%p\n",
581 snic_io_status_to_str(hdr_stat),
582 cmnd_id,
583 fwreq);
584
585 SNIC_TRC(snic->shost->host_no, cmnd_id, 0,
586 ((u64)hdr_stat << 16 |
587 (u64)sc_stat << 8 | (u64)icmnd_cmpl->flags),
588 (ulong) fwreq, le32_to_cpu(icmnd_cmpl->resid), ctx);
589
590 return;
591 }
592
593 io_lock = snic_io_lock_hash(snic, sc);
594
595 spin_lock_irqsave(io_lock, flags);
596 rqi = (struct snic_req_info *) CMD_SP(sc);
597 SNIC_SCSI_DBG(snic->shost,
598 "Icmnd_cmpl:lun %lld sc %p cmd %xtag %d flags 0x%llx rqi %p\n",
599 sc->device->lun, sc, sc->cmnd[0], snic_cmd_tag(sc),
600 CMD_FLAGS(sc), rqi);
601
602 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) {
603 spin_unlock_irqrestore(io_lock, flags);
604
605 return;
606 }
607
608 SNIC_BUG_ON(rqi != (struct snic_req_info *)ctx);
609 WARN_ON_ONCE(req);
610 if (!rqi) {
611 atomic64_inc(&snic->s_stats.io.req_null);
612 CMD_FLAGS(sc) |= SNIC_IO_REQ_NULL;
613 spin_unlock_irqrestore(io_lock, flags);
614
615 SNIC_HOST_ERR(snic->shost,
616 "Icmnd_cmpl:Host Req Not Found(null), Hdr Status %s, Tag 0x%x, sc 0x%p flags 0x%llx\n",
617 snic_io_status_to_str(hdr_stat),
618 cmnd_id, sc, CMD_FLAGS(sc));
619 return;
620 }
621
622 rqi = (struct snic_req_info *) ctx;
623 start_time = rqi->start_time;
624
625 /* firmware completed the io */
626 rqi->io_cmpl = 1;
627
628 /*
629 * if SCSI-ML has already issued abort on this command,
630 * ignore completion of the IO. The abts path will clean it up
631 */
632 if (unlikely(snic_tmreq_pending(sc))) {
633 snic_proc_tmreq_pending_state(snic, sc, hdr_stat);
634 spin_unlock_irqrestore(io_lock, flags);
635
636 snic_stats_update_io_cmpl(&snic->s_stats);
637
638 /* Expected value is SNIC_STAT_ABORTED */
639 if (likely(hdr_stat == SNIC_STAT_ABORTED))
640 return;
641
642 SNIC_SCSI_DBG(snic->shost,
643 "icmnd_cmpl:TM Req Pending(%s), Hdr Status %s sc 0x%p scsi status %x resid %d flags 0x%llx\n",
644 snic_ioreq_state_to_str(CMD_STATE(sc)),
645 snic_io_status_to_str(hdr_stat),
646 sc, sc_stat, le32_to_cpu(icmnd_cmpl->resid),
647 CMD_FLAGS(sc));
648
649 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
650 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq,
651 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
652
653 return;
654 }
655
656 if (snic_process_icmnd_cmpl_status(snic, icmnd_cmpl, hdr_stat, sc)) {
657 scsi_print_command(sc);
658 SNIC_HOST_ERR(snic->shost,
659 "icmnd_cmpl:IO Failed, sc 0x%p Tag %d Cmd %x Hdr Status %s flags 0x%llx\n",
660 sc, sc->cmnd[0], cmnd_id,
661 snic_io_status_to_str(hdr_stat), CMD_FLAGS(sc));
662 }
663
664 /* Break link with the SCSI Command */
665 CMD_SP(sc) = NULL;
666 CMD_FLAGS(sc) |= SNIC_IO_DONE;
667
668 spin_unlock_irqrestore(io_lock, flags);
669
670 /* For now, consider only successful IO. */
671 snic_calc_io_process_time(snic, rqi);
672
673 snic_release_req_buf(snic, rqi, sc);
674
675 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
676 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq,
677 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
678
679
680 if (sc->scsi_done)
681 sc->scsi_done(sc);
682
683 snic_stats_update_io_cmpl(&snic->s_stats);
684 } /* end of snic_icmnd_cmpl_handler */
685
686 static void
687 snic_proc_dr_cmpl_locked(struct snic *snic,
688 struct snic_fw_req *fwreq,
689 u8 cmpl_stat,
690 u32 cmnd_id,
691 struct scsi_cmnd *sc)
692 {
693 struct snic_req_info *rqi = (struct snic_req_info *) CMD_SP(sc);
694 u32 start_time = rqi->start_time;
695
696 CMD_LR_STATUS(sc) = cmpl_stat;
697
698 SNIC_SCSI_DBG(snic->shost, "itmf_cmpl: Cmd State = %s\n",
699 snic_ioreq_state_to_str(CMD_STATE(sc)));
700
701 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
702 CMD_FLAGS(sc) |= SNIC_DEV_RST_ABTS_PENDING;
703
704 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
705 jiffies_to_msecs(jiffies - start_time),
706 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc));
707
708 SNIC_SCSI_DBG(snic->shost,
709 "itmf_cmpl: Terminate Pending Dev Reset Cmpl Recvd.id %x, status %s flags 0x%llx\n",
710 (int)(cmnd_id & SNIC_TAG_MASK),
711 snic_io_status_to_str(cmpl_stat),
712 CMD_FLAGS(sc));
713
714 return;
715 }
716
717
718 if (CMD_FLAGS(sc) & SNIC_DEV_RST_TIMEDOUT) {
719 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
720 jiffies_to_msecs(jiffies - start_time),
721 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc));
722
723 SNIC_SCSI_DBG(snic->shost,
724 "itmf_cmpl:Dev Reset Completion Received after timeout. id %d cmpl status %s flags 0x%llx\n",
725 (int)(cmnd_id & SNIC_TAG_MASK),
726 snic_io_status_to_str(cmpl_stat),
727 CMD_FLAGS(sc));
728
729 return;
730 }
731
732 CMD_STATE(sc) = SNIC_IOREQ_LR_COMPLETE;
733 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE;
734
735 SNIC_SCSI_DBG(snic->shost,
736 "itmf_cmpl:Dev Reset Cmpl Recvd id %d cmpl status %s flags 0x%llx\n",
737 (int)(cmnd_id & SNIC_TAG_MASK),
738 snic_io_status_to_str(cmpl_stat),
739 CMD_FLAGS(sc));
740
741 if (rqi->dr_done)
742 complete(rqi->dr_done);
743 } /* end of snic_proc_dr_cmpl_locked */
744
745 /*
746 * snic_update_abort_stats : Updates abort stats based on completion status.
747 */
748 static void
749 snic_update_abort_stats(struct snic *snic, u8 cmpl_stat)
750 {
751 struct snic_abort_stats *abt_stats = &snic->s_stats.abts;
752
753 SNIC_SCSI_DBG(snic->shost, "Updating Abort stats.\n");
754
755 switch (cmpl_stat) {
756 case SNIC_STAT_IO_SUCCESS:
757 break;
758
759 case SNIC_STAT_TIMEOUT:
760 atomic64_inc(&abt_stats->fw_tmo);
761 break;
762
763 case SNIC_STAT_IO_NOT_FOUND:
764 atomic64_inc(&abt_stats->io_not_found);
765 break;
766
767 default:
768 atomic64_inc(&abt_stats->fail);
769 break;
770 }
771 }
772
773 static int
774 snic_process_itmf_cmpl(struct snic *snic,
775 struct snic_fw_req *fwreq,
776 u32 cmnd_id,
777 u8 cmpl_stat,
778 struct scsi_cmnd *sc)
779 {
780 struct snic_req_info *rqi = NULL;
781 u32 tm_tags = 0;
782 spinlock_t *io_lock = NULL;
783 unsigned long flags;
784 u32 start_time = 0;
785 int ret = 0;
786
787 io_lock = snic_io_lock_hash(snic, sc);
788 spin_lock_irqsave(io_lock, flags);
789 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) {
790 spin_unlock_irqrestore(io_lock, flags);
791
792 return ret;
793 }
794 rqi = (struct snic_req_info *) CMD_SP(sc);
795 WARN_ON_ONCE(!rqi);
796
797 if (!rqi) {
798 atomic64_inc(&snic->s_stats.io.req_null);
799 spin_unlock_irqrestore(io_lock, flags);
800 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
801 SNIC_HOST_ERR(snic->shost,
802 "itmf_cmpl: rqi is null,Hdr stat = %s Tag = 0x%x sc = 0x%p flags 0x%llx\n",
803 snic_io_status_to_str(cmpl_stat), cmnd_id, sc,
804 CMD_FLAGS(sc));
805
806 return ret;
807 }
808
809 /* Extract task management flags */
810 tm_tags = cmnd_id & ~(SNIC_TAG_MASK);
811
812 start_time = rqi->start_time;
813 cmnd_id &= (SNIC_TAG_MASK);
814
815 switch (tm_tags) {
816 case SNIC_TAG_ABORT:
817 /* Abort only issued on cmd */
818 snic_update_abort_stats(snic, cmpl_stat);
819
820 if (CMD_STATE(sc) != SNIC_IOREQ_ABTS_PENDING) {
821 /* This is a late completion. Ignore it. */
822 ret = -1;
823 spin_unlock_irqrestore(io_lock, flags);
824 break;
825 }
826
827 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
828 CMD_ABTS_STATUS(sc) = cmpl_stat;
829 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE;
830
831 SNIC_SCSI_DBG(snic->shost,
832 "itmf_cmpl:Abort Cmpl Recvd.Tag 0x%x Status %s flags 0x%llx\n",
833 cmnd_id,
834 snic_io_status_to_str(cmpl_stat),
835 CMD_FLAGS(sc));
836
837 /*
838 * If scsi_eh thread is blocked waiting for abts complete,
839 * signal completion to it. IO will be cleaned in the thread,
840 * else clean it in this context.
841 */
842 if (rqi->abts_done) {
843 complete(rqi->abts_done);
844 spin_unlock_irqrestore(io_lock, flags);
845
846 break; /* jump out */
847 }
848
849 CMD_SP(sc) = NULL;
850 sc->result = (DID_ERROR << 16);
851 SNIC_SCSI_DBG(snic->shost,
852 "itmf_cmpl: Completing IO. sc %p flags 0x%llx\n",
853 sc, CMD_FLAGS(sc));
854
855 spin_unlock_irqrestore(io_lock, flags);
856
857 snic_release_req_buf(snic, rqi, sc);
858
859 if (sc->scsi_done) {
860 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
861 jiffies_to_msecs(jiffies - start_time),
862 (ulong) fwreq, SNIC_TRC_CMD(sc),
863 SNIC_TRC_CMD_STATE_FLAGS(sc));
864
865 sc->scsi_done(sc);
866 }
867
868 break;
869
870 case SNIC_TAG_DEV_RST:
871 case SNIC_TAG_DEV_RST | SNIC_TAG_IOCTL_DEV_RST:
872 snic_proc_dr_cmpl_locked(snic, fwreq, cmpl_stat, cmnd_id, sc);
873 spin_unlock_irqrestore(io_lock, flags);
874 ret = 0;
875
876 break;
877
878 case SNIC_TAG_ABORT | SNIC_TAG_DEV_RST:
879 /* Abort and terminate completion of device reset req */
880
881 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
882 CMD_ABTS_STATUS(sc) = cmpl_stat;
883 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE;
884
885 SNIC_SCSI_DBG(snic->shost,
886 "itmf_cmpl:dev reset abts cmpl recvd. id %d status %s flags 0x%llx\n",
887 cmnd_id, snic_io_status_to_str(cmpl_stat),
888 CMD_FLAGS(sc));
889
890 if (rqi->abts_done)
891 complete(rqi->abts_done);
892
893 spin_unlock_irqrestore(io_lock, flags);
894
895 break;
896
897 default:
898 spin_unlock_irqrestore(io_lock, flags);
899 SNIC_HOST_ERR(snic->shost,
900 "itmf_cmpl: Unknown TM tag bit 0x%x\n", tm_tags);
901
902 SNIC_HOST_ERR(snic->shost,
903 "itmf_cmpl:Unexpected itmf io stat %s Tag = 0x%x flags 0x%llx\n",
904 snic_ioreq_state_to_str(CMD_STATE(sc)),
905 cmnd_id,
906 CMD_FLAGS(sc));
907 ret = -1;
908 SNIC_BUG_ON(1);
909
910 break;
911 }
912
913 return ret;
914 } /* end of snic_process_itmf_cmpl_status */
915
916 /*
917 * snic_itmf_cmpl_handler.
918 * Routine to handle itmf completions.
919 */
920 static void
921 snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
922 {
923 struct scsi_cmnd *sc = NULL;
924 struct snic_req_info *rqi = NULL;
925 struct snic_itmf_cmpl *itmf_cmpl = NULL;
926 ulong ctx;
927 u32 cmnd_id;
928 u32 hid;
929 u8 typ;
930 u8 hdr_stat;
931
932 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
933 SNIC_SCSI_DBG(snic->shost,
934 "Itmf_cmpl: %s: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,ctx = %lx\n",
935 __func__, typ, hdr_stat, cmnd_id, hid, ctx);
936
937 itmf_cmpl = &fwreq->u.itmf_cmpl;
938 SNIC_SCSI_DBG(snic->shost,
939 "Itmf_cmpl: nterm %u , flags 0x%x\n",
940 le32_to_cpu(itmf_cmpl->nterminated), itmf_cmpl->flags);
941
942 /* spl case, dev reset issued through ioctl */
943 if (cmnd_id & SNIC_TAG_IOCTL_DEV_RST) {
944 rqi = (struct snic_req_info *) ctx;
945 sc = rqi->sc;
946
947 goto ioctl_dev_rst;
948 }
949
950 if ((cmnd_id & SNIC_TAG_MASK) >= snic->max_tag_id) {
951 SNIC_HOST_ERR(snic->shost,
952 "Itmf_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
953 cmnd_id, snic_io_status_to_str(hdr_stat));
954 SNIC_BUG_ON(1);
955
956 return;
957 }
958
959 sc = scsi_host_find_tag(snic->shost, cmnd_id & SNIC_TAG_MASK);
960 WARN_ON_ONCE(!sc);
961
962 ioctl_dev_rst:
963 if (!sc) {
964 atomic64_inc(&snic->s_stats.io.sc_null);
965 SNIC_HOST_ERR(snic->shost,
966 "Itmf_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n",
967 snic_io_status_to_str(hdr_stat), cmnd_id);
968
969 return;
970 }
971
972 snic_process_itmf_cmpl(snic, fwreq, cmnd_id, hdr_stat, sc);
973 } /* end of snic_itmf_cmpl_handler */
974
975
976
977 static void
978 snic_hba_reset_scsi_cleanup(struct snic *snic, struct scsi_cmnd *sc)
979 {
980 struct snic_stats *st = &snic->s_stats;
981 long act_ios = 0, act_fwreqs = 0;
982
983 SNIC_SCSI_DBG(snic->shost, "HBA Reset scsi cleanup.\n");
984 snic_scsi_cleanup(snic, snic_cmd_tag(sc));
985
986 /* Update stats on pending IOs */
987 act_ios = atomic64_read(&st->io.active);
988 atomic64_add(act_ios, &st->io.compl);
989 atomic64_sub(act_ios, &st->io.active);
990
991 act_fwreqs = atomic64_read(&st->fw.actv_reqs);
992 atomic64_sub(act_fwreqs, &st->fw.actv_reqs);
993 }
994
995 /*
996 * snic_hba_reset_cmpl_handler :
997 *
998 * Notes :
999 * 1. Cleanup all the scsi cmds, release all snic specific cmds
1000 * 2. Issue Report Targets in case of SAN targets
1001 */
1002 static int
1003 snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
1004 {
1005 ulong ctx;
1006 u32 cmnd_id;
1007 u32 hid;
1008 u8 typ;
1009 u8 hdr_stat;
1010 struct scsi_cmnd *sc = NULL;
1011 struct snic_req_info *rqi = NULL;
1012 spinlock_t *io_lock = NULL;
1013 unsigned long flags, gflags;
1014 int ret = 0;
1015
1016 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
1017 SNIC_HOST_INFO(snic->shost,
1018 "reset_cmpl:Tag %d ctx %lx cmpl status %s HBA Reset Completion received.\n",
1019 cmnd_id, ctx, snic_io_status_to_str(hdr_stat));
1020
1021 SNIC_SCSI_DBG(snic->shost,
1022 "reset_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n",
1023 typ, hdr_stat, cmnd_id, hid, ctx);
1024
1025 /* spl case, host reset issued through ioctl */
1026 if (cmnd_id == SCSI_NO_TAG) {
1027 rqi = (struct snic_req_info *) ctx;
1028 SNIC_HOST_INFO(snic->shost,
1029 "reset_cmpl:Tag %d ctx %lx cmpl stat %s\n",
1030 cmnd_id, ctx, snic_io_status_to_str(hdr_stat));
1031 sc = rqi->sc;
1032
1033 goto ioctl_hba_rst;
1034 }
1035
1036 if (cmnd_id >= snic->max_tag_id) {
1037 SNIC_HOST_ERR(snic->shost,
1038 "reset_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
1039 cmnd_id, snic_io_status_to_str(hdr_stat));
1040 SNIC_BUG_ON(1);
1041
1042 return 1;
1043 }
1044
1045 sc = scsi_host_find_tag(snic->shost, cmnd_id);
1046 ioctl_hba_rst:
1047 if (!sc) {
1048 atomic64_inc(&snic->s_stats.io.sc_null);
1049 SNIC_HOST_ERR(snic->shost,
1050 "reset_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n",
1051 snic_io_status_to_str(hdr_stat), cmnd_id);
1052 ret = 1;
1053
1054 return ret;
1055 }
1056
1057 SNIC_HOST_INFO(snic->shost,
1058 "reset_cmpl: sc %p rqi %p Tag %d flags 0x%llx\n",
1059 sc, rqi, cmnd_id, CMD_FLAGS(sc));
1060
1061 io_lock = snic_io_lock_hash(snic, sc);
1062 spin_lock_irqsave(io_lock, flags);
1063
1064 if (!snic->remove_wait) {
1065 spin_unlock_irqrestore(io_lock, flags);
1066 SNIC_HOST_ERR(snic->shost,
1067 "reset_cmpl:host reset completed after timeout\n");
1068 ret = 1;
1069
1070 return ret;
1071 }
1072
1073 rqi = (struct snic_req_info *) CMD_SP(sc);
1074 WARN_ON_ONCE(!rqi);
1075
1076 if (!rqi) {
1077 atomic64_inc(&snic->s_stats.io.req_null);
1078 spin_unlock_irqrestore(io_lock, flags);
1079 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1080 SNIC_HOST_ERR(snic->shost,
1081 "reset_cmpl: rqi is null,Hdr stat %s Tag 0x%x sc 0x%p flags 0x%llx\n",
1082 snic_io_status_to_str(hdr_stat), cmnd_id, sc,
1083 CMD_FLAGS(sc));
1084
1085 ret = 1;
1086
1087 return ret;
1088 }
1089 /* stats */
1090 spin_unlock_irqrestore(io_lock, flags);
1091
1092 /* scsi cleanup */
1093 snic_hba_reset_scsi_cleanup(snic, sc);
1094
1095 SNIC_BUG_ON(snic_get_state(snic) != SNIC_OFFLINE &&
1096 snic_get_state(snic) != SNIC_FWRESET);
1097
1098 /* Careful locking between snic_lock and io lock */
1099 spin_lock_irqsave(io_lock, flags);
1100 spin_lock_irqsave(&snic->snic_lock, gflags);
1101 if (snic_get_state(snic) == SNIC_FWRESET)
1102 snic_set_state(snic, SNIC_ONLINE);
1103 spin_unlock_irqrestore(&snic->snic_lock, gflags);
1104
1105 if (snic->remove_wait)
1106 complete(snic->remove_wait);
1107
1108 spin_unlock_irqrestore(io_lock, flags);
1109 atomic64_inc(&snic->s_stats.reset.hba_reset_cmpl);
1110
1111 ret = 0;
1112 /* Rediscovery is for SAN */
1113 if (snic->config.xpt_type == SNIC_DAS)
1114 return ret;
1115
1116 SNIC_SCSI_DBG(snic->shost, "reset_cmpl: Queuing discovery work.\n");
1117 queue_work(snic_glob->event_q, &snic->disc_work);
1118
1119 return ret;
1120 }
1121
1122 static void
1123 snic_msg_ack_handler(struct snic *snic, struct snic_fw_req *fwreq)
1124 {
1125 SNIC_HOST_INFO(snic->shost, "Message Ack Received.\n");
1126
1127 SNIC_ASSERT_NOT_IMPL(1);
1128 }
1129
1130 static void
1131 snic_aen_handler(struct snic *snic, struct snic_fw_req *fwreq)
1132 {
1133 u8 typ, hdr_stat;
1134 u32 cmnd_id, hid;
1135 ulong ctx;
1136 struct snic_async_evnotify *aen = &fwreq->u.async_ev;
1137 u32 event_id = 0;
1138
1139 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
1140 SNIC_SCSI_DBG(snic->shost,
1141 "aen: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n",
1142 typ, hdr_stat, cmnd_id, hid, ctx);
1143
1144 event_id = le32_to_cpu(aen->ev_id);
1145
1146 switch (event_id) {
1147 case SNIC_EV_TGT_OFFLINE:
1148 SNIC_HOST_INFO(snic->shost, "aen:TGT_OFFLINE Event Recvd.\n");
1149 break;
1150
1151 case SNIC_EV_TGT_ONLINE:
1152 SNIC_HOST_INFO(snic->shost, "aen:TGT_ONLINE Event Recvd.\n");
1153 break;
1154
1155 case SNIC_EV_LUN_OFFLINE:
1156 SNIC_HOST_INFO(snic->shost, "aen:LUN_OFFLINE Event Recvd.\n");
1157 break;
1158
1159 case SNIC_EV_LUN_ONLINE:
1160 SNIC_HOST_INFO(snic->shost, "aen:LUN_ONLINE Event Recvd.\n");
1161 break;
1162
1163 case SNIC_EV_CONF_CHG:
1164 SNIC_HOST_INFO(snic->shost, "aen:Config Change Event Recvd.\n");
1165 break;
1166
1167 case SNIC_EV_TGT_ADDED:
1168 SNIC_HOST_INFO(snic->shost, "aen:TGT_ADD Event Recvd.\n");
1169 break;
1170
1171 case SNIC_EV_TGT_DELTD:
1172 SNIC_HOST_INFO(snic->shost, "aen:TGT_DEL Event Recvd.\n");
1173 break;
1174
1175 case SNIC_EV_LUN_ADDED:
1176 SNIC_HOST_INFO(snic->shost, "aen:LUN_ADD Event Recvd.\n");
1177 break;
1178
1179 case SNIC_EV_LUN_DELTD:
1180 SNIC_HOST_INFO(snic->shost, "aen:LUN_DEL Event Recvd.\n");
1181 break;
1182
1183 case SNIC_EV_DISC_CMPL:
1184 SNIC_HOST_INFO(snic->shost, "aen:DISC_CMPL Event Recvd.\n");
1185 break;
1186
1187 default:
1188 SNIC_HOST_INFO(snic->shost, "aen:Unknown Event Recvd.\n");
1189 SNIC_BUG_ON(1);
1190 break;
1191 }
1192
1193 SNIC_ASSERT_NOT_IMPL(1);
1194 } /* end of snic_aen_handler */
1195
1196 /*
1197 * snic_io_cmpl_handler
1198 * Routine to process CQ entries(IO Completions) posted by fw.
1199 */
1200 static int
1201 snic_io_cmpl_handler(struct vnic_dev *vdev,
1202 unsigned int cq_idx,
1203 struct snic_fw_req *fwreq)
1204 {
1205 struct snic *snic = svnic_dev_priv(vdev);
1206 u64 start = jiffies, cmpl_time;
1207
1208 snic_print_desc(__func__, (char *)fwreq, sizeof(*fwreq));
1209
1210 /* Update FW Stats */
1211 if ((fwreq->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL) &&
1212 (fwreq->hdr.type <= SNIC_RSP_BOOT_LUNS_CMPL))
1213 atomic64_dec(&snic->s_stats.fw.actv_reqs);
1214
1215 SNIC_BUG_ON((fwreq->hdr.type > SNIC_RSP_BOOT_LUNS_CMPL) &&
1216 (fwreq->hdr.type < SNIC_MSG_ASYNC_EVNOTIFY));
1217
1218 /* Check for snic subsys errors */
1219 switch (fwreq->hdr.status) {
1220 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */
1221 SNIC_HOST_ERR(snic->shost,
1222 "sNIC SubSystem is NOT Ready.\n");
1223 break;
1224
1225 case SNIC_STAT_FATAL_ERROR: /* XPT Error */
1226 SNIC_HOST_ERR(snic->shost,
1227 "sNIC SubSystem in Unrecoverable State.\n");
1228 break;
1229 }
1230
1231 switch (fwreq->hdr.type) {
1232 case SNIC_RSP_EXCH_VER_CMPL:
1233 snic_io_exch_ver_cmpl_handler(snic, fwreq);
1234 break;
1235
1236 case SNIC_RSP_REPORT_TGTS_CMPL:
1237 snic_report_tgt_cmpl_handler(snic, fwreq);
1238 break;
1239
1240 case SNIC_RSP_ICMND_CMPL:
1241 snic_icmnd_cmpl_handler(snic, fwreq);
1242 break;
1243
1244 case SNIC_RSP_ITMF_CMPL:
1245 snic_itmf_cmpl_handler(snic, fwreq);
1246 break;
1247
1248 case SNIC_RSP_HBA_RESET_CMPL:
1249 snic_hba_reset_cmpl_handler(snic, fwreq);
1250 break;
1251
1252 case SNIC_MSG_ACK:
1253 snic_msg_ack_handler(snic, fwreq);
1254 break;
1255
1256 case SNIC_MSG_ASYNC_EVNOTIFY:
1257 snic_aen_handler(snic, fwreq);
1258 break;
1259
1260 default:
1261 SNIC_BUG_ON(1);
1262 SNIC_SCSI_DBG(snic->shost,
1263 "Unknown Firmware completion request type %d\n",
1264 fwreq->hdr.type);
1265 break;
1266 }
1267
1268 /* Update Stats */
1269 cmpl_time = jiffies - start;
1270 if (cmpl_time > atomic64_read(&snic->s_stats.io.max_cmpl_time))
1271 atomic64_set(&snic->s_stats.io.max_cmpl_time, cmpl_time);
1272
1273 return 0;
1274 } /* end of snic_io_cmpl_handler */
1275
1276 /*
1277 * snic_fwcq_cmpl_handler
1278 * Routine to process fwCQ
1279 * This CQ is independent, and not associated with wq/rq/wq_copy queues
1280 */
1281 int
1282 snic_fwcq_cmpl_handler(struct snic *snic, int io_cmpl_work)
1283 {
1284 unsigned int num_ent = 0; /* number cq entries processed */
1285 unsigned int cq_idx;
1286 unsigned int nent_per_cq;
1287 struct snic_misc_stats *misc_stats = &snic->s_stats.misc;
1288
1289 for (cq_idx = snic->wq_count; cq_idx < snic->cq_count; cq_idx++) {
1290 nent_per_cq = vnic_cq_fw_service(&snic->cq[cq_idx],
1291 snic_io_cmpl_handler,
1292 io_cmpl_work);
1293 num_ent += nent_per_cq;
1294
1295 if (nent_per_cq > atomic64_read(&misc_stats->max_cq_ents))
1296 atomic64_set(&misc_stats->max_cq_ents, nent_per_cq);
1297 }
1298
1299 return num_ent;
1300 } /* end of snic_fwcq_cmpl_handler */
1301
1302 /*
1303 * snic_queue_itmf_req: Common API to queue Task Management requests.
1304 * Use rqi->tm_tag for passing special tags.
1305 * @req_id : aborted request's tag, -1 for lun reset.
1306 */
1307 static int
1308 snic_queue_itmf_req(struct snic *snic,
1309 struct snic_host_req *tmreq,
1310 struct scsi_cmnd *sc,
1311 u32 tmf,
1312 u32 req_id)
1313 {
1314 struct snic_req_info *rqi = req_to_rqi(tmreq);
1315 struct scsi_lun lun;
1316 int tm_tag = snic_cmd_tag(sc) | rqi->tm_tag;
1317 int ret = 0;
1318
1319 SNIC_BUG_ON(!rqi);
1320 SNIC_BUG_ON(!rqi->tm_tag);
1321
1322 /* fill in lun info */
1323 int_to_scsilun(sc->device->lun, &lun);
1324
1325 /* Initialize snic_host_req: itmf */
1326 snic_itmf_init(tmreq,
1327 tm_tag,
1328 snic->config.hid,
1329 (ulong) rqi,
1330 0 /* flags */,
1331 req_id, /* Command to be aborted. */
1332 rqi->tgt_id,
1333 lun.scsi_lun,
1334 tmf);
1335
1336 /*
1337 * In case of multiple aborts on same cmd,
1338 * use try_wait_for_completion and completion_done() to check
1339 * whether it queues aborts even after completion of abort issued
1340 * prior.SNIC_BUG_ON(completion_done(&rqi->done));
1341 */
1342
1343 ret = snic_queue_wq_desc(snic, tmreq, sizeof(*tmreq));
1344 if (ret)
1345 SNIC_HOST_ERR(snic->shost,
1346 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d tag %d Failed, ret = %d\n",
1347 tmf, sc, rqi, req_id, snic_cmd_tag(sc), ret);
1348 else
1349 SNIC_SCSI_DBG(snic->shost,
1350 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d, tag %d (req_id)- Success.",
1351 tmf, sc, rqi, req_id, snic_cmd_tag(sc));
1352
1353 return ret;
1354 } /* end of snic_queue_itmf_req */
1355
1356 static int
1357 snic_issue_tm_req(struct snic *snic,
1358 struct snic_req_info *rqi,
1359 struct scsi_cmnd *sc,
1360 int tmf)
1361 {
1362 struct snic_host_req *tmreq = NULL;
1363 int req_id = 0, tag = snic_cmd_tag(sc);
1364 int ret = 0;
1365
1366 if (snic_get_state(snic) == SNIC_FWRESET)
1367 return -EBUSY;
1368
1369 atomic_inc(&snic->ios_inflight);
1370
1371 SNIC_SCSI_DBG(snic->shost,
1372 "issu_tmreq: Task mgmt req %d. rqi %p w/ tag %x\n",
1373 tmf, rqi, tag);
1374
1375
1376 if (tmf == SNIC_ITMF_LUN_RESET) {
1377 tmreq = snic_dr_req_init(snic, rqi);
1378 req_id = SCSI_NO_TAG;
1379 } else {
1380 tmreq = snic_abort_req_init(snic, rqi);
1381 req_id = tag;
1382 }
1383
1384 if (!tmreq) {
1385 ret = -ENOMEM;
1386
1387 goto tmreq_err;
1388 }
1389
1390 ret = snic_queue_itmf_req(snic, tmreq, sc, tmf, req_id);
1391 if (ret)
1392 goto tmreq_err;
1393
1394 ret = 0;
1395
1396 tmreq_err:
1397 if (ret) {
1398 SNIC_HOST_ERR(snic->shost,
1399 "issu_tmreq: Queing ITMF(%d) Req, sc %p rqi %p req_id %d tag %x fails err = %d\n",
1400 tmf, sc, rqi, req_id, tag, ret);
1401 } else {
1402 SNIC_SCSI_DBG(snic->shost,
1403 "issu_tmreq: Queuing ITMF(%d) Req, sc %p, rqi %p, req_id %d tag %x - Success.\n",
1404 tmf, sc, rqi, req_id, tag);
1405 }
1406
1407 atomic_dec(&snic->ios_inflight);
1408
1409 return ret;
1410 }
1411
1412 /*
1413 * snic_queue_abort_req : Queues abort req to WQ
1414 */
1415 static int
1416 snic_queue_abort_req(struct snic *snic,
1417 struct snic_req_info *rqi,
1418 struct scsi_cmnd *sc,
1419 int tmf)
1420 {
1421 SNIC_SCSI_DBG(snic->shost, "q_abtreq: sc %p, rqi %p, tag %x, tmf %d\n",
1422 sc, rqi, snic_cmd_tag(sc), tmf);
1423
1424 /* Add special tag for abort */
1425 rqi->tm_tag |= SNIC_TAG_ABORT;
1426
1427 return snic_issue_tm_req(snic, rqi, sc, tmf);
1428 }
1429
1430 /*
1431 * snic_abort_finish : called by snic_abort_cmd on queuing abort successfully.
1432 */
1433 static int
1434 snic_abort_finish(struct snic *snic, struct scsi_cmnd *sc)
1435 {
1436 struct snic_req_info *rqi = NULL;
1437 spinlock_t *io_lock = NULL;
1438 unsigned long flags;
1439 int ret = 0, tag = snic_cmd_tag(sc);
1440
1441 io_lock = snic_io_lock_hash(snic, sc);
1442 spin_lock_irqsave(io_lock, flags);
1443 rqi = (struct snic_req_info *) CMD_SP(sc);
1444 if (!rqi) {
1445 atomic64_inc(&snic->s_stats.io.req_null);
1446 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1447
1448 SNIC_SCSI_DBG(snic->shost,
1449 "abt_fini:req info is null tag 0x%x, sc 0x%p flags 0x%llx\n",
1450 tag, sc, CMD_FLAGS(sc));
1451 ret = FAILED;
1452
1453 goto abort_fail;
1454 }
1455
1456 rqi->abts_done = NULL;
1457
1458 ret = FAILED;
1459
1460 /* Check the abort status. */
1461 switch (CMD_ABTS_STATUS(sc)) {
1462 case SNIC_INVALID_CODE:
1463 /* Firmware didn't complete abort req, timedout */
1464 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TIMEDOUT;
1465 atomic64_inc(&snic->s_stats.abts.drv_tmo);
1466 SNIC_SCSI_DBG(snic->shost,
1467 "abt_fini:sc %p Tag %x Driver Timeout.flags 0x%llx\n",
1468 sc, snic_cmd_tag(sc), CMD_FLAGS(sc));
1469 /* do not release snic request in timedout case */
1470 rqi = NULL;
1471
1472 goto abort_fail;
1473
1474 case SNIC_STAT_IO_SUCCESS:
1475 case SNIC_STAT_IO_NOT_FOUND:
1476 ret = SUCCESS;
1477 /*
1478 * If abort path doesn't call scsi_done(),
1479 * the # IO timeouts == 2, will cause the LUN offline.
1480 * Call scsi_done to complete the IO.
1481 */
1482 sc->result = (DID_ERROR << 16);
1483 sc->scsi_done(sc);
1484 break;
1485
1486 default:
1487 /* Firmware completed abort with error */
1488 ret = FAILED;
1489 rqi = NULL;
1490 break;
1491 }
1492
1493 CMD_SP(sc) = NULL;
1494 SNIC_HOST_INFO(snic->shost,
1495 "abt_fini: Tag %x, Cmpl Status %s flags 0x%llx\n",
1496 tag, snic_io_status_to_str(CMD_ABTS_STATUS(sc)),
1497 CMD_FLAGS(sc));
1498
1499 abort_fail:
1500 spin_unlock_irqrestore(io_lock, flags);
1501 if (rqi)
1502 snic_release_req_buf(snic, rqi, sc);
1503
1504 return ret;
1505 } /* end of snic_abort_finish */
1506
1507 /*
1508 * snic_send_abort_and_wait : Issues Abort, and Waits
1509 */
1510 static int
1511 snic_send_abort_and_wait(struct snic *snic, struct scsi_cmnd *sc)
1512 {
1513 struct snic_req_info *rqi = NULL;
1514 enum snic_ioreq_state sv_state;
1515 struct snic_tgt *tgt = NULL;
1516 spinlock_t *io_lock = NULL;
1517 DECLARE_COMPLETION_ONSTACK(tm_done);
1518 unsigned long flags;
1519 int ret = 0, tmf = 0, tag = snic_cmd_tag(sc);
1520
1521 tgt = starget_to_tgt(scsi_target(sc->device));
1522 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN))
1523 tmf = SNIC_ITMF_ABTS_TASK_TERM;
1524 else
1525 tmf = SNIC_ITMF_ABTS_TASK;
1526
1527 /* stats */
1528
1529 io_lock = snic_io_lock_hash(snic, sc);
1530
1531 /*
1532 * Avoid a race between SCSI issuing the abort and the device
1533 * completing the command.
1534 *
1535 * If the command is already completed by fw_cmpl code,
1536 * we just return SUCCESS from here. This means that the abort
1537 * succeeded. In the SCSI ML, since the timeout for command has
1538 * happend, the completion wont actually complete the command
1539 * and it will be considered as an aborted command
1540 *
1541 * The CMD_SP will not be cleared except while holding io_lock
1542 */
1543 spin_lock_irqsave(io_lock, flags);
1544 rqi = (struct snic_req_info *) CMD_SP(sc);
1545 if (!rqi) {
1546 spin_unlock_irqrestore(io_lock, flags);
1547
1548 SNIC_HOST_ERR(snic->shost,
1549 "abt_cmd: rqi is null. Tag %d flags 0x%llx\n",
1550 tag, CMD_FLAGS(sc));
1551
1552 ret = SUCCESS;
1553
1554 goto send_abts_end;
1555 }
1556
1557 rqi->abts_done = &tm_done;
1558 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
1559 spin_unlock_irqrestore(io_lock, flags);
1560
1561 ret = 0;
1562 goto abts_pending;
1563 }
1564 SNIC_BUG_ON(!rqi->abts_done);
1565
1566 /* Save Command State, should be restored on failed to Queue. */
1567 sv_state = CMD_STATE(sc);
1568
1569 /*
1570 * Command is still pending, need to abort it
1571 * If the fw completes the command after this point,
1572 * the completion won't be done till mid-layer, since abot
1573 * has already started.
1574 */
1575 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
1576 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
1577
1578 SNIC_SCSI_DBG(snic->shost, "send_abt_cmd: TAG 0x%x\n", tag);
1579
1580 spin_unlock_irqrestore(io_lock, flags);
1581
1582 /* Now Queue the abort command to firmware */
1583 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
1584 if (ret) {
1585 atomic64_inc(&snic->s_stats.abts.q_fail);
1586 SNIC_HOST_ERR(snic->shost,
1587 "send_abt_cmd: IO w/ Tag 0x%x fail w/ err %d flags 0x%llx\n",
1588 tag, ret, CMD_FLAGS(sc));
1589
1590 spin_lock_irqsave(io_lock, flags);
1591 /* Restore Command's previous state */
1592 CMD_STATE(sc) = sv_state;
1593 rqi = (struct snic_req_info *) CMD_SP(sc);
1594 if (rqi)
1595 rqi->abts_done = NULL;
1596 spin_unlock_irqrestore(io_lock, flags);
1597 ret = FAILED;
1598
1599 goto send_abts_end;
1600 }
1601
1602 spin_lock_irqsave(io_lock, flags);
1603 if (tmf == SNIC_ITMF_ABTS_TASK) {
1604 CMD_FLAGS(sc) |= SNIC_IO_ABTS_ISSUED;
1605 atomic64_inc(&snic->s_stats.abts.num);
1606 } else {
1607 /* term stats */
1608 CMD_FLAGS(sc) |= SNIC_IO_TERM_ISSUED;
1609 }
1610 spin_unlock_irqrestore(io_lock, flags);
1611
1612 SNIC_SCSI_DBG(snic->shost,
1613 "send_abt_cmd: sc %p Tag %x flags 0x%llx\n",
1614 sc, tag, CMD_FLAGS(sc));
1615
1616
1617 ret = 0;
1618
1619 abts_pending:
1620 /*
1621 * Queued an abort IO, wait for its completion.
1622 * Once the fw completes the abort command, it will
1623 * wakeup this thread.
1624 */
1625 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT);
1626
1627 send_abts_end:
1628 return ret;
1629 } /* end of snic_send_abort_and_wait */
1630
1631 /*
1632 * This function is exported to SCSI for sending abort cmnds.
1633 * A SCSI IO is represent by snic_ioreq in the driver.
1634 * The snic_ioreq is linked to the SCSI Cmd, thus a link with the ULP'S IO
1635 */
1636 int
1637 snic_abort_cmd(struct scsi_cmnd *sc)
1638 {
1639 struct snic *snic = shost_priv(sc->device->host);
1640 int ret = SUCCESS, tag = snic_cmd_tag(sc);
1641 u32 start_time = jiffies;
1642
1643 SNIC_SCSI_DBG(snic->shost, "abt_cmd:sc %p :0x%x :req = %p :tag = %d\n",
1644 sc, sc->cmnd[0], sc->request, tag);
1645
1646 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) {
1647 SNIC_HOST_ERR(snic->shost,
1648 "abt_cmd: tag %x Parent Devs are not rdy\n",
1649 tag);
1650 ret = FAST_IO_FAIL;
1651
1652 goto abort_end;
1653 }
1654
1655
1656 ret = snic_send_abort_and_wait(snic, sc);
1657 if (ret)
1658 goto abort_end;
1659
1660 ret = snic_abort_finish(snic, sc);
1661
1662 abort_end:
1663 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
1664 jiffies_to_msecs(jiffies - start_time), 0,
1665 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
1666
1667 SNIC_SCSI_DBG(snic->shost,
1668 "abts: Abort Req Status = %s\n",
1669 (ret == SUCCESS) ? "SUCCESS" :
1670 ((ret == FAST_IO_FAIL) ? "FAST_IO_FAIL" : "FAILED"));
1671
1672 return ret;
1673 }
1674
1675
1676
1677 static int
1678 snic_is_abts_pending(struct snic *snic, struct scsi_cmnd *lr_sc)
1679 {
1680 struct snic_req_info *rqi = NULL;
1681 struct scsi_cmnd *sc = NULL;
1682 struct scsi_device *lr_sdev = NULL;
1683 spinlock_t *io_lock = NULL;
1684 u32 tag;
1685 unsigned long flags;
1686
1687 if (lr_sc)
1688 lr_sdev = lr_sc->device;
1689
1690 /* walk through the tag map, an dcheck if IOs are still pending in fw*/
1691 for (tag = 0; tag < snic->max_tag_id; tag++) {
1692 io_lock = snic_io_lock_tag(snic, tag);
1693
1694 spin_lock_irqsave(io_lock, flags);
1695 sc = scsi_host_find_tag(snic->shost, tag);
1696
1697 if (!sc || (lr_sc && (sc->device != lr_sdev || sc == lr_sc))) {
1698 spin_unlock_irqrestore(io_lock, flags);
1699
1700 continue;
1701 }
1702
1703 rqi = (struct snic_req_info *) CMD_SP(sc);
1704 if (!rqi) {
1705 spin_unlock_irqrestore(io_lock, flags);
1706
1707 continue;
1708 }
1709
1710 /*
1711 * Found IO that is still pending w/ firmware and belongs to
1712 * the LUN that is under reset, if lr_sc != NULL
1713 */
1714 SNIC_SCSI_DBG(snic->shost, "Found IO in %s on LUN\n",
1715 snic_ioreq_state_to_str(CMD_STATE(sc)));
1716
1717 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
1718 spin_unlock_irqrestore(io_lock, flags);
1719
1720 return 1;
1721 }
1722
1723 spin_unlock_irqrestore(io_lock, flags);
1724 }
1725
1726 return 0;
1727 } /* end of snic_is_abts_pending */
1728
1729 static int
1730 snic_dr_clean_single_req(struct snic *snic,
1731 u32 tag,
1732 struct scsi_device *lr_sdev)
1733 {
1734 struct snic_req_info *rqi = NULL;
1735 struct snic_tgt *tgt = NULL;
1736 struct scsi_cmnd *sc = NULL;
1737 spinlock_t *io_lock = NULL;
1738 u32 sv_state = 0, tmf = 0;
1739 DECLARE_COMPLETION_ONSTACK(tm_done);
1740 unsigned long flags;
1741 int ret = 0;
1742
1743 io_lock = snic_io_lock_tag(snic, tag);
1744 spin_lock_irqsave(io_lock, flags);
1745 sc = scsi_host_find_tag(snic->shost, tag);
1746
1747 /* Ignore Cmd that don't belong to Lun Reset device */
1748 if (!sc || sc->device != lr_sdev)
1749 goto skip_clean;
1750
1751 rqi = (struct snic_req_info *) CMD_SP(sc);
1752
1753 if (!rqi)
1754 goto skip_clean;
1755
1756
1757 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
1758 goto skip_clean;
1759
1760
1761 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) &&
1762 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) {
1763
1764 SNIC_SCSI_DBG(snic->shost,
1765 "clean_single_req: devrst is not pending sc 0x%p\n",
1766 sc);
1767
1768 goto skip_clean;
1769 }
1770
1771 SNIC_SCSI_DBG(snic->shost,
1772 "clean_single_req: Found IO in %s on lun\n",
1773 snic_ioreq_state_to_str(CMD_STATE(sc)));
1774
1775 /* Save Command State */
1776 sv_state = CMD_STATE(sc);
1777
1778 /*
1779 * Any pending IO issued prior to reset is expected to be
1780 * in abts pending state, if not we need to set SNIC_IOREQ_ABTS_PENDING
1781 * to indicate the IO is abort pending.
1782 * When IO is completed, the IO will be handed over and handled
1783 * in this function.
1784 */
1785
1786 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
1787 SNIC_BUG_ON(rqi->abts_done);
1788
1789 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) {
1790 rqi->tm_tag = SNIC_TAG_DEV_RST;
1791
1792 SNIC_SCSI_DBG(snic->shost,
1793 "clean_single_req:devrst sc 0x%p\n", sc);
1794 }
1795
1796 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
1797 rqi->abts_done = &tm_done;
1798 spin_unlock_irqrestore(io_lock, flags);
1799
1800 tgt = starget_to_tgt(scsi_target(sc->device));
1801 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN))
1802 tmf = SNIC_ITMF_ABTS_TASK_TERM;
1803 else
1804 tmf = SNIC_ITMF_ABTS_TASK;
1805
1806 /* Now queue the abort command to firmware */
1807 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
1808 if (ret) {
1809 SNIC_HOST_ERR(snic->shost,
1810 "clean_single_req_err:sc %p, tag %d abt failed. tm_tag %d flags 0x%llx\n",
1811 sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
1812
1813 spin_lock_irqsave(io_lock, flags);
1814 rqi = (struct snic_req_info *) CMD_SP(sc);
1815 if (rqi)
1816 rqi->abts_done = NULL;
1817
1818 /* Restore Command State */
1819 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
1820 CMD_STATE(sc) = sv_state;
1821
1822 ret = 1;
1823 goto skip_clean;
1824 }
1825
1826 spin_lock_irqsave(io_lock, flags);
1827 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET)
1828 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED;
1829
1830 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED;
1831 spin_unlock_irqrestore(io_lock, flags);
1832
1833 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT);
1834
1835 /* Recheck cmd state to check if it now aborted. */
1836 spin_lock_irqsave(io_lock, flags);
1837 rqi = (struct snic_req_info *) CMD_SP(sc);
1838 if (!rqi) {
1839 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1840 goto skip_clean;
1841 }
1842 rqi->abts_done = NULL;
1843
1844 /* if abort is still pending w/ fw, fail */
1845 if (CMD_ABTS_STATUS(sc) == SNIC_INVALID_CODE) {
1846 SNIC_HOST_ERR(snic->shost,
1847 "clean_single_req_err:sc %p tag %d abt still pending w/ fw, tm_tag %d flags 0x%llx\n",
1848 sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
1849
1850 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE;
1851 ret = 1;
1852
1853 goto skip_clean;
1854 }
1855
1856 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
1857 CMD_SP(sc) = NULL;
1858 spin_unlock_irqrestore(io_lock, flags);
1859
1860 snic_release_req_buf(snic, rqi, sc);
1861
1862 sc->result = (DID_ERROR << 16);
1863 sc->scsi_done(sc);
1864
1865 ret = 0;
1866
1867 return ret;
1868
1869 skip_clean:
1870 spin_unlock_irqrestore(io_lock, flags);
1871
1872 return ret;
1873 } /* end of snic_dr_clean_single_req */
1874
1875 static int
1876 snic_dr_clean_pending_req(struct snic *snic, struct scsi_cmnd *lr_sc)
1877 {
1878 struct scsi_device *lr_sdev = lr_sc->device;
1879 u32 tag = 0;
1880 int ret = FAILED;
1881
1882 for (tag = 0; tag < snic->max_tag_id; tag++) {
1883 if (tag == snic_cmd_tag(lr_sc))
1884 continue;
1885
1886 ret = snic_dr_clean_single_req(snic, tag, lr_sdev);
1887 if (ret) {
1888 SNIC_HOST_ERR(snic->shost, "clean_err:tag = %d\n", tag);
1889
1890 goto clean_err;
1891 }
1892 }
1893
1894 schedule_timeout(msecs_to_jiffies(100));
1895
1896 /* Walk through all the cmds and check abts status. */
1897 if (snic_is_abts_pending(snic, lr_sc)) {
1898 ret = FAILED;
1899
1900 goto clean_err;
1901 }
1902
1903 ret = 0;
1904 SNIC_SCSI_DBG(snic->shost, "clean_pending_req: Success.\n");
1905
1906 return ret;
1907
1908 clean_err:
1909 ret = FAILED;
1910 SNIC_HOST_ERR(snic->shost,
1911 "Failed to Clean Pending IOs on %s device.\n",
1912 dev_name(&lr_sdev->sdev_gendev));
1913
1914 return ret;
1915
1916 } /* end of snic_dr_clean_pending_req */
1917
1918 /*
1919 * snic_dr_finish : Called by snic_device_reset
1920 */
1921 static int
1922 snic_dr_finish(struct snic *snic, struct scsi_cmnd *sc)
1923 {
1924 struct snic_req_info *rqi = NULL;
1925 spinlock_t *io_lock = NULL;
1926 unsigned long flags;
1927 int lr_res = 0;
1928 int ret = FAILED;
1929
1930 io_lock = snic_io_lock_hash(snic, sc);
1931 spin_lock_irqsave(io_lock, flags);
1932 rqi = (struct snic_req_info *) CMD_SP(sc);
1933 if (!rqi) {
1934 spin_unlock_irqrestore(io_lock, flags);
1935 SNIC_SCSI_DBG(snic->shost,
1936 "dr_fini: rqi is null tag 0x%x sc 0x%p flags 0x%llx\n",
1937 snic_cmd_tag(sc), sc, CMD_FLAGS(sc));
1938
1939 ret = FAILED;
1940 goto dr_fini_end;
1941 }
1942
1943 rqi->dr_done = NULL;
1944
1945 lr_res = CMD_LR_STATUS(sc);
1946
1947 switch (lr_res) {
1948 case SNIC_INVALID_CODE:
1949 /* stats */
1950 SNIC_SCSI_DBG(snic->shost,
1951 "dr_fini: Tag %x Dev Reset Timedout. flags 0x%llx\n",
1952 snic_cmd_tag(sc), CMD_FLAGS(sc));
1953
1954 CMD_FLAGS(sc) |= SNIC_DEV_RST_TIMEDOUT;
1955 ret = FAILED;
1956
1957 goto dr_failed;
1958
1959 case SNIC_STAT_IO_SUCCESS:
1960 SNIC_SCSI_DBG(snic->shost,
1961 "dr_fini: Tag %x Dev Reset cmpl\n",
1962 snic_cmd_tag(sc));
1963 ret = 0;
1964 break;
1965
1966 default:
1967 SNIC_HOST_ERR(snic->shost,
1968 "dr_fini:Device Reset completed& failed.Tag = %x lr_status %s flags 0x%llx\n",
1969 snic_cmd_tag(sc),
1970 snic_io_status_to_str(lr_res), CMD_FLAGS(sc));
1971 ret = FAILED;
1972 goto dr_failed;
1973 }
1974 spin_unlock_irqrestore(io_lock, flags);
1975
1976 /*
1977 * Cleanup any IOs on this LUN that have still not completed.
1978 * If any of these fail, then LUN Reset fails.
1979 * Cleanup cleans all commands on this LUN except
1980 * the lun reset command. If all cmds get cleaned, the LUN Reset
1981 * succeeds.
1982 */
1983
1984 ret = snic_dr_clean_pending_req(snic, sc);
1985 if (ret) {
1986 spin_lock_irqsave(io_lock, flags);
1987 SNIC_SCSI_DBG(snic->shost,
1988 "dr_fini: Device Reset Failed since could not abort all IOs. Tag = %x.\n",
1989 snic_cmd_tag(sc));
1990 rqi = (struct snic_req_info *) CMD_SP(sc);
1991
1992 goto dr_failed;
1993 } else {
1994 /* Cleanup LUN Reset Command */
1995 spin_lock_irqsave(io_lock, flags);
1996 rqi = (struct snic_req_info *) CMD_SP(sc);
1997 if (rqi)
1998 ret = SUCCESS; /* Completed Successfully */
1999 else
2000 ret = FAILED;
2001 }
2002
2003 dr_failed:
2004 SNIC_BUG_ON(!spin_is_locked(io_lock));
2005 if (rqi)
2006 CMD_SP(sc) = NULL;
2007 spin_unlock_irqrestore(io_lock, flags);
2008
2009 if (rqi)
2010 snic_release_req_buf(snic, rqi, sc);
2011
2012 dr_fini_end:
2013 return ret;
2014 } /* end of snic_dr_finish */
2015
2016 static int
2017 snic_queue_dr_req(struct snic *snic,
2018 struct snic_req_info *rqi,
2019 struct scsi_cmnd *sc)
2020 {
2021 /* Add special tag for device reset */
2022 rqi->tm_tag |= SNIC_TAG_DEV_RST;
2023
2024 return snic_issue_tm_req(snic, rqi, sc, SNIC_ITMF_LUN_RESET);
2025 }
2026
2027 static int
2028 snic_send_dr_and_wait(struct snic *snic, struct scsi_cmnd *sc)
2029 {
2030 struct snic_req_info *rqi = NULL;
2031 enum snic_ioreq_state sv_state;
2032 spinlock_t *io_lock = NULL;
2033 unsigned long flags;
2034 DECLARE_COMPLETION_ONSTACK(tm_done);
2035 int ret = FAILED, tag = snic_cmd_tag(sc);
2036
2037 io_lock = snic_io_lock_hash(snic, sc);
2038 spin_lock_irqsave(io_lock, flags);
2039 CMD_FLAGS(sc) |= SNIC_DEVICE_RESET;
2040 rqi = (struct snic_req_info *) CMD_SP(sc);
2041 if (!rqi) {
2042 SNIC_HOST_ERR(snic->shost,
2043 "send_dr: rqi is null, Tag 0x%x flags 0x%llx\n",
2044 tag, CMD_FLAGS(sc));
2045 spin_unlock_irqrestore(io_lock, flags);
2046
2047 ret = FAILED;
2048 goto send_dr_end;
2049 }
2050
2051 /* Save Command state to restore in case Queuing failed. */
2052 sv_state = CMD_STATE(sc);
2053
2054 CMD_STATE(sc) = SNIC_IOREQ_LR_PENDING;
2055 CMD_LR_STATUS(sc) = SNIC_INVALID_CODE;
2056
2057 SNIC_SCSI_DBG(snic->shost, "dr: TAG = %x\n", tag);
2058
2059 rqi->dr_done = &tm_done;
2060 SNIC_BUG_ON(!rqi->dr_done);
2061
2062 spin_unlock_irqrestore(io_lock, flags);
2063 /*
2064 * The Command state is changed to IOREQ_PENDING,
2065 * in this case, if the command is completed, the icmnd_cmpl will
2066 * mark the cmd as completed.
2067 * This logic still makes LUN Reset is inevitable.
2068 */
2069
2070 ret = snic_queue_dr_req(snic, rqi, sc);
2071 if (ret) {
2072 SNIC_HOST_ERR(snic->shost,
2073 "send_dr: IO w/ Tag 0x%x Failed err = %d. flags 0x%llx\n",
2074 tag, ret, CMD_FLAGS(sc));
2075
2076 spin_lock_irqsave(io_lock, flags);
2077 /* Restore State */
2078 CMD_STATE(sc) = sv_state;
2079 rqi = (struct snic_req_info *) CMD_SP(sc);
2080 if (rqi)
2081 rqi->dr_done = NULL;
2082 /* rqi is freed in caller. */
2083 spin_unlock_irqrestore(io_lock, flags);
2084 ret = FAILED;
2085
2086 goto send_dr_end;
2087 }
2088
2089 spin_lock_irqsave(io_lock, flags);
2090 CMD_FLAGS(sc) |= SNIC_DEV_RST_ISSUED;
2091 spin_unlock_irqrestore(io_lock, flags);
2092
2093 ret = 0;
2094
2095 wait_for_completion_timeout(&tm_done, SNIC_LUN_RESET_TIMEOUT);
2096
2097 send_dr_end:
2098 return ret;
2099 }
2100
2101 /*
2102 * auxillary funciton to check lun reset op is supported or not
2103 * Not supported if returns 0
2104 */
2105 static int
2106 snic_dev_reset_supported(struct scsi_device *sdev)
2107 {
2108 struct snic_tgt *tgt = starget_to_tgt(scsi_target(sdev));
2109
2110 if (tgt->tdata.typ == SNIC_TGT_DAS)
2111 return 0;
2112
2113 return 1;
2114 }
2115
2116 static void
2117 snic_unlink_and_release_req(struct snic *snic, struct scsi_cmnd *sc, int flag)
2118 {
2119 struct snic_req_info *rqi = NULL;
2120 spinlock_t *io_lock = NULL;
2121 unsigned long flags;
2122 u32 start_time = jiffies;
2123
2124 io_lock = snic_io_lock_hash(snic, sc);
2125 spin_lock_irqsave(io_lock, flags);
2126 rqi = (struct snic_req_info *) CMD_SP(sc);
2127 if (rqi) {
2128 start_time = rqi->start_time;
2129 CMD_SP(sc) = NULL;
2130 }
2131
2132 CMD_FLAGS(sc) |= flag;
2133 spin_unlock_irqrestore(io_lock, flags);
2134
2135 if (rqi)
2136 snic_release_req_buf(snic, rqi, sc);
2137
2138 SNIC_TRC(snic->shost->host_no, snic_cmd_tag(sc), (ulong) sc,
2139 jiffies_to_msecs(jiffies - start_time), (ulong) rqi,
2140 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2141 }
2142
2143 /*
2144 * SCSI Eh thread issues a LUN Reset when one or more commands on a LUN
2145 * fail to get aborted. It calls driver's eh_device_reset with a SCSI
2146 * command on the LUN.
2147 */
2148 int
2149 snic_device_reset(struct scsi_cmnd *sc)
2150 {
2151 struct Scsi_Host *shost = sc->device->host;
2152 struct snic *snic = shost_priv(shost);
2153 struct snic_req_info *rqi = NULL;
2154 int tag = snic_cmd_tag(sc);
2155 int start_time = jiffies;
2156 int ret = FAILED;
2157 int dr_supp = 0;
2158
2159 SNIC_SCSI_DBG(shost, "dev_reset:sc %p :0x%x :req = %p :tag = %d\n",
2160 sc, sc->cmnd[0], sc->request,
2161 snic_cmd_tag(sc));
2162 dr_supp = snic_dev_reset_supported(sc->device);
2163 if (!dr_supp) {
2164 /* device reset op is not supported */
2165 SNIC_HOST_INFO(shost, "LUN Reset Op not supported.\n");
2166 snic_unlink_and_release_req(snic, sc, SNIC_DEV_RST_NOTSUP);
2167
2168 goto dev_rst_end;
2169 }
2170
2171 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) {
2172 snic_unlink_and_release_req(snic, sc, 0);
2173 SNIC_HOST_ERR(shost, "Devrst: Parent Devs are not online.\n");
2174
2175 goto dev_rst_end;
2176 }
2177
2178 /* There is no tag when lun reset is issue through ioctl. */
2179 if (unlikely(tag <= SNIC_NO_TAG)) {
2180 SNIC_HOST_INFO(snic->shost,
2181 "Devrst: LUN Reset Recvd thru IOCTL.\n");
2182
2183 rqi = snic_req_init(snic, 0);
2184 if (!rqi)
2185 goto dev_rst_end;
2186
2187 memset(scsi_cmd_priv(sc), 0,
2188 sizeof(struct snic_internal_io_state));
2189 CMD_SP(sc) = (char *)rqi;
2190 CMD_FLAGS(sc) = SNIC_NO_FLAGS;
2191
2192 /* Add special tag for dr coming from user spc */
2193 rqi->tm_tag = SNIC_TAG_IOCTL_DEV_RST;
2194 rqi->sc = sc;
2195 }
2196
2197 ret = snic_send_dr_and_wait(snic, sc);
2198 if (ret) {
2199 SNIC_HOST_ERR(snic->shost,
2200 "Devrst: IO w/ Tag %x Failed w/ err = %d\n",
2201 tag, ret);
2202
2203 snic_unlink_and_release_req(snic, sc, 0);
2204
2205 goto dev_rst_end;
2206 }
2207
2208 ret = snic_dr_finish(snic, sc);
2209
2210 dev_rst_end:
2211 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
2212 jiffies_to_msecs(jiffies - start_time),
2213 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2214
2215 SNIC_SCSI_DBG(snic->shost,
2216 "Devrst: Returning from Device Reset : %s\n",
2217 (ret == SUCCESS) ? "SUCCESS" : "FAILED");
2218
2219 return ret;
2220 } /* end of snic_device_reset */
2221
2222 /*
2223 * SCSI Error handling calls driver's eh_host_reset if all prior
2224 * error handling levels return FAILED.
2225 *
2226 * Host Reset is the highest level of error recovery. If this fails, then
2227 * host is offlined by SCSI.
2228 */
2229 /*
2230 * snic_issue_hba_reset : Queues FW Reset Request.
2231 */
2232 static int
2233 snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
2234 {
2235 struct snic_req_info *rqi = NULL;
2236 struct snic_host_req *req = NULL;
2237 spinlock_t *io_lock = NULL;
2238 DECLARE_COMPLETION_ONSTACK(wait);
2239 unsigned long flags;
2240 int ret = -ENOMEM;
2241
2242 rqi = snic_req_init(snic, 0);
2243 if (!rqi) {
2244 ret = -ENOMEM;
2245
2246 goto hba_rst_end;
2247 }
2248
2249 if (snic_cmd_tag(sc) == SCSI_NO_TAG) {
2250 memset(scsi_cmd_priv(sc), 0,
2251 sizeof(struct snic_internal_io_state));
2252 SNIC_HOST_INFO(snic->shost, "issu_hr:Host reset thru ioctl.\n");
2253 rqi->sc = sc;
2254 }
2255
2256 req = rqi_to_req(rqi);
2257
2258 io_lock = snic_io_lock_hash(snic, sc);
2259 spin_lock_irqsave(io_lock, flags);
2260 SNIC_BUG_ON(CMD_SP(sc) != NULL);
2261 CMD_STATE(sc) = SNIC_IOREQ_PENDING;
2262 CMD_SP(sc) = (char *) rqi;
2263 CMD_FLAGS(sc) |= SNIC_IO_INITIALIZED;
2264 snic->remove_wait = &wait;
2265 spin_unlock_irqrestore(io_lock, flags);
2266
2267 /* Initialize Request */
2268 snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(sc),
2269 snic->config.hid, 0, (ulong) rqi);
2270
2271 req->u.reset.flags = 0;
2272
2273 ret = snic_queue_wq_desc(snic, req, sizeof(*req));
2274 if (ret) {
2275 SNIC_HOST_ERR(snic->shost,
2276 "issu_hr:Queuing HBA Reset Failed. w err %d\n",
2277 ret);
2278
2279 goto hba_rst_err;
2280 }
2281
2282 spin_lock_irqsave(io_lock, flags);
2283 CMD_FLAGS(sc) |= SNIC_HOST_RESET_ISSUED;
2284 spin_unlock_irqrestore(io_lock, flags);
2285 atomic64_inc(&snic->s_stats.reset.hba_resets);
2286 SNIC_HOST_INFO(snic->shost, "Queued HBA Reset Successfully.\n");
2287
2288 wait_for_completion_timeout(snic->remove_wait,
2289 SNIC_HOST_RESET_TIMEOUT);
2290
2291 if (snic_get_state(snic) == SNIC_FWRESET) {
2292 SNIC_HOST_ERR(snic->shost, "reset_cmpl: Reset Timedout.\n");
2293 ret = -ETIMEDOUT;
2294
2295 goto hba_rst_err;
2296 }
2297
2298 spin_lock_irqsave(io_lock, flags);
2299 snic->remove_wait = NULL;
2300 rqi = (struct snic_req_info *) CMD_SP(sc);
2301 CMD_SP(sc) = NULL;
2302 spin_unlock_irqrestore(io_lock, flags);
2303
2304 if (rqi)
2305 snic_req_free(snic, rqi);
2306
2307 ret = 0;
2308
2309 return ret;
2310
2311 hba_rst_err:
2312 spin_lock_irqsave(io_lock, flags);
2313 snic->remove_wait = NULL;
2314 rqi = (struct snic_req_info *) CMD_SP(sc);
2315 CMD_SP(sc) = NULL;
2316 spin_unlock_irqrestore(io_lock, flags);
2317
2318 if (rqi)
2319 snic_req_free(snic, rqi);
2320
2321 hba_rst_end:
2322 SNIC_HOST_ERR(snic->shost,
2323 "reset:HBA Reset Failed w/ err = %d.\n",
2324 ret);
2325
2326 return ret;
2327 } /* end of snic_issue_hba_reset */
2328
2329 int
2330 snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc)
2331 {
2332 struct snic *snic = shost_priv(shost);
2333 enum snic_state sv_state;
2334 unsigned long flags;
2335 int ret = FAILED;
2336
2337 /* Set snic state as SNIC_FWRESET*/
2338 sv_state = snic_get_state(snic);
2339
2340 spin_lock_irqsave(&snic->snic_lock, flags);
2341 if (snic_get_state(snic) == SNIC_FWRESET) {
2342 spin_unlock_irqrestore(&snic->snic_lock, flags);
2343 SNIC_HOST_INFO(shost, "reset:prev reset is in progres\n");
2344
2345 msleep(SNIC_HOST_RESET_TIMEOUT);
2346 ret = SUCCESS;
2347
2348 goto reset_end;
2349 }
2350
2351 snic_set_state(snic, SNIC_FWRESET);
2352 spin_unlock_irqrestore(&snic->snic_lock, flags);
2353
2354
2355 /* Wait for all the IOs that are entered in Qcmd */
2356 while (atomic_read(&snic->ios_inflight))
2357 schedule_timeout(msecs_to_jiffies(1));
2358
2359 ret = snic_issue_hba_reset(snic, sc);
2360 if (ret) {
2361 SNIC_HOST_ERR(shost,
2362 "reset:Host Reset Failed w/ err %d.\n",
2363 ret);
2364 spin_lock_irqsave(&snic->snic_lock, flags);
2365 snic_set_state(snic, sv_state);
2366 spin_unlock_irqrestore(&snic->snic_lock, flags);
2367 atomic64_inc(&snic->s_stats.reset.hba_reset_fail);
2368 ret = FAILED;
2369
2370 goto reset_end;
2371 }
2372
2373 ret = SUCCESS;
2374
2375 reset_end:
2376 return ret;
2377 } /* end of snic_reset */
2378
2379 /*
2380 * SCSI Error handling calls driver's eh_host_reset if all prior
2381 * error handling levels return FAILED.
2382 *
2383 * Host Reset is the highest level of error recovery. If this fails, then
2384 * host is offlined by SCSI.
2385 */
2386 int
2387 snic_host_reset(struct scsi_cmnd *sc)
2388 {
2389 struct Scsi_Host *shost = sc->device->host;
2390 u32 start_time = jiffies;
2391 int ret = FAILED;
2392
2393 SNIC_SCSI_DBG(shost,
2394 "host reset:sc %p sc_cmd 0x%x req %p tag %d flags 0x%llx\n",
2395 sc, sc->cmnd[0], sc->request,
2396 snic_cmd_tag(sc), CMD_FLAGS(sc));
2397
2398 ret = snic_reset(shost, sc);
2399
2400 SNIC_TRC(shost->host_no, snic_cmd_tag(sc), (ulong) sc,
2401 jiffies_to_msecs(jiffies - start_time),
2402 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2403
2404 return ret;
2405 } /* end of snic_host_reset */
2406
2407 /*
2408 * snic_cmpl_pending_tmreq : Caller should hold io_lock
2409 */
2410 static void
2411 snic_cmpl_pending_tmreq(struct snic *snic, struct scsi_cmnd *sc)
2412 {
2413 struct snic_req_info *rqi = NULL;
2414
2415 SNIC_SCSI_DBG(snic->shost,
2416 "Completing Pending TM Req sc %p, state %s flags 0x%llx\n",
2417 sc, snic_io_status_to_str(CMD_STATE(sc)), CMD_FLAGS(sc));
2418
2419 /*
2420 * CASE : FW didn't post itmf completion due to PCIe Errors.
2421 * Marking the abort status as Success to call scsi completion
2422 * in snic_abort_finish()
2423 */
2424 CMD_ABTS_STATUS(sc) = SNIC_STAT_IO_SUCCESS;
2425
2426 rqi = (struct snic_req_info *) CMD_SP(sc);
2427 if (!rqi)
2428 return;
2429
2430 if (rqi->dr_done)
2431 complete(rqi->dr_done);
2432 else if (rqi->abts_done)
2433 complete(rqi->abts_done);
2434 }
2435
2436 /*
2437 * snic_scsi_cleanup: Walks through tag map and releases the reqs
2438 */
2439 static void
2440 snic_scsi_cleanup(struct snic *snic, int ex_tag)
2441 {
2442 struct snic_req_info *rqi = NULL;
2443 struct scsi_cmnd *sc = NULL;
2444 spinlock_t *io_lock = NULL;
2445 unsigned long flags;
2446 int tag;
2447 u64 st_time = 0;
2448
2449 SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n");
2450
2451 for (tag = 0; tag < snic->max_tag_id; tag++) {
2452 /* Skip ex_tag */
2453 if (tag == ex_tag)
2454 continue;
2455
2456 io_lock = snic_io_lock_tag(snic, tag);
2457 spin_lock_irqsave(io_lock, flags);
2458 sc = scsi_host_find_tag(snic->shost, tag);
2459 if (!sc) {
2460 spin_unlock_irqrestore(io_lock, flags);
2461
2462 continue;
2463 }
2464
2465 if (unlikely(snic_tmreq_pending(sc))) {
2466 /*
2467 * When FW Completes reset w/o sending completions
2468 * for outstanding ios.
2469 */
2470 snic_cmpl_pending_tmreq(snic, sc);
2471 spin_unlock_irqrestore(io_lock, flags);
2472
2473 continue;
2474 }
2475
2476 rqi = (struct snic_req_info *) CMD_SP(sc);
2477 if (!rqi) {
2478 spin_unlock_irqrestore(io_lock, flags);
2479
2480 goto cleanup;
2481 }
2482
2483 SNIC_SCSI_DBG(snic->shost,
2484 "sc_clean: sc %p, rqi %p, tag %d flags 0x%llx\n",
2485 sc, rqi, tag, CMD_FLAGS(sc));
2486
2487 CMD_SP(sc) = NULL;
2488 CMD_FLAGS(sc) |= SNIC_SCSI_CLEANUP;
2489 spin_unlock_irqrestore(io_lock, flags);
2490 st_time = rqi->start_time;
2491
2492 SNIC_HOST_INFO(snic->shost,
2493 "sc_clean: Releasing rqi %p : flags 0x%llx\n",
2494 rqi, CMD_FLAGS(sc));
2495
2496 snic_release_req_buf(snic, rqi, sc);
2497
2498 cleanup:
2499 sc->result = DID_TRANSPORT_DISRUPTED << 16;
2500 SNIC_HOST_INFO(snic->shost,
2501 "sc_clean: DID_TRANSPORT_DISRUPTED for sc %p, Tag %d flags 0x%llx rqi %p duration %u msecs\n",
2502 sc, sc->request->tag, CMD_FLAGS(sc), rqi,
2503 jiffies_to_msecs(jiffies - st_time));
2504
2505 /* Update IO stats */
2506 snic_stats_update_io_cmpl(&snic->s_stats);
2507
2508 if (sc->scsi_done) {
2509 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
2510 jiffies_to_msecs(jiffies - st_time), 0,
2511 SNIC_TRC_CMD(sc),
2512 SNIC_TRC_CMD_STATE_FLAGS(sc));
2513
2514 sc->scsi_done(sc);
2515 }
2516 }
2517 } /* end of snic_scsi_cleanup */
2518
2519 void
2520 snic_shutdown_scsi_cleanup(struct snic *snic)
2521 {
2522 SNIC_HOST_INFO(snic->shost, "Shutdown time SCSI Cleanup.\n");
2523
2524 snic_scsi_cleanup(snic, SCSI_NO_TAG);
2525 } /* end of snic_shutdown_scsi_cleanup */
2526
2527 /*
2528 * snic_internal_abort_io
2529 * called by : snic_tgt_scsi_abort_io
2530 */
2531 static int
2532 snic_internal_abort_io(struct snic *snic, struct scsi_cmnd *sc, int tmf)
2533 {
2534 struct snic_req_info *rqi = NULL;
2535 spinlock_t *io_lock = NULL;
2536 unsigned long flags;
2537 u32 sv_state = 0;
2538 int ret = 0;
2539
2540 io_lock = snic_io_lock_hash(snic, sc);
2541 spin_lock_irqsave(io_lock, flags);
2542 rqi = (struct snic_req_info *) CMD_SP(sc);
2543 if (!rqi)
2544 goto skip_internal_abts;
2545
2546 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
2547 goto skip_internal_abts;
2548
2549 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) &&
2550 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) {
2551
2552 SNIC_SCSI_DBG(snic->shost,
2553 "internal_abts: dev rst not pending sc 0x%p\n",
2554 sc);
2555
2556 goto skip_internal_abts;
2557 }
2558
2559
2560 if (!(CMD_FLAGS(sc) & SNIC_IO_ISSUED)) {
2561 SNIC_SCSI_DBG(snic->shost,
2562 "internal_abts: IO not yet issued sc 0x%p tag 0x%x flags 0x%llx state %d\n",
2563 sc, snic_cmd_tag(sc), CMD_FLAGS(sc), CMD_STATE(sc));
2564
2565 goto skip_internal_abts;
2566 }
2567
2568 sv_state = CMD_STATE(sc);
2569 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
2570 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
2571 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_PENDING;
2572
2573 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) {
2574 /* stats */
2575 rqi->tm_tag = SNIC_TAG_DEV_RST;
2576 SNIC_SCSI_DBG(snic->shost, "internal_abts:dev rst sc %p\n", sc);
2577 }
2578
2579 SNIC_SCSI_DBG(snic->shost, "internal_abts: Issuing abts tag %x\n",
2580 snic_cmd_tag(sc));
2581 SNIC_BUG_ON(rqi->abts_done);
2582 spin_unlock_irqrestore(io_lock, flags);
2583
2584 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
2585 if (ret) {
2586 SNIC_HOST_ERR(snic->shost,
2587 "internal_abts: Tag = %x , Failed w/ err = %d\n",
2588 snic_cmd_tag(sc), ret);
2589
2590 spin_lock_irqsave(io_lock, flags);
2591
2592 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
2593 CMD_STATE(sc) = sv_state;
2594
2595 goto skip_internal_abts;
2596 }
2597
2598 spin_lock_irqsave(io_lock, flags);
2599 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET)
2600 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED;
2601 else
2602 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED;
2603
2604 ret = SUCCESS;
2605
2606 skip_internal_abts:
2607 SNIC_BUG_ON(!spin_is_locked(io_lock));
2608 spin_unlock_irqrestore(io_lock, flags);
2609
2610 return ret;
2611 } /* end of snic_internal_abort_io */
2612
2613 /*
2614 * snic_tgt_scsi_abort_io : called by snic_tgt_del
2615 */
2616 int
2617 snic_tgt_scsi_abort_io(struct snic_tgt *tgt)
2618 {
2619 struct snic *snic = NULL;
2620 struct scsi_cmnd *sc = NULL;
2621 struct snic_tgt *sc_tgt = NULL;
2622 spinlock_t *io_lock = NULL;
2623 unsigned long flags;
2624 int ret = 0, tag, abt_cnt = 0, tmf = 0;
2625
2626 if (!tgt)
2627 return -1;
2628
2629 snic = shost_priv(snic_tgt_to_shost(tgt));
2630 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: Cleaning Pending IOs.\n");
2631
2632 if (tgt->tdata.typ == SNIC_TGT_DAS)
2633 tmf = SNIC_ITMF_ABTS_TASK;
2634 else
2635 tmf = SNIC_ITMF_ABTS_TASK_TERM;
2636
2637 for (tag = 0; tag < snic->max_tag_id; tag++) {
2638 io_lock = snic_io_lock_tag(snic, tag);
2639
2640 spin_lock_irqsave(io_lock, flags);
2641 sc = scsi_host_find_tag(snic->shost, tag);
2642 if (!sc) {
2643 spin_unlock_irqrestore(io_lock, flags);
2644
2645 continue;
2646 }
2647
2648 sc_tgt = starget_to_tgt(scsi_target(sc->device));
2649 if (sc_tgt != tgt) {
2650 spin_unlock_irqrestore(io_lock, flags);
2651
2652 continue;
2653 }
2654 spin_unlock_irqrestore(io_lock, flags);
2655
2656 ret = snic_internal_abort_io(snic, sc, tmf);
2657 if (ret < 0) {
2658 SNIC_HOST_ERR(snic->shost,
2659 "tgt_abt_io: Tag %x, Failed w err = %d\n",
2660 tag, ret);
2661
2662 continue;
2663 }
2664
2665 if (ret == SUCCESS)
2666 abt_cnt++;
2667 }
2668
2669 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: abt_cnt = %d\n", abt_cnt);
2670
2671 return 0;
2672 } /* end of snic_tgt_scsi_abort_io */
Linux with added FPC-III support