/*

   * QLogic Fibre Channel HBA Driver

   * Copyright (c)  2003-2014 QLogic Corporation

   *

   * See LICENSE.qla2xxx for copyright and licensing details.

   */
  #include "qla_def.h"
  
  #include <linux/moduleparam.h>
  #include <linux/vmalloc.h>

  #include <linux/delay.h>

  #include <linux/kthread.h>

  #include <linux/mutex.h>

  #include <linux/kobject.h>

  #include <linux/slab.h>

  #include <scsi/scsi_tcq.h>
  #include <scsi/scsicam.h>
  #include <scsi/scsi_transport.h>
  #include <scsi/scsi_transport_fc.h>

  #include "qla_target.h"

  /*
   * Driver version
   */
  char qla2x00_version_str[40];

  static int apidev_major;

  /*
   * SRB allocation cache
   */

  static struct kmem_cache *srb_cachep;

  /*
   * CT6 CTX allocation cache
   */
  static struct kmem_cache *ctx_cachep;

  /*
   * error level for logging
   */
  int ql_errlev = ql_log_all;

  static int ql2xenableclass2;

  module_param(ql2xenableclass2, int, S_IRUGO|S_IRUSR);
  MODULE_PARM_DESC(ql2xenableclass2,
  		"Specify if Class 2 operations are supported from the very "
  		"beginning. Default is 0 - class 2 not supported.");

  int ql2xlogintimeout = 20;

  module_param(ql2xlogintimeout, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xlogintimeout,
  		"Login timeout value in seconds.");

  int qlport_down_retry;

  module_param(qlport_down_retry, int, S_IRUGO);

  MODULE_PARM_DESC(qlport_down_retry,

  		"Maximum number of command retries to a port that returns "

  		"a PORT-DOWN status.");

  int ql2xplogiabsentdevice;
  module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(ql2xplogiabsentdevice,
  		"Option to enable PLOGI to devices that are not present after "

  		"a Fabric scan.  This is needed for several broken switches. "

  		"Default is 0 - no PLOGI. 1 - perfom PLOGI.");

  int ql2xloginretrycount = 0;

  module_param(ql2xloginretrycount, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xloginretrycount,
  		"Specify an alternate value for the NVRAM login retry count.");

  int ql2xallocfwdump = 1;

  module_param(ql2xallocfwdump, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xallocfwdump,
  		"Option to enable allocation of memory for a firmware dump "
  		"during HBA initialization.  Memory allocation requirements "
  		"vary by ISP type.  Default is 1 - allocate memory.");

  int ql2xextended_error_logging;

  module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);

  MODULE_PARM_DESC(ql2xextended_error_logging,

  		"Option to enable extended error logging,
  "
  		"\t\tDefault is 0 - no logging.  0x40000000 - Module Init & Probe.
  "
  		"\t\t0x20000000 - Mailbox Cmnds. 0x10000000 - Device Discovery.
  "
  		"\t\t0x08000000 - IO tracing.    0x04000000 - DPC Thread.
  "
  		"\t\t0x02000000 - Async events.  0x01000000 - Timer routines.
  "
  		"\t\t0x00800000 - User space.    0x00400000 - Task Management.
  "
  		"\t\t0x00200000 - AER/EEH.       0x00100000 - Multi Q.
  "
  		"\t\t0x00080000 - P3P Specific.  0x00040000 - Virtual Port.
  "
  		"\t\t0x00020000 - Buffer Dump.   0x00010000 - Misc.
  "

  		"\t\t0x00008000 - Verbose.       0x00004000 - Target.
  "
  		"\t\t0x00002000 - Target Mgmt.   0x00001000 - Target TMF.
  "

  		"\t\t0x7fffffff - For enabling all logs, can be too many logs.
  "

  		"\t\t0x1e400000 - Preferred value for capturing essential "
  		"debug information (equivalent to old "
  		"ql2xextended_error_logging=1).
  "

  		"\t\tDo LOGICAL OR of the value to enable more than one level");

  int ql2xshiftctondsd = 6;

  module_param(ql2xshiftctondsd, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xshiftctondsd,
  		"Set to control shifting of command type processing "
  		"based on total number of SG elements.");

  int ql2xfdmienable=1;

  module_param(ql2xfdmienable, int, S_IRUGO|S_IWUSR);

  MODULE_PARM_DESC(ql2xfdmienable,

  		"Enables FDMI registrations. "
  		"0 - no FDMI. Default is 1 - perform FDMI.");

  #define MAX_Q_DEPTH	32
  static int ql2xmaxqdepth = MAX_Q_DEPTH;

  module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(ql2xmaxqdepth,

  		"Maximum queue depth to set for each LUN. "
  		"Default is 32.");

  int ql2xenabledif = 2;
  module_param(ql2xenabledif, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xenabledif,

  		" Enable T10-CRC-DIF:
  "
  		" Default is 2.
  "
  		"  0 -- No DIF Support
  "
  		"  1 -- Enable DIF for all types
  "
  		"  2 -- Enable DIF for all types, except Type 0.
  ");

  int ql2xenablehba_err_chk = 2;

  module_param(ql2xenablehba_err_chk, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(ql2xenablehba_err_chk,

  		" Enable T10-CRC-DIF Error isolation by HBA:
  "

  		" Default is 2.
  "

  		"  0 -- Error isolation disabled
  "
  		"  1 -- Error isolation enabled only for DIX Type 0
  "
  		"  2 -- Error isolation enabled for all Types
  ");

  int ql2xiidmaenable=1;

  module_param(ql2xiidmaenable, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xiidmaenable,
  		"Enables iIDMA settings "
  		"Default is 1 - perform iIDMA. 0 - no iIDMA.");

  int ql2xmaxqueues = 1;

  module_param(ql2xmaxqueues, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xmaxqueues,
  		"Enables MQ settings "

  		"Default is 1 for single queue. Set it to number "
  		"of queues in MQ mode.");

  
  int ql2xmultique_tag;

  module_param(ql2xmultique_tag, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xmultique_tag,
  		"Enables CPU affinity settings for the driver "
  		"Default is 0 for no affinity of request and response IO. "
  		"Set it to 1 to turn on the cpu affinity.");

  
  int ql2xfwloadbin;

  module_param(ql2xfwloadbin, int, S_IRUGO|S_IWUSR);

  MODULE_PARM_DESC(ql2xfwloadbin,

  		"Option to specify location from which to load ISP firmware:.
  "
  		" 2 -- load firmware via the request_firmware() (hotplug).
  "

  		"      interface.
  "
  		" 1 -- load firmware from flash.
  "
  		" 0 -- use default semantics.
  ");

  int ql2xetsenable;

  module_param(ql2xetsenable, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xetsenable,
  		"Enables firmware ETS burst."
  		"Default is 0 - skip ETS enablement.");

  int ql2xdbwr = 1;

  module_param(ql2xdbwr, int, S_IRUGO|S_IWUSR);

  MODULE_PARM_DESC(ql2xdbwr,

  		"Option to specify scheme for request queue posting.
  "
  		" 0 -- Regular doorbell.
  "
  		" 1 -- CAMRAM doorbell (faster).
  ");

  int ql2xtargetreset = 1;

  module_param(ql2xtargetreset, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xtargetreset,
  		 "Enable target reset."
  		 "Default is 1 - use hw defaults.");

  int ql2xgffidenable;

  module_param(ql2xgffidenable, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xgffidenable,
  		"Enables GFF_ID checks of port type. "
  		"Default is 0 - Do not use GFF_ID information.");

  int ql2xasynctmfenable;

  module_param(ql2xasynctmfenable, int, S_IRUGO);

  MODULE_PARM_DESC(ql2xasynctmfenable,
  		"Enables issue of TM IOCBs asynchronously via IOCB mechanism"
  		"Default is 0 - Issue TM IOCBs via mailbox mechanism.");

  
  int ql2xdontresethba;

  module_param(ql2xdontresethba, int, S_IRUGO|S_IWUSR);

  MODULE_PARM_DESC(ql2xdontresethba,

  		"Option to specify reset behaviour.
  "
  		" 0 (Default) -- Reset on failure.
  "
  		" 1 -- Do not reset on failure.
  ");

  uint64_t ql2xmaxlun = MAX_LUNS;
  module_param(ql2xmaxlun, ullong, S_IRUGO);

  MODULE_PARM_DESC(ql2xmaxlun,
  		"Defines the maximum LU number to register with the SCSI "
  		"midlayer. Default is 65535.");

  int ql2xmdcapmask = 0x1F;
  module_param(ql2xmdcapmask, int, S_IRUGO);
  MODULE_PARM_DESC(ql2xmdcapmask,
  		"Set the Minidump driver capture mask level. "

  		"Default is 0x1F - Can be set to 0x3, 0x7, 0xF, 0x1F, 0x7F.");

  int ql2xmdenable = 1;

  module_param(ql2xmdenable, int, S_IRUGO);
  MODULE_PARM_DESC(ql2xmdenable,
  		"Enable/disable MiniDump. "

  		"0 - MiniDump disabled. "
  		"1 (Default) - MiniDump enabled.");

  /*

   * SCSI host template entry points

   */
  static int qla2xxx_slave_configure(struct scsi_device * device);

  static int qla2xxx_slave_alloc(struct scsi_device *);

  static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time);
  static void qla2xxx_scan_start(struct Scsi_Host *);

  static void qla2xxx_slave_destroy(struct scsi_device *);

  static int qla2xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);

  static int qla2xxx_eh_abort(struct scsi_cmnd *);
  static int qla2xxx_eh_device_reset(struct scsi_cmnd *);

  static int qla2xxx_eh_target_reset(struct scsi_cmnd *);

  static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
  static int qla2xxx_eh_host_reset(struct scsi_cmnd *);

  static void qla2x00_clear_drv_active(struct qla_hw_data *);

  static void qla2x00_free_device(scsi_qla_host_t *);

  static void qla83xx_disable_laser(scsi_qla_host_t *vha);

  struct scsi_host_template qla2xxx_driver_template = {

  	.module			= THIS_MODULE,

  	.name			= QLA2XXX_DRIVER_NAME,

  	.queuecommand		= qla2xxx_queuecommand,

  
  	.eh_abort_handler	= qla2xxx_eh_abort,
  	.eh_device_reset_handler = qla2xxx_eh_device_reset,

  	.eh_target_reset_handler = qla2xxx_eh_target_reset,

  	.eh_bus_reset_handler	= qla2xxx_eh_bus_reset,
  	.eh_host_reset_handler	= qla2xxx_eh_host_reset,
  
  	.slave_configure	= qla2xxx_slave_configure,
  
  	.slave_alloc		= qla2xxx_slave_alloc,
  	.slave_destroy		= qla2xxx_slave_destroy,

  	.scan_finished		= qla2xxx_scan_finished,
  	.scan_start		= qla2xxx_scan_start,

  	.change_queue_depth	= scsi_change_queue_depth,

  	.this_id		= -1,
  	.cmd_per_lun		= 3,
  	.use_clustering		= ENABLE_CLUSTERING,
  	.sg_tablesize		= SG_ALL,
  
  	.max_sectors		= 0xFFFF,

  	.shost_attrs		= qla2x00_host_attrs,

  
  	.supported_mode		= MODE_INITIATOR,

  	.use_blk_tags		= 1,

  	.track_queue_depth	= 1,

  };

  static struct scsi_transport_template *qla2xxx_transport_template = NULL;

  struct scsi_transport_template *qla2xxx_transport_vport_template = NULL;

  /* TODO Convert to inlines
   *
   * Timer routines
   */

  __inline__ void

  qla2x00_start_timer(scsi_qla_host_t *vha, void *func, unsigned long interval)

  {

  	init_timer(&vha->timer);
  	vha->timer.expires = jiffies + interval * HZ;
  	vha->timer.data = (unsigned long)vha;
  	vha->timer.function = (void (*)(unsigned long))func;
  	add_timer(&vha->timer);
  	vha->timer_active = 1;

  }
  
  static inline void

  qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval)

  {

  	/* Currently used for 82XX only. */

  	if (vha->device_flags & DFLG_DEV_FAILED) {
  		ql_dbg(ql_dbg_timer, vha, 0x600d,
  		    "Device in a failed state, returning.
  ");

  		return;

  	}

  	mod_timer(&vha->timer, jiffies + interval * HZ);

  }

  static __inline__ void

  qla2x00_stop_timer(scsi_qla_host_t *vha)

  {

  	del_timer_sync(&vha->timer);
  	vha->timer_active = 0;

  }

  static int qla2x00_do_dpc(void *data);
  
  static void qla2x00_rst_aen(scsi_qla_host_t *);

  static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t,
  	struct req_que **, struct rsp_que **);

  static void qla2x00_free_fw_dump(struct qla_hw_data *);

  static void qla2x00_mem_free(struct qla_hw_data *);

  /* -------------------------------------------------------------------------- */

  static int qla2x00_alloc_queues(struct qla_hw_data *ha, struct req_que *req,
  				struct rsp_que *rsp)

  {

  	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);

  	ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues,

  				GFP_KERNEL);
  	if (!ha->req_q_map) {

  		ql_log(ql_log_fatal, vha, 0x003b,
  		    "Unable to allocate memory for request queue ptrs.
  ");

  		goto fail_req_map;
  	}

  	ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues,

  				GFP_KERNEL);
  	if (!ha->rsp_q_map) {

  		ql_log(ql_log_fatal, vha, 0x003c,
  		    "Unable to allocate memory for response queue ptrs.
  ");

  		goto fail_rsp_map;
  	}

  	/*
  	 * Make sure we record at least the request and response queue zero in
  	 * case we need to free them if part of the probe fails.
  	 */
  	ha->rsp_q_map[0] = rsp;
  	ha->req_q_map[0] = req;

  	set_bit(0, ha->rsp_qid_map);
  	set_bit(0, ha->req_qid_map);
  	return 1;
  
  fail_rsp_map:
  	kfree(ha->req_q_map);
  	ha->req_q_map = NULL;
  fail_req_map:
  	return -ENOMEM;
  }

  static void qla2x00_free_req_que(struct qla_hw_data *ha, struct req_que *req)

  {

  	if (IS_QLAFX00(ha)) {
  		if (req && req->ring_fx00)
  			dma_free_coherent(&ha->pdev->dev,
  			    (req->length_fx00 + 1) * sizeof(request_t),
  			    req->ring_fx00, req->dma_fx00);
  	} else if (req && req->ring)

  		dma_free_coherent(&ha->pdev->dev,
  		(req->length + 1) * sizeof(request_t),
  		req->ring, req->dma);

  	if (req)
  		kfree(req->outstanding_cmds);

  	kfree(req);
  	req = NULL;
  }

  static void qla2x00_free_rsp_que(struct qla_hw_data *ha, struct rsp_que *rsp)
  {

  	if (IS_QLAFX00(ha)) {
  		if (rsp && rsp->ring)
  			dma_free_coherent(&ha->pdev->dev,
  			    (rsp->length_fx00 + 1) * sizeof(request_t),
  			    rsp->ring_fx00, rsp->dma_fx00);
  	} else if (rsp && rsp->ring) {

  		dma_free_coherent(&ha->pdev->dev,
  		(rsp->length + 1) * sizeof(response_t),
  		rsp->ring, rsp->dma);

  	}

  	kfree(rsp);
  	rsp = NULL;
  }

  static void qla2x00_free_queues(struct qla_hw_data *ha)
  {
  	struct req_que *req;
  	struct rsp_que *rsp;
  	int cnt;

  	for (cnt = 0; cnt < ha->max_req_queues; cnt++) {

  		req = ha->req_q_map[cnt];

  		qla2x00_free_req_que(ha, req);

  	}

  	kfree(ha->req_q_map);
  	ha->req_q_map = NULL;

  
  	for (cnt = 0; cnt < ha->max_rsp_queues; cnt++) {
  		rsp = ha->rsp_q_map[cnt];
  		qla2x00_free_rsp_que(ha, rsp);
  	}
  	kfree(ha->rsp_q_map);
  	ha->rsp_q_map = NULL;

  }

  static int qla25xx_setup_mode(struct scsi_qla_host *vha)
  {
  	uint16_t options = 0;
  	int ques, req, ret;
  	struct qla_hw_data *ha = vha->hw;

  	if (!(ha->fw_attributes & BIT_6)) {

  		ql_log(ql_log_warn, vha, 0x00d8,
  		    "Firmware is not multi-queue capable.
  ");

  		goto fail;
  	}

  	if (ql2xmultique_tag) {

  		/* create a request queue for IO */
  		options |= BIT_7;
  		req = qla25xx_create_req_que(ha, options, 0, 0, -1,
  			QLA_DEFAULT_QUE_QOS);
  		if (!req) {

  			ql_log(ql_log_warn, vha, 0x00e0,
  			    "Failed to create request queue.
  ");

  			goto fail;
  		}

  		ha->wq = alloc_workqueue("qla2xxx_wq", WQ_MEM_RECLAIM, 1);

  		vha->req = ha->req_q_map[req];
  		options |= BIT_1;
  		for (ques = 1; ques < ha->max_rsp_queues; ques++) {
  			ret = qla25xx_create_rsp_que(ha, options, 0, 0, req);
  			if (!ret) {

  				ql_log(ql_log_warn, vha, 0x00e8,
  				    "Failed to create response queue.
  ");

  				goto fail2;
  			}
  		}

  		ha->flags.cpu_affinity_enabled = 1;

  		ql_dbg(ql_dbg_multiq, vha, 0xc007,
  		    "CPU affinity mode enalbed, "
  		    "no. of response queues:%d no. of request queues:%d.
  ",
  		    ha->max_rsp_queues, ha->max_req_queues);
  		ql_dbg(ql_dbg_init, vha, 0x00e9,
  		    "CPU affinity mode enalbed, "
  		    "no. of response queues:%d no. of request queues:%d.
  ",
  		    ha->max_rsp_queues, ha->max_req_queues);

  	}
  	return 0;
  fail2:
  	qla25xx_delete_queues(vha);

  	destroy_workqueue(ha->wq);
  	ha->wq = NULL;

  	vha->req = ha->req_q_map[0];

  fail:
  	ha->mqenable = 0;

  	kfree(ha->req_q_map);
  	kfree(ha->rsp_q_map);
  	ha->max_req_queues = ha->max_rsp_queues = 1;

  	return 1;
  }

  static char *

  qla2x00_pci_info_str(struct scsi_qla_host *vha, char *str)

  {

  	struct qla_hw_data *ha = vha->hw;

  	static char *pci_bus_modes[] = {
  		"33", "66", "100", "133",
  	};
  	uint16_t pci_bus;
  
  	strcpy(str, "PCI");
  	pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9;
  	if (pci_bus) {
  		strcat(str, "-X (");
  		strcat(str, pci_bus_modes[pci_bus]);
  	} else {
  		pci_bus = (ha->pci_attr & BIT_8) >> 8;
  		strcat(str, " (");
  		strcat(str, pci_bus_modes[pci_bus]);
  	}
  	strcat(str, " MHz)");
  
  	return (str);
  }

  static char *

  qla24xx_pci_info_str(struct scsi_qla_host *vha, char *str)

  {
  	static char *pci_bus_modes[] = { "33", "66", "100", "133", };

  	struct qla_hw_data *ha = vha->hw;

  	uint32_t pci_bus;

  	if (pci_is_pcie(ha->pdev)) {

  		char lwstr[6];

  		uint32_t lstat, lspeed, lwidth;

  		pcie_capability_read_dword(ha->pdev, PCI_EXP_LNKCAP, &lstat);
  		lspeed = lstat & PCI_EXP_LNKCAP_SLS;
  		lwidth = (lstat & PCI_EXP_LNKCAP_MLW) >> 4;

  
  		strcpy(str, "PCIe (");

  		switch (lspeed) {
  		case 1:

  			strcat(str, "2.5GT/s ");

  			break;
  		case 2:

  			strcat(str, "5.0GT/s ");

  			break;
  		case 3:
  			strcat(str, "8.0GT/s ");
  			break;
  		default:

  			strcat(str, "<unknown> ");

  			break;
  		}

  		snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth);
  		strcat(str, lwstr);
  
  		return str;
  	}
  
  	strcpy(str, "PCI");
  	pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8;
  	if (pci_bus == 0 || pci_bus == 8) {
  		strcat(str, " (");
  		strcat(str, pci_bus_modes[pci_bus >> 3]);
  	} else {
  		strcat(str, "-X ");
  		if (pci_bus & BIT_2)
  			strcat(str, "Mode 2");
  		else
  			strcat(str, "Mode 1");
  		strcat(str, " (");
  		strcat(str, pci_bus_modes[pci_bus & ~BIT_2]);
  	}
  	strcat(str, " MHz)");
  
  	return str;
  }

  static char *

  qla2x00_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)

  {
  	char un_str[10];

  	struct qla_hw_data *ha = vha->hw;

  	snprintf(str, size, "%d.%02d.%02d ", ha->fw_major_version,
  	    ha->fw_minor_version, ha->fw_subminor_version);

  
  	if (ha->fw_attributes & BIT_9) {
  		strcat(str, "FLX");
  		return (str);
  	}
  
  	switch (ha->fw_attributes & 0xFF) {
  	case 0x7:
  		strcat(str, "EF");
  		break;
  	case 0x17:
  		strcat(str, "TP");
  		break;
  	case 0x37:
  		strcat(str, "IP");
  		break;
  	case 0x77:
  		strcat(str, "VI");
  		break;
  	default:
  		sprintf(un_str, "(%x)", ha->fw_attributes);
  		strcat(str, un_str);
  		break;
  	}
  	if (ha->fw_attributes & 0x100)
  		strcat(str, "X");
  
  	return (str);
  }

  static char *

  qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str, size_t size)

  {

  	struct qla_hw_data *ha = vha->hw;

  	snprintf(str, size, "%d.%02d.%02d (%x)", ha->fw_major_version,

  	    ha->fw_minor_version, ha->fw_subminor_version, ha->fw_attributes);

  	return str;

  }

  void
  qla2x00_sp_free_dma(void *vha, void *ptr)

  {

  	srb_t *sp = (srb_t *)ptr;
  	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
  	struct qla_hw_data *ha = sp->fcport->vha->hw;
  	void *ctx = GET_CMD_CTX_SP(sp);

  	if (sp->flags & SRB_DMA_VALID) {
  		scsi_dma_unmap(cmd);
  		sp->flags &= ~SRB_DMA_VALID;

  	}

  	if (sp->flags & SRB_CRC_PROT_DMA_VALID) {
  		dma_unmap_sg(&ha->pdev->dev, scsi_prot_sglist(cmd),
  		    scsi_prot_sg_count(cmd), cmd->sc_data_direction);
  		sp->flags &= ~SRB_CRC_PROT_DMA_VALID;
  	}
  
  	if (sp->flags & SRB_CRC_CTX_DSD_VALID) {
  		/* List assured to be having elements */

  		qla2x00_clean_dsd_pool(ha, sp, NULL);

  		sp->flags &= ~SRB_CRC_CTX_DSD_VALID;
  	}
  
  	if (sp->flags & SRB_CRC_CTX_DMA_VALID) {
  		dma_pool_free(ha->dl_dma_pool, ctx,
  		    ((struct crc_context *)ctx)->crc_ctx_dma);
  		sp->flags &= ~SRB_CRC_CTX_DMA_VALID;
  	}
  
  	if (sp->flags & SRB_FCP_CMND_DMA_VALID) {
  		struct ct6_dsd *ctx1 = (struct ct6_dsd *)ctx;

  		dma_pool_free(ha->fcp_cmnd_dma_pool, ctx1->fcp_cmnd,
  			ctx1->fcp_cmnd_dma);
  		list_splice(&ctx1->dsd_list, &ha->gbl_dsd_list);
  		ha->gbl_dsd_inuse -= ctx1->dsd_use_cnt;
  		ha->gbl_dsd_avail += ctx1->dsd_use_cnt;
  		mempool_free(ctx1, ha->ctx_mempool);
  		ctx1 = NULL;
  	}
  
  	CMD_SP(cmd) = NULL;

  	qla2x00_rel_sp(sp->fcport->vha, sp);

  }

  static void

  qla2x00_sp_compl(void *data, void *ptr, int res)
  {
  	struct qla_hw_data *ha = (struct qla_hw_data *)data;
  	srb_t *sp = (srb_t *)ptr;
  	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
  
  	cmd->result = res;
  
  	if (atomic_read(&sp->ref_count) == 0) {
  		ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3015,
  		    "SP reference-count to ZERO -- sp=%p cmd=%p.
  ",
  		    sp, GET_CMD_SP(sp));
  		if (ql2xextended_error_logging & ql_dbg_io)
  			BUG();
  		return;
  	}
  	if (!atomic_dec_and_test(&sp->ref_count))
  		return;
  
  	qla2x00_sp_free_dma(ha, sp);
  	cmd->scsi_done(cmd);

  }

  /* If we are SP1 here, we need to still take and release the host_lock as SP1
   * does not have the changes necessary to avoid taking host->host_lock.
   */

  static int

  qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)

  {

  	scsi_qla_host_t *vha = shost_priv(host);

  	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;

  	struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));

  	struct qla_hw_data *ha = vha->hw;
  	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);

  	srb_t *sp;
  	int rval;

  	if (ha->flags.eeh_busy) {

  		if (ha->flags.pci_channel_io_perm_failure) {

  			ql_dbg(ql_dbg_aer, vha, 0x9010,

  			    "PCI Channel IO permanent failure, exiting "
  			    "cmd=%p.
  ", cmd);

  			cmd->result = DID_NO_CONNECT << 16;

  		} else {

  			ql_dbg(ql_dbg_aer, vha, 0x9011,

  			    "EEH_Busy, Requeuing the cmd=%p.
  ", cmd);

  			cmd->result = DID_REQUEUE << 16;

  		}

  		goto qc24_fail_command;
  	}

  	rval = fc_remote_port_chkready(rport);
  	if (rval) {
  		cmd->result = rval;

  		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3003,

  		    "fc_remote_port_chkready failed for cmd=%p, rval=0x%x.
  ",
  		    cmd, rval);

  		goto qc24_fail_command;
  	}

  	if (!vha->flags.difdix_supported &&
  		scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {

  			ql_dbg(ql_dbg_io, vha, 0x3004,
  			    "DIF Cap not reg, fail DIF capable cmd's:%p.
  ",
  			    cmd);

  			cmd->result = DID_NO_CONNECT << 16;
  			goto qc24_fail_command;
  	}

  
  	if (!fcport) {
  		cmd->result = DID_NO_CONNECT << 16;
  		goto qc24_fail_command;
  	}

  	if (atomic_read(&fcport->state) != FCS_ONLINE) {
  		if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||

  			atomic_read(&base_vha->loop_state) == LOOP_DEAD) {

  			ql_dbg(ql_dbg_io, vha, 0x3005,
  			    "Returning DNC, fcport_state=%d loop_state=%d.
  ",
  			    atomic_read(&fcport->state),
  			    atomic_read(&base_vha->loop_state));

  			cmd->result = DID_NO_CONNECT << 16;
  			goto qc24_fail_command;
  		}

  		goto qc24_target_busy;

  	}

  	/*
  	 * Return target busy if we've received a non-zero retry_delay_timer
  	 * in a FCP_RSP.
  	 */

  	if (fcport->retry_delay_timestamp == 0) {
  		/* retry delay not set */
  	} else if (time_after(jiffies, fcport->retry_delay_timestamp))

  		fcport->retry_delay_timestamp = 0;
  	else
  		goto qc24_target_busy;

  	sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);

  	if (!sp)

  		goto qc24_host_busy;

  	sp->u.scmd.cmd = cmd;
  	sp->type = SRB_SCSI_CMD;
  	atomic_set(&sp->ref_count, 1);
  	CMD_SP(cmd) = (void *)sp;
  	sp->free = qla2x00_sp_free_dma;
  	sp->done = qla2x00_sp_compl;

  	rval = ha->isp_ops->start_scsi(sp);

  	if (rval != QLA_SUCCESS) {

  		ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x3013,

  		    "Start scsi failed rval=%d for cmd=%p.
  ", rval, cmd);

  		goto qc24_host_busy_free_sp;

  	}

  	return 0;
  
  qc24_host_busy_free_sp:

  	qla2x00_sp_free_dma(ha, sp);

  qc24_host_busy:

  	return SCSI_MLQUEUE_HOST_BUSY;

  qc24_target_busy:
  	return SCSI_MLQUEUE_TARGET_BUSY;

  qc24_fail_command:

  	cmd->scsi_done(cmd);

  
  	return 0;
  }

  /*
   * qla2x00_eh_wait_on_command
   *    Waits for the command to be returned by the Firmware for some
   *    max time.
   *
   * Input:

   *    cmd = Scsi Command to wait on.

   *
   * Return:
   *    Not Found : 0
   *    Found : 1
   */
  static int

  qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd)

  {

  #define ABORT_POLLING_PERIOD	1000

  #define ABORT_WAIT_ITER		((2 * 1000) / (ABORT_POLLING_PERIOD))

  	unsigned long wait_iter = ABORT_WAIT_ITER;

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
  	struct qla_hw_data *ha = vha->hw;

  	int ret = QLA_SUCCESS;

  	if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) {

  		ql_dbg(ql_dbg_taskm, vha, 0x8005,
  		    "Return:eh_wait.
  ");

  		return ret;
  	}

  	while (CMD_SP(cmd) && wait_iter--) {

  		msleep(ABORT_POLLING_PERIOD);

  	}
  	if (CMD_SP(cmd))
  		ret = QLA_FUNCTION_FAILED;

  	return ret;

  }
  
  /*
   * qla2x00_wait_for_hba_online

   *    Wait till the HBA is online after going through

   *    <= MAX_RETRIES_OF_ISP_ABORT  or
   *    finally HBA is disabled ie marked offline
   *
   * Input:
   *     ha - pointer to host adapter structure

   *
   * Note:

   *    Does context switching-Release SPIN_LOCK
   *    (if any) before calling this routine.
   *
   * Return:
   *    Success (Adapter is online) : 0
   *    Failed  (Adapter is offline/disabled) : 1
   */

  int

  qla2x00_wait_for_hba_online(scsi_qla_host_t *vha)

  {

  	int		return_status;
  	unsigned long	wait_online;

  	struct qla_hw_data *ha = vha->hw;
  	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);

  	wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ);

  	while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
  	    test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
  	    test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
  	    ha->dpc_active) && time_before(jiffies, wait_online)) {

  
  		msleep(1000);
  	}

  	if (base_vha->flags.online)

  		return_status = QLA_SUCCESS;

  	else
  		return_status = QLA_FUNCTION_FAILED;

  	return (return_status);
  }

  /*

   * qla2x00_wait_for_hba_ready
   * Wait till the HBA is ready before doing driver unload

   *
   * Input:
   *     ha - pointer to host adapter structure
   *
   * Note:
   *    Does context switching-Release SPIN_LOCK
   *    (if any) before calling this routine.
   *

   */

  static void
  qla2x00_wait_for_hba_ready(scsi_qla_host_t *vha)

  {

  	struct qla_hw_data *ha = vha->hw;

  	while (((qla2x00_reset_active(vha)) || ha->dpc_active ||
  	    ha->flags.mbox_busy) ||
  		test_bit(FX00_RESET_RECOVERY, &vha->dpc_flags) ||
  		test_bit(FX00_TARGET_SCAN, &vha->dpc_flags))

  		msleep(1000);

  }

  int
  qla2x00_wait_for_chip_reset(scsi_qla_host_t *vha)
  {
  	int		return_status;
  	unsigned long	wait_reset;
  	struct qla_hw_data *ha = vha->hw;
  	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
  
  	wait_reset = jiffies + (MAX_LOOP_TIMEOUT * HZ);
  	while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) ||
  	    test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
  	    test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
  	    ha->dpc_active) && time_before(jiffies, wait_reset)) {
  
  		msleep(1000);
  
  		if (!test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
  		    ha->flags.chip_reset_done)
  			break;
  	}
  	if (ha->flags.chip_reset_done)
  		return_status = QLA_SUCCESS;
  	else
  		return_status = QLA_FUNCTION_FAILED;
  
  	return return_status;
  }

  static void
  sp_get(struct srb *sp)
  {
  	atomic_inc(&sp->ref_count);
  }

  /**************************************************************************
  * qla2xxx_eh_abort
  *
  * Description:
  *    The abort function will abort the specified command.
  *
  * Input:
  *    cmd = Linux SCSI command packet to be aborted.
  *
  * Returns:
  *    Either SUCCESS or FAILED.
  *
  * Note:

  *    Only return FAILED if command not returned by firmware.

  **************************************************************************/

  static int

  qla2xxx_eh_abort(struct scsi_cmnd *cmd)
  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);

  	srb_t *sp;

  	int ret;

  	unsigned int id;
  	uint64_t lun;

  	unsigned long flags;

  	int rval, wait = 0;

  	struct qla_hw_data *ha = vha->hw;

  	if (!CMD_SP(cmd))

  		return SUCCESS;

  	ret = fc_block_scsi_eh(cmd);
  	if (ret != 0)
  		return ret;
  	ret = SUCCESS;

  	id = cmd->device->id;
  	lun = cmd->device->lun;

  	spin_lock_irqsave(&ha->hardware_lock, flags);

  	sp = (srb_t *) CMD_SP(cmd);
  	if (!sp) {
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  		return SUCCESS;
  	}

  	ql_dbg(ql_dbg_taskm, vha, 0x8002,

  	    "Aborting from RISC nexus=%ld:%d:%llu sp=%p cmd=%p
  ",

  	    vha->host_no, id, lun, sp, cmd);

  	/* Get a reference to the sp and drop the lock.*/
  	sp_get(sp);

  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  	rval = ha->isp_ops->abort_command(sp);
  	if (rval) {
  		if (rval == QLA_FUNCTION_PARAMETER_ERROR) {
  			/*
  			 * Decrement the ref_count since we can't find the
  			 * command
  			 */
  			atomic_dec(&sp->ref_count);
  			ret = SUCCESS;
  		} else
  			ret = FAILED;

  		ql_dbg(ql_dbg_taskm, vha, 0x8003,

  		    "Abort command mbx failed cmd=%p, rval=%x.
  ", cmd, rval);

  	} else {

  		ql_dbg(ql_dbg_taskm, vha, 0x8004,

  		    "Abort command mbx success cmd=%p.
  ", cmd);

  		wait = 1;
  	}

  
  	spin_lock_irqsave(&ha->hardware_lock, flags);

  	/*
  	 * Clear the slot in the oustanding_cmds array if we can't find the
  	 * command to reclaim the resources.
  	 */
  	if (rval == QLA_FUNCTION_PARAMETER_ERROR)
  		vha->req->outstanding_cmds[sp->handle] = NULL;

  	sp->done(ha, sp, 0);

  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  	/* Did the command return during mailbox execution? */
  	if (ret == FAILED && !CMD_SP(cmd))
  		ret = SUCCESS;

  	/* Wait for the command to be returned. */

  	if (wait) {

  		if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) {

  			ql_log(ql_log_warn, vha, 0x8006,

  			    "Abort handler timed out cmd=%p.
  ", cmd);

  			ret = FAILED;

  		}

  	}

  	ql_log(ql_log_info, vha, 0x801c,

  	    "Abort command issued nexus=%ld:%d:%llu --  %d %x.
  ",

  	    vha->host_no, id, lun, wait, ret);

  	return ret;
  }

  int

  qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *vha, unsigned int t,

  	uint64_t l, enum nexus_wait_type type)

  {

  	int cnt, match, status;

  	unsigned long flags;

  	struct qla_hw_data *ha = vha->hw;

  	struct req_que *req;

  	srb_t *sp;

  	struct scsi_cmnd *cmd;

  	status = QLA_SUCCESS;

  	spin_lock_irqsave(&ha->hardware_lock, flags);

  	req = vha->req;

  	for (cnt = 1; status == QLA_SUCCESS &&

  		cnt < req->num_outstanding_cmds; cnt++) {

  		sp = req->outstanding_cmds[cnt];
  		if (!sp)

  			continue;

  		if (sp->type != SRB_SCSI_CMD)

  			continue;

  		if (vha->vp_idx != sp->fcport->vha->vp_idx)
  			continue;
  		match = 0;

  		cmd = GET_CMD_SP(sp);

  		switch (type) {
  		case WAIT_HOST:
  			match = 1;
  			break;
  		case WAIT_TARGET:

  			match = cmd->device->id == t;

  			break;
  		case WAIT_LUN:

  			match = (cmd->device->id == t &&
  				cmd->device->lun == l);

  			break;

  		}

  		if (!match)
  			continue;
  
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);

  		status = qla2x00_eh_wait_on_command(cmd);

  		spin_lock_irqsave(&ha->hardware_lock, flags);

  	}

  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  
  	return status;

  }

  static char *reset_errors[] = {
  	"HBA not online",
  	"HBA not ready",
  	"Task management failed",
  	"Waiting for command completions",
  };

  static int

  __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,

      struct scsi_cmnd *cmd, int (*do_reset)(struct fc_port *, uint64_t, int))

  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);

  	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;

  	int err;

  	if (!fcport) {

  		return FAILED;

  	}

  	err = fc_block_scsi_eh(cmd);
  	if (err != 0)
  		return err;

  	ql_log(ql_log_info, vha, 0x8009,

  	    "%s RESET ISSUED nexus=%ld:%d:%llu cmd=%p.
  ", name, vha->host_no,

  	    cmd->device->id, cmd->device->lun, cmd);

  	err = 0;

  	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
  		ql_log(ql_log_warn, vha, 0x800a,
  		    "Wait for hba online failed for cmd=%p.
  ", cmd);

  		goto eh_reset_failed;

  	}

  	err = 2;

  	if (do_reset(fcport, cmd->device->lun, cmd->request->cpu + 1)

  		!= QLA_SUCCESS) {
  		ql_log(ql_log_warn, vha, 0x800c,
  		    "do_reset failed for cmd=%p.
  ", cmd);

  		goto eh_reset_failed;

  	}

  	err = 3;

  	if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id,

  	    cmd->device->lun, type) != QLA_SUCCESS) {
  		ql_log(ql_log_warn, vha, 0x800d,

  		    "wait for pending cmds failed for cmd=%p.
  ", cmd);

  		goto eh_reset_failed;

  	}

  	ql_log(ql_log_info, vha, 0x800e,

  	    "%s RESET SUCCEEDED nexus:%ld:%d:%llu cmd=%p.
  ", name,

  	    vha->host_no, cmd->device->id, cmd->device->lun, cmd);

  
  	return SUCCESS;

  eh_reset_failed:

  	ql_log(ql_log_info, vha, 0x800f,

  	    "%s RESET FAILED: %s nexus=%ld:%d:%llu cmd=%p.
  ", name,

  	    reset_errors[err], vha->host_no, cmd->device->id, cmd->device->lun,
  	    cmd);

  	return FAILED;
  }

  static int
  qla2xxx_eh_device_reset(struct scsi_cmnd *cmd)
  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
  	struct qla_hw_data *ha = vha->hw;

  	return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN, cmd,
  	    ha->isp_ops->lun_reset);

  }

  static int

  qla2xxx_eh_target_reset(struct scsi_cmnd *cmd)

  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);
  	struct qla_hw_data *ha = vha->hw;

  	return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET, cmd,
  	    ha->isp_ops->target_reset);

  }

  /**************************************************************************
  * qla2xxx_eh_bus_reset
  *
  * Description:
  *    The bus reset function will reset the bus and abort any executing
  *    commands.
  *
  * Input:
  *    cmd = Linux SCSI command packet of the command that cause the
  *          bus reset.
  *
  * Returns:
  *    SUCCESS/FAILURE (defined as macro in scsi.h).
  *
  **************************************************************************/

  static int

  qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);

  	fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;

  	int ret = FAILED;

  	unsigned int id;
  	uint64_t lun;

  	id = cmd->device->id;
  	lun = cmd->device->lun;

  	if (!fcport) {

  		return ret;

  	}

  	ret = fc_block_scsi_eh(cmd);
  	if (ret != 0)
  		return ret;
  	ret = FAILED;

  	ql_log(ql_log_info, vha, 0x8012,

  	    "BUS RESET ISSUED nexus=%ld:%d:%llu.
  ", vha->host_no, id, lun);

  	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {

  		ql_log(ql_log_fatal, vha, 0x8013,
  		    "Wait for hba online failed board disabled.
  ");

  		goto eh_bus_reset_done;

  	}

  	if (qla2x00_loop_reset(vha) == QLA_SUCCESS)
  		ret = SUCCESS;

  	if (ret == FAILED)
  		goto eh_bus_reset_done;

  	/* Flush outstanding commands. */

  	if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) !=

  	    QLA_SUCCESS) {
  		ql_log(ql_log_warn, vha, 0x8014,
  		    "Wait for pending commands failed.
  ");

  		ret = FAILED;

  	}

  eh_bus_reset_done:

  	ql_log(ql_log_warn, vha, 0x802b,

  	    "BUS RESET %s nexus=%ld:%d:%llu.
  ",

  	    (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);

  	return ret;

  }
  
  /**************************************************************************
  * qla2xxx_eh_host_reset
  *
  * Description:
  *    The reset function will reset the Adapter.
  *
  * Input:
  *      cmd = Linux SCSI command packet of the command that cause the
  *            adapter reset.
  *
  * Returns:
  *      Either SUCCESS or FAILED.
  *
  * Note:
  **************************************************************************/

  static int

  qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
  {

  	scsi_qla_host_t *vha = shost_priv(cmd->device->host);

  	struct qla_hw_data *ha = vha->hw;

  	int ret = FAILED;

  	unsigned int id;
  	uint64_t lun;

  	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);

  	id = cmd->device->id;
  	lun = cmd->device->lun;

  	ql_log(ql_log_info, vha, 0x8018,

  	    "ADAPTER RESET ISSUED nexus=%ld:%d:%llu.
  ", vha->host_no, id, lun);

  	/*
  	 * No point in issuing another reset if one is active.  Also do not
  	 * attempt a reset if we are updating flash.
  	 */
  	if (qla2x00_reset_active(vha) || ha->optrom_state != QLA_SWAITING)

  		goto eh_host_reset_lock;

  	if (vha != base_vha) {
  		if (qla2x00_vp_abort_isp(vha))

  			goto eh_host_reset_lock;

  	} else {

  		if (IS_P3P_TYPE(vha->hw)) {

  			if (!qla82xx_fcoe_ctx_reset(vha)) {
  				/* Ctx reset success */
  				ret = SUCCESS;
  				goto eh_host_reset_lock;
  			}
  			/* fall thru if ctx reset failed */
  		}

  		if (ha->wq)
  			flush_workqueue(ha->wq);

  		set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);

  		if (ha->isp_ops->abort_isp(base_vha)) {

  			clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
  			/* failed. schedule dpc to try */
  			set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);

  			if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
  				ql_log(ql_log_warn, vha, 0x802a,
  				    "wait for hba online failed.
  ");

  				goto eh_host_reset_lock;

  			}

  		}
  		clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);

  	}

  	/* Waiting for command to be returned to OS.*/

  	if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) ==

  		QLA_SUCCESS)

  		ret = SUCCESS;

  eh_host_reset_lock:

  	ql_log(ql_log_info, vha, 0x8017,

  	    "ADAPTER RESET %s nexus=%ld:%d:%llu.
  ",

  	    (ret == FAILED) ? "FAILED" : "SUCCEEDED", vha->host_no, id, lun);

  	return ret;
  }

  
  /*
  * qla2x00_loop_reset
  *      Issue loop reset.
  *
  * Input:
  *      ha = adapter block pointer.
  *
  * Returns:
  *      0 = success
  */

  int

  qla2x00_loop_reset(scsi_qla_host_t *vha)

  {

  	int ret;

  	struct fc_port *fcport;

  	struct qla_hw_data *ha = vha->hw;

  	if (IS_QLAFX00(ha)) {
  		return qlafx00_loop_reset(vha);
  	}

  	if (ql2xtargetreset == 1 && ha->flags.enable_target_reset) {

  		list_for_each_entry(fcport, &vha->vp_fcports, list) {
  			if (fcport->port_type != FCT_TARGET)
  				continue;
  
  			ret = ha->isp_ops->target_reset(fcport, 0, 0);
  			if (ret != QLA_SUCCESS) {

  				ql_dbg(ql_dbg_taskm, vha, 0x802c,

  				    "Bus Reset failed: Reset=%d "

  				    "d_id=%x.
  ", ret, fcport->d_id.b24);

  			}
  		}
  	}

  	if (ha->flags.enable_lip_full_login && !IS_CNA_CAPABLE(ha)) {

  		atomic_set(&vha->loop_state, LOOP_DOWN);
  		atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
  		qla2x00_mark_all_devices_lost(vha, 0);

  		ret = qla2x00_full_login_lip(vha);

  		if (ret != QLA_SUCCESS) {

  			ql_dbg(ql_dbg_taskm, vha, 0x802d,
  			    "full_login_lip=%d.
  ", ret);

  		}

  	}

  	if (ha->flags.enable_lip_reset) {

  		ret = qla2x00_lip_reset(vha);

  		if (ret != QLA_SUCCESS)

  			ql_dbg(ql_dbg_taskm, vha, 0x802e,
  			    "lip_reset failed (%d).
  ", ret);

  	}

  	/* Issue marker command only when we are going to start the I/O */

  	vha->marker_needed = 1;

  	return QLA_SUCCESS;

  }

  void

  qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)

  {