/*
   * QLogic iSCSI HBA Driver

   * Copyright (c)  2003-2013 QLogic Corporation

   *
   * See LICENSE.qla4xxx for copyright and licensing details.
   */
  #include <linux/moduleparam.h>

  #include <linux/slab.h>

  #include <linux/blkdev.h>
  #include <linux/iscsi_boot_sysfs.h>

  #include <linux/inet.h>

  
  #include <scsi/scsi_tcq.h>
  #include <scsi/scsicam.h>
  
  #include "ql4_def.h"

  #include "ql4_version.h"
  #include "ql4_glbl.h"
  #include "ql4_dbg.h"
  #include "ql4_inline.h"

  #include "ql4_83xx.h"

  
  /*
   * Driver version
   */

  static char qla4xxx_version_str[40];

  
  /*
   * SRB allocation cache
   */

  static struct kmem_cache *srb_cachep;

  
  /*
   * Module parameter information and variables
   */

  static int ql4xdisablesysfsboot = 1;

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

  		 " Set to disable exporting boot targets to sysfs.
  "
  		 "\t\t  0 - Export boot targets
  "
  		 "\t\t  1 - Do not export boot targets (Default)");

  int ql4xdontresethba;

  module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR);

  MODULE_PARM_DESC(ql4xdontresethba,

  		 " Don't reset the HBA for driver recovery.
  "
  		 "\t\t  0 - It will reset HBA (Default)
  "
  		 "\t\t  1 - It will NOT reset HBA");

  int ql4xextended_error_logging;

  module_param(ql4xextended_error_logging, int, S_IRUGO | S_IWUSR);

  MODULE_PARM_DESC(ql4xextended_error_logging,

  		 " Option to enable extended error logging.
  "
  		 "\t\t  0 - no logging (Default)
  "
  		 "\t\t  2 - debug logging");

  int ql4xenablemsix = 1;
  module_param(ql4xenablemsix, int, S_IRUGO|S_IWUSR);
  MODULE_PARM_DESC(ql4xenablemsix,

  		 " Set to enable MSI or MSI-X interrupt mechanism.
  "
  		 "\t\t  0 = enable INTx interrupt mechanism.
  "
  		 "\t\t  1 = enable MSI-X interrupt mechanism (Default).
  "
  		 "\t\t  2 = enable MSI interrupt mechanism.");

  #define QL4_DEF_QDEPTH 32

  static int ql4xmaxqdepth = QL4_DEF_QDEPTH;
  module_param(ql4xmaxqdepth, int, S_IRUGO | S_IWUSR);
  MODULE_PARM_DESC(ql4xmaxqdepth,

  		 " Maximum queue depth to report for target devices.
  "
  		 "\t\t  Default: 32.");

  static int ql4xqfulltracking = 1;
  module_param(ql4xqfulltracking, int, S_IRUGO | S_IWUSR);
  MODULE_PARM_DESC(ql4xqfulltracking,
  		 " Enable or disable dynamic tracking and adjustment of
  "
  		 "\t\t scsi device queue depth.
  "
  		 "\t\t  0 - Disable.
  "
  		 "\t\t  1 - Enable. (Default)");

  static int ql4xsess_recovery_tmo = QL4_SESS_RECOVERY_TMO;
  module_param(ql4xsess_recovery_tmo, int, S_IRUGO);
  MODULE_PARM_DESC(ql4xsess_recovery_tmo,

  		" Target Session Recovery Timeout.
  "

  		"\t\t  Default: 120 sec.");

  int ql4xmdcapmask = 0;

  module_param(ql4xmdcapmask, int, S_IRUGO);
  MODULE_PARM_DESC(ql4xmdcapmask,
  		 " Set the Minidump driver capture mask level.
  "

  		 "\t\t  Default is 0 (firmware default capture mask)
  "

  		 "\t\t  Can be set to 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF");

  
  int ql4xenablemd = 1;
  module_param(ql4xenablemd, int, S_IRUGO | S_IWUSR);
  MODULE_PARM_DESC(ql4xenablemd,
  		 " Set to enable minidump.
  "
  		 "\t\t  0 - disable minidump
  "
  		 "\t\t  1 - enable minidump (Default)");

  static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha);

  /*
   * SCSI host template entry points
   */

  static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);

  
  /*
   * iSCSI template entry points
   */

  static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
  				     enum iscsi_param param, char *buf);

  static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn,
  				  enum iscsi_param param, char *buf);

  static int qla4xxx_host_get_param(struct Scsi_Host *shost,
  				  enum iscsi_host_param param, char *buf);

  static int qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data,
  				   uint32_t len);

  static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
  				   enum iscsi_param_type param_type,
  				   int param, char *buf);

  static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc);

  static struct iscsi_endpoint *qla4xxx_ep_connect(struct Scsi_Host *shost,
  						 struct sockaddr *dst_addr,
  						 int non_blocking);
  static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms);
  static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep);
  static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
  				enum iscsi_param param, char *buf);
  static int qla4xxx_conn_start(struct iscsi_cls_conn *conn);
  static struct iscsi_cls_conn *
  qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx);
  static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
  			     struct iscsi_cls_conn *cls_conn,
  			     uint64_t transport_fd, int is_leading);
  static void qla4xxx_conn_destroy(struct iscsi_cls_conn *conn);
  static struct iscsi_cls_session *
  qla4xxx_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max,
  			uint16_t qdepth, uint32_t initial_cmdsn);
  static void qla4xxx_session_destroy(struct iscsi_cls_session *sess);
  static void qla4xxx_task_work(struct work_struct *wdata);
  static int qla4xxx_alloc_pdu(struct iscsi_task *, uint8_t);
  static int qla4xxx_task_xmit(struct iscsi_task *);
  static void qla4xxx_task_cleanup(struct iscsi_task *);
  static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session);
  static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
  				   struct iscsi_stats *stats);

  static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
  			     uint32_t iface_type, uint32_t payload_size,
  			     uint32_t pid, struct sockaddr *dst_addr);

  static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
  				 uint32_t *num_entries, char *buf);
  static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx);

  static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void  *data,
  				  int len);

  static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len);

  /*
   * SCSI host template entry points
   */

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

  static int qla4xxx_eh_abort(struct scsi_cmnd *cmd);

  static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);

  static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);

  static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd);
  static int qla4xxx_slave_alloc(struct scsi_device *device);
  static int qla4xxx_slave_configure(struct scsi_device *device);
  static void qla4xxx_slave_destroy(struct scsi_device *sdev);

  static umode_t qla4_attr_is_visible(int param_type, int param);

  static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type);

  static int qla4xxx_change_queue_depth(struct scsi_device *sdev, int qdepth,
  				      int reason);

  /*
   * iSCSI Flash DDB sysfs entry points
   */
  static int
  qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
  			    struct iscsi_bus_flash_conn *fnode_conn,
  			    void *data, int len);
  static int
  qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
  			    int param, char *buf);
  static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
  				 int len);
  static int
  qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess);
  static int qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session *fnode_sess,
  				   struct iscsi_bus_flash_conn *fnode_conn);
  static int qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session *fnode_sess,
  				    struct iscsi_bus_flash_conn *fnode_conn);
  static int qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session *cls_sess);

  static struct qla4_8xxx_legacy_intr_set legacy_intr[] =
      QLA82XX_LEGACY_INTR_CONFIG;

  static struct scsi_host_template qla4xxx_driver_template = {
  	.module			= THIS_MODULE,
  	.name			= DRIVER_NAME,
  	.proc_name		= DRIVER_NAME,
  	.queuecommand		= qla4xxx_queuecommand,

  	.eh_abort_handler	= qla4xxx_eh_abort,

  	.eh_device_reset_handler = qla4xxx_eh_device_reset,

  	.eh_target_reset_handler = qla4xxx_eh_target_reset,

  	.eh_host_reset_handler	= qla4xxx_eh_host_reset,

  	.eh_timed_out		= qla4xxx_eh_cmd_timed_out,

  
  	.slave_configure	= qla4xxx_slave_configure,
  	.slave_alloc		= qla4xxx_slave_alloc,
  	.slave_destroy		= qla4xxx_slave_destroy,

  	.change_queue_depth	= qla4xxx_change_queue_depth,

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

  	.shost_attrs		= qla4xxx_host_attrs,

  	.host_reset		= qla4xxx_host_reset,

  	.vendor_id		= SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC,

  };
  
  static struct iscsi_transport qla4xxx_iscsi_transport = {
  	.owner			= THIS_MODULE,
  	.name			= DRIVER_NAME,

  	.caps			= CAP_TEXT_NEGO |
  				  CAP_DATA_PATH_OFFLOAD | CAP_HDRDGST |
  				  CAP_DATADGST | CAP_LOGIN_OFFLOAD |
  				  CAP_MULTI_R2T,

  	.attr_is_visible	= qla4_attr_is_visible,

  	.create_session         = qla4xxx_session_create,
  	.destroy_session        = qla4xxx_session_destroy,
  	.start_conn             = qla4xxx_conn_start,
  	.create_conn            = qla4xxx_conn_create,
  	.bind_conn              = qla4xxx_conn_bind,
  	.stop_conn              = iscsi_conn_stop,
  	.destroy_conn           = qla4xxx_conn_destroy,
  	.set_param              = iscsi_set_param,

  	.get_conn_param		= qla4xxx_conn_get_param,

  	.get_session_param	= qla4xxx_session_get_param,

  	.get_ep_param           = qla4xxx_get_ep_param,
  	.ep_connect		= qla4xxx_ep_connect,
  	.ep_poll		= qla4xxx_ep_poll,
  	.ep_disconnect		= qla4xxx_ep_disconnect,
  	.get_stats		= qla4xxx_conn_get_stats,
  	.send_pdu		= iscsi_conn_send_pdu,
  	.xmit_task		= qla4xxx_task_xmit,
  	.cleanup_task		= qla4xxx_task_cleanup,
  	.alloc_pdu		= qla4xxx_alloc_pdu,

  	.get_host_param		= qla4xxx_host_get_param,

  	.set_iface_param	= qla4xxx_iface_set_param,

  	.get_iface_param	= qla4xxx_get_iface_param,

  	.bsg_request		= qla4xxx_bsg_request,

  	.send_ping		= qla4xxx_send_ping,

  	.get_chap		= qla4xxx_get_chap_list,
  	.delete_chap		= qla4xxx_delete_chap,

  	.set_chap		= qla4xxx_set_chap_entry,

  	.get_flashnode_param	= qla4xxx_sysfs_ddb_get_param,
  	.set_flashnode_param	= qla4xxx_sysfs_ddb_set_param,
  	.new_flashnode		= qla4xxx_sysfs_ddb_add,
  	.del_flashnode		= qla4xxx_sysfs_ddb_delete,
  	.login_flashnode	= qla4xxx_sysfs_ddb_login,
  	.logout_flashnode	= qla4xxx_sysfs_ddb_logout,
  	.logout_flashnode_sid	= qla4xxx_sysfs_ddb_logout_sid,

  	.get_host_stats		= qla4xxx_get_host_stats,

  };
  
  static struct scsi_transport_template *qla4xxx_scsi_transport;

  static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
  			     uint32_t iface_type, uint32_t payload_size,
  			     uint32_t pid, struct sockaddr *dst_addr)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	struct sockaddr_in *addr;
  	struct sockaddr_in6 *addr6;
  	uint32_t options = 0;
  	uint8_t ipaddr[IPv6_ADDR_LEN];
  	int rval;
  
  	memset(ipaddr, 0, IPv6_ADDR_LEN);
  	/* IPv4 to IPv4 */
  	if ((iface_type == ISCSI_IFACE_TYPE_IPV4) &&
  	    (dst_addr->sa_family == AF_INET)) {
  		addr = (struct sockaddr_in *)dst_addr;
  		memcpy(ipaddr, &addr->sin_addr.s_addr, IP_ADDR_LEN);
  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv4 Ping src: %pI4 "
  				  "dest: %pI4
  ", __func__,
  				  &ha->ip_config.ip_address, ipaddr));
  		rval = qla4xxx_ping_iocb(ha, options, payload_size, pid,
  					 ipaddr);
  		if (rval)
  			rval = -EINVAL;
  	} else if ((iface_type == ISCSI_IFACE_TYPE_IPV6) &&
  		   (dst_addr->sa_family == AF_INET6)) {
  		/* IPv6 to IPv6 */
  		addr6 = (struct sockaddr_in6 *)dst_addr;
  		memcpy(ipaddr, &addr6->sin6_addr.in6_u.u6_addr8, IPv6_ADDR_LEN);
  
  		options |= PING_IPV6_PROTOCOL_ENABLE;
  
  		/* Ping using LinkLocal address */
  		if ((iface_num == 0) || (iface_num == 1)) {
  			DEBUG2(ql4_printk(KERN_INFO, ha, "%s: LinkLocal Ping "
  					  "src: %pI6 dest: %pI6
  ", __func__,
  					  &ha->ip_config.ipv6_link_local_addr,
  					  ipaddr));
  			options |= PING_IPV6_LINKLOCAL_ADDR;
  			rval = qla4xxx_ping_iocb(ha, options, payload_size,
  						 pid, ipaddr);
  		} else {
  			ql4_printk(KERN_WARNING, ha, "%s: iface num = %d "
  				   "not supported
  ", __func__, iface_num);
  			rval = -ENOSYS;
  			goto exit_send_ping;
  		}
  
  		/*
  		 * If ping using LinkLocal address fails, try ping using
  		 * IPv6 address
  		 */
  		if (rval != QLA_SUCCESS) {
  			options &= ~PING_IPV6_LINKLOCAL_ADDR;
  			if (iface_num == 0) {
  				options |= PING_IPV6_ADDR0;
  				DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
  						  "Ping src: %pI6 "
  						  "dest: %pI6
  ", __func__,
  						  &ha->ip_config.ipv6_addr0,
  						  ipaddr));
  			} else if (iface_num == 1) {
  				options |= PING_IPV6_ADDR1;
  				DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
  						  "Ping src: %pI6 "
  						  "dest: %pI6
  ", __func__,
  						  &ha->ip_config.ipv6_addr1,
  						  ipaddr));
  			}
  			rval = qla4xxx_ping_iocb(ha, options, payload_size,
  						 pid, ipaddr);
  			if (rval)
  				rval = -EINVAL;
  		}
  	} else
  		rval = -ENOSYS;
  exit_send_ping:
  	return rval;
  }

  static umode_t qla4_attr_is_visible(int param_type, int param)

  {
  	switch (param_type) {

  	case ISCSI_HOST_PARAM:
  		switch (param) {
  		case ISCSI_HOST_PARAM_HWADDRESS:
  		case ISCSI_HOST_PARAM_IPADDRESS:
  		case ISCSI_HOST_PARAM_INITIATOR_NAME:

  		case ISCSI_HOST_PARAM_PORT_STATE:
  		case ISCSI_HOST_PARAM_PORT_SPEED:

  			return S_IRUGO;
  		default:
  			return 0;
  		}

  	case ISCSI_PARAM:
  		switch (param) {

  		case ISCSI_PARAM_PERSISTENT_ADDRESS:
  		case ISCSI_PARAM_PERSISTENT_PORT:

  		case ISCSI_PARAM_CONN_ADDRESS:
  		case ISCSI_PARAM_CONN_PORT:

  		case ISCSI_PARAM_TARGET_NAME:
  		case ISCSI_PARAM_TPGT:
  		case ISCSI_PARAM_TARGET_ALIAS:

  		case ISCSI_PARAM_MAX_BURST:
  		case ISCSI_PARAM_MAX_R2T:
  		case ISCSI_PARAM_FIRST_BURST:
  		case ISCSI_PARAM_MAX_RECV_DLENGTH:
  		case ISCSI_PARAM_MAX_XMIT_DLENGTH:

  		case ISCSI_PARAM_IFACE_NAME:

  		case ISCSI_PARAM_CHAP_OUT_IDX:
  		case ISCSI_PARAM_CHAP_IN_IDX:
  		case ISCSI_PARAM_USERNAME:
  		case ISCSI_PARAM_PASSWORD:
  		case ISCSI_PARAM_USERNAME_IN:
  		case ISCSI_PARAM_PASSWORD_IN:

  		case ISCSI_PARAM_AUTO_SND_TGT_DISABLE:
  		case ISCSI_PARAM_DISCOVERY_SESS:
  		case ISCSI_PARAM_PORTAL_TYPE:
  		case ISCSI_PARAM_CHAP_AUTH_EN:
  		case ISCSI_PARAM_DISCOVERY_LOGOUT_EN:
  		case ISCSI_PARAM_BIDI_CHAP_EN:
  		case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL:
  		case ISCSI_PARAM_DEF_TIME2WAIT:
  		case ISCSI_PARAM_DEF_TIME2RETAIN:
  		case ISCSI_PARAM_HDRDGST_EN:
  		case ISCSI_PARAM_DATADGST_EN:
  		case ISCSI_PARAM_INITIAL_R2T_EN:
  		case ISCSI_PARAM_IMM_DATA_EN:
  		case ISCSI_PARAM_PDU_INORDER_EN:
  		case ISCSI_PARAM_DATASEQ_INORDER_EN:
  		case ISCSI_PARAM_MAX_SEGMENT_SIZE:
  		case ISCSI_PARAM_TCP_TIMESTAMP_STAT:
  		case ISCSI_PARAM_TCP_WSF_DISABLE:
  		case ISCSI_PARAM_TCP_NAGLE_DISABLE:
  		case ISCSI_PARAM_TCP_TIMER_SCALE:
  		case ISCSI_PARAM_TCP_TIMESTAMP_EN:
  		case ISCSI_PARAM_TCP_XMIT_WSF:
  		case ISCSI_PARAM_TCP_RECV_WSF:
  		case ISCSI_PARAM_IP_FRAGMENT_DISABLE:
  		case ISCSI_PARAM_IPV4_TOS:
  		case ISCSI_PARAM_IPV6_TC:
  		case ISCSI_PARAM_IPV6_FLOW_LABEL:
  		case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6:
  		case ISCSI_PARAM_KEEPALIVE_TMO:
  		case ISCSI_PARAM_LOCAL_PORT:
  		case ISCSI_PARAM_ISID:
  		case ISCSI_PARAM_TSID:
  		case ISCSI_PARAM_DEF_TASKMGMT_TMO:
  		case ISCSI_PARAM_ERL:
  		case ISCSI_PARAM_STATSN:
  		case ISCSI_PARAM_EXP_STATSN:
  		case ISCSI_PARAM_DISCOVERY_PARENT_IDX:
  		case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:

  		case ISCSI_PARAM_LOCAL_IPADDR:

  			return S_IRUGO;
  		default:
  			return 0;
  		}

  	case ISCSI_NET_PARAM:
  		switch (param) {
  		case ISCSI_NET_PARAM_IPV4_ADDR:
  		case ISCSI_NET_PARAM_IPV4_SUBNET:
  		case ISCSI_NET_PARAM_IPV4_GW:
  		case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
  		case ISCSI_NET_PARAM_IFACE_ENABLE:
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
  		case ISCSI_NET_PARAM_IPV6_ADDR:
  		case ISCSI_NET_PARAM_IPV6_ROUTER:
  		case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:

  		case ISCSI_NET_PARAM_VLAN_ID:
  		case ISCSI_NET_PARAM_VLAN_PRIORITY:
  		case ISCSI_NET_PARAM_VLAN_ENABLED:

  		case ISCSI_NET_PARAM_MTU:

  		case ISCSI_NET_PARAM_PORT:

  		case ISCSI_NET_PARAM_IPADDR_STATE:
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
  		case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
  		case ISCSI_NET_PARAM_DELAYED_ACK_EN:
  		case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
  		case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
  		case ISCSI_NET_PARAM_TCP_WSF:
  		case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
  		case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
  		case ISCSI_NET_PARAM_CACHE_ID:
  		case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
  		case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
  		case ISCSI_NET_PARAM_IPV4_TOS_EN:
  		case ISCSI_NET_PARAM_IPV4_TOS:
  		case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
  		case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
  		case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
  		case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
  		case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
  		case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
  		case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
  		case ISCSI_NET_PARAM_REDIRECT_EN:
  		case ISCSI_NET_PARAM_IPV4_TTL:
  		case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
  		case ISCSI_NET_PARAM_IPV6_MLD_EN:
  		case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
  		case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
  		case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
  		case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
  		case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
  		case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
  		case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
  		case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
  			return S_IRUGO;
  		default:
  			return 0;
  		}
  	case ISCSI_IFACE_PARAM:
  		switch (param) {
  		case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
  		case ISCSI_IFACE_PARAM_HDRDGST_EN:
  		case ISCSI_IFACE_PARAM_DATADGST_EN:
  		case ISCSI_IFACE_PARAM_IMM_DATA_EN:
  		case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
  		case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
  		case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
  		case ISCSI_IFACE_PARAM_ERL:
  		case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
  		case ISCSI_IFACE_PARAM_FIRST_BURST:
  		case ISCSI_IFACE_PARAM_MAX_R2T:
  		case ISCSI_IFACE_PARAM_MAX_BURST:
  		case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
  		case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
  		case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
  		case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
  		case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
  		case ISCSI_IFACE_PARAM_INITIATOR_NAME:

  			return S_IRUGO;
  		default:
  			return 0;
  		}

  	case ISCSI_FLASHNODE_PARAM:
  		switch (param) {
  		case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
  		case ISCSI_FLASHNODE_PORTAL_TYPE:
  		case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
  		case ISCSI_FLASHNODE_DISCOVERY_SESS:
  		case ISCSI_FLASHNODE_ENTRY_EN:
  		case ISCSI_FLASHNODE_HDR_DGST_EN:
  		case ISCSI_FLASHNODE_DATA_DGST_EN:
  		case ISCSI_FLASHNODE_IMM_DATA_EN:
  		case ISCSI_FLASHNODE_INITIAL_R2T_EN:
  		case ISCSI_FLASHNODE_DATASEQ_INORDER:
  		case ISCSI_FLASHNODE_PDU_INORDER:
  		case ISCSI_FLASHNODE_CHAP_AUTH_EN:
  		case ISCSI_FLASHNODE_SNACK_REQ_EN:
  		case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
  		case ISCSI_FLASHNODE_BIDI_CHAP_EN:
  		case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
  		case ISCSI_FLASHNODE_ERL:
  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
  		case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
  		case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
  		case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
  		case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
  		case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
  		case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
  		case ISCSI_FLASHNODE_FIRST_BURST:
  		case ISCSI_FLASHNODE_DEF_TIME2WAIT:
  		case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
  		case ISCSI_FLASHNODE_MAX_R2T:
  		case ISCSI_FLASHNODE_KEEPALIVE_TMO:
  		case ISCSI_FLASHNODE_ISID:
  		case ISCSI_FLASHNODE_TSID:
  		case ISCSI_FLASHNODE_PORT:
  		case ISCSI_FLASHNODE_MAX_BURST:
  		case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
  		case ISCSI_FLASHNODE_IPADDR:
  		case ISCSI_FLASHNODE_ALIAS:
  		case ISCSI_FLASHNODE_REDIRECT_IPADDR:
  		case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
  		case ISCSI_FLASHNODE_LOCAL_PORT:
  		case ISCSI_FLASHNODE_IPV4_TOS:
  		case ISCSI_FLASHNODE_IPV6_TC:
  		case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
  		case ISCSI_FLASHNODE_NAME:
  		case ISCSI_FLASHNODE_TPGT:
  		case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
  		case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
  		case ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE:
  		case ISCSI_FLASHNODE_TCP_XMIT_WSF:
  		case ISCSI_FLASHNODE_TCP_RECV_WSF:
  		case ISCSI_FLASHNODE_CHAP_OUT_IDX:
  		case ISCSI_FLASHNODE_USERNAME:
  		case ISCSI_FLASHNODE_PASSWORD:
  		case ISCSI_FLASHNODE_STATSN:
  		case ISCSI_FLASHNODE_EXP_STATSN:
  		case ISCSI_FLASHNODE_IS_BOOT_TGT:
  			return S_IRUGO;
  		default:
  			return 0;
  		}

  	}
  
  	return 0;
  }

  /**
   * qla4xxx_create chap_list - Create CHAP list from FLASH
   * @ha: pointer to adapter structure
   *
   * Read flash and make a list of CHAP entries, during login when a CHAP entry
   * is received, it will be checked in this list. If entry exist then the CHAP
   * entry index is set in the DDB. If CHAP entry does not exist in this list
   * then a new entry is added in FLASH in CHAP table and the index obtained is
   * used in the DDB.
   **/
  static void qla4xxx_create_chap_list(struct scsi_qla_host *ha)
  {
  	int rval = 0;
  	uint8_t *chap_flash_data = NULL;
  	uint32_t offset;
  	dma_addr_t chap_dma;
  	uint32_t chap_size = 0;
  
  	if (is_qla40XX(ha))
  		chap_size = MAX_CHAP_ENTRIES_40XX *
  			    sizeof(struct ql4_chap_table);
  	else	/* Single region contains CHAP info for both
  		 * ports which is divided into half for each port.
  		 */
  		chap_size = ha->hw.flt_chap_size / 2;
  
  	chap_flash_data = dma_alloc_coherent(&ha->pdev->dev, chap_size,
  					     &chap_dma, GFP_KERNEL);
  	if (!chap_flash_data) {
  		ql4_printk(KERN_ERR, ha, "No memory for chap_flash_data
  ");
  		return;
  	}
  
  	if (is_qla40XX(ha)) {
  		offset = FLASH_CHAP_OFFSET;
  	} else {
  		offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
  		if (ha->port_num == 1)
  			offset += chap_size;
  	}
  
  	rval = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
  	if (rval != QLA_SUCCESS)
  		goto exit_chap_list;
  
  	if (ha->chap_list == NULL)
  		ha->chap_list = vmalloc(chap_size);
  	if (ha->chap_list == NULL) {
  		ql4_printk(KERN_ERR, ha, "No memory for ha->chap_list
  ");
  		goto exit_chap_list;
  	}
  
  	memset(ha->chap_list, 0, chap_size);
  	memcpy(ha->chap_list, chap_flash_data, chap_size);
  
  exit_chap_list:
  	dma_free_coherent(&ha->pdev->dev, chap_size, chap_flash_data, chap_dma);
  }

  static int qla4xxx_get_chap_by_index(struct scsi_qla_host *ha,
  				     int16_t chap_index,
  				     struct ql4_chap_table **chap_entry)
  {
  	int rval = QLA_ERROR;
  	int max_chap_entries;
  
  	if (!ha->chap_list) {
  		ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!
  ");
  		rval = QLA_ERROR;
  		goto exit_get_chap;
  	}
  
  	if (is_qla80XX(ha))
  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
  				   sizeof(struct ql4_chap_table);
  	else
  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
  
  	if (chap_index > max_chap_entries) {
  		ql4_printk(KERN_ERR, ha, "Invalid Chap index
  ");
  		rval = QLA_ERROR;
  		goto exit_get_chap;
  	}
  
  	*chap_entry = (struct ql4_chap_table *)ha->chap_list + chap_index;
  	if ((*chap_entry)->cookie !=
  	     __constant_cpu_to_le16(CHAP_VALID_COOKIE)) {
  		rval = QLA_ERROR;
  		*chap_entry = NULL;
  	} else {
  		rval = QLA_SUCCESS;
  	}
  
  exit_get_chap:
  	return rval;
  }
  
  /**
   * qla4xxx_find_free_chap_index - Find the first free chap index
   * @ha: pointer to adapter structure
   * @chap_index: CHAP index to be returned
   *
   * Find the first free chap index available in the chap table
   *
   * Note: Caller should acquire the chap lock before getting here.
   **/
  static int qla4xxx_find_free_chap_index(struct scsi_qla_host *ha,
  					uint16_t *chap_index)
  {
  	int i, rval;
  	int free_index = -1;
  	int max_chap_entries = 0;
  	struct ql4_chap_table *chap_table;
  
  	if (is_qla80XX(ha))
  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
  						sizeof(struct ql4_chap_table);
  	else
  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
  
  	if (!ha->chap_list) {
  		ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!
  ");
  		rval = QLA_ERROR;
  		goto exit_find_chap;
  	}
  
  	for (i = 0; i < max_chap_entries; i++) {
  		chap_table = (struct ql4_chap_table *)ha->chap_list + i;
  
  		if ((chap_table->cookie !=
  		    __constant_cpu_to_le16(CHAP_VALID_COOKIE)) &&
  		   (i > MAX_RESRV_CHAP_IDX)) {
  				free_index = i;
  				break;
  		}
  	}
  
  	if (free_index != -1) {
  		*chap_index = free_index;
  		rval = QLA_SUCCESS;
  	} else {
  		rval = QLA_ERROR;
  	}
  
  exit_find_chap:
  	return rval;
  }

  static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
  				  uint32_t *num_entries, char *buf)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	struct ql4_chap_table *chap_table;
  	struct iscsi_chap_rec *chap_rec;
  	int max_chap_entries = 0;
  	int valid_chap_entries = 0;
  	int ret = 0, i;

  	if (is_qla80XX(ha))

  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
  					sizeof(struct ql4_chap_table);
  	else
  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
  
  	ql4_printk(KERN_INFO, ha, "%s: num_entries = %d, CHAP idx = %d
  ",
  			__func__, *num_entries, chap_tbl_idx);
  
  	if (!buf) {
  		ret = -ENOMEM;
  		goto exit_get_chap_list;
  	}

  	qla4xxx_create_chap_list(ha);

  	chap_rec = (struct iscsi_chap_rec *) buf;
  	mutex_lock(&ha->chap_sem);
  	for (i = chap_tbl_idx; i < max_chap_entries; i++) {
  		chap_table = (struct ql4_chap_table *)ha->chap_list + i;
  		if (chap_table->cookie !=
  		    __constant_cpu_to_le16(CHAP_VALID_COOKIE))
  			continue;
  
  		chap_rec->chap_tbl_idx = i;
  		strncpy(chap_rec->username, chap_table->name,
  			ISCSI_CHAP_AUTH_NAME_MAX_LEN);
  		strncpy(chap_rec->password, chap_table->secret,
  			QL4_CHAP_MAX_SECRET_LEN);
  		chap_rec->password_length = chap_table->secret_len;
  
  		if (chap_table->flags & BIT_7) /* local */
  			chap_rec->chap_type = CHAP_TYPE_OUT;
  
  		if (chap_table->flags & BIT_6) /* peer */
  			chap_rec->chap_type = CHAP_TYPE_IN;
  
  		chap_rec++;
  
  		valid_chap_entries++;
  		if (valid_chap_entries == *num_entries)
  			break;
  		else
  			continue;
  	}
  	mutex_unlock(&ha->chap_sem);
  
  exit_get_chap_list:
  	ql4_printk(KERN_INFO, ha, "%s: Valid CHAP Entries = %d
  ",
  			__func__,  valid_chap_entries);
  	*num_entries = valid_chap_entries;
  	return ret;
  }
  
  static int __qla4xxx_is_chap_active(struct device *dev, void *data)
  {
  	int ret = 0;
  	uint16_t *chap_tbl_idx = (uint16_t *) data;
  	struct iscsi_cls_session *cls_session;
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  
  	if (!iscsi_is_session_dev(dev))
  		goto exit_is_chap_active;
  
  	cls_session = iscsi_dev_to_session(dev);
  	sess = cls_session->dd_data;
  	ddb_entry = sess->dd_data;
  
  	if (iscsi_session_chkready(cls_session))
  		goto exit_is_chap_active;
  
  	if (ddb_entry->chap_tbl_idx == *chap_tbl_idx)
  		ret = 1;
  
  exit_is_chap_active:
  	return ret;
  }
  
  static int qla4xxx_is_chap_active(struct Scsi_Host *shost,
  				  uint16_t chap_tbl_idx)
  {
  	int ret = 0;
  
  	ret = device_for_each_child(&shost->shost_gendev, &chap_tbl_idx,
  				    __qla4xxx_is_chap_active);
  
  	return ret;
  }
  
  static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	struct ql4_chap_table *chap_table;
  	dma_addr_t chap_dma;
  	int max_chap_entries = 0;
  	uint32_t offset = 0;
  	uint32_t chap_size;
  	int ret = 0;
  
  	chap_table = dma_pool_alloc(ha->chap_dma_pool, GFP_KERNEL, &chap_dma);
  	if (chap_table == NULL)
  		return -ENOMEM;
  
  	memset(chap_table, 0, sizeof(struct ql4_chap_table));

  	if (is_qla80XX(ha))

  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
  				   sizeof(struct ql4_chap_table);
  	else
  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
  
  	if (chap_tbl_idx > max_chap_entries) {
  		ret = -EINVAL;
  		goto exit_delete_chap;
  	}
  
  	/* Check if chap index is in use.
  	 * If chap is in use don't delet chap entry */
  	ret = qla4xxx_is_chap_active(shost, chap_tbl_idx);
  	if (ret) {
  		ql4_printk(KERN_INFO, ha, "CHAP entry %d is in use, cannot "
  			   "delete from flash
  ", chap_tbl_idx);
  		ret = -EBUSY;
  		goto exit_delete_chap;
  	}
  
  	chap_size = sizeof(struct ql4_chap_table);
  	if (is_qla40XX(ha))
  		offset = FLASH_CHAP_OFFSET | (chap_tbl_idx * chap_size);
  	else {
  		offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
  		/* flt_chap_size is CHAP table size for both ports
  		 * so divide it by 2 to calculate the offset for second port
  		 */
  		if (ha->port_num == 1)
  			offset += (ha->hw.flt_chap_size / 2);
  		offset += (chap_tbl_idx * chap_size);
  	}
  
  	ret = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
  	if (ret != QLA_SUCCESS) {
  		ret = -EINVAL;
  		goto exit_delete_chap;
  	}
  
  	DEBUG2(ql4_printk(KERN_INFO, ha, "Chap Cookie: x%x
  ",
  			  __le16_to_cpu(chap_table->cookie)));
  
  	if (__le16_to_cpu(chap_table->cookie) != CHAP_VALID_COOKIE) {
  		ql4_printk(KERN_ERR, ha, "No valid chap entry found
  ");
  		goto exit_delete_chap;
  	}
  
  	chap_table->cookie = __constant_cpu_to_le16(0xFFFF);
  
  	offset = FLASH_CHAP_OFFSET |
  			(chap_tbl_idx * sizeof(struct ql4_chap_table));
  	ret = qla4xxx_set_flash(ha, chap_dma, offset, chap_size,
  				FLASH_OPT_RMW_COMMIT);
  	if (ret == QLA_SUCCESS && ha->chap_list) {
  		mutex_lock(&ha->chap_sem);
  		/* Update ha chap_list cache */
  		memcpy((struct ql4_chap_table *)ha->chap_list + chap_tbl_idx,
  			chap_table, sizeof(struct ql4_chap_table));
  		mutex_unlock(&ha->chap_sem);
  	}
  	if (ret != QLA_SUCCESS)
  		ret =  -EINVAL;
  
  exit_delete_chap:
  	dma_pool_free(ha->chap_dma_pool, chap_table, chap_dma);
  	return ret;
  }

  /**
   * qla4xxx_set_chap_entry - Make chap entry with given information
   * @shost: pointer to host
   * @data: chap info - credentials, index and type to make chap entry
   * @len: length of data
   *
   * Add or update chap entry with the given information
   **/
  static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void *data, int len)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	struct iscsi_chap_rec chap_rec;
  	struct ql4_chap_table *chap_entry = NULL;
  	struct iscsi_param_info *param_info;
  	struct nlattr *attr;
  	int max_chap_entries = 0;
  	int type;
  	int rem = len;
  	int rc = 0;

  	int size;

  
  	memset(&chap_rec, 0, sizeof(chap_rec));
  
  	nla_for_each_attr(attr, data, len, rem) {
  		param_info = nla_data(attr);
  
  		switch (param_info->param) {
  		case ISCSI_CHAP_PARAM_INDEX:
  			chap_rec.chap_tbl_idx = *(uint16_t *)param_info->value;
  			break;
  		case ISCSI_CHAP_PARAM_CHAP_TYPE:
  			chap_rec.chap_type = param_info->value[0];
  			break;
  		case ISCSI_CHAP_PARAM_USERNAME:

  			size = min_t(size_t, sizeof(chap_rec.username),
  				     param_info->len);
  			memcpy(chap_rec.username, param_info->value, size);

  			break;
  		case ISCSI_CHAP_PARAM_PASSWORD:

  			size = min_t(size_t, sizeof(chap_rec.password),
  				     param_info->len);
  			memcpy(chap_rec.password, param_info->value, size);

  			break;
  		case ISCSI_CHAP_PARAM_PASSWORD_LEN:
  			chap_rec.password_length = param_info->value[0];
  			break;
  		default:
  			ql4_printk(KERN_ERR, ha,
  				   "%s: No such sysfs attribute
  ", __func__);
  			rc = -ENOSYS;
  			goto exit_set_chap;
  		};
  	}
  
  	if (chap_rec.chap_type == CHAP_TYPE_IN)
  		type = BIDI_CHAP;
  	else
  		type = LOCAL_CHAP;
  
  	if (is_qla80XX(ha))
  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
  				   sizeof(struct ql4_chap_table);
  	else
  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
  
  	mutex_lock(&ha->chap_sem);
  	if (chap_rec.chap_tbl_idx < max_chap_entries) {
  		rc = qla4xxx_get_chap_by_index(ha, chap_rec.chap_tbl_idx,
  					       &chap_entry);
  		if (!rc) {
  			if (!(type == qla4xxx_get_chap_type(chap_entry))) {
  				ql4_printk(KERN_INFO, ha,
  					   "Type mismatch for CHAP entry %d
  ",
  					   chap_rec.chap_tbl_idx);
  				rc = -EINVAL;
  				goto exit_unlock_chap;
  			}
  
  			/* If chap index is in use then don't modify it */
  			rc = qla4xxx_is_chap_active(shost,
  						    chap_rec.chap_tbl_idx);
  			if (rc) {
  				ql4_printk(KERN_INFO, ha,
  					   "CHAP entry %d is in use
  ",
  					   chap_rec.chap_tbl_idx);
  				rc = -EBUSY;
  				goto exit_unlock_chap;
  			}
  		}
  	} else {
  		rc = qla4xxx_find_free_chap_index(ha, &chap_rec.chap_tbl_idx);
  		if (rc) {
  			ql4_printk(KERN_INFO, ha, "CHAP entry not available
  ");
  			rc = -EBUSY;
  			goto exit_unlock_chap;
  		}
  	}
  
  	rc = qla4xxx_set_chap(ha, chap_rec.username, chap_rec.password,
  			      chap_rec.chap_tbl_idx, type);
  
  exit_unlock_chap:
  	mutex_unlock(&ha->chap_sem);
  
  exit_set_chap:
  	return rc;
  }

  
  static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	struct iscsi_offload_host_stats *host_stats = NULL;
  	int host_stats_size;
  	int ret = 0;
  	int ddb_idx = 0;
  	struct ql_iscsi_stats *ql_iscsi_stats = NULL;
  	int stats_size;
  	dma_addr_t iscsi_stats_dma;
  
  	DEBUG2(ql4_printk(KERN_INFO, ha, "Func: %s
  ", __func__));
  
  	host_stats_size = sizeof(struct iscsi_offload_host_stats);
  
  	if (host_stats_size != len) {
  		ql4_printk(KERN_INFO, ha, "%s: host_stats size mismatch expected = %d, is = %d
  ",
  			   __func__, len, host_stats_size);
  		ret = -EINVAL;
  		goto exit_host_stats;
  	}
  	host_stats = (struct iscsi_offload_host_stats *)buf;
  
  	if (!buf) {
  		ret = -ENOMEM;
  		goto exit_host_stats;
  	}
  
  	stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
  
  	ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
  					    &iscsi_stats_dma, GFP_KERNEL);
  	if (!ql_iscsi_stats) {
  		ql4_printk(KERN_ERR, ha,
  			   "Unable to allocate memory for iscsi stats
  ");
  		goto exit_host_stats;
  	}
  
  	ret =  qla4xxx_get_mgmt_data(ha, ddb_idx, stats_size,
  				     iscsi_stats_dma);
  	if (ret != QLA_SUCCESS) {
  		ql4_printk(KERN_ERR, ha,
  			   "Unable to retrieve iscsi stats
  ");
  		goto exit_host_stats;
  	}
  	host_stats->mactx_frames = le64_to_cpu(ql_iscsi_stats->mac_tx_frames);
  	host_stats->mactx_bytes = le64_to_cpu(ql_iscsi_stats->mac_tx_bytes);
  	host_stats->mactx_multicast_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_multicast_frames);
  	host_stats->mactx_broadcast_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_broadcast_frames);
  	host_stats->mactx_pause_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_pause_frames);
  	host_stats->mactx_control_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_control_frames);
  	host_stats->mactx_deferral =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_deferral);
  	host_stats->mactx_excess_deferral =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_excess_deferral);
  	host_stats->mactx_late_collision =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_late_collision);
  	host_stats->mactx_abort	= le64_to_cpu(ql_iscsi_stats->mac_tx_abort);
  	host_stats->mactx_single_collision =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_single_collision);
  	host_stats->mactx_multiple_collision =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_multiple_collision);
  	host_stats->mactx_collision =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_collision);
  	host_stats->mactx_frames_dropped =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_frames_dropped);
  	host_stats->mactx_jumbo_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_tx_jumbo_frames);
  	host_stats->macrx_frames = le64_to_cpu(ql_iscsi_stats->mac_rx_frames);
  	host_stats->macrx_bytes = le64_to_cpu(ql_iscsi_stats->mac_rx_bytes);
  	host_stats->macrx_unknown_control_frames =
  		le64_to_cpu(ql_iscsi_stats->mac_rx_unknown_control_frames);
  	host_stats->macrx_pause_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_pause_frames);
  	host_stats->macrx_control_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_control_frames);
  	host_stats->macrx_dribble =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_dribble);
  	host_stats->macrx_frame_length_error =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_frame_length_error);
  	host_stats->macrx_jabber = le64_to_cpu(ql_iscsi_stats->mac_rx_jabber);
  	host_stats->macrx_carrier_sense_error =
  		le64_to_cpu(ql_iscsi_stats->mac_rx_carrier_sense_error);
  	host_stats->macrx_frame_discarded =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_frame_discarded);
  	host_stats->macrx_frames_dropped =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_frames_dropped);
  	host_stats->mac_crc_error = le64_to_cpu(ql_iscsi_stats->mac_crc_error);
  	host_stats->mac_encoding_error =
  			le64_to_cpu(ql_iscsi_stats->mac_encoding_error);
  	host_stats->macrx_length_error_large =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_large);
  	host_stats->macrx_length_error_small =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_small);
  	host_stats->macrx_multicast_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_multicast_frames);
  	host_stats->macrx_broadcast_frames =
  			le64_to_cpu(ql_iscsi_stats->mac_rx_broadcast_frames);
  	host_stats->iptx_packets = le64_to_cpu(ql_iscsi_stats->ip_tx_packets);
  	host_stats->iptx_bytes = le64_to_cpu(ql_iscsi_stats->ip_tx_bytes);
  	host_stats->iptx_fragments =
  			le64_to_cpu(ql_iscsi_stats->ip_tx_fragments);
  	host_stats->iprx_packets = le64_to_cpu(ql_iscsi_stats->ip_rx_packets);
  	host_stats->iprx_bytes = le64_to_cpu(ql_iscsi_stats->ip_rx_bytes);
  	host_stats->iprx_fragments =
  			le64_to_cpu(ql_iscsi_stats->ip_rx_fragments);
  	host_stats->ip_datagram_reassembly =
  			le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly);
  	host_stats->ip_invalid_address_error =
  			le64_to_cpu(ql_iscsi_stats->ip_invalid_address_error);
  	host_stats->ip_error_packets =
  			le64_to_cpu(ql_iscsi_stats->ip_error_packets);
  	host_stats->ip_fragrx_overlap =
  			le64_to_cpu(ql_iscsi_stats->ip_fragrx_overlap);
  	host_stats->ip_fragrx_outoforder =
  			le64_to_cpu(ql_iscsi_stats->ip_fragrx_outoforder);
  	host_stats->ip_datagram_reassembly_timeout =
  		le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly_timeout);
  	host_stats->ipv6tx_packets =
  			le64_to_cpu(ql_iscsi_stats->ipv6_tx_packets);
  	host_stats->ipv6tx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_tx_bytes);
  	host_stats->ipv6tx_fragments =
  			le64_to_cpu(ql_iscsi_stats->ipv6_tx_fragments);
  	host_stats->ipv6rx_packets =
  			le64_to_cpu(ql_iscsi_stats->ipv6_rx_packets);
  	host_stats->ipv6rx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_rx_bytes);
  	host_stats->ipv6rx_fragments =
  			le64_to_cpu(ql_iscsi_stats->ipv6_rx_fragments);
  	host_stats->ipv6_datagram_reassembly =
  			le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly);
  	host_stats->ipv6_invalid_address_error =
  		le64_to_cpu(ql_iscsi_stats->ipv6_invalid_address_error);
  	host_stats->ipv6_error_packets =
  			le64_to_cpu(ql_iscsi_stats->ipv6_error_packets);
  	host_stats->ipv6_fragrx_overlap =
  			le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_overlap);
  	host_stats->ipv6_fragrx_outoforder =
  			le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_outoforder);
  	host_stats->ipv6_datagram_reassembly_timeout =
  		le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly_timeout);
  	host_stats->tcptx_segments =
  			le64_to_cpu(ql_iscsi_stats->tcp_tx_segments);
  	host_stats->tcptx_bytes	= le64_to_cpu(ql_iscsi_stats->tcp_tx_bytes);
  	host_stats->tcprx_segments =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segments);
  	host_stats->tcprx_byte = le64_to_cpu(ql_iscsi_stats->tcp_rx_byte);
  	host_stats->tcp_duplicate_ack_retx =
  			le64_to_cpu(ql_iscsi_stats->tcp_duplicate_ack_retx);
  	host_stats->tcp_retx_timer_expired =
  			le64_to_cpu(ql_iscsi_stats->tcp_retx_timer_expired);
  	host_stats->tcprx_duplicate_ack	=
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_duplicate_ack);
  	host_stats->tcprx_pure_ackr =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_pure_ackr);
  	host_stats->tcptx_delayed_ack =
  			le64_to_cpu(ql_iscsi_stats->tcp_tx_delayed_ack);
  	host_stats->tcptx_pure_ack =
  			le64_to_cpu(ql_iscsi_stats->tcp_tx_pure_ack);
  	host_stats->tcprx_segment_error =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_error);
  	host_stats->tcprx_segment_outoforder =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_outoforder);
  	host_stats->tcprx_window_probe =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_window_probe);
  	host_stats->tcprx_window_update =
  			le64_to_cpu(ql_iscsi_stats->tcp_rx_window_update);
  	host_stats->tcptx_window_probe_persist =
  		le64_to_cpu(ql_iscsi_stats->tcp_tx_window_probe_persist);
  	host_stats->ecc_error_correction =
  			le64_to_cpu(ql_iscsi_stats->ecc_error_correction);
  	host_stats->iscsi_pdu_tx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_tx);
  	host_stats->iscsi_data_bytes_tx =
  			le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_tx);
  	host_stats->iscsi_pdu_rx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_rx);
  	host_stats->iscsi_data_bytes_rx	=
  			le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_rx);
  	host_stats->iscsi_io_completed =
  			le64_to_cpu(ql_iscsi_stats->iscsi_io_completed);
  	host_stats->iscsi_unexpected_io_rx =
  			le64_to_cpu(ql_iscsi_stats->iscsi_unexpected_io_rx);
  	host_stats->iscsi_format_error =
  			le64_to_cpu(ql_iscsi_stats->iscsi_format_error);
  	host_stats->iscsi_hdr_digest_error =
  			le64_to_cpu(ql_iscsi_stats->iscsi_hdr_digest_error);
  	host_stats->iscsi_data_digest_error =
  			le64_to_cpu(ql_iscsi_stats->iscsi_data_digest_error);
  	host_stats->iscsi_sequence_error =
  			le64_to_cpu(ql_iscsi_stats->iscsi_sequence_error);
  exit_host_stats:
  	if (ql_iscsi_stats)
  		dma_free_coherent(&ha->pdev->dev, host_stats_size,
  				  ql_iscsi_stats, iscsi_stats_dma);
  
  	ql4_printk(KERN_INFO, ha, "%s: Get host stats done
  ",
  		   __func__);
  	return ret;
  }

  static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
  				   enum iscsi_param_type param_type,
  				   int param, char *buf)
  {
  	struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
  	struct scsi_qla_host *ha = to_qla_host(shost);

  	int ival;
  	char *pval = NULL;

  	int len = -ENOSYS;

  	if (param_type == ISCSI_NET_PARAM) {
  		switch (param) {
  		case ISCSI_NET_PARAM_IPV4_ADDR:
  			len = sprintf(buf, "%pI4
  ", &ha->ip_config.ip_address);
  			break;
  		case ISCSI_NET_PARAM_IPV4_SUBNET:
  			len = sprintf(buf, "%pI4
  ",
  				      &ha->ip_config.subnet_mask);
  			break;
  		case ISCSI_NET_PARAM_IPV4_GW:
  			len = sprintf(buf, "%pI4
  ", &ha->ip_config.gateway);
  			break;
  		case ISCSI_NET_PARAM_IFACE_ENABLE:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(ha->ip_config.ipv4_options,
  					 IPOPT_IPV4_PROTOCOL_ENABLE, pval);
  			} else {
  				OP_STATE(ha->ip_config.ipv6_options,
  					 IPV6_OPT_IPV6_PROTOCOL_ENABLE, pval);
  			}

  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_BOOTPROTO:

  			len = sprintf(buf, "%s
  ",

  				      (ha->ip_config.tcp_options &
  				       TCPOPT_DHCP_ENABLE) ?
  				      "dhcp" : "static");
  			break;
  		case ISCSI_NET_PARAM_IPV6_ADDR:
  			if (iface->iface_num == 0)
  				len = sprintf(buf, "%pI6
  ",
  					      &ha->ip_config.ipv6_addr0);
  			if (iface->iface_num == 1)
  				len = sprintf(buf, "%pI6
  ",
  					      &ha->ip_config.ipv6_addr1);
  			break;
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
  			len = sprintf(buf, "%pI6
  ",
  				      &ha->ip_config.ipv6_link_local_addr);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ROUTER:
  			len = sprintf(buf, "%pI6
  ",
  				      &ha->ip_config.ipv6_default_router_addr);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
  			pval = (ha->ip_config.ipv6_addl_options &
  				IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) ?
  				"nd" : "static";
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
  			pval = (ha->ip_config.ipv6_addl_options &
  				IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR) ?
  				"auto" : "static";
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_VLAN_ID:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				ival = ha->ip_config.ipv4_vlan_tag &
  				       ISCSI_MAX_VLAN_ID;
  			else
  				ival = ha->ip_config.ipv6_vlan_tag &
  				       ISCSI_MAX_VLAN_ID;
  
  			len = sprintf(buf, "%d
  ", ival);
  			break;
  		case ISCSI_NET_PARAM_VLAN_PRIORITY:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				ival = (ha->ip_config.ipv4_vlan_tag >> 13) &
  				       ISCSI_MAX_VLAN_PRIORITY;
  			else
  				ival = (ha->ip_config.ipv6_vlan_tag >> 13) &
  				       ISCSI_MAX_VLAN_PRIORITY;
  
  			len = sprintf(buf, "%d
  ", ival);
  			break;
  		case ISCSI_NET_PARAM_VLAN_ENABLED:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(ha->ip_config.ipv4_options,
  					 IPOPT_VLAN_TAGGING_ENABLE, pval);
  			} else {
  				OP_STATE(ha->ip_config.ipv6_options,
  					 IPV6_OPT_VLAN_TAGGING_ENABLE, pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_MTU:
  			len = sprintf(buf, "%d
  ", ha->ip_config.eth_mtu_size);
  			break;
  		case ISCSI_NET_PARAM_PORT:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.ipv4_port);
  			else
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.ipv6_port);
  			break;
  		case ISCSI_NET_PARAM_IPADDR_STATE:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				pval = iscsi_get_ipaddress_state_name(
  						ha->ip_config.ipv4_addr_state);
  			} else {
  				if (iface->iface_num == 0)
  					pval = iscsi_get_ipaddress_state_name(
  						ha->ip_config.ipv6_addr0_state);
  				else if (iface->iface_num == 1)
  					pval = iscsi_get_ipaddress_state_name(
  						ha->ip_config.ipv6_addr1_state);
  			}
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
  			pval = iscsi_get_ipaddress_state_name(
  					ha->ip_config.ipv6_link_local_state);
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
  			pval = iscsi_get_router_state_name(
  				      ha->ip_config.ipv6_default_router_state);
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_DELAYED_ACK_EN:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(~ha->ip_config.tcp_options,
  					 TCPOPT_DELAYED_ACK_DISABLE, pval);
  			} else {
  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
  					 IPV6_TCPOPT_DELAYED_ACK_DISABLE, pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(~ha->ip_config.tcp_options,
  					 TCPOPT_NAGLE_ALGO_DISABLE, pval);
  			} else {
  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
  					 IPV6_TCPOPT_NAGLE_ALGO_DISABLE, pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(~ha->ip_config.tcp_options,
  					 TCPOPT_WINDOW_SCALE_DISABLE, pval);
  			} else {
  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
  					 IPV6_TCPOPT_WINDOW_SCALE_DISABLE,
  					 pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_TCP_WSF:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.tcp_wsf);
  			else
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.ipv6_tcp_wsf);
  			break;
  		case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				ival = (ha->ip_config.tcp_options &
  					TCPOPT_TIMER_SCALE) >> 1;
  			else
  				ival = (ha->ip_config.ipv6_tcp_options &
  					IPV6_TCPOPT_TIMER_SCALE) >> 1;
  
  			len = sprintf(buf, "%d
  ", ival);
  			break;
  		case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(ha->ip_config.tcp_options,
  					 TCPOPT_TIMESTAMP_ENABLE, pval);
  			} else {
  				OP_STATE(ha->ip_config.ipv6_tcp_options,
  					 IPV6_TCPOPT_TIMESTAMP_EN, pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_CACHE_ID:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.ipv4_cache_id);
  			else
  				len = sprintf(buf, "%d
  ",
  					      ha->ip_config.ipv6_cache_id);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
  			OP_STATE(ha->ip_config.tcp_options,
  				 TCPOPT_DNS_SERVER_IP_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
  			OP_STATE(ha->ip_config.tcp_options,
  				 TCPOPT_SLP_DA_INFO_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_TOS_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_IPV4_TOS_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_TOS:
  			len = sprintf(buf, "%d
  ", ha->ip_config.ipv4_tos);
  			break;
  		case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_GRAT_ARP_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
  			OP_STATE(ha->ip_config.ipv4_options, IPOPT_ALT_CID_EN,
  				 pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
  			pval = (ha->ip_config.ipv4_alt_cid_len) ?
  			       (char *)ha->ip_config.ipv4_alt_cid : "";
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_REQ_VID_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_USE_VID_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
  			pval = (ha->ip_config.ipv4_vid_len) ?
  			       (char *)ha->ip_config.ipv4_vid : "";
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_LEARN_IQN_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
  			OP_STATE(~ha->ip_config.ipv4_options,
  				 IPOPT_FRAGMENTATION_DISABLE, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
  			OP_STATE(ha->ip_config.ipv4_options,
  				 IPOPT_IN_FORWARD_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_REDIRECT_EN:
  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
  				OP_STATE(ha->ip_config.ipv4_options,
  					 IPOPT_ARP_REDIRECT_EN, pval);
  			} else {
  				OP_STATE(ha->ip_config.ipv6_options,
  					 IPV6_OPT_REDIRECT_EN, pval);
  			}
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV4_TTL:
  			len = sprintf(buf, "%d
  ", ha->ip_config.ipv4_ttl);
  			break;
  		case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
  			OP_STATE(ha->ip_config.ipv6_options,
  				 IPV6_OPT_GRAT_NEIGHBOR_ADV_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV6_MLD_EN:
  			OP_STATE(ha->ip_config.ipv6_addl_options,
  				 IPV6_ADDOPT_MLD_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
  			len = sprintf(buf, "%u
  ", ha->ip_config.ipv6_flow_lbl);
  			break;
  		case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:

  			len = sprintf(buf, "%d
  ",

  				      ha->ip_config.ipv6_traffic_class);
  			break;
  		case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:

  			len = sprintf(buf, "%d
  ",

  				      ha->ip_config.ipv6_hop_limit);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:

  			len = sprintf(buf, "%d
  ",

  				      ha->ip_config.ipv6_nd_reach_time);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:

  			len = sprintf(buf, "%d
  ",

  				      ha->ip_config.ipv6_nd_rexmit_timer);
  			break;
  		case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
  			len = sprintf(buf, "%d
  ",
  				      ha->ip_config.ipv6_nd_stale_timeout);
  			break;
  		case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
  			len = sprintf(buf, "%d
  ",
  				      ha->ip_config.ipv6_dup_addr_detect_count);
  			break;
  		case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
  			len = sprintf(buf, "%d
  ",
  				      ha->ip_config.ipv6_gw_advrt_mtu);
  			break;
  		default:
  			len = -ENOSYS;
  		}
  	} else if (param_type == ISCSI_IFACE_PARAM) {
  		switch (param) {
  		case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
  			len = sprintf(buf, "%d
  ", ha->ip_config.def_timeout);
  			break;
  		case ISCSI_IFACE_PARAM_HDRDGST_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_HEADER_DIGEST_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_DATADGST_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_DATA_DIGEST_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_IMM_DATA_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_IMMEDIATE_DATA_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_INITIAL_R2T_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_DATA_SEQ_INORDER_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_DATA_PDU_INORDER_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_ERL:
  			len = sprintf(buf, "%d
  ",
  				      (ha->ip_config.iscsi_options &
  				       ISCSIOPTS_ERL));
  			break;
  		case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
  			len = sprintf(buf, "%u
  ",
  				      ha->ip_config.iscsi_max_pdu_size *
  				      BYTE_UNITS);
  			break;
  		case ISCSI_IFACE_PARAM_FIRST_BURST:
  			len = sprintf(buf, "%u
  ",
  				      ha->ip_config.iscsi_first_burst_len *
  				      BYTE_UNITS);
  			break;
  		case ISCSI_IFACE_PARAM_MAX_R2T:
  			len = sprintf(buf, "%d
  ",
  				      ha->ip_config.iscsi_max_outstnd_r2t);
  			break;
  		case ISCSI_IFACE_PARAM_MAX_BURST:
  			len = sprintf(buf, "%u
  ",
  				      ha->ip_config.iscsi_max_burst_len *
  				      BYTE_UNITS);
  			break;
  		case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_CHAP_AUTH_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_BIDI_CHAP_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_DISCOVERY_AUTH_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_DISCOVERY_LOGOUT_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
  			OP_STATE(ha->ip_config.iscsi_options,
  				 ISCSIOPTS_STRICT_LOGIN_COMP_EN, pval);
  
  			len = sprintf(buf, "%s
  ", pval);
  			break;
  		case ISCSI_IFACE_PARAM_INITIATOR_NAME:
  			len = sprintf(buf, "%s
  ", ha->ip_config.iscsi_name);
  			break;
  		default:
  			len = -ENOSYS;
  		}

  	}
  
  	return len;
  }

  static struct iscsi_endpoint *
  qla4xxx_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
  		   int non_blocking)

  {

  	int ret;
  	struct iscsi_endpoint *ep;
  	struct qla_endpoint *qla_ep;
  	struct scsi_qla_host *ha;
  	struct sockaddr_in *addr;
  	struct sockaddr_in6 *addr6;

  	if (!shost) {
  		ret = -ENXIO;

  		pr_err("%s: shost is NULL
  ", __func__);

  		return ERR_PTR(ret);
  	}

  	ha = iscsi_host_priv(shost);

  	ep = iscsi_create_endpoint(sizeof(struct qla_endpoint));
  	if (!ep) {
  		ret = -ENOMEM;
  		return ERR_PTR(ret);
  	}
  
  	qla_ep = ep->dd_data;
  	memset(qla_ep, 0, sizeof(struct qla_endpoint));
  	if (dst_addr->sa_family == AF_INET) {
  		memcpy(&qla_ep->dst_addr, dst_addr, sizeof(struct sockaddr_in));
  		addr = (struct sockaddr_in *)&qla_ep->dst_addr;
  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI4
  ", __func__,
  				  (char *)&addr->sin_addr));
  	} else if (dst_addr->sa_family == AF_INET6) {
  		memcpy(&qla_ep->dst_addr, dst_addr,
  		       sizeof(struct sockaddr_in6));
  		addr6 = (struct sockaddr_in6 *)&qla_ep->dst_addr;
  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI6
  ", __func__,
  				  (char *)&addr6->sin6_addr));

  	} else {
  		ql4_printk(KERN_WARNING, ha, "%s: Invalid endpoint
  ",
  			   __func__);

  	}
  
  	qla_ep->host = shost;
  
  	return ep;

  }

  static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)

  {

  	struct qla_endpoint *qla_ep;
  	struct scsi_qla_host *ha;
  	int ret = 0;

  	qla_ep = ep->dd_data;
  	ha = to_qla_host(qla_ep->host);

  	DEBUG2(pr_info_ratelimited("%s: host: %ld
  ", __func__, ha->host_no));

  	if (adapter_up(ha) && !test_bit(AF_BUILD_DDB_LIST, &ha->flags))

  		ret = 1;
  
  	return ret;
  }
  
  static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep)
  {

  	struct qla_endpoint *qla_ep;
  	struct scsi_qla_host *ha;
  
  	qla_ep = ep->dd_data;
  	ha = to_qla_host(qla_ep->host);
  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld
  ", __func__,
  			  ha->host_no));

  	iscsi_destroy_endpoint(ep);
  }
  
  static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
  				enum iscsi_param param,
  				char *buf)
  {
  	struct qla_endpoint *qla_ep = ep->dd_data;
  	struct sockaddr *dst_addr;

  	struct scsi_qla_host *ha;

  	if (!qla_ep)
  		return -ENOTCONN;

  	ha = to_qla_host(qla_ep->host);
  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld
  ", __func__,
  			  ha->host_no));

  
  	switch (param) {
  	case ISCSI_PARAM_CONN_PORT:
  	case ISCSI_PARAM_CONN_ADDRESS:

  		dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
  		if (!dst_addr)
  			return -ENOTCONN;
  
  		return iscsi_conn_get_addr_param((struct sockaddr_storage *)
  						 &qla_ep->dst_addr, param, buf);
  	default:
  		return -ENOSYS;
  	}
  }
  
  static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
  				   struct iscsi_stats *stats)
  {
  	struct iscsi_session *sess;
  	struct iscsi_cls_session *cls_sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;
  	struct ql_iscsi_stats *ql_iscsi_stats;
  	int stats_size;
  	int ret;
  	dma_addr_t iscsi_stats_dma;

  	cls_sess = iscsi_conn_to_session(cls_conn);
  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld
  ", __func__,
  			  ha->host_no));

  	stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
  	/* Allocate memory */
  	ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
  					    &iscsi_stats_dma, GFP_KERNEL);
  	if (!ql_iscsi_stats) {
  		ql4_printk(KERN_ERR, ha,
  			   "Unable to allocate memory for iscsi stats
  ");
  		goto exit_get_stats;

  	}

  
  	ret =  qla4xxx_get_mgmt_data(ha, ddb_entry->fw_ddb_index, stats_size,
  				     iscsi_stats_dma);
  	if (ret != QLA_SUCCESS) {
  		ql4_printk(KERN_ERR, ha,

  			   "Unable to retrieve iscsi stats
  ");

  		goto free_stats;
  	}
  
  	/* octets */
  	stats->txdata_octets = le64_to_cpu(ql_iscsi_stats->tx_data_octets);
  	stats->rxdata_octets = le64_to_cpu(ql_iscsi_stats->rx_data_octets);
  	/* xmit pdus */
  	stats->noptx_pdus = le32_to_cpu(ql_iscsi_stats->tx_nopout_pdus);
  	stats->scsicmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_cmd_pdus);
  	stats->tmfcmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_tmf_cmd_pdus);
  	stats->login_pdus = le32_to_cpu(ql_iscsi_stats->tx_login_cmd_pdus);
  	stats->text_pdus = le32_to_cpu(ql_iscsi_stats->tx_text_cmd_pdus);
  	stats->dataout_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_write_pdus);
  	stats->logout_pdus = le32_to_cpu(ql_iscsi_stats->tx_logout_cmd_pdus);
  	stats->snack_pdus = le32_to_cpu(ql_iscsi_stats->tx_snack_req_pdus);
  	/* recv pdus */
  	stats->noprx_pdus = le32_to_cpu(ql_iscsi_stats->rx_nopin_pdus);
  	stats->scsirsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_resp_pdus);
  	stats->tmfrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_tmf_resp_pdus);
  	stats->textrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_text_resp_pdus);
  	stats->datain_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_read_pdus);
  	stats->logoutrsp_pdus =
  			le32_to_cpu(ql_iscsi_stats->rx_logout_resp_pdus);
  	stats->r2t_pdus = le32_to_cpu(ql_iscsi_stats->rx_r2t_pdus);
  	stats->async_pdus = le32_to_cpu(ql_iscsi_stats->rx_async_pdus);
  	stats->rjt_pdus = le32_to_cpu(ql_iscsi_stats->rx_reject_pdus);
  
  free_stats:
  	dma_free_coherent(&ha->pdev->dev, stats_size, ql_iscsi_stats,
  			  iscsi_stats_dma);
  exit_get_stats:
  	return;
  }
  
  static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc)
  {
  	struct iscsi_cls_session *session;
  	struct iscsi_session *sess;
  	unsigned long flags;
  	enum blk_eh_timer_return ret = BLK_EH_NOT_HANDLED;
  
  	session = starget_to_session(scsi_target(sc->device));
  	sess = session->dd_data;
  
  	spin_lock_irqsave(&session->lock, flags);
  	if (session->state == ISCSI_SESSION_FAILED)
  		ret = BLK_EH_RESET_TIMER;
  	spin_unlock_irqrestore(&session->lock, flags);
  
  	return ret;

  }

  static void qla4xxx_set_port_speed(struct Scsi_Host *shost)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);

  	struct iscsi_cls_host *ihost = shost->shost_data;

  	uint32_t speed = ISCSI_PORT_SPEED_UNKNOWN;
  
  	qla4xxx_get_firmware_state(ha);
  
  	switch (ha->addl_fw_state & 0x0F00) {
  	case FW_ADDSTATE_LINK_SPEED_10MBPS:
  		speed = ISCSI_PORT_SPEED_10MBPS;
  		break;
  	case FW_ADDSTATE_LINK_SPEED_100MBPS:
  		speed = ISCSI_PORT_SPEED_100MBPS;
  		break;
  	case FW_ADDSTATE_LINK_SPEED_1GBPS:
  		speed = ISCSI_PORT_SPEED_1GBPS;
  		break;
  	case FW_ADDSTATE_LINK_SPEED_10GBPS:
  		speed = ISCSI_PORT_SPEED_10GBPS;
  		break;
  	}
  	ihost->port_speed = speed;
  }
  
  static void qla4xxx_set_port_state(struct Scsi_Host *shost)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);

  	struct iscsi_cls_host *ihost = shost->shost_data;

  	uint32_t state = ISCSI_PORT_STATE_DOWN;
  
  	if (test_bit(AF_LINK_UP, &ha->flags))
  		state = ISCSI_PORT_STATE_UP;
  
  	ihost->port_state = state;
  }

  static int qla4xxx_host_get_param(struct Scsi_Host *shost,
  				  enum iscsi_host_param param, char *buf)
  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	int len;
  
  	switch (param) {
  	case ISCSI_HOST_PARAM_HWADDRESS:

  		len = sysfs_format_mac(buf, ha->my_mac, MAC_ADDR_LEN);

  		break;

  	case ISCSI_HOST_PARAM_IPADDRESS:

  		len = sprintf(buf, "%pI4
  ", &ha->ip_config.ip_address);

  		break;

  	case ISCSI_HOST_PARAM_INITIATOR_NAME:

  		len = sprintf(buf, "%s
  ", ha->name_string);

  		break;

  	case ISCSI_HOST_PARAM_PORT_STATE:
  		qla4xxx_set_port_state(shost);
  		len = sprintf(buf, "%s
  ", iscsi_get_port_state_name(shost));
  		break;
  	case ISCSI_HOST_PARAM_PORT_SPEED:
  		qla4xxx_set_port_speed(shost);
  		len = sprintf(buf, "%s
  ", iscsi_get_port_speed_name(shost));
  		break;

  	default:
  		return -ENOSYS;
  	}
  
  	return len;
  }

  static void qla4xxx_create_ipv4_iface(struct scsi_qla_host *ha)
  {
  	if (ha->iface_ipv4)
  		return;
  
  	/* IPv4 */
  	ha->iface_ipv4 = iscsi_create_iface(ha->host,
  					    &qla4xxx_iscsi_transport,
  					    ISCSI_IFACE_TYPE_IPV4, 0, 0);
  	if (!ha->iface_ipv4)
  		ql4_printk(KERN_ERR, ha, "Could not create IPv4 iSCSI "
  			   "iface0.
  ");
  }
  
  static void qla4xxx_create_ipv6_iface(struct scsi_qla_host *ha)
  {
  	if (!ha->iface_ipv6_0)
  		/* IPv6 iface-0 */
  		ha->iface_ipv6_0 = iscsi_create_iface(ha->host,
  						      &qla4xxx_iscsi_transport,
  						      ISCSI_IFACE_TYPE_IPV6, 0,
  						      0);
  	if (!ha->iface_ipv6_0)
  		ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
  			   "iface0.
  ");
  
  	if (!ha->iface_ipv6_1)
  		/* IPv6 iface-1 */
  		ha->iface_ipv6_1 = iscsi_create_iface(ha->host,
  						      &qla4xxx_iscsi_transport,
  						      ISCSI_IFACE_TYPE_IPV6, 1,
  						      0);
  	if (!ha->iface_ipv6_1)
  		ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
  			   "iface1.
  ");
  }
  
  static void qla4xxx_create_ifaces(struct scsi_qla_host *ha)
  {
  	if (ha->ip_config.ipv4_options & IPOPT_IPV4_PROTOCOL_ENABLE)
  		qla4xxx_create_ipv4_iface(ha);
  
  	if (ha->ip_config.ipv6_options & IPV6_OPT_IPV6_PROTOCOL_ENABLE)
  		qla4xxx_create_ipv6_iface(ha);
  }
  
  static void qla4xxx_destroy_ipv4_iface(struct scsi_qla_host *ha)
  {
  	if (ha->iface_ipv4) {
  		iscsi_destroy_iface(ha->iface_ipv4);
  		ha->iface_ipv4 = NULL;
  	}
  }
  
  static void qla4xxx_destroy_ipv6_iface(struct scsi_qla_host *ha)
  {
  	if (ha->iface_ipv6_0) {
  		iscsi_destroy_iface(ha->iface_ipv6_0);
  		ha->iface_ipv6_0 = NULL;
  	}
  	if (ha->iface_ipv6_1) {
  		iscsi_destroy_iface(ha->iface_ipv6_1);
  		ha->iface_ipv6_1 = NULL;
  	}
  }
  
  static void qla4xxx_destroy_ifaces(struct scsi_qla_host *ha)
  {
  	qla4xxx_destroy_ipv4_iface(ha);
  	qla4xxx_destroy_ipv6_iface(ha);
  }

  static void qla4xxx_set_ipv6(struct scsi_qla_host *ha,
  			     struct iscsi_iface_param_info *iface_param,
  			     struct addr_ctrl_blk *init_fw_cb)
  {
  	/*
  	 * iface_num 0 is valid for IPv6 Addr, linklocal, router, autocfg.
  	 * iface_num 1 is valid only for IPv6 Addr.
  	 */
  	switch (iface_param->param) {
  	case ISCSI_NET_PARAM_IPV6_ADDR:
  		if (iface_param->iface_num & 0x1)
  			/* IPv6 Addr 1 */
  			memcpy(init_fw_cb->ipv6_addr1, iface_param->value,
  			       sizeof(init_fw_cb->ipv6_addr1));
  		else
  			/* IPv6 Addr 0 */
  			memcpy(init_fw_cb->ipv6_addr0, iface_param->value,
  			       sizeof(init_fw_cb->ipv6_addr0));
  		break;
  	case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
  		if (iface_param->iface_num & 0x1)
  			break;
  		memcpy(init_fw_cb->ipv6_if_id, &iface_param->value[8],
  		       sizeof(init_fw_cb->ipv6_if_id));
  		break;
  	case ISCSI_NET_PARAM_IPV6_ROUTER:
  		if (iface_param->iface_num & 0x1)
  			break;
  		memcpy(init_fw_cb->ipv6_dflt_rtr_addr, iface_param->value,
  		       sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
  		break;
  	case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
  		/* Autocfg applies to even interface */
  		if (iface_param->iface_num & 0x1)
  			break;
  
  		if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_DISABLE)
  			init_fw_cb->ipv6_addtl_opts &=
  				cpu_to_le16(
  				  ~IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
  		else if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_ND_ENABLE)
  			init_fw_cb->ipv6_addtl_opts |=
  				cpu_to_le16(
  				  IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
  		else

  			ql4_printk(KERN_ERR, ha,
  				   "Invalid autocfg setting for IPv6 addr
  ");

  		break;
  	case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
  		/* Autocfg applies to even interface */
  		if (iface_param->iface_num & 0x1)
  			break;
  
  		if (iface_param->value[0] ==
  		    ISCSI_IPV6_LINKLOCAL_AUTOCFG_ENABLE)
  			init_fw_cb->ipv6_addtl_opts |= cpu_to_le16(
  					IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
  		else if (iface_param->value[0] ==
  			 ISCSI_IPV6_LINKLOCAL_AUTOCFG_DISABLE)
  			init_fw_cb->ipv6_addtl_opts &= cpu_to_le16(
  				       ~IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
  		else

  			ql4_printk(KERN_ERR, ha,
  				   "Invalid autocfg setting for IPv6 linklocal addr
  ");

  		break;
  	case ISCSI_NET_PARAM_IPV6_ROUTER_AUTOCFG:
  		/* Autocfg applies to even interface */
  		if (iface_param->iface_num & 0x1)
  			break;
  
  		if (iface_param->value[0] == ISCSI_IPV6_ROUTER_AUTOCFG_ENABLE)
  			memset(init_fw_cb->ipv6_dflt_rtr_addr, 0,
  			       sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
  		break;
  	case ISCSI_NET_PARAM_IFACE_ENABLE:

  		if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {

  			init_fw_cb->ipv6_opts |=
  				cpu_to_le16(IPV6_OPT_IPV6_PROTOCOL_ENABLE);

  			qla4xxx_create_ipv6_iface(ha);
  		} else {

  			init_fw_cb->ipv6_opts &=
  				cpu_to_le16(~IPV6_OPT_IPV6_PROTOCOL_ENABLE &
  					    0xFFFF);

  			qla4xxx_destroy_ipv6_iface(ha);
  		}

  		break;

  	case ISCSI_NET_PARAM_VLAN_TAG:

  		if (iface_param->len != sizeof(init_fw_cb->ipv6_vlan_tag))
  			break;

  		init_fw_cb->ipv6_vlan_tag =
  				cpu_to_be16(*(uint16_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_VLAN_ENABLED:
  		if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
  			init_fw_cb->ipv6_opts |=
  				cpu_to_le16(IPV6_OPT_VLAN_TAGGING_ENABLE);
  		else
  			init_fw_cb->ipv6_opts &=
  				cpu_to_le16(~IPV6_OPT_VLAN_TAGGING_ENABLE);

  		break;

  	case ISCSI_NET_PARAM_MTU:
  		init_fw_cb->eth_mtu_size =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;

  	case ISCSI_NET_PARAM_PORT:
  		/* Autocfg applies to even interface */
  		if (iface_param->iface_num & 0x1)
  			break;
  
  		init_fw_cb->ipv6_port =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;

  	case ISCSI_NET_PARAM_DELAYED_ACK_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv6_tcp_opts |=
  				cpu_to_le16(IPV6_TCPOPT_DELAYED_ACK_DISABLE);
  		else
  			init_fw_cb->ipv6_tcp_opts &=

  				cpu_to_le16(~IPV6_TCPOPT_DELAYED_ACK_DISABLE &
  					    0xFFFF);

  		break;
  	case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv6_tcp_opts |=
  				cpu_to_le16(IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
  		else
  			init_fw_cb->ipv6_tcp_opts &=
  				cpu_to_le16(~IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
  		break;
  	case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv6_tcp_opts |=
  				cpu_to_le16(IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
  		else
  			init_fw_cb->ipv6_tcp_opts &=
  				cpu_to_le16(~IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
  		break;
  	case ISCSI_NET_PARAM_TCP_WSF:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_tcp_wsf = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_tcp_opts &=
  					cpu_to_le16(~IPV6_TCPOPT_TIMER_SCALE);
  		init_fw_cb->ipv6_tcp_opts |=
  				cpu_to_le16((iface_param->value[0] << 1) &
  					    IPV6_TCPOPT_TIMER_SCALE);
  		break;
  	case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv6_tcp_opts |=
  				cpu_to_le16(IPV6_TCPOPT_TIMESTAMP_EN);
  		else
  			init_fw_cb->ipv6_tcp_opts &=
  				cpu_to_le16(~IPV6_TCPOPT_TIMESTAMP_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv6_opts |=
  				cpu_to_le16(IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
  		else
  			init_fw_cb->ipv6_opts &=
  				cpu_to_le16(~IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
  		break;
  	case ISCSI_NET_PARAM_REDIRECT_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv6_opts |=
  				cpu_to_le16(IPV6_OPT_REDIRECT_EN);
  		else
  			init_fw_cb->ipv6_opts &=
  				cpu_to_le16(~IPV6_OPT_REDIRECT_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV6_MLD_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv6_addtl_opts |=
  				cpu_to_le16(IPV6_ADDOPT_MLD_EN);
  		else
  			init_fw_cb->ipv6_addtl_opts &=
  				cpu_to_le16(~IPV6_ADDOPT_MLD_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_flow_lbl =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_traffic_class = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_hop_limit = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_nd_reach_time =
  				cpu_to_le32(*(uint32_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_nd_rexmit_timer =
  				cpu_to_le32(*(uint32_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_nd_stale_timeout =
  				cpu_to_le32(*(uint32_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_dup_addr_detect_count = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv6_gw_advrt_mtu =
  				cpu_to_le32(*(uint32_t *)iface_param->value);
  		break;

  	default:
  		ql4_printk(KERN_ERR, ha, "Unknown IPv6 param = %d
  ",
  			   iface_param->param);
  		break;
  	}
  }
  
  static void qla4xxx_set_ipv4(struct scsi_qla_host *ha,
  			     struct iscsi_iface_param_info *iface_param,
  			     struct addr_ctrl_blk *init_fw_cb)
  {
  	switch (iface_param->param) {
  	case ISCSI_NET_PARAM_IPV4_ADDR:
  		memcpy(init_fw_cb->ipv4_addr, iface_param->value,
  		       sizeof(init_fw_cb->ipv4_addr));
  		break;
  	case ISCSI_NET_PARAM_IPV4_SUBNET:
  		memcpy(init_fw_cb->ipv4_subnet,	iface_param->value,
  		       sizeof(init_fw_cb->ipv4_subnet));
  		break;
  	case ISCSI_NET_PARAM_IPV4_GW:
  		memcpy(init_fw_cb->ipv4_gw_addr, iface_param->value,
  		       sizeof(init_fw_cb->ipv4_gw_addr));
  		break;
  	case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
  		if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP)
  			init_fw_cb->ipv4_tcp_opts |=
  					cpu_to_le16(TCPOPT_DHCP_ENABLE);
  		else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC)
  			init_fw_cb->ipv4_tcp_opts &=
  					cpu_to_le16(~TCPOPT_DHCP_ENABLE);
  		else
  			ql4_printk(KERN_ERR, ha, "Invalid IPv4 bootproto
  ");
  		break;
  	case ISCSI_NET_PARAM_IFACE_ENABLE:

  		if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {

  			init_fw_cb->ipv4_ip_opts |=

  				cpu_to_le16(IPOPT_IPV4_PROTOCOL_ENABLE);

  			qla4xxx_create_ipv4_iface(ha);
  		} else {

  			init_fw_cb->ipv4_ip_opts &=

  				cpu_to_le16(~IPOPT_IPV4_PROTOCOL_ENABLE &

  					    0xFFFF);

  			qla4xxx_destroy_ipv4_iface(ha);
  		}

  		break;

  	case ISCSI_NET_PARAM_VLAN_TAG:

  		if (iface_param->len != sizeof(init_fw_cb->ipv4_vlan_tag))
  			break;

  		init_fw_cb->ipv4_vlan_tag =
  				cpu_to_be16(*(uint16_t *)iface_param->value);
  		break;
  	case ISCSI_NET_PARAM_VLAN_ENABLED:
  		if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  					cpu_to_le16(IPOPT_VLAN_TAGGING_ENABLE);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  					cpu_to_le16(~IPOPT_VLAN_TAGGING_ENABLE);

  		break;

  	case ISCSI_NET_PARAM_MTU:
  		init_fw_cb->eth_mtu_size =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;

  	case ISCSI_NET_PARAM_PORT:
  		init_fw_cb->ipv4_port =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;

  	case ISCSI_NET_PARAM_DELAYED_ACK_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_DELAYED_ACK_DISABLE);
  		else
  			init_fw_cb->ipv4_tcp_opts &=

  				cpu_to_le16(~TCPOPT_DELAYED_ACK_DISABLE &
  					    0xFFFF);

  		break;
  	case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_NAGLE_ALGO_DISABLE);
  		else
  			init_fw_cb->ipv4_tcp_opts &=
  				cpu_to_le16(~TCPOPT_NAGLE_ALGO_DISABLE);
  		break;
  	case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_WINDOW_SCALE_DISABLE);
  		else
  			init_fw_cb->ipv4_tcp_opts &=
  				cpu_to_le16(~TCPOPT_WINDOW_SCALE_DISABLE);
  		break;
  	case ISCSI_NET_PARAM_TCP_WSF:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv4_tcp_wsf = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv4_tcp_opts &= cpu_to_le16(~TCPOPT_TIMER_SCALE);
  		init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16((iface_param->value[0] << 1) &
  					    TCPOPT_TIMER_SCALE);
  		break;
  	case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_TIMESTAMP_ENABLE);
  		else
  			init_fw_cb->ipv4_tcp_opts &=
  				cpu_to_le16(~TCPOPT_TIMESTAMP_ENABLE);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_DNS_SERVER_IP_EN);
  		else
  			init_fw_cb->ipv4_tcp_opts &=
  				cpu_to_le16(~TCPOPT_DNS_SERVER_IP_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_tcp_opts |=
  				cpu_to_le16(TCPOPT_SLP_DA_INFO_EN);
  		else
  			init_fw_cb->ipv4_tcp_opts &=
  				cpu_to_le16(~TCPOPT_SLP_DA_INFO_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_TOS_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  				cpu_to_le16(IPOPT_IPV4_TOS_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  				cpu_to_le16(~IPOPT_IPV4_TOS_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_TOS:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv4_tos = iface_param->value[0];
  		break;
  	case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  					cpu_to_le16(IPOPT_GRAT_ARP_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  					cpu_to_le16(~IPOPT_GRAT_ARP_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  				cpu_to_le16(IPOPT_ALT_CID_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  				cpu_to_le16(~IPOPT_ALT_CID_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
  		if (iface_param->iface_num & 0x1)
  			break;
  		memcpy(init_fw_cb->ipv4_dhcp_alt_cid, iface_param->value,
  		       (sizeof(init_fw_cb->ipv4_dhcp_alt_cid) - 1));
  		init_fw_cb->ipv4_dhcp_alt_cid_len =
  					strlen(init_fw_cb->ipv4_dhcp_alt_cid);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  					cpu_to_le16(IPOPT_REQ_VID_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  					cpu_to_le16(~IPOPT_REQ_VID_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  					cpu_to_le16(IPOPT_USE_VID_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  					cpu_to_le16(~IPOPT_USE_VID_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
  		if (iface_param->iface_num & 0x1)
  			break;
  		memcpy(init_fw_cb->ipv4_dhcp_vid, iface_param->value,
  		       (sizeof(init_fw_cb->ipv4_dhcp_vid) - 1));
  		init_fw_cb->ipv4_dhcp_vid_len =
  					strlen(init_fw_cb->ipv4_dhcp_vid);
  		break;
  	case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  					cpu_to_le16(IPOPT_LEARN_IQN_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  					cpu_to_le16(~IPOPT_LEARN_IQN_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
  			init_fw_cb->ipv4_ip_opts |=
  				cpu_to_le16(IPOPT_FRAGMENTATION_DISABLE);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  				cpu_to_le16(~IPOPT_FRAGMENTATION_DISABLE);
  		break;
  	case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  				cpu_to_le16(IPOPT_IN_FORWARD_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  				cpu_to_le16(~IPOPT_IN_FORWARD_EN);
  		break;
  	case ISCSI_NET_PARAM_REDIRECT_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->ipv4_ip_opts |=
  				cpu_to_le16(IPOPT_ARP_REDIRECT_EN);
  		else
  			init_fw_cb->ipv4_ip_opts &=
  				cpu_to_le16(~IPOPT_ARP_REDIRECT_EN);
  		break;
  	case ISCSI_NET_PARAM_IPV4_TTL:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->ipv4_ttl = iface_param->value[0];
  		break;

  	default:
  		ql4_printk(KERN_ERR, ha, "Unknown IPv4 param = %d
  ",
  			   iface_param->param);
  		break;
  	}
  }

  static void qla4xxx_set_iscsi_param(struct scsi_qla_host *ha,
  				    struct iscsi_iface_param_info *iface_param,
  				    struct addr_ctrl_blk *init_fw_cb)
  {
  	switch (iface_param->param) {
  	case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->def_timeout =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;
  	case ISCSI_IFACE_PARAM_HDRDGST_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_HEADER_DIGEST_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_HEADER_DIGEST_EN);
  		break;
  	case ISCSI_IFACE_PARAM_DATADGST_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_DATA_DIGEST_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_DATA_DIGEST_EN);
  		break;
  	case ISCSI_IFACE_PARAM_IMM_DATA_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_IMMEDIATE_DATA_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_IMMEDIATE_DATA_EN);
  		break;
  	case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_INITIAL_R2T_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_INITIAL_R2T_EN);
  		break;
  	case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_DATA_SEQ_INORDER_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_DATA_SEQ_INORDER_EN);
  		break;
  	case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_DATA_PDU_INORDER_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_DATA_PDU_INORDER_EN);
  		break;
  	case ISCSI_IFACE_PARAM_ERL:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->iscsi_opts &= cpu_to_le16(~ISCSIOPTS_ERL);
  		init_fw_cb->iscsi_opts |= cpu_to_le16(iface_param->value[0] &
  						      ISCSIOPTS_ERL);
  		break;
  	case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->iscsi_max_pdu_size =
  				cpu_to_le32(*(uint32_t *)iface_param->value) /
  				BYTE_UNITS;
  		break;
  	case ISCSI_IFACE_PARAM_FIRST_BURST:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->iscsi_fburst_len =
  				cpu_to_le32(*(uint32_t *)iface_param->value) /
  				BYTE_UNITS;
  		break;
  	case ISCSI_IFACE_PARAM_MAX_R2T:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->iscsi_max_outstnd_r2t =
  				cpu_to_le16(*(uint16_t *)iface_param->value);
  		break;
  	case ISCSI_IFACE_PARAM_MAX_BURST:
  		if (iface_param->iface_num & 0x1)
  			break;
  		init_fw_cb->iscsi_max_burst_len =
  				cpu_to_le32(*(uint32_t *)iface_param->value) /
  				BYTE_UNITS;
  		break;
  	case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_CHAP_AUTH_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_CHAP_AUTH_EN);
  		break;
  	case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_BIDI_CHAP_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_BIDI_CHAP_EN);
  		break;
  	case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_DISCOVERY_AUTH_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_DISCOVERY_AUTH_EN);
  		break;
  	case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_DISCOVERY_LOGOUT_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_DISCOVERY_LOGOUT_EN);
  		break;
  	case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
  		if (iface_param->iface_num & 0x1)
  			break;
  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
  			init_fw_cb->iscsi_opts |=
  				cpu_to_le16(ISCSIOPTS_STRICT_LOGIN_COMP_EN);
  		else
  			init_fw_cb->iscsi_opts &=
  				cpu_to_le16(~ISCSIOPTS_STRICT_LOGIN_COMP_EN);
  		break;
  	default:
  		ql4_printk(KERN_ERR, ha, "Unknown iscsi param = %d
  ",
  			   iface_param->param);
  		break;
  	}
  }

  static void
  qla4xxx_initcb_to_acb(struct addr_ctrl_blk *init_fw_cb)
  {
  	struct addr_ctrl_blk_def *acb;
  	acb = (struct addr_ctrl_blk_def *)init_fw_cb;
  	memset(acb->reserved1, 0, sizeof(acb->reserved1));
  	memset(acb->reserved2, 0, sizeof(acb->reserved2));
  	memset(acb->reserved3, 0, sizeof(acb->reserved3));
  	memset(acb->reserved4, 0, sizeof(acb->reserved4));
  	memset(acb->reserved5, 0, sizeof(acb->reserved5));
  	memset(acb->reserved6, 0, sizeof(acb->reserved6));
  	memset(acb->reserved7, 0, sizeof(acb->reserved7));
  	memset(acb->reserved8, 0, sizeof(acb->reserved8));
  	memset(acb->reserved9, 0, sizeof(acb->reserved9));
  	memset(acb->reserved10, 0, sizeof(acb->reserved10));
  	memset(acb->reserved11, 0, sizeof(acb->reserved11));
  	memset(acb->reserved12, 0, sizeof(acb->reserved12));
  	memset(acb->reserved13, 0, sizeof(acb->reserved13));
  	memset(acb->reserved14, 0, sizeof(acb->reserved14));
  	memset(acb->reserved15, 0, sizeof(acb->reserved15));
  }
  
  static int

  qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len)

  {
  	struct scsi_qla_host *ha = to_qla_host(shost);
  	int rval = 0;
  	struct iscsi_iface_param_info *iface_param = NULL;
  	struct addr_ctrl_blk *init_fw_cb = NULL;
  	dma_addr_t init_fw_cb_dma;
  	uint32_t mbox_cmd[MBOX_REG_COUNT];
  	uint32_t mbox_sts[MBOX_REG_COUNT];

  	uint32_t rem = len;
  	struct nlattr *attr;

  
  	init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
  					sizeof(struct addr_ctrl_blk),
  					&init_fw_cb_dma, GFP_KERNEL);
  	if (!init_fw_cb) {
  		ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb
  ",
  			   __func__);
  		return -ENOMEM;
  	}
  
  	memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk));
  	memset(&mbox_cmd, 0, sizeof(mbox_cmd));
  	memset(&mbox_sts, 0, sizeof(mbox_sts));
  
  	if (qla4xxx_get_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma)) {
  		ql4_printk(KERN_ERR, ha, "%s: get ifcb failed
  ", __func__);
  		rval = -EIO;
  		goto exit_init_fw_cb;
  	}

  	nla_for_each_attr(attr, data, len, rem) {
  		iface_param = nla_data(attr);

  		if (iface_param->param_type == ISCSI_NET_PARAM) {
  			switch (iface_param->iface_type) {
  			case ISCSI_IFACE_TYPE_IPV4:
  				switch (iface_param->iface_num) {
  				case 0:
  					qla4xxx_set_ipv4(ha, iface_param,
  							 init_fw_cb);
  					break;
  				default:

  				/* Cannot have more than one IPv4 interface */

  					ql4_printk(KERN_ERR, ha,
  						   "Invalid IPv4 iface number = %d
  ",
  						   iface_param->iface_num);
  					break;
  				}

  				break;

  			case ISCSI_IFACE_TYPE_IPV6:
  				switch (iface_param->iface_num) {
  				case 0:
  				case 1:
  					qla4xxx_set_ipv6(ha, iface_param,
  							 init_fw_cb);
  					break;
  				default:
  				/* Cannot have more than two IPv6 interface */
  					ql4_printk(KERN_ERR, ha,
  						   "Invalid IPv6 iface number = %d
  ",
  						   iface_param->iface_num);
  					break;
  				}

  				break;
  			default:

  				ql4_printk(KERN_ERR, ha,
  					   "Invalid iface type
  ");

  				break;
  			}

  		} else if (iface_param->param_type == ISCSI_IFACE_PARAM) {
  				qla4xxx_set_iscsi_param(ha, iface_param,
  							init_fw_cb);
  		} else {
  			continue;

  		}

  	}
  
  	init_fw_cb->cookie = cpu_to_le32(0x11BEAD5A);
  
  	rval = qla4xxx_set_flash(ha, init_fw_cb_dma, FLASH_SEGMENT_IFCB,
  				 sizeof(struct addr_ctrl_blk),
  				 FLASH_OPT_RMW_COMMIT);
  	if (rval != QLA_SUCCESS) {
  		ql4_printk(KERN_ERR, ha, "%s: set flash mbx failed
  ",
  			   __func__);
  		rval = -EIO;
  		goto exit_init_fw_cb;
  	}

  	rval = qla4xxx_disable_acb(ha);
  	if (rval != QLA_SUCCESS) {
  		ql4_printk(KERN_ERR, ha, "%s: disable acb mbx failed
  ",
  			   __func__);
  		rval = -EIO;
  		goto exit_init_fw_cb;
  	}
  
  	wait_for_completion_timeout(&ha->disable_acb_comp,
  				    DISABLE_ACB_TOV * HZ);

  
  	qla4xxx_initcb_to_acb(init_fw_cb);
  
  	rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma);
  	if (rval != QLA_SUCCESS) {
  		ql4_printk(KERN_ERR, ha, "%s: set acb mbx failed
  ",
  			   __func__);
  		rval = -EIO;
  		goto exit_init_fw_cb;
  	}
  
  	memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk));
  	qla4xxx_update_local_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb,
  				  init_fw_cb_dma);
  
  exit_init_fw_cb:
  	dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk),
  			  init_fw_cb, init_fw_cb_dma);
  
  	return rval;
  }

  static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
  				     enum iscsi_param param, char *buf)
  {
  	struct iscsi_session *sess = cls_sess->dd_data;
  	struct ddb_entry *ddb_entry = sess->dd_data;
  	struct scsi_qla_host *ha = ddb_entry->ha;

  	struct iscsi_cls_conn *cls_conn = ddb_entry->conn;
  	struct ql4_chap_table chap_tbl;

  	int rval, len;
  	uint16_t idx;

  	memset(&chap_tbl, 0, sizeof(chap_tbl));

  	switch (param) {
  	case ISCSI_PARAM_CHAP_IN_IDX:
  		rval = qla4xxx_get_chap_index(ha, sess->username_in,
  					      sess->password_in, BIDI_CHAP,
  					      &idx);
  		if (rval)

  			len = sprintf(buf, "
  ");
  		else
  			len = sprintf(buf, "%hu
  ", idx);

  		break;
  	case ISCSI_PARAM_CHAP_OUT_IDX:

  		if (ddb_entry->ddb_type == FLASH_DDB) {
  			if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
  				idx = ddb_entry->chap_tbl_idx;
  				rval = QLA_SUCCESS;
  			} else {
  				rval = QLA_ERROR;
  			}
  		} else {
  			rval = qla4xxx_get_chap_index(ha, sess->username,
  						      sess->password,
  						      LOCAL_CHAP, &idx);
  		}

  		if (rval)

  			len = sprintf(buf, "
  ");
  		else
  			len = sprintf(buf, "%hu
  ", idx);

  		break;

  	case ISCSI_PARAM_USERNAME:
  	case ISCSI_PARAM_PASSWORD:
  		/* First, populate session username and password for FLASH DDB,
  		 * if not already done. This happens when session login fails
  		 * for a FLASH DDB.
  		 */
  		if (ddb_entry->ddb_type == FLASH_DDB &&
  		    ddb_entry->chap_tbl_idx != INVALID_ENTRY &&
  		    !sess->username && !sess->password) {
  			idx = ddb_entry->chap_tbl_idx;
  			rval = qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
  							    chap_tbl.secret,
  							    idx);
  			if (!rval) {
  				iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
  						(char *)chap_tbl.name,
  						strlen((char *)chap_tbl.name));
  				iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
  						(char *)chap_tbl.secret,
  						chap_tbl.secret_len);
  			}
  		}
  		/* allow fall-through */

  	default:
  		return iscsi_session_get_param(cls_sess, param, buf);
  	}
  
  	return len;
  }

  static int qla4xxx_conn_get_param(struct iscsi_cls_conn *cls_conn,

  				  enum iscsi_param param, char *buf)
  {

  	struct iscsi_conn *conn;
  	struct qla_conn *qla_conn;
  	struct sockaddr *dst_addr;

  	conn = cls_conn->dd_data;
  	qla_conn = conn->dd_data;

  	dst_addr = (struct sockaddr *)&qla_conn->qla_ep->dst_addr;

  
  	switch (param) {
  	case ISCSI_PARAM_CONN_PORT:

  	case ISCSI_PARAM_CONN_ADDRESS:

  		return iscsi_conn_get_addr_param((struct sockaddr_storage *)
  						 dst_addr, param, buf);

  	default:

  		return iscsi_conn_get_param(cls_conn, param, buf);

  	}

  }

  int qla4xxx_get_ddb_index(struct scsi_qla_host *ha, uint16_t *ddb_index)
  {
  	uint32_t mbx_sts = 0;
  	uint16_t tmp_ddb_index;
  	int ret;
  
  get_ddb_index:
  	tmp_ddb_index = find_first_zero_bit(ha->ddb_idx_map, MAX_DDB_ENTRIES);
  
  	if (tmp_ddb_index >= MAX_DDB_ENTRIES) {
  		DEBUG2(ql4_printk(KERN_INFO, ha,
  				  "Free DDB index not available
  "));
  		ret = QLA_ERROR;
  		goto exit_get_ddb_index;
  	}
  
  	if (test_and_set_bit(tmp_ddb_index, ha->ddb_idx_map))
  		goto get_ddb_index;
  
  	DEBUG2(ql4_printk(KERN_INFO, ha,
  			  "Found a free DDB index at %d
  ", tmp_ddb_index));
  	ret = qla4xxx_req_ddb_entry(ha, tmp_ddb_index, &mbx_sts);
  	if (ret == QLA_ERROR) {
  		if (mbx_sts == MBOX_STS_COMMAND_ERROR) {
  			ql4_printk(KERN_INFO, ha,
  				   "DDB index = %d not available trying next
  ",
  				   tmp_ddb_index);
  			goto get_ddb_index;
  		}
  		DEBUG2(ql4_printk(KERN_INFO, ha,
  				  "Free FW DDB not available
  "));
  	}
  
  	*ddb_index = tmp_ddb_index;
  
  exit_get_ddb_index:
  	return ret;
  }
  
  static int qla4xxx_match_ipaddress(struct scsi_qla_host *ha,
  				   struct ddb_entry *ddb_entry,
  				   char *existing_ipaddr,
  				   char *user_ipaddr)
  {
  	uint8_t dst_ipaddr[IPv6_ADDR_LEN];
  	char formatted_ipaddr[DDB_IPADDR_LEN];
  	int status = QLA_SUCCESS, ret = 0;
  
  	if (ddb_entry->fw_ddb_entry.options & DDB_OPT_IPV6_DEVICE) {
  		ret = in6_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
  			       '\0', NULL);
  		if (ret == 0) {
  			status = QLA_ERROR;
  			goto out_match;
  		}
  		ret = sprintf(formatted_ipaddr, "%pI6", dst_ipaddr);
  	} else {
  		ret = in4_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
  			       '\0', NULL);
  		if (ret == 0) {
  			status = QLA_ERROR;
  			goto out_match;
  		}
  		ret = sprintf(formatted_ipaddr, "%pI4", dst_ipaddr);
  	}
  
  	if (strcmp(existing_ipaddr, formatted_ipaddr))
  		status = QLA_ERROR;
  
  out_match:
  	return status;
  }
  
  static int qla4xxx_match_fwdb_session(struct scsi_qla_host *ha,
  				      struct iscsi_cls_conn *cls_conn)
  {
  	int idx = 0, max_ddbs, rval;
  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
  	struct iscsi_session *sess, *existing_sess;
  	struct iscsi_conn *conn, *existing_conn;
  	struct ddb_entry *ddb_entry;
  
  	sess = cls_sess->dd_data;
  	conn = cls_conn->dd_data;
  
  	if (sess->targetname == NULL ||
  	    conn->persistent_address == NULL ||
  	    conn->persistent_port == 0)
  		return QLA_ERROR;
  
  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
  				     MAX_DEV_DB_ENTRIES;
  
  	for (idx = 0; idx < max_ddbs; idx++) {
  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
  		if (ddb_entry == NULL)
  			continue;
  
  		if (ddb_entry->ddb_type != FLASH_DDB)
  			continue;
  
  		existing_sess = ddb_entry->sess->dd_data;
  		existing_conn = ddb_entry->conn->dd_data;
  
  		if (existing_sess->targetname == NULL ||
  		    existing_conn->persistent_address == NULL ||
  		    existing_conn->persistent_port == 0)
  			continue;
  
  		DEBUG2(ql4_printk(KERN_INFO, ha,
  				  "IQN = %s User IQN = %s
  ",
  				  existing_sess->targetname,
  				  sess->targetname));
  
  		DEBUG2(ql4_printk(KERN_INFO, ha,
  				  "IP = %s User IP = %s
  ",
  				  existing_conn->persistent_address,
  				  conn->persistent_address));
  
  		DEBUG2(ql4_printk(KERN_INFO, ha,
  				  "Port = %d User Port = %d
  ",
  				  existing_conn->persistent_port,
  				  conn->persistent_port));
  
  		if (strcmp(existing_sess->targetname, sess->targetname))
  			continue;
  		rval = qla4xxx_match_ipaddress(ha, ddb_entry,
  					existing_conn->persistent_address,
  					conn->persistent_address);
  		if (rval == QLA_ERROR)
  			continue;
  		if (existing_conn->persistent_port != conn->persistent_port)
  			continue;
  		break;
  	}
  
  	if (idx == max_ddbs)
  		return QLA_ERROR;
  
  	DEBUG2(ql4_printk(KERN_INFO, ha,
  			  "Match found in fwdb sessions
  "));
  	return QLA_SUCCESS;
  }

  static struct iscsi_cls_session *
  qla4xxx_session_create(struct iscsi_endpoint *ep,
  			uint16_t cmds_max, uint16_t qdepth,
  			uint32_t initial_cmdsn)
  {
  	struct iscsi_cls_session *cls_sess;
  	struct scsi_qla_host *ha;
  	struct qla_endpoint *qla_ep;
  	struct ddb_entry *ddb_entry;

  	uint16_t ddb_index;

  	struct iscsi_session *sess;
  	struct sockaddr *dst_addr;
  	int ret;

  	if (!ep) {
  		printk(KERN_ERR "qla4xxx: missing ep.
  ");
  		return NULL;
  	}
  
  	qla_ep = ep->dd_data;
  	dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
  	ha = to_qla_host(qla_ep->host);

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld
  ", __func__,
  			  ha->host_no));

  	ret = qla4xxx_get_ddb_index(ha, &ddb_index);
  	if (ret == QLA_ERROR)

  		return NULL;

  
  	cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, qla_ep->host,
  				       cmds_max, sizeof(struct ddb_entry),
  				       sizeof(struct ql4_task_data),
  				       initial_cmdsn, ddb_index);
  	if (!cls_sess)
  		return NULL;
  
  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ddb_entry->fw_ddb_index = ddb_index;
  	ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE;
  	ddb_entry->ha = ha;
  	ddb_entry->sess = cls_sess;

  	ddb_entry->unblock_sess = qla4xxx_unblock_ddb;
  	ddb_entry->ddb_change = qla4xxx_ddb_change;

  	clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags);

  	cls_sess->recovery_tmo = ql4xsess_recovery_tmo;
  	ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry;
  	ha->tot_ddbs++;
  
  	return cls_sess;
  }
  
  static void qla4xxx_session_destroy(struct iscsi_cls_session *cls_sess)
  {
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;

  	unsigned long flags, wtime;
  	struct dev_db_entry *fw_ddb_entry = NULL;
  	dma_addr_t fw_ddb_entry_dma;
  	uint32_t ddb_state;
  	int ret;

  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld
  ", __func__,
  			  ha->host_no));

  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  					  &fw_ddb_entry_dma, GFP_KERNEL);
  	if (!fw_ddb_entry) {
  		ql4_printk(KERN_ERR, ha,
  			   "%s: Unable to allocate dma buffer
  ", __func__);
  		goto destroy_session;
  	}
  
  	wtime = jiffies + (HZ * LOGOUT_TOV);
  	do {
  		ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
  					      fw_ddb_entry, fw_ddb_entry_dma,
  					      NULL, NULL, &ddb_state, NULL,
  					      NULL, NULL);
  		if (ret == QLA_ERROR)
  			goto destroy_session;
  
  		if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
  		    (ddb_state == DDB_DS_SESSION_FAILED))
  			goto destroy_session;
  
  		schedule_timeout_uninterruptible(HZ);
  	} while ((time_after(wtime, jiffies)));
  
  destroy_session:

  	qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);

  	if (test_and_clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags))
  		clear_bit(ddb_entry->fw_ddb_index, ha->ddb_idx_map);

  	spin_lock_irqsave(&ha->hardware_lock, flags);
  	qla4xxx_free_ddb(ha, ddb_entry);
  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  	iscsi_session_teardown(cls_sess);

  
  	if (fw_ddb_entry)
  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  				  fw_ddb_entry, fw_ddb_entry_dma);

  }

  static struct iscsi_cls_conn *
  qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx)
  {
  	struct iscsi_cls_conn *cls_conn;
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;

  	struct scsi_qla_host *ha;

  	cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn),
  				    conn_idx);

  	if (!cls_conn) {
  		pr_info("%s: Can not create connection for conn_idx = %u
  ",
  			__func__, conn_idx);

  		return NULL;

  	}

  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ddb_entry->conn = cls_conn;

  	ha = ddb_entry->ha;
  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: conn_idx = %u
  ", __func__,
  			  conn_idx));

  	return cls_conn;
  }
  
  static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
  			     struct iscsi_cls_conn *cls_conn,
  			     uint64_t transport_fd, int is_leading)
  {
  	struct iscsi_conn *conn;
  	struct qla_conn *qla_conn;
  	struct iscsi_endpoint *ep;

  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;
  	struct iscsi_session *sess;
  
  	sess = cls_session->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d
  ", __func__,
  			  cls_session->sid, cls_conn->cid));

  
  	if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
  		return -EINVAL;
  	ep = iscsi_lookup_endpoint(transport_fd);
  	conn = cls_conn->dd_data;
  	qla_conn = conn->dd_data;
  	qla_conn->qla_ep = ep->dd_data;
  	return 0;
  }
  
  static int qla4xxx_conn_start(struct iscsi_cls_conn *cls_conn)
  {
  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;

  	struct dev_db_entry *fw_ddb_entry = NULL;

  	dma_addr_t fw_ddb_entry_dma;

  	uint32_t mbx_sts = 0;
  	int ret = 0;
  	int status = QLA_SUCCESS;

  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d
  ", __func__,
  			  cls_sess->sid, cls_conn->cid));

  	/* Check if we have  matching FW DDB, if yes then do not
  	 * login to this target. This could cause target to logout previous
  	 * connection
  	 */
  	ret = qla4xxx_match_fwdb_session(ha, cls_conn);
  	if (ret == QLA_SUCCESS) {
  		ql4_printk(KERN_INFO, ha,
  			   "Session already exist in FW.
  ");
  		ret = -EEXIST;
  		goto exit_conn_start;
  	}

  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  					  &fw_ddb_entry_dma, GFP_KERNEL);
  	if (!fw_ddb_entry) {
  		ql4_printk(KERN_ERR, ha,
  			   "%s: Unable to allocate dma buffer
  ", __func__);

  		ret = -ENOMEM;
  		goto exit_conn_start;

  	}
  
  	ret = qla4xxx_set_param_ddbentry(ha, ddb_entry, cls_conn, &mbx_sts);
  	if (ret) {
  		/* If iscsid is stopped and started then no need to do
  		* set param again since ddb state will be already
  		* active and FW does not allow set ddb to an
  		* active session.
  		*/
  		if (mbx_sts)
  			if (ddb_entry->fw_ddb_device_state ==

  						DDB_DS_SESSION_ACTIVE) {

  				ddb_entry->unblock_sess(ddb_entry->sess);

  				goto exit_set_param;

  			}

  
  		ql4_printk(KERN_ERR, ha, "%s: Failed set param for index[%d]
  ",
  			   __func__, ddb_entry->fw_ddb_index);
  		goto exit_conn_start;
  	}
  
  	status = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index);
  	if (status == QLA_ERROR) {

  		ql4_printk(KERN_ERR, ha, "%s: Login failed: %s
  ", __func__,
  			   sess->targetname);

  		ret = -EINVAL;
  		goto exit_conn_start;
  	}

  	if (ddb_entry->fw_ddb_device_state == DDB_DS_NO_CONNECTION_ACTIVE)
  		ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS;
  
  	DEBUG2(printk(KERN_INFO "%s: DDB state [%d]
  ", __func__,
  		      ddb_entry->fw_ddb_device_state));

  
  exit_set_param:

  	ret = 0;
  
  exit_conn_start:

  	if (fw_ddb_entry)
  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  				  fw_ddb_entry, fw_ddb_entry_dma);

  	return ret;
  }
  
  static void qla4xxx_conn_destroy(struct iscsi_cls_conn *cls_conn)
  {
  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
  	struct iscsi_session *sess;
  	struct scsi_qla_host *ha;
  	struct ddb_entry *ddb_entry;
  	int options;

  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: cid = %d
  ", __func__,
  			  cls_conn->cid));

  
  	options = LOGOUT_OPTION_CLOSE_SESSION;
  	if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR)
  		ql4_printk(KERN_ERR, ha, "%s: Logout failed
  ", __func__);

  }
  
  static void qla4xxx_task_work(struct work_struct *wdata)
  {
  	struct ql4_task_data *task_data;
  	struct scsi_qla_host *ha;
  	struct passthru_status *sts;
  	struct iscsi_task *task;
  	struct iscsi_hdr *hdr;
  	uint8_t *data;
  	uint32_t data_len;
  	struct iscsi_conn *conn;
  	int hdr_len;
  	itt_t itt;
  
  	task_data = container_of(wdata, struct ql4_task_data, task_work);
  	ha = task_data->ha;
  	task = task_data->task;
  	sts = &task_data->sts;
  	hdr_len = sizeof(struct iscsi_hdr);
  
  	DEBUG3(printk(KERN_INFO "Status returned
  "));
  	DEBUG3(qla4xxx_dump_buffer(sts, 64));
  	DEBUG3(printk(KERN_INFO "Response buffer"));
  	DEBUG3(qla4xxx_dump_buffer(task_data->resp_buffer, 64));
  
  	conn = task->conn;
  
  	switch (sts->completionStatus) {
  	case PASSTHRU_STATUS_COMPLETE:
  		hdr = (struct iscsi_hdr *)task_data->resp_buffer;
  		/* Assign back the itt in hdr, until we use the PREASSIGN_TAG */
  		itt = sts->handle;
  		hdr->itt = itt;
  		data = task_data->resp_buffer + hdr_len;
  		data_len = task_data->resp_len - hdr_len;
  		iscsi_complete_pdu(conn, hdr, data, data_len);
  		break;
  	default:
  		ql4_printk(KERN_ERR, ha, "Passthru failed status = 0x%x
  ",
  			   sts->completionStatus);
  		break;
  	}
  	return;
  }
  
  static int qla4xxx_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
  {
  	struct ql4_task_data *task_data;
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;
  	int hdr_len;
  
  	sess = task->conn->session;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;
  	task_data = task->dd_data;
  	memset(task_data, 0, sizeof(struct ql4_task_data));
  
  	if (task->sc) {
  		ql4_printk(KERN_INFO, ha,
  			   "%s: SCSI Commands not implemented
  ", __func__);
  		return -EINVAL;
  	}
  
  	hdr_len = sizeof(struct iscsi_hdr);
  	task_data->ha = ha;
  	task_data->task = task;
  
  	if (task->data_count) {
  		task_data->data_dma = dma_map_single(&ha->pdev->dev, task->data,
  						     task->data_count,
  						     PCI_DMA_TODEVICE);
  	}
  
  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d
  ",
  		      __func__, task->conn->max_recv_dlength, hdr_len));

  	task_data->resp_len = task->conn->max_recv_dlength + hdr_len;

  	task_data->resp_buffer = dma_alloc_coherent(&ha->pdev->dev,
  						    task_data->resp_len,
  						    &task_data->resp_dma,
  						    GFP_ATOMIC);
  	if (!task_data->resp_buffer)
  		goto exit_alloc_pdu;

  	task_data->req_len = task->data_count + hdr_len;

  	task_data->req_buffer = dma_alloc_coherent(&ha->pdev->dev,

  						   task_data->req_len,

  						   &task_data->req_dma,
  						   GFP_ATOMIC);
  	if (!task_data->req_buffer)
  		goto exit_alloc_pdu;
  
  	task->hdr = task_data->req_buffer;
  
  	INIT_WORK(&task_data->task_work, qla4xxx_task_work);
  
  	return 0;
  
  exit_alloc_pdu:
  	if (task_data->resp_buffer)
  		dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
  				  task_data->resp_buffer, task_data->resp_dma);
  
  	if (task_data->req_buffer)

  		dma_free_coherent(&ha->pdev->dev, task_data->req_len,

  				  task_data->req_buffer, task_data->req_dma);
  	return -ENOMEM;
  }
  
  static void qla4xxx_task_cleanup(struct iscsi_task *task)
  {
  	struct ql4_task_data *task_data;
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;
  	int hdr_len;
  
  	hdr_len = sizeof(struct iscsi_hdr);
  	sess = task->conn->session;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;
  	task_data = task->dd_data;
  
  	if (task->data_count) {
  		dma_unmap_single(&ha->pdev->dev, task_data->data_dma,
  				 task->data_count, PCI_DMA_TODEVICE);
  	}
  
  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d
  ",
  		      __func__, task->conn->max_recv_dlength, hdr_len));
  
  	dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
  			  task_data->resp_buffer, task_data->resp_dma);

  	dma_free_coherent(&ha->pdev->dev, task_data->req_len,

  			  task_data->req_buffer, task_data->req_dma);
  	return;
  }
  
  static int qla4xxx_task_xmit(struct iscsi_task *task)
  {
  	struct scsi_cmnd *sc = task->sc;
  	struct iscsi_session *sess = task->conn->session;
  	struct ddb_entry *ddb_entry = sess->dd_data;
  	struct scsi_qla_host *ha = ddb_entry->ha;
  
  	if (!sc)
  		return qla4xxx_send_passthru0(task);
  
  	ql4_printk(KERN_INFO, ha, "%s: scsi cmd xmit not implemented
  ",
  		   __func__);
  	return -ENOSYS;
  }

  static int qla4xxx_copy_from_fwddb_param(struct iscsi_bus_flash_session *sess,
  					 struct iscsi_bus_flash_conn *conn,
  					 struct dev_db_entry *fw_ddb_entry)
  {
  	unsigned long options = 0;
  	int rc = 0;
  
  	options = le16_to_cpu(fw_ddb_entry->options);
  	conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
  	if (test_bit(OPT_IPV6_DEVICE, &options)) {

  		rc = iscsi_switch_str_param(&sess->portal_type,
  					    PORTAL_TYPE_IPV6);

  		if (rc)
  			goto exit_copy;
  	} else {

  		rc = iscsi_switch_str_param(&sess->portal_type,
  					    PORTAL_TYPE_IPV4);

  		if (rc)
  			goto exit_copy;
  	}
  
  	sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
  					      &options);
  	sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
  	sess->entry_state = test_bit(OPT_ENTRY_STATE, &options);
  
  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
  	conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
  	conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
  	sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
  	sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
  	sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
  					    &options);
  	sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
  	sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
  	conn->snack_req_en = test_bit(ISCSIOPT_SNACK_REQ_EN, &options);
  	sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
  					     &options);
  	sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
  	sess->discovery_auth_optional =
  			test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
  	if (test_bit(ISCSIOPT_ERL1, &options))
  		sess->erl |= BIT_1;
  	if (test_bit(ISCSIOPT_ERL0, &options))
  		sess->erl |= BIT_0;
  
  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
  	conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
  	conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
  	conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
  	if (test_bit(TCPOPT_TIMER_SCALE3, &options))
  		conn->tcp_timer_scale |= BIT_3;
  	if (test_bit(TCPOPT_TIMER_SCALE2, &options))
  		conn->tcp_timer_scale |= BIT_2;
  	if (test_bit(TCPOPT_TIMER_SCALE1, &options))
  		conn->tcp_timer_scale |= BIT_1;
  
  	conn->tcp_timer_scale >>= 1;
  	conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
  
  	options = le16_to_cpu(fw_ddb_entry->ip_options);
  	conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
  
  	conn->max_recv_dlength = BYTE_UNITS *
  			  le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
  	conn->max_xmit_dlength = BYTE_UNITS *
  			  le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
  	sess->first_burst = BYTE_UNITS *
  			       le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
  	sess->max_burst = BYTE_UNITS *
  				 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
  	sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
  	sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
  	sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
  	sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
  	conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
  	conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
  	conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
  	conn->ipv6_flow_label = le16_to_cpu(fw_ddb_entry->ipv6_flow_lbl);
  	conn->keepalive_timeout = le16_to_cpu(fw_ddb_entry->ka_timeout);
  	conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
  	conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
  	conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
  	sess->discovery_parent_idx = le16_to_cpu(fw_ddb_entry->ddb_link);
  	sess->discovery_parent_type = le16_to_cpu(fw_ddb_entry->ddb_link);
  	sess->chap_out_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
  	sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
  
  	sess->default_taskmgmt_timeout =
  				le16_to_cpu(fw_ddb_entry->def_timeout);
  	conn->port = le16_to_cpu(fw_ddb_entry->port);
  
  	options = le16_to_cpu(fw_ddb_entry->options);
  	conn->ipaddress = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
  	if (!conn->ipaddress) {
  		rc = -ENOMEM;
  		goto exit_copy;
  	}
  
  	conn->redirect_ipaddr = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
  	if (!conn->redirect_ipaddr) {
  		rc = -ENOMEM;
  		goto exit_copy;
  	}
  
  	memcpy(conn->ipaddress, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN);
  	memcpy(conn->redirect_ipaddr, fw_ddb_entry->tgt_addr, IPv6_ADDR_LEN);
  
  	if (test_bit(OPT_IPV6_DEVICE, &options)) {
  		conn->ipv6_traffic_class = fw_ddb_entry->ipv4_tos;

  		conn->link_local_ipv6_addr = kmemdup(
  					fw_ddb_entry->link_local_ipv6_addr,
  					IPv6_ADDR_LEN, GFP_KERNEL);

  		if (!conn->link_local_ipv6_addr) {
  			rc = -ENOMEM;
  			goto exit_copy;
  		}

  	} else {
  		conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
  	}
  
  	if (fw_ddb_entry->iscsi_name[0]) {
  		rc = iscsi_switch_str_param(&sess->targetname,
  					    (char *)fw_ddb_entry->iscsi_name);
  		if (rc)
  			goto exit_copy;
  	}
  
  	if (fw_ddb_entry->iscsi_alias[0]) {
  		rc = iscsi_switch_str_param(&sess->targetalias,
  					    (char *)fw_ddb_entry->iscsi_alias);
  		if (rc)
  			goto exit_copy;
  	}
  
  	COPY_ISID(sess->isid, fw_ddb_entry->isid);
  
  exit_copy:
  	return rc;
  }
  
  static int qla4xxx_copy_to_fwddb_param(struct iscsi_bus_flash_session *sess,
  				       struct iscsi_bus_flash_conn *conn,
  				       struct dev_db_entry *fw_ddb_entry)
  {
  	uint16_t options;
  	int rc = 0;
  
  	options = le16_to_cpu(fw_ddb_entry->options);
  	SET_BITVAL(conn->is_fw_assigned_ipv6,  options, BIT_11);

  	if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))

  		options |= BIT_8;
  	else
  		options &= ~BIT_8;
  
  	SET_BITVAL(sess->auto_snd_tgt_disable, options, BIT_6);
  	SET_BITVAL(sess->discovery_sess, options, BIT_4);
  	SET_BITVAL(sess->entry_state, options, BIT_3);
  	fw_ddb_entry->options = cpu_to_le16(options);
  
  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
  	SET_BITVAL(conn->hdrdgst_en, options, BIT_13);
  	SET_BITVAL(conn->datadgst_en, options, BIT_12);
  	SET_BITVAL(sess->imm_data_en, options, BIT_11);
  	SET_BITVAL(sess->initial_r2t_en, options, BIT_10);
  	SET_BITVAL(sess->dataseq_inorder_en, options, BIT_9);
  	SET_BITVAL(sess->pdu_inorder_en, options, BIT_8);
  	SET_BITVAL(sess->chap_auth_en, options, BIT_7);
  	SET_BITVAL(conn->snack_req_en, options, BIT_6);
  	SET_BITVAL(sess->discovery_logout_en, options, BIT_5);
  	SET_BITVAL(sess->bidi_chap_en, options, BIT_4);
  	SET_BITVAL(sess->discovery_auth_optional, options, BIT_3);
  	SET_BITVAL(sess->erl & BIT_1, options, BIT_1);
  	SET_BITVAL(sess->erl & BIT_0, options, BIT_0);
  	fw_ddb_entry->iscsi_options = cpu_to_le16(options);
  
  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
  	SET_BITVAL(conn->tcp_timestamp_stat, options, BIT_6);
  	SET_BITVAL(conn->tcp_nagle_disable, options, BIT_5);
  	SET_BITVAL(conn->tcp_wsf_disable, options, BIT_4);
  	SET_BITVAL(conn->tcp_timer_scale & BIT_2, options, BIT_3);
  	SET_BITVAL(conn->tcp_timer_scale & BIT_1, options, BIT_2);
  	SET_BITVAL(conn->tcp_timer_scale & BIT_0, options, BIT_1);
  	SET_BITVAL(conn->tcp_timestamp_en, options, BIT_0);
  	fw_ddb_entry->tcp_options = cpu_to_le16(options);
  
  	options = le16_to_cpu(fw_ddb_entry->ip_options);
  	SET_BITVAL(conn->fragment_disable, options, BIT_4);
  	fw_ddb_entry->ip_options = cpu_to_le16(options);
  
  	fw_ddb_entry->iscsi_max_outsnd_r2t = cpu_to_le16(sess->max_r2t);
  	fw_ddb_entry->iscsi_max_rcv_data_seg_len =
  			       cpu_to_le16(conn->max_recv_dlength / BYTE_UNITS);
  	fw_ddb_entry->iscsi_max_snd_data_seg_len =
  			       cpu_to_le16(conn->max_xmit_dlength / BYTE_UNITS);
  	fw_ddb_entry->iscsi_first_burst_len =
  				cpu_to_le16(sess->first_burst / BYTE_UNITS);
  	fw_ddb_entry->iscsi_max_burst_len = cpu_to_le16(sess->max_burst /
  					    BYTE_UNITS);
  	fw_ddb_entry->iscsi_def_time2wait = cpu_to_le16(sess->time2wait);
  	fw_ddb_entry->iscsi_def_time2retain = cpu_to_le16(sess->time2retain);
  	fw_ddb_entry->tgt_portal_grp = cpu_to_le16(sess->tpgt);
  	fw_ddb_entry->mss = cpu_to_le16(conn->max_segment_size);

  	fw_ddb_entry->tcp_xmt_wsf = (uint8_t) cpu_to_le32(conn->tcp_xmit_wsf);
  	fw_ddb_entry->tcp_rcv_wsf = (uint8_t) cpu_to_le32(conn->tcp_recv_wsf);

  	fw_ddb_entry->ipv6_flow_lbl = cpu_to_le16(conn->ipv6_flow_label);
  	fw_ddb_entry->ka_timeout = cpu_to_le16(conn->keepalive_timeout);
  	fw_ddb_entry->lcl_port = cpu_to_le16(conn->local_port);

  	fw_ddb_entry->stat_sn = cpu_to_le32(conn->statsn);
  	fw_ddb_entry->exp_stat_sn = cpu_to_le32(conn->exp_statsn);

  	fw_ddb_entry->ddb_link = cpu_to_le16(sess->discovery_parent_idx);

  	fw_ddb_entry->chap_tbl_idx = cpu_to_le16(sess->chap_out_idx);
  	fw_ddb_entry->tsid = cpu_to_le16(sess->tsid);
  	fw_ddb_entry->port = cpu_to_le16(conn->port);
  	fw_ddb_entry->def_timeout =
  				cpu_to_le16(sess->default_taskmgmt_timeout);

  	if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))
  		fw_ddb_entry->ipv4_tos = conn->ipv6_traffic_class;
  	else
  		fw_ddb_entry->ipv4_tos = conn->ipv4_tos;

  	if (conn->ipaddress)
  		memcpy(fw_ddb_entry->ip_addr, conn->ipaddress,
  		       sizeof(fw_ddb_entry->ip_addr));
  
  	if (conn->redirect_ipaddr)
  		memcpy(fw_ddb_entry->tgt_addr, conn->redirect_ipaddr,
  		       sizeof(fw_ddb_entry->tgt_addr));
  
  	if (conn->link_local_ipv6_addr)
  		memcpy(fw_ddb_entry->link_local_ipv6_addr,
  		       conn->link_local_ipv6_addr,
  		       sizeof(fw_ddb_entry->link_local_ipv6_addr));
  
  	if (sess->targetname)
  		memcpy(fw_ddb_entry->iscsi_name, sess->targetname,
  		       sizeof(fw_ddb_entry->iscsi_name));
  
  	if (sess->targetalias)
  		memcpy(fw_ddb_entry->iscsi_alias, sess->targetalias,
  		       sizeof(fw_ddb_entry->iscsi_alias));
  
  	COPY_ISID(fw_ddb_entry->isid, sess->isid);
  
  	return rc;
  }

  static void qla4xxx_copy_to_sess_conn_params(struct iscsi_conn *conn,
  					     struct iscsi_session *sess,
  					     struct dev_db_entry *fw_ddb_entry)
  {
  	unsigned long options = 0;
  	uint16_t ddb_link;
  	uint16_t disc_parent;

  	char ip_addr[DDB_IPADDR_LEN];

  
  	options = le16_to_cpu(fw_ddb_entry->options);
  	conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
  	sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
  					      &options);
  	sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
  
  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
  	conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
  	conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
  	sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
  	sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
  	sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
  					    &options);
  	sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
  	sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
  	sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
  					     &options);
  	sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
  	sess->discovery_auth_optional =
  			test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
  	if (test_bit(ISCSIOPT_ERL1, &options))
  		sess->erl |= BIT_1;
  	if (test_bit(ISCSIOPT_ERL0, &options))
  		sess->erl |= BIT_0;
  
  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
  	conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
  	conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
  	conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
  	if (test_bit(TCPOPT_TIMER_SCALE3, &options))
  		conn->tcp_timer_scale |= BIT_3;
  	if (test_bit(TCPOPT_TIMER_SCALE2, &options))
  		conn->tcp_timer_scale |= BIT_2;
  	if (test_bit(TCPOPT_TIMER_SCALE1, &options))
  		conn->tcp_timer_scale |= BIT_1;
  
  	conn->tcp_timer_scale >>= 1;
  	conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
  
  	options = le16_to_cpu(fw_ddb_entry->ip_options);
  	conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
  
  	conn->max_recv_dlength = BYTE_UNITS *
  			  le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
  	conn->max_xmit_dlength = BYTE_UNITS *
  			  le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
  	sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
  	sess->first_burst = BYTE_UNITS *
  			       le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
  	sess->max_burst = BYTE_UNITS *
  				 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
  	sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
  	sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
  	sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
  	conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
  	conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
  	conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
  	conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
  	conn->keepalive_tmo = le16_to_cpu(fw_ddb_entry->ka_timeout);
  	conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
  	conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
  	conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
  	sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
  	COPY_ISID(sess->isid, fw_ddb_entry->isid);
  
  	ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);

  	if (ddb_link == DDB_ISNS)
  		disc_parent = ISCSI_DISC_PARENT_ISNS;
  	else if (ddb_link == DDB_NO_LINK)
  		disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
  	else if (ddb_link < MAX_DDB_ENTRIES)
  		disc_parent = ISCSI_DISC_PARENT_SENDTGT;
  	else
  		disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
  
  	iscsi_set_param(conn->cls_conn, ISCSI_PARAM_DISCOVERY_PARENT_TYPE,
  			iscsi_get_discovery_parent_name(disc_parent), 0);
  
  	iscsi_set_param(conn->cls_conn, ISCSI_PARAM_TARGET_ALIAS,
  			(char *)fw_ddb_entry->iscsi_alias, 0);

  
  	options = le16_to_cpu(fw_ddb_entry->options);
  	if (options & DDB_OPT_IPV6_DEVICE) {
  		memset(ip_addr, 0, sizeof(ip_addr));
  		sprintf(ip_addr, "%pI6", fw_ddb_entry->link_local_ipv6_addr);
  		iscsi_set_param(conn->cls_conn, ISCSI_PARAM_LOCAL_IPADDR,
  				(char *)ip_addr, 0);
  	}

  }

  static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha,
  				     struct dev_db_entry *fw_ddb_entry,
  				     struct iscsi_cls_session *cls_sess,
  				     struct iscsi_cls_conn *cls_conn)
  {
  	int buflen = 0;
  	struct iscsi_session *sess;

  	struct ddb_entry *ddb_entry;

  	struct ql4_chap_table chap_tbl;

  	struct iscsi_conn *conn;
  	char ip_addr[DDB_IPADDR_LEN];
  	uint16_t options = 0;
  
  	sess = cls_sess->dd_data;

  	ddb_entry = sess->dd_data;

  	conn = cls_conn->dd_data;

  	memset(&chap_tbl, 0, sizeof(chap_tbl));

  	ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);

  	qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);

  	sess->def_taskmgmt_tmo = le16_to_cpu(fw_ddb_entry->def_timeout);

  	conn->persistent_port = le16_to_cpu(fw_ddb_entry->port);

  	memset(ip_addr, 0, sizeof(ip_addr));

  	options = le16_to_cpu(fw_ddb_entry->options);

  	if (options & DDB_OPT_IPV6_DEVICE) {
  		iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv6", 4);
  
  		memset(ip_addr, 0, sizeof(ip_addr));

  		sprintf(ip_addr, "%pI6", fw_ddb_entry->ip_addr);

  	} else {
  		iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv4", 4);

  		sprintf(ip_addr, "%pI4", fw_ddb_entry->ip_addr);

  	}

  	iscsi_set_param(cls_conn, ISCSI_PARAM_PERSISTENT_ADDRESS,
  			(char *)ip_addr, buflen);

  	iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_NAME,
  			(char *)fw_ddb_entry->iscsi_name, buflen);
  	iscsi_set_param(cls_conn, ISCSI_PARAM_INITIATOR_NAME,
  			(char *)ha->name_string, buflen);

  
  	if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
  		if (!qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
  						   chap_tbl.secret,
  						   ddb_entry->chap_tbl_idx)) {
  			iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
  					(char *)chap_tbl.name,
  					strlen((char *)chap_tbl.name));
  			iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
  					(char *)chap_tbl.secret,
  					chap_tbl.secret_len);
  		}
  	}

  }
  
  void qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host *ha,
  					     struct ddb_entry *ddb_entry)
  {
  	struct iscsi_cls_session *cls_sess;
  	struct iscsi_cls_conn *cls_conn;
  	uint32_t ddb_state;
  	dma_addr_t fw_ddb_entry_dma;
  	struct dev_db_entry *fw_ddb_entry;
  
  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  					  &fw_ddb_entry_dma, GFP_KERNEL);
  	if (!fw_ddb_entry) {
  		ql4_printk(KERN_ERR, ha,
  			   "%s: Unable to allocate dma buffer
  ", __func__);
  		goto exit_session_conn_fwddb_param;
  	}
  
  	if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
  				    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
  				    NULL, NULL, NULL) == QLA_ERROR) {
  		DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
  				  "get_ddb_entry for fw_ddb_index %d
  ",
  				  ha->host_no, __func__,
  				  ddb_entry->fw_ddb_index));
  		goto exit_session_conn_fwddb_param;
  	}
  
  	cls_sess = ddb_entry->sess;
  
  	cls_conn = ddb_entry->conn;
  
  	/* Update params */
  	qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn);
  
  exit_session_conn_fwddb_param:
  	if (fw_ddb_entry)
  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  				  fw_ddb_entry, fw_ddb_entry_dma);
  }

  void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha,
  				       struct ddb_entry *ddb_entry)
  {
  	struct iscsi_cls_session *cls_sess;
  	struct iscsi_cls_conn *cls_conn;
  	struct iscsi_session *sess;
  	struct iscsi_conn *conn;
  	uint32_t ddb_state;
  	dma_addr_t fw_ddb_entry_dma;
  	struct dev_db_entry *fw_ddb_entry;
  
  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  					  &fw_ddb_entry_dma, GFP_KERNEL);
  	if (!fw_ddb_entry) {
  		ql4_printk(KERN_ERR, ha,
  			   "%s: Unable to allocate dma buffer
  ", __func__);

  		goto exit_session_conn_param;

  	}
  
  	if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
  				    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
  				    NULL, NULL, NULL) == QLA_ERROR) {
  		DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
  				  "get_ddb_entry for fw_ddb_index %d
  ",
  				  ha->host_no, __func__,
  				  ddb_entry->fw_ddb_index));

  		goto exit_session_conn_param;

  	}
  
  	cls_sess = ddb_entry->sess;
  	sess = cls_sess->dd_data;
  
  	cls_conn = ddb_entry->conn;
  	conn = cls_conn->dd_data;

  	/* Update timers after login */
  	ddb_entry->default_relogin_timeout =

  		(le16_to_cpu(fw_ddb_entry->def_timeout) > LOGIN_TOV) &&
  		 (le16_to_cpu(fw_ddb_entry->def_timeout) < LOGIN_TOV * 10) ?
  		 le16_to_cpu(fw_ddb_entry->def_timeout) : LOGIN_TOV;

  	ddb_entry->default_time2wait =
  				le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);

  	/* Update params */

  	ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);

  	qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);

  
  	memcpy(sess->initiatorname, ha->name_string,
  	       min(sizeof(ha->name_string), sizeof(sess->initiatorname)));

  
  exit_session_conn_param:
  	if (fw_ddb_entry)
  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
  				  fw_ddb_entry, fw_ddb_entry_dma);

  }

  /*
   * Timer routines
   */
  
  static void qla4xxx_start_timer(struct scsi_qla_host *ha, void *func,
  				unsigned long interval)
  {
  	DEBUG(printk("scsi: %s: Starting timer thread for adapter %d
  ",
  		     __func__, ha->host->host_no));
  	init_timer(&ha->timer);
  	ha->timer.expires = jiffies + interval * HZ;
  	ha->timer.data = (unsigned long)ha;
  	ha->timer.function = (void (*)(unsigned long))func;
  	add_timer(&ha->timer);
  	ha->timer_active = 1;
  }
  
  static void qla4xxx_stop_timer(struct scsi_qla_host *ha)
  {
  	del_timer_sync(&ha->timer);
  	ha->timer_active = 0;
  }
  
  /***

   * qla4xxx_mark_device_missing - blocks the session
   * @cls_session: Pointer to the session to be blocked

   * @ddb_entry: Pointer to device database entry
   *

   * This routine marks a device missing and close connection.

   **/

  void qla4xxx_mark_device_missing(struct iscsi_cls_session *cls_session)

  {

  	iscsi_block_session(cls_session);

  }

  /**
   * qla4xxx_mark_all_devices_missing - mark all devices as missing.
   * @ha: Pointer to host adapter structure.
   *
   * This routine marks a device missing and resets the relogin retry count.
   **/
  void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha)
  {

  	iscsi_host_for_each_session(ha->host, qla4xxx_mark_device_missing);

  }

  static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha,
  				       struct ddb_entry *ddb_entry,

  				       struct scsi_cmnd *cmd)

  {
  	struct srb *srb;
  
  	srb = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
  	if (!srb)
  		return srb;

  	kref_init(&srb->srb_ref);

  	srb->ha = ha;
  	srb->ddb = ddb_entry;
  	srb->cmd = cmd;
  	srb->flags = 0;

  	CMD_SP(cmd) = (void *)srb;

  
  	return srb;
  }
  
  static void qla4xxx_srb_free_dma(struct scsi_qla_host *ha, struct srb *srb)
  {
  	struct scsi_cmnd *cmd = srb->cmd;
  
  	if (srb->flags & SRB_DMA_VALID) {

  		scsi_dma_unmap(cmd);

  		srb->flags &= ~SRB_DMA_VALID;
  	}

  	CMD_SP(cmd) = NULL;

  }

  void qla4xxx_srb_compl(struct kref *ref)

  {

  	struct srb *srb = container_of(ref, struct srb, srb_ref);

  	struct scsi_cmnd *cmd = srb->cmd;

  	struct scsi_qla_host *ha = srb->ha;

  
  	qla4xxx_srb_free_dma(ha, srb);
  
  	mempool_free(srb, ha->srb_mempool);
  
  	cmd->scsi_done(cmd);
  }
  
  /**
   * qla4xxx_queuecommand - scsi layer issues scsi command to driver.

   * @host: scsi host

   * @cmd: Pointer to Linux's SCSI command structure

   *
   * Remarks:
   * This routine is invoked by Linux to send a SCSI command to the driver.
   * The mid-level driver tries to ensure that queuecommand never gets
   * invoked concurrently with itself or the interrupt handler (although
   * the interrupt handler may call this routine as part of request-
   * completion handling).   Unfortunely, it sometimes calls the scheduler
   * in interrupt context which is a big NO! NO!.
   **/

  static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)

  {

  	struct scsi_qla_host *ha = to_qla_host(host);

  	struct ddb_entry *ddb_entry = cmd->device->hostdata;

  	struct iscsi_cls_session *sess = ddb_entry->sess;

  	struct srb *srb;
  	int rval;

  	if (test_bit(AF_EEH_BUSY, &ha->flags)) {
  		if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
  			cmd->result = DID_NO_CONNECT << 16;
  		else
  			cmd->result = DID_REQUEUE << 16;
  		goto qc_fail_command;
  	}

  	if (!sess) {
  		cmd->result = DID_IMM_RETRY << 16;
  		goto qc_fail_command;
  	}
  
  	rval = iscsi_session_chkready(sess);
  	if (rval) {
  		cmd->result = rval;
  		goto qc_fail_command;
  	}

  	if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
  	    test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
  	    test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
  	    test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
  	    test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
  	    !test_bit(AF_ONLINE, &ha->flags) ||

  	    !test_bit(AF_LINK_UP, &ha->flags) ||

  	    test_bit(AF_LOOPBACK, &ha->flags) ||

  	    test_bit(DPC_POST_IDC_ACK, &ha->dpc_flags) ||
  	    test_bit(DPC_RESTORE_ACB, &ha->dpc_flags) ||

  	    test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))

  		goto qc_host_busy;

  	srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd);

  	if (!srb)

  		goto qc_host_busy;

  
  	rval = qla4xxx_send_command_to_isp(ha, srb);
  	if (rval != QLA_SUCCESS)
  		goto qc_host_busy_free_sp;

  	return 0;
  
  qc_host_busy_free_sp:
  	qla4xxx_srb_free_dma(ha, srb);
  	mempool_free(srb, ha->srb_mempool);

  qc_host_busy:
  	return SCSI_MLQUEUE_HOST_BUSY;
  
  qc_fail_command:

  	cmd->scsi_done(cmd);

  
  	return 0;
  }
  
  /**
   * qla4xxx_mem_free - frees memory allocated to adapter
   * @ha: Pointer to host adapter structure.
   *
   * Frees memory previously allocated by qla4xxx_mem_alloc
   **/
  static void qla4xxx_mem_free(struct scsi_qla_host *ha)
  {
  	if (ha->queues)
  		dma_free_coherent(&ha->pdev->dev, ha->queues_len, ha->queues,
  				  ha->queues_dma);

  	 if (ha->fw_dump)
  		vfree(ha->fw_dump);

  	ha->queues_len = 0;
  	ha->queues = NULL;
  	ha->queues_dma = 0;
  	ha->request_ring = NULL;
  	ha->request_dma = 0;
  	ha->response_ring = NULL;
  	ha->response_dma = 0;
  	ha->shadow_regs = NULL;
  	ha->shadow_regs_dma = 0;

  	ha->fw_dump = NULL;
  	ha->fw_dump_size = 0;

  
  	/* Free srb pool. */
  	if (ha->srb_mempool)
  		mempool_destroy(ha->srb_mempool);
  
  	ha->srb_mempool = NULL;

  	if (ha->chap_dma_pool)
  		dma_pool_destroy(ha->chap_dma_pool);

  	if (ha->chap_list)
  		vfree(ha->chap_list);
  	ha->chap_list = NULL;

  	if (ha->fw_ddb_dma_pool)
  		dma_pool_destroy(ha->fw_ddb_dma_pool);

  	/* release io space registers  */

  	if (is_qla8022(ha)) {
  		if (ha->nx_pcibase)
  			iounmap(
  			    (struct device_reg_82xx __iomem *)ha->nx_pcibase);

  	} else if (is_qla8032(ha) || is_qla8042(ha)) {

  		if (ha->nx_pcibase)
  			iounmap(
  			    (struct device_reg_83xx __iomem *)ha->nx_pcibase);
  	} else if (ha->reg) {

  		iounmap(ha->reg);

  	}
  
  	if (ha->reset_tmplt.buff)
  		vfree(ha->reset_tmplt.buff);

  	pci_release_regions(ha->pdev);
  }
  
  /**
   * qla4xxx_mem_alloc - allocates memory for use by adapter.
   * @ha: Pointer to host adapter structure
   *
   * Allocates DMA memory for request and response queues. Also allocates memory
   * for srbs.
   **/
  static int qla4xxx_mem_alloc(struct scsi_qla_host *ha)
  {
  	unsigned long align;
  
  	/* Allocate contiguous block of DMA memory for queues. */
  	ha->queues_len = ((REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
  			  (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE) +
  			  sizeof(struct shadow_regs) +
  			  MEM_ALIGN_VALUE +
  			  (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
  	ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len,
  					&ha->queues_dma, GFP_KERNEL);
  	if (ha->queues == NULL) {

  		ql4_printk(KERN_WARNING, ha,
  		    "Memory Allocation failed - queues.
  ");

  
  		goto mem_alloc_error_exit;
  	}
  	memset(ha->queues, 0, ha->queues_len);
  
  	/*
  	 * As per RISC alignment requirements -- the bus-address must be a
  	 * multiple of the request-ring size (in bytes).
  	 */
  	align = 0;
  	if ((unsigned long)ha->queues_dma & (MEM_ALIGN_VALUE - 1))
  		align = MEM_ALIGN_VALUE - ((unsigned long)ha->queues_dma &
  					   (MEM_ALIGN_VALUE - 1));
  
  	/* Update request and response queue pointers. */
  	ha->request_dma = ha->queues_dma + align;
  	ha->request_ring = (struct queue_entry *) (ha->queues + align);
  	ha->response_dma = ha->queues_dma + align +
  		(REQUEST_QUEUE_DEPTH * QUEUE_SIZE);
  	ha->response_ring = (struct queue_entry *) (ha->queues + align +
  						    (REQUEST_QUEUE_DEPTH *
  						     QUEUE_SIZE));
  	ha->shadow_regs_dma = ha->queues_dma + align +
  		(REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
  		(RESPONSE_QUEUE_DEPTH * QUEUE_SIZE);
  	ha->shadow_regs = (struct shadow_regs *) (ha->queues + align +
  						  (REQUEST_QUEUE_DEPTH *
  						   QUEUE_SIZE) +
  						  (RESPONSE_QUEUE_DEPTH *
  						   QUEUE_SIZE));
  
  	/* Allocate memory for srb pool. */
  	ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
  					 mempool_free_slab, srb_cachep);
  	if (ha->srb_mempool == NULL) {

  		ql4_printk(KERN_WARNING, ha,
  		    "Memory Allocation failed - SRB Pool.
  ");

  
  		goto mem_alloc_error_exit;
  	}

  	ha->chap_dma_pool = dma_pool_create("ql4_chap", &ha->pdev->dev,
  					    CHAP_DMA_BLOCK_SIZE, 8, 0);
  
  	if (ha->chap_dma_pool == NULL) {
  		ql4_printk(KERN_WARNING, ha,
  		    "%s: chap_dma_pool allocation failed..
  ", __func__);
  		goto mem_alloc_error_exit;
  	}

  	ha->fw_ddb_dma_pool = dma_pool_create("ql4_fw_ddb", &ha->pdev->dev,
  					      DDB_DMA_BLOCK_SIZE, 8, 0);
  
  	if (ha->fw_ddb_dma_pool == NULL) {
  		ql4_printk(KERN_WARNING, ha,
  			   "%s: fw_ddb_dma_pool allocation failed..
  ",
  			   __func__);
  		goto mem_alloc_error_exit;
  	}

  	return QLA_SUCCESS;
  
  mem_alloc_error_exit:
  	qla4xxx_mem_free(ha);
  	return QLA_ERROR;
  }
  
  /**

   * qla4_8xxx_check_temp - Check the ISP82XX temperature.
   * @ha: adapter block pointer.
   *
   * Note: The caller should not hold the idc lock.
   **/
  static int qla4_8xxx_check_temp(struct scsi_qla_host *ha)
  {
  	uint32_t temp, temp_state, temp_val;
  	int status = QLA_SUCCESS;

  	temp = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_TEMP_STATE);

  
  	temp_state = qla82xx_get_temp_state(temp);
  	temp_val = qla82xx_get_temp_val(temp);
  
  	if (temp_state == QLA82XX_TEMP_PANIC) {
  		ql4_printk(KERN_WARNING, ha, "Device temperature %d degrees C"
  			   " exceeds maximum allowed. Hardware has been shut"
  			   " down.
  ", temp_val);
  		status = QLA_ERROR;
  	} else if (temp_state == QLA82XX_TEMP_WARN) {
  		if (ha->temperature == QLA82XX_TEMP_NORMAL)
  			ql4_printk(KERN_WARNING, ha, "Device temperature %d"
  				   " degrees C exceeds operating range."
  				   " Immediate action needed.
  ", temp_val);
  	} else {
  		if (ha->temperature == QLA82XX_TEMP_WARN)
  			ql4_printk(KERN_INFO, ha, "Device temperature is"
  				   " now %d degrees C in normal range.
  ",
  				   temp_val);
  	}
  	ha->temperature = temp_state;
  	return status;
  }
  
  /**

   * qla4_8xxx_check_fw_alive  - Check firmware health
   * @ha: Pointer to host adapter structure.
   *
   * Context: Interrupt
   **/

  static int qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)

  {

  	uint32_t fw_heartbeat_counter;
  	int status = QLA_SUCCESS;

  	fw_heartbeat_counter = qla4_8xxx_rd_direct(ha,
  						   QLA8XXX_PEG_ALIVE_COUNTER);

  	/* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */
  	if (fw_heartbeat_counter == 0xffffffff) {
  		DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen "
  		    "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff
  ",
  		    ha->host_no, __func__));

  		return status;

  	}

  
  	if (ha->fw_heartbeat_counter == fw_heartbeat_counter) {
  		ha->seconds_since_last_heartbeat++;
  		/* FW not alive after 2 seconds */
  		if (ha->seconds_since_last_heartbeat == 2) {
  			ha->seconds_since_last_heartbeat = 0;

  			qla4_8xxx_dump_peg_reg(ha);

  			status = QLA_ERROR;

  		}

  	} else
  		ha->seconds_since_last_heartbeat = 0;

  	ha->fw_heartbeat_counter = fw_heartbeat_counter;

  	return status;

  }

  static void qla4_8xxx_process_fw_error(struct scsi_qla_host *ha)
  {
  	uint32_t halt_status;
  	int halt_status_unrecoverable = 0;
  
  	halt_status = qla4_8xxx_rd_direct(ha, QLA8XXX_PEG_HALT_STATUS1);
  
  	if (is_qla8022(ha)) {
  		ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.
  ",
  			   __func__);
  		qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
  				CRB_NIU_XG_PAUSE_CTL_P0 |
  				CRB_NIU_XG_PAUSE_CTL_P1);
  
  		if (QLA82XX_FWERROR_CODE(halt_status) == 0x67)
  			ql4_printk(KERN_ERR, ha, "%s: Firmware aborted with error code 0x00006700. Device is being reset
  ",
  				   __func__);
  		if (halt_status & HALT_STATUS_UNRECOVERABLE)
  			halt_status_unrecoverable = 1;

  	} else if (is_qla8032(ha) || is_qla8042(ha)) {

  		if (halt_status & QLA83XX_HALT_STATUS_FW_RESET)
  			ql4_printk(KERN_ERR, ha, "%s: Firmware error detected device is being reset
  ",
  				   __func__);
  		else if (halt_status & QLA83XX_HALT_STATUS_UNRECOVERABLE)
  			halt_status_unrecoverable = 1;
  	}
  
  	/*
  	 * Since we cannot change dev_state in interrupt context,
  	 * set appropriate DPC flag then wakeup DPC
  	 */
  	if (halt_status_unrecoverable) {
  		set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
  	} else {
  		ql4_printk(KERN_INFO, ha, "%s: detect abort needed!
  ",
  			   __func__);
  		set_bit(DPC_RESET_HA, &ha->dpc_flags);
  	}
  	qla4xxx_mailbox_premature_completion(ha);
  	qla4xxx_wake_dpc(ha);
  }

  /**
   * qla4_8xxx_watchdog - Poll dev state
   * @ha: Pointer to host adapter structure.
   *
   * Context: Interrupt
   **/
  void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
  {

  	uint32_t dev_state;

  	uint32_t idc_ctrl;

  	if (is_qla8032(ha) &&
  	    (qla4_83xx_is_detached(ha) == QLA_SUCCESS))
  		WARN_ONCE(1, "%s: iSCSI function %d marked invisible
  ",
  			  __func__, ha->func_num);

  	/* don't poll if reset is going on */

  	if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
  	    test_bit(DPC_RESET_HA, &ha->dpc_flags) ||

  	    test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags))) {

  		dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);

  
  		if (qla4_8xxx_check_temp(ha)) {

  			if (is_qla8022(ha)) {
  				ql4_printk(KERN_INFO, ha, "disabling pause transmit on port 0 & 1.
  ");
  				qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
  						CRB_NIU_XG_PAUSE_CTL_P0 |
  						CRB_NIU_XG_PAUSE_CTL_P1);
  			}

  			set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
  			qla4xxx_wake_dpc(ha);

  		} else if (dev_state == QLA8XXX_DEV_NEED_RESET &&

  			   !test_bit(DPC_RESET_HA, &ha->dpc_flags)) {

  
  			ql4_printk(KERN_INFO, ha, "%s: HW State: NEED RESET!
  ",
  				   __func__);

  			if (is_qla8032(ha) || is_qla8042(ha)) {

  				idc_ctrl = qla4_83xx_rd_reg(ha,
  							QLA83XX_IDC_DRV_CTRL);
  				if (!(idc_ctrl & GRACEFUL_RESET_BIT1)) {
  					ql4_printk(KERN_INFO, ha, "%s: Graceful reset bit is not set
  ",
  						   __func__);
  					qla4xxx_mailbox_premature_completion(
  									    ha);
  				}
  			}

  			if ((is_qla8032(ha) || is_qla8042(ha)) ||

  			    (is_qla8022(ha) && !ql4xdontresethba)) {

  				set_bit(DPC_RESET_HA, &ha->dpc_flags);
  				qla4xxx_wake_dpc(ha);

  			}

  		} else if (dev_state == QLA8XXX_DEV_NEED_QUIESCENT &&

  		    !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {

  			ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!
  ",
  			    __func__);

  			set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags);
  			qla4xxx_wake_dpc(ha);
  		} else  {
  			/* Check firmware health */

  			if (qla4_8xxx_check_fw_alive(ha))
  				qla4_8xxx_process_fw_error(ha);

  		}
  	}
  }

  static void qla4xxx_check_relogin_flash_ddb(struct iscsi_cls_session *cls_sess)

  {
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  	struct scsi_qla_host *ha;
  
  	sess = cls_sess->dd_data;
  	ddb_entry = sess->dd_data;
  	ha = ddb_entry->ha;
  
  	if (!(ddb_entry->ddb_type == FLASH_DDB))
  		return;
  
  	if (adapter_up(ha) && !test_bit(DF_RELOGIN, &ddb_entry->flags) &&
  	    !iscsi_is_session_online(cls_sess)) {
  		if (atomic_read(&ddb_entry->retry_relogin_timer) !=
  		    INVALID_ENTRY) {
  			if (atomic_read(&ddb_entry->retry_relogin_timer) ==
  					0) {
  				atomic_set(&ddb_entry->retry_relogin_timer,
  					   INVALID_ENTRY);
  				set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
  				set_bit(DF_RELOGIN, &ddb_entry->flags);
  				DEBUG2(ql4_printk(KERN_INFO, ha,
  				       "%s: index [%d] login device
  ",
  					__func__, ddb_entry->fw_ddb_index));
  			} else
  				atomic_dec(&ddb_entry->retry_relogin_timer);
  		}
  	}
  
  	/* Wait for relogin to timeout */
  	if (atomic_read(&ddb_entry->relogin_timer) &&
  	    (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) {
  		/*
  		 * If the relogin times out and the device is
  		 * still NOT ONLINE then try and relogin again.
  		 */
  		if (!iscsi_is_session_online(cls_sess)) {
  			/* Reset retry relogin timer */
  			atomic_inc(&ddb_entry->relogin_retry_count);
  			DEBUG2(ql4_printk(KERN_INFO, ha,
  				"%s: index[%d] relogin timed out-retrying"
  				" relogin (%d), retry (%d)
  ", __func__,
  				ddb_entry->fw_ddb_index,
  				atomic_read(&ddb_entry->relogin_retry_count),
  				ddb_entry->default_time2wait + 4));
  			set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
  			atomic_set(&ddb_entry->retry_relogin_timer,
  				   ddb_entry->default_time2wait + 4);
  		}
  	}
  }

  /**

   * qla4xxx_timer - checks every second for work to do.
   * @ha: Pointer to host adapter structure.
   **/
  static void qla4xxx_timer(struct scsi_qla_host *ha)
  {

  	int start_dpc = 0;

  	uint16_t w;

  	iscsi_host_for_each_session(ha->host, qla4xxx_check_relogin_flash_ddb);

  	/* If we are in the middle of AER/EEH processing
  	 * skip any processing and reschedule the timer
  	 */
  	if (test_bit(AF_EEH_BUSY, &ha->flags)) {
  		mod_timer(&ha->timer, jiffies + HZ);
  		return;
  	}
  
  	/* Hardware read to trigger an EEH error during mailbox waits. */
  	if (!pci_channel_offline(ha->pdev))
  		pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);

  	if (is_qla80XX(ha))

  		qla4_8xxx_watchdog(ha);

  	if (is_qla40XX(ha)) {

  		/* Check for heartbeat interval. */
  		if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE &&
  		    ha->heartbeat_interval != 0) {
  			ha->seconds_since_last_heartbeat++;
  			if (ha->seconds_since_last_heartbeat >
  			    ha->heartbeat_interval + 2)
  				set_bit(DPC_RESET_HA, &ha->dpc_flags);
  		}

  	}

  	/* Process any deferred work. */
  	if (!list_empty(&ha->work_list))
  		start_dpc++;

  	/* Wakeup the dpc routine for this adapter, if needed. */

  	if (start_dpc ||

  	     test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
  	     test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) ||
  	     test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) ||

  	     test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) ||

  	     test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
  	     test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) ||

  	     test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) ||

  	     test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
  	     test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||

  	     test_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags) ||

  	     test_bit(DPC_AEN, &ha->dpc_flags)) {

  		DEBUG2(printk("scsi%ld: %s: scheduling dpc routine"
  			      " - dpc flags = 0x%lx
  ",
  			      ha->host_no, __func__, ha->dpc_flags));

  		qla4xxx_wake_dpc(ha);

  	}
  
  	/* Reschedule timer thread to call us back in one second */
  	mod_timer(&ha->timer, jiffies + HZ);
  
  	DEBUG2(ha->seconds_since_last_intr++);
  }
  
  /**
   * qla4xxx_cmd_wait - waits for all outstanding commands to complete
   * @ha: Pointer to host adapter structure.
   *
   * This routine stalls the driver until all outstanding commands are returned.
   * Caller must release the Hardware Lock prior to calling this routine.
   **/
  static int qla4xxx_cmd_wait(struct scsi_qla_host *ha)
  {
  	uint32_t index = 0;

  	unsigned long flags;
  	struct scsi_cmnd *cmd;

  	unsigned long wtime;
  	uint32_t wtmo;

  	if (is_qla40XX(ha))
  		wtmo = WAIT_CMD_TOV;
  	else
  		wtmo = ha->nx_reset_timeout / 2;
  
  	wtime = jiffies + (wtmo * HZ);

  	DEBUG2(ql4_printk(KERN_INFO, ha,
  			  "Wait up to %u seconds for cmds to complete
  ",
  			  wtmo));

  
  	while (!time_after_eq(jiffies, wtime)) {

  		spin_lock_irqsave(&ha->hardware_lock, flags);
  		/* Find a command that hasn't completed. */
  		for (index = 0; index < ha->host->can_queue; index++) {
  			cmd = scsi_host_find_tag(ha->host, index);

  			/*
  			 * We cannot just check if the index is valid,
  			 * becase if we are run from the scsi eh, then
  			 * the scsi/block layer is going to prevent
  			 * the tag from being released.
  			 */
  			if (cmd != NULL && CMD_SP(cmd))

  				break;
  		}
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  
  		/* If No Commands are pending, wait is complete */

  		if (index == ha->host->can_queue)
  			return QLA_SUCCESS;

  		msleep(1000);
  	}
  	/* If we timed out on waiting for commands to come back
  	 * return ERROR. */
  	return QLA_ERROR;

  }

  int qla4xxx_hw_reset(struct scsi_qla_host *ha)

  {

  	uint32_t ctrl_status;

  	unsigned long flags = 0;
  
  	DEBUG2(printk(KERN_ERR "scsi%ld: %s
  ", ha->host_no, __func__));

  	if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS)
  		return QLA_ERROR;

  	spin_lock_irqsave(&ha->hardware_lock, flags);
  
  	/*
  	 * If the SCSI Reset Interrupt bit is set, clear it.
  	 * Otherwise, the Soft Reset won't work.
  	 */
  	ctrl_status = readw(&ha->reg->ctrl_status);
  	if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0)
  		writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
  
  	/* Issue Soft Reset */
  	writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status);
  	readl(&ha->reg->ctrl_status);
  
  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  	return QLA_SUCCESS;

  }
  
  /**
   * qla4xxx_soft_reset - performs soft reset.
   * @ha: Pointer to host adapter structure.
   **/
  int qla4xxx_soft_reset(struct scsi_qla_host *ha)
  {
  	uint32_t max_wait_time;
  	unsigned long flags = 0;

  	int status;

  	uint32_t ctrl_status;

  	status = qla4xxx_hw_reset(ha);
  	if (status != QLA_SUCCESS)
  		return status;

  	status = QLA_ERROR;

  	/* Wait until the Network Reset Intr bit is cleared */
  	max_wait_time = RESET_INTR_TOV;
  	do {
  		spin_lock_irqsave(&ha->hardware_lock, flags);
  		ctrl_status = readw(&ha->reg->ctrl_status);
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  
  		if ((ctrl_status & CSR_NET_RESET_INTR) == 0)
  			break;
  
  		msleep(1000);
  	} while ((--max_wait_time));
  
  	if ((ctrl_status & CSR_NET_RESET_INTR) != 0) {
  		DEBUG2(printk(KERN_WARNING
  			      "scsi%ld: Network Reset Intr not cleared by "
  			      "Network function, clearing it now!
  ",
  			      ha->host_no));
  		spin_lock_irqsave(&ha->hardware_lock, flags);
  		writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status);
  		readl(&ha->reg->ctrl_status);
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  	}
  
  	/* Wait until the firmware tells us the Soft Reset is done */
  	max_wait_time = SOFT_RESET_TOV;
  	do {
  		spin_lock_irqsave(&ha->hardware_lock, flags);
  		ctrl_status = readw(&ha->reg->ctrl_status);
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  
  		if ((ctrl_status & CSR_SOFT_RESET) == 0) {
  			status = QLA_SUCCESS;
  			break;
  		}
  
  		msleep(1000);
  	} while ((--max_wait_time));
  
  	/*
  	 * Also, make sure that the SCSI Reset Interrupt bit has been cleared
  	 * after the soft reset has taken place.
  	 */
  	spin_lock_irqsave(&ha->hardware_lock, flags);
  	ctrl_status = readw(&ha->reg->ctrl_status);
  	if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) {
  		writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
  		readl(&ha->reg->ctrl_status);
  	}
  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
  
  	/* If soft reset fails then most probably the bios on other
  	 * function is also enabled.
  	 * Since the initialization is sequential the other fn
  	 * wont be able to acknowledge the soft reset.
  	 * Issue a force soft reset to workaround this scenario.
  	 */
  	if (max_wait_time == 0) {
  		/* Issue Force Soft Reset */
  		spin_lock_irqsave(&ha->hardware_lock, flags);
  		writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status);
  		readl(&ha->reg->ctrl_status);
  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
  		/* Wait until the firmware tells us the Soft Reset is done */
  		max_wait_time = SOFT_RESET_TOV;
  		do {
  			spin_lock_irqsave(&ha->hardware_lock, flags);
  			ctrl_status = readw(&ha->reg->ctrl_status);
  			spin_unlock_irqrestore(&ha->hardware_lock, flags);
  
  			if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) {
  				status = QLA_SUCCESS;
  				break;
  			}
  
  			msleep(1000);
  		} while ((--max_wait_time));
  	}
  
  	return status;
  }
  
  /**

   * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S.

   * @ha: Pointer to host adapter structure.

   * @res: returned scsi status

   *
   * This routine is called just prior to a HARD RESET to return all
   * outstanding commands back to the Operating System.
   * Caller should make sure that the following locks are released
   * before this calling routine: Hardware lock, and io_request_lock.
   **/

  static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res)

  {
  	struct srb *srb;
  	int i;
  	unsigned long flags;
  
  	spin_lock_irqsave(&ha->hardware_lock, flags);
  	for (i = 0; i < ha->host->can_queue; i++) {
  		srb = qla4xxx_del_from_active_array(ha, i);
  		if (srb != NULL) {

  			srb->cmd->result = res;

  			kref_put(&srb->srb_ref, qla4xxx_srb_compl);

  		}
  	}
  	spin_unlock_irqrestore(&ha->hardware_lock, flags);

  }

  void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha)
  {
  	clear_bit(AF_ONLINE, &ha->flags);
  
  	/* Disable the board */
  	ql4_printk(KERN_INFO, ha, "Disabling the board
  ");

  
  	qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
  	qla4xxx_mark_all_devices_missing(ha);
  	clear_bit(AF_INIT_DONE, &ha->flags);
  }

  static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session)
  {
  	struct iscsi_session *sess;
  	struct ddb_entry *ddb_entry;
  
  	sess = cls_session->dd_data;
  	ddb_entry = sess->dd_data;
  	ddb_entry->fw_ddb_device_state = DDB_DS_SESSION_FAILED;

  
  	if (ddb_entry->ddb_type == FLASH_DDB)
  		iscsi_block_session(ddb_entry->sess);
  	else
  		iscsi_session_failure(cls_session->dd_data,
  				      ISCSI_ERR_CONN_FAILED);

  }

  /**

   * qla4xxx_recover_adapter - recovers adapter after a fatal error
   * @ha: Pointer to host adapter structure.

   **/

  static int qla4xxx_recover_adapter(struct scsi_qla_host *ha)

  {

  	int status = QLA_ERROR;
  	uint8_t reset_chip = 0;

  	uint32_t dev_state;

  	unsigned long wait;

  
  	/* Stall incoming I/O until we are done */

  	scsi_block_requests(ha->host);

  	clear_bit(AF_ONLINE, &ha->flags);

  	clear_bit(AF_LINK_UP, &ha->flags);

  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE
  ", __func__));

  	set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);

  	if ((is_qla8032(ha) || is_qla8042(ha)) &&

  	    !test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) {
  		ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.
  ",
  			   __func__);
  		/* disable pause frame for ISP83xx */
  		qla4_83xx_disable_pause(ha);
  	}

  	iscsi_host_for_each_session(ha->host, qla4xxx_fail_session);

  	if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
  		reset_chip = 1;

  	/* For the DPC_RESET_HA_INTR case (ISP-4xxx specific)
  	 * do not reset adapter, jump to initialize_adapter */
  	if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
  		status = QLA_SUCCESS;
  		goto recover_ha_init_adapter;
  	}

  	/* For the ISP-8xxx adapter, issue a stop_firmware if invoked