drivers/scsi/snic/snic_scsi.c

   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 */