fnic_scsi.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
   4 * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
   5 */
   6#include <linux/mempool.h>
   7#include <linux/errno.h>
   8#include <linux/init.h>
   9#include <linux/workqueue.h>
  10#include <linux/pci.h>
  11#include <linux/scatterlist.h>
  12#include <linux/skbuff.h>
  13#include <linux/spinlock.h>
  14#include <linux/etherdevice.h>
  15#include <linux/if_ether.h>
  16#include <linux/if_vlan.h>
  17#include <linux/delay.h>
  18#include <linux/gfp.h>
  19#include <scsi/scsi.h>
  20#include <scsi/scsi_host.h>
  21#include <scsi/scsi_device.h>
  22#include <scsi/scsi_cmnd.h>
  23#include <scsi/scsi_tcq.h>
  24#include <scsi/fc/fc_els.h>
  25#include <scsi/fc/fc_fcoe.h>
  26#include <scsi/fc_frame.h>
  27#include <scsi/scsi_transport_fc.h>
  28#include "fnic_io.h"
  29#include "fnic.h"
  30
  31static void fnic_cleanup_io(struct fnic *fnic, int exclude_id);
  32
  33const char *fnic_state_str[] = {
  34	[FNIC_IN_FC_MODE] =           "FNIC_IN_FC_MODE",
  35	[FNIC_IN_FC_TRANS_ETH_MODE] = "FNIC_IN_FC_TRANS_ETH_MODE",
  36	[FNIC_IN_ETH_MODE] =          "FNIC_IN_ETH_MODE",
  37	[FNIC_IN_ETH_TRANS_FC_MODE] = "FNIC_IN_ETH_TRANS_FC_MODE",
  38};
  39
  40static const char *fnic_ioreq_state_str[] = {
  41	[FNIC_IOREQ_NOT_INITED] = "FNIC_IOREQ_NOT_INITED",
  42	[FNIC_IOREQ_CMD_PENDING] = "FNIC_IOREQ_CMD_PENDING",
  43	[FNIC_IOREQ_ABTS_PENDING] = "FNIC_IOREQ_ABTS_PENDING",
  44	[FNIC_IOREQ_ABTS_COMPLETE] = "FNIC_IOREQ_ABTS_COMPLETE",
  45	[FNIC_IOREQ_CMD_COMPLETE] = "FNIC_IOREQ_CMD_COMPLETE",
  46};
  47
  48static const char *fcpio_status_str[] =  {
  49	[FCPIO_SUCCESS] = "FCPIO_SUCCESS", /*0x0*/
  50	[FCPIO_INVALID_HEADER] = "FCPIO_INVALID_HEADER",
  51	[FCPIO_OUT_OF_RESOURCE] = "FCPIO_OUT_OF_RESOURCE",
  52	[FCPIO_INVALID_PARAM] = "FCPIO_INVALID_PARAM]",
  53	[FCPIO_REQ_NOT_SUPPORTED] = "FCPIO_REQ_NOT_SUPPORTED",
  54	[FCPIO_IO_NOT_FOUND] = "FCPIO_IO_NOT_FOUND",
  55	[FCPIO_ABORTED] = "FCPIO_ABORTED", /*0x41*/
  56	[FCPIO_TIMEOUT] = "FCPIO_TIMEOUT",
  57	[FCPIO_SGL_INVALID] = "FCPIO_SGL_INVALID",
  58	[FCPIO_MSS_INVALID] = "FCPIO_MSS_INVALID",
  59	[FCPIO_DATA_CNT_MISMATCH] = "FCPIO_DATA_CNT_MISMATCH",
  60	[FCPIO_FW_ERR] = "FCPIO_FW_ERR",
  61	[FCPIO_ITMF_REJECTED] = "FCPIO_ITMF_REJECTED",
  62	[FCPIO_ITMF_FAILED] = "FCPIO_ITMF_FAILED",
  63	[FCPIO_ITMF_INCORRECT_LUN] = "FCPIO_ITMF_INCORRECT_LUN",
  64	[FCPIO_CMND_REJECTED] = "FCPIO_CMND_REJECTED",
  65	[FCPIO_NO_PATH_AVAIL] = "FCPIO_NO_PATH_AVAIL",
  66	[FCPIO_PATH_FAILED] = "FCPIO_PATH_FAILED",
  67	[FCPIO_LUNMAP_CHNG_PEND] = "FCPIO_LUNHMAP_CHNG_PEND",
  68};
  69
  70enum terminate_io_return {
  71	TERM_SUCCESS = 0,
  72	TERM_NO_SC = 1,
  73	TERM_IO_REQ_NOT_FOUND,
  74	TERM_ANOTHER_PORT,
  75	TERM_GSTATE,
  76	TERM_IO_BLOCKED,
  77	TERM_OUT_OF_WQ_DESC,
  78	TERM_TIMED_OUT,
  79	TERM_MISC,
  80};
  81
  82const char *fnic_state_to_str(unsigned int state)
  83{
  84	if (state >= ARRAY_SIZE(fnic_state_str) || !fnic_state_str[state])
  85		return "unknown";
  86
  87	return fnic_state_str[state];
  88}
  89
  90static const char *fnic_ioreq_state_to_str(unsigned int state)
  91{
  92	if (state >= ARRAY_SIZE(fnic_ioreq_state_str) ||
  93	    !fnic_ioreq_state_str[state])
  94		return "unknown";
  95
  96	return fnic_ioreq_state_str[state];
  97}
  98
  99static const char *fnic_fcpio_status_to_str(unsigned int status)
 100{
 101	if (status >= ARRAY_SIZE(fcpio_status_str) || !fcpio_status_str[status])
 102		return "unknown";
 103
 104	return fcpio_status_str[status];
 105}
 106
 107/*
 108 * Unmap the data buffer and sense buffer for an io_req,
 109 * also unmap and free the device-private scatter/gather list.
 110 */
 111static void fnic_release_ioreq_buf(struct fnic *fnic,
 112				   struct fnic_io_req *io_req,
 113				   struct scsi_cmnd *sc)
 114{
 115	if (io_req->sgl_list_pa)
 116		dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
 117				 sizeof(io_req->sgl_list[0]) * io_req->sgl_cnt,
 118				 DMA_TO_DEVICE);
 119	scsi_dma_unmap(sc);
 120
 121	if (io_req->sgl_cnt)
 122		mempool_free(io_req->sgl_list_alloc,
 123			     fnic->io_sgl_pool[io_req->sgl_type]);
 124	if (io_req->sense_buf_pa)
 125		dma_unmap_single(&fnic->pdev->dev, io_req->sense_buf_pa,
 126				 SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
 127}
 128
 129static bool
 130fnic_count_portid_ioreqs_iter(struct fnic *fnic, struct scsi_cmnd *sc,
 131				void *data1, void *data2)
 132{
 133	u32 *portid = data1;
 134	unsigned int *count = data2;
 135	struct fnic_io_req *io_req = fnic_priv(sc)->io_req;
 136
 137	if (!io_req || (*portid && (io_req->port_id != *portid)))
 138		return true;
 139
 140	*count += 1;
 141	return true;
 142}
 143
 144unsigned int fnic_count_ioreqs(struct fnic *fnic, u32 portid)
 145{
 146	unsigned int count = 0;
 147
 148	fnic_scsi_io_iter(fnic, fnic_count_portid_ioreqs_iter,
 149				&portid, &count);
 150
 151	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
 152		      "portid = 0x%x count = %u\n", portid, count);
 153	return count;
 154}
 155
 156unsigned int fnic_count_all_ioreqs(struct fnic *fnic)
 157{
 158	return fnic_count_ioreqs(fnic, 0);
 159}
 160
 161static bool
 162fnic_count_lun_ioreqs_iter(struct fnic *fnic, struct scsi_cmnd *sc,
 163				void *data1, void *data2)
 164{
 165	struct scsi_device *scsi_device = data1;
 166	unsigned int *count = data2;
 167
 168	if (sc->device != scsi_device || !fnic_priv(sc)->io_req)
 169		return true;
 170
 171	*count += 1;
 172	return true;
 173}
 174
 175unsigned int
 176fnic_count_lun_ioreqs(struct fnic *fnic, struct scsi_device *scsi_device)
 177{
 178	unsigned int count = 0;
 179
 180	fnic_scsi_io_iter(fnic, fnic_count_lun_ioreqs_iter,
 181				scsi_device, &count);
 182
 183	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
 184		      "lun = %p count = %u\n", scsi_device, count);
 185	return count;
 186}
 187
 188/* Free up Copy Wq descriptors. Called with copy_wq lock held */
 189static int free_wq_copy_descs(struct fnic *fnic, struct vnic_wq_copy *wq, unsigned int hwq)
 190{
 191	/* if no Ack received from firmware, then nothing to clean */
 192	if (!fnic->fw_ack_recd[hwq])
 193		return 1;
 194
 195	/*
 196	 * Update desc_available count based on number of freed descriptors
 197	 * Account for wraparound
 198	 */
 199	if (wq->to_clean_index <= fnic->fw_ack_index[hwq])
 200		wq->ring.desc_avail += (fnic->fw_ack_index[hwq]
 201					- wq->to_clean_index + 1);
 202	else
 203		wq->ring.desc_avail += (wq->ring.desc_count
 204					- wq->to_clean_index
 205					+ fnic->fw_ack_index[hwq] + 1);
 206
 207	/*
 208	 * just bump clean index to ack_index+1 accounting for wraparound
 209	 * this will essentially free up all descriptors between
 210	 * to_clean_index and fw_ack_index, both inclusive
 211	 */
 212	wq->to_clean_index =
 213		(fnic->fw_ack_index[hwq] + 1) % wq->ring.desc_count;
 214
 215	/* we have processed the acks received so far */
 216	fnic->fw_ack_recd[hwq] = 0;
 217	return 0;
 218}
 219
 220
 221/*
 222 * __fnic_set_state_flags
 223 * Sets/Clears bits in fnic's state_flags
 224 **/
 225void
 226__fnic_set_state_flags(struct fnic *fnic, unsigned long st_flags,
 227			unsigned long clearbits)
 228{
 229	unsigned long flags = 0;
 230
 231	spin_lock_irqsave(&fnic->fnic_lock, flags);
 232
 233	if (clearbits)
 234		fnic->state_flags &= ~st_flags;
 235	else
 236		fnic->state_flags |= st_flags;
 237
 238	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 239
 240	return;
 241}
 242
 243
 244/*
 245 * fnic_fw_reset_handler
 246 * Routine to send reset msg to fw
 247 */
 248int fnic_fw_reset_handler(struct fnic *fnic)
 249{
 250	struct vnic_wq_copy *wq = &fnic->hw_copy_wq[0];
 251	int ret = 0;
 252	unsigned long flags;
 253	unsigned int ioreq_count;
 254
 255	/* indicate fwreset to io path */
 256	fnic_set_state_flags(fnic, FNIC_FLAGS_FWRESET);
 257	ioreq_count = fnic_count_all_ioreqs(fnic);
 258
 259	/* wait for io cmpl */
 260	while (atomic_read(&fnic->in_flight))
 261		schedule_timeout(msecs_to_jiffies(1));
 262
 263	spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 264
 265	if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
 266		free_wq_copy_descs(fnic, wq, 0);
 267
 268	if (!vnic_wq_copy_desc_avail(wq))
 269		ret = -EAGAIN;
 270	else {
 271		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 272			  "ioreq_count: %u\n", ioreq_count);
 273		fnic_queue_wq_copy_desc_fw_reset(wq, SCSI_NO_TAG);
 274		atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 275		if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 276			  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 277			atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 278				atomic64_read(
 279				  &fnic->fnic_stats.fw_stats.active_fw_reqs));
 280	}
 281
 282	spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 283
 284	if (!ret) {
 285		atomic64_inc(&fnic->fnic_stats.reset_stats.fw_resets);
 286		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 287				"Issued fw reset\n");
 288	} else {
 289		fnic_clear_state_flags(fnic, FNIC_FLAGS_FWRESET);
 290		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 291				"Failed to issue fw reset\n");
 292	}
 293
 294	return ret;
 295}
 296
 297
 298/*
 299 * fnic_flogi_reg_handler
 300 * Routine to send flogi register msg to fw
 301 */
 302int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
 303{
 304	struct vnic_wq_copy *wq = &fnic->hw_copy_wq[0];
 305	enum fcpio_flogi_reg_format_type format;
 306	u8 gw_mac[ETH_ALEN];
 307	int ret = 0;
 308	unsigned long flags;
 309	struct fnic_iport_s *iport = &fnic->iport;
 310
 311	spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 312
 313	if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
 314		free_wq_copy_descs(fnic, wq, 0);
 315
 316	if (!vnic_wq_copy_desc_avail(wq)) {
 317		ret = -EAGAIN;
 318		goto flogi_reg_ioreq_end;
 319	}
 320
 321	memcpy(gw_mac, fnic->iport.fcfmac, ETH_ALEN);
 322	format = FCPIO_FLOGI_REG_GW_DEST;
 323
 324	if (fnic->config.flags & VFCF_FIP_CAPABLE) {
 325		fnic_queue_wq_copy_desc_fip_reg(wq, SCSI_NO_TAG,
 326						fc_id, gw_mac,
 327						fnic->iport.fpma,
 328						iport->r_a_tov, iport->e_d_tov);
 329		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 330			      "FLOGI FIP reg issued fcid: 0x%x src %p dest %p\n",
 331				  fc_id, fnic->iport.fpma, gw_mac);
 332	} else {
 333		fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
 334						  format, fc_id, gw_mac);
 335		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 336			"FLOGI reg issued fcid 0x%x dest %p\n",
 337			fc_id, gw_mac);
 338	}
 339
 340	atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 341	if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 342		  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 343		atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 344		  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
 345
 346flogi_reg_ioreq_end:
 347	spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 348	return ret;
 349}
 350
 351/*
 352 * fnic_queue_wq_copy_desc
 353 * Routine to enqueue a wq copy desc
 354 */
 355static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
 356					  struct vnic_wq_copy *wq,
 357					  struct fnic_io_req *io_req,
 358					  struct scsi_cmnd *sc,
 359					  int sg_count,
 360					  uint32_t mqtag,
 361					  uint16_t hwq)
 362{
 363	struct scatterlist *sg;
 364	struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
 365	struct host_sg_desc *desc;
 366	struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
 367	unsigned int i;
 368	int flags;
 369	u8 exch_flags;
 370	struct scsi_lun fc_lun;
 371	struct fnic_tport_s *tport;
 372	struct rport_dd_data_s *rdd_data;
 373
 374	rdd_data = rport->dd_data;
 375	tport = rdd_data->tport;
 376
 377	if (sg_count) {
 378		/* For each SGE, create a device desc entry */
 379		desc = io_req->sgl_list;
 380		for_each_sg(scsi_sglist(sc), sg, sg_count, i) {
 381			desc->addr = cpu_to_le64(sg_dma_address(sg));
 382			desc->len = cpu_to_le32(sg_dma_len(sg));
 383			desc->_resvd = 0;
 384			desc++;
 385		}
 386
 387		io_req->sgl_list_pa = dma_map_single(&fnic->pdev->dev,
 388				io_req->sgl_list,
 389				sizeof(io_req->sgl_list[0]) * sg_count,
 390				DMA_TO_DEVICE);
 391		if (dma_mapping_error(&fnic->pdev->dev, io_req->sgl_list_pa)) {
 392			printk(KERN_ERR "DMA mapping failed\n");
 393			return SCSI_MLQUEUE_HOST_BUSY;
 394		}
 395	}
 396
 397	io_req->sense_buf_pa = dma_map_single(&fnic->pdev->dev,
 398					      sc->sense_buffer,
 399					      SCSI_SENSE_BUFFERSIZE,
 400					      DMA_FROM_DEVICE);
 401	if (dma_mapping_error(&fnic->pdev->dev, io_req->sense_buf_pa)) {
 402		dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
 403				sizeof(io_req->sgl_list[0]) * sg_count,
 404				DMA_TO_DEVICE);
 405		printk(KERN_ERR "DMA mapping failed\n");
 406		return SCSI_MLQUEUE_HOST_BUSY;
 407	}
 408
 409	int_to_scsilun(sc->device->lun, &fc_lun);
 410
 411	/* Enqueue the descriptor in the Copy WQ */
 412	if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[hwq])
 413		free_wq_copy_descs(fnic, wq, hwq);
 414
 415	if (unlikely(!vnic_wq_copy_desc_avail(wq))) {
 416		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 417			  "fnic_queue_wq_copy_desc failure - no descriptors\n");
 418		atomic64_inc(&misc_stats->io_cpwq_alloc_failures);
 419		return SCSI_MLQUEUE_HOST_BUSY;
 420	}
 421
 422	flags = 0;
 423	if (sc->sc_data_direction == DMA_FROM_DEVICE)
 424		flags = FCPIO_ICMND_RDDATA;
 425	else if (sc->sc_data_direction == DMA_TO_DEVICE)
 426		flags = FCPIO_ICMND_WRDATA;
 427
 428	exch_flags = 0;
 429	if ((fnic->config.flags & VFCF_FCP_SEQ_LVL_ERR) &&
 430		(tport->tgt_flags & FDLS_FC_RP_FLAGS_RETRY))
 431		exch_flags |= FCPIO_ICMND_SRFLAG_RETRY;
 432
 433	fnic_queue_wq_copy_desc_icmnd_16(wq, mqtag,
 434					 0, exch_flags, io_req->sgl_cnt,
 435					 SCSI_SENSE_BUFFERSIZE,
 436					 io_req->sgl_list_pa,
 437					 io_req->sense_buf_pa,
 438					 0, /* scsi cmd ref, always 0 */
 439					 FCPIO_ICMND_PTA_SIMPLE,
 440					 	/* scsi pri and tag */
 441					 flags,	/* command flags */
 442					 sc->cmnd, sc->cmd_len,
 443					 scsi_bufflen(sc),
 444					 fc_lun.scsi_lun, io_req->port_id,
 445					 tport->max_payload_size,
 446					 tport->r_a_tov, tport->e_d_tov);
 447
 448	atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 449	if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 450		  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 451		atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 452		  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
 453
 454	return 0;
 455}
 456
 457int fnic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
 458{
 459	struct request *const rq = scsi_cmd_to_rq(sc);
 460	uint32_t mqtag = 0;
 461	void (*done)(struct scsi_cmnd *) = scsi_done;
 462	struct fc_rport *rport;
 463	struct fnic_io_req *io_req = NULL;
 464	struct fnic *fnic = *((struct fnic **) shost_priv(sc->device->host));
 465	struct fnic_iport_s *iport = NULL;
 466	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 467	struct vnic_wq_copy *wq;
 468	int ret = 1;
 469	u64 cmd_trace;
 470	int sg_count = 0;
 471	unsigned long flags = 0;
 472	unsigned long ptr;
 473	int io_lock_acquired = 0;
 474	uint16_t hwq = 0;
 475	struct fnic_tport_s *tport = NULL;
 476	struct rport_dd_data_s *rdd_data;
 477	uint16_t lun0_delay = 0;
 478
 479	rport = starget_to_rport(scsi_target(sc->device));
 480	if (!rport) {
 481		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 482				"returning DID_NO_CONNECT for IO as rport is NULL\n");
 483		sc->result = DID_NO_CONNECT << 16;
 484		done(sc);
 485		return 0;
 486	}
 487
 488	ret = fc_remote_port_chkready(rport);
 489	if (ret) {
 490		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 491				"rport is not ready\n");
 492		atomic64_inc(&fnic_stats->misc_stats.tport_not_ready);
 493		sc->result = ret;
 494		done(sc);
 495		return 0;
 496	}
 497
 498	mqtag = blk_mq_unique_tag(rq);
 499	spin_lock_irqsave(&fnic->fnic_lock, flags);
 500	iport = &fnic->iport;
 501
 502	if (iport->state != FNIC_IPORT_STATE_READY) {
 503		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 504		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 505					  "returning DID_NO_CONNECT for IO as iport state: %d\n",
 506					  iport->state);
 507		sc->result = DID_NO_CONNECT << 16;
 508		done(sc);
 509		return 0;
 510	}
 511
 512	/* fc_remote_port_add() may have added the tport to
 513	 * fc_transport but dd_data not yet set
 514	 */
 515	rdd_data = rport->dd_data;
 516	tport = rdd_data->tport;
 517	if (!tport || (rdd_data->iport != iport)) {
 518		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 519					  "dd_data not yet set in SCSI for rport portid: 0x%x\n",
 520					  rport->port_id);
 521		tport = fnic_find_tport_by_fcid(iport, rport->port_id);
 522		if (!tport) {
 523			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 524			FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 525						  "returning DID_BUS_BUSY for IO as tport not found for: 0x%x\n",
 526						  rport->port_id);
 527			sc->result = DID_BUS_BUSY << 16;
 528			done(sc);
 529			return 0;
 530		}
 531
 532		/* Re-assign same params as in fnic_fdls_add_tport */
 533		rport->maxframe_size = FNIC_FC_MAX_PAYLOAD_LEN;
 534		rport->supported_classes =
 535			FC_COS_CLASS3 | FC_RPORT_ROLE_FCP_TARGET;
 536		/* the dd_data is allocated by fctransport of size dd_fcrport_size */
 537		rdd_data = rport->dd_data;
 538		rdd_data->tport = tport;
 539		rdd_data->iport = iport;
 540		tport->rport = rport;
 541		tport->flags |= FNIC_FDLS_SCSI_REGISTERED;
 542	}
 543
 544	if ((tport->state != FDLS_TGT_STATE_READY)
 545		&& (tport->state != FDLS_TGT_STATE_ADISC)) {
 546		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 547		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 548					  "returning DID_NO_CONNECT for IO as tport state: %d\n",
 549					  tport->state);
 550		sc->result = DID_NO_CONNECT << 16;
 551		done(sc);
 552		return 0;
 553	}
 554
 555	atomic_inc(&fnic->in_flight);
 556	atomic_inc(&tport->in_flight);
 557
 558	if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_IO_BLOCKED))) {
 559		atomic_dec(&fnic->in_flight);
 560		atomic_dec(&tport->in_flight);
 561		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 562		return SCSI_MLQUEUE_HOST_BUSY;
 563	}
 564
 565	if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_FWRESET))) {
 566		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 567		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 568		  "fnic flags FW reset: 0x%lx. Returning SCSI_MLQUEUE_HOST_BUSY\n",
 569		  fnic->state_flags);
 570		return SCSI_MLQUEUE_HOST_BUSY;
 571	}
 572
 573	if (!tport->lun0_delay) {
 574		lun0_delay = 1;
 575		tport->lun0_delay++;
 576	}
 577
 578	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 579
 580	fnic_priv(sc)->state = FNIC_IOREQ_NOT_INITED;
 581	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
 582
 583	/* Get a new io_req for this SCSI IO */
 584	io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
 585	if (!io_req) {
 586		atomic64_inc(&fnic_stats->io_stats.alloc_failures);
 587		ret = SCSI_MLQUEUE_HOST_BUSY;
 588		goto out;
 589	}
 590	memset(io_req, 0, sizeof(*io_req));
 591
 592	/* Map the data buffer */
 593	sg_count = scsi_dma_map(sc);
 594	if (sg_count < 0) {
 595		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 596			  mqtag, sc, 0, sc->cmnd[0], sg_count, fnic_priv(sc)->state);
 597		mempool_free(io_req, fnic->io_req_pool);
 598		goto out;
 599	}
 600
 601	io_req->tport = tport;
 602	/* Determine the type of scatter/gather list we need */
 603	io_req->sgl_cnt = sg_count;
 604	io_req->sgl_type = FNIC_SGL_CACHE_DFLT;
 605	if (sg_count > FNIC_DFLT_SG_DESC_CNT)
 606		io_req->sgl_type = FNIC_SGL_CACHE_MAX;
 607
 608	if (sg_count) {
 609		io_req->sgl_list =
 610			mempool_alloc(fnic->io_sgl_pool[io_req->sgl_type],
 611				      GFP_ATOMIC);
 612		if (!io_req->sgl_list) {
 613			atomic64_inc(&fnic_stats->io_stats.alloc_failures);
 614			ret = SCSI_MLQUEUE_HOST_BUSY;
 615			scsi_dma_unmap(sc);
 616			mempool_free(io_req, fnic->io_req_pool);
 617			goto out;
 618		}
 619
 620		/* Cache sgl list allocated address before alignment */
 621		io_req->sgl_list_alloc = io_req->sgl_list;
 622		ptr = (unsigned long) io_req->sgl_list;
 623		if (ptr % FNIC_SG_DESC_ALIGN) {
 624			io_req->sgl_list = (struct host_sg_desc *)
 625				(((unsigned long) ptr
 626				  + FNIC_SG_DESC_ALIGN - 1)
 627				 & ~(FNIC_SG_DESC_ALIGN - 1));
 628		}
 629	}
 630
 631	/*
 632	* Will acquire lock before setting to IO initialized.
 633	*/
 634	hwq = blk_mq_unique_tag_to_hwq(mqtag);
 635	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
 636
 637	/* initialize rest of io_req */
 638	io_lock_acquired = 1;
 639	io_req->port_id = rport->port_id;
 640	io_req->start_time = jiffies;
 641	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
 642	fnic_priv(sc)->io_req = io_req;
 643	fnic_priv(sc)->flags |= FNIC_IO_INITIALIZED;
 644	io_req->sc = sc;
 645
 646	if (fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] != NULL) {
 647		WARN(1, "fnic<%d>: %s: hwq: %d tag 0x%x already exists\n",
 648				fnic->fnic_num, __func__, hwq, blk_mq_unique_tag_to_tag(mqtag));
 649		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 650		return SCSI_MLQUEUE_HOST_BUSY;
 651	}
 652
 653	fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] = io_req;
 654	io_req->tag = mqtag;
 655
 656	/* create copy wq desc and enqueue it */
 657	wq = &fnic->hw_copy_wq[hwq];
 658	atomic64_inc(&fnic_stats->io_stats.ios[hwq]);
 659	ret = fnic_queue_wq_copy_desc(fnic, wq, io_req, sc, sg_count, mqtag, hwq);
 660	if (ret) {
 661		/*
 662		 * In case another thread cancelled the request,
 663		 * refetch the pointer under the lock.
 664		 */
 665		FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 666			  mqtag, sc, 0, 0, 0, fnic_flags_and_state(sc));
 667		io_req = fnic_priv(sc)->io_req;
 668		fnic_priv(sc)->io_req = NULL;
 669		if (io_req)
 670			fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] = NULL;
 671		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
 672		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 673		if (io_req) {
 674			fnic_release_ioreq_buf(fnic, io_req, sc);
 675			mempool_free(io_req, fnic->io_req_pool);
 676		}
 677		atomic_dec(&fnic->in_flight);
 678		atomic_dec(&tport->in_flight);
 679		return ret;
 680	} else {
 681		atomic64_inc(&fnic_stats->io_stats.active_ios);
 682		atomic64_inc(&fnic_stats->io_stats.num_ios);
 683		if (atomic64_read(&fnic_stats->io_stats.active_ios) >
 684			  atomic64_read(&fnic_stats->io_stats.max_active_ios))
 685			atomic64_set(&fnic_stats->io_stats.max_active_ios,
 686			     atomic64_read(&fnic_stats->io_stats.active_ios));
 687
 688		/* REVISIT: Use per IO lock in the final code */
 689		fnic_priv(sc)->flags |= FNIC_IO_ISSUED;
 690	}
 691out:
 692	cmd_trace = ((u64)sc->cmnd[0] << 56 | (u64)sc->cmnd[7] << 40 |
 693			(u64)sc->cmnd[8] << 32 | (u64)sc->cmnd[2] << 24 |
 694			(u64)sc->cmnd[3] << 16 | (u64)sc->cmnd[4] << 8 |
 695			sc->cmnd[5]);
 696
 697	FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 698		   mqtag, sc, io_req, sg_count, cmd_trace,
 699		   fnic_flags_and_state(sc));
 700
 701	/* if only we issued IO, will we have the io lock */
 702	if (io_lock_acquired)
 703		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 704
 705	atomic_dec(&fnic->in_flight);
 706	atomic_dec(&tport->in_flight);
 707
 708	if (lun0_delay) {
 709		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 710					  "LUN0 delay\n");
 711		mdelay(LUN0_DELAY_TIME);
 712	}
 713
 714	return ret;
 715}
 716
 717
 718/*
 719 * fnic_fcpio_fw_reset_cmpl_handler
 720 * Routine to handle fw reset completion
 721 */
 722static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
 723					    struct fcpio_fw_req *desc)
 724{
 725	u8 type;
 726	u8 hdr_status;
 727	struct fcpio_tag tag;
 728	int ret = 0;
 729	unsigned long flags;
 730	struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
 731
 732	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 733
 734	atomic64_inc(&reset_stats->fw_reset_completions);
 735
 736	/* Clean up all outstanding io requests */
 737	fnic_cleanup_io(fnic, SCSI_NO_TAG);
 738
 739	atomic64_set(&fnic->fnic_stats.fw_stats.active_fw_reqs, 0);
 740	atomic64_set(&fnic->fnic_stats.io_stats.active_ios, 0);
 741	atomic64_set(&fnic->io_cmpl_skip, 0);
 742
 743	spin_lock_irqsave(&fnic->fnic_lock, flags);
 744
 745	/* fnic should be in FC_TRANS_ETH_MODE */
 746	if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) {
 747		/* Check status of reset completion */
 748		if (!hdr_status) {
 749			FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
 750					"reset cmpl success\n");
 751			/* Ready to send flogi out */
 752			fnic->state = FNIC_IN_ETH_MODE;
 753		} else {
 754			FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 755				"reset failed with header status: %s\n",
 756				fnic_fcpio_status_to_str(hdr_status));
 757
 758			fnic->state = FNIC_IN_FC_MODE;
 759			atomic64_inc(&reset_stats->fw_reset_failures);
 760			ret = -1;
 761		}
 762	} else {
 763		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 764			"Unexpected state while processing reset completion: %s\n",
 765			fnic_state_to_str(fnic->state));
 766		atomic64_inc(&reset_stats->fw_reset_failures);
 767		ret = -1;
 768	}
 769
 770	if (fnic->fw_reset_done)
 771		complete(fnic->fw_reset_done);
 772
 773	/*
 774	 * If fnic is being removed, or fw reset failed
 775	 * free the flogi frame. Else, send it out
 776	 */
 777	if (ret) {
 778		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 779		fnic_free_txq(&fnic->tx_queue);
 780		goto reset_cmpl_handler_end;
 781	}
 782
 783	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 784
 785	queue_work(fnic_event_queue, &fnic->flush_work);
 786
 787 reset_cmpl_handler_end:
 788	fnic_clear_state_flags(fnic, FNIC_FLAGS_FWRESET);
 789
 790	return ret;
 791}
 792
 793/*
 794 * fnic_fcpio_flogi_reg_cmpl_handler
 795 * Routine to handle flogi register completion
 796 */
 797static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
 798					     struct fcpio_fw_req *desc)
 799{
 800	u8 type;
 801	u8 hdr_status;
 802	struct fcpio_tag tag;
 803	int ret = 0;
 804	unsigned long flags;
 805
 806	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 807
 808	/* Update fnic state based on status of flogi reg completion */
 809	spin_lock_irqsave(&fnic->fnic_lock, flags);
 810
 811	if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) {
 812
 813		/* Check flogi registration completion status */
 814		if (!hdr_status) {
 815			FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
 816				      "FLOGI reg succeeded\n");
 817			fnic->state = FNIC_IN_FC_MODE;
 818		} else {
 819			FNIC_SCSI_DBG(KERN_DEBUG,
 820				      fnic->host, fnic->fnic_num,
 821				      "fnic flogi reg failed: %s\n",
 822				      fnic_fcpio_status_to_str(hdr_status));
 823			fnic->state = FNIC_IN_ETH_MODE;
 824			ret = -1;
 825		}
 826	} else {
 827		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
 828			      "Unexpected fnic state %s while"
 829			      " processing flogi reg completion\n",
 830			      fnic_state_to_str(fnic->state));
 831		ret = -1;
 832	}
 833
 834	if (!ret) {
 835		if (fnic->stop_rx_link_events) {
 836			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 837			goto reg_cmpl_handler_end;
 838		}
 839		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 840
 841		queue_work(fnic_event_queue, &fnic->flush_work);
 842		queue_work(fnic_event_queue, &fnic->frame_work);
 843	} else {
 844		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 845	}
 846
 847reg_cmpl_handler_end:
 848	return ret;
 849}
 850
 851static inline int is_ack_index_in_range(struct vnic_wq_copy *wq,
 852					u16 request_out)
 853{
 854	if (wq->to_clean_index <= wq->to_use_index) {
 855		/* out of range, stale request_out index */
 856		if (request_out < wq->to_clean_index ||
 857		    request_out >= wq->to_use_index)
 858			return 0;
 859	} else {
 860		/* out of range, stale request_out index */
 861		if (request_out < wq->to_clean_index &&
 862		    request_out >= wq->to_use_index)
 863			return 0;
 864	}
 865	/* request_out index is in range */
 866	return 1;
 867}
 868
 869
 870/*
 871 * Mark that ack received and store the Ack index. If there are multiple
 872 * acks received before Tx thread cleans it up, the latest value will be
 873 * used which is correct behavior. This state should be in the copy Wq
 874 * instead of in the fnic
 875 */
 876static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
 877					  unsigned int cq_index,
 878					  struct fcpio_fw_req *desc)
 879{
 880	struct vnic_wq_copy *wq;
 881	u16 request_out = desc->u.ack.request_out;
 882	unsigned long flags;
 883	u64 *ox_id_tag = (u64 *)(void *)desc;
 884	unsigned int wq_index = cq_index;
 885
 886	/* mark the ack state */
 887	wq = &fnic->hw_copy_wq[cq_index];
 888	spin_lock_irqsave(&fnic->wq_copy_lock[wq_index], flags);
 889
 890	fnic->fnic_stats.misc_stats.last_ack_time = jiffies;
 891	if (is_ack_index_in_range(wq, request_out)) {
 892		fnic->fw_ack_index[wq_index] = request_out;
 893		fnic->fw_ack_recd[wq_index] = 1;
 894	} else
 895		atomic64_inc(
 896			&fnic->fnic_stats.misc_stats.ack_index_out_of_range);
 897
 898	spin_unlock_irqrestore(&fnic->wq_copy_lock[wq_index], flags);
 899	FNIC_TRACE(fnic_fcpio_ack_handler,
 900		  fnic->host->host_no, 0, 0, ox_id_tag[2], ox_id_tag[3],
 901		  ox_id_tag[4], ox_id_tag[5]);
 902}
 903
 904/*
 905 * fnic_fcpio_icmnd_cmpl_handler
 906 * Routine to handle icmnd completions
 907 */
 908static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic, unsigned int cq_index,
 909					 struct fcpio_fw_req *desc)
 910{
 911	u8 type;
 912	u8 hdr_status;
 913	struct fcpio_tag ftag;
 914	u32 id;
 915	u64 xfer_len = 0;
 916	struct fcpio_icmnd_cmpl *icmnd_cmpl;
 917	struct fnic_io_req *io_req;
 918	struct scsi_cmnd *sc;
 919	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 920	unsigned long flags;
 921	u64 cmd_trace;
 922	unsigned long start_time;
 923	unsigned long io_duration_time;
 924	unsigned int hwq = 0;
 925	unsigned int mqtag = 0;
 926	unsigned int tag = 0;
 927
 928	/* Decode the cmpl description to get the io_req id */
 929	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &ftag);
 930	fcpio_tag_id_dec(&ftag, &id);
 931	icmnd_cmpl = &desc->u.icmnd_cmpl;
 932
 933	mqtag = id;
 934	tag = blk_mq_unique_tag_to_tag(mqtag);
 935	hwq = blk_mq_unique_tag_to_hwq(mqtag);
 936
 937	if (hwq != cq_index) {
 938		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 939			"hwq: %d mqtag: 0x%x tag: 0x%x cq index: %d ",
 940			hwq, mqtag, tag, cq_index);
 941		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 942			"hdr status: %s icmnd completion on the wrong queue\n",
 943			fnic_fcpio_status_to_str(hdr_status));
 944	}
 945
 946	if (tag >= fnic->fnic_max_tag_id) {
 947		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 948			"hwq: %d mqtag: 0x%x tag: 0x%x cq index: %d ",
 949			hwq, mqtag, tag, cq_index);
 950		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
 951			"hdr status: %s Out of range tag\n",
 952			fnic_fcpio_status_to_str(hdr_status));
 953		return;
 954	}
 955	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
 956
 957	sc = scsi_host_find_tag(fnic->host, id);
 958	WARN_ON_ONCE(!sc);
 959	if (!sc) {
 960		atomic64_inc(&fnic_stats->io_stats.sc_null);
 961		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 962		shost_printk(KERN_ERR, fnic->host,
 963			  "icmnd_cmpl sc is null - "
 964			  "hdr status = %s tag = 0x%x desc = 0x%p\n",
 965			  fnic_fcpio_status_to_str(hdr_status), id, desc);
 966		FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
 967			  fnic->host->host_no, id,
 968			  ((u64)icmnd_cmpl->_resvd0[1] << 16 |
 969			  (u64)icmnd_cmpl->_resvd0[0]),
 970			  ((u64)hdr_status << 16 |
 971			  (u64)icmnd_cmpl->scsi_status << 8 |
 972			  (u64)icmnd_cmpl->flags), desc,
 973			  (u64)icmnd_cmpl->residual, 0);
 974		return;
 975	}
 976
 977	io_req = fnic_priv(sc)->io_req;
 978	if (fnic->sw_copy_wq[hwq].io_req_table[tag] != io_req) {
 979		WARN(1, "%s: %d: hwq: %d mqtag: 0x%x tag: 0x%x io_req tag mismatch\n",
 980			__func__, __LINE__, hwq, mqtag, tag);
 981		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 982		return;
 983	}
 984
 985	WARN_ON_ONCE(!io_req);
 986	if (!io_req) {
 987		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
 988		fnic_priv(sc)->flags |= FNIC_IO_REQ_NULL;
 989		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
 990		shost_printk(KERN_ERR, fnic->host,
 991			  "icmnd_cmpl io_req is null - "
 992			  "hdr status = %s tag = 0x%x sc 0x%p\n",
 993			  fnic_fcpio_status_to_str(hdr_status), id, sc);
 994		return;
 995	}
 996	start_time = io_req->start_time;
 997
 998	/* firmware completed the io */
 999	io_req->io_completed = 1;
1000
1001	/*
1002	 *  if SCSI-ML has already issued abort on this command,
1003	 *  set completion of the IO. The abts path will clean it up
1004	 */
1005	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
1006
1007		/*
1008		 * set the FNIC_IO_DONE so that this doesn't get
1009		 * flagged as 'out of order' if it was not aborted
1010		 */
1011		fnic_priv(sc)->flags |= FNIC_IO_DONE;
1012		fnic_priv(sc)->flags |= FNIC_IO_ABTS_PENDING;
1013		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1014		if(FCPIO_ABORTED == hdr_status)
1015			fnic_priv(sc)->flags |= FNIC_IO_ABORTED;
1016
1017		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
1018			"icmnd_cmpl abts pending "
1019			  "hdr status = %s tag = 0x%x sc = 0x%p "
1020			  "scsi_status = %x residual = %d\n",
1021			  fnic_fcpio_status_to_str(hdr_status),
1022			  id, sc,
1023			  icmnd_cmpl->scsi_status,
1024			  icmnd_cmpl->residual);
1025		return;
1026	}
1027
1028	/* Mark the IO as complete */
1029	fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
1030
1031	icmnd_cmpl = &desc->u.icmnd_cmpl;
1032
1033	switch (hdr_status) {
1034	case FCPIO_SUCCESS:
1035		sc->result = (DID_OK << 16) | icmnd_cmpl->scsi_status;
1036		xfer_len = scsi_bufflen(sc);
1037
1038		if (icmnd_cmpl->flags & FCPIO_ICMND_CMPL_RESID_UNDER) {
1039			xfer_len -= icmnd_cmpl->residual;
1040			scsi_set_resid(sc, icmnd_cmpl->residual);
1041		}
1042
1043		if (icmnd_cmpl->scsi_status == SAM_STAT_CHECK_CONDITION)
1044			atomic64_inc(&fnic_stats->misc_stats.check_condition);
1045
1046		if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL)
1047			atomic64_inc(&fnic_stats->misc_stats.queue_fulls);
1048
1049		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1050				"xfer_len: %llu", xfer_len);
1051		break;
1052
1053	case FCPIO_TIMEOUT:          /* request was timed out */
1054		atomic64_inc(&fnic_stats->misc_stats.fcpio_timeout);
1055		sc->result = (DID_TIME_OUT << 16) | icmnd_cmpl->scsi_status;
1056		break;
1057
1058	case FCPIO_ABORTED:          /* request was aborted */
1059		atomic64_inc(&fnic_stats->misc_stats.fcpio_aborted);
1060		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1061		break;
1062
1063	case FCPIO_DATA_CNT_MISMATCH: /* recv/sent more/less data than exp. */
1064		atomic64_inc(&fnic_stats->misc_stats.data_count_mismatch);
1065		scsi_set_resid(sc, icmnd_cmpl->residual);
1066		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1067		break;
1068
1069	case FCPIO_OUT_OF_RESOURCE:  /* out of resources to complete request */
1070		atomic64_inc(&fnic_stats->fw_stats.fw_out_of_resources);
1071		sc->result = (DID_REQUEUE << 16) | icmnd_cmpl->scsi_status;
1072		break;
1073
1074	case FCPIO_IO_NOT_FOUND:     /* requested I/O was not found */
1075		atomic64_inc(&fnic_stats->io_stats.io_not_found);
1076		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1077		break;
1078
1079	case FCPIO_SGL_INVALID:      /* request was aborted due to sgl error */
1080		atomic64_inc(&fnic_stats->misc_stats.sgl_invalid);
1081		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1082		break;
1083
1084	case FCPIO_FW_ERR:           /* request was terminated due fw error */
1085		atomic64_inc(&fnic_stats->fw_stats.io_fw_errs);
1086		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1087		break;
1088
1089	case FCPIO_MSS_INVALID:      /* request was aborted due to mss error */
1090		atomic64_inc(&fnic_stats->misc_stats.mss_invalid);
1091		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1092		break;
1093
1094	case FCPIO_INVALID_HEADER:   /* header contains invalid data */
1095	case FCPIO_INVALID_PARAM:    /* some parameter in request invalid */
1096	case FCPIO_REQ_NOT_SUPPORTED:/* request type is not supported */
1097	default:
1098		sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
1099		break;
1100	}
1101
1102	/* Break link with the SCSI command */
1103	fnic_priv(sc)->io_req = NULL;
1104	io_req->sc = NULL;
1105	fnic_priv(sc)->flags |= FNIC_IO_DONE;
1106	fnic->sw_copy_wq[hwq].io_req_table[tag] = NULL;
1107
1108	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1109
1110	if (hdr_status != FCPIO_SUCCESS) {
1111		atomic64_inc(&fnic_stats->io_stats.io_failures);
1112		shost_printk(KERN_ERR, fnic->host, "hdr status = %s\n",
1113			     fnic_fcpio_status_to_str(hdr_status));
1114	}
1115
1116	fnic_release_ioreq_buf(fnic, io_req, sc);
1117
1118	cmd_trace = ((u64)hdr_status << 56) |
1119		  (u64)icmnd_cmpl->scsi_status << 48 |
1120		  (u64)icmnd_cmpl->flags << 40 | (u64)sc->cmnd[0] << 32 |
1121		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
1122		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5];
1123
1124	FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
1125		  sc->device->host->host_no, id, sc,
1126		  ((u64)icmnd_cmpl->_resvd0[1] << 56 |
1127		  (u64)icmnd_cmpl->_resvd0[0] << 48 |
1128		  jiffies_to_msecs(jiffies - start_time)),
1129		  desc, cmd_trace, fnic_flags_and_state(sc));
1130
1131	if (sc->sc_data_direction == DMA_FROM_DEVICE) {
1132		fnic_stats->host_stats.fcp_input_requests++;
1133		fnic->fcp_input_bytes += xfer_len;
1134	} else if (sc->sc_data_direction == DMA_TO_DEVICE) {
1135		fnic_stats->host_stats.fcp_output_requests++;
1136		fnic->fcp_output_bytes += xfer_len;
1137	} else
1138		fnic_stats->host_stats.fcp_control_requests++;
1139
1140	/* Call SCSI completion function to complete the IO */
1141	scsi_done(sc);
1142
1143	mempool_free(io_req, fnic->io_req_pool);
1144
1145	atomic64_dec(&fnic_stats->io_stats.active_ios);
1146	if (atomic64_read(&fnic->io_cmpl_skip))
1147		atomic64_dec(&fnic->io_cmpl_skip);
1148	else
1149		atomic64_inc(&fnic_stats->io_stats.io_completions);
1150
1151
1152	io_duration_time = jiffies_to_msecs(jiffies) -
1153						jiffies_to_msecs(start_time);
1154
1155	if(io_duration_time <= 10)
1156		atomic64_inc(&fnic_stats->io_stats.io_btw_0_to_10_msec);
1157	else if(io_duration_time <= 100)
1158		atomic64_inc(&fnic_stats->io_stats.io_btw_10_to_100_msec);
1159	else if(io_duration_time <= 500)
1160		atomic64_inc(&fnic_stats->io_stats.io_btw_100_to_500_msec);
1161	else if(io_duration_time <= 5000)
1162		atomic64_inc(&fnic_stats->io_stats.io_btw_500_to_5000_msec);
1163	else if(io_duration_time <= 10000)
1164		atomic64_inc(&fnic_stats->io_stats.io_btw_5000_to_10000_msec);
1165	else if(io_duration_time <= 30000)
1166		atomic64_inc(&fnic_stats->io_stats.io_btw_10000_to_30000_msec);
1167	else {
1168		atomic64_inc(&fnic_stats->io_stats.io_greater_than_30000_msec);
1169
1170		if(io_duration_time > atomic64_read(&fnic_stats->io_stats.current_max_io_time))
1171			atomic64_set(&fnic_stats->io_stats.current_max_io_time, io_duration_time);
1172	}
1173}
1174
1175/* fnic_fcpio_itmf_cmpl_handler
1176 * Routine to handle itmf completions
1177 */
1178static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic, unsigned int cq_index,
1179					struct fcpio_fw_req *desc)
1180{
1181	u8 type;
1182	u8 hdr_status;
1183	struct fcpio_tag ftag;
1184	u32 id;
1185	struct scsi_cmnd *sc = NULL;
1186	struct fnic_io_req *io_req;
1187	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1188	struct abort_stats *abts_stats = &fnic->fnic_stats.abts_stats;
1189	struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1190	struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1191	unsigned long flags;
1192	unsigned long start_time;
1193	unsigned int hwq = cq_index;
1194	unsigned int mqtag;
1195	unsigned int tag;
1196
1197	fcpio_header_dec(&desc->hdr, &type, &hdr_status, &ftag);
1198	fcpio_tag_id_dec(&ftag, &id);
1199
1200	mqtag = id & FNIC_TAG_MASK;
1201	tag = blk_mq_unique_tag_to_tag(id & FNIC_TAG_MASK);
1202	hwq = blk_mq_unique_tag_to_hwq(id & FNIC_TAG_MASK);
1203
1204	if (hwq != cq_index) {
1205		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1206			"hwq: %d mqtag: 0x%x tag: 0x%x cq index: %d ",
1207			hwq, mqtag, tag, cq_index);
1208		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1209			"hdr status: %s ITMF completion on the wrong queue\n",
1210			fnic_fcpio_status_to_str(hdr_status));
1211	}
1212
1213	if (tag > fnic->fnic_max_tag_id) {
1214		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1215			"hwq: %d mqtag: 0x%x tag: 0x%x cq index: %d ",
1216			hwq, mqtag, tag, cq_index);
1217		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1218			"hdr status: %s Tag out of range\n",
1219			fnic_fcpio_status_to_str(hdr_status));
1220		return;
1221	}  else if ((tag == fnic->fnic_max_tag_id) && !(id & FNIC_TAG_DEV_RST)) {
1222		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1223			"hwq: %d mqtag: 0x%x tag: 0x%x cq index: %d ",
1224			hwq, mqtag, tag, cq_index);
1225		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1226			"hdr status: %s Tag out of range\n",
1227			fnic_fcpio_status_to_str(hdr_status));
1228		return;
1229	}
1230
1231	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1232
1233	/* If it is sg3utils allocated SC then tag_id
1234	 * is max_tag_id and SC is retrieved from io_req
1235	 */
1236	if ((mqtag == fnic->fnic_max_tag_id) && (id & FNIC_TAG_DEV_RST)) {
1237		io_req = fnic->sw_copy_wq[hwq].io_req_table[tag];
1238		if (io_req)
1239			sc = io_req->sc;
1240	} else {
1241		sc = scsi_host_find_tag(fnic->host, id & FNIC_TAG_MASK);
1242	}
1243
1244	WARN_ON_ONCE(!sc);
1245	if (!sc) {
1246		atomic64_inc(&fnic_stats->io_stats.sc_null);
1247		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1248		shost_printk(KERN_ERR, fnic->host,
1249			  "itmf_cmpl sc is null - hdr status = %s tag = 0x%x\n",
1250			  fnic_fcpio_status_to_str(hdr_status), tag);
1251		return;
1252	}
1253
1254	io_req = fnic_priv(sc)->io_req;
1255	WARN_ON_ONCE(!io_req);
1256	if (!io_req) {
1257		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
1258		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1259		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
1260		shost_printk(KERN_ERR, fnic->host,
1261			  "itmf_cmpl io_req is null - "
1262			  "hdr status = %s tag = 0x%x sc 0x%p\n",
1263			  fnic_fcpio_status_to_str(hdr_status), tag, sc);
1264		return;
1265	}
1266	start_time = io_req->start_time;
1267
1268	if ((id & FNIC_TAG_ABORT) && (id & FNIC_TAG_DEV_RST)) {
1269		/* Abort and terminate completion of device reset req */
1270		/* REVISIT : Add asserts about various flags */
1271		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
1272			"hwq: %d mqtag: 0x%x tag: 0x%x hst: %s Abt/term completion received\n",
1273			hwq, mqtag, tag,
1274			fnic_fcpio_status_to_str(hdr_status));
1275		fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
1276		fnic_priv(sc)->abts_status = hdr_status;
1277		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
1278		if (io_req->abts_done)
1279			complete(io_req->abts_done);
1280		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1281	} else if (id & FNIC_TAG_ABORT) {
1282		/* Completion of abort cmd */
1283		shost_printk(KERN_DEBUG, fnic->host,
1284			"hwq: %d mqtag: 0x%x tag: 0x%x Abort header status: %s\n",
1285			hwq, mqtag, tag,
1286			fnic_fcpio_status_to_str(hdr_status));
1287		switch (hdr_status) {
1288		case FCPIO_SUCCESS:
1289			break;
1290		case FCPIO_TIMEOUT:
1291			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
1292				atomic64_inc(&abts_stats->abort_fw_timeouts);
1293			else
1294				atomic64_inc(
1295					&term_stats->terminate_fw_timeouts);
1296			break;
1297		case FCPIO_ITMF_REJECTED:
1298			FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
1299				"abort reject recd. id %d\n",
1300				(int)(id & FNIC_TAG_MASK));
1301			break;
1302		case FCPIO_IO_NOT_FOUND:
1303			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
1304				atomic64_inc(&abts_stats->abort_io_not_found);
1305			else
1306				atomic64_inc(
1307					&term_stats->terminate_io_not_found);
1308			break;
1309		default:
1310			if (fnic_priv(sc)->flags & FNIC_IO_ABTS_ISSUED)
1311				atomic64_inc(&abts_stats->abort_failures);
1312			else
1313				atomic64_inc(
1314					&term_stats->terminate_failures);
1315			break;
1316		}
1317		if (fnic_priv(sc)->state != FNIC_IOREQ_ABTS_PENDING) {
1318			/* This is a late completion. Ignore it */
1319			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1320			return;
1321		}
1322
1323		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
1324		fnic_priv(sc)->abts_status = hdr_status;
1325
1326		/* If the status is IO not found consider it as success */
1327		if (hdr_status == FCPIO_IO_NOT_FOUND)
1328			fnic_priv(sc)->abts_status = FCPIO_SUCCESS;
1329
1330		if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
1331			atomic64_inc(&misc_stats->no_icmnd_itmf_cmpls);
1332
1333		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1334			      "abts cmpl recd. id %d status %s\n",
1335			      (int)(id & FNIC_TAG_MASK),
1336			      fnic_fcpio_status_to_str(hdr_status));
1337
1338		/*
1339		 * If scsi_eh thread is blocked waiting for abts to complete,
1340		 * signal completion to it. IO will be cleaned in the thread
1341		 * else clean it in this context
1342		 */
1343		if (io_req->abts_done) {
1344			complete(io_req->abts_done);
1345			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1346			shost_printk(KERN_INFO, fnic->host,
1347					"hwq: %d mqtag: 0x%x tag: 0x%x Waking up abort thread\n",
1348					hwq, mqtag, tag);
1349		} else {
1350			FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1351				"hwq: %d mqtag: 0x%x tag: 0x%x hst: %s Completing IO\n",
1352				hwq, mqtag,
1353				tag, fnic_fcpio_status_to_str(hdr_status));
1354			fnic_priv(sc)->io_req = NULL;
1355			sc->result = (DID_ERROR << 16);
1356			fnic->sw_copy_wq[hwq].io_req_table[tag] = NULL;
1357			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1358
1359			fnic_release_ioreq_buf(fnic, io_req, sc);
1360			mempool_free(io_req, fnic->io_req_pool);
1361			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1362				   sc->device->host->host_no, id,
1363				   sc,
1364				   jiffies_to_msecs(jiffies - start_time),
1365				   desc,
1366				   (((u64)hdr_status << 40) |
1367				    (u64)sc->cmnd[0] << 32 |
1368				    (u64)sc->cmnd[2] << 24 |
1369				    (u64)sc->cmnd[3] << 16 |
1370				    (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1371				   fnic_flags_and_state(sc));
1372			scsi_done(sc);
1373			atomic64_dec(&fnic_stats->io_stats.active_ios);
1374			if (atomic64_read(&fnic->io_cmpl_skip))
1375				atomic64_dec(&fnic->io_cmpl_skip);
1376			else
1377				atomic64_inc(&fnic_stats->io_stats.io_completions);
1378		}
1379	} else if (id & FNIC_TAG_DEV_RST) {
1380		/* Completion of device reset */
1381		shost_printk(KERN_INFO, fnic->host,
1382			"hwq: %d mqtag: 0x%x tag: 0x%x DR hst: %s\n",
1383			hwq, mqtag,
1384			tag, fnic_fcpio_status_to_str(hdr_status));
1385		fnic_priv(sc)->lr_status = hdr_status;
1386		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
1387			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1388			fnic_priv(sc)->flags |= FNIC_DEV_RST_ABTS_PENDING;
1389			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1390				  sc->device->host->host_no, id, sc,
1391				  jiffies_to_msecs(jiffies - start_time),
1392				  desc, 0, fnic_flags_and_state(sc));
1393			FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1394				"hwq: %d mqtag: 0x%x tag: 0x%x hst: %s Terminate pending\n",
1395				hwq, mqtag,
1396				tag, fnic_fcpio_status_to_str(hdr_status));
1397			return;
1398		}
1399		if (fnic_priv(sc)->flags & FNIC_DEV_RST_TIMED_OUT) {
1400			/* Need to wait for terminate completion */
1401			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1402			FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1403				  sc->device->host->host_no, id, sc,
1404				  jiffies_to_msecs(jiffies - start_time),
1405				  desc, 0, fnic_flags_and_state(sc));
1406			FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1407				"dev reset cmpl recd after time out. "
1408				"id %d status %s\n",
1409				(int)(id & FNIC_TAG_MASK),
1410				fnic_fcpio_status_to_str(hdr_status));
1411			return;
1412		}
1413		fnic_priv(sc)->state = FNIC_IOREQ_CMD_COMPLETE;
1414		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
1415		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
1416			"hwq: %d mqtag: 0x%x tag: 0x%x hst: %s DR completion received\n",
1417			hwq, mqtag,
1418			tag, fnic_fcpio_status_to_str(hdr_status));
1419		if (io_req->dr_done)
1420			complete(io_req->dr_done);
1421		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1422
1423	} else {
1424		shost_printk(KERN_ERR, fnic->host,
1425			"%s: Unexpected itmf io state: hwq: %d tag 0x%x %s\n",
1426			__func__, hwq, id, fnic_ioreq_state_to_str(fnic_priv(sc)->state));
1427		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1428	}
1429
1430}
1431
1432/*
1433 * fnic_fcpio_cmpl_handler
1434 * Routine to service the cq for wq_copy
1435 */
1436static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
1437				   unsigned int cq_index,
1438				   struct fcpio_fw_req *desc)
1439{
1440	struct fnic *fnic = vnic_dev_priv(vdev);
1441
1442	switch (desc->hdr.type) {
1443	case FCPIO_ICMND_CMPL: /* fw completed a command */
1444	case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
1445	case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
1446	case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
1447	case FCPIO_RESET_CMPL: /* fw completed reset */
1448		atomic64_dec(&fnic->fnic_stats.fw_stats.active_fw_reqs);
1449		break;
1450	default:
1451		break;
1452	}
1453
1454	cq_index -= fnic->copy_wq_base;
1455
1456	switch (desc->hdr.type) {
1457	case FCPIO_ACK: /* fw copied copy wq desc to its queue */
1458		fnic_fcpio_ack_handler(fnic, cq_index, desc);
1459		break;
1460
1461	case FCPIO_ICMND_CMPL: /* fw completed a command */
1462		fnic_fcpio_icmnd_cmpl_handler(fnic, cq_index, desc);
1463		break;
1464
1465	case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
1466		fnic_fcpio_itmf_cmpl_handler(fnic, cq_index, desc);
1467		break;
1468
1469	case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
1470	case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
1471		fnic_fcpio_flogi_reg_cmpl_handler(fnic, desc);
1472		break;
1473
1474	case FCPIO_RESET_CMPL: /* fw completed reset */
1475		fnic_fcpio_fw_reset_cmpl_handler(fnic, desc);
1476		break;
1477
1478	default:
1479		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1480			      "firmware completion type %d\n",
1481			      desc->hdr.type);
1482		break;
1483	}
1484
1485	return 0;
1486}
1487
1488/*
1489 * fnic_wq_copy_cmpl_handler
1490 * Routine to process wq copy
1491 */
1492int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int copy_work_to_do, unsigned int cq_index)
1493{
1494	unsigned int cur_work_done;
1495	struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1496	u64 start_jiffies = 0;
1497	u64 end_jiffies = 0;
1498	u64 delta_jiffies = 0;
1499	u64 delta_ms = 0;
1500
1501	start_jiffies = jiffies;
1502	cur_work_done = vnic_cq_copy_service(&fnic->cq[cq_index],
1503					fnic_fcpio_cmpl_handler,
1504					copy_work_to_do);
1505	end_jiffies = jiffies;
1506	delta_jiffies = end_jiffies - start_jiffies;
1507	if (delta_jiffies > (u64) atomic64_read(&misc_stats->max_isr_jiffies)) {
1508		atomic64_set(&misc_stats->max_isr_jiffies, delta_jiffies);
1509		delta_ms = jiffies_to_msecs(delta_jiffies);
1510		atomic64_set(&misc_stats->max_isr_time_ms, delta_ms);
1511		atomic64_set(&misc_stats->corr_work_done, cur_work_done);
1512	}
1513
1514	return cur_work_done;
1515}
1516
1517static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data)
1518{
1519	struct request *const rq = scsi_cmd_to_rq(sc);
1520	struct fnic *fnic = data;
1521	struct fnic_io_req *io_req;
1522	unsigned long start_time = 0;
1523	unsigned long flags;
1524	struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1525	uint16_t hwq = 0;
1526	int tag;
1527	int mqtag;
1528
1529	mqtag = blk_mq_unique_tag(rq);
1530	hwq = blk_mq_unique_tag_to_hwq(mqtag);
1531	tag = blk_mq_unique_tag_to_tag(mqtag);
1532
1533	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1534
1535	fnic->sw_copy_wq[hwq].io_req_table[tag] = NULL;
1536
1537	io_req = fnic_priv(sc)->io_req;
1538	if (!io_req) {
1539		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1540		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1541			"hwq: %d mqtag: 0x%x tag: 0x%x flags: 0x%x No ioreq. Returning\n",
1542			hwq, mqtag, tag, fnic_priv(sc)->flags);
1543		return true;
1544	}
1545
1546	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
1547		!(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
1548		/*
1549		 * We will be here only when FW completes reset
1550		 * without sending completions for outstanding ios.
1551		 */
1552		fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
1553		if (io_req && io_req->dr_done)
1554			complete(io_req->dr_done);
1555		else if (io_req && io_req->abts_done)
1556			complete(io_req->abts_done);
1557
1558		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1559		return true;
1560	} else if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
1561		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1562		return true;
1563	}
1564
1565	fnic_priv(sc)->io_req = NULL;
1566	io_req->sc = NULL;
1567	start_time = io_req->start_time;
1568	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1569
1570	/*
1571	 * If there is a scsi_cmnd associated with this io_req, then
1572	 * free the corresponding state
1573	 */
1574	fnic_release_ioreq_buf(fnic, io_req, sc);
1575	mempool_free(io_req, fnic->io_req_pool);
1576
1577	sc->result = DID_TRANSPORT_DISRUPTED << 16;
1578	FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1579	"mqtag: 0x%x tag: 0x%x sc: 0x%p duration = %lu DID_TRANSPORT_DISRUPTED\n",
1580		mqtag, tag, sc, (jiffies - start_time));
1581
1582	if (atomic64_read(&fnic->io_cmpl_skip))
1583		atomic64_dec(&fnic->io_cmpl_skip);
1584	else
1585		atomic64_inc(&fnic_stats->io_stats.io_completions);
1586
1587	FNIC_TRACE(fnic_cleanup_io,
1588			   sc->device->host->host_no, tag, sc,
1589			   jiffies_to_msecs(jiffies - start_time),
1590			   0, ((u64) sc->cmnd[0] << 32 |
1591				   (u64) sc->cmnd[2] << 24 |
1592				   (u64) sc->cmnd[3] << 16 |
1593				   (u64) sc->cmnd[4] << 8 | sc->cmnd[5]),
1594			   (((u64) fnic_priv(sc)->flags << 32) | fnic_priv(sc)->
1595				state));
1596
1597	/* Complete the command to SCSI */
1598	scsi_done(sc);
1599	return true;
1600}
1601
1602static void fnic_cleanup_io(struct fnic *fnic, int exclude_id)
1603{
1604	unsigned int io_count = 0;
1605	unsigned long flags;
1606	struct fnic_io_req *io_req = NULL;
1607	struct scsi_cmnd *sc = NULL;
1608
1609	io_count = fnic_count_all_ioreqs(fnic);
1610	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1611				  "Outstanding ioreq count: %d active io count: %lld Waiting\n",
1612				  io_count,
1613				  atomic64_read(&fnic->fnic_stats.io_stats.active_ios));
1614
1615	scsi_host_busy_iter(fnic->host,
1616						fnic_cleanup_io_iter, fnic);
1617
1618	/* with sg3utils device reset, SC needs to be retrieved from ioreq */
1619	spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
1620	io_req = fnic->sw_copy_wq[0].io_req_table[fnic->fnic_max_tag_id];
1621	if (io_req) {
1622		sc = io_req->sc;
1623		if (sc) {
1624			if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
1625				&& !(fnic_priv(sc)->flags & FNIC_DEV_RST_DONE)) {
1626				fnic_priv(sc)->flags |= FNIC_DEV_RST_DONE;
1627				if (io_req && io_req->dr_done)
1628					complete(io_req->dr_done);
1629			}
1630		}
1631	}
1632	spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
1633
1634	while ((io_count = fnic_count_all_ioreqs(fnic))) {
1635		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1636		  "Outstanding ioreq count: %d active io count: %lld Waiting\n",
1637		  io_count,
1638		  atomic64_read(&fnic->fnic_stats.io_stats.active_ios));
1639
1640		schedule_timeout(msecs_to_jiffies(100));
1641	}
1642}
1643
1644void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
1645				  struct fcpio_host_req *desc)
1646{
1647	u32 id;
1648	struct fnic *fnic = vnic_dev_priv(wq->vdev);
1649	struct fnic_io_req *io_req;
1650	struct scsi_cmnd *sc;
1651	unsigned long flags;
1652	unsigned long start_time = 0;
1653	uint16_t hwq;
1654
1655	/* get the tag reference */
1656	fcpio_tag_id_dec(&desc->hdr.tag, &id);
1657	id &= FNIC_TAG_MASK;
1658
1659	if (id >= fnic->fnic_max_tag_id)
1660		return;
1661
1662	sc = scsi_host_find_tag(fnic->host, id);
1663	if (!sc)
1664		return;
1665
1666	hwq = blk_mq_unique_tag_to_hwq(id);
1667	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1668
1669	/* Get the IO context which this desc refers to */
1670	io_req = fnic_priv(sc)->io_req;
1671
1672	/* fnic interrupts are turned off by now */
1673
1674	if (!io_req) {
1675		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1676		goto wq_copy_cleanup_scsi_cmd;
1677	}
1678
1679	fnic_priv(sc)->io_req = NULL;
1680	io_req->sc = NULL;
1681	fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(id)] = NULL;
1682
1683	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1684
1685	start_time = io_req->start_time;
1686	fnic_release_ioreq_buf(fnic, io_req, sc);
1687	mempool_free(io_req, fnic->io_req_pool);
1688
1689wq_copy_cleanup_scsi_cmd:
1690	sc->result = DID_NO_CONNECT << 16;
1691	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num, "wq_copy_cleanup_handler:"
1692		      " DID_NO_CONNECT\n");
1693
1694	FNIC_TRACE(fnic_wq_copy_cleanup_handler,
1695		   sc->device->host->host_no, id, sc,
1696		   jiffies_to_msecs(jiffies - start_time),
1697		   0, ((u64)sc->cmnd[0] << 32 |
1698		       (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
1699		       (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1700		   fnic_flags_and_state(sc));
1701
1702	scsi_done(sc);
1703}
1704
1705static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
1706					  u32 task_req, u8 *fc_lun,
1707					  struct fnic_io_req *io_req,
1708					  unsigned int hwq)
1709{
1710	struct vnic_wq_copy *wq = &fnic->hw_copy_wq[hwq];
1711	struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1712	unsigned long flags;
1713	struct fnic_tport_s *tport = io_req->tport;
1714
1715	spin_lock_irqsave(&fnic->fnic_lock, flags);
1716	if (unlikely(fnic_chk_state_flags_locked(fnic,
1717						FNIC_FLAGS_IO_BLOCKED))) {
1718		atomic_dec(&fnic->in_flight);
1719		atomic_dec(&tport->in_flight);
1720		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1721		return 1;
1722	} else
1723		atomic_inc(&fnic->in_flight);
1724	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1725
1726	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1727
1728	if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[hwq])
1729		free_wq_copy_descs(fnic, wq, hwq);
1730
1731	if (!vnic_wq_copy_desc_avail(wq)) {
1732		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1733		atomic_dec(&fnic->in_flight);
1734		atomic_dec(&tport->in_flight);
1735		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1736			"fnic_queue_abort_io_req: failure: no descriptors\n");
1737		atomic64_inc(&misc_stats->abts_cpwq_alloc_failures);
1738		return 1;
1739	}
1740	fnic_queue_wq_copy_desc_itmf(wq, tag | FNIC_TAG_ABORT,
1741				     0, task_req, tag, fc_lun, io_req->port_id,
1742				     fnic->config.ra_tov, fnic->config.ed_tov);
1743
1744	atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
1745	if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
1746		  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
1747		atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
1748		  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
1749
1750	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1751	atomic_dec(&fnic->in_flight);
1752
1753	return 0;
1754}
1755
1756struct fnic_rport_abort_io_iter_data {
1757	struct fnic *fnic;
1758	u32 port_id;
1759	int term_cnt;
1760};
1761
1762static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data)
1763{
1764	struct request *const rq = scsi_cmd_to_rq(sc);
1765	struct fnic_rport_abort_io_iter_data *iter_data = data;
1766	struct fnic *fnic = iter_data->fnic;
1767	int abt_tag = 0;
1768	struct fnic_io_req *io_req;
1769	struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
1770	struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1771	struct scsi_lun fc_lun;
1772	enum fnic_ioreq_state old_ioreq_state;
1773	uint16_t hwq = 0;
1774	unsigned long flags;
1775
1776	abt_tag = blk_mq_unique_tag(rq);
1777	hwq = blk_mq_unique_tag_to_hwq(abt_tag);
1778
1779	if (!sc) {
1780		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1781					  "sc is NULL abt_tag: 0x%x hwq: %d\n", abt_tag, hwq);
1782		return true;
1783	}
1784
1785	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1786	io_req = fnic_priv(sc)->io_req;
1787	if (!io_req || io_req->port_id != iter_data->port_id) {
1788		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1789		return true;
1790	}
1791
1792	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
1793	    !(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED)) {
1794		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1795			"hwq: %d abt_tag: 0x%x flags: 0x%x Device reset is not pending\n",
1796			hwq, abt_tag, fnic_priv(sc)->flags);
1797		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1798		return true;
1799	}
1800
1801	/*
1802	 * Found IO that is still pending with firmware and
1803	 * belongs to rport that went away
1804	 */
1805	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
1806		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1807		return true;
1808	}
1809
1810	if (io_req->abts_done) {
1811		shost_printk(KERN_ERR, fnic->host,
1812			"fnic_rport_exch_reset: io_req->abts_done is set state is %s\n",
1813			fnic_ioreq_state_to_str(fnic_priv(sc)->state));
1814	}
1815
1816	if (!(fnic_priv(sc)->flags & FNIC_IO_ISSUED)) {
1817		shost_printk(KERN_ERR, fnic->host,
1818			"rport_exch_reset IO not yet issued %p abt_tag 0x%x",
1819			sc, abt_tag);
1820		shost_printk(KERN_ERR, fnic->host,
1821			"flags %x state %d\n", fnic_priv(sc)->flags,
1822			fnic_priv(sc)->state);
1823	}
1824	old_ioreq_state = fnic_priv(sc)->state;
1825	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
1826	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
1827
1828	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
1829		atomic64_inc(&reset_stats->device_reset_terminates);
1830		abt_tag |= FNIC_TAG_DEV_RST;
1831		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1832					  "dev reset sc 0x%p\n", sc);
1833	}
1834	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1835		      "fnic_rport_exch_reset: dev rst sc 0x%p\n", sc);
1836	WARN_ON_ONCE(io_req->abts_done);
1837	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1838		      "fnic_rport_reset_exch: Issuing abts\n");
1839
1840	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1841
1842	/* Queue the abort command to firmware */
1843	int_to_scsilun(sc->device->lun, &fc_lun);
1844
1845	if (fnic_queue_abort_io_req(fnic, abt_tag,
1846				    FCPIO_ITMF_ABT_TASK_TERM,
1847				    fc_lun.scsi_lun, io_req, hwq)) {
1848		/*
1849		 * Revert the cmd state back to old state, if
1850		 * it hasn't changed in between. This cmd will get
1851		 * aborted later by scsi_eh, or cleaned up during
1852		 * lun reset
1853		 */
1854		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1855		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
1856			"hwq: %d abt_tag: 0x%x flags: 0x%x Queuing abort failed\n",
1857			hwq, abt_tag, fnic_priv(sc)->flags);
1858		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
1859			fnic_priv(sc)->state = old_ioreq_state;
1860		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1861	} else {
1862		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
1863		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
1864			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
1865		else
1866			fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
1867		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
1868		atomic64_inc(&term_stats->terminates);
1869		iter_data->term_cnt++;
1870	}
1871
1872	return true;
1873}
1874
1875void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
1876{
1877	unsigned int io_count = 0;
1878	unsigned long flags;
1879	struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1880	struct fnic_rport_abort_io_iter_data iter_data = {
1881		.fnic = fnic,
1882		.port_id = port_id,
1883		.term_cnt = 0,
1884	};
1885
1886	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1887				  "fnic rport exchange reset for tport: 0x%06x\n",
1888				  port_id);
1889
1890	if (fnic->in_remove)
1891		return;
1892
1893	io_count = fnic_count_ioreqs(fnic, port_id);
1894	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1895				  "Starting terminates: rport:0x%x  portid-io-count: %d active-io-count: %lld\n",
1896				  port_id, io_count,
1897				  atomic64_read(&fnic->fnic_stats.io_stats.active_ios));
1898
1899	spin_lock_irqsave(&fnic->fnic_lock, flags);
1900	/* Bump in_flight counter to hold off fnic_fw_reset_handler. */
1901	atomic_inc(&fnic->in_flight);
1902	if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_IO_BLOCKED))) {
1903		atomic_dec(&fnic->in_flight);
1904		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1905		return;
1906	}
1907	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1908
1909	scsi_host_busy_iter(fnic->host, fnic_rport_abort_io_iter,
1910			    &iter_data);
1911
1912	if (iter_data.term_cnt > atomic64_read(&term_stats->max_terminates))
1913		atomic64_set(&term_stats->max_terminates, iter_data.term_cnt);
1914
1915	atomic_dec(&fnic->in_flight);
1916
1917	while ((io_count = fnic_count_ioreqs(fnic, port_id)))
1918		schedule_timeout(msecs_to_jiffies(1000));
1919
1920	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
1921				  "rport: 0x%x remaining portid-io-count: %d ",
1922				  port_id, io_count);
1923}
1924
1925void fnic_terminate_rport_io(struct fc_rport *rport)
1926{
1927	struct fnic_tport_s *tport;
1928	struct rport_dd_data_s *rdd_data;
1929	struct fnic_iport_s *iport = NULL;
1930	struct fnic *fnic = NULL;
1931
1932	if (!rport) {
1933		pr_err("rport is NULL\n");
1934		return;
1935	}
1936
1937	rdd_data = rport->dd_data;
1938	if (rdd_data) {
1939		tport = rdd_data->tport;
1940		if (!tport) {
1941			pr_err(
1942			"term rport io called after tport is deleted. Returning 0x%8x\n",
1943		   rport->port_id);
1944		} else {
1945			pr_err(
1946			   "term rport io called after tport is set 0x%8x\n",
1947			   rport->port_id);
1948			pr_err(
1949			   "tport maybe rediscovered\n");
1950
1951			iport = (struct fnic_iport_s *) tport->iport;
1952			fnic = iport->fnic;
1953			fnic_rport_exch_reset(fnic, rport->port_id);
1954		}
1955	}
1956}
1957
1958/*
1959 * FCP-SCSI specific handling for module unload
1960 *
1961 */
1962void fnic_scsi_unload(struct fnic *fnic)
1963{
1964	unsigned long flags;
1965
1966	/*
1967	 * Mark state so that the workqueue thread stops forwarding
1968	 * received frames and link events to the local port. ISR and
1969	 * other threads that can queue work items will also stop
1970	 * creating work items on the fnic workqueue
1971	 */
1972	spin_lock_irqsave(&fnic->fnic_lock, flags);
1973	fnic->iport.state = FNIC_IPORT_STATE_LINK_WAIT;
1974	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1975
1976	if (fdls_get_state(&fnic->iport.fabric) != FDLS_STATE_INIT)
1977		fnic_scsi_fcpio_reset(fnic);
1978
1979	spin_lock_irqsave(&fnic->fnic_lock, flags);
1980	fnic->in_remove = 1;
1981	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
1982
1983	fnic_flush_tport_event_list(fnic);
1984	fnic_delete_fcp_tports(fnic);
1985}
1986
1987void fnic_scsi_unload_cleanup(struct fnic *fnic)
1988{
1989	int hwq = 0;
1990
1991	fc_remove_host(fnic->host);
1992	scsi_remove_host(fnic->host);
1993	for (hwq = 0; hwq < fnic->wq_copy_count; hwq++)
1994		kfree(fnic->sw_copy_wq[hwq].io_req_table);
1995}
1996
1997/*
1998 * This function is exported to SCSI for sending abort cmnds.
1999 * A SCSI IO is represented by a io_req in the driver.
2000 * The ioreq is linked to the SCSI Cmd, thus a link with the ULP's IO.
2001 */
2002int fnic_abort_cmd(struct scsi_cmnd *sc)
2003{
2004	struct request *const rq = scsi_cmd_to_rq(sc);
2005	struct fnic_iport_s *iport;
2006	struct fnic_tport_s *tport;
2007	struct fnic *fnic;
2008	struct fnic_io_req *io_req = NULL;
2009	struct fc_rport *rport;
2010	struct rport_dd_data_s *rdd_data;
2011	unsigned long flags;
2012	unsigned long start_time = 0;
2013	int ret = SUCCESS;
2014	u32 task_req = 0;
2015	struct scsi_lun fc_lun;
2016	struct fnic_stats *fnic_stats;
2017	struct abort_stats *abts_stats;
2018	struct terminate_stats *term_stats;
2019	enum fnic_ioreq_state old_ioreq_state;
2020	int mqtag;
2021	unsigned long abt_issued_time;
2022	uint16_t hwq = 0;
2023
2024	DECLARE_COMPLETION_ONSTACK(tm_done);
2025
2026	/* Wait for rport to unblock */
2027	fc_block_scsi_eh(sc);
2028
2029	/* Get local-port, check ready and link up */
2030	fnic = *((struct fnic **) shost_priv(sc->device->host));
2031
2032	spin_lock_irqsave(&fnic->fnic_lock, flags);
2033	iport = &fnic->iport;
2034
2035	fnic_stats = &fnic->fnic_stats;
2036	abts_stats = &fnic->fnic_stats.abts_stats;
2037	term_stats = &fnic->fnic_stats.term_stats;
2038
2039	rport = starget_to_rport(scsi_target(sc->device));
2040	mqtag = blk_mq_unique_tag(rq);
2041	hwq = blk_mq_unique_tag_to_hwq(mqtag);
2042
2043	fnic_priv(sc)->flags = FNIC_NO_FLAGS;
2044
2045	rdd_data = rport->dd_data;
2046	tport = rdd_data->tport;
2047
2048	if (!tport) {
2049		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2050			  "Abort cmd called after tport delete! rport fcid: 0x%x",
2051			  rport->port_id);
2052		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2053			  "lun: %llu hwq: 0x%x mqtag: 0x%x Op: 0x%x flags: 0x%x\n",
2054			  sc->device->lun, hwq, mqtag,
2055			  sc->cmnd[0], fnic_priv(sc)->flags);
2056		ret = FAILED;
2057		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2058		goto fnic_abort_cmd_end;
2059	}
2060
2061	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2062	  "Abort cmd called rport fcid: 0x%x lun: %llu hwq: 0x%x mqtag: 0x%x",
2063	  rport->port_id, sc->device->lun, hwq, mqtag);
2064
2065	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2066				  "Op: 0x%x flags: 0x%x\n",
2067				  sc->cmnd[0],
2068				  fnic_priv(sc)->flags);
2069
2070	if (iport->state != FNIC_IPORT_STATE_READY) {
2071		atomic64_inc(&fnic_stats->misc_stats.iport_not_ready);
2072		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2073					  "iport NOT in READY state");
2074		ret = FAILED;
2075		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2076		goto fnic_abort_cmd_end;
2077	}
2078
2079	if ((tport->state != FDLS_TGT_STATE_READY) &&
2080		(tport->state != FDLS_TGT_STATE_ADISC)) {
2081		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2082					  "tport state: %d\n", tport->state);
2083		ret = FAILED;
2084		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2085		goto fnic_abort_cmd_end;
2086	}
2087
2088	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2089	/*
2090	 * Avoid a race between SCSI issuing the abort and the device
2091	 * completing the command.
2092	 *
2093	 * If the command is already completed by the fw cmpl code,
2094	 * we just return SUCCESS from here. This means that the abort
2095	 * succeeded. In the SCSI ML, since the timeout for command has
2096	 * happened, the completion wont actually complete the command
2097	 * and it will be considered as an aborted command
2098	 *
2099	 * .io_req will not be cleared except while holding io_req_lock.
2100	 */
2101	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2102	io_req = fnic_priv(sc)->io_req;
2103	if (!io_req) {
2104		ret = FAILED;
2105		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2106		goto fnic_abort_cmd_end;
2107	}
2108
2109	io_req->abts_done = &tm_done;
2110
2111	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
2112		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2113		goto wait_pending;
2114	}
2115
2116	abt_issued_time = jiffies_to_msecs(jiffies) - jiffies_to_msecs(io_req->start_time);
2117	if (abt_issued_time <= 6000)
2118		atomic64_inc(&abts_stats->abort_issued_btw_0_to_6_sec);
2119	else if (abt_issued_time > 6000 && abt_issued_time <= 20000)
2120		atomic64_inc(&abts_stats->abort_issued_btw_6_to_20_sec);
2121	else if (abt_issued_time > 20000 && abt_issued_time <= 30000)
2122		atomic64_inc(&abts_stats->abort_issued_btw_20_to_30_sec);
2123	else if (abt_issued_time > 30000 && abt_issued_time <= 40000)
2124		atomic64_inc(&abts_stats->abort_issued_btw_30_to_40_sec);
2125	else if (abt_issued_time > 40000 && abt_issued_time <= 50000)
2126		atomic64_inc(&abts_stats->abort_issued_btw_40_to_50_sec);
2127	else if (abt_issued_time > 50000 && abt_issued_time <= 60000)
2128		atomic64_inc(&abts_stats->abort_issued_btw_50_to_60_sec);
2129	else
2130		atomic64_inc(&abts_stats->abort_issued_greater_than_60_sec);
2131
2132	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2133		"CDB Opcode: 0x%02x Abort issued time: %lu msec\n",
2134		sc->cmnd[0], abt_issued_time);
2135	/*
2136	 * Command is still pending, need to abort it
2137	 * If the firmware completes the command after this point,
2138	 * the completion wont be done till mid-layer, since abort
2139	 * has already started.
2140	 */
2141	old_ioreq_state = fnic_priv(sc)->state;
2142	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
2143	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
2144
2145	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2146
2147	/*
2148	 * Check readiness of the remote port. If the path to remote
2149	 * port is up, then send abts to the remote port to terminate
2150	 * the IO. Else, just locally terminate the IO in the firmware
2151	 */
2152	if (fc_remote_port_chkready(rport) == 0)
2153		task_req = FCPIO_ITMF_ABT_TASK;
2154	else {
2155		atomic64_inc(&fnic_stats->misc_stats.tport_not_ready);
2156		task_req = FCPIO_ITMF_ABT_TASK_TERM;
2157	}
2158
2159	/* Now queue the abort command to firmware */
2160	int_to_scsilun(sc->device->lun, &fc_lun);
2161
2162	if (fnic_queue_abort_io_req(fnic, mqtag, task_req, fc_lun.scsi_lun,
2163				    io_req, hwq)) {
2164		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2165		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
2166			fnic_priv(sc)->state = old_ioreq_state;
2167		io_req = fnic_priv(sc)->io_req;
2168		if (io_req)
2169			io_req->abts_done = NULL;
2170		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2171		ret = FAILED;
2172		goto fnic_abort_cmd_end;
2173	}
2174	if (task_req == FCPIO_ITMF_ABT_TASK) {
2175		fnic_priv(sc)->flags |= FNIC_IO_ABTS_ISSUED;
2176		atomic64_inc(&fnic_stats->abts_stats.aborts);
2177	} else {
2178		fnic_priv(sc)->flags |= FNIC_IO_TERM_ISSUED;
2179		atomic64_inc(&fnic_stats->term_stats.terminates);
2180	}
2181
2182	/*
2183	 * We queued an abort IO, wait for its completion.
2184	 * Once the firmware completes the abort command, it will
2185	 * wake up this thread.
2186	 */
2187 wait_pending:
2188	wait_for_completion_timeout(&tm_done,
2189				    msecs_to_jiffies
2190				    (2 * fnic->config.ra_tov +
2191				     fnic->config.ed_tov));
2192
2193	/* Check the abort status */
2194	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2195
2196	io_req = fnic_priv(sc)->io_req;
2197	if (!io_req) {
2198		atomic64_inc(&fnic_stats->io_stats.ioreq_null);
2199		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2200		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
2201		ret = FAILED;
2202		goto fnic_abort_cmd_end;
2203	}
2204	io_req->abts_done = NULL;
2205
2206	/* fw did not complete abort, timed out */
2207	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
2208		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2209		if (task_req == FCPIO_ITMF_ABT_TASK) {
2210			atomic64_inc(&abts_stats->abort_drv_timeouts);
2211		} else {
2212			atomic64_inc(&term_stats->terminate_drv_timeouts);
2213		}
2214		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_TIMED_OUT;
2215		ret = FAILED;
2216		goto fnic_abort_cmd_end;
2217	}
2218
2219	/* IO out of order */
2220
2221	if (!(fnic_priv(sc)->flags & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
2222		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2223		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2224			      "Issuing host reset due to out of order IO\n");
2225
2226		ret = FAILED;
2227		goto fnic_abort_cmd_end;
2228	}
2229
2230	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
2231
2232	start_time = io_req->start_time;
2233	/*
2234	 * firmware completed the abort, check the status,
2235	 * free the io_req if successful. If abort fails,
2236	 * Device reset will clean the I/O.
2237	 */
2238	if (fnic_priv(sc)->abts_status == FCPIO_SUCCESS ||
2239		(fnic_priv(sc)->abts_status == FCPIO_ABORTED)) {
2240		fnic_priv(sc)->io_req = NULL;
2241		io_req->sc = NULL;
2242	} else {
2243		ret = FAILED;
2244		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2245		goto fnic_abort_cmd_end;
2246	}
2247
2248	fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] = NULL;
2249	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2250
2251	fnic_release_ioreq_buf(fnic, io_req, sc);
2252	mempool_free(io_req, fnic->io_req_pool);
2253
2254	/* Call SCSI completion function to complete the IO */
2255	sc->result = DID_ABORT << 16;
2256	scsi_done(sc);
2257	atomic64_dec(&fnic_stats->io_stats.active_ios);
2258	if (atomic64_read(&fnic->io_cmpl_skip))
2259		atomic64_dec(&fnic->io_cmpl_skip);
2260	else
2261		atomic64_inc(&fnic_stats->io_stats.io_completions);
2262
2263fnic_abort_cmd_end:
2264	FNIC_TRACE(fnic_abort_cmd, sc->device->host->host_no, mqtag, sc,
2265		  jiffies_to_msecs(jiffies - start_time),
2266		  0, ((u64)sc->cmnd[0] << 32 |
2267		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
2268		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
2269		  fnic_flags_and_state(sc));
2270
2271	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2272		      "Returning from abort cmd type %x %s\n", task_req,
2273		      (ret == SUCCESS) ?
2274		      "SUCCESS" : "FAILED");
2275	return ret;
2276}
2277
2278static inline int fnic_queue_dr_io_req(struct fnic *fnic,
2279				       struct scsi_cmnd *sc,
2280				       struct fnic_io_req *io_req)
2281{
2282	struct vnic_wq_copy *wq;
2283	struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
2284	struct scsi_lun fc_lun;
2285	int ret = 0;
2286	unsigned long flags;
2287	uint16_t hwq = 0;
2288	uint32_t tag = 0;
2289	struct fnic_tport_s *tport = io_req->tport;
2290
2291	tag = io_req->tag;
2292	hwq = blk_mq_unique_tag_to_hwq(tag);
2293	wq = &fnic->hw_copy_wq[hwq];
2294
2295	spin_lock_irqsave(&fnic->fnic_lock, flags);
2296	if (unlikely(fnic_chk_state_flags_locked(fnic,
2297						FNIC_FLAGS_IO_BLOCKED))) {
2298		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2299		return FAILED;
2300	} else {
2301		atomic_inc(&fnic->in_flight);
2302		atomic_inc(&tport->in_flight);
2303	}
2304	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2305
2306	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2307
2308	if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[hwq])
2309		free_wq_copy_descs(fnic, wq, hwq);
2310
2311	if (!vnic_wq_copy_desc_avail(wq)) {
2312		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2313			  "queue_dr_io_req failure - no descriptors\n");
2314		atomic64_inc(&misc_stats->devrst_cpwq_alloc_failures);
2315		ret = -EAGAIN;
2316		goto lr_io_req_end;
2317	}
2318
2319	/* fill in the lun info */
2320	int_to_scsilun(sc->device->lun, &fc_lun);
2321
2322	tag |= FNIC_TAG_DEV_RST;
2323	fnic_queue_wq_copy_desc_itmf(wq, tag,
2324				     0, FCPIO_ITMF_LUN_RESET, SCSI_NO_TAG,
2325				     fc_lun.scsi_lun, io_req->port_id,
2326				     fnic->config.ra_tov, fnic->config.ed_tov);
2327
2328	atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
2329	if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
2330		  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
2331		atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
2332		  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
2333
2334lr_io_req_end:
2335	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2336	atomic_dec(&fnic->in_flight);
2337	atomic_dec(&tport->in_flight);
2338
2339	return ret;
2340}
2341
2342struct fnic_pending_aborts_iter_data {
2343	struct fnic *fnic;
2344	struct scsi_cmnd *lr_sc;
2345	struct scsi_device *lun_dev;
2346	int ret;
2347};
2348
2349static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc, void *data)
2350{
2351	struct request *const rq = scsi_cmd_to_rq(sc);
2352	struct fnic_pending_aborts_iter_data *iter_data = data;
2353	struct fnic *fnic = iter_data->fnic;
2354	struct scsi_device *lun_dev = iter_data->lun_dev;
2355	unsigned long abt_tag = 0;
2356	uint16_t hwq = 0;
2357	struct fnic_io_req *io_req;
2358	unsigned long flags;
2359	struct scsi_lun fc_lun;
2360	DECLARE_COMPLETION_ONSTACK(tm_done);
2361	enum fnic_ioreq_state old_ioreq_state;
2362
2363	if (sc == iter_data->lr_sc || sc->device != lun_dev)
2364		return true;
2365
2366	abt_tag = blk_mq_unique_tag(rq);
2367	hwq = blk_mq_unique_tag_to_hwq(abt_tag);
2368
2369	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2370	io_req = fnic_priv(sc)->io_req;
2371	if (!io_req) {
2372		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2373		return true;
2374	}
2375
2376	/*
2377	 * Found IO that is still pending with firmware and
2378	 * belongs to the LUN that we are resetting
2379	 */
2380	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2381		      "Found IO in %s on lun\n",
2382		      fnic_ioreq_state_to_str(fnic_priv(sc)->state));
2383
2384	if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING) {
2385		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2386		return true;
2387	}
2388	if ((fnic_priv(sc)->flags & FNIC_DEVICE_RESET) &&
2389	    (!(fnic_priv(sc)->flags & FNIC_DEV_RST_ISSUED))) {
2390		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2391			      "dev rst not pending sc 0x%p\n", sc);
2392		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2393		return true;
2394	}
2395
2396	if (io_req->abts_done)
2397		shost_printk(KERN_ERR, fnic->host,
2398			     "%s: io_req->abts_done is set state is %s\n",
2399			     __func__, fnic_ioreq_state_to_str(fnic_priv(sc)->state));
2400	old_ioreq_state = fnic_priv(sc)->state;
2401	/*
2402	 * Any pending IO issued prior to reset is expected to be
2403	 * in abts pending state, if not we need to set
2404	 * FNIC_IOREQ_ABTS_PENDING to indicate the IO is abort pending.
2405	 * When IO is completed, the IO will be handed over and
2406	 * handled in this function.
2407	 */
2408	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_PENDING;
2409
2410	BUG_ON(io_req->abts_done);
2411
2412	if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET) {
2413		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2414			      "dev rst sc 0x%p\n", sc);
2415	}
2416
2417	fnic_priv(sc)->abts_status = FCPIO_INVALID_CODE;
2418	io_req->abts_done = &tm_done;
2419	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2420
2421	/* Now queue the abort command to firmware */
2422	int_to_scsilun(sc->device->lun, &fc_lun);
2423
2424	if (fnic_queue_abort_io_req(fnic, abt_tag,
2425				    FCPIO_ITMF_ABT_TASK_TERM,
2426				    fc_lun.scsi_lun, io_req, hwq)) {
2427		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2428		io_req = fnic_priv(sc)->io_req;
2429		if (io_req)
2430			io_req->abts_done = NULL;
2431		if (fnic_priv(sc)->state == FNIC_IOREQ_ABTS_PENDING)
2432			fnic_priv(sc)->state = old_ioreq_state;
2433		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2434		iter_data->ret = FAILED;
2435		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2436			"hwq: %d abt_tag: 0x%lx Abort could not be queued\n",
2437			hwq, abt_tag);
2438		return false;
2439	} else {
2440		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2441		if (fnic_priv(sc)->flags & FNIC_DEVICE_RESET)
2442			fnic_priv(sc)->flags |= FNIC_DEV_RST_TERM_ISSUED;
2443		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2444	}
2445	fnic_priv(sc)->flags |= FNIC_IO_INTERNAL_TERM_ISSUED;
2446
2447	wait_for_completion_timeout(&tm_done, msecs_to_jiffies
2448				    (fnic->config.ed_tov));
2449
2450	/* Recheck cmd state to check if it is now aborted */
2451	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2452	io_req = fnic_priv(sc)->io_req;
2453	if (!io_req) {
2454		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2455		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_REQ_NULL;
2456		return true;
2457	}
2458
2459	io_req->abts_done = NULL;
2460
2461	/* if abort is still pending with fw, fail */
2462	if (fnic_priv(sc)->abts_status == FCPIO_INVALID_CODE) {
2463		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2464		fnic_priv(sc)->flags |= FNIC_IO_ABT_TERM_DONE;
2465		iter_data->ret = FAILED;
2466		return false;
2467	}
2468	fnic_priv(sc)->state = FNIC_IOREQ_ABTS_COMPLETE;
2469
2470	/* original sc used for lr is handled by dev reset code */
2471	if (sc != iter_data->lr_sc) {
2472		fnic_priv(sc)->io_req = NULL;
2473		fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(abt_tag)] = NULL;
2474	}
2475	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2476
2477	/* original sc used for lr is handled by dev reset code */
2478	if (sc != iter_data->lr_sc) {
2479		fnic_release_ioreq_buf(fnic, io_req, sc);
2480		mempool_free(io_req, fnic->io_req_pool);
2481	}
2482
2483	/*
2484	 * Any IO is returned during reset, it needs to call scsi_done
2485	 * to return the scsi_cmnd to upper layer.
2486	 */
2487	/* Set result to let upper SCSI layer retry */
2488	sc->result = DID_RESET << 16;
2489	scsi_done(sc);
2490
2491	return true;
2492}
2493
2494/*
2495 * Clean up any pending aborts on the lun
2496 * For each outstanding IO on this lun, whose abort is not completed by fw,
2497 * issue a local abort. Wait for abort to complete. Return 0 if all commands
2498 * successfully aborted, 1 otherwise
2499 */
2500static int fnic_clean_pending_aborts(struct fnic *fnic,
2501				     struct scsi_cmnd *lr_sc,
2502				     bool new_sc)
2503
2504{
2505	int ret = 0;
2506	struct fnic_pending_aborts_iter_data iter_data = {
2507		.fnic = fnic,
2508		.lun_dev = lr_sc->device,
2509		.ret = SUCCESS,
2510	};
2511
2512	iter_data.lr_sc = lr_sc;
2513
2514	scsi_host_busy_iter(fnic->host,
2515			    fnic_pending_aborts_iter, &iter_data);
2516	if (iter_data.ret == FAILED) {
2517		ret = iter_data.ret;
2518		goto clean_pending_aborts_end;
2519	}
2520	schedule_timeout(msecs_to_jiffies(2 * fnic->config.ed_tov));
2521
2522	/* walk again to check, if IOs are still pending in fw */
2523	if (fnic_is_abts_pending(fnic, lr_sc))
2524		ret = 1;
2525
2526clean_pending_aborts_end:
2527	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2528			"exit status: %d\n", ret);
2529	return ret;
2530}
2531
2532/*
2533 * SCSI Eh thread issues a Lun Reset when one or more commands on a LUN
2534 * fail to get aborted. It calls driver's eh_device_reset with a SCSI command
2535 * on the LUN.
2536 */
2537int fnic_device_reset(struct scsi_cmnd *sc)
2538{
2539	struct request *rq = scsi_cmd_to_rq(sc);
2540	struct fnic *fnic;
2541	struct fnic_io_req *io_req = NULL;
2542	struct fc_rport *rport;
2543	int status;
2544	int count = 0;
2545	int ret = FAILED;
2546	unsigned long flags;
2547	unsigned long start_time = 0;
2548	struct scsi_lun fc_lun;
2549	struct fnic_stats *fnic_stats;
2550	struct reset_stats *reset_stats;
2551	int mqtag = rq->tag;
2552	DECLARE_COMPLETION_ONSTACK(tm_done);
2553	bool new_sc = 0;
2554	uint16_t hwq = 0;
2555	struct fnic_iport_s *iport = NULL;
2556	struct rport_dd_data_s *rdd_data;
2557	struct fnic_tport_s *tport;
2558	u32 old_soft_reset_count;
2559	u32 old_link_down_cnt;
2560	int exit_dr = 0;
2561
2562	/* Wait for rport to unblock */
2563	fc_block_scsi_eh(sc);
2564
2565	/* Get local-port, check ready and link up */
2566	fnic = *((struct fnic **) shost_priv(sc->device->host));
2567	iport = &fnic->iport;
2568
2569	fnic_stats = &fnic->fnic_stats;
2570	reset_stats = &fnic_stats->reset_stats;
2571
2572	atomic64_inc(&reset_stats->device_resets);
2573
2574	rport = starget_to_rport(scsi_target(sc->device));
2575
2576	spin_lock_irqsave(&fnic->fnic_lock, flags);
2577	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2578		"fcid: 0x%x lun: %llu hwq: %d mqtag: 0x%x flags: 0x%x Device reset\n",
2579		rport->port_id, sc->device->lun, hwq, mqtag,
2580		fnic_priv(sc)->flags);
2581
2582	rdd_data = rport->dd_data;
2583	tport = rdd_data->tport;
2584	if (!tport) {
2585		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2586		  "Dev rst called after tport delete! rport fcid: 0x%x lun: %llu\n",
2587		  rport->port_id, sc->device->lun);
2588		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2589		goto fnic_device_reset_end;
2590	}
2591
2592	if (iport->state != FNIC_IPORT_STATE_READY) {
2593		atomic64_inc(&fnic_stats->misc_stats.iport_not_ready);
2594		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2595					  "iport NOT in READY state");
2596		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2597		goto fnic_device_reset_end;
2598	}
2599
2600	if ((tport->state != FDLS_TGT_STATE_READY) &&
2601		(tport->state != FDLS_TGT_STATE_ADISC)) {
2602		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2603					  "tport state: %d\n", tport->state);
2604		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2605		goto fnic_device_reset_end;
2606	}
2607	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2608
2609	/* Check if remote port up */
2610	if (fc_remote_port_chkready(rport)) {
2611		atomic64_inc(&fnic_stats->misc_stats.tport_not_ready);
2612		goto fnic_device_reset_end;
2613	}
2614
2615	fnic_priv(sc)->flags = FNIC_DEVICE_RESET;
2616
2617	if (unlikely(mqtag < 0)) {
2618		/*
2619		 * For device reset issued through sg3utils, we let
2620		 * only one LUN_RESET to go through and use a special
2621		 * tag equal to max_tag_id so that we don't have to allocate
2622		 * or free it. It won't interact with tags
2623		 * allocated by mid layer.
2624		 */
2625		mutex_lock(&fnic->sgreset_mutex);
2626		mqtag = fnic->fnic_max_tag_id;
2627		new_sc = 1;
2628	}  else {
2629		mqtag = blk_mq_unique_tag(rq);
2630		hwq = blk_mq_unique_tag_to_hwq(mqtag);
2631	}
2632
2633	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2634	io_req = fnic_priv(sc)->io_req;
2635
2636	/*
2637	 * If there is a io_req attached to this command, then use it,
2638	 * else allocate a new one.
2639	 */
2640	if (!io_req) {
2641		io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
2642		if (!io_req) {
2643			spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2644			goto fnic_device_reset_end;
2645		}
2646		memset(io_req, 0, sizeof(*io_req));
2647		io_req->port_id = rport->port_id;
2648		io_req->tag = mqtag;
2649		fnic_priv(sc)->io_req = io_req;
2650		io_req->tport = tport;
2651		io_req->sc = sc;
2652
2653		if (fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] != NULL)
2654			WARN(1, "fnic<%d>: %s: tag 0x%x already exists\n",
2655					fnic->fnic_num, __func__, blk_mq_unique_tag_to_tag(mqtag));
2656
2657		fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(mqtag)] =
2658				io_req;
2659	}
2660	io_req->dr_done = &tm_done;
2661	fnic_priv(sc)->state = FNIC_IOREQ_CMD_PENDING;
2662	fnic_priv(sc)->lr_status = FCPIO_INVALID_CODE;
2663	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2664
2665	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num, "TAG %x\n", mqtag);
2666
2667	/*
2668	 * issue the device reset, if enqueue failed, clean up the ioreq
2669	 * and break assoc with scsi cmd
2670	 */
2671	if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
2672		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2673		io_req = fnic_priv(sc)->io_req;
2674		if (io_req)
2675			io_req->dr_done = NULL;
2676		goto fnic_device_reset_clean;
2677	}
2678	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2679	fnic_priv(sc)->flags |= FNIC_DEV_RST_ISSUED;
2680	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2681
2682	spin_lock_irqsave(&fnic->fnic_lock, flags);
2683	old_link_down_cnt = iport->fnic->link_down_cnt;
2684	old_soft_reset_count = fnic->soft_reset_count;
2685	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2686
2687	/*
2688	 * Wait on the local completion for LUN reset.  The io_req may be
2689	 * freed while we wait since we hold no lock.
2690	 */
2691	wait_for_completion_timeout(&tm_done,
2692				    msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
2693
2694	/*
2695	 * Wake up can be due to the following reasons:
2696	 * 1) The device reset completed from target.
2697	 * 2) Device reset timed out.
2698	 * 3) A link-down/host_reset may have happened in between.
2699	 * 4) The device reset was aborted and io_req->dr_done was called.
2700	 */
2701
2702	exit_dr = 0;
2703	spin_lock_irqsave(&fnic->fnic_lock, flags);
2704	if ((old_link_down_cnt != fnic->link_down_cnt) ||
2705		(fnic->reset_in_progress) ||
2706		(fnic->soft_reset_count != old_soft_reset_count) ||
2707		(iport->state != FNIC_IPORT_STATE_READY))
2708		exit_dr = 1;
2709
2710	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2711
2712	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2713	io_req = fnic_priv(sc)->io_req;
2714	if (!io_req) {
2715		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2716		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2717				"io_req is null mqtag 0x%x sc 0x%p\n", mqtag, sc);
2718		goto fnic_device_reset_end;
2719	}
2720
2721	if (exit_dr) {
2722		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2723					  "Host reset called for fnic. Exit device reset\n");
2724		io_req->dr_done = NULL;
2725		goto fnic_device_reset_clean;
2726	}
2727	io_req->dr_done = NULL;
2728
2729	status = fnic_priv(sc)->lr_status;
2730
2731	/*
2732	 * If lun reset not completed, bail out with failed. io_req
2733	 * gets cleaned up during higher levels of EH
2734	 */
2735	if (status == FCPIO_INVALID_CODE) {
2736		atomic64_inc(&reset_stats->device_reset_timeouts);
2737		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2738			      "Device reset timed out\n");
2739		fnic_priv(sc)->flags |= FNIC_DEV_RST_TIMED_OUT;
2740		int_to_scsilun(sc->device->lun, &fc_lun);
2741		goto fnic_device_reset_clean;
2742	} else {
2743		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2744	}
2745
2746	/* Completed, but not successful, clean up the io_req, return fail */
2747	if (status != FCPIO_SUCCESS) {
2748		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2749		FNIC_SCSI_DBG(KERN_DEBUG,
2750			      fnic->host, fnic->fnic_num,
2751			      "Device reset completed - failed\n");
2752		io_req = fnic_priv(sc)->io_req;
2753		goto fnic_device_reset_clean;
2754	}
2755
2756	/*
2757	 * Clean up any aborts on this lun that have still not
2758	 * completed. If any of these fail, then LUN reset fails.
2759	 * clean_pending_aborts cleans all cmds on this lun except
2760	 * the lun reset cmd. If all cmds get cleaned, the lun reset
2761	 * succeeds
2762	 */
2763	if (fnic_clean_pending_aborts(fnic, sc, new_sc)) {
2764		spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2765		io_req = fnic_priv(sc)->io_req;
2766		FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2767					  "Device reset failed: Cannot abort all IOs\n");
2768		goto fnic_device_reset_clean;
2769	}
2770
2771	/* Clean lun reset command */
2772	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2773	io_req = fnic_priv(sc)->io_req;
2774	if (io_req)
2775		/* Completed, and successful */
2776		ret = SUCCESS;
2777
2778fnic_device_reset_clean:
2779	if (io_req) {
2780		fnic_priv(sc)->io_req = NULL;
2781		io_req->sc = NULL;
2782		fnic->sw_copy_wq[hwq].io_req_table[blk_mq_unique_tag_to_tag(io_req->tag)] = NULL;
2783	}
2784
2785	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2786
2787	if (io_req) {
2788		start_time = io_req->start_time;
2789		fnic_release_ioreq_buf(fnic, io_req, sc);
2790		mempool_free(io_req, fnic->io_req_pool);
2791	}
2792
2793	/*
2794	 * If link-event is seen while LUN reset is issued we need
2795	 * to complete the LUN reset here
2796	 */
2797	if (!new_sc) {
2798		sc->result = DID_RESET << 16;
2799		scsi_done(sc);
2800	}
2801
2802fnic_device_reset_end:
2803	FNIC_TRACE(fnic_device_reset, sc->device->host->host_no, rq->tag, sc,
2804		  jiffies_to_msecs(jiffies - start_time),
2805		  0, ((u64)sc->cmnd[0] << 32 |
2806		  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
2807		  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
2808		  fnic_flags_and_state(sc));
2809
2810	if (new_sc) {
2811		fnic->sgreset_sc = NULL;
2812		mutex_unlock(&fnic->sgreset_mutex);
2813	}
2814
2815	while ((ret == SUCCESS) && fnic_count_lun_ioreqs(fnic, sc->device)) {
2816		if (count >= 2) {
2817			ret = FAILED;
2818			break;
2819		}
2820		FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
2821					  "Cannot clean up all IOs for the LUN\n");
2822		schedule_timeout(msecs_to_jiffies(1000));
2823		count++;
2824	}
2825
2826	FNIC_SCSI_DBG(KERN_DEBUG, fnic->host, fnic->fnic_num,
2827		      "Returning from device reset %s\n",
2828		      (ret == SUCCESS) ?
2829		      "SUCCESS" : "FAILED");
2830
2831	if (ret == FAILED)
2832		atomic64_inc(&reset_stats->device_reset_failures);
2833
2834	return ret;
2835}
2836
2837static void fnic_post_flogo_linkflap(struct fnic *fnic)
2838{
2839	unsigned long flags;
2840
2841	fnic_fdls_link_status_change(fnic, 0);
2842	spin_lock_irqsave(&fnic->fnic_lock, flags);
2843
2844	if (fnic->link_status) {
2845		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2846		fnic_fdls_link_status_change(fnic, 1);
2847		return;
2848	}
2849	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2850}
2851
2852/* Logout from all the targets and simulate link flap */
2853void fnic_reset(struct Scsi_Host *shost)
2854{
2855	struct fnic *fnic;
2856	struct reset_stats *reset_stats;
2857
2858	fnic = *((struct fnic **) shost_priv(shost));
2859	reset_stats = &fnic->fnic_stats.reset_stats;
2860
2861	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2862				  "Issuing fnic reset\n");
2863
2864	atomic64_inc(&reset_stats->fnic_resets);
2865	fnic_post_flogo_linkflap(fnic);
2866
2867	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2868				  "Returning from fnic reset");
2869
2870	atomic64_inc(&reset_stats->fnic_reset_completions);
2871}
2872
2873int fnic_issue_fc_host_lip(struct Scsi_Host *shost)
2874{
2875	int ret = 0;
2876	struct fnic *fnic = *((struct fnic **) shost_priv(shost));
2877
2878	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2879				  "FC host lip issued");
2880
2881	ret = fnic_host_reset(shost);
2882	return ret;
2883}
2884
2885int fnic_host_reset(struct Scsi_Host *shost)
2886{
2887	int ret = SUCCESS;
2888	unsigned long wait_host_tmo;
2889	struct fnic *fnic = *((struct fnic **) shost_priv(shost));
2890	unsigned long flags;
2891	struct fnic_iport_s *iport = &fnic->iport;
2892
2893	spin_lock_irqsave(&fnic->fnic_lock, flags);
2894	if (fnic->reset_in_progress == NOT_IN_PROGRESS) {
2895		fnic->reset_in_progress = IN_PROGRESS;
2896	} else {
2897		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2898		wait_for_completion_timeout(&fnic->reset_completion_wait,
2899									msecs_to_jiffies(10000));
2900
2901		spin_lock_irqsave(&fnic->fnic_lock, flags);
2902		if (fnic->reset_in_progress == IN_PROGRESS) {
2903			spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2904			FNIC_SCSI_DBG(KERN_WARNING, fnic->host, fnic->fnic_num,
2905			  "Firmware reset in progress. Skipping another host reset\n");
2906			return SUCCESS;
2907		}
2908		fnic->reset_in_progress = IN_PROGRESS;
2909	}
2910	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2911
2912	/*
2913	 * If fnic_reset is successful, wait for fabric login to complete
2914	 * scsi-ml tries to send a TUR to every device if host reset is
2915	 * successful, so before returning to scsi, fabric should be up
2916	 */
2917	fnic_reset(shost);
2918
2919	spin_lock_irqsave(&fnic->fnic_lock, flags);
2920	fnic->reset_in_progress = NOT_IN_PROGRESS;
2921	complete(&fnic->reset_completion_wait);
2922	fnic->soft_reset_count++;
2923
2924	/* wait till the link is up */
2925	if (fnic->link_status) {
2926		wait_host_tmo = jiffies + FNIC_HOST_RESET_SETTLE_TIME * HZ;
2927		ret = FAILED;
2928		while (time_before(jiffies, wait_host_tmo)) {
2929			if (iport->state != FNIC_IPORT_STATE_READY
2930				&& fnic->link_status) {
2931				spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2932				ssleep(1);
2933				spin_lock_irqsave(&fnic->fnic_lock, flags);
2934			} else {
2935				ret = SUCCESS;
2936				break;
2937			}
2938		}
2939	}
2940	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2941
2942	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2943				  "host reset return status: %d\n", ret);
2944	return ret;
2945}
2946
2947static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data)
2948{
2949	struct request *const rq = scsi_cmd_to_rq(sc);
2950	struct fnic_pending_aborts_iter_data *iter_data = data;
2951	struct fnic *fnic = iter_data->fnic;
2952	int cmd_state;
2953	struct fnic_io_req *io_req;
2954	unsigned long flags;
2955	uint16_t hwq = 0;
2956	int tag;
2957
2958	tag = blk_mq_unique_tag(rq);
2959	hwq = blk_mq_unique_tag_to_hwq(tag);
2960
2961	/*
2962	 * ignore this lun reset cmd or cmds that do not belong to
2963	 * this lun
2964	 */
2965	if (iter_data->lr_sc && sc == iter_data->lr_sc)
2966		return true;
2967	if (iter_data->lun_dev && sc->device != iter_data->lun_dev)
2968		return true;
2969
2970	spin_lock_irqsave(&fnic->wq_copy_lock[hwq], flags);
2971
2972	io_req = fnic_priv(sc)->io_req;
2973	if (!io_req) {
2974		spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2975		return true;
2976	}
2977
2978	/*
2979	 * Found IO that is still pending with firmware and
2980	 * belongs to the LUN that we are resetting
2981	 */
2982	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
2983		"hwq: %d tag: 0x%x Found IO in state: %s on lun\n",
2984		hwq, tag,
2985		fnic_ioreq_state_to_str(fnic_priv(sc)->state));
2986	cmd_state = fnic_priv(sc)->state;
2987	spin_unlock_irqrestore(&fnic->wq_copy_lock[hwq], flags);
2988	if (cmd_state == FNIC_IOREQ_ABTS_PENDING)
2989		iter_data->ret = 1;
2990
2991	return iter_data->ret ? false : true;
2992}
2993
2994/*
2995 * fnic_is_abts_pending() is a helper function that
2996 * walks through tag map to check if there is any IOs pending,if there is one,
2997 * then it returns 1 (true), otherwise 0 (false)
2998 * if @lr_sc is non NULL, then it checks IOs specific to particular LUN,
2999 * otherwise, it checks for all IOs.
3000 */
3001int fnic_is_abts_pending(struct fnic *fnic, struct scsi_cmnd *lr_sc)
3002{
3003	struct fnic_pending_aborts_iter_data iter_data = {
3004		.fnic = fnic,
3005		.lun_dev = NULL,
3006		.ret = 0,
3007	};
3008
3009	if (lr_sc) {
3010		iter_data.lun_dev = lr_sc->device;
3011		iter_data.lr_sc = lr_sc;
3012	}
3013
3014	/* walk again to check, if IOs are still pending in fw */
3015	scsi_host_busy_iter(fnic->host,
3016			    fnic_abts_pending_iter, &iter_data);
3017
3018	return iter_data.ret;
3019}
3020
3021/*
3022 * SCSI Error handling calls driver's eh_host_reset if all prior
3023 * error handling levels return FAILED. If host reset completes
3024 * successfully, and if link is up, then Fabric login begins.
3025 *
3026 * Host Reset is the highest level of error recovery. If this fails, then
3027 * host is offlined by SCSI.
3028 *
3029 */
3030int fnic_eh_host_reset_handler(struct scsi_cmnd *sc)
3031{
3032	int ret = 0;
3033	struct Scsi_Host *shost = sc->device->host;
3034	struct fnic *fnic = *((struct fnic **) shost_priv(shost));
3035
3036	FNIC_SCSI_DBG(KERN_ERR, fnic->host, fnic->fnic_num,
3037				  "SCSI error handling: fnic host reset");
3038
3039	ret = fnic_host_reset(shost);
3040	return ret;
3041}
3042
3043
3044void fnic_scsi_fcpio_reset(struct fnic *fnic)
3045{
3046	unsigned long flags;
3047	enum fnic_state old_state;
3048	struct fnic_iport_s *iport = &fnic->iport;
3049	DECLARE_COMPLETION_ONSTACK(fw_reset_done);
3050	int time_remain;
3051
3052	/* issue fw reset */
3053	spin_lock_irqsave(&fnic->fnic_lock, flags);
3054	if (unlikely(fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)) {
3055		/* fw reset is in progress, poll for its completion */
3056		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
3057		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
3058			  "fnic is in unexpected state: %d for fw_reset\n",
3059			  fnic->state);
3060		return;
3061	}
3062
3063	old_state = fnic->state;
3064	fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
3065
3066	fnic_update_mac_locked(fnic, iport->hwmac);
3067	fnic->fw_reset_done = &fw_reset_done;
3068	spin_unlock_irqrestore(&fnic->fnic_lock, flags);
3069
3070	FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
3071				  "Issuing fw reset\n");
3072	if (fnic_fw_reset_handler(fnic)) {
3073		spin_lock_irqsave(&fnic->fnic_lock, flags);
3074		if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)
3075			fnic->state = old_state;
3076		spin_unlock_irqrestore(&fnic->fnic_lock, flags);
3077	} else {
3078		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
3079					  "Waiting for fw completion\n");
3080		time_remain = wait_for_completion_timeout(&fw_reset_done,
3081						  msecs_to_jiffies(FNIC_FW_RESET_TIMEOUT));
3082		FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
3083					  "Woken up after fw completion timeout\n");
3084		if (time_remain == 0) {
3085			FNIC_SCSI_DBG(KERN_INFO, fnic->host, fnic->fnic_num,
3086				  "FW reset completion timed out after %d ms)\n",
3087				  FNIC_FW_RESET_TIMEOUT);
3088		}
3089		atomic64_inc(&fnic->fnic_stats.reset_stats.fw_reset_timeouts);
3090	}
3091	fnic->fw_reset_done = NULL;
3092}