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