xref: /openbmc/linux/drivers/scsi/qla4xxx/ql4_os.c (revision c900529f3d9161bfde5cca0754f83b4d3c3e0220)
1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   * QLogic iSCSI HBA Driver
4   * Copyright (c)  2003-2013 QLogic Corporation
5   */
6  #include <linux/moduleparam.h>
7  #include <linux/slab.h>
8  #include <linux/blkdev.h>
9  #include <linux/iscsi_boot_sysfs.h>
10  #include <linux/inet.h>
11  
12  #include <scsi/scsi_tcq.h>
13  #include <scsi/scsicam.h>
14  
15  #include "ql4_def.h"
16  #include "ql4_version.h"
17  #include "ql4_glbl.h"
18  #include "ql4_dbg.h"
19  #include "ql4_inline.h"
20  #include "ql4_83xx.h"
21  
22  /*
23   * Driver version
24   */
25  static char qla4xxx_version_str[40];
26  
27  /*
28   * SRB allocation cache
29   */
30  static struct kmem_cache *srb_cachep;
31  
32  /*
33   * Module parameter information and variables
34   */
35  static int ql4xdisablesysfsboot = 1;
36  module_param(ql4xdisablesysfsboot, int, S_IRUGO | S_IWUSR);
37  MODULE_PARM_DESC(ql4xdisablesysfsboot,
38  		 " Set to disable exporting boot targets to sysfs.\n"
39  		 "\t\t  0 - Export boot targets\n"
40  		 "\t\t  1 - Do not export boot targets (Default)");
41  
42  int ql4xdontresethba;
43  module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR);
44  MODULE_PARM_DESC(ql4xdontresethba,
45  		 " Don't reset the HBA for driver recovery.\n"
46  		 "\t\t  0 - It will reset HBA (Default)\n"
47  		 "\t\t  1 - It will NOT reset HBA");
48  
49  int ql4xextended_error_logging;
50  module_param(ql4xextended_error_logging, int, S_IRUGO | S_IWUSR);
51  MODULE_PARM_DESC(ql4xextended_error_logging,
52  		 " Option to enable extended error logging.\n"
53  		 "\t\t  0 - no logging (Default)\n"
54  		 "\t\t  2 - debug logging");
55  
56  int ql4xenablemsix = 1;
57  module_param(ql4xenablemsix, int, S_IRUGO|S_IWUSR);
58  MODULE_PARM_DESC(ql4xenablemsix,
59  		 " Set to enable MSI or MSI-X interrupt mechanism.\n"
60  		 "\t\t  0 = enable INTx interrupt mechanism.\n"
61  		 "\t\t  1 = enable MSI-X interrupt mechanism (Default).\n"
62  		 "\t\t  2 = enable MSI interrupt mechanism.");
63  
64  #define QL4_DEF_QDEPTH 32
65  static int ql4xmaxqdepth = QL4_DEF_QDEPTH;
66  module_param(ql4xmaxqdepth, int, S_IRUGO | S_IWUSR);
67  MODULE_PARM_DESC(ql4xmaxqdepth,
68  		 " Maximum queue depth to report for target devices.\n"
69  		 "\t\t  Default: 32.");
70  
71  static int ql4xqfulltracking = 1;
72  module_param(ql4xqfulltracking, int, S_IRUGO | S_IWUSR);
73  MODULE_PARM_DESC(ql4xqfulltracking,
74  		 " Enable or disable dynamic tracking and adjustment of\n"
75  		 "\t\t scsi device queue depth.\n"
76  		 "\t\t  0 - Disable.\n"
77  		 "\t\t  1 - Enable. (Default)");
78  
79  static int ql4xsess_recovery_tmo = QL4_SESS_RECOVERY_TMO;
80  module_param(ql4xsess_recovery_tmo, int, S_IRUGO);
81  MODULE_PARM_DESC(ql4xsess_recovery_tmo,
82  		" Target Session Recovery Timeout.\n"
83  		"\t\t  Default: 120 sec.");
84  
85  int ql4xmdcapmask = 0;
86  module_param(ql4xmdcapmask, int, S_IRUGO);
87  MODULE_PARM_DESC(ql4xmdcapmask,
88  		 " Set the Minidump driver capture mask level.\n"
89  		 "\t\t  Default is 0 (firmware default capture mask)\n"
90  		 "\t\t  Can be set to 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF");
91  
92  int ql4xenablemd = 1;
93  module_param(ql4xenablemd, int, S_IRUGO | S_IWUSR);
94  MODULE_PARM_DESC(ql4xenablemd,
95  		 " Set to enable minidump.\n"
96  		 "\t\t  0 - disable minidump\n"
97  		 "\t\t  1 - enable minidump (Default)");
98  
99  static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha);
100  /*
101   * SCSI host template entry points
102   */
103  static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha);
104  
105  /*
106   * iSCSI template entry points
107   */
108  static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
109  				     enum iscsi_param param, char *buf);
110  static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn,
111  				  enum iscsi_param param, char *buf);
112  static int qla4xxx_host_get_param(struct Scsi_Host *shost,
113  				  enum iscsi_host_param param, char *buf);
114  static int qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data,
115  				   uint32_t len);
116  static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
117  				   enum iscsi_param_type param_type,
118  				   int param, char *buf);
119  static enum scsi_timeout_action qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc);
120  static struct iscsi_endpoint *qla4xxx_ep_connect(struct Scsi_Host *shost,
121  						 struct sockaddr *dst_addr,
122  						 int non_blocking);
123  static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms);
124  static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep);
125  static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
126  				enum iscsi_param param, char *buf);
127  static int qla4xxx_conn_start(struct iscsi_cls_conn *conn);
128  static struct iscsi_cls_conn *
129  qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx);
130  static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
131  			     struct iscsi_cls_conn *cls_conn,
132  			     uint64_t transport_fd, int is_leading);
133  static void qla4xxx_conn_destroy(struct iscsi_cls_conn *conn);
134  static struct iscsi_cls_session *
135  qla4xxx_session_create(struct iscsi_endpoint *ep, uint16_t cmds_max,
136  			uint16_t qdepth, uint32_t initial_cmdsn);
137  static void qla4xxx_session_destroy(struct iscsi_cls_session *sess);
138  static void qla4xxx_task_work(struct work_struct *wdata);
139  static int qla4xxx_alloc_pdu(struct iscsi_task *, uint8_t);
140  static int qla4xxx_task_xmit(struct iscsi_task *);
141  static void qla4xxx_task_cleanup(struct iscsi_task *);
142  static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session);
143  static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
144  				   struct iscsi_stats *stats);
145  static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
146  			     uint32_t iface_type, uint32_t payload_size,
147  			     uint32_t pid, struct sockaddr *dst_addr);
148  static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
149  				 uint32_t *num_entries, char *buf);
150  static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx);
151  static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void  *data,
152  				  int len);
153  static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len);
154  
155  /*
156   * SCSI host template entry points
157   */
158  static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
159  static int qla4xxx_eh_abort(struct scsi_cmnd *cmd);
160  static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);
161  static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);
162  static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd);
163  static int qla4xxx_slave_alloc(struct scsi_device *device);
164  static umode_t qla4_attr_is_visible(int param_type, int param);
165  static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type);
166  
167  /*
168   * iSCSI Flash DDB sysfs entry points
169   */
170  static int
171  qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
172  			    struct iscsi_bus_flash_conn *fnode_conn,
173  			    void *data, int len);
174  static int
175  qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
176  			    int param, char *buf);
177  static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
178  				 int len);
179  static int
180  qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess);
181  static int qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session *fnode_sess,
182  				   struct iscsi_bus_flash_conn *fnode_conn);
183  static int qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session *fnode_sess,
184  				    struct iscsi_bus_flash_conn *fnode_conn);
185  static int qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session *cls_sess);
186  
187  static struct qla4_8xxx_legacy_intr_set legacy_intr[] =
188      QLA82XX_LEGACY_INTR_CONFIG;
189  
190  static const uint32_t qla4_82xx_reg_tbl[] = {
191  	QLA82XX_PEG_HALT_STATUS1,
192  	QLA82XX_PEG_HALT_STATUS2,
193  	QLA82XX_PEG_ALIVE_COUNTER,
194  	QLA82XX_CRB_DRV_ACTIVE,
195  	QLA82XX_CRB_DEV_STATE,
196  	QLA82XX_CRB_DRV_STATE,
197  	QLA82XX_CRB_DRV_SCRATCH,
198  	QLA82XX_CRB_DEV_PART_INFO,
199  	QLA82XX_CRB_DRV_IDC_VERSION,
200  	QLA82XX_FW_VERSION_MAJOR,
201  	QLA82XX_FW_VERSION_MINOR,
202  	QLA82XX_FW_VERSION_SUB,
203  	CRB_CMDPEG_STATE,
204  	CRB_TEMP_STATE,
205  };
206  
207  static const uint32_t qla4_83xx_reg_tbl[] = {
208  	QLA83XX_PEG_HALT_STATUS1,
209  	QLA83XX_PEG_HALT_STATUS2,
210  	QLA83XX_PEG_ALIVE_COUNTER,
211  	QLA83XX_CRB_DRV_ACTIVE,
212  	QLA83XX_CRB_DEV_STATE,
213  	QLA83XX_CRB_DRV_STATE,
214  	QLA83XX_CRB_DRV_SCRATCH,
215  	QLA83XX_CRB_DEV_PART_INFO1,
216  	QLA83XX_CRB_IDC_VER_MAJOR,
217  	QLA83XX_FW_VER_MAJOR,
218  	QLA83XX_FW_VER_MINOR,
219  	QLA83XX_FW_VER_SUB,
220  	QLA83XX_CMDPEG_STATE,
221  	QLA83XX_ASIC_TEMP,
222  };
223  
224  static struct scsi_host_template qla4xxx_driver_template = {
225  	.module			= THIS_MODULE,
226  	.name			= DRIVER_NAME,
227  	.proc_name		= DRIVER_NAME,
228  	.queuecommand		= qla4xxx_queuecommand,
229  	.cmd_size		= sizeof(struct qla4xxx_cmd_priv),
230  
231  	.eh_abort_handler	= qla4xxx_eh_abort,
232  	.eh_device_reset_handler = qla4xxx_eh_device_reset,
233  	.eh_target_reset_handler = qla4xxx_eh_target_reset,
234  	.eh_host_reset_handler	= qla4xxx_eh_host_reset,
235  	.eh_timed_out		= qla4xxx_eh_cmd_timed_out,
236  
237  	.slave_alloc		= qla4xxx_slave_alloc,
238  	.change_queue_depth	= scsi_change_queue_depth,
239  
240  	.this_id		= -1,
241  	.cmd_per_lun		= 3,
242  	.sg_tablesize		= SG_ALL,
243  
244  	.max_sectors		= 0xFFFF,
245  	.shost_groups		= qla4xxx_host_groups,
246  	.host_reset		= qla4xxx_host_reset,
247  	.vendor_id		= SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC,
248  };
249  
250  static struct iscsi_transport qla4xxx_iscsi_transport = {
251  	.owner			= THIS_MODULE,
252  	.name			= DRIVER_NAME,
253  	.caps			= CAP_TEXT_NEGO |
254  				  CAP_DATA_PATH_OFFLOAD | CAP_HDRDGST |
255  				  CAP_DATADGST | CAP_LOGIN_OFFLOAD |
256  				  CAP_MULTI_R2T,
257  	.attr_is_visible	= qla4_attr_is_visible,
258  	.create_session         = qla4xxx_session_create,
259  	.destroy_session        = qla4xxx_session_destroy,
260  	.start_conn             = qla4xxx_conn_start,
261  	.create_conn            = qla4xxx_conn_create,
262  	.bind_conn              = qla4xxx_conn_bind,
263  	.unbind_conn		= iscsi_conn_unbind,
264  	.stop_conn              = iscsi_conn_stop,
265  	.destroy_conn           = qla4xxx_conn_destroy,
266  	.set_param              = iscsi_set_param,
267  	.get_conn_param		= qla4xxx_conn_get_param,
268  	.get_session_param	= qla4xxx_session_get_param,
269  	.get_ep_param           = qla4xxx_get_ep_param,
270  	.ep_connect		= qla4xxx_ep_connect,
271  	.ep_poll		= qla4xxx_ep_poll,
272  	.ep_disconnect		= qla4xxx_ep_disconnect,
273  	.get_stats		= qla4xxx_conn_get_stats,
274  	.send_pdu		= iscsi_conn_send_pdu,
275  	.xmit_task		= qla4xxx_task_xmit,
276  	.cleanup_task		= qla4xxx_task_cleanup,
277  	.alloc_pdu		= qla4xxx_alloc_pdu,
278  
279  	.get_host_param		= qla4xxx_host_get_param,
280  	.set_iface_param	= qla4xxx_iface_set_param,
281  	.get_iface_param	= qla4xxx_get_iface_param,
282  	.bsg_request		= qla4xxx_bsg_request,
283  	.send_ping		= qla4xxx_send_ping,
284  	.get_chap		= qla4xxx_get_chap_list,
285  	.delete_chap		= qla4xxx_delete_chap,
286  	.set_chap		= qla4xxx_set_chap_entry,
287  	.get_flashnode_param	= qla4xxx_sysfs_ddb_get_param,
288  	.set_flashnode_param	= qla4xxx_sysfs_ddb_set_param,
289  	.new_flashnode		= qla4xxx_sysfs_ddb_add,
290  	.del_flashnode		= qla4xxx_sysfs_ddb_delete,
291  	.login_flashnode	= qla4xxx_sysfs_ddb_login,
292  	.logout_flashnode	= qla4xxx_sysfs_ddb_logout,
293  	.logout_flashnode_sid	= qla4xxx_sysfs_ddb_logout_sid,
294  	.get_host_stats		= qla4xxx_get_host_stats,
295  };
296  
297  static struct scsi_transport_template *qla4xxx_scsi_transport;
298  
qla4xxx_isp_check_reg(struct scsi_qla_host * ha)299  static int qla4xxx_isp_check_reg(struct scsi_qla_host *ha)
300  {
301  	u32 reg_val = 0;
302  	int rval = QLA_SUCCESS;
303  
304  	if (is_qla8022(ha))
305  		reg_val = readl(&ha->qla4_82xx_reg->host_status);
306  	else if (is_qla8032(ha) || is_qla8042(ha))
307  		reg_val = qla4_8xxx_rd_direct(ha, QLA8XXX_PEG_ALIVE_COUNTER);
308  	else
309  		reg_val = readw(&ha->reg->ctrl_status);
310  
311  	if (reg_val == QL4_ISP_REG_DISCONNECT)
312  		rval = QLA_ERROR;
313  
314  	return rval;
315  }
316  
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)317  static int qla4xxx_send_ping(struct Scsi_Host *shost, uint32_t iface_num,
318  			     uint32_t iface_type, uint32_t payload_size,
319  			     uint32_t pid, struct sockaddr *dst_addr)
320  {
321  	struct scsi_qla_host *ha = to_qla_host(shost);
322  	struct sockaddr_in *addr;
323  	struct sockaddr_in6 *addr6;
324  	uint32_t options = 0;
325  	uint8_t ipaddr[IPv6_ADDR_LEN];
326  	int rval;
327  
328  	memset(ipaddr, 0, IPv6_ADDR_LEN);
329  	/* IPv4 to IPv4 */
330  	if ((iface_type == ISCSI_IFACE_TYPE_IPV4) &&
331  	    (dst_addr->sa_family == AF_INET)) {
332  		addr = (struct sockaddr_in *)dst_addr;
333  		memcpy(ipaddr, &addr->sin_addr.s_addr, IP_ADDR_LEN);
334  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv4 Ping src: %pI4 "
335  				  "dest: %pI4\n", __func__,
336  				  &ha->ip_config.ip_address, ipaddr));
337  		rval = qla4xxx_ping_iocb(ha, options, payload_size, pid,
338  					 ipaddr);
339  		if (rval)
340  			rval = -EINVAL;
341  	} else if ((iface_type == ISCSI_IFACE_TYPE_IPV6) &&
342  		   (dst_addr->sa_family == AF_INET6)) {
343  		/* IPv6 to IPv6 */
344  		addr6 = (struct sockaddr_in6 *)dst_addr;
345  		memcpy(ipaddr, &addr6->sin6_addr.in6_u.u6_addr8, IPv6_ADDR_LEN);
346  
347  		options |= PING_IPV6_PROTOCOL_ENABLE;
348  
349  		/* Ping using LinkLocal address */
350  		if ((iface_num == 0) || (iface_num == 1)) {
351  			DEBUG2(ql4_printk(KERN_INFO, ha, "%s: LinkLocal Ping "
352  					  "src: %pI6 dest: %pI6\n", __func__,
353  					  &ha->ip_config.ipv6_link_local_addr,
354  					  ipaddr));
355  			options |= PING_IPV6_LINKLOCAL_ADDR;
356  			rval = qla4xxx_ping_iocb(ha, options, payload_size,
357  						 pid, ipaddr);
358  		} else {
359  			ql4_printk(KERN_WARNING, ha, "%s: iface num = %d "
360  				   "not supported\n", __func__, iface_num);
361  			rval = -ENOSYS;
362  			goto exit_send_ping;
363  		}
364  
365  		/*
366  		 * If ping using LinkLocal address fails, try ping using
367  		 * IPv6 address
368  		 */
369  		if (rval != QLA_SUCCESS) {
370  			options &= ~PING_IPV6_LINKLOCAL_ADDR;
371  			if (iface_num == 0) {
372  				options |= PING_IPV6_ADDR0;
373  				DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
374  						  "Ping src: %pI6 "
375  						  "dest: %pI6\n", __func__,
376  						  &ha->ip_config.ipv6_addr0,
377  						  ipaddr));
378  			} else if (iface_num == 1) {
379  				options |= PING_IPV6_ADDR1;
380  				DEBUG2(ql4_printk(KERN_INFO, ha, "%s: IPv6 "
381  						  "Ping src: %pI6 "
382  						  "dest: %pI6\n", __func__,
383  						  &ha->ip_config.ipv6_addr1,
384  						  ipaddr));
385  			}
386  			rval = qla4xxx_ping_iocb(ha, options, payload_size,
387  						 pid, ipaddr);
388  			if (rval)
389  				rval = -EINVAL;
390  		}
391  	} else
392  		rval = -ENOSYS;
393  exit_send_ping:
394  	return rval;
395  }
396  
qla4_attr_is_visible(int param_type,int param)397  static umode_t qla4_attr_is_visible(int param_type, int param)
398  {
399  	switch (param_type) {
400  	case ISCSI_HOST_PARAM:
401  		switch (param) {
402  		case ISCSI_HOST_PARAM_HWADDRESS:
403  		case ISCSI_HOST_PARAM_IPADDRESS:
404  		case ISCSI_HOST_PARAM_INITIATOR_NAME:
405  		case ISCSI_HOST_PARAM_PORT_STATE:
406  		case ISCSI_HOST_PARAM_PORT_SPEED:
407  			return S_IRUGO;
408  		default:
409  			return 0;
410  		}
411  	case ISCSI_PARAM:
412  		switch (param) {
413  		case ISCSI_PARAM_PERSISTENT_ADDRESS:
414  		case ISCSI_PARAM_PERSISTENT_PORT:
415  		case ISCSI_PARAM_CONN_ADDRESS:
416  		case ISCSI_PARAM_CONN_PORT:
417  		case ISCSI_PARAM_TARGET_NAME:
418  		case ISCSI_PARAM_TPGT:
419  		case ISCSI_PARAM_TARGET_ALIAS:
420  		case ISCSI_PARAM_MAX_BURST:
421  		case ISCSI_PARAM_MAX_R2T:
422  		case ISCSI_PARAM_FIRST_BURST:
423  		case ISCSI_PARAM_MAX_RECV_DLENGTH:
424  		case ISCSI_PARAM_MAX_XMIT_DLENGTH:
425  		case ISCSI_PARAM_IFACE_NAME:
426  		case ISCSI_PARAM_CHAP_OUT_IDX:
427  		case ISCSI_PARAM_CHAP_IN_IDX:
428  		case ISCSI_PARAM_USERNAME:
429  		case ISCSI_PARAM_PASSWORD:
430  		case ISCSI_PARAM_USERNAME_IN:
431  		case ISCSI_PARAM_PASSWORD_IN:
432  		case ISCSI_PARAM_AUTO_SND_TGT_DISABLE:
433  		case ISCSI_PARAM_DISCOVERY_SESS:
434  		case ISCSI_PARAM_PORTAL_TYPE:
435  		case ISCSI_PARAM_CHAP_AUTH_EN:
436  		case ISCSI_PARAM_DISCOVERY_LOGOUT_EN:
437  		case ISCSI_PARAM_BIDI_CHAP_EN:
438  		case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL:
439  		case ISCSI_PARAM_DEF_TIME2WAIT:
440  		case ISCSI_PARAM_DEF_TIME2RETAIN:
441  		case ISCSI_PARAM_HDRDGST_EN:
442  		case ISCSI_PARAM_DATADGST_EN:
443  		case ISCSI_PARAM_INITIAL_R2T_EN:
444  		case ISCSI_PARAM_IMM_DATA_EN:
445  		case ISCSI_PARAM_PDU_INORDER_EN:
446  		case ISCSI_PARAM_DATASEQ_INORDER_EN:
447  		case ISCSI_PARAM_MAX_SEGMENT_SIZE:
448  		case ISCSI_PARAM_TCP_TIMESTAMP_STAT:
449  		case ISCSI_PARAM_TCP_WSF_DISABLE:
450  		case ISCSI_PARAM_TCP_NAGLE_DISABLE:
451  		case ISCSI_PARAM_TCP_TIMER_SCALE:
452  		case ISCSI_PARAM_TCP_TIMESTAMP_EN:
453  		case ISCSI_PARAM_TCP_XMIT_WSF:
454  		case ISCSI_PARAM_TCP_RECV_WSF:
455  		case ISCSI_PARAM_IP_FRAGMENT_DISABLE:
456  		case ISCSI_PARAM_IPV4_TOS:
457  		case ISCSI_PARAM_IPV6_TC:
458  		case ISCSI_PARAM_IPV6_FLOW_LABEL:
459  		case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6:
460  		case ISCSI_PARAM_KEEPALIVE_TMO:
461  		case ISCSI_PARAM_LOCAL_PORT:
462  		case ISCSI_PARAM_ISID:
463  		case ISCSI_PARAM_TSID:
464  		case ISCSI_PARAM_DEF_TASKMGMT_TMO:
465  		case ISCSI_PARAM_ERL:
466  		case ISCSI_PARAM_STATSN:
467  		case ISCSI_PARAM_EXP_STATSN:
468  		case ISCSI_PARAM_DISCOVERY_PARENT_IDX:
469  		case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
470  		case ISCSI_PARAM_LOCAL_IPADDR:
471  			return S_IRUGO;
472  		default:
473  			return 0;
474  		}
475  	case ISCSI_NET_PARAM:
476  		switch (param) {
477  		case ISCSI_NET_PARAM_IPV4_ADDR:
478  		case ISCSI_NET_PARAM_IPV4_SUBNET:
479  		case ISCSI_NET_PARAM_IPV4_GW:
480  		case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
481  		case ISCSI_NET_PARAM_IFACE_ENABLE:
482  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
483  		case ISCSI_NET_PARAM_IPV6_ADDR:
484  		case ISCSI_NET_PARAM_IPV6_ROUTER:
485  		case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
486  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
487  		case ISCSI_NET_PARAM_VLAN_ID:
488  		case ISCSI_NET_PARAM_VLAN_PRIORITY:
489  		case ISCSI_NET_PARAM_VLAN_ENABLED:
490  		case ISCSI_NET_PARAM_MTU:
491  		case ISCSI_NET_PARAM_PORT:
492  		case ISCSI_NET_PARAM_IPADDR_STATE:
493  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
494  		case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
495  		case ISCSI_NET_PARAM_DELAYED_ACK_EN:
496  		case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
497  		case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
498  		case ISCSI_NET_PARAM_TCP_WSF:
499  		case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
500  		case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
501  		case ISCSI_NET_PARAM_CACHE_ID:
502  		case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
503  		case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
504  		case ISCSI_NET_PARAM_IPV4_TOS_EN:
505  		case ISCSI_NET_PARAM_IPV4_TOS:
506  		case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
507  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
508  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
509  		case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
510  		case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
511  		case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
512  		case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
513  		case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
514  		case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
515  		case ISCSI_NET_PARAM_REDIRECT_EN:
516  		case ISCSI_NET_PARAM_IPV4_TTL:
517  		case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
518  		case ISCSI_NET_PARAM_IPV6_MLD_EN:
519  		case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
520  		case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
521  		case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
522  		case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
523  		case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
524  		case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
525  		case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
526  		case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
527  			return S_IRUGO;
528  		default:
529  			return 0;
530  		}
531  	case ISCSI_IFACE_PARAM:
532  		switch (param) {
533  		case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
534  		case ISCSI_IFACE_PARAM_HDRDGST_EN:
535  		case ISCSI_IFACE_PARAM_DATADGST_EN:
536  		case ISCSI_IFACE_PARAM_IMM_DATA_EN:
537  		case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
538  		case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
539  		case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
540  		case ISCSI_IFACE_PARAM_ERL:
541  		case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
542  		case ISCSI_IFACE_PARAM_FIRST_BURST:
543  		case ISCSI_IFACE_PARAM_MAX_R2T:
544  		case ISCSI_IFACE_PARAM_MAX_BURST:
545  		case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
546  		case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
547  		case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
548  		case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
549  		case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
550  		case ISCSI_IFACE_PARAM_INITIATOR_NAME:
551  			return S_IRUGO;
552  		default:
553  			return 0;
554  		}
555  	case ISCSI_FLASHNODE_PARAM:
556  		switch (param) {
557  		case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
558  		case ISCSI_FLASHNODE_PORTAL_TYPE:
559  		case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
560  		case ISCSI_FLASHNODE_DISCOVERY_SESS:
561  		case ISCSI_FLASHNODE_ENTRY_EN:
562  		case ISCSI_FLASHNODE_HDR_DGST_EN:
563  		case ISCSI_FLASHNODE_DATA_DGST_EN:
564  		case ISCSI_FLASHNODE_IMM_DATA_EN:
565  		case ISCSI_FLASHNODE_INITIAL_R2T_EN:
566  		case ISCSI_FLASHNODE_DATASEQ_INORDER:
567  		case ISCSI_FLASHNODE_PDU_INORDER:
568  		case ISCSI_FLASHNODE_CHAP_AUTH_EN:
569  		case ISCSI_FLASHNODE_SNACK_REQ_EN:
570  		case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
571  		case ISCSI_FLASHNODE_BIDI_CHAP_EN:
572  		case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
573  		case ISCSI_FLASHNODE_ERL:
574  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
575  		case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
576  		case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
577  		case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
578  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
579  		case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
580  		case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
581  		case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
582  		case ISCSI_FLASHNODE_FIRST_BURST:
583  		case ISCSI_FLASHNODE_DEF_TIME2WAIT:
584  		case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
585  		case ISCSI_FLASHNODE_MAX_R2T:
586  		case ISCSI_FLASHNODE_KEEPALIVE_TMO:
587  		case ISCSI_FLASHNODE_ISID:
588  		case ISCSI_FLASHNODE_TSID:
589  		case ISCSI_FLASHNODE_PORT:
590  		case ISCSI_FLASHNODE_MAX_BURST:
591  		case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
592  		case ISCSI_FLASHNODE_IPADDR:
593  		case ISCSI_FLASHNODE_ALIAS:
594  		case ISCSI_FLASHNODE_REDIRECT_IPADDR:
595  		case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
596  		case ISCSI_FLASHNODE_LOCAL_PORT:
597  		case ISCSI_FLASHNODE_IPV4_TOS:
598  		case ISCSI_FLASHNODE_IPV6_TC:
599  		case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
600  		case ISCSI_FLASHNODE_NAME:
601  		case ISCSI_FLASHNODE_TPGT:
602  		case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
603  		case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
604  		case ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE:
605  		case ISCSI_FLASHNODE_TCP_XMIT_WSF:
606  		case ISCSI_FLASHNODE_TCP_RECV_WSF:
607  		case ISCSI_FLASHNODE_CHAP_OUT_IDX:
608  		case ISCSI_FLASHNODE_USERNAME:
609  		case ISCSI_FLASHNODE_PASSWORD:
610  		case ISCSI_FLASHNODE_STATSN:
611  		case ISCSI_FLASHNODE_EXP_STATSN:
612  		case ISCSI_FLASHNODE_IS_BOOT_TGT:
613  			return S_IRUGO;
614  		default:
615  			return 0;
616  		}
617  	}
618  
619  	return 0;
620  }
621  
622  /**
623   * qla4xxx_create_chap_list - Create CHAP list from FLASH
624   * @ha: pointer to adapter structure
625   *
626   * Read flash and make a list of CHAP entries, during login when a CHAP entry
627   * is received, it will be checked in this list. If entry exist then the CHAP
628   * entry index is set in the DDB. If CHAP entry does not exist in this list
629   * then a new entry is added in FLASH in CHAP table and the index obtained is
630   * used in the DDB.
631   **/
qla4xxx_create_chap_list(struct scsi_qla_host * ha)632  static void qla4xxx_create_chap_list(struct scsi_qla_host *ha)
633  {
634  	int rval = 0;
635  	uint8_t *chap_flash_data = NULL;
636  	uint32_t offset;
637  	dma_addr_t chap_dma;
638  	uint32_t chap_size = 0;
639  
640  	if (is_qla40XX(ha))
641  		chap_size = MAX_CHAP_ENTRIES_40XX *
642  			    sizeof(struct ql4_chap_table);
643  	else	/* Single region contains CHAP info for both
644  		 * ports which is divided into half for each port.
645  		 */
646  		chap_size = ha->hw.flt_chap_size / 2;
647  
648  	chap_flash_data = dma_alloc_coherent(&ha->pdev->dev, chap_size,
649  					     &chap_dma, GFP_KERNEL);
650  	if (!chap_flash_data) {
651  		ql4_printk(KERN_ERR, ha, "No memory for chap_flash_data\n");
652  		return;
653  	}
654  
655  	if (is_qla40XX(ha)) {
656  		offset = FLASH_CHAP_OFFSET;
657  	} else {
658  		offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
659  		if (ha->port_num == 1)
660  			offset += chap_size;
661  	}
662  
663  	rval = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
664  	if (rval != QLA_SUCCESS)
665  		goto exit_chap_list;
666  
667  	if (ha->chap_list == NULL)
668  		ha->chap_list = vmalloc(chap_size);
669  	if (ha->chap_list == NULL) {
670  		ql4_printk(KERN_ERR, ha, "No memory for ha->chap_list\n");
671  		goto exit_chap_list;
672  	}
673  
674  	memcpy(ha->chap_list, chap_flash_data, chap_size);
675  
676  exit_chap_list:
677  	dma_free_coherent(&ha->pdev->dev, chap_size, chap_flash_data, chap_dma);
678  }
679  
qla4xxx_get_chap_by_index(struct scsi_qla_host * ha,int16_t chap_index,struct ql4_chap_table ** chap_entry)680  static int qla4xxx_get_chap_by_index(struct scsi_qla_host *ha,
681  				     int16_t chap_index,
682  				     struct ql4_chap_table **chap_entry)
683  {
684  	int rval = QLA_ERROR;
685  	int max_chap_entries;
686  
687  	if (!ha->chap_list) {
688  		ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!\n");
689  		goto exit_get_chap;
690  	}
691  
692  	if (is_qla80XX(ha))
693  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
694  				   sizeof(struct ql4_chap_table);
695  	else
696  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
697  
698  	if (chap_index > max_chap_entries) {
699  		ql4_printk(KERN_ERR, ha, "Invalid Chap index\n");
700  		goto exit_get_chap;
701  	}
702  
703  	*chap_entry = (struct ql4_chap_table *)ha->chap_list + chap_index;
704  	if ((*chap_entry)->cookie !=
705  	     cpu_to_le16(CHAP_VALID_COOKIE)) {
706  		*chap_entry = NULL;
707  	} else {
708  		rval = QLA_SUCCESS;
709  	}
710  
711  exit_get_chap:
712  	return rval;
713  }
714  
715  /**
716   * qla4xxx_find_free_chap_index - Find the first free chap index
717   * @ha: pointer to adapter structure
718   * @chap_index: CHAP index to be returned
719   *
720   * Find the first free chap index available in the chap table
721   *
722   * Note: Caller should acquire the chap lock before getting here.
723   **/
qla4xxx_find_free_chap_index(struct scsi_qla_host * ha,uint16_t * chap_index)724  static int qla4xxx_find_free_chap_index(struct scsi_qla_host *ha,
725  					uint16_t *chap_index)
726  {
727  	int i, rval;
728  	int free_index = -1;
729  	int max_chap_entries = 0;
730  	struct ql4_chap_table *chap_table;
731  
732  	if (is_qla80XX(ha))
733  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
734  						sizeof(struct ql4_chap_table);
735  	else
736  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
737  
738  	if (!ha->chap_list) {
739  		ql4_printk(KERN_ERR, ha, "CHAP table cache is empty!\n");
740  		rval = QLA_ERROR;
741  		goto exit_find_chap;
742  	}
743  
744  	for (i = 0; i < max_chap_entries; i++) {
745  		chap_table = (struct ql4_chap_table *)ha->chap_list + i;
746  
747  		if ((chap_table->cookie !=
748  		    cpu_to_le16(CHAP_VALID_COOKIE)) &&
749  		   (i > MAX_RESRV_CHAP_IDX)) {
750  				free_index = i;
751  				break;
752  		}
753  	}
754  
755  	if (free_index != -1) {
756  		*chap_index = free_index;
757  		rval = QLA_SUCCESS;
758  	} else {
759  		rval = QLA_ERROR;
760  	}
761  
762  exit_find_chap:
763  	return rval;
764  }
765  
qla4xxx_get_chap_list(struct Scsi_Host * shost,uint16_t chap_tbl_idx,uint32_t * num_entries,char * buf)766  static int qla4xxx_get_chap_list(struct Scsi_Host *shost, uint16_t chap_tbl_idx,
767  				  uint32_t *num_entries, char *buf)
768  {
769  	struct scsi_qla_host *ha = to_qla_host(shost);
770  	struct ql4_chap_table *chap_table;
771  	struct iscsi_chap_rec *chap_rec;
772  	int max_chap_entries = 0;
773  	int valid_chap_entries = 0;
774  	int ret = 0, i;
775  
776  	if (is_qla80XX(ha))
777  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
778  					sizeof(struct ql4_chap_table);
779  	else
780  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
781  
782  	ql4_printk(KERN_INFO, ha, "%s: num_entries = %d, CHAP idx = %d\n",
783  			__func__, *num_entries, chap_tbl_idx);
784  
785  	if (!buf) {
786  		ret = -ENOMEM;
787  		goto exit_get_chap_list;
788  	}
789  
790  	qla4xxx_create_chap_list(ha);
791  
792  	chap_rec = (struct iscsi_chap_rec *) buf;
793  	mutex_lock(&ha->chap_sem);
794  	for (i = chap_tbl_idx; i < max_chap_entries; i++) {
795  		chap_table = (struct ql4_chap_table *)ha->chap_list + i;
796  		if (chap_table->cookie !=
797  		    cpu_to_le16(CHAP_VALID_COOKIE))
798  			continue;
799  
800  		chap_rec->chap_tbl_idx = i;
801  		strscpy(chap_rec->username, chap_table->name,
802  			ISCSI_CHAP_AUTH_NAME_MAX_LEN);
803  		strscpy(chap_rec->password, chap_table->secret,
804  			QL4_CHAP_MAX_SECRET_LEN);
805  		chap_rec->password_length = chap_table->secret_len;
806  
807  		if (chap_table->flags & BIT_7) /* local */
808  			chap_rec->chap_type = CHAP_TYPE_OUT;
809  
810  		if (chap_table->flags & BIT_6) /* peer */
811  			chap_rec->chap_type = CHAP_TYPE_IN;
812  
813  		chap_rec++;
814  
815  		valid_chap_entries++;
816  		if (valid_chap_entries == *num_entries)
817  			break;
818  	}
819  	mutex_unlock(&ha->chap_sem);
820  
821  exit_get_chap_list:
822  	ql4_printk(KERN_INFO, ha, "%s: Valid CHAP Entries = %d\n",
823  			__func__,  valid_chap_entries);
824  	*num_entries = valid_chap_entries;
825  	return ret;
826  }
827  
__qla4xxx_is_chap_active(struct device * dev,void * data)828  static int __qla4xxx_is_chap_active(struct device *dev, void *data)
829  {
830  	int ret = 0;
831  	uint16_t *chap_tbl_idx = (uint16_t *) data;
832  	struct iscsi_cls_session *cls_session;
833  	struct iscsi_session *sess;
834  	struct ddb_entry *ddb_entry;
835  
836  	if (!iscsi_is_session_dev(dev))
837  		goto exit_is_chap_active;
838  
839  	cls_session = iscsi_dev_to_session(dev);
840  	sess = cls_session->dd_data;
841  	ddb_entry = sess->dd_data;
842  
843  	if (iscsi_is_session_online(cls_session))
844  		goto exit_is_chap_active;
845  
846  	if (ddb_entry->chap_tbl_idx == *chap_tbl_idx)
847  		ret = 1;
848  
849  exit_is_chap_active:
850  	return ret;
851  }
852  
qla4xxx_is_chap_active(struct Scsi_Host * shost,uint16_t chap_tbl_idx)853  static int qla4xxx_is_chap_active(struct Scsi_Host *shost,
854  				  uint16_t chap_tbl_idx)
855  {
856  	int ret = 0;
857  
858  	ret = device_for_each_child(&shost->shost_gendev, &chap_tbl_idx,
859  				    __qla4xxx_is_chap_active);
860  
861  	return ret;
862  }
863  
qla4xxx_delete_chap(struct Scsi_Host * shost,uint16_t chap_tbl_idx)864  static int qla4xxx_delete_chap(struct Scsi_Host *shost, uint16_t chap_tbl_idx)
865  {
866  	struct scsi_qla_host *ha = to_qla_host(shost);
867  	struct ql4_chap_table *chap_table;
868  	dma_addr_t chap_dma;
869  	int max_chap_entries = 0;
870  	uint32_t offset = 0;
871  	uint32_t chap_size;
872  	int ret = 0;
873  
874  	chap_table = dma_pool_zalloc(ha->chap_dma_pool, GFP_KERNEL, &chap_dma);
875  	if (chap_table == NULL)
876  		return -ENOMEM;
877  
878  	if (is_qla80XX(ha))
879  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
880  				   sizeof(struct ql4_chap_table);
881  	else
882  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
883  
884  	if (chap_tbl_idx > max_chap_entries) {
885  		ret = -EINVAL;
886  		goto exit_delete_chap;
887  	}
888  
889  	/* Check if chap index is in use.
890  	 * If chap is in use don't delet chap entry */
891  	ret = qla4xxx_is_chap_active(shost, chap_tbl_idx);
892  	if (ret) {
893  		ql4_printk(KERN_INFO, ha, "CHAP entry %d is in use, cannot "
894  			   "delete from flash\n", chap_tbl_idx);
895  		ret = -EBUSY;
896  		goto exit_delete_chap;
897  	}
898  
899  	chap_size = sizeof(struct ql4_chap_table);
900  	if (is_qla40XX(ha))
901  		offset = FLASH_CHAP_OFFSET | (chap_tbl_idx * chap_size);
902  	else {
903  		offset = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_region_chap << 2);
904  		/* flt_chap_size is CHAP table size for both ports
905  		 * so divide it by 2 to calculate the offset for second port
906  		 */
907  		if (ha->port_num == 1)
908  			offset += (ha->hw.flt_chap_size / 2);
909  		offset += (chap_tbl_idx * chap_size);
910  	}
911  
912  	ret = qla4xxx_get_flash(ha, chap_dma, offset, chap_size);
913  	if (ret != QLA_SUCCESS) {
914  		ret = -EINVAL;
915  		goto exit_delete_chap;
916  	}
917  
918  	DEBUG2(ql4_printk(KERN_INFO, ha, "Chap Cookie: x%x\n",
919  			  __le16_to_cpu(chap_table->cookie)));
920  
921  	if (__le16_to_cpu(chap_table->cookie) != CHAP_VALID_COOKIE) {
922  		ql4_printk(KERN_ERR, ha, "No valid chap entry found\n");
923  		goto exit_delete_chap;
924  	}
925  
926  	chap_table->cookie = cpu_to_le16(0xFFFF);
927  
928  	offset = FLASH_CHAP_OFFSET |
929  			(chap_tbl_idx * sizeof(struct ql4_chap_table));
930  	ret = qla4xxx_set_flash(ha, chap_dma, offset, chap_size,
931  				FLASH_OPT_RMW_COMMIT);
932  	if (ret == QLA_SUCCESS && ha->chap_list) {
933  		mutex_lock(&ha->chap_sem);
934  		/* Update ha chap_list cache */
935  		memcpy((struct ql4_chap_table *)ha->chap_list + chap_tbl_idx,
936  			chap_table, sizeof(struct ql4_chap_table));
937  		mutex_unlock(&ha->chap_sem);
938  	}
939  	if (ret != QLA_SUCCESS)
940  		ret =  -EINVAL;
941  
942  exit_delete_chap:
943  	dma_pool_free(ha->chap_dma_pool, chap_table, chap_dma);
944  	return ret;
945  }
946  
947  /**
948   * qla4xxx_set_chap_entry - Make chap entry with given information
949   * @shost: pointer to host
950   * @data: chap info - credentials, index and type to make chap entry
951   * @len: length of data
952   *
953   * Add or update chap entry with the given information
954   **/
qla4xxx_set_chap_entry(struct Scsi_Host * shost,void * data,int len)955  static int qla4xxx_set_chap_entry(struct Scsi_Host *shost, void *data, int len)
956  {
957  	struct scsi_qla_host *ha = to_qla_host(shost);
958  	struct iscsi_chap_rec chap_rec;
959  	struct ql4_chap_table *chap_entry = NULL;
960  	struct iscsi_param_info *param_info;
961  	struct nlattr *attr;
962  	int max_chap_entries = 0;
963  	int type;
964  	int rem = len;
965  	int rc = 0;
966  	int size;
967  
968  	memset(&chap_rec, 0, sizeof(chap_rec));
969  
970  	nla_for_each_attr(attr, data, len, rem) {
971  		if (nla_len(attr) < sizeof(*param_info)) {
972  			rc = -EINVAL;
973  			goto exit_set_chap;
974  		}
975  
976  		param_info = nla_data(attr);
977  
978  		switch (param_info->param) {
979  		case ISCSI_CHAP_PARAM_INDEX:
980  			chap_rec.chap_tbl_idx = *(uint16_t *)param_info->value;
981  			break;
982  		case ISCSI_CHAP_PARAM_CHAP_TYPE:
983  			chap_rec.chap_type = param_info->value[0];
984  			break;
985  		case ISCSI_CHAP_PARAM_USERNAME:
986  			size = min_t(size_t, sizeof(chap_rec.username),
987  				     param_info->len);
988  			memcpy(chap_rec.username, param_info->value, size);
989  			break;
990  		case ISCSI_CHAP_PARAM_PASSWORD:
991  			size = min_t(size_t, sizeof(chap_rec.password),
992  				     param_info->len);
993  			memcpy(chap_rec.password, param_info->value, size);
994  			break;
995  		case ISCSI_CHAP_PARAM_PASSWORD_LEN:
996  			chap_rec.password_length = param_info->value[0];
997  			break;
998  		default:
999  			ql4_printk(KERN_ERR, ha,
1000  				   "%s: No such sysfs attribute\n", __func__);
1001  			rc = -ENOSYS;
1002  			goto exit_set_chap;
1003  		}
1004  	}
1005  
1006  	if (chap_rec.chap_type == CHAP_TYPE_IN)
1007  		type = BIDI_CHAP;
1008  	else
1009  		type = LOCAL_CHAP;
1010  
1011  	if (is_qla80XX(ha))
1012  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
1013  				   sizeof(struct ql4_chap_table);
1014  	else
1015  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
1016  
1017  	mutex_lock(&ha->chap_sem);
1018  	if (chap_rec.chap_tbl_idx < max_chap_entries) {
1019  		rc = qla4xxx_get_chap_by_index(ha, chap_rec.chap_tbl_idx,
1020  					       &chap_entry);
1021  		if (!rc) {
1022  			if (!(type == qla4xxx_get_chap_type(chap_entry))) {
1023  				ql4_printk(KERN_INFO, ha,
1024  					   "Type mismatch for CHAP entry %d\n",
1025  					   chap_rec.chap_tbl_idx);
1026  				rc = -EINVAL;
1027  				goto exit_unlock_chap;
1028  			}
1029  
1030  			/* If chap index is in use then don't modify it */
1031  			rc = qla4xxx_is_chap_active(shost,
1032  						    chap_rec.chap_tbl_idx);
1033  			if (rc) {
1034  				ql4_printk(KERN_INFO, ha,
1035  					   "CHAP entry %d is in use\n",
1036  					   chap_rec.chap_tbl_idx);
1037  				rc = -EBUSY;
1038  				goto exit_unlock_chap;
1039  			}
1040  		}
1041  	} else {
1042  		rc = qla4xxx_find_free_chap_index(ha, &chap_rec.chap_tbl_idx);
1043  		if (rc) {
1044  			ql4_printk(KERN_INFO, ha, "CHAP entry not available\n");
1045  			rc = -EBUSY;
1046  			goto exit_unlock_chap;
1047  		}
1048  	}
1049  
1050  	rc = qla4xxx_set_chap(ha, chap_rec.username, chap_rec.password,
1051  			      chap_rec.chap_tbl_idx, type);
1052  
1053  exit_unlock_chap:
1054  	mutex_unlock(&ha->chap_sem);
1055  
1056  exit_set_chap:
1057  	return rc;
1058  }
1059  
1060  
qla4xxx_get_host_stats(struct Scsi_Host * shost,char * buf,int len)1061  static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len)
1062  {
1063  	struct scsi_qla_host *ha = to_qla_host(shost);
1064  	struct iscsi_offload_host_stats *host_stats = NULL;
1065  	int host_stats_size;
1066  	int ret = 0;
1067  	int ddb_idx = 0;
1068  	struct ql_iscsi_stats *ql_iscsi_stats = NULL;
1069  	int stats_size;
1070  	dma_addr_t iscsi_stats_dma;
1071  
1072  	DEBUG2(ql4_printk(KERN_INFO, ha, "Func: %s\n", __func__));
1073  
1074  	host_stats_size = sizeof(struct iscsi_offload_host_stats);
1075  
1076  	if (host_stats_size != len) {
1077  		ql4_printk(KERN_INFO, ha, "%s: host_stats size mismatch expected = %d, is = %d\n",
1078  			   __func__, len, host_stats_size);
1079  		ret = -EINVAL;
1080  		goto exit_host_stats;
1081  	}
1082  	host_stats = (struct iscsi_offload_host_stats *)buf;
1083  
1084  	if (!buf) {
1085  		ret = -ENOMEM;
1086  		goto exit_host_stats;
1087  	}
1088  
1089  	stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
1090  
1091  	ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
1092  					    &iscsi_stats_dma, GFP_KERNEL);
1093  	if (!ql_iscsi_stats) {
1094  		ql4_printk(KERN_ERR, ha,
1095  			   "Unable to allocate memory for iscsi stats\n");
1096  		ret = -ENOMEM;
1097  		goto exit_host_stats;
1098  	}
1099  
1100  	ret =  qla4xxx_get_mgmt_data(ha, ddb_idx, stats_size,
1101  				     iscsi_stats_dma);
1102  	if (ret != QLA_SUCCESS) {
1103  		ql4_printk(KERN_ERR, ha,
1104  			   "Unable to retrieve iscsi stats\n");
1105  		ret = -EIO;
1106  		goto exit_host_stats;
1107  	}
1108  	host_stats->mactx_frames = le64_to_cpu(ql_iscsi_stats->mac_tx_frames);
1109  	host_stats->mactx_bytes = le64_to_cpu(ql_iscsi_stats->mac_tx_bytes);
1110  	host_stats->mactx_multicast_frames =
1111  			le64_to_cpu(ql_iscsi_stats->mac_tx_multicast_frames);
1112  	host_stats->mactx_broadcast_frames =
1113  			le64_to_cpu(ql_iscsi_stats->mac_tx_broadcast_frames);
1114  	host_stats->mactx_pause_frames =
1115  			le64_to_cpu(ql_iscsi_stats->mac_tx_pause_frames);
1116  	host_stats->mactx_control_frames =
1117  			le64_to_cpu(ql_iscsi_stats->mac_tx_control_frames);
1118  	host_stats->mactx_deferral =
1119  			le64_to_cpu(ql_iscsi_stats->mac_tx_deferral);
1120  	host_stats->mactx_excess_deferral =
1121  			le64_to_cpu(ql_iscsi_stats->mac_tx_excess_deferral);
1122  	host_stats->mactx_late_collision =
1123  			le64_to_cpu(ql_iscsi_stats->mac_tx_late_collision);
1124  	host_stats->mactx_abort	= le64_to_cpu(ql_iscsi_stats->mac_tx_abort);
1125  	host_stats->mactx_single_collision =
1126  			le64_to_cpu(ql_iscsi_stats->mac_tx_single_collision);
1127  	host_stats->mactx_multiple_collision =
1128  			le64_to_cpu(ql_iscsi_stats->mac_tx_multiple_collision);
1129  	host_stats->mactx_collision =
1130  			le64_to_cpu(ql_iscsi_stats->mac_tx_collision);
1131  	host_stats->mactx_frames_dropped =
1132  			le64_to_cpu(ql_iscsi_stats->mac_tx_frames_dropped);
1133  	host_stats->mactx_jumbo_frames =
1134  			le64_to_cpu(ql_iscsi_stats->mac_tx_jumbo_frames);
1135  	host_stats->macrx_frames = le64_to_cpu(ql_iscsi_stats->mac_rx_frames);
1136  	host_stats->macrx_bytes = le64_to_cpu(ql_iscsi_stats->mac_rx_bytes);
1137  	host_stats->macrx_unknown_control_frames =
1138  		le64_to_cpu(ql_iscsi_stats->mac_rx_unknown_control_frames);
1139  	host_stats->macrx_pause_frames =
1140  			le64_to_cpu(ql_iscsi_stats->mac_rx_pause_frames);
1141  	host_stats->macrx_control_frames =
1142  			le64_to_cpu(ql_iscsi_stats->mac_rx_control_frames);
1143  	host_stats->macrx_dribble =
1144  			le64_to_cpu(ql_iscsi_stats->mac_rx_dribble);
1145  	host_stats->macrx_frame_length_error =
1146  			le64_to_cpu(ql_iscsi_stats->mac_rx_frame_length_error);
1147  	host_stats->macrx_jabber = le64_to_cpu(ql_iscsi_stats->mac_rx_jabber);
1148  	host_stats->macrx_carrier_sense_error =
1149  		le64_to_cpu(ql_iscsi_stats->mac_rx_carrier_sense_error);
1150  	host_stats->macrx_frame_discarded =
1151  			le64_to_cpu(ql_iscsi_stats->mac_rx_frame_discarded);
1152  	host_stats->macrx_frames_dropped =
1153  			le64_to_cpu(ql_iscsi_stats->mac_rx_frames_dropped);
1154  	host_stats->mac_crc_error = le64_to_cpu(ql_iscsi_stats->mac_crc_error);
1155  	host_stats->mac_encoding_error =
1156  			le64_to_cpu(ql_iscsi_stats->mac_encoding_error);
1157  	host_stats->macrx_length_error_large =
1158  			le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_large);
1159  	host_stats->macrx_length_error_small =
1160  			le64_to_cpu(ql_iscsi_stats->mac_rx_length_error_small);
1161  	host_stats->macrx_multicast_frames =
1162  			le64_to_cpu(ql_iscsi_stats->mac_rx_multicast_frames);
1163  	host_stats->macrx_broadcast_frames =
1164  			le64_to_cpu(ql_iscsi_stats->mac_rx_broadcast_frames);
1165  	host_stats->iptx_packets = le64_to_cpu(ql_iscsi_stats->ip_tx_packets);
1166  	host_stats->iptx_bytes = le64_to_cpu(ql_iscsi_stats->ip_tx_bytes);
1167  	host_stats->iptx_fragments =
1168  			le64_to_cpu(ql_iscsi_stats->ip_tx_fragments);
1169  	host_stats->iprx_packets = le64_to_cpu(ql_iscsi_stats->ip_rx_packets);
1170  	host_stats->iprx_bytes = le64_to_cpu(ql_iscsi_stats->ip_rx_bytes);
1171  	host_stats->iprx_fragments =
1172  			le64_to_cpu(ql_iscsi_stats->ip_rx_fragments);
1173  	host_stats->ip_datagram_reassembly =
1174  			le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly);
1175  	host_stats->ip_invalid_address_error =
1176  			le64_to_cpu(ql_iscsi_stats->ip_invalid_address_error);
1177  	host_stats->ip_error_packets =
1178  			le64_to_cpu(ql_iscsi_stats->ip_error_packets);
1179  	host_stats->ip_fragrx_overlap =
1180  			le64_to_cpu(ql_iscsi_stats->ip_fragrx_overlap);
1181  	host_stats->ip_fragrx_outoforder =
1182  			le64_to_cpu(ql_iscsi_stats->ip_fragrx_outoforder);
1183  	host_stats->ip_datagram_reassembly_timeout =
1184  		le64_to_cpu(ql_iscsi_stats->ip_datagram_reassembly_timeout);
1185  	host_stats->ipv6tx_packets =
1186  			le64_to_cpu(ql_iscsi_stats->ipv6_tx_packets);
1187  	host_stats->ipv6tx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_tx_bytes);
1188  	host_stats->ipv6tx_fragments =
1189  			le64_to_cpu(ql_iscsi_stats->ipv6_tx_fragments);
1190  	host_stats->ipv6rx_packets =
1191  			le64_to_cpu(ql_iscsi_stats->ipv6_rx_packets);
1192  	host_stats->ipv6rx_bytes = le64_to_cpu(ql_iscsi_stats->ipv6_rx_bytes);
1193  	host_stats->ipv6rx_fragments =
1194  			le64_to_cpu(ql_iscsi_stats->ipv6_rx_fragments);
1195  	host_stats->ipv6_datagram_reassembly =
1196  			le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly);
1197  	host_stats->ipv6_invalid_address_error =
1198  		le64_to_cpu(ql_iscsi_stats->ipv6_invalid_address_error);
1199  	host_stats->ipv6_error_packets =
1200  			le64_to_cpu(ql_iscsi_stats->ipv6_error_packets);
1201  	host_stats->ipv6_fragrx_overlap =
1202  			le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_overlap);
1203  	host_stats->ipv6_fragrx_outoforder =
1204  			le64_to_cpu(ql_iscsi_stats->ipv6_fragrx_outoforder);
1205  	host_stats->ipv6_datagram_reassembly_timeout =
1206  		le64_to_cpu(ql_iscsi_stats->ipv6_datagram_reassembly_timeout);
1207  	host_stats->tcptx_segments =
1208  			le64_to_cpu(ql_iscsi_stats->tcp_tx_segments);
1209  	host_stats->tcptx_bytes	= le64_to_cpu(ql_iscsi_stats->tcp_tx_bytes);
1210  	host_stats->tcprx_segments =
1211  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segments);
1212  	host_stats->tcprx_byte = le64_to_cpu(ql_iscsi_stats->tcp_rx_byte);
1213  	host_stats->tcp_duplicate_ack_retx =
1214  			le64_to_cpu(ql_iscsi_stats->tcp_duplicate_ack_retx);
1215  	host_stats->tcp_retx_timer_expired =
1216  			le64_to_cpu(ql_iscsi_stats->tcp_retx_timer_expired);
1217  	host_stats->tcprx_duplicate_ack	=
1218  			le64_to_cpu(ql_iscsi_stats->tcp_rx_duplicate_ack);
1219  	host_stats->tcprx_pure_ackr =
1220  			le64_to_cpu(ql_iscsi_stats->tcp_rx_pure_ackr);
1221  	host_stats->tcptx_delayed_ack =
1222  			le64_to_cpu(ql_iscsi_stats->tcp_tx_delayed_ack);
1223  	host_stats->tcptx_pure_ack =
1224  			le64_to_cpu(ql_iscsi_stats->tcp_tx_pure_ack);
1225  	host_stats->tcprx_segment_error =
1226  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_error);
1227  	host_stats->tcprx_segment_outoforder =
1228  			le64_to_cpu(ql_iscsi_stats->tcp_rx_segment_outoforder);
1229  	host_stats->tcprx_window_probe =
1230  			le64_to_cpu(ql_iscsi_stats->tcp_rx_window_probe);
1231  	host_stats->tcprx_window_update =
1232  			le64_to_cpu(ql_iscsi_stats->tcp_rx_window_update);
1233  	host_stats->tcptx_window_probe_persist =
1234  		le64_to_cpu(ql_iscsi_stats->tcp_tx_window_probe_persist);
1235  	host_stats->ecc_error_correction =
1236  			le64_to_cpu(ql_iscsi_stats->ecc_error_correction);
1237  	host_stats->iscsi_pdu_tx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_tx);
1238  	host_stats->iscsi_data_bytes_tx =
1239  			le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_tx);
1240  	host_stats->iscsi_pdu_rx = le64_to_cpu(ql_iscsi_stats->iscsi_pdu_rx);
1241  	host_stats->iscsi_data_bytes_rx	=
1242  			le64_to_cpu(ql_iscsi_stats->iscsi_data_bytes_rx);
1243  	host_stats->iscsi_io_completed =
1244  			le64_to_cpu(ql_iscsi_stats->iscsi_io_completed);
1245  	host_stats->iscsi_unexpected_io_rx =
1246  			le64_to_cpu(ql_iscsi_stats->iscsi_unexpected_io_rx);
1247  	host_stats->iscsi_format_error =
1248  			le64_to_cpu(ql_iscsi_stats->iscsi_format_error);
1249  	host_stats->iscsi_hdr_digest_error =
1250  			le64_to_cpu(ql_iscsi_stats->iscsi_hdr_digest_error);
1251  	host_stats->iscsi_data_digest_error =
1252  			le64_to_cpu(ql_iscsi_stats->iscsi_data_digest_error);
1253  	host_stats->iscsi_sequence_error =
1254  			le64_to_cpu(ql_iscsi_stats->iscsi_sequence_error);
1255  exit_host_stats:
1256  	if (ql_iscsi_stats)
1257  		dma_free_coherent(&ha->pdev->dev, stats_size,
1258  				  ql_iscsi_stats, iscsi_stats_dma);
1259  
1260  	ql4_printk(KERN_INFO, ha, "%s: Get host stats done\n",
1261  		   __func__);
1262  	return ret;
1263  }
1264  
qla4xxx_get_iface_param(struct iscsi_iface * iface,enum iscsi_param_type param_type,int param,char * buf)1265  static int qla4xxx_get_iface_param(struct iscsi_iface *iface,
1266  				   enum iscsi_param_type param_type,
1267  				   int param, char *buf)
1268  {
1269  	struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
1270  	struct scsi_qla_host *ha = to_qla_host(shost);
1271  	int ival;
1272  	char *pval = NULL;
1273  	int len = -ENOSYS;
1274  
1275  	if (param_type == ISCSI_NET_PARAM) {
1276  		switch (param) {
1277  		case ISCSI_NET_PARAM_IPV4_ADDR:
1278  			len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address);
1279  			break;
1280  		case ISCSI_NET_PARAM_IPV4_SUBNET:
1281  			len = sprintf(buf, "%pI4\n",
1282  				      &ha->ip_config.subnet_mask);
1283  			break;
1284  		case ISCSI_NET_PARAM_IPV4_GW:
1285  			len = sprintf(buf, "%pI4\n", &ha->ip_config.gateway);
1286  			break;
1287  		case ISCSI_NET_PARAM_IFACE_ENABLE:
1288  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1289  				OP_STATE(ha->ip_config.ipv4_options,
1290  					 IPOPT_IPV4_PROTOCOL_ENABLE, pval);
1291  			} else {
1292  				OP_STATE(ha->ip_config.ipv6_options,
1293  					 IPV6_OPT_IPV6_PROTOCOL_ENABLE, pval);
1294  			}
1295  
1296  			len = sprintf(buf, "%s\n", pval);
1297  			break;
1298  		case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
1299  			len = sprintf(buf, "%s\n",
1300  				      (ha->ip_config.tcp_options &
1301  				       TCPOPT_DHCP_ENABLE) ?
1302  				      "dhcp" : "static");
1303  			break;
1304  		case ISCSI_NET_PARAM_IPV6_ADDR:
1305  			if (iface->iface_num == 0)
1306  				len = sprintf(buf, "%pI6\n",
1307  					      &ha->ip_config.ipv6_addr0);
1308  			if (iface->iface_num == 1)
1309  				len = sprintf(buf, "%pI6\n",
1310  					      &ha->ip_config.ipv6_addr1);
1311  			break;
1312  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
1313  			len = sprintf(buf, "%pI6\n",
1314  				      &ha->ip_config.ipv6_link_local_addr);
1315  			break;
1316  		case ISCSI_NET_PARAM_IPV6_ROUTER:
1317  			len = sprintf(buf, "%pI6\n",
1318  				      &ha->ip_config.ipv6_default_router_addr);
1319  			break;
1320  		case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
1321  			pval = (ha->ip_config.ipv6_addl_options &
1322  				IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE) ?
1323  				"nd" : "static";
1324  
1325  			len = sprintf(buf, "%s\n", pval);
1326  			break;
1327  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
1328  			pval = (ha->ip_config.ipv6_addl_options &
1329  				IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR) ?
1330  				"auto" : "static";
1331  
1332  			len = sprintf(buf, "%s\n", pval);
1333  			break;
1334  		case ISCSI_NET_PARAM_VLAN_ID:
1335  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1336  				ival = ha->ip_config.ipv4_vlan_tag &
1337  				       ISCSI_MAX_VLAN_ID;
1338  			else
1339  				ival = ha->ip_config.ipv6_vlan_tag &
1340  				       ISCSI_MAX_VLAN_ID;
1341  
1342  			len = sprintf(buf, "%d\n", ival);
1343  			break;
1344  		case ISCSI_NET_PARAM_VLAN_PRIORITY:
1345  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1346  				ival = (ha->ip_config.ipv4_vlan_tag >> 13) &
1347  				       ISCSI_MAX_VLAN_PRIORITY;
1348  			else
1349  				ival = (ha->ip_config.ipv6_vlan_tag >> 13) &
1350  				       ISCSI_MAX_VLAN_PRIORITY;
1351  
1352  			len = sprintf(buf, "%d\n", ival);
1353  			break;
1354  		case ISCSI_NET_PARAM_VLAN_ENABLED:
1355  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1356  				OP_STATE(ha->ip_config.ipv4_options,
1357  					 IPOPT_VLAN_TAGGING_ENABLE, pval);
1358  			} else {
1359  				OP_STATE(ha->ip_config.ipv6_options,
1360  					 IPV6_OPT_VLAN_TAGGING_ENABLE, pval);
1361  			}
1362  			len = sprintf(buf, "%s\n", pval);
1363  			break;
1364  		case ISCSI_NET_PARAM_MTU:
1365  			len = sprintf(buf, "%d\n", ha->ip_config.eth_mtu_size);
1366  			break;
1367  		case ISCSI_NET_PARAM_PORT:
1368  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1369  				len = sprintf(buf, "%d\n",
1370  					      ha->ip_config.ipv4_port);
1371  			else
1372  				len = sprintf(buf, "%d\n",
1373  					      ha->ip_config.ipv6_port);
1374  			break;
1375  		case ISCSI_NET_PARAM_IPADDR_STATE:
1376  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1377  				pval = iscsi_get_ipaddress_state_name(
1378  						ha->ip_config.ipv4_addr_state);
1379  			} else {
1380  				if (iface->iface_num == 0)
1381  					pval = iscsi_get_ipaddress_state_name(
1382  						ha->ip_config.ipv6_addr0_state);
1383  				else if (iface->iface_num == 1)
1384  					pval = iscsi_get_ipaddress_state_name(
1385  						ha->ip_config.ipv6_addr1_state);
1386  			}
1387  
1388  			len = sprintf(buf, "%s\n", pval);
1389  			break;
1390  		case ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE:
1391  			pval = iscsi_get_ipaddress_state_name(
1392  					ha->ip_config.ipv6_link_local_state);
1393  			len = sprintf(buf, "%s\n", pval);
1394  			break;
1395  		case ISCSI_NET_PARAM_IPV6_ROUTER_STATE:
1396  			pval = iscsi_get_router_state_name(
1397  				      ha->ip_config.ipv6_default_router_state);
1398  			len = sprintf(buf, "%s\n", pval);
1399  			break;
1400  		case ISCSI_NET_PARAM_DELAYED_ACK_EN:
1401  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1402  				OP_STATE(~ha->ip_config.tcp_options,
1403  					 TCPOPT_DELAYED_ACK_DISABLE, pval);
1404  			} else {
1405  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
1406  					 IPV6_TCPOPT_DELAYED_ACK_DISABLE, pval);
1407  			}
1408  			len = sprintf(buf, "%s\n", pval);
1409  			break;
1410  		case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
1411  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1412  				OP_STATE(~ha->ip_config.tcp_options,
1413  					 TCPOPT_NAGLE_ALGO_DISABLE, pval);
1414  			} else {
1415  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
1416  					 IPV6_TCPOPT_NAGLE_ALGO_DISABLE, pval);
1417  			}
1418  			len = sprintf(buf, "%s\n", pval);
1419  			break;
1420  		case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
1421  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1422  				OP_STATE(~ha->ip_config.tcp_options,
1423  					 TCPOPT_WINDOW_SCALE_DISABLE, pval);
1424  			} else {
1425  				OP_STATE(~ha->ip_config.ipv6_tcp_options,
1426  					 IPV6_TCPOPT_WINDOW_SCALE_DISABLE,
1427  					 pval);
1428  			}
1429  			len = sprintf(buf, "%s\n", pval);
1430  			break;
1431  		case ISCSI_NET_PARAM_TCP_WSF:
1432  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1433  				len = sprintf(buf, "%d\n",
1434  					      ha->ip_config.tcp_wsf);
1435  			else
1436  				len = sprintf(buf, "%d\n",
1437  					      ha->ip_config.ipv6_tcp_wsf);
1438  			break;
1439  		case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
1440  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1441  				ival = (ha->ip_config.tcp_options &
1442  					TCPOPT_TIMER_SCALE) >> 1;
1443  			else
1444  				ival = (ha->ip_config.ipv6_tcp_options &
1445  					IPV6_TCPOPT_TIMER_SCALE) >> 1;
1446  
1447  			len = sprintf(buf, "%d\n", ival);
1448  			break;
1449  		case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
1450  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1451  				OP_STATE(ha->ip_config.tcp_options,
1452  					 TCPOPT_TIMESTAMP_ENABLE, pval);
1453  			} else {
1454  				OP_STATE(ha->ip_config.ipv6_tcp_options,
1455  					 IPV6_TCPOPT_TIMESTAMP_EN, pval);
1456  			}
1457  			len = sprintf(buf, "%s\n", pval);
1458  			break;
1459  		case ISCSI_NET_PARAM_CACHE_ID:
1460  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4)
1461  				len = sprintf(buf, "%d\n",
1462  					      ha->ip_config.ipv4_cache_id);
1463  			else
1464  				len = sprintf(buf, "%d\n",
1465  					      ha->ip_config.ipv6_cache_id);
1466  			break;
1467  		case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
1468  			OP_STATE(ha->ip_config.tcp_options,
1469  				 TCPOPT_DNS_SERVER_IP_EN, pval);
1470  
1471  			len = sprintf(buf, "%s\n", pval);
1472  			break;
1473  		case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
1474  			OP_STATE(ha->ip_config.tcp_options,
1475  				 TCPOPT_SLP_DA_INFO_EN, pval);
1476  
1477  			len = sprintf(buf, "%s\n", pval);
1478  			break;
1479  		case ISCSI_NET_PARAM_IPV4_TOS_EN:
1480  			OP_STATE(ha->ip_config.ipv4_options,
1481  				 IPOPT_IPV4_TOS_EN, pval);
1482  
1483  			len = sprintf(buf, "%s\n", pval);
1484  			break;
1485  		case ISCSI_NET_PARAM_IPV4_TOS:
1486  			len = sprintf(buf, "%d\n", ha->ip_config.ipv4_tos);
1487  			break;
1488  		case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
1489  			OP_STATE(ha->ip_config.ipv4_options,
1490  				 IPOPT_GRAT_ARP_EN, pval);
1491  
1492  			len = sprintf(buf, "%s\n", pval);
1493  			break;
1494  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
1495  			OP_STATE(ha->ip_config.ipv4_options, IPOPT_ALT_CID_EN,
1496  				 pval);
1497  
1498  			len = sprintf(buf, "%s\n", pval);
1499  			break;
1500  		case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
1501  			pval = (ha->ip_config.ipv4_alt_cid_len) ?
1502  			       (char *)ha->ip_config.ipv4_alt_cid : "";
1503  
1504  			len = sprintf(buf, "%s\n", pval);
1505  			break;
1506  		case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
1507  			OP_STATE(ha->ip_config.ipv4_options,
1508  				 IPOPT_REQ_VID_EN, pval);
1509  
1510  			len = sprintf(buf, "%s\n", pval);
1511  			break;
1512  		case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
1513  			OP_STATE(ha->ip_config.ipv4_options,
1514  				 IPOPT_USE_VID_EN, pval);
1515  
1516  			len = sprintf(buf, "%s\n", pval);
1517  			break;
1518  		case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
1519  			pval = (ha->ip_config.ipv4_vid_len) ?
1520  			       (char *)ha->ip_config.ipv4_vid : "";
1521  
1522  			len = sprintf(buf, "%s\n", pval);
1523  			break;
1524  		case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
1525  			OP_STATE(ha->ip_config.ipv4_options,
1526  				 IPOPT_LEARN_IQN_EN, pval);
1527  
1528  			len = sprintf(buf, "%s\n", pval);
1529  			break;
1530  		case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
1531  			OP_STATE(~ha->ip_config.ipv4_options,
1532  				 IPOPT_FRAGMENTATION_DISABLE, pval);
1533  
1534  			len = sprintf(buf, "%s\n", pval);
1535  			break;
1536  		case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
1537  			OP_STATE(ha->ip_config.ipv4_options,
1538  				 IPOPT_IN_FORWARD_EN, pval);
1539  
1540  			len = sprintf(buf, "%s\n", pval);
1541  			break;
1542  		case ISCSI_NET_PARAM_REDIRECT_EN:
1543  			if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
1544  				OP_STATE(ha->ip_config.ipv4_options,
1545  					 IPOPT_ARP_REDIRECT_EN, pval);
1546  			} else {
1547  				OP_STATE(ha->ip_config.ipv6_options,
1548  					 IPV6_OPT_REDIRECT_EN, pval);
1549  			}
1550  			len = sprintf(buf, "%s\n", pval);
1551  			break;
1552  		case ISCSI_NET_PARAM_IPV4_TTL:
1553  			len = sprintf(buf, "%d\n", ha->ip_config.ipv4_ttl);
1554  			break;
1555  		case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
1556  			OP_STATE(ha->ip_config.ipv6_options,
1557  				 IPV6_OPT_GRAT_NEIGHBOR_ADV_EN, pval);
1558  
1559  			len = sprintf(buf, "%s\n", pval);
1560  			break;
1561  		case ISCSI_NET_PARAM_IPV6_MLD_EN:
1562  			OP_STATE(ha->ip_config.ipv6_addl_options,
1563  				 IPV6_ADDOPT_MLD_EN, pval);
1564  
1565  			len = sprintf(buf, "%s\n", pval);
1566  			break;
1567  		case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
1568  			len = sprintf(buf, "%u\n", ha->ip_config.ipv6_flow_lbl);
1569  			break;
1570  		case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
1571  			len = sprintf(buf, "%d\n",
1572  				      ha->ip_config.ipv6_traffic_class);
1573  			break;
1574  		case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
1575  			len = sprintf(buf, "%d\n",
1576  				      ha->ip_config.ipv6_hop_limit);
1577  			break;
1578  		case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
1579  			len = sprintf(buf, "%d\n",
1580  				      ha->ip_config.ipv6_nd_reach_time);
1581  			break;
1582  		case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
1583  			len = sprintf(buf, "%d\n",
1584  				      ha->ip_config.ipv6_nd_rexmit_timer);
1585  			break;
1586  		case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
1587  			len = sprintf(buf, "%d\n",
1588  				      ha->ip_config.ipv6_nd_stale_timeout);
1589  			break;
1590  		case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
1591  			len = sprintf(buf, "%d\n",
1592  				      ha->ip_config.ipv6_dup_addr_detect_count);
1593  			break;
1594  		case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
1595  			len = sprintf(buf, "%d\n",
1596  				      ha->ip_config.ipv6_gw_advrt_mtu);
1597  			break;
1598  		default:
1599  			len = -ENOSYS;
1600  		}
1601  	} else if (param_type == ISCSI_IFACE_PARAM) {
1602  		switch (param) {
1603  		case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
1604  			len = sprintf(buf, "%d\n", ha->ip_config.def_timeout);
1605  			break;
1606  		case ISCSI_IFACE_PARAM_HDRDGST_EN:
1607  			OP_STATE(ha->ip_config.iscsi_options,
1608  				 ISCSIOPTS_HEADER_DIGEST_EN, pval);
1609  
1610  			len = sprintf(buf, "%s\n", pval);
1611  			break;
1612  		case ISCSI_IFACE_PARAM_DATADGST_EN:
1613  			OP_STATE(ha->ip_config.iscsi_options,
1614  				 ISCSIOPTS_DATA_DIGEST_EN, pval);
1615  
1616  			len = sprintf(buf, "%s\n", pval);
1617  			break;
1618  		case ISCSI_IFACE_PARAM_IMM_DATA_EN:
1619  			OP_STATE(ha->ip_config.iscsi_options,
1620  				 ISCSIOPTS_IMMEDIATE_DATA_EN, pval);
1621  
1622  			len = sprintf(buf, "%s\n", pval);
1623  			break;
1624  		case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
1625  			OP_STATE(ha->ip_config.iscsi_options,
1626  				 ISCSIOPTS_INITIAL_R2T_EN, pval);
1627  
1628  			len = sprintf(buf, "%s\n", pval);
1629  			break;
1630  		case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
1631  			OP_STATE(ha->ip_config.iscsi_options,
1632  				 ISCSIOPTS_DATA_SEQ_INORDER_EN, pval);
1633  
1634  			len = sprintf(buf, "%s\n", pval);
1635  			break;
1636  		case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
1637  			OP_STATE(ha->ip_config.iscsi_options,
1638  				 ISCSIOPTS_DATA_PDU_INORDER_EN, pval);
1639  
1640  			len = sprintf(buf, "%s\n", pval);
1641  			break;
1642  		case ISCSI_IFACE_PARAM_ERL:
1643  			len = sprintf(buf, "%d\n",
1644  				      (ha->ip_config.iscsi_options &
1645  				       ISCSIOPTS_ERL));
1646  			break;
1647  		case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
1648  			len = sprintf(buf, "%u\n",
1649  				      ha->ip_config.iscsi_max_pdu_size *
1650  				      BYTE_UNITS);
1651  			break;
1652  		case ISCSI_IFACE_PARAM_FIRST_BURST:
1653  			len = sprintf(buf, "%u\n",
1654  				      ha->ip_config.iscsi_first_burst_len *
1655  				      BYTE_UNITS);
1656  			break;
1657  		case ISCSI_IFACE_PARAM_MAX_R2T:
1658  			len = sprintf(buf, "%d\n",
1659  				      ha->ip_config.iscsi_max_outstnd_r2t);
1660  			break;
1661  		case ISCSI_IFACE_PARAM_MAX_BURST:
1662  			len = sprintf(buf, "%u\n",
1663  				      ha->ip_config.iscsi_max_burst_len *
1664  				      BYTE_UNITS);
1665  			break;
1666  		case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
1667  			OP_STATE(ha->ip_config.iscsi_options,
1668  				 ISCSIOPTS_CHAP_AUTH_EN, pval);
1669  
1670  			len = sprintf(buf, "%s\n", pval);
1671  			break;
1672  		case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
1673  			OP_STATE(ha->ip_config.iscsi_options,
1674  				 ISCSIOPTS_BIDI_CHAP_EN, pval);
1675  
1676  			len = sprintf(buf, "%s\n", pval);
1677  			break;
1678  		case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
1679  			OP_STATE(ha->ip_config.iscsi_options,
1680  				 ISCSIOPTS_DISCOVERY_AUTH_EN, pval);
1681  
1682  			len = sprintf(buf, "%s\n", pval);
1683  			break;
1684  		case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
1685  			OP_STATE(ha->ip_config.iscsi_options,
1686  				 ISCSIOPTS_DISCOVERY_LOGOUT_EN, pval);
1687  
1688  			len = sprintf(buf, "%s\n", pval);
1689  			break;
1690  		case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
1691  			OP_STATE(ha->ip_config.iscsi_options,
1692  				 ISCSIOPTS_STRICT_LOGIN_COMP_EN, pval);
1693  
1694  			len = sprintf(buf, "%s\n", pval);
1695  			break;
1696  		case ISCSI_IFACE_PARAM_INITIATOR_NAME:
1697  			len = sprintf(buf, "%s\n", ha->ip_config.iscsi_name);
1698  			break;
1699  		default:
1700  			len = -ENOSYS;
1701  		}
1702  	}
1703  
1704  	return len;
1705  }
1706  
1707  static struct iscsi_endpoint *
qla4xxx_ep_connect(struct Scsi_Host * shost,struct sockaddr * dst_addr,int non_blocking)1708  qla4xxx_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
1709  		   int non_blocking)
1710  {
1711  	int ret;
1712  	struct iscsi_endpoint *ep;
1713  	struct qla_endpoint *qla_ep;
1714  	struct scsi_qla_host *ha;
1715  	struct sockaddr_in *addr;
1716  	struct sockaddr_in6 *addr6;
1717  
1718  	if (!shost) {
1719  		ret = -ENXIO;
1720  		pr_err("%s: shost is NULL\n", __func__);
1721  		return ERR_PTR(ret);
1722  	}
1723  
1724  	ha = iscsi_host_priv(shost);
1725  	ep = iscsi_create_endpoint(sizeof(struct qla_endpoint));
1726  	if (!ep) {
1727  		ret = -ENOMEM;
1728  		return ERR_PTR(ret);
1729  	}
1730  
1731  	qla_ep = ep->dd_data;
1732  	memset(qla_ep, 0, sizeof(struct qla_endpoint));
1733  	if (dst_addr->sa_family == AF_INET) {
1734  		memcpy(&qla_ep->dst_addr, dst_addr, sizeof(struct sockaddr_in));
1735  		addr = (struct sockaddr_in *)&qla_ep->dst_addr;
1736  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI4\n", __func__,
1737  				  (char *)&addr->sin_addr));
1738  	} else if (dst_addr->sa_family == AF_INET6) {
1739  		memcpy(&qla_ep->dst_addr, dst_addr,
1740  		       sizeof(struct sockaddr_in6));
1741  		addr6 = (struct sockaddr_in6 *)&qla_ep->dst_addr;
1742  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: %pI6\n", __func__,
1743  				  (char *)&addr6->sin6_addr));
1744  	} else {
1745  		ql4_printk(KERN_WARNING, ha, "%s: Invalid endpoint\n",
1746  			   __func__);
1747  	}
1748  
1749  	qla_ep->host = shost;
1750  
1751  	return ep;
1752  }
1753  
qla4xxx_ep_poll(struct iscsi_endpoint * ep,int timeout_ms)1754  static int qla4xxx_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1755  {
1756  	struct qla_endpoint *qla_ep;
1757  	struct scsi_qla_host *ha;
1758  	int ret = 0;
1759  
1760  	qla_ep = ep->dd_data;
1761  	ha = to_qla_host(qla_ep->host);
1762  	DEBUG2(pr_info_ratelimited("%s: host: %ld\n", __func__, ha->host_no));
1763  
1764  	if (adapter_up(ha) && !test_bit(AF_BUILD_DDB_LIST, &ha->flags))
1765  		ret = 1;
1766  
1767  	return ret;
1768  }
1769  
qla4xxx_ep_disconnect(struct iscsi_endpoint * ep)1770  static void qla4xxx_ep_disconnect(struct iscsi_endpoint *ep)
1771  {
1772  	struct qla_endpoint *qla_ep;
1773  	struct scsi_qla_host *ha;
1774  
1775  	qla_ep = ep->dd_data;
1776  	ha = to_qla_host(qla_ep->host);
1777  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1778  			  ha->host_no));
1779  	iscsi_destroy_endpoint(ep);
1780  }
1781  
qla4xxx_get_ep_param(struct iscsi_endpoint * ep,enum iscsi_param param,char * buf)1782  static int qla4xxx_get_ep_param(struct iscsi_endpoint *ep,
1783  				enum iscsi_param param,
1784  				char *buf)
1785  {
1786  	struct qla_endpoint *qla_ep = ep->dd_data;
1787  	struct sockaddr *dst_addr;
1788  	struct scsi_qla_host *ha;
1789  
1790  	if (!qla_ep)
1791  		return -ENOTCONN;
1792  
1793  	ha = to_qla_host(qla_ep->host);
1794  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1795  			  ha->host_no));
1796  
1797  	switch (param) {
1798  	case ISCSI_PARAM_CONN_PORT:
1799  	case ISCSI_PARAM_CONN_ADDRESS:
1800  		dst_addr = (struct sockaddr *)&qla_ep->dst_addr;
1801  		if (!dst_addr)
1802  			return -ENOTCONN;
1803  
1804  		return iscsi_conn_get_addr_param((struct sockaddr_storage *)
1805  						 &qla_ep->dst_addr, param, buf);
1806  	default:
1807  		return -ENOSYS;
1808  	}
1809  }
1810  
qla4xxx_conn_get_stats(struct iscsi_cls_conn * cls_conn,struct iscsi_stats * stats)1811  static void qla4xxx_conn_get_stats(struct iscsi_cls_conn *cls_conn,
1812  				   struct iscsi_stats *stats)
1813  {
1814  	struct iscsi_session *sess;
1815  	struct iscsi_cls_session *cls_sess;
1816  	struct ddb_entry *ddb_entry;
1817  	struct scsi_qla_host *ha;
1818  	struct ql_iscsi_stats *ql_iscsi_stats;
1819  	int stats_size;
1820  	int ret;
1821  	dma_addr_t iscsi_stats_dma;
1822  
1823  	cls_sess = iscsi_conn_to_session(cls_conn);
1824  	sess = cls_sess->dd_data;
1825  	ddb_entry = sess->dd_data;
1826  	ha = ddb_entry->ha;
1827  
1828  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
1829  			  ha->host_no));
1830  	stats_size = PAGE_ALIGN(sizeof(struct ql_iscsi_stats));
1831  	/* Allocate memory */
1832  	ql_iscsi_stats = dma_alloc_coherent(&ha->pdev->dev, stats_size,
1833  					    &iscsi_stats_dma, GFP_KERNEL);
1834  	if (!ql_iscsi_stats) {
1835  		ql4_printk(KERN_ERR, ha,
1836  			   "Unable to allocate memory for iscsi stats\n");
1837  		goto exit_get_stats;
1838  	}
1839  
1840  	ret =  qla4xxx_get_mgmt_data(ha, ddb_entry->fw_ddb_index, stats_size,
1841  				     iscsi_stats_dma);
1842  	if (ret != QLA_SUCCESS) {
1843  		ql4_printk(KERN_ERR, ha,
1844  			   "Unable to retrieve iscsi stats\n");
1845  		goto free_stats;
1846  	}
1847  
1848  	/* octets */
1849  	stats->txdata_octets = le64_to_cpu(ql_iscsi_stats->tx_data_octets);
1850  	stats->rxdata_octets = le64_to_cpu(ql_iscsi_stats->rx_data_octets);
1851  	/* xmit pdus */
1852  	stats->noptx_pdus = le32_to_cpu(ql_iscsi_stats->tx_nopout_pdus);
1853  	stats->scsicmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_cmd_pdus);
1854  	stats->tmfcmd_pdus = le32_to_cpu(ql_iscsi_stats->tx_tmf_cmd_pdus);
1855  	stats->login_pdus = le32_to_cpu(ql_iscsi_stats->tx_login_cmd_pdus);
1856  	stats->text_pdus = le32_to_cpu(ql_iscsi_stats->tx_text_cmd_pdus);
1857  	stats->dataout_pdus = le32_to_cpu(ql_iscsi_stats->tx_scsi_write_pdus);
1858  	stats->logout_pdus = le32_to_cpu(ql_iscsi_stats->tx_logout_cmd_pdus);
1859  	stats->snack_pdus = le32_to_cpu(ql_iscsi_stats->tx_snack_req_pdus);
1860  	/* recv pdus */
1861  	stats->noprx_pdus = le32_to_cpu(ql_iscsi_stats->rx_nopin_pdus);
1862  	stats->scsirsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_resp_pdus);
1863  	stats->tmfrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_tmf_resp_pdus);
1864  	stats->textrsp_pdus = le32_to_cpu(ql_iscsi_stats->rx_text_resp_pdus);
1865  	stats->datain_pdus = le32_to_cpu(ql_iscsi_stats->rx_scsi_read_pdus);
1866  	stats->logoutrsp_pdus =
1867  			le32_to_cpu(ql_iscsi_stats->rx_logout_resp_pdus);
1868  	stats->r2t_pdus = le32_to_cpu(ql_iscsi_stats->rx_r2t_pdus);
1869  	stats->async_pdus = le32_to_cpu(ql_iscsi_stats->rx_async_pdus);
1870  	stats->rjt_pdus = le32_to_cpu(ql_iscsi_stats->rx_reject_pdus);
1871  
1872  free_stats:
1873  	dma_free_coherent(&ha->pdev->dev, stats_size, ql_iscsi_stats,
1874  			  iscsi_stats_dma);
1875  exit_get_stats:
1876  	return;
1877  }
1878  
qla4xxx_eh_cmd_timed_out(struct scsi_cmnd * sc)1879  static enum scsi_timeout_action qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc)
1880  {
1881  	struct iscsi_cls_session *session;
1882  	unsigned long flags;
1883  	enum scsi_timeout_action ret = SCSI_EH_NOT_HANDLED;
1884  
1885  	session = starget_to_session(scsi_target(sc->device));
1886  
1887  	spin_lock_irqsave(&session->lock, flags);
1888  	if (session->state == ISCSI_SESSION_FAILED)
1889  		ret = SCSI_EH_RESET_TIMER;
1890  	spin_unlock_irqrestore(&session->lock, flags);
1891  
1892  	return ret;
1893  }
1894  
qla4xxx_set_port_speed(struct Scsi_Host * shost)1895  static void qla4xxx_set_port_speed(struct Scsi_Host *shost)
1896  {
1897  	struct scsi_qla_host *ha = to_qla_host(shost);
1898  	struct iscsi_cls_host *ihost = shost->shost_data;
1899  	uint32_t speed = ISCSI_PORT_SPEED_UNKNOWN;
1900  
1901  	qla4xxx_get_firmware_state(ha);
1902  
1903  	switch (ha->addl_fw_state & 0x0F00) {
1904  	case FW_ADDSTATE_LINK_SPEED_10MBPS:
1905  		speed = ISCSI_PORT_SPEED_10MBPS;
1906  		break;
1907  	case FW_ADDSTATE_LINK_SPEED_100MBPS:
1908  		speed = ISCSI_PORT_SPEED_100MBPS;
1909  		break;
1910  	case FW_ADDSTATE_LINK_SPEED_1GBPS:
1911  		speed = ISCSI_PORT_SPEED_1GBPS;
1912  		break;
1913  	case FW_ADDSTATE_LINK_SPEED_10GBPS:
1914  		speed = ISCSI_PORT_SPEED_10GBPS;
1915  		break;
1916  	}
1917  	ihost->port_speed = speed;
1918  }
1919  
qla4xxx_set_port_state(struct Scsi_Host * shost)1920  static void qla4xxx_set_port_state(struct Scsi_Host *shost)
1921  {
1922  	struct scsi_qla_host *ha = to_qla_host(shost);
1923  	struct iscsi_cls_host *ihost = shost->shost_data;
1924  	uint32_t state = ISCSI_PORT_STATE_DOWN;
1925  
1926  	if (test_bit(AF_LINK_UP, &ha->flags))
1927  		state = ISCSI_PORT_STATE_UP;
1928  
1929  	ihost->port_state = state;
1930  }
1931  
qla4xxx_host_get_param(struct Scsi_Host * shost,enum iscsi_host_param param,char * buf)1932  static int qla4xxx_host_get_param(struct Scsi_Host *shost,
1933  				  enum iscsi_host_param param, char *buf)
1934  {
1935  	struct scsi_qla_host *ha = to_qla_host(shost);
1936  	int len;
1937  
1938  	switch (param) {
1939  	case ISCSI_HOST_PARAM_HWADDRESS:
1940  		len = sysfs_format_mac(buf, ha->my_mac, MAC_ADDR_LEN);
1941  		break;
1942  	case ISCSI_HOST_PARAM_IPADDRESS:
1943  		len = sprintf(buf, "%pI4\n", &ha->ip_config.ip_address);
1944  		break;
1945  	case ISCSI_HOST_PARAM_INITIATOR_NAME:
1946  		len = sprintf(buf, "%s\n", ha->name_string);
1947  		break;
1948  	case ISCSI_HOST_PARAM_PORT_STATE:
1949  		qla4xxx_set_port_state(shost);
1950  		len = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
1951  		break;
1952  	case ISCSI_HOST_PARAM_PORT_SPEED:
1953  		qla4xxx_set_port_speed(shost);
1954  		len = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
1955  		break;
1956  	default:
1957  		return -ENOSYS;
1958  	}
1959  
1960  	return len;
1961  }
1962  
qla4xxx_create_ipv4_iface(struct scsi_qla_host * ha)1963  static void qla4xxx_create_ipv4_iface(struct scsi_qla_host *ha)
1964  {
1965  	if (ha->iface_ipv4)
1966  		return;
1967  
1968  	/* IPv4 */
1969  	ha->iface_ipv4 = iscsi_create_iface(ha->host,
1970  					    &qla4xxx_iscsi_transport,
1971  					    ISCSI_IFACE_TYPE_IPV4, 0, 0);
1972  	if (!ha->iface_ipv4)
1973  		ql4_printk(KERN_ERR, ha, "Could not create IPv4 iSCSI "
1974  			   "iface0.\n");
1975  }
1976  
qla4xxx_create_ipv6_iface(struct scsi_qla_host * ha)1977  static void qla4xxx_create_ipv6_iface(struct scsi_qla_host *ha)
1978  {
1979  	if (!ha->iface_ipv6_0)
1980  		/* IPv6 iface-0 */
1981  		ha->iface_ipv6_0 = iscsi_create_iface(ha->host,
1982  						      &qla4xxx_iscsi_transport,
1983  						      ISCSI_IFACE_TYPE_IPV6, 0,
1984  						      0);
1985  	if (!ha->iface_ipv6_0)
1986  		ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
1987  			   "iface0.\n");
1988  
1989  	if (!ha->iface_ipv6_1)
1990  		/* IPv6 iface-1 */
1991  		ha->iface_ipv6_1 = iscsi_create_iface(ha->host,
1992  						      &qla4xxx_iscsi_transport,
1993  						      ISCSI_IFACE_TYPE_IPV6, 1,
1994  						      0);
1995  	if (!ha->iface_ipv6_1)
1996  		ql4_printk(KERN_ERR, ha, "Could not create IPv6 iSCSI "
1997  			   "iface1.\n");
1998  }
1999  
qla4xxx_create_ifaces(struct scsi_qla_host * ha)2000  static void qla4xxx_create_ifaces(struct scsi_qla_host *ha)
2001  {
2002  	if (ha->ip_config.ipv4_options & IPOPT_IPV4_PROTOCOL_ENABLE)
2003  		qla4xxx_create_ipv4_iface(ha);
2004  
2005  	if (ha->ip_config.ipv6_options & IPV6_OPT_IPV6_PROTOCOL_ENABLE)
2006  		qla4xxx_create_ipv6_iface(ha);
2007  }
2008  
qla4xxx_destroy_ipv4_iface(struct scsi_qla_host * ha)2009  static void qla4xxx_destroy_ipv4_iface(struct scsi_qla_host *ha)
2010  {
2011  	if (ha->iface_ipv4) {
2012  		iscsi_destroy_iface(ha->iface_ipv4);
2013  		ha->iface_ipv4 = NULL;
2014  	}
2015  }
2016  
qla4xxx_destroy_ipv6_iface(struct scsi_qla_host * ha)2017  static void qla4xxx_destroy_ipv6_iface(struct scsi_qla_host *ha)
2018  {
2019  	if (ha->iface_ipv6_0) {
2020  		iscsi_destroy_iface(ha->iface_ipv6_0);
2021  		ha->iface_ipv6_0 = NULL;
2022  	}
2023  	if (ha->iface_ipv6_1) {
2024  		iscsi_destroy_iface(ha->iface_ipv6_1);
2025  		ha->iface_ipv6_1 = NULL;
2026  	}
2027  }
2028  
qla4xxx_destroy_ifaces(struct scsi_qla_host * ha)2029  static void qla4xxx_destroy_ifaces(struct scsi_qla_host *ha)
2030  {
2031  	qla4xxx_destroy_ipv4_iface(ha);
2032  	qla4xxx_destroy_ipv6_iface(ha);
2033  }
2034  
qla4xxx_set_ipv6(struct scsi_qla_host * ha,struct iscsi_iface_param_info * iface_param,struct addr_ctrl_blk * init_fw_cb)2035  static void qla4xxx_set_ipv6(struct scsi_qla_host *ha,
2036  			     struct iscsi_iface_param_info *iface_param,
2037  			     struct addr_ctrl_blk *init_fw_cb)
2038  {
2039  	/*
2040  	 * iface_num 0 is valid for IPv6 Addr, linklocal, router, autocfg.
2041  	 * iface_num 1 is valid only for IPv6 Addr.
2042  	 */
2043  	switch (iface_param->param) {
2044  	case ISCSI_NET_PARAM_IPV6_ADDR:
2045  		if (iface_param->iface_num & 0x1)
2046  			/* IPv6 Addr 1 */
2047  			memcpy(init_fw_cb->ipv6_addr1, iface_param->value,
2048  			       sizeof(init_fw_cb->ipv6_addr1));
2049  		else
2050  			/* IPv6 Addr 0 */
2051  			memcpy(init_fw_cb->ipv6_addr0, iface_param->value,
2052  			       sizeof(init_fw_cb->ipv6_addr0));
2053  		break;
2054  	case ISCSI_NET_PARAM_IPV6_LINKLOCAL:
2055  		if (iface_param->iface_num & 0x1)
2056  			break;
2057  		memcpy(init_fw_cb->ipv6_if_id, &iface_param->value[8],
2058  		       sizeof(init_fw_cb->ipv6_if_id));
2059  		break;
2060  	case ISCSI_NET_PARAM_IPV6_ROUTER:
2061  		if (iface_param->iface_num & 0x1)
2062  			break;
2063  		memcpy(init_fw_cb->ipv6_dflt_rtr_addr, iface_param->value,
2064  		       sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
2065  		break;
2066  	case ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG:
2067  		/* Autocfg applies to even interface */
2068  		if (iface_param->iface_num & 0x1)
2069  			break;
2070  
2071  		if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_DISABLE)
2072  			init_fw_cb->ipv6_addtl_opts &=
2073  				cpu_to_le16(
2074  				  ~IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
2075  		else if (iface_param->value[0] == ISCSI_IPV6_AUTOCFG_ND_ENABLE)
2076  			init_fw_cb->ipv6_addtl_opts |=
2077  				cpu_to_le16(
2078  				  IPV6_ADDOPT_NEIGHBOR_DISCOVERY_ADDR_ENABLE);
2079  		else
2080  			ql4_printk(KERN_ERR, ha,
2081  				   "Invalid autocfg setting for IPv6 addr\n");
2082  		break;
2083  	case ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG:
2084  		/* Autocfg applies to even interface */
2085  		if (iface_param->iface_num & 0x1)
2086  			break;
2087  
2088  		if (iface_param->value[0] ==
2089  		    ISCSI_IPV6_LINKLOCAL_AUTOCFG_ENABLE)
2090  			init_fw_cb->ipv6_addtl_opts |= cpu_to_le16(
2091  					IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
2092  		else if (iface_param->value[0] ==
2093  			 ISCSI_IPV6_LINKLOCAL_AUTOCFG_DISABLE)
2094  			init_fw_cb->ipv6_addtl_opts &= cpu_to_le16(
2095  				       ~IPV6_ADDOPT_AUTOCONFIG_LINK_LOCAL_ADDR);
2096  		else
2097  			ql4_printk(KERN_ERR, ha,
2098  				   "Invalid autocfg setting for IPv6 linklocal addr\n");
2099  		break;
2100  	case ISCSI_NET_PARAM_IPV6_ROUTER_AUTOCFG:
2101  		/* Autocfg applies to even interface */
2102  		if (iface_param->iface_num & 0x1)
2103  			break;
2104  
2105  		if (iface_param->value[0] == ISCSI_IPV6_ROUTER_AUTOCFG_ENABLE)
2106  			memset(init_fw_cb->ipv6_dflt_rtr_addr, 0,
2107  			       sizeof(init_fw_cb->ipv6_dflt_rtr_addr));
2108  		break;
2109  	case ISCSI_NET_PARAM_IFACE_ENABLE:
2110  		if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {
2111  			init_fw_cb->ipv6_opts |=
2112  				cpu_to_le16(IPV6_OPT_IPV6_PROTOCOL_ENABLE);
2113  			qla4xxx_create_ipv6_iface(ha);
2114  		} else {
2115  			init_fw_cb->ipv6_opts &=
2116  				cpu_to_le16(~IPV6_OPT_IPV6_PROTOCOL_ENABLE &
2117  					    0xFFFF);
2118  			qla4xxx_destroy_ipv6_iface(ha);
2119  		}
2120  		break;
2121  	case ISCSI_NET_PARAM_VLAN_TAG:
2122  		if (iface_param->len != sizeof(init_fw_cb->ipv6_vlan_tag))
2123  			break;
2124  		init_fw_cb->ipv6_vlan_tag =
2125  				cpu_to_be16(*(uint16_t *)iface_param->value);
2126  		break;
2127  	case ISCSI_NET_PARAM_VLAN_ENABLED:
2128  		if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
2129  			init_fw_cb->ipv6_opts |=
2130  				cpu_to_le16(IPV6_OPT_VLAN_TAGGING_ENABLE);
2131  		else
2132  			init_fw_cb->ipv6_opts &=
2133  				cpu_to_le16(~IPV6_OPT_VLAN_TAGGING_ENABLE);
2134  		break;
2135  	case ISCSI_NET_PARAM_MTU:
2136  		init_fw_cb->eth_mtu_size =
2137  				cpu_to_le16(*(uint16_t *)iface_param->value);
2138  		break;
2139  	case ISCSI_NET_PARAM_PORT:
2140  		/* Autocfg applies to even interface */
2141  		if (iface_param->iface_num & 0x1)
2142  			break;
2143  
2144  		init_fw_cb->ipv6_port =
2145  				cpu_to_le16(*(uint16_t *)iface_param->value);
2146  		break;
2147  	case ISCSI_NET_PARAM_DELAYED_ACK_EN:
2148  		if (iface_param->iface_num & 0x1)
2149  			break;
2150  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2151  			init_fw_cb->ipv6_tcp_opts |=
2152  				cpu_to_le16(IPV6_TCPOPT_DELAYED_ACK_DISABLE);
2153  		else
2154  			init_fw_cb->ipv6_tcp_opts &=
2155  				cpu_to_le16(~IPV6_TCPOPT_DELAYED_ACK_DISABLE &
2156  					    0xFFFF);
2157  		break;
2158  	case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
2159  		if (iface_param->iface_num & 0x1)
2160  			break;
2161  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2162  			init_fw_cb->ipv6_tcp_opts |=
2163  				cpu_to_le16(IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
2164  		else
2165  			init_fw_cb->ipv6_tcp_opts &=
2166  				cpu_to_le16(~IPV6_TCPOPT_NAGLE_ALGO_DISABLE);
2167  		break;
2168  	case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
2169  		if (iface_param->iface_num & 0x1)
2170  			break;
2171  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2172  			init_fw_cb->ipv6_tcp_opts |=
2173  				cpu_to_le16(IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
2174  		else
2175  			init_fw_cb->ipv6_tcp_opts &=
2176  				cpu_to_le16(~IPV6_TCPOPT_WINDOW_SCALE_DISABLE);
2177  		break;
2178  	case ISCSI_NET_PARAM_TCP_WSF:
2179  		if (iface_param->iface_num & 0x1)
2180  			break;
2181  		init_fw_cb->ipv6_tcp_wsf = iface_param->value[0];
2182  		break;
2183  	case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
2184  		if (iface_param->iface_num & 0x1)
2185  			break;
2186  		init_fw_cb->ipv6_tcp_opts &=
2187  					cpu_to_le16(~IPV6_TCPOPT_TIMER_SCALE);
2188  		init_fw_cb->ipv6_tcp_opts |=
2189  				cpu_to_le16((iface_param->value[0] << 1) &
2190  					    IPV6_TCPOPT_TIMER_SCALE);
2191  		break;
2192  	case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
2193  		if (iface_param->iface_num & 0x1)
2194  			break;
2195  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2196  			init_fw_cb->ipv6_tcp_opts |=
2197  				cpu_to_le16(IPV6_TCPOPT_TIMESTAMP_EN);
2198  		else
2199  			init_fw_cb->ipv6_tcp_opts &=
2200  				cpu_to_le16(~IPV6_TCPOPT_TIMESTAMP_EN);
2201  		break;
2202  	case ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN:
2203  		if (iface_param->iface_num & 0x1)
2204  			break;
2205  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2206  			init_fw_cb->ipv6_opts |=
2207  				cpu_to_le16(IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
2208  		else
2209  			init_fw_cb->ipv6_opts &=
2210  				cpu_to_le16(~IPV6_OPT_GRAT_NEIGHBOR_ADV_EN);
2211  		break;
2212  	case ISCSI_NET_PARAM_REDIRECT_EN:
2213  		if (iface_param->iface_num & 0x1)
2214  			break;
2215  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2216  			init_fw_cb->ipv6_opts |=
2217  				cpu_to_le16(IPV6_OPT_REDIRECT_EN);
2218  		else
2219  			init_fw_cb->ipv6_opts &=
2220  				cpu_to_le16(~IPV6_OPT_REDIRECT_EN);
2221  		break;
2222  	case ISCSI_NET_PARAM_IPV6_MLD_EN:
2223  		if (iface_param->iface_num & 0x1)
2224  			break;
2225  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2226  			init_fw_cb->ipv6_addtl_opts |=
2227  				cpu_to_le16(IPV6_ADDOPT_MLD_EN);
2228  		else
2229  			init_fw_cb->ipv6_addtl_opts &=
2230  				cpu_to_le16(~IPV6_ADDOPT_MLD_EN);
2231  		break;
2232  	case ISCSI_NET_PARAM_IPV6_FLOW_LABEL:
2233  		if (iface_param->iface_num & 0x1)
2234  			break;
2235  		init_fw_cb->ipv6_flow_lbl =
2236  				cpu_to_le16(*(uint16_t *)iface_param->value);
2237  		break;
2238  	case ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS:
2239  		if (iface_param->iface_num & 0x1)
2240  			break;
2241  		init_fw_cb->ipv6_traffic_class = iface_param->value[0];
2242  		break;
2243  	case ISCSI_NET_PARAM_IPV6_HOP_LIMIT:
2244  		if (iface_param->iface_num & 0x1)
2245  			break;
2246  		init_fw_cb->ipv6_hop_limit = iface_param->value[0];
2247  		break;
2248  	case ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO:
2249  		if (iface_param->iface_num & 0x1)
2250  			break;
2251  		init_fw_cb->ipv6_nd_reach_time =
2252  				cpu_to_le32(*(uint32_t *)iface_param->value);
2253  		break;
2254  	case ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME:
2255  		if (iface_param->iface_num & 0x1)
2256  			break;
2257  		init_fw_cb->ipv6_nd_rexmit_timer =
2258  				cpu_to_le32(*(uint32_t *)iface_param->value);
2259  		break;
2260  	case ISCSI_NET_PARAM_IPV6_ND_STALE_TMO:
2261  		if (iface_param->iface_num & 0x1)
2262  			break;
2263  		init_fw_cb->ipv6_nd_stale_timeout =
2264  				cpu_to_le32(*(uint32_t *)iface_param->value);
2265  		break;
2266  	case ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT:
2267  		if (iface_param->iface_num & 0x1)
2268  			break;
2269  		init_fw_cb->ipv6_dup_addr_detect_count = iface_param->value[0];
2270  		break;
2271  	case ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU:
2272  		if (iface_param->iface_num & 0x1)
2273  			break;
2274  		init_fw_cb->ipv6_gw_advrt_mtu =
2275  				cpu_to_le32(*(uint32_t *)iface_param->value);
2276  		break;
2277  	default:
2278  		ql4_printk(KERN_ERR, ha, "Unknown IPv6 param = %d\n",
2279  			   iface_param->param);
2280  		break;
2281  	}
2282  }
2283  
qla4xxx_set_ipv4(struct scsi_qla_host * ha,struct iscsi_iface_param_info * iface_param,struct addr_ctrl_blk * init_fw_cb)2284  static void qla4xxx_set_ipv4(struct scsi_qla_host *ha,
2285  			     struct iscsi_iface_param_info *iface_param,
2286  			     struct addr_ctrl_blk *init_fw_cb)
2287  {
2288  	switch (iface_param->param) {
2289  	case ISCSI_NET_PARAM_IPV4_ADDR:
2290  		memcpy(init_fw_cb->ipv4_addr, iface_param->value,
2291  		       sizeof(init_fw_cb->ipv4_addr));
2292  		break;
2293  	case ISCSI_NET_PARAM_IPV4_SUBNET:
2294  		memcpy(init_fw_cb->ipv4_subnet,	iface_param->value,
2295  		       sizeof(init_fw_cb->ipv4_subnet));
2296  		break;
2297  	case ISCSI_NET_PARAM_IPV4_GW:
2298  		memcpy(init_fw_cb->ipv4_gw_addr, iface_param->value,
2299  		       sizeof(init_fw_cb->ipv4_gw_addr));
2300  		break;
2301  	case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
2302  		if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP)
2303  			init_fw_cb->ipv4_tcp_opts |=
2304  					cpu_to_le16(TCPOPT_DHCP_ENABLE);
2305  		else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC)
2306  			init_fw_cb->ipv4_tcp_opts &=
2307  					cpu_to_le16(~TCPOPT_DHCP_ENABLE);
2308  		else
2309  			ql4_printk(KERN_ERR, ha, "Invalid IPv4 bootproto\n");
2310  		break;
2311  	case ISCSI_NET_PARAM_IFACE_ENABLE:
2312  		if (iface_param->value[0] == ISCSI_IFACE_ENABLE) {
2313  			init_fw_cb->ipv4_ip_opts |=
2314  				cpu_to_le16(IPOPT_IPV4_PROTOCOL_ENABLE);
2315  			qla4xxx_create_ipv4_iface(ha);
2316  		} else {
2317  			init_fw_cb->ipv4_ip_opts &=
2318  				cpu_to_le16(~IPOPT_IPV4_PROTOCOL_ENABLE &
2319  					    0xFFFF);
2320  			qla4xxx_destroy_ipv4_iface(ha);
2321  		}
2322  		break;
2323  	case ISCSI_NET_PARAM_VLAN_TAG:
2324  		if (iface_param->len != sizeof(init_fw_cb->ipv4_vlan_tag))
2325  			break;
2326  		init_fw_cb->ipv4_vlan_tag =
2327  				cpu_to_be16(*(uint16_t *)iface_param->value);
2328  		break;
2329  	case ISCSI_NET_PARAM_VLAN_ENABLED:
2330  		if (iface_param->value[0] == ISCSI_VLAN_ENABLE)
2331  			init_fw_cb->ipv4_ip_opts |=
2332  					cpu_to_le16(IPOPT_VLAN_TAGGING_ENABLE);
2333  		else
2334  			init_fw_cb->ipv4_ip_opts &=
2335  					cpu_to_le16(~IPOPT_VLAN_TAGGING_ENABLE);
2336  		break;
2337  	case ISCSI_NET_PARAM_MTU:
2338  		init_fw_cb->eth_mtu_size =
2339  				cpu_to_le16(*(uint16_t *)iface_param->value);
2340  		break;
2341  	case ISCSI_NET_PARAM_PORT:
2342  		init_fw_cb->ipv4_port =
2343  				cpu_to_le16(*(uint16_t *)iface_param->value);
2344  		break;
2345  	case ISCSI_NET_PARAM_DELAYED_ACK_EN:
2346  		if (iface_param->iface_num & 0x1)
2347  			break;
2348  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2349  			init_fw_cb->ipv4_tcp_opts |=
2350  				cpu_to_le16(TCPOPT_DELAYED_ACK_DISABLE);
2351  		else
2352  			init_fw_cb->ipv4_tcp_opts &=
2353  				cpu_to_le16(~TCPOPT_DELAYED_ACK_DISABLE &
2354  					    0xFFFF);
2355  		break;
2356  	case ISCSI_NET_PARAM_TCP_NAGLE_DISABLE:
2357  		if (iface_param->iface_num & 0x1)
2358  			break;
2359  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2360  			init_fw_cb->ipv4_tcp_opts |=
2361  				cpu_to_le16(TCPOPT_NAGLE_ALGO_DISABLE);
2362  		else
2363  			init_fw_cb->ipv4_tcp_opts &=
2364  				cpu_to_le16(~TCPOPT_NAGLE_ALGO_DISABLE);
2365  		break;
2366  	case ISCSI_NET_PARAM_TCP_WSF_DISABLE:
2367  		if (iface_param->iface_num & 0x1)
2368  			break;
2369  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2370  			init_fw_cb->ipv4_tcp_opts |=
2371  				cpu_to_le16(TCPOPT_WINDOW_SCALE_DISABLE);
2372  		else
2373  			init_fw_cb->ipv4_tcp_opts &=
2374  				cpu_to_le16(~TCPOPT_WINDOW_SCALE_DISABLE);
2375  		break;
2376  	case ISCSI_NET_PARAM_TCP_WSF:
2377  		if (iface_param->iface_num & 0x1)
2378  			break;
2379  		init_fw_cb->ipv4_tcp_wsf = iface_param->value[0];
2380  		break;
2381  	case ISCSI_NET_PARAM_TCP_TIMER_SCALE:
2382  		if (iface_param->iface_num & 0x1)
2383  			break;
2384  		init_fw_cb->ipv4_tcp_opts &= cpu_to_le16(~TCPOPT_TIMER_SCALE);
2385  		init_fw_cb->ipv4_tcp_opts |=
2386  				cpu_to_le16((iface_param->value[0] << 1) &
2387  					    TCPOPT_TIMER_SCALE);
2388  		break;
2389  	case ISCSI_NET_PARAM_TCP_TIMESTAMP_EN:
2390  		if (iface_param->iface_num & 0x1)
2391  			break;
2392  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2393  			init_fw_cb->ipv4_tcp_opts |=
2394  				cpu_to_le16(TCPOPT_TIMESTAMP_ENABLE);
2395  		else
2396  			init_fw_cb->ipv4_tcp_opts &=
2397  				cpu_to_le16(~TCPOPT_TIMESTAMP_ENABLE);
2398  		break;
2399  	case ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN:
2400  		if (iface_param->iface_num & 0x1)
2401  			break;
2402  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2403  			init_fw_cb->ipv4_tcp_opts |=
2404  				cpu_to_le16(TCPOPT_DNS_SERVER_IP_EN);
2405  		else
2406  			init_fw_cb->ipv4_tcp_opts &=
2407  				cpu_to_le16(~TCPOPT_DNS_SERVER_IP_EN);
2408  		break;
2409  	case ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN:
2410  		if (iface_param->iface_num & 0x1)
2411  			break;
2412  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2413  			init_fw_cb->ipv4_tcp_opts |=
2414  				cpu_to_le16(TCPOPT_SLP_DA_INFO_EN);
2415  		else
2416  			init_fw_cb->ipv4_tcp_opts &=
2417  				cpu_to_le16(~TCPOPT_SLP_DA_INFO_EN);
2418  		break;
2419  	case ISCSI_NET_PARAM_IPV4_TOS_EN:
2420  		if (iface_param->iface_num & 0x1)
2421  			break;
2422  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2423  			init_fw_cb->ipv4_ip_opts |=
2424  				cpu_to_le16(IPOPT_IPV4_TOS_EN);
2425  		else
2426  			init_fw_cb->ipv4_ip_opts &=
2427  				cpu_to_le16(~IPOPT_IPV4_TOS_EN);
2428  		break;
2429  	case ISCSI_NET_PARAM_IPV4_TOS:
2430  		if (iface_param->iface_num & 0x1)
2431  			break;
2432  		init_fw_cb->ipv4_tos = iface_param->value[0];
2433  		break;
2434  	case ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN:
2435  		if (iface_param->iface_num & 0x1)
2436  			break;
2437  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2438  			init_fw_cb->ipv4_ip_opts |=
2439  					cpu_to_le16(IPOPT_GRAT_ARP_EN);
2440  		else
2441  			init_fw_cb->ipv4_ip_opts &=
2442  					cpu_to_le16(~IPOPT_GRAT_ARP_EN);
2443  		break;
2444  	case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN:
2445  		if (iface_param->iface_num & 0x1)
2446  			break;
2447  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2448  			init_fw_cb->ipv4_ip_opts |=
2449  				cpu_to_le16(IPOPT_ALT_CID_EN);
2450  		else
2451  			init_fw_cb->ipv4_ip_opts &=
2452  				cpu_to_le16(~IPOPT_ALT_CID_EN);
2453  		break;
2454  	case ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID:
2455  		if (iface_param->iface_num & 0x1)
2456  			break;
2457  		memcpy(init_fw_cb->ipv4_dhcp_alt_cid, iface_param->value,
2458  		       (sizeof(init_fw_cb->ipv4_dhcp_alt_cid) - 1));
2459  		init_fw_cb->ipv4_dhcp_alt_cid_len =
2460  					strlen(init_fw_cb->ipv4_dhcp_alt_cid);
2461  		break;
2462  	case ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN:
2463  		if (iface_param->iface_num & 0x1)
2464  			break;
2465  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2466  			init_fw_cb->ipv4_ip_opts |=
2467  					cpu_to_le16(IPOPT_REQ_VID_EN);
2468  		else
2469  			init_fw_cb->ipv4_ip_opts &=
2470  					cpu_to_le16(~IPOPT_REQ_VID_EN);
2471  		break;
2472  	case ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN:
2473  		if (iface_param->iface_num & 0x1)
2474  			break;
2475  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2476  			init_fw_cb->ipv4_ip_opts |=
2477  					cpu_to_le16(IPOPT_USE_VID_EN);
2478  		else
2479  			init_fw_cb->ipv4_ip_opts &=
2480  					cpu_to_le16(~IPOPT_USE_VID_EN);
2481  		break;
2482  	case ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID:
2483  		if (iface_param->iface_num & 0x1)
2484  			break;
2485  		memcpy(init_fw_cb->ipv4_dhcp_vid, iface_param->value,
2486  		       (sizeof(init_fw_cb->ipv4_dhcp_vid) - 1));
2487  		init_fw_cb->ipv4_dhcp_vid_len =
2488  					strlen(init_fw_cb->ipv4_dhcp_vid);
2489  		break;
2490  	case ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN:
2491  		if (iface_param->iface_num & 0x1)
2492  			break;
2493  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2494  			init_fw_cb->ipv4_ip_opts |=
2495  					cpu_to_le16(IPOPT_LEARN_IQN_EN);
2496  		else
2497  			init_fw_cb->ipv4_ip_opts &=
2498  					cpu_to_le16(~IPOPT_LEARN_IQN_EN);
2499  		break;
2500  	case ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE:
2501  		if (iface_param->iface_num & 0x1)
2502  			break;
2503  		if (iface_param->value[0] == ISCSI_NET_PARAM_DISABLE)
2504  			init_fw_cb->ipv4_ip_opts |=
2505  				cpu_to_le16(IPOPT_FRAGMENTATION_DISABLE);
2506  		else
2507  			init_fw_cb->ipv4_ip_opts &=
2508  				cpu_to_le16(~IPOPT_FRAGMENTATION_DISABLE);
2509  		break;
2510  	case ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN:
2511  		if (iface_param->iface_num & 0x1)
2512  			break;
2513  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2514  			init_fw_cb->ipv4_ip_opts |=
2515  				cpu_to_le16(IPOPT_IN_FORWARD_EN);
2516  		else
2517  			init_fw_cb->ipv4_ip_opts &=
2518  				cpu_to_le16(~IPOPT_IN_FORWARD_EN);
2519  		break;
2520  	case ISCSI_NET_PARAM_REDIRECT_EN:
2521  		if (iface_param->iface_num & 0x1)
2522  			break;
2523  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2524  			init_fw_cb->ipv4_ip_opts |=
2525  				cpu_to_le16(IPOPT_ARP_REDIRECT_EN);
2526  		else
2527  			init_fw_cb->ipv4_ip_opts &=
2528  				cpu_to_le16(~IPOPT_ARP_REDIRECT_EN);
2529  		break;
2530  	case ISCSI_NET_PARAM_IPV4_TTL:
2531  		if (iface_param->iface_num & 0x1)
2532  			break;
2533  		init_fw_cb->ipv4_ttl = iface_param->value[0];
2534  		break;
2535  	default:
2536  		ql4_printk(KERN_ERR, ha, "Unknown IPv4 param = %d\n",
2537  			   iface_param->param);
2538  		break;
2539  	}
2540  }
2541  
qla4xxx_set_iscsi_param(struct scsi_qla_host * ha,struct iscsi_iface_param_info * iface_param,struct addr_ctrl_blk * init_fw_cb)2542  static void qla4xxx_set_iscsi_param(struct scsi_qla_host *ha,
2543  				    struct iscsi_iface_param_info *iface_param,
2544  				    struct addr_ctrl_blk *init_fw_cb)
2545  {
2546  	switch (iface_param->param) {
2547  	case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO:
2548  		if (iface_param->iface_num & 0x1)
2549  			break;
2550  		init_fw_cb->def_timeout =
2551  				cpu_to_le16(*(uint16_t *)iface_param->value);
2552  		break;
2553  	case ISCSI_IFACE_PARAM_HDRDGST_EN:
2554  		if (iface_param->iface_num & 0x1)
2555  			break;
2556  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2557  			init_fw_cb->iscsi_opts |=
2558  				cpu_to_le16(ISCSIOPTS_HEADER_DIGEST_EN);
2559  		else
2560  			init_fw_cb->iscsi_opts &=
2561  				cpu_to_le16(~ISCSIOPTS_HEADER_DIGEST_EN);
2562  		break;
2563  	case ISCSI_IFACE_PARAM_DATADGST_EN:
2564  		if (iface_param->iface_num & 0x1)
2565  			break;
2566  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2567  			init_fw_cb->iscsi_opts |=
2568  				cpu_to_le16(ISCSIOPTS_DATA_DIGEST_EN);
2569  		else
2570  			init_fw_cb->iscsi_opts &=
2571  				cpu_to_le16(~ISCSIOPTS_DATA_DIGEST_EN);
2572  		break;
2573  	case ISCSI_IFACE_PARAM_IMM_DATA_EN:
2574  		if (iface_param->iface_num & 0x1)
2575  			break;
2576  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2577  			init_fw_cb->iscsi_opts |=
2578  				cpu_to_le16(ISCSIOPTS_IMMEDIATE_DATA_EN);
2579  		else
2580  			init_fw_cb->iscsi_opts &=
2581  				cpu_to_le16(~ISCSIOPTS_IMMEDIATE_DATA_EN);
2582  		break;
2583  	case ISCSI_IFACE_PARAM_INITIAL_R2T_EN:
2584  		if (iface_param->iface_num & 0x1)
2585  			break;
2586  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2587  			init_fw_cb->iscsi_opts |=
2588  				cpu_to_le16(ISCSIOPTS_INITIAL_R2T_EN);
2589  		else
2590  			init_fw_cb->iscsi_opts &=
2591  				cpu_to_le16(~ISCSIOPTS_INITIAL_R2T_EN);
2592  		break;
2593  	case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN:
2594  		if (iface_param->iface_num & 0x1)
2595  			break;
2596  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2597  			init_fw_cb->iscsi_opts |=
2598  				cpu_to_le16(ISCSIOPTS_DATA_SEQ_INORDER_EN);
2599  		else
2600  			init_fw_cb->iscsi_opts &=
2601  				cpu_to_le16(~ISCSIOPTS_DATA_SEQ_INORDER_EN);
2602  		break;
2603  	case ISCSI_IFACE_PARAM_PDU_INORDER_EN:
2604  		if (iface_param->iface_num & 0x1)
2605  			break;
2606  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2607  			init_fw_cb->iscsi_opts |=
2608  				cpu_to_le16(ISCSIOPTS_DATA_PDU_INORDER_EN);
2609  		else
2610  			init_fw_cb->iscsi_opts &=
2611  				cpu_to_le16(~ISCSIOPTS_DATA_PDU_INORDER_EN);
2612  		break;
2613  	case ISCSI_IFACE_PARAM_ERL:
2614  		if (iface_param->iface_num & 0x1)
2615  			break;
2616  		init_fw_cb->iscsi_opts &= cpu_to_le16(~ISCSIOPTS_ERL);
2617  		init_fw_cb->iscsi_opts |= cpu_to_le16(iface_param->value[0] &
2618  						      ISCSIOPTS_ERL);
2619  		break;
2620  	case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH:
2621  		if (iface_param->iface_num & 0x1)
2622  			break;
2623  		init_fw_cb->iscsi_max_pdu_size =
2624  				cpu_to_le32(*(uint32_t *)iface_param->value) /
2625  				BYTE_UNITS;
2626  		break;
2627  	case ISCSI_IFACE_PARAM_FIRST_BURST:
2628  		if (iface_param->iface_num & 0x1)
2629  			break;
2630  		init_fw_cb->iscsi_fburst_len =
2631  				cpu_to_le32(*(uint32_t *)iface_param->value) /
2632  				BYTE_UNITS;
2633  		break;
2634  	case ISCSI_IFACE_PARAM_MAX_R2T:
2635  		if (iface_param->iface_num & 0x1)
2636  			break;
2637  		init_fw_cb->iscsi_max_outstnd_r2t =
2638  				cpu_to_le16(*(uint16_t *)iface_param->value);
2639  		break;
2640  	case ISCSI_IFACE_PARAM_MAX_BURST:
2641  		if (iface_param->iface_num & 0x1)
2642  			break;
2643  		init_fw_cb->iscsi_max_burst_len =
2644  				cpu_to_le32(*(uint32_t *)iface_param->value) /
2645  				BYTE_UNITS;
2646  		break;
2647  	case ISCSI_IFACE_PARAM_CHAP_AUTH_EN:
2648  		if (iface_param->iface_num & 0x1)
2649  			break;
2650  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2651  			init_fw_cb->iscsi_opts |=
2652  				cpu_to_le16(ISCSIOPTS_CHAP_AUTH_EN);
2653  		else
2654  			init_fw_cb->iscsi_opts &=
2655  				cpu_to_le16(~ISCSIOPTS_CHAP_AUTH_EN);
2656  		break;
2657  	case ISCSI_IFACE_PARAM_BIDI_CHAP_EN:
2658  		if (iface_param->iface_num & 0x1)
2659  			break;
2660  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2661  			init_fw_cb->iscsi_opts |=
2662  				cpu_to_le16(ISCSIOPTS_BIDI_CHAP_EN);
2663  		else
2664  			init_fw_cb->iscsi_opts &=
2665  				cpu_to_le16(~ISCSIOPTS_BIDI_CHAP_EN);
2666  		break;
2667  	case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL:
2668  		if (iface_param->iface_num & 0x1)
2669  			break;
2670  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2671  			init_fw_cb->iscsi_opts |=
2672  				cpu_to_le16(ISCSIOPTS_DISCOVERY_AUTH_EN);
2673  		else
2674  			init_fw_cb->iscsi_opts &=
2675  				cpu_to_le16(~ISCSIOPTS_DISCOVERY_AUTH_EN);
2676  		break;
2677  	case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN:
2678  		if (iface_param->iface_num & 0x1)
2679  			break;
2680  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2681  			init_fw_cb->iscsi_opts |=
2682  				cpu_to_le16(ISCSIOPTS_DISCOVERY_LOGOUT_EN);
2683  		else
2684  			init_fw_cb->iscsi_opts &=
2685  				cpu_to_le16(~ISCSIOPTS_DISCOVERY_LOGOUT_EN);
2686  		break;
2687  	case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN:
2688  		if (iface_param->iface_num & 0x1)
2689  			break;
2690  		if (iface_param->value[0] == ISCSI_NET_PARAM_ENABLE)
2691  			init_fw_cb->iscsi_opts |=
2692  				cpu_to_le16(ISCSIOPTS_STRICT_LOGIN_COMP_EN);
2693  		else
2694  			init_fw_cb->iscsi_opts &=
2695  				cpu_to_le16(~ISCSIOPTS_STRICT_LOGIN_COMP_EN);
2696  		break;
2697  	default:
2698  		ql4_printk(KERN_ERR, ha, "Unknown iscsi param = %d\n",
2699  			   iface_param->param);
2700  		break;
2701  	}
2702  }
2703  
2704  static void
qla4xxx_initcb_to_acb(struct addr_ctrl_blk * init_fw_cb)2705  qla4xxx_initcb_to_acb(struct addr_ctrl_blk *init_fw_cb)
2706  {
2707  	struct addr_ctrl_blk_def *acb;
2708  	acb = (struct addr_ctrl_blk_def *)init_fw_cb;
2709  	memset(acb->reserved1, 0, sizeof(acb->reserved1));
2710  	memset(acb->reserved2, 0, sizeof(acb->reserved2));
2711  	memset(acb->reserved3, 0, sizeof(acb->reserved3));
2712  	memset(acb->reserved4, 0, sizeof(acb->reserved4));
2713  	memset(acb->reserved5, 0, sizeof(acb->reserved5));
2714  	memset(acb->reserved6, 0, sizeof(acb->reserved6));
2715  	memset(acb->reserved7, 0, sizeof(acb->reserved7));
2716  	memset(acb->reserved8, 0, sizeof(acb->reserved8));
2717  	memset(acb->reserved9, 0, sizeof(acb->reserved9));
2718  	memset(acb->reserved10, 0, sizeof(acb->reserved10));
2719  	memset(acb->reserved11, 0, sizeof(acb->reserved11));
2720  	memset(acb->reserved12, 0, sizeof(acb->reserved12));
2721  	memset(acb->reserved13, 0, sizeof(acb->reserved13));
2722  	memset(acb->reserved14, 0, sizeof(acb->reserved14));
2723  	memset(acb->reserved15, 0, sizeof(acb->reserved15));
2724  }
2725  
2726  static int
qla4xxx_iface_set_param(struct Scsi_Host * shost,void * data,uint32_t len)2727  qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len)
2728  {
2729  	struct scsi_qla_host *ha = to_qla_host(shost);
2730  	int rval = 0;
2731  	struct iscsi_iface_param_info *iface_param = NULL;
2732  	struct addr_ctrl_blk *init_fw_cb = NULL;
2733  	dma_addr_t init_fw_cb_dma;
2734  	uint32_t mbox_cmd[MBOX_REG_COUNT];
2735  	uint32_t mbox_sts[MBOX_REG_COUNT];
2736  	uint32_t rem = len;
2737  	struct nlattr *attr;
2738  
2739  	init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
2740  					sizeof(struct addr_ctrl_blk),
2741  					&init_fw_cb_dma, GFP_KERNEL);
2742  	if (!init_fw_cb) {
2743  		ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb\n",
2744  			   __func__);
2745  		return -ENOMEM;
2746  	}
2747  
2748  	memset(&mbox_cmd, 0, sizeof(mbox_cmd));
2749  	memset(&mbox_sts, 0, sizeof(mbox_sts));
2750  
2751  	if (qla4xxx_get_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma)) {
2752  		ql4_printk(KERN_ERR, ha, "%s: get ifcb failed\n", __func__);
2753  		rval = -EIO;
2754  		goto exit_init_fw_cb;
2755  	}
2756  
2757  	nla_for_each_attr(attr, data, len, rem) {
2758  		if (nla_len(attr) < sizeof(*iface_param)) {
2759  			rval = -EINVAL;
2760  			goto exit_init_fw_cb;
2761  		}
2762  
2763  		iface_param = nla_data(attr);
2764  
2765  		if (iface_param->param_type == ISCSI_NET_PARAM) {
2766  			switch (iface_param->iface_type) {
2767  			case ISCSI_IFACE_TYPE_IPV4:
2768  				switch (iface_param->iface_num) {
2769  				case 0:
2770  					qla4xxx_set_ipv4(ha, iface_param,
2771  							 init_fw_cb);
2772  					break;
2773  				default:
2774  				/* Cannot have more than one IPv4 interface */
2775  					ql4_printk(KERN_ERR, ha,
2776  						   "Invalid IPv4 iface number = %d\n",
2777  						   iface_param->iface_num);
2778  					break;
2779  				}
2780  				break;
2781  			case ISCSI_IFACE_TYPE_IPV6:
2782  				switch (iface_param->iface_num) {
2783  				case 0:
2784  				case 1:
2785  					qla4xxx_set_ipv6(ha, iface_param,
2786  							 init_fw_cb);
2787  					break;
2788  				default:
2789  				/* Cannot have more than two IPv6 interface */
2790  					ql4_printk(KERN_ERR, ha,
2791  						   "Invalid IPv6 iface number = %d\n",
2792  						   iface_param->iface_num);
2793  					break;
2794  				}
2795  				break;
2796  			default:
2797  				ql4_printk(KERN_ERR, ha,
2798  					   "Invalid iface type\n");
2799  				break;
2800  			}
2801  		} else if (iface_param->param_type == ISCSI_IFACE_PARAM) {
2802  				qla4xxx_set_iscsi_param(ha, iface_param,
2803  							init_fw_cb);
2804  		} else {
2805  			continue;
2806  		}
2807  	}
2808  
2809  	init_fw_cb->cookie = cpu_to_le32(0x11BEAD5A);
2810  
2811  	rval = qla4xxx_set_flash(ha, init_fw_cb_dma, FLASH_SEGMENT_IFCB,
2812  				 sizeof(struct addr_ctrl_blk),
2813  				 FLASH_OPT_RMW_COMMIT);
2814  	if (rval != QLA_SUCCESS) {
2815  		ql4_printk(KERN_ERR, ha, "%s: set flash mbx failed\n",
2816  			   __func__);
2817  		rval = -EIO;
2818  		goto exit_init_fw_cb;
2819  	}
2820  
2821  	rval = qla4xxx_disable_acb(ha);
2822  	if (rval != QLA_SUCCESS) {
2823  		ql4_printk(KERN_ERR, ha, "%s: disable acb mbx failed\n",
2824  			   __func__);
2825  		rval = -EIO;
2826  		goto exit_init_fw_cb;
2827  	}
2828  
2829  	wait_for_completion_timeout(&ha->disable_acb_comp,
2830  				    DISABLE_ACB_TOV * HZ);
2831  
2832  	qla4xxx_initcb_to_acb(init_fw_cb);
2833  
2834  	rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb_dma);
2835  	if (rval != QLA_SUCCESS) {
2836  		ql4_printk(KERN_ERR, ha, "%s: set acb mbx failed\n",
2837  			   __func__);
2838  		rval = -EIO;
2839  		goto exit_init_fw_cb;
2840  	}
2841  
2842  	memset(init_fw_cb, 0, sizeof(struct addr_ctrl_blk));
2843  	qla4xxx_update_local_ifcb(ha, &mbox_cmd[0], &mbox_sts[0], init_fw_cb,
2844  				  init_fw_cb_dma);
2845  
2846  exit_init_fw_cb:
2847  	dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk),
2848  			  init_fw_cb, init_fw_cb_dma);
2849  
2850  	return rval;
2851  }
2852  
qla4xxx_session_get_param(struct iscsi_cls_session * cls_sess,enum iscsi_param param,char * buf)2853  static int qla4xxx_session_get_param(struct iscsi_cls_session *cls_sess,
2854  				     enum iscsi_param param, char *buf)
2855  {
2856  	struct iscsi_session *sess = cls_sess->dd_data;
2857  	struct ddb_entry *ddb_entry = sess->dd_data;
2858  	struct scsi_qla_host *ha = ddb_entry->ha;
2859  	struct iscsi_cls_conn *cls_conn = ddb_entry->conn;
2860  	struct ql4_chap_table chap_tbl;
2861  	int rval, len;
2862  	uint16_t idx;
2863  
2864  	memset(&chap_tbl, 0, sizeof(chap_tbl));
2865  	switch (param) {
2866  	case ISCSI_PARAM_CHAP_IN_IDX:
2867  		rval = qla4xxx_get_chap_index(ha, sess->username_in,
2868  					      sess->password_in, BIDI_CHAP,
2869  					      &idx);
2870  		if (rval)
2871  			len = sprintf(buf, "\n");
2872  		else
2873  			len = sprintf(buf, "%hu\n", idx);
2874  		break;
2875  	case ISCSI_PARAM_CHAP_OUT_IDX:
2876  		if (ddb_entry->ddb_type == FLASH_DDB) {
2877  			if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
2878  				idx = ddb_entry->chap_tbl_idx;
2879  				rval = QLA_SUCCESS;
2880  			} else {
2881  				rval = QLA_ERROR;
2882  			}
2883  		} else {
2884  			rval = qla4xxx_get_chap_index(ha, sess->username,
2885  						      sess->password,
2886  						      LOCAL_CHAP, &idx);
2887  		}
2888  		if (rval)
2889  			len = sprintf(buf, "\n");
2890  		else
2891  			len = sprintf(buf, "%hu\n", idx);
2892  		break;
2893  	case ISCSI_PARAM_USERNAME:
2894  	case ISCSI_PARAM_PASSWORD:
2895  		/* First, populate session username and password for FLASH DDB,
2896  		 * if not already done. This happens when session login fails
2897  		 * for a FLASH DDB.
2898  		 */
2899  		if (ddb_entry->ddb_type == FLASH_DDB &&
2900  		    ddb_entry->chap_tbl_idx != INVALID_ENTRY &&
2901  		    !sess->username && !sess->password) {
2902  			idx = ddb_entry->chap_tbl_idx;
2903  			rval = qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
2904  							    chap_tbl.secret,
2905  							    idx);
2906  			if (!rval) {
2907  				iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
2908  						(char *)chap_tbl.name,
2909  						strlen((char *)chap_tbl.name));
2910  				iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
2911  						(char *)chap_tbl.secret,
2912  						chap_tbl.secret_len);
2913  			}
2914  		}
2915  		fallthrough;
2916  	default:
2917  		return iscsi_session_get_param(cls_sess, param, buf);
2918  	}
2919  
2920  	return len;
2921  }
2922  
qla4xxx_conn_get_param(struct iscsi_cls_conn * cls_conn,enum iscsi_param param,char * buf)2923  static int qla4xxx_conn_get_param(struct iscsi_cls_conn *cls_conn,
2924  				  enum iscsi_param param, char *buf)
2925  {
2926  	struct iscsi_conn *conn;
2927  	struct qla_conn *qla_conn;
2928  	struct sockaddr *dst_addr;
2929  
2930  	conn = cls_conn->dd_data;
2931  	qla_conn = conn->dd_data;
2932  	dst_addr = (struct sockaddr *)&qla_conn->qla_ep->dst_addr;
2933  
2934  	switch (param) {
2935  	case ISCSI_PARAM_CONN_PORT:
2936  	case ISCSI_PARAM_CONN_ADDRESS:
2937  		return iscsi_conn_get_addr_param((struct sockaddr_storage *)
2938  						 dst_addr, param, buf);
2939  	default:
2940  		return iscsi_conn_get_param(cls_conn, param, buf);
2941  	}
2942  }
2943  
qla4xxx_get_ddb_index(struct scsi_qla_host * ha,uint16_t * ddb_index)2944  int qla4xxx_get_ddb_index(struct scsi_qla_host *ha, uint16_t *ddb_index)
2945  {
2946  	uint32_t mbx_sts = 0;
2947  	uint16_t tmp_ddb_index;
2948  	int ret;
2949  
2950  get_ddb_index:
2951  	tmp_ddb_index = find_first_zero_bit(ha->ddb_idx_map, MAX_DDB_ENTRIES);
2952  
2953  	if (tmp_ddb_index >= MAX_DDB_ENTRIES) {
2954  		DEBUG2(ql4_printk(KERN_INFO, ha,
2955  				  "Free DDB index not available\n"));
2956  		ret = QLA_ERROR;
2957  		goto exit_get_ddb_index;
2958  	}
2959  
2960  	if (test_and_set_bit(tmp_ddb_index, ha->ddb_idx_map))
2961  		goto get_ddb_index;
2962  
2963  	DEBUG2(ql4_printk(KERN_INFO, ha,
2964  			  "Found a free DDB index at %d\n", tmp_ddb_index));
2965  	ret = qla4xxx_req_ddb_entry(ha, tmp_ddb_index, &mbx_sts);
2966  	if (ret == QLA_ERROR) {
2967  		if (mbx_sts == MBOX_STS_COMMAND_ERROR) {
2968  			ql4_printk(KERN_INFO, ha,
2969  				   "DDB index = %d not available trying next\n",
2970  				   tmp_ddb_index);
2971  			goto get_ddb_index;
2972  		}
2973  		DEBUG2(ql4_printk(KERN_INFO, ha,
2974  				  "Free FW DDB not available\n"));
2975  	}
2976  
2977  	*ddb_index = tmp_ddb_index;
2978  
2979  exit_get_ddb_index:
2980  	return ret;
2981  }
2982  
qla4xxx_match_ipaddress(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry,char * existing_ipaddr,char * user_ipaddr)2983  static int qla4xxx_match_ipaddress(struct scsi_qla_host *ha,
2984  				   struct ddb_entry *ddb_entry,
2985  				   char *existing_ipaddr,
2986  				   char *user_ipaddr)
2987  {
2988  	uint8_t dst_ipaddr[IPv6_ADDR_LEN];
2989  	char formatted_ipaddr[DDB_IPADDR_LEN];
2990  	int status = QLA_SUCCESS, ret = 0;
2991  
2992  	if (ddb_entry->fw_ddb_entry.options & DDB_OPT_IPV6_DEVICE) {
2993  		ret = in6_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
2994  			       '\0', NULL);
2995  		if (ret == 0) {
2996  			status = QLA_ERROR;
2997  			goto out_match;
2998  		}
2999  		ret = sprintf(formatted_ipaddr, "%pI6", dst_ipaddr);
3000  	} else {
3001  		ret = in4_pton(user_ipaddr, strlen(user_ipaddr), dst_ipaddr,
3002  			       '\0', NULL);
3003  		if (ret == 0) {
3004  			status = QLA_ERROR;
3005  			goto out_match;
3006  		}
3007  		ret = sprintf(formatted_ipaddr, "%pI4", dst_ipaddr);
3008  	}
3009  
3010  	if (strcmp(existing_ipaddr, formatted_ipaddr))
3011  		status = QLA_ERROR;
3012  
3013  out_match:
3014  	return status;
3015  }
3016  
qla4xxx_match_fwdb_session(struct scsi_qla_host * ha,struct iscsi_cls_conn * cls_conn)3017  static int qla4xxx_match_fwdb_session(struct scsi_qla_host *ha,
3018  				      struct iscsi_cls_conn *cls_conn)
3019  {
3020  	int idx = 0, max_ddbs, rval;
3021  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
3022  	struct iscsi_session *sess, *existing_sess;
3023  	struct iscsi_conn *conn, *existing_conn;
3024  	struct ddb_entry *ddb_entry;
3025  
3026  	sess = cls_sess->dd_data;
3027  	conn = cls_conn->dd_data;
3028  
3029  	if (sess->targetname == NULL ||
3030  	    conn->persistent_address == NULL ||
3031  	    conn->persistent_port == 0)
3032  		return QLA_ERROR;
3033  
3034  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
3035  				     MAX_DEV_DB_ENTRIES;
3036  
3037  	for (idx = 0; idx < max_ddbs; idx++) {
3038  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
3039  		if (ddb_entry == NULL)
3040  			continue;
3041  
3042  		if (ddb_entry->ddb_type != FLASH_DDB)
3043  			continue;
3044  
3045  		existing_sess = ddb_entry->sess->dd_data;
3046  		existing_conn = ddb_entry->conn->dd_data;
3047  
3048  		if (existing_sess->targetname == NULL ||
3049  		    existing_conn->persistent_address == NULL ||
3050  		    existing_conn->persistent_port == 0)
3051  			continue;
3052  
3053  		DEBUG2(ql4_printk(KERN_INFO, ha,
3054  				  "IQN = %s User IQN = %s\n",
3055  				  existing_sess->targetname,
3056  				  sess->targetname));
3057  
3058  		DEBUG2(ql4_printk(KERN_INFO, ha,
3059  				  "IP = %s User IP = %s\n",
3060  				  existing_conn->persistent_address,
3061  				  conn->persistent_address));
3062  
3063  		DEBUG2(ql4_printk(KERN_INFO, ha,
3064  				  "Port = %d User Port = %d\n",
3065  				  existing_conn->persistent_port,
3066  				  conn->persistent_port));
3067  
3068  		if (strcmp(existing_sess->targetname, sess->targetname))
3069  			continue;
3070  		rval = qla4xxx_match_ipaddress(ha, ddb_entry,
3071  					existing_conn->persistent_address,
3072  					conn->persistent_address);
3073  		if (rval == QLA_ERROR)
3074  			continue;
3075  		if (existing_conn->persistent_port != conn->persistent_port)
3076  			continue;
3077  		break;
3078  	}
3079  
3080  	if (idx == max_ddbs)
3081  		return QLA_ERROR;
3082  
3083  	DEBUG2(ql4_printk(KERN_INFO, ha,
3084  			  "Match found in fwdb sessions\n"));
3085  	return QLA_SUCCESS;
3086  }
3087  
3088  static struct iscsi_cls_session *
qla4xxx_session_create(struct iscsi_endpoint * ep,uint16_t cmds_max,uint16_t qdepth,uint32_t initial_cmdsn)3089  qla4xxx_session_create(struct iscsi_endpoint *ep,
3090  			uint16_t cmds_max, uint16_t qdepth,
3091  			uint32_t initial_cmdsn)
3092  {
3093  	struct iscsi_cls_session *cls_sess;
3094  	struct scsi_qla_host *ha;
3095  	struct qla_endpoint *qla_ep;
3096  	struct ddb_entry *ddb_entry;
3097  	uint16_t ddb_index;
3098  	struct iscsi_session *sess;
3099  	int ret;
3100  
3101  	if (!ep) {
3102  		printk(KERN_ERR "qla4xxx: missing ep.\n");
3103  		return NULL;
3104  	}
3105  
3106  	qla_ep = ep->dd_data;
3107  	ha = to_qla_host(qla_ep->host);
3108  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
3109  			  ha->host_no));
3110  
3111  	ret = qla4xxx_get_ddb_index(ha, &ddb_index);
3112  	if (ret == QLA_ERROR)
3113  		return NULL;
3114  
3115  	cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, qla_ep->host,
3116  				       cmds_max, sizeof(struct ddb_entry),
3117  				       sizeof(struct ql4_task_data),
3118  				       initial_cmdsn, ddb_index);
3119  	if (!cls_sess)
3120  		return NULL;
3121  
3122  	sess = cls_sess->dd_data;
3123  	ddb_entry = sess->dd_data;
3124  	ddb_entry->fw_ddb_index = ddb_index;
3125  	ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE;
3126  	ddb_entry->ha = ha;
3127  	ddb_entry->sess = cls_sess;
3128  	ddb_entry->unblock_sess = qla4xxx_unblock_ddb;
3129  	ddb_entry->ddb_change = qla4xxx_ddb_change;
3130  	clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags);
3131  	cls_sess->recovery_tmo = ql4xsess_recovery_tmo;
3132  	ha->fw_ddb_index_map[ddb_entry->fw_ddb_index] = ddb_entry;
3133  	ha->tot_ddbs++;
3134  
3135  	return cls_sess;
3136  }
3137  
qla4xxx_session_destroy(struct iscsi_cls_session * cls_sess)3138  static void qla4xxx_session_destroy(struct iscsi_cls_session *cls_sess)
3139  {
3140  	struct iscsi_session *sess;
3141  	struct ddb_entry *ddb_entry;
3142  	struct scsi_qla_host *ha;
3143  	unsigned long flags, wtime;
3144  	struct dev_db_entry *fw_ddb_entry = NULL;
3145  	dma_addr_t fw_ddb_entry_dma;
3146  	uint32_t ddb_state;
3147  	int ret;
3148  
3149  	sess = cls_sess->dd_data;
3150  	ddb_entry = sess->dd_data;
3151  	ha = ddb_entry->ha;
3152  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: host: %ld\n", __func__,
3153  			  ha->host_no));
3154  
3155  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3156  					  &fw_ddb_entry_dma, GFP_KERNEL);
3157  	if (!fw_ddb_entry) {
3158  		ql4_printk(KERN_ERR, ha,
3159  			   "%s: Unable to allocate dma buffer\n", __func__);
3160  		goto destroy_session;
3161  	}
3162  
3163  	wtime = jiffies + (HZ * LOGOUT_TOV);
3164  	do {
3165  		ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
3166  					      fw_ddb_entry, fw_ddb_entry_dma,
3167  					      NULL, NULL, &ddb_state, NULL,
3168  					      NULL, NULL);
3169  		if (ret == QLA_ERROR)
3170  			goto destroy_session;
3171  
3172  		if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
3173  		    (ddb_state == DDB_DS_SESSION_FAILED))
3174  			goto destroy_session;
3175  
3176  		schedule_timeout_uninterruptible(HZ);
3177  	} while ((time_after(wtime, jiffies)));
3178  
3179  destroy_session:
3180  	qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
3181  	if (test_and_clear_bit(DDB_CONN_CLOSE_FAILURE, &ddb_entry->flags))
3182  		clear_bit(ddb_entry->fw_ddb_index, ha->ddb_idx_map);
3183  	spin_lock_irqsave(&ha->hardware_lock, flags);
3184  	qla4xxx_free_ddb(ha, ddb_entry);
3185  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
3186  
3187  	iscsi_session_teardown(cls_sess);
3188  
3189  	if (fw_ddb_entry)
3190  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3191  				  fw_ddb_entry, fw_ddb_entry_dma);
3192  }
3193  
3194  static struct iscsi_cls_conn *
qla4xxx_conn_create(struct iscsi_cls_session * cls_sess,uint32_t conn_idx)3195  qla4xxx_conn_create(struct iscsi_cls_session *cls_sess, uint32_t conn_idx)
3196  {
3197  	struct iscsi_cls_conn *cls_conn;
3198  	struct iscsi_session *sess;
3199  	struct ddb_entry *ddb_entry;
3200  	struct scsi_qla_host *ha;
3201  
3202  	cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn),
3203  				    conn_idx);
3204  	if (!cls_conn) {
3205  		pr_info("%s: Can not create connection for conn_idx = %u\n",
3206  			__func__, conn_idx);
3207  		return NULL;
3208  	}
3209  
3210  	sess = cls_sess->dd_data;
3211  	ddb_entry = sess->dd_data;
3212  	ddb_entry->conn = cls_conn;
3213  
3214  	ha = ddb_entry->ha;
3215  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: conn_idx = %u\n", __func__,
3216  			  conn_idx));
3217  	return cls_conn;
3218  }
3219  
qla4xxx_conn_bind(struct iscsi_cls_session * cls_session,struct iscsi_cls_conn * cls_conn,uint64_t transport_fd,int is_leading)3220  static int qla4xxx_conn_bind(struct iscsi_cls_session *cls_session,
3221  			     struct iscsi_cls_conn *cls_conn,
3222  			     uint64_t transport_fd, int is_leading)
3223  {
3224  	struct iscsi_conn *conn;
3225  	struct qla_conn *qla_conn;
3226  	struct iscsi_endpoint *ep;
3227  	struct ddb_entry *ddb_entry;
3228  	struct scsi_qla_host *ha;
3229  	struct iscsi_session *sess;
3230  
3231  	sess = cls_session->dd_data;
3232  	ddb_entry = sess->dd_data;
3233  	ha = ddb_entry->ha;
3234  
3235  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d\n", __func__,
3236  			  cls_session->sid, cls_conn->cid));
3237  
3238  	if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
3239  		return -EINVAL;
3240  	ep = iscsi_lookup_endpoint(transport_fd);
3241  	if (!ep)
3242  		return -EINVAL;
3243  	conn = cls_conn->dd_data;
3244  	qla_conn = conn->dd_data;
3245  	qla_conn->qla_ep = ep->dd_data;
3246  	iscsi_put_endpoint(ep);
3247  	return 0;
3248  }
3249  
qla4xxx_conn_start(struct iscsi_cls_conn * cls_conn)3250  static int qla4xxx_conn_start(struct iscsi_cls_conn *cls_conn)
3251  {
3252  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
3253  	struct iscsi_session *sess;
3254  	struct ddb_entry *ddb_entry;
3255  	struct scsi_qla_host *ha;
3256  	struct dev_db_entry *fw_ddb_entry = NULL;
3257  	dma_addr_t fw_ddb_entry_dma;
3258  	uint32_t mbx_sts = 0;
3259  	int ret = 0;
3260  	int status = QLA_SUCCESS;
3261  
3262  	sess = cls_sess->dd_data;
3263  	ddb_entry = sess->dd_data;
3264  	ha = ddb_entry->ha;
3265  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: sid = %d, cid = %d\n", __func__,
3266  			  cls_sess->sid, cls_conn->cid));
3267  
3268  	/* Check if we have  matching FW DDB, if yes then do not
3269  	 * login to this target. This could cause target to logout previous
3270  	 * connection
3271  	 */
3272  	ret = qla4xxx_match_fwdb_session(ha, cls_conn);
3273  	if (ret == QLA_SUCCESS) {
3274  		ql4_printk(KERN_INFO, ha,
3275  			   "Session already exist in FW.\n");
3276  		ret = -EEXIST;
3277  		goto exit_conn_start;
3278  	}
3279  
3280  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3281  					  &fw_ddb_entry_dma, GFP_KERNEL);
3282  	if (!fw_ddb_entry) {
3283  		ql4_printk(KERN_ERR, ha,
3284  			   "%s: Unable to allocate dma buffer\n", __func__);
3285  		ret = -ENOMEM;
3286  		goto exit_conn_start;
3287  	}
3288  
3289  	ret = qla4xxx_set_param_ddbentry(ha, ddb_entry, cls_conn, &mbx_sts);
3290  	if (ret) {
3291  		/* If iscsid is stopped and started then no need to do
3292  		* set param again since ddb state will be already
3293  		* active and FW does not allow set ddb to an
3294  		* active session.
3295  		*/
3296  		if (mbx_sts)
3297  			if (ddb_entry->fw_ddb_device_state ==
3298  						DDB_DS_SESSION_ACTIVE) {
3299  				ddb_entry->unblock_sess(ddb_entry->sess);
3300  				goto exit_set_param;
3301  			}
3302  
3303  		ql4_printk(KERN_ERR, ha, "%s: Failed set param for index[%d]\n",
3304  			   __func__, ddb_entry->fw_ddb_index);
3305  		goto exit_conn_start;
3306  	}
3307  
3308  	status = qla4xxx_conn_open(ha, ddb_entry->fw_ddb_index);
3309  	if (status == QLA_ERROR) {
3310  		ql4_printk(KERN_ERR, ha, "%s: Login failed: %s\n", __func__,
3311  			   sess->targetname);
3312  		ret = -EINVAL;
3313  		goto exit_conn_start;
3314  	}
3315  
3316  	if (ddb_entry->fw_ddb_device_state == DDB_DS_NO_CONNECTION_ACTIVE)
3317  		ddb_entry->fw_ddb_device_state = DDB_DS_LOGIN_IN_PROCESS;
3318  
3319  	DEBUG2(printk(KERN_INFO "%s: DDB state [%d]\n", __func__,
3320  		      ddb_entry->fw_ddb_device_state));
3321  
3322  exit_set_param:
3323  	ret = 0;
3324  
3325  exit_conn_start:
3326  	if (fw_ddb_entry)
3327  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3328  				  fw_ddb_entry, fw_ddb_entry_dma);
3329  	return ret;
3330  }
3331  
qla4xxx_conn_destroy(struct iscsi_cls_conn * cls_conn)3332  static void qla4xxx_conn_destroy(struct iscsi_cls_conn *cls_conn)
3333  {
3334  	struct iscsi_cls_session *cls_sess = iscsi_conn_to_session(cls_conn);
3335  	struct iscsi_session *sess;
3336  	struct scsi_qla_host *ha;
3337  	struct ddb_entry *ddb_entry;
3338  	int options;
3339  
3340  	sess = cls_sess->dd_data;
3341  	ddb_entry = sess->dd_data;
3342  	ha = ddb_entry->ha;
3343  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: cid = %d\n", __func__,
3344  			  cls_conn->cid));
3345  
3346  	options = LOGOUT_OPTION_CLOSE_SESSION;
3347  	if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR)
3348  		ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", __func__);
3349  }
3350  
qla4xxx_task_work(struct work_struct * wdata)3351  static void qla4xxx_task_work(struct work_struct *wdata)
3352  {
3353  	struct ql4_task_data *task_data;
3354  	struct scsi_qla_host *ha;
3355  	struct passthru_status *sts;
3356  	struct iscsi_task *task;
3357  	struct iscsi_hdr *hdr;
3358  	uint8_t *data;
3359  	uint32_t data_len;
3360  	struct iscsi_conn *conn;
3361  	int hdr_len;
3362  	itt_t itt;
3363  
3364  	task_data = container_of(wdata, struct ql4_task_data, task_work);
3365  	ha = task_data->ha;
3366  	task = task_data->task;
3367  	sts = &task_data->sts;
3368  	hdr_len = sizeof(struct iscsi_hdr);
3369  
3370  	DEBUG3(printk(KERN_INFO "Status returned\n"));
3371  	DEBUG3(qla4xxx_dump_buffer(sts, 64));
3372  	DEBUG3(printk(KERN_INFO "Response buffer"));
3373  	DEBUG3(qla4xxx_dump_buffer(task_data->resp_buffer, 64));
3374  
3375  	conn = task->conn;
3376  
3377  	switch (sts->completionStatus) {
3378  	case PASSTHRU_STATUS_COMPLETE:
3379  		hdr = (struct iscsi_hdr *)task_data->resp_buffer;
3380  		/* Assign back the itt in hdr, until we use the PREASSIGN_TAG */
3381  		itt = sts->handle;
3382  		hdr->itt = itt;
3383  		data = task_data->resp_buffer + hdr_len;
3384  		data_len = task_data->resp_len - hdr_len;
3385  		iscsi_complete_pdu(conn, hdr, data, data_len);
3386  		break;
3387  	default:
3388  		ql4_printk(KERN_ERR, ha, "Passthru failed status = 0x%x\n",
3389  			   sts->completionStatus);
3390  		break;
3391  	}
3392  	return;
3393  }
3394  
qla4xxx_alloc_pdu(struct iscsi_task * task,uint8_t opcode)3395  static int qla4xxx_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
3396  {
3397  	struct ql4_task_data *task_data;
3398  	struct iscsi_session *sess;
3399  	struct ddb_entry *ddb_entry;
3400  	struct scsi_qla_host *ha;
3401  	int hdr_len;
3402  
3403  	sess = task->conn->session;
3404  	ddb_entry = sess->dd_data;
3405  	ha = ddb_entry->ha;
3406  	task_data = task->dd_data;
3407  	memset(task_data, 0, sizeof(struct ql4_task_data));
3408  
3409  	if (task->sc) {
3410  		ql4_printk(KERN_INFO, ha,
3411  			   "%s: SCSI Commands not implemented\n", __func__);
3412  		return -EINVAL;
3413  	}
3414  
3415  	hdr_len = sizeof(struct iscsi_hdr);
3416  	task_data->ha = ha;
3417  	task_data->task = task;
3418  
3419  	if (task->data_count) {
3420  		task_data->data_dma = dma_map_single(&ha->pdev->dev, task->data,
3421  						     task->data_count,
3422  						     DMA_TO_DEVICE);
3423  	}
3424  
3425  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n",
3426  		      __func__, task->conn->max_recv_dlength, hdr_len));
3427  
3428  	task_data->resp_len = task->conn->max_recv_dlength + hdr_len;
3429  	task_data->resp_buffer = dma_alloc_coherent(&ha->pdev->dev,
3430  						    task_data->resp_len,
3431  						    &task_data->resp_dma,
3432  						    GFP_ATOMIC);
3433  	if (!task_data->resp_buffer)
3434  		goto exit_alloc_pdu;
3435  
3436  	task_data->req_len = task->data_count + hdr_len;
3437  	task_data->req_buffer = dma_alloc_coherent(&ha->pdev->dev,
3438  						   task_data->req_len,
3439  						   &task_data->req_dma,
3440  						   GFP_ATOMIC);
3441  	if (!task_data->req_buffer)
3442  		goto exit_alloc_pdu;
3443  
3444  	task->hdr = task_data->req_buffer;
3445  
3446  	INIT_WORK(&task_data->task_work, qla4xxx_task_work);
3447  
3448  	return 0;
3449  
3450  exit_alloc_pdu:
3451  	if (task_data->resp_buffer)
3452  		dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
3453  				  task_data->resp_buffer, task_data->resp_dma);
3454  
3455  	if (task_data->req_buffer)
3456  		dma_free_coherent(&ha->pdev->dev, task_data->req_len,
3457  				  task_data->req_buffer, task_data->req_dma);
3458  	return -ENOMEM;
3459  }
3460  
qla4xxx_task_cleanup(struct iscsi_task * task)3461  static void qla4xxx_task_cleanup(struct iscsi_task *task)
3462  {
3463  	struct ql4_task_data *task_data;
3464  	struct iscsi_session *sess;
3465  	struct ddb_entry *ddb_entry;
3466  	struct scsi_qla_host *ha;
3467  	int hdr_len;
3468  
3469  	hdr_len = sizeof(struct iscsi_hdr);
3470  	sess = task->conn->session;
3471  	ddb_entry = sess->dd_data;
3472  	ha = ddb_entry->ha;
3473  	task_data = task->dd_data;
3474  
3475  	if (task->data_count) {
3476  		dma_unmap_single(&ha->pdev->dev, task_data->data_dma,
3477  				 task->data_count, DMA_TO_DEVICE);
3478  	}
3479  
3480  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: MaxRecvLen %u, iscsi hrd %d\n",
3481  		      __func__, task->conn->max_recv_dlength, hdr_len));
3482  
3483  	dma_free_coherent(&ha->pdev->dev, task_data->resp_len,
3484  			  task_data->resp_buffer, task_data->resp_dma);
3485  	dma_free_coherent(&ha->pdev->dev, task_data->req_len,
3486  			  task_data->req_buffer, task_data->req_dma);
3487  	return;
3488  }
3489  
qla4xxx_task_xmit(struct iscsi_task * task)3490  static int qla4xxx_task_xmit(struct iscsi_task *task)
3491  {
3492  	struct scsi_cmnd *sc = task->sc;
3493  	struct iscsi_session *sess = task->conn->session;
3494  	struct ddb_entry *ddb_entry = sess->dd_data;
3495  	struct scsi_qla_host *ha = ddb_entry->ha;
3496  
3497  	if (!sc)
3498  		return qla4xxx_send_passthru0(task);
3499  
3500  	ql4_printk(KERN_INFO, ha, "%s: scsi cmd xmit not implemented\n",
3501  		   __func__);
3502  	return -ENOSYS;
3503  }
3504  
qla4xxx_copy_from_fwddb_param(struct iscsi_bus_flash_session * sess,struct iscsi_bus_flash_conn * conn,struct dev_db_entry * fw_ddb_entry)3505  static int qla4xxx_copy_from_fwddb_param(struct iscsi_bus_flash_session *sess,
3506  					 struct iscsi_bus_flash_conn *conn,
3507  					 struct dev_db_entry *fw_ddb_entry)
3508  {
3509  	unsigned long options = 0;
3510  	int rc = 0;
3511  
3512  	options = le16_to_cpu(fw_ddb_entry->options);
3513  	conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
3514  	if (test_bit(OPT_IPV6_DEVICE, &options)) {
3515  		rc = iscsi_switch_str_param(&sess->portal_type,
3516  					    PORTAL_TYPE_IPV6);
3517  		if (rc)
3518  			goto exit_copy;
3519  	} else {
3520  		rc = iscsi_switch_str_param(&sess->portal_type,
3521  					    PORTAL_TYPE_IPV4);
3522  		if (rc)
3523  			goto exit_copy;
3524  	}
3525  
3526  	sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
3527  					      &options);
3528  	sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
3529  	sess->entry_state = test_bit(OPT_ENTRY_STATE, &options);
3530  
3531  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3532  	conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
3533  	conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
3534  	sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
3535  	sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
3536  	sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
3537  					    &options);
3538  	sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
3539  	sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
3540  	conn->snack_req_en = test_bit(ISCSIOPT_SNACK_REQ_EN, &options);
3541  	sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
3542  					     &options);
3543  	sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
3544  	sess->discovery_auth_optional =
3545  			test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
3546  	if (test_bit(ISCSIOPT_ERL1, &options))
3547  		sess->erl |= BIT_1;
3548  	if (test_bit(ISCSIOPT_ERL0, &options))
3549  		sess->erl |= BIT_0;
3550  
3551  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
3552  	conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
3553  	conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
3554  	conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
3555  	if (test_bit(TCPOPT_TIMER_SCALE3, &options))
3556  		conn->tcp_timer_scale |= BIT_3;
3557  	if (test_bit(TCPOPT_TIMER_SCALE2, &options))
3558  		conn->tcp_timer_scale |= BIT_2;
3559  	if (test_bit(TCPOPT_TIMER_SCALE1, &options))
3560  		conn->tcp_timer_scale |= BIT_1;
3561  
3562  	conn->tcp_timer_scale >>= 1;
3563  	conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
3564  
3565  	options = le16_to_cpu(fw_ddb_entry->ip_options);
3566  	conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
3567  
3568  	conn->max_recv_dlength = BYTE_UNITS *
3569  			  le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
3570  	conn->max_xmit_dlength = BYTE_UNITS *
3571  			  le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
3572  	sess->first_burst = BYTE_UNITS *
3573  			       le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
3574  	sess->max_burst = BYTE_UNITS *
3575  				 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
3576  	sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
3577  	sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3578  	sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
3579  	sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
3580  	conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
3581  	conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
3582  	conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
3583  	conn->ipv6_flow_label = le16_to_cpu(fw_ddb_entry->ipv6_flow_lbl);
3584  	conn->keepalive_timeout = le16_to_cpu(fw_ddb_entry->ka_timeout);
3585  	conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
3586  	conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
3587  	conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
3588  	sess->discovery_parent_idx = le16_to_cpu(fw_ddb_entry->ddb_link);
3589  	sess->discovery_parent_type = le16_to_cpu(fw_ddb_entry->ddb_link);
3590  	sess->chap_out_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3591  	sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
3592  
3593  	sess->default_taskmgmt_timeout =
3594  				le16_to_cpu(fw_ddb_entry->def_timeout);
3595  	conn->port = le16_to_cpu(fw_ddb_entry->port);
3596  
3597  	options = le16_to_cpu(fw_ddb_entry->options);
3598  	conn->ipaddress = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
3599  	if (!conn->ipaddress) {
3600  		rc = -ENOMEM;
3601  		goto exit_copy;
3602  	}
3603  
3604  	conn->redirect_ipaddr = kzalloc(IPv6_ADDR_LEN, GFP_KERNEL);
3605  	if (!conn->redirect_ipaddr) {
3606  		rc = -ENOMEM;
3607  		goto exit_copy;
3608  	}
3609  
3610  	memcpy(conn->ipaddress, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN);
3611  	memcpy(conn->redirect_ipaddr, fw_ddb_entry->tgt_addr, IPv6_ADDR_LEN);
3612  
3613  	if (test_bit(OPT_IPV6_DEVICE, &options)) {
3614  		conn->ipv6_traffic_class = fw_ddb_entry->ipv4_tos;
3615  
3616  		conn->link_local_ipv6_addr = kmemdup(
3617  					fw_ddb_entry->link_local_ipv6_addr,
3618  					IPv6_ADDR_LEN, GFP_KERNEL);
3619  		if (!conn->link_local_ipv6_addr) {
3620  			rc = -ENOMEM;
3621  			goto exit_copy;
3622  		}
3623  	} else {
3624  		conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
3625  	}
3626  
3627  	if (fw_ddb_entry->iscsi_name[0]) {
3628  		rc = iscsi_switch_str_param(&sess->targetname,
3629  					    (char *)fw_ddb_entry->iscsi_name);
3630  		if (rc)
3631  			goto exit_copy;
3632  	}
3633  
3634  	if (fw_ddb_entry->iscsi_alias[0]) {
3635  		rc = iscsi_switch_str_param(&sess->targetalias,
3636  					    (char *)fw_ddb_entry->iscsi_alias);
3637  		if (rc)
3638  			goto exit_copy;
3639  	}
3640  
3641  	COPY_ISID(sess->isid, fw_ddb_entry->isid);
3642  
3643  exit_copy:
3644  	return rc;
3645  }
3646  
qla4xxx_copy_to_fwddb_param(struct iscsi_bus_flash_session * sess,struct iscsi_bus_flash_conn * conn,struct dev_db_entry * fw_ddb_entry)3647  static int qla4xxx_copy_to_fwddb_param(struct iscsi_bus_flash_session *sess,
3648  				       struct iscsi_bus_flash_conn *conn,
3649  				       struct dev_db_entry *fw_ddb_entry)
3650  {
3651  	uint16_t options;
3652  
3653  	options = le16_to_cpu(fw_ddb_entry->options);
3654  	SET_BITVAL(conn->is_fw_assigned_ipv6,  options, BIT_11);
3655  	if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))
3656  		options |= BIT_8;
3657  	else
3658  		options &= ~BIT_8;
3659  
3660  	SET_BITVAL(sess->auto_snd_tgt_disable, options, BIT_6);
3661  	SET_BITVAL(sess->discovery_sess, options, BIT_4);
3662  	SET_BITVAL(sess->entry_state, options, BIT_3);
3663  	fw_ddb_entry->options = cpu_to_le16(options);
3664  
3665  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3666  	SET_BITVAL(conn->hdrdgst_en, options, BIT_13);
3667  	SET_BITVAL(conn->datadgst_en, options, BIT_12);
3668  	SET_BITVAL(sess->imm_data_en, options, BIT_11);
3669  	SET_BITVAL(sess->initial_r2t_en, options, BIT_10);
3670  	SET_BITVAL(sess->dataseq_inorder_en, options, BIT_9);
3671  	SET_BITVAL(sess->pdu_inorder_en, options, BIT_8);
3672  	SET_BITVAL(sess->chap_auth_en, options, BIT_7);
3673  	SET_BITVAL(conn->snack_req_en, options, BIT_6);
3674  	SET_BITVAL(sess->discovery_logout_en, options, BIT_5);
3675  	SET_BITVAL(sess->bidi_chap_en, options, BIT_4);
3676  	SET_BITVAL(sess->discovery_auth_optional, options, BIT_3);
3677  	SET_BITVAL(sess->erl & BIT_1, options, BIT_1);
3678  	SET_BITVAL(sess->erl & BIT_0, options, BIT_0);
3679  	fw_ddb_entry->iscsi_options = cpu_to_le16(options);
3680  
3681  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
3682  	SET_BITVAL(conn->tcp_timestamp_stat, options, BIT_6);
3683  	SET_BITVAL(conn->tcp_nagle_disable, options, BIT_5);
3684  	SET_BITVAL(conn->tcp_wsf_disable, options, BIT_4);
3685  	SET_BITVAL(conn->tcp_timer_scale & BIT_2, options, BIT_3);
3686  	SET_BITVAL(conn->tcp_timer_scale & BIT_1, options, BIT_2);
3687  	SET_BITVAL(conn->tcp_timer_scale & BIT_0, options, BIT_1);
3688  	SET_BITVAL(conn->tcp_timestamp_en, options, BIT_0);
3689  	fw_ddb_entry->tcp_options = cpu_to_le16(options);
3690  
3691  	options = le16_to_cpu(fw_ddb_entry->ip_options);
3692  	SET_BITVAL(conn->fragment_disable, options, BIT_4);
3693  	fw_ddb_entry->ip_options = cpu_to_le16(options);
3694  
3695  	fw_ddb_entry->iscsi_max_outsnd_r2t = cpu_to_le16(sess->max_r2t);
3696  	fw_ddb_entry->iscsi_max_rcv_data_seg_len =
3697  			       cpu_to_le16(conn->max_recv_dlength / BYTE_UNITS);
3698  	fw_ddb_entry->iscsi_max_snd_data_seg_len =
3699  			       cpu_to_le16(conn->max_xmit_dlength / BYTE_UNITS);
3700  	fw_ddb_entry->iscsi_first_burst_len =
3701  				cpu_to_le16(sess->first_burst / BYTE_UNITS);
3702  	fw_ddb_entry->iscsi_max_burst_len = cpu_to_le16(sess->max_burst /
3703  					    BYTE_UNITS);
3704  	fw_ddb_entry->iscsi_def_time2wait = cpu_to_le16(sess->time2wait);
3705  	fw_ddb_entry->iscsi_def_time2retain = cpu_to_le16(sess->time2retain);
3706  	fw_ddb_entry->tgt_portal_grp = cpu_to_le16(sess->tpgt);
3707  	fw_ddb_entry->mss = cpu_to_le16(conn->max_segment_size);
3708  	fw_ddb_entry->tcp_xmt_wsf = (uint8_t) cpu_to_le32(conn->tcp_xmit_wsf);
3709  	fw_ddb_entry->tcp_rcv_wsf = (uint8_t) cpu_to_le32(conn->tcp_recv_wsf);
3710  	fw_ddb_entry->ipv6_flow_lbl = cpu_to_le16(conn->ipv6_flow_label);
3711  	fw_ddb_entry->ka_timeout = cpu_to_le16(conn->keepalive_timeout);
3712  	fw_ddb_entry->lcl_port = cpu_to_le16(conn->local_port);
3713  	fw_ddb_entry->stat_sn = cpu_to_le32(conn->statsn);
3714  	fw_ddb_entry->exp_stat_sn = cpu_to_le32(conn->exp_statsn);
3715  	fw_ddb_entry->ddb_link = cpu_to_le16(sess->discovery_parent_idx);
3716  	fw_ddb_entry->chap_tbl_idx = cpu_to_le16(sess->chap_out_idx);
3717  	fw_ddb_entry->tsid = cpu_to_le16(sess->tsid);
3718  	fw_ddb_entry->port = cpu_to_le16(conn->port);
3719  	fw_ddb_entry->def_timeout =
3720  				cpu_to_le16(sess->default_taskmgmt_timeout);
3721  
3722  	if (!strncmp(sess->portal_type, PORTAL_TYPE_IPV6, 4))
3723  		fw_ddb_entry->ipv4_tos = conn->ipv6_traffic_class;
3724  	else
3725  		fw_ddb_entry->ipv4_tos = conn->ipv4_tos;
3726  
3727  	if (conn->ipaddress)
3728  		memcpy(fw_ddb_entry->ip_addr, conn->ipaddress,
3729  		       sizeof(fw_ddb_entry->ip_addr));
3730  
3731  	if (conn->redirect_ipaddr)
3732  		memcpy(fw_ddb_entry->tgt_addr, conn->redirect_ipaddr,
3733  		       sizeof(fw_ddb_entry->tgt_addr));
3734  
3735  	if (conn->link_local_ipv6_addr)
3736  		memcpy(fw_ddb_entry->link_local_ipv6_addr,
3737  		       conn->link_local_ipv6_addr,
3738  		       sizeof(fw_ddb_entry->link_local_ipv6_addr));
3739  
3740  	if (sess->targetname)
3741  		memcpy(fw_ddb_entry->iscsi_name, sess->targetname,
3742  		       sizeof(fw_ddb_entry->iscsi_name));
3743  
3744  	if (sess->targetalias)
3745  		memcpy(fw_ddb_entry->iscsi_alias, sess->targetalias,
3746  		       sizeof(fw_ddb_entry->iscsi_alias));
3747  
3748  	COPY_ISID(fw_ddb_entry->isid, sess->isid);
3749  
3750  	return 0;
3751  }
3752  
qla4xxx_copy_to_sess_conn_params(struct iscsi_conn * conn,struct iscsi_session * sess,struct dev_db_entry * fw_ddb_entry)3753  static void qla4xxx_copy_to_sess_conn_params(struct iscsi_conn *conn,
3754  					     struct iscsi_session *sess,
3755  					     struct dev_db_entry *fw_ddb_entry)
3756  {
3757  	unsigned long options = 0;
3758  	uint16_t ddb_link;
3759  	uint16_t disc_parent;
3760  	char ip_addr[DDB_IPADDR_LEN];
3761  
3762  	options = le16_to_cpu(fw_ddb_entry->options);
3763  	conn->is_fw_assigned_ipv6 = test_bit(OPT_IS_FW_ASSIGNED_IPV6, &options);
3764  	sess->auto_snd_tgt_disable = test_bit(OPT_AUTO_SENDTGTS_DISABLE,
3765  					      &options);
3766  	sess->discovery_sess = test_bit(OPT_DISC_SESSION, &options);
3767  
3768  	options = le16_to_cpu(fw_ddb_entry->iscsi_options);
3769  	conn->hdrdgst_en = test_bit(ISCSIOPT_HEADER_DIGEST_EN, &options);
3770  	conn->datadgst_en = test_bit(ISCSIOPT_DATA_DIGEST_EN, &options);
3771  	sess->imm_data_en = test_bit(ISCSIOPT_IMMEDIATE_DATA_EN, &options);
3772  	sess->initial_r2t_en = test_bit(ISCSIOPT_INITIAL_R2T_EN, &options);
3773  	sess->dataseq_inorder_en = test_bit(ISCSIOPT_DATA_SEQ_IN_ORDER,
3774  					    &options);
3775  	sess->pdu_inorder_en = test_bit(ISCSIOPT_DATA_PDU_IN_ORDER, &options);
3776  	sess->chap_auth_en = test_bit(ISCSIOPT_CHAP_AUTH_EN, &options);
3777  	sess->discovery_logout_en = test_bit(ISCSIOPT_DISCOVERY_LOGOUT_EN,
3778  					     &options);
3779  	sess->bidi_chap_en = test_bit(ISCSIOPT_BIDI_CHAP_EN, &options);
3780  	sess->discovery_auth_optional =
3781  			test_bit(ISCSIOPT_DISCOVERY_AUTH_OPTIONAL, &options);
3782  	if (test_bit(ISCSIOPT_ERL1, &options))
3783  		sess->erl |= BIT_1;
3784  	if (test_bit(ISCSIOPT_ERL0, &options))
3785  		sess->erl |= BIT_0;
3786  
3787  	options = le16_to_cpu(fw_ddb_entry->tcp_options);
3788  	conn->tcp_timestamp_stat = test_bit(TCPOPT_TIMESTAMP_STAT, &options);
3789  	conn->tcp_nagle_disable = test_bit(TCPOPT_NAGLE_DISABLE, &options);
3790  	conn->tcp_wsf_disable = test_bit(TCPOPT_WSF_DISABLE, &options);
3791  	if (test_bit(TCPOPT_TIMER_SCALE3, &options))
3792  		conn->tcp_timer_scale |= BIT_3;
3793  	if (test_bit(TCPOPT_TIMER_SCALE2, &options))
3794  		conn->tcp_timer_scale |= BIT_2;
3795  	if (test_bit(TCPOPT_TIMER_SCALE1, &options))
3796  		conn->tcp_timer_scale |= BIT_1;
3797  
3798  	conn->tcp_timer_scale >>= 1;
3799  	conn->tcp_timestamp_en = test_bit(TCPOPT_TIMESTAMP_EN, &options);
3800  
3801  	options = le16_to_cpu(fw_ddb_entry->ip_options);
3802  	conn->fragment_disable = test_bit(IPOPT_FRAGMENT_DISABLE, &options);
3803  
3804  	conn->max_recv_dlength = BYTE_UNITS *
3805  			  le16_to_cpu(fw_ddb_entry->iscsi_max_rcv_data_seg_len);
3806  	conn->max_xmit_dlength = BYTE_UNITS *
3807  			  le16_to_cpu(fw_ddb_entry->iscsi_max_snd_data_seg_len);
3808  	sess->max_r2t = le16_to_cpu(fw_ddb_entry->iscsi_max_outsnd_r2t);
3809  	sess->first_burst = BYTE_UNITS *
3810  			       le16_to_cpu(fw_ddb_entry->iscsi_first_burst_len);
3811  	sess->max_burst = BYTE_UNITS *
3812  				 le16_to_cpu(fw_ddb_entry->iscsi_max_burst_len);
3813  	sess->time2wait = le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3814  	sess->time2retain = le16_to_cpu(fw_ddb_entry->iscsi_def_time2retain);
3815  	sess->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
3816  	conn->max_segment_size = le16_to_cpu(fw_ddb_entry->mss);
3817  	conn->tcp_xmit_wsf = fw_ddb_entry->tcp_xmt_wsf;
3818  	conn->tcp_recv_wsf = fw_ddb_entry->tcp_rcv_wsf;
3819  	conn->ipv4_tos = fw_ddb_entry->ipv4_tos;
3820  	conn->keepalive_tmo = le16_to_cpu(fw_ddb_entry->ka_timeout);
3821  	conn->local_port = le16_to_cpu(fw_ddb_entry->lcl_port);
3822  	conn->statsn = le32_to_cpu(fw_ddb_entry->stat_sn);
3823  	conn->exp_statsn = le32_to_cpu(fw_ddb_entry->exp_stat_sn);
3824  	sess->tsid = le16_to_cpu(fw_ddb_entry->tsid);
3825  	COPY_ISID(sess->isid, fw_ddb_entry->isid);
3826  
3827  	ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
3828  	if (ddb_link == DDB_ISNS)
3829  		disc_parent = ISCSI_DISC_PARENT_ISNS;
3830  	else if (ddb_link == DDB_NO_LINK)
3831  		disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
3832  	else if (ddb_link < MAX_DDB_ENTRIES)
3833  		disc_parent = ISCSI_DISC_PARENT_SENDTGT;
3834  	else
3835  		disc_parent = ISCSI_DISC_PARENT_UNKNOWN;
3836  
3837  	iscsi_set_param(conn->cls_conn, ISCSI_PARAM_DISCOVERY_PARENT_TYPE,
3838  			iscsi_get_discovery_parent_name(disc_parent), 0);
3839  
3840  	iscsi_set_param(conn->cls_conn, ISCSI_PARAM_TARGET_ALIAS,
3841  			(char *)fw_ddb_entry->iscsi_alias, 0);
3842  
3843  	options = le16_to_cpu(fw_ddb_entry->options);
3844  	if (options & DDB_OPT_IPV6_DEVICE) {
3845  		memset(ip_addr, 0, sizeof(ip_addr));
3846  		sprintf(ip_addr, "%pI6", fw_ddb_entry->link_local_ipv6_addr);
3847  		iscsi_set_param(conn->cls_conn, ISCSI_PARAM_LOCAL_IPADDR,
3848  				(char *)ip_addr, 0);
3849  	}
3850  }
3851  
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)3852  static void qla4xxx_copy_fwddb_param(struct scsi_qla_host *ha,
3853  				     struct dev_db_entry *fw_ddb_entry,
3854  				     struct iscsi_cls_session *cls_sess,
3855  				     struct iscsi_cls_conn *cls_conn)
3856  {
3857  	int buflen = 0;
3858  	struct iscsi_session *sess;
3859  	struct ddb_entry *ddb_entry;
3860  	struct ql4_chap_table chap_tbl;
3861  	struct iscsi_conn *conn;
3862  	char ip_addr[DDB_IPADDR_LEN];
3863  	uint16_t options = 0;
3864  
3865  	sess = cls_sess->dd_data;
3866  	ddb_entry = sess->dd_data;
3867  	conn = cls_conn->dd_data;
3868  	memset(&chap_tbl, 0, sizeof(chap_tbl));
3869  
3870  	ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3871  
3872  	qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);
3873  
3874  	sess->def_taskmgmt_tmo = le16_to_cpu(fw_ddb_entry->def_timeout);
3875  	conn->persistent_port = le16_to_cpu(fw_ddb_entry->port);
3876  
3877  	memset(ip_addr, 0, sizeof(ip_addr));
3878  	options = le16_to_cpu(fw_ddb_entry->options);
3879  	if (options & DDB_OPT_IPV6_DEVICE) {
3880  		iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv6", 4);
3881  
3882  		memset(ip_addr, 0, sizeof(ip_addr));
3883  		sprintf(ip_addr, "%pI6", fw_ddb_entry->ip_addr);
3884  	} else {
3885  		iscsi_set_param(cls_conn, ISCSI_PARAM_PORTAL_TYPE, "ipv4", 4);
3886  		sprintf(ip_addr, "%pI4", fw_ddb_entry->ip_addr);
3887  	}
3888  
3889  	iscsi_set_param(cls_conn, ISCSI_PARAM_PERSISTENT_ADDRESS,
3890  			(char *)ip_addr, buflen);
3891  	iscsi_set_param(cls_conn, ISCSI_PARAM_TARGET_NAME,
3892  			(char *)fw_ddb_entry->iscsi_name, buflen);
3893  	iscsi_set_param(cls_conn, ISCSI_PARAM_INITIATOR_NAME,
3894  			(char *)ha->name_string, buflen);
3895  
3896  	if (ddb_entry->chap_tbl_idx != INVALID_ENTRY) {
3897  		if (!qla4xxx_get_uni_chap_at_index(ha, chap_tbl.name,
3898  						   chap_tbl.secret,
3899  						   ddb_entry->chap_tbl_idx)) {
3900  			iscsi_set_param(cls_conn, ISCSI_PARAM_USERNAME,
3901  					(char *)chap_tbl.name,
3902  					strlen((char *)chap_tbl.name));
3903  			iscsi_set_param(cls_conn, ISCSI_PARAM_PASSWORD,
3904  					(char *)chap_tbl.secret,
3905  					chap_tbl.secret_len);
3906  		}
3907  	}
3908  }
3909  
qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry)3910  void qla4xxx_update_session_conn_fwddb_param(struct scsi_qla_host *ha,
3911  					     struct ddb_entry *ddb_entry)
3912  {
3913  	struct iscsi_cls_session *cls_sess;
3914  	struct iscsi_cls_conn *cls_conn;
3915  	uint32_t ddb_state;
3916  	dma_addr_t fw_ddb_entry_dma;
3917  	struct dev_db_entry *fw_ddb_entry;
3918  
3919  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3920  					  &fw_ddb_entry_dma, GFP_KERNEL);
3921  	if (!fw_ddb_entry) {
3922  		ql4_printk(KERN_ERR, ha,
3923  			   "%s: Unable to allocate dma buffer\n", __func__);
3924  		goto exit_session_conn_fwddb_param;
3925  	}
3926  
3927  	if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
3928  				    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
3929  				    NULL, NULL, NULL) == QLA_ERROR) {
3930  		DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
3931  				  "get_ddb_entry for fw_ddb_index %d\n",
3932  				  ha->host_no, __func__,
3933  				  ddb_entry->fw_ddb_index));
3934  		goto exit_session_conn_fwddb_param;
3935  	}
3936  
3937  	cls_sess = ddb_entry->sess;
3938  
3939  	cls_conn = ddb_entry->conn;
3940  
3941  	/* Update params */
3942  	qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn);
3943  
3944  exit_session_conn_fwddb_param:
3945  	if (fw_ddb_entry)
3946  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3947  				  fw_ddb_entry, fw_ddb_entry_dma);
3948  }
3949  
qla4xxx_update_session_conn_param(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry)3950  void qla4xxx_update_session_conn_param(struct scsi_qla_host *ha,
3951  				       struct ddb_entry *ddb_entry)
3952  {
3953  	struct iscsi_cls_session *cls_sess;
3954  	struct iscsi_cls_conn *cls_conn;
3955  	struct iscsi_session *sess;
3956  	struct iscsi_conn *conn;
3957  	uint32_t ddb_state;
3958  	dma_addr_t fw_ddb_entry_dma;
3959  	struct dev_db_entry *fw_ddb_entry;
3960  
3961  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
3962  					  &fw_ddb_entry_dma, GFP_KERNEL);
3963  	if (!fw_ddb_entry) {
3964  		ql4_printk(KERN_ERR, ha,
3965  			   "%s: Unable to allocate dma buffer\n", __func__);
3966  		goto exit_session_conn_param;
3967  	}
3968  
3969  	if (qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index, fw_ddb_entry,
3970  				    fw_ddb_entry_dma, NULL, NULL, &ddb_state,
3971  				    NULL, NULL, NULL) == QLA_ERROR) {
3972  		DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: failed "
3973  				  "get_ddb_entry for fw_ddb_index %d\n",
3974  				  ha->host_no, __func__,
3975  				  ddb_entry->fw_ddb_index));
3976  		goto exit_session_conn_param;
3977  	}
3978  
3979  	cls_sess = ddb_entry->sess;
3980  	sess = cls_sess->dd_data;
3981  
3982  	cls_conn = ddb_entry->conn;
3983  	conn = cls_conn->dd_data;
3984  
3985  	/* Update timers after login */
3986  	ddb_entry->default_relogin_timeout =
3987  		(le16_to_cpu(fw_ddb_entry->def_timeout) > LOGIN_TOV) &&
3988  		 (le16_to_cpu(fw_ddb_entry->def_timeout) < LOGIN_TOV * 10) ?
3989  		 le16_to_cpu(fw_ddb_entry->def_timeout) : LOGIN_TOV;
3990  	ddb_entry->default_time2wait =
3991  				le16_to_cpu(fw_ddb_entry->iscsi_def_time2wait);
3992  
3993  	/* Update params */
3994  	ddb_entry->chap_tbl_idx = le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
3995  	qla4xxx_copy_to_sess_conn_params(conn, sess, fw_ddb_entry);
3996  
3997  	memcpy(sess->initiatorname, ha->name_string,
3998  	       min(sizeof(ha->name_string), sizeof(sess->initiatorname)));
3999  
4000  exit_session_conn_param:
4001  	if (fw_ddb_entry)
4002  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
4003  				  fw_ddb_entry, fw_ddb_entry_dma);
4004  }
4005  
4006  /*
4007   * Timer routines
4008   */
4009  static void qla4xxx_timer(struct timer_list *t);
4010  
qla4xxx_start_timer(struct scsi_qla_host * ha,unsigned long interval)4011  static void qla4xxx_start_timer(struct scsi_qla_host *ha,
4012  				unsigned long interval)
4013  {
4014  	DEBUG(printk("scsi: %s: Starting timer thread for adapter %d\n",
4015  		     __func__, ha->host->host_no));
4016  	timer_setup(&ha->timer, qla4xxx_timer, 0);
4017  	ha->timer.expires = jiffies + interval * HZ;
4018  	add_timer(&ha->timer);
4019  	ha->timer_active = 1;
4020  }
4021  
qla4xxx_stop_timer(struct scsi_qla_host * ha)4022  static void qla4xxx_stop_timer(struct scsi_qla_host *ha)
4023  {
4024  	del_timer_sync(&ha->timer);
4025  	ha->timer_active = 0;
4026  }
4027  
4028  /***
4029   * qla4xxx_mark_device_missing - blocks the session
4030   * @cls_session: Pointer to the session to be blocked
4031   * @ddb_entry: Pointer to device database entry
4032   *
4033   * This routine marks a device missing and close connection.
4034   **/
qla4xxx_mark_device_missing(struct iscsi_cls_session * cls_session)4035  void qla4xxx_mark_device_missing(struct iscsi_cls_session *cls_session)
4036  {
4037  	iscsi_block_session(cls_session);
4038  }
4039  
4040  /**
4041   * qla4xxx_mark_all_devices_missing - mark all devices as missing.
4042   * @ha: Pointer to host adapter structure.
4043   *
4044   * This routine marks a device missing and resets the relogin retry count.
4045   **/
qla4xxx_mark_all_devices_missing(struct scsi_qla_host * ha)4046  void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha)
4047  {
4048  	iscsi_host_for_each_session(ha->host, qla4xxx_mark_device_missing);
4049  }
4050  
qla4xxx_get_new_srb(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry,struct scsi_cmnd * cmd)4051  static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha,
4052  				       struct ddb_entry *ddb_entry,
4053  				       struct scsi_cmnd *cmd)
4054  {
4055  	struct srb *srb;
4056  
4057  	srb = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
4058  	if (!srb)
4059  		return srb;
4060  
4061  	kref_init(&srb->srb_ref);
4062  	srb->ha = ha;
4063  	srb->ddb = ddb_entry;
4064  	srb->cmd = cmd;
4065  	srb->flags = 0;
4066  	qla4xxx_cmd_priv(cmd)->srb = srb;
4067  
4068  	return srb;
4069  }
4070  
qla4xxx_srb_free_dma(struct scsi_qla_host * ha,struct srb * srb)4071  static void qla4xxx_srb_free_dma(struct scsi_qla_host *ha, struct srb *srb)
4072  {
4073  	struct scsi_cmnd *cmd = srb->cmd;
4074  
4075  	if (srb->flags & SRB_DMA_VALID) {
4076  		scsi_dma_unmap(cmd);
4077  		srb->flags &= ~SRB_DMA_VALID;
4078  	}
4079  	qla4xxx_cmd_priv(cmd)->srb = NULL;
4080  }
4081  
qla4xxx_srb_compl(struct kref * ref)4082  void qla4xxx_srb_compl(struct kref *ref)
4083  {
4084  	struct srb *srb = container_of(ref, struct srb, srb_ref);
4085  	struct scsi_cmnd *cmd = srb->cmd;
4086  	struct scsi_qla_host *ha = srb->ha;
4087  
4088  	qla4xxx_srb_free_dma(ha, srb);
4089  
4090  	mempool_free(srb, ha->srb_mempool);
4091  
4092  	scsi_done(cmd);
4093  }
4094  
4095  /**
4096   * qla4xxx_queuecommand - scsi layer issues scsi command to driver.
4097   * @host: scsi host
4098   * @cmd: Pointer to Linux's SCSI command structure
4099   *
4100   * Remarks:
4101   * This routine is invoked by Linux to send a SCSI command to the driver.
4102   * The mid-level driver tries to ensure that queuecommand never gets
4103   * invoked concurrently with itself or the interrupt handler (although
4104   * the interrupt handler may call this routine as part of request-
4105   * completion handling).   Unfortunely, it sometimes calls the scheduler
4106   * in interrupt context which is a big NO! NO!.
4107   **/
qla4xxx_queuecommand(struct Scsi_Host * host,struct scsi_cmnd * cmd)4108  static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
4109  {
4110  	struct scsi_qla_host *ha = to_qla_host(host);
4111  	struct ddb_entry *ddb_entry = cmd->device->hostdata;
4112  	struct iscsi_cls_session *sess = ddb_entry->sess;
4113  	struct srb *srb;
4114  	int rval;
4115  
4116  	if (test_bit(AF_EEH_BUSY, &ha->flags)) {
4117  		if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
4118  			cmd->result = DID_NO_CONNECT << 16;
4119  		else
4120  			cmd->result = DID_REQUEUE << 16;
4121  		goto qc_fail_command;
4122  	}
4123  
4124  	if (!sess) {
4125  		cmd->result = DID_IMM_RETRY << 16;
4126  		goto qc_fail_command;
4127  	}
4128  
4129  	rval = iscsi_session_chkready(sess);
4130  	if (rval) {
4131  		cmd->result = rval;
4132  		goto qc_fail_command;
4133  	}
4134  
4135  	if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
4136  	    test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
4137  	    test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4138  	    test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
4139  	    test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
4140  	    !test_bit(AF_ONLINE, &ha->flags) ||
4141  	    !test_bit(AF_LINK_UP, &ha->flags) ||
4142  	    test_bit(AF_LOOPBACK, &ha->flags) ||
4143  	    test_bit(DPC_POST_IDC_ACK, &ha->dpc_flags) ||
4144  	    test_bit(DPC_RESTORE_ACB, &ha->dpc_flags) ||
4145  	    test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))
4146  		goto qc_host_busy;
4147  
4148  	srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd);
4149  	if (!srb)
4150  		goto qc_host_busy;
4151  
4152  	rval = qla4xxx_send_command_to_isp(ha, srb);
4153  	if (rval != QLA_SUCCESS)
4154  		goto qc_host_busy_free_sp;
4155  
4156  	return 0;
4157  
4158  qc_host_busy_free_sp:
4159  	qla4xxx_srb_free_dma(ha, srb);
4160  	mempool_free(srb, ha->srb_mempool);
4161  
4162  qc_host_busy:
4163  	return SCSI_MLQUEUE_HOST_BUSY;
4164  
4165  qc_fail_command:
4166  	scsi_done(cmd);
4167  
4168  	return 0;
4169  }
4170  
4171  /**
4172   * qla4xxx_mem_free - frees memory allocated to adapter
4173   * @ha: Pointer to host adapter structure.
4174   *
4175   * Frees memory previously allocated by qla4xxx_mem_alloc
4176   **/
qla4xxx_mem_free(struct scsi_qla_host * ha)4177  static void qla4xxx_mem_free(struct scsi_qla_host *ha)
4178  {
4179  	if (ha->queues)
4180  		dma_free_coherent(&ha->pdev->dev, ha->queues_len, ha->queues,
4181  				  ha->queues_dma);
4182  
4183  	vfree(ha->fw_dump);
4184  
4185  	ha->queues_len = 0;
4186  	ha->queues = NULL;
4187  	ha->queues_dma = 0;
4188  	ha->request_ring = NULL;
4189  	ha->request_dma = 0;
4190  	ha->response_ring = NULL;
4191  	ha->response_dma = 0;
4192  	ha->shadow_regs = NULL;
4193  	ha->shadow_regs_dma = 0;
4194  	ha->fw_dump = NULL;
4195  	ha->fw_dump_size = 0;
4196  
4197  	/* Free srb pool. */
4198  	mempool_destroy(ha->srb_mempool);
4199  	ha->srb_mempool = NULL;
4200  
4201  	dma_pool_destroy(ha->chap_dma_pool);
4202  
4203  	vfree(ha->chap_list);
4204  	ha->chap_list = NULL;
4205  
4206  	dma_pool_destroy(ha->fw_ddb_dma_pool);
4207  
4208  	/* release io space registers  */
4209  	if (is_qla8022(ha)) {
4210  		if (ha->nx_pcibase)
4211  			iounmap(
4212  			    (struct device_reg_82xx __iomem *)ha->nx_pcibase);
4213  	} else if (is_qla8032(ha) || is_qla8042(ha)) {
4214  		if (ha->nx_pcibase)
4215  			iounmap(
4216  			    (struct device_reg_83xx __iomem *)ha->nx_pcibase);
4217  	} else if (ha->reg) {
4218  		iounmap(ha->reg);
4219  	}
4220  
4221  	vfree(ha->reset_tmplt.buff);
4222  
4223  	pci_release_regions(ha->pdev);
4224  }
4225  
4226  /**
4227   * qla4xxx_mem_alloc - allocates memory for use by adapter.
4228   * @ha: Pointer to host adapter structure
4229   *
4230   * Allocates DMA memory for request and response queues. Also allocates memory
4231   * for srbs.
4232   **/
qla4xxx_mem_alloc(struct scsi_qla_host * ha)4233  static int qla4xxx_mem_alloc(struct scsi_qla_host *ha)
4234  {
4235  	unsigned long align;
4236  
4237  	/* Allocate contiguous block of DMA memory for queues. */
4238  	ha->queues_len = ((REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
4239  			  (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE) +
4240  			  sizeof(struct shadow_regs) +
4241  			  MEM_ALIGN_VALUE +
4242  			  (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
4243  	ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len,
4244  					&ha->queues_dma, GFP_KERNEL);
4245  	if (ha->queues == NULL) {
4246  		ql4_printk(KERN_WARNING, ha,
4247  		    "Memory Allocation failed - queues.\n");
4248  
4249  		goto mem_alloc_error_exit;
4250  	}
4251  
4252  	/*
4253  	 * As per RISC alignment requirements -- the bus-address must be a
4254  	 * multiple of the request-ring size (in bytes).
4255  	 */
4256  	align = 0;
4257  	if ((unsigned long)ha->queues_dma & (MEM_ALIGN_VALUE - 1))
4258  		align = MEM_ALIGN_VALUE - ((unsigned long)ha->queues_dma &
4259  					   (MEM_ALIGN_VALUE - 1));
4260  
4261  	/* Update request and response queue pointers. */
4262  	ha->request_dma = ha->queues_dma + align;
4263  	ha->request_ring = (struct queue_entry *) (ha->queues + align);
4264  	ha->response_dma = ha->queues_dma + align +
4265  		(REQUEST_QUEUE_DEPTH * QUEUE_SIZE);
4266  	ha->response_ring = (struct queue_entry *) (ha->queues + align +
4267  						    (REQUEST_QUEUE_DEPTH *
4268  						     QUEUE_SIZE));
4269  	ha->shadow_regs_dma = ha->queues_dma + align +
4270  		(REQUEST_QUEUE_DEPTH * QUEUE_SIZE) +
4271  		(RESPONSE_QUEUE_DEPTH * QUEUE_SIZE);
4272  	ha->shadow_regs = (struct shadow_regs *) (ha->queues + align +
4273  						  (REQUEST_QUEUE_DEPTH *
4274  						   QUEUE_SIZE) +
4275  						  (RESPONSE_QUEUE_DEPTH *
4276  						   QUEUE_SIZE));
4277  
4278  	/* Allocate memory for srb pool. */
4279  	ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
4280  					 mempool_free_slab, srb_cachep);
4281  	if (ha->srb_mempool == NULL) {
4282  		ql4_printk(KERN_WARNING, ha,
4283  		    "Memory Allocation failed - SRB Pool.\n");
4284  
4285  		goto mem_alloc_error_exit;
4286  	}
4287  
4288  	ha->chap_dma_pool = dma_pool_create("ql4_chap", &ha->pdev->dev,
4289  					    CHAP_DMA_BLOCK_SIZE, 8, 0);
4290  
4291  	if (ha->chap_dma_pool == NULL) {
4292  		ql4_printk(KERN_WARNING, ha,
4293  		    "%s: chap_dma_pool allocation failed..\n", __func__);
4294  		goto mem_alloc_error_exit;
4295  	}
4296  
4297  	ha->fw_ddb_dma_pool = dma_pool_create("ql4_fw_ddb", &ha->pdev->dev,
4298  					      DDB_DMA_BLOCK_SIZE, 8, 0);
4299  
4300  	if (ha->fw_ddb_dma_pool == NULL) {
4301  		ql4_printk(KERN_WARNING, ha,
4302  			   "%s: fw_ddb_dma_pool allocation failed..\n",
4303  			   __func__);
4304  		goto mem_alloc_error_exit;
4305  	}
4306  
4307  	return QLA_SUCCESS;
4308  
4309  mem_alloc_error_exit:
4310  	return QLA_ERROR;
4311  }
4312  
4313  /**
4314   * qla4_8xxx_check_temp - Check the ISP82XX temperature.
4315   * @ha: adapter block pointer.
4316   *
4317   * Note: The caller should not hold the idc lock.
4318   **/
qla4_8xxx_check_temp(struct scsi_qla_host * ha)4319  static int qla4_8xxx_check_temp(struct scsi_qla_host *ha)
4320  {
4321  	uint32_t temp, temp_state, temp_val;
4322  	int status = QLA_SUCCESS;
4323  
4324  	temp = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_TEMP_STATE);
4325  
4326  	temp_state = qla82xx_get_temp_state(temp);
4327  	temp_val = qla82xx_get_temp_val(temp);
4328  
4329  	if (temp_state == QLA82XX_TEMP_PANIC) {
4330  		ql4_printk(KERN_WARNING, ha, "Device temperature %d degrees C"
4331  			   " exceeds maximum allowed. Hardware has been shut"
4332  			   " down.\n", temp_val);
4333  		status = QLA_ERROR;
4334  	} else if (temp_state == QLA82XX_TEMP_WARN) {
4335  		if (ha->temperature == QLA82XX_TEMP_NORMAL)
4336  			ql4_printk(KERN_WARNING, ha, "Device temperature %d"
4337  				   " degrees C exceeds operating range."
4338  				   " Immediate action needed.\n", temp_val);
4339  	} else {
4340  		if (ha->temperature == QLA82XX_TEMP_WARN)
4341  			ql4_printk(KERN_INFO, ha, "Device temperature is"
4342  				   " now %d degrees C in normal range.\n",
4343  				   temp_val);
4344  	}
4345  	ha->temperature = temp_state;
4346  	return status;
4347  }
4348  
4349  /**
4350   * qla4_8xxx_check_fw_alive  - Check firmware health
4351   * @ha: Pointer to host adapter structure.
4352   *
4353   * Context: Interrupt
4354   **/
qla4_8xxx_check_fw_alive(struct scsi_qla_host * ha)4355  static int qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
4356  {
4357  	uint32_t fw_heartbeat_counter;
4358  	int status = QLA_SUCCESS;
4359  
4360  	fw_heartbeat_counter = qla4_8xxx_rd_direct(ha,
4361  						   QLA8XXX_PEG_ALIVE_COUNTER);
4362  	/* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */
4363  	if (fw_heartbeat_counter == 0xffffffff) {
4364  		DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen "
4365  		    "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff\n",
4366  		    ha->host_no, __func__));
4367  		return status;
4368  	}
4369  
4370  	if (ha->fw_heartbeat_counter == fw_heartbeat_counter) {
4371  		ha->seconds_since_last_heartbeat++;
4372  		/* FW not alive after 2 seconds */
4373  		if (ha->seconds_since_last_heartbeat == 2) {
4374  			ha->seconds_since_last_heartbeat = 0;
4375  			qla4_8xxx_dump_peg_reg(ha);
4376  			status = QLA_ERROR;
4377  		}
4378  	} else
4379  		ha->seconds_since_last_heartbeat = 0;
4380  
4381  	ha->fw_heartbeat_counter = fw_heartbeat_counter;
4382  	return status;
4383  }
4384  
qla4_8xxx_process_fw_error(struct scsi_qla_host * ha)4385  static void qla4_8xxx_process_fw_error(struct scsi_qla_host *ha)
4386  {
4387  	uint32_t halt_status;
4388  	int halt_status_unrecoverable = 0;
4389  
4390  	halt_status = qla4_8xxx_rd_direct(ha, QLA8XXX_PEG_HALT_STATUS1);
4391  
4392  	if (is_qla8022(ha)) {
4393  		ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
4394  			   __func__);
4395  		qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
4396  				CRB_NIU_XG_PAUSE_CTL_P0 |
4397  				CRB_NIU_XG_PAUSE_CTL_P1);
4398  
4399  		if (QLA82XX_FWERROR_CODE(halt_status) == 0x67)
4400  			ql4_printk(KERN_ERR, ha, "%s: Firmware aborted with error code 0x00006700. Device is being reset\n",
4401  				   __func__);
4402  		if (halt_status & HALT_STATUS_UNRECOVERABLE)
4403  			halt_status_unrecoverable = 1;
4404  	} else if (is_qla8032(ha) || is_qla8042(ha)) {
4405  		if (halt_status & QLA83XX_HALT_STATUS_FW_RESET)
4406  			ql4_printk(KERN_ERR, ha, "%s: Firmware error detected device is being reset\n",
4407  				   __func__);
4408  		else if (halt_status & QLA83XX_HALT_STATUS_UNRECOVERABLE)
4409  			halt_status_unrecoverable = 1;
4410  	}
4411  
4412  	/*
4413  	 * Since we cannot change dev_state in interrupt context,
4414  	 * set appropriate DPC flag then wakeup DPC
4415  	 */
4416  	if (halt_status_unrecoverable) {
4417  		set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
4418  	} else {
4419  		ql4_printk(KERN_INFO, ha, "%s: detect abort needed!\n",
4420  			   __func__);
4421  		set_bit(DPC_RESET_HA, &ha->dpc_flags);
4422  	}
4423  	qla4xxx_mailbox_premature_completion(ha);
4424  	qla4xxx_wake_dpc(ha);
4425  }
4426  
4427  /**
4428   * qla4_8xxx_watchdog - Poll dev state
4429   * @ha: Pointer to host adapter structure.
4430   *
4431   * Context: Interrupt
4432   **/
qla4_8xxx_watchdog(struct scsi_qla_host * ha)4433  void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
4434  {
4435  	uint32_t dev_state;
4436  	uint32_t idc_ctrl;
4437  
4438  	if (is_qla8032(ha) &&
4439  	    (qla4_83xx_is_detached(ha) == QLA_SUCCESS))
4440  		WARN_ONCE(1, "%s: iSCSI function %d marked invisible\n",
4441  			  __func__, ha->func_num);
4442  
4443  	/* don't poll if reset is going on */
4444  	if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
4445  	    test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4446  	    test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags))) {
4447  		dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
4448  
4449  		if (qla4_8xxx_check_temp(ha)) {
4450  			if (is_qla8022(ha)) {
4451  				ql4_printk(KERN_INFO, ha, "disabling pause transmit on port 0 & 1.\n");
4452  				qla4_82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x98,
4453  						CRB_NIU_XG_PAUSE_CTL_P0 |
4454  						CRB_NIU_XG_PAUSE_CTL_P1);
4455  			}
4456  			set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags);
4457  			qla4xxx_wake_dpc(ha);
4458  		} else if (dev_state == QLA8XXX_DEV_NEED_RESET &&
4459  			   !test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
4460  
4461  			ql4_printk(KERN_INFO, ha, "%s: HW State: NEED RESET!\n",
4462  				   __func__);
4463  
4464  			if (is_qla8032(ha) || is_qla8042(ha)) {
4465  				idc_ctrl = qla4_83xx_rd_reg(ha,
4466  							QLA83XX_IDC_DRV_CTRL);
4467  				if (!(idc_ctrl & GRACEFUL_RESET_BIT1)) {
4468  					ql4_printk(KERN_INFO, ha, "%s: Graceful reset bit is not set\n",
4469  						   __func__);
4470  					qla4xxx_mailbox_premature_completion(
4471  									    ha);
4472  				}
4473  			}
4474  
4475  			if ((is_qla8032(ha) || is_qla8042(ha)) ||
4476  			    (is_qla8022(ha) && !ql4xdontresethba)) {
4477  				set_bit(DPC_RESET_HA, &ha->dpc_flags);
4478  				qla4xxx_wake_dpc(ha);
4479  			}
4480  		} else if (dev_state == QLA8XXX_DEV_NEED_QUIESCENT &&
4481  		    !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
4482  			ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!\n",
4483  			    __func__);
4484  			set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags);
4485  			qla4xxx_wake_dpc(ha);
4486  		} else  {
4487  			/* Check firmware health */
4488  			if (qla4_8xxx_check_fw_alive(ha))
4489  				qla4_8xxx_process_fw_error(ha);
4490  		}
4491  	}
4492  }
4493  
qla4xxx_check_relogin_flash_ddb(struct iscsi_cls_session * cls_sess)4494  static void qla4xxx_check_relogin_flash_ddb(struct iscsi_cls_session *cls_sess)
4495  {
4496  	struct iscsi_session *sess;
4497  	struct ddb_entry *ddb_entry;
4498  	struct scsi_qla_host *ha;
4499  
4500  	sess = cls_sess->dd_data;
4501  	ddb_entry = sess->dd_data;
4502  	ha = ddb_entry->ha;
4503  
4504  	if (!(ddb_entry->ddb_type == FLASH_DDB))
4505  		return;
4506  
4507  	if (adapter_up(ha) && !test_bit(DF_RELOGIN, &ddb_entry->flags) &&
4508  	    !iscsi_is_session_online(cls_sess)) {
4509  		if (atomic_read(&ddb_entry->retry_relogin_timer) !=
4510  		    INVALID_ENTRY) {
4511  			if (atomic_read(&ddb_entry->retry_relogin_timer) ==
4512  					0) {
4513  				atomic_set(&ddb_entry->retry_relogin_timer,
4514  					   INVALID_ENTRY);
4515  				set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
4516  				set_bit(DF_RELOGIN, &ddb_entry->flags);
4517  				DEBUG2(ql4_printk(KERN_INFO, ha,
4518  				       "%s: index [%d] login device\n",
4519  					__func__, ddb_entry->fw_ddb_index));
4520  			} else
4521  				atomic_dec(&ddb_entry->retry_relogin_timer);
4522  		}
4523  	}
4524  
4525  	/* Wait for relogin to timeout */
4526  	if (atomic_read(&ddb_entry->relogin_timer) &&
4527  	    (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) {
4528  		/*
4529  		 * If the relogin times out and the device is
4530  		 * still NOT ONLINE then try and relogin again.
4531  		 */
4532  		if (!iscsi_is_session_online(cls_sess)) {
4533  			/* Reset retry relogin timer */
4534  			atomic_inc(&ddb_entry->relogin_retry_count);
4535  			DEBUG2(ql4_printk(KERN_INFO, ha,
4536  				"%s: index[%d] relogin timed out-retrying"
4537  				" relogin (%d), retry (%d)\n", __func__,
4538  				ddb_entry->fw_ddb_index,
4539  				atomic_read(&ddb_entry->relogin_retry_count),
4540  				ddb_entry->default_time2wait + 4));
4541  			set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
4542  			atomic_set(&ddb_entry->retry_relogin_timer,
4543  				   ddb_entry->default_time2wait + 4);
4544  		}
4545  	}
4546  }
4547  
4548  /**
4549   * qla4xxx_timer - checks every second for work to do.
4550   * @t: Context to obtain pointer to host adapter structure.
4551   **/
qla4xxx_timer(struct timer_list * t)4552  static void qla4xxx_timer(struct timer_list *t)
4553  {
4554  	struct scsi_qla_host *ha = from_timer(ha, t, timer);
4555  	int start_dpc = 0;
4556  	uint16_t w;
4557  
4558  	iscsi_host_for_each_session(ha->host, qla4xxx_check_relogin_flash_ddb);
4559  
4560  	/* If we are in the middle of AER/EEH processing
4561  	 * skip any processing and reschedule the timer
4562  	 */
4563  	if (test_bit(AF_EEH_BUSY, &ha->flags)) {
4564  		mod_timer(&ha->timer, jiffies + HZ);
4565  		return;
4566  	}
4567  
4568  	/* Hardware read to trigger an EEH error during mailbox waits. */
4569  	if (!pci_channel_offline(ha->pdev))
4570  		pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
4571  
4572  	if (is_qla80XX(ha))
4573  		qla4_8xxx_watchdog(ha);
4574  
4575  	if (is_qla40XX(ha)) {
4576  		/* Check for heartbeat interval. */
4577  		if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE &&
4578  		    ha->heartbeat_interval != 0) {
4579  			ha->seconds_since_last_heartbeat++;
4580  			if (ha->seconds_since_last_heartbeat >
4581  			    ha->heartbeat_interval + 2)
4582  				set_bit(DPC_RESET_HA, &ha->dpc_flags);
4583  		}
4584  	}
4585  
4586  	/* Process any deferred work. */
4587  	if (!list_empty(&ha->work_list))
4588  		start_dpc++;
4589  
4590  	/* Wakeup the dpc routine for this adapter, if needed. */
4591  	if (start_dpc ||
4592  	     test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
4593  	     test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) ||
4594  	     test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) ||
4595  	     test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) ||
4596  	     test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
4597  	     test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) ||
4598  	     test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) ||
4599  	     test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
4600  	     test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
4601  	     test_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags) ||
4602  	     test_bit(DPC_AEN, &ha->dpc_flags)) {
4603  		DEBUG2(printk("scsi%ld: %s: scheduling dpc routine"
4604  			      " - dpc flags = 0x%lx\n",
4605  			      ha->host_no, __func__, ha->dpc_flags));
4606  		qla4xxx_wake_dpc(ha);
4607  	}
4608  
4609  	/* Reschedule timer thread to call us back in one second */
4610  	mod_timer(&ha->timer, jiffies + HZ);
4611  
4612  	DEBUG2(ha->seconds_since_last_intr++);
4613  }
4614  
4615  /**
4616   * qla4xxx_cmd_wait - waits for all outstanding commands to complete
4617   * @ha: Pointer to host adapter structure.
4618   *
4619   * This routine stalls the driver until all outstanding commands are returned.
4620   * Caller must release the Hardware Lock prior to calling this routine.
4621   **/
qla4xxx_cmd_wait(struct scsi_qla_host * ha)4622  static int qla4xxx_cmd_wait(struct scsi_qla_host *ha)
4623  {
4624  	uint32_t index = 0;
4625  	unsigned long flags;
4626  	struct scsi_cmnd *cmd;
4627  	unsigned long wtime;
4628  	uint32_t wtmo;
4629  
4630  	if (is_qla40XX(ha))
4631  		wtmo = WAIT_CMD_TOV;
4632  	else
4633  		wtmo = ha->nx_reset_timeout / 2;
4634  
4635  	wtime = jiffies + (wtmo * HZ);
4636  
4637  	DEBUG2(ql4_printk(KERN_INFO, ha,
4638  			  "Wait up to %u seconds for cmds to complete\n",
4639  			  wtmo));
4640  
4641  	while (!time_after_eq(jiffies, wtime)) {
4642  		spin_lock_irqsave(&ha->hardware_lock, flags);
4643  		/* Find a command that hasn't completed. */
4644  		for (index = 0; index < ha->host->can_queue; index++) {
4645  			cmd = scsi_host_find_tag(ha->host, index);
4646  			/*
4647  			 * We cannot just check if the index is valid,
4648  			 * becase if we are run from the scsi eh, then
4649  			 * the scsi/block layer is going to prevent
4650  			 * the tag from being released.
4651  			 */
4652  			if (cmd != NULL && qla4xxx_cmd_priv(cmd)->srb)
4653  				break;
4654  		}
4655  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
4656  
4657  		/* If No Commands are pending, wait is complete */
4658  		if (index == ha->host->can_queue)
4659  			return QLA_SUCCESS;
4660  
4661  		msleep(1000);
4662  	}
4663  	/* If we timed out on waiting for commands to come back
4664  	 * return ERROR. */
4665  	return QLA_ERROR;
4666  }
4667  
qla4xxx_hw_reset(struct scsi_qla_host * ha)4668  int qla4xxx_hw_reset(struct scsi_qla_host *ha)
4669  {
4670  	uint32_t ctrl_status;
4671  	unsigned long flags = 0;
4672  
4673  	DEBUG2(printk(KERN_ERR "scsi%ld: %s\n", ha->host_no, __func__));
4674  
4675  	if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS)
4676  		return QLA_ERROR;
4677  
4678  	spin_lock_irqsave(&ha->hardware_lock, flags);
4679  
4680  	/*
4681  	 * If the SCSI Reset Interrupt bit is set, clear it.
4682  	 * Otherwise, the Soft Reset won't work.
4683  	 */
4684  	ctrl_status = readw(&ha->reg->ctrl_status);
4685  	if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0)
4686  		writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
4687  
4688  	/* Issue Soft Reset */
4689  	writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status);
4690  	readl(&ha->reg->ctrl_status);
4691  
4692  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
4693  	return QLA_SUCCESS;
4694  }
4695  
4696  /**
4697   * qla4xxx_soft_reset - performs soft reset.
4698   * @ha: Pointer to host adapter structure.
4699   **/
qla4xxx_soft_reset(struct scsi_qla_host * ha)4700  int qla4xxx_soft_reset(struct scsi_qla_host *ha)
4701  {
4702  	uint32_t max_wait_time;
4703  	unsigned long flags = 0;
4704  	int status;
4705  	uint32_t ctrl_status;
4706  
4707  	status = qla4xxx_hw_reset(ha);
4708  	if (status != QLA_SUCCESS)
4709  		return status;
4710  
4711  	status = QLA_ERROR;
4712  	/* Wait until the Network Reset Intr bit is cleared */
4713  	max_wait_time = RESET_INTR_TOV;
4714  	do {
4715  		spin_lock_irqsave(&ha->hardware_lock, flags);
4716  		ctrl_status = readw(&ha->reg->ctrl_status);
4717  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
4718  
4719  		if ((ctrl_status & CSR_NET_RESET_INTR) == 0)
4720  			break;
4721  
4722  		msleep(1000);
4723  	} while ((--max_wait_time));
4724  
4725  	if ((ctrl_status & CSR_NET_RESET_INTR) != 0) {
4726  		DEBUG2(printk(KERN_WARNING
4727  			      "scsi%ld: Network Reset Intr not cleared by "
4728  			      "Network function, clearing it now!\n",
4729  			      ha->host_no));
4730  		spin_lock_irqsave(&ha->hardware_lock, flags);
4731  		writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status);
4732  		readl(&ha->reg->ctrl_status);
4733  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
4734  	}
4735  
4736  	/* Wait until the firmware tells us the Soft Reset is done */
4737  	max_wait_time = SOFT_RESET_TOV;
4738  	do {
4739  		spin_lock_irqsave(&ha->hardware_lock, flags);
4740  		ctrl_status = readw(&ha->reg->ctrl_status);
4741  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
4742  
4743  		if ((ctrl_status & CSR_SOFT_RESET) == 0) {
4744  			status = QLA_SUCCESS;
4745  			break;
4746  		}
4747  
4748  		msleep(1000);
4749  	} while ((--max_wait_time));
4750  
4751  	/*
4752  	 * Also, make sure that the SCSI Reset Interrupt bit has been cleared
4753  	 * after the soft reset has taken place.
4754  	 */
4755  	spin_lock_irqsave(&ha->hardware_lock, flags);
4756  	ctrl_status = readw(&ha->reg->ctrl_status);
4757  	if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) {
4758  		writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status);
4759  		readl(&ha->reg->ctrl_status);
4760  	}
4761  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
4762  
4763  	/* If soft reset fails then most probably the bios on other
4764  	 * function is also enabled.
4765  	 * Since the initialization is sequential the other fn
4766  	 * wont be able to acknowledge the soft reset.
4767  	 * Issue a force soft reset to workaround this scenario.
4768  	 */
4769  	if (max_wait_time == 0) {
4770  		/* Issue Force Soft Reset */
4771  		spin_lock_irqsave(&ha->hardware_lock, flags);
4772  		writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status);
4773  		readl(&ha->reg->ctrl_status);
4774  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
4775  		/* Wait until the firmware tells us the Soft Reset is done */
4776  		max_wait_time = SOFT_RESET_TOV;
4777  		do {
4778  			spin_lock_irqsave(&ha->hardware_lock, flags);
4779  			ctrl_status = readw(&ha->reg->ctrl_status);
4780  			spin_unlock_irqrestore(&ha->hardware_lock, flags);
4781  
4782  			if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) {
4783  				status = QLA_SUCCESS;
4784  				break;
4785  			}
4786  
4787  			msleep(1000);
4788  		} while ((--max_wait_time));
4789  	}
4790  
4791  	return status;
4792  }
4793  
4794  /**
4795   * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S.
4796   * @ha: Pointer to host adapter structure.
4797   * @res: returned scsi status
4798   *
4799   * This routine is called just prior to a HARD RESET to return all
4800   * outstanding commands back to the Operating System.
4801   * Caller should make sure that the following locks are released
4802   * before this calling routine: Hardware lock, and io_request_lock.
4803   **/
qla4xxx_abort_active_cmds(struct scsi_qla_host * ha,int res)4804  static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res)
4805  {
4806  	struct srb *srb;
4807  	int i;
4808  	unsigned long flags;
4809  
4810  	spin_lock_irqsave(&ha->hardware_lock, flags);
4811  	for (i = 0; i < ha->host->can_queue; i++) {
4812  		srb = qla4xxx_del_from_active_array(ha, i);
4813  		if (srb != NULL) {
4814  			srb->cmd->result = res;
4815  			kref_put(&srb->srb_ref, qla4xxx_srb_compl);
4816  		}
4817  	}
4818  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
4819  }
4820  
qla4xxx_dead_adapter_cleanup(struct scsi_qla_host * ha)4821  void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha)
4822  {
4823  	clear_bit(AF_ONLINE, &ha->flags);
4824  
4825  	/* Disable the board */
4826  	ql4_printk(KERN_INFO, ha, "Disabling the board\n");
4827  
4828  	qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
4829  	qla4xxx_mark_all_devices_missing(ha);
4830  	clear_bit(AF_INIT_DONE, &ha->flags);
4831  }
4832  
qla4xxx_fail_session(struct iscsi_cls_session * cls_session)4833  static void qla4xxx_fail_session(struct iscsi_cls_session *cls_session)
4834  {
4835  	struct iscsi_session *sess;
4836  	struct ddb_entry *ddb_entry;
4837  
4838  	sess = cls_session->dd_data;
4839  	ddb_entry = sess->dd_data;
4840  	ddb_entry->fw_ddb_device_state = DDB_DS_SESSION_FAILED;
4841  
4842  	if (ddb_entry->ddb_type == FLASH_DDB)
4843  		iscsi_block_session(ddb_entry->sess);
4844  	else
4845  		iscsi_session_failure(cls_session->dd_data,
4846  				      ISCSI_ERR_CONN_FAILED);
4847  }
4848  
4849  /**
4850   * qla4xxx_recover_adapter - recovers adapter after a fatal error
4851   * @ha: Pointer to host adapter structure.
4852   **/
qla4xxx_recover_adapter(struct scsi_qla_host * ha)4853  static int qla4xxx_recover_adapter(struct scsi_qla_host *ha)
4854  {
4855  	int status = QLA_ERROR;
4856  	uint8_t reset_chip = 0;
4857  	uint32_t dev_state;
4858  	unsigned long wait;
4859  
4860  	/* Stall incoming I/O until we are done */
4861  	scsi_block_requests(ha->host);
4862  	clear_bit(AF_ONLINE, &ha->flags);
4863  	clear_bit(AF_LINK_UP, &ha->flags);
4864  
4865  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE\n", __func__));
4866  
4867  	set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
4868  
4869  	if ((is_qla8032(ha) || is_qla8042(ha)) &&
4870  	    !test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) {
4871  		ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
4872  			   __func__);
4873  		/* disable pause frame for ISP83xx */
4874  		qla4_83xx_disable_pause(ha);
4875  	}
4876  
4877  	iscsi_host_for_each_session(ha->host, qla4xxx_fail_session);
4878  
4879  	if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
4880  		reset_chip = 1;
4881  
4882  	/* For the DPC_RESET_HA_INTR case (ISP-4xxx specific)
4883  	 * do not reset adapter, jump to initialize_adapter */
4884  	if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
4885  		status = QLA_SUCCESS;
4886  		goto recover_ha_init_adapter;
4887  	}
4888  
4889  	/* For the ISP-8xxx adapter, issue a stop_firmware if invoked
4890  	 * from eh_host_reset or ioctl module */
4891  	if (is_qla80XX(ha) && !reset_chip &&
4892  	    test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) {
4893  
4894  		DEBUG2(ql4_printk(KERN_INFO, ha,
4895  		    "scsi%ld: %s - Performing stop_firmware...\n",
4896  		    ha->host_no, __func__));
4897  		status = ha->isp_ops->reset_firmware(ha);
4898  		if (status == QLA_SUCCESS) {
4899  			ha->isp_ops->disable_intrs(ha);
4900  			qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4901  			qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
4902  		} else {
4903  			/* If the stop_firmware fails then
4904  			 * reset the entire chip */
4905  			reset_chip = 1;
4906  			clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
4907  			set_bit(DPC_RESET_HA, &ha->dpc_flags);
4908  		}
4909  	}
4910  
4911  	/* Issue full chip reset if recovering from a catastrophic error,
4912  	 * or if stop_firmware fails for ISP-8xxx.
4913  	 * This is the default case for ISP-4xxx */
4914  	if (is_qla40XX(ha) || reset_chip) {
4915  		if (is_qla40XX(ha))
4916  			goto chip_reset;
4917  
4918  		/* Check if 8XXX firmware is alive or not
4919  		 * We may have arrived here from NEED_RESET
4920  		 * detection only */
4921  		if (test_bit(AF_FW_RECOVERY, &ha->flags))
4922  			goto chip_reset;
4923  
4924  		wait = jiffies + (FW_ALIVE_WAIT_TOV * HZ);
4925  		while (time_before(jiffies, wait)) {
4926  			if (qla4_8xxx_check_fw_alive(ha)) {
4927  				qla4xxx_mailbox_premature_completion(ha);
4928  				break;
4929  			}
4930  
4931  			set_current_state(TASK_UNINTERRUPTIBLE);
4932  			schedule_timeout(HZ);
4933  		}
4934  chip_reset:
4935  		if (!test_bit(AF_FW_RECOVERY, &ha->flags))
4936  			qla4xxx_cmd_wait(ha);
4937  
4938  		qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4939  		DEBUG2(ql4_printk(KERN_INFO, ha,
4940  		    "scsi%ld: %s - Performing chip reset..\n",
4941  		    ha->host_no, __func__));
4942  		status = ha->isp_ops->reset_chip(ha);
4943  		qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
4944  	}
4945  
4946  	/* Flush any pending ddb changed AENs */
4947  	qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
4948  
4949  recover_ha_init_adapter:
4950  	/* Upon successful firmware/chip reset, re-initialize the adapter */
4951  	if (status == QLA_SUCCESS) {
4952  		/* For ISP-4xxx, force function 1 to always initialize
4953  		 * before function 3 to prevent both funcions from
4954  		 * stepping on top of the other */
4955  		if (is_qla40XX(ha) && (ha->mac_index == 3))
4956  			ssleep(6);
4957  
4958  		/* NOTE: AF_ONLINE flag set upon successful completion of
4959  		 * qla4xxx_initialize_adapter */
4960  		status = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
4961  		if (is_qla80XX(ha) && (status == QLA_ERROR)) {
4962  			status = qla4_8xxx_check_init_adapter_retry(ha);
4963  			if (status == QLA_ERROR) {
4964  				ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Don't retry recover adapter\n",
4965  					   ha->host_no, __func__);
4966  				qla4xxx_dead_adapter_cleanup(ha);
4967  				clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
4968  				clear_bit(DPC_RESET_HA, &ha->dpc_flags);
4969  				clear_bit(DPC_RESET_HA_FW_CONTEXT,
4970  					  &ha->dpc_flags);
4971  				goto exit_recover;
4972  			}
4973  		}
4974  	}
4975  
4976  	/* Retry failed adapter initialization, if necessary
4977  	 * Do not retry initialize_adapter for RESET_HA_INTR (ISP-4xxx specific)
4978  	 * case to prevent ping-pong resets between functions */
4979  	if (!test_bit(AF_ONLINE, &ha->flags) &&
4980  	    !test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
4981  		/* Adapter initialization failed, see if we can retry
4982  		 * resetting the ha.
4983  		 * Since we don't want to block the DPC for too long
4984  		 * with multiple resets in the same thread,
4985  		 * utilize DPC to retry */
4986  		if (is_qla80XX(ha)) {
4987  			ha->isp_ops->idc_lock(ha);
4988  			dev_state = qla4_8xxx_rd_direct(ha,
4989  							QLA8XXX_CRB_DEV_STATE);
4990  			ha->isp_ops->idc_unlock(ha);
4991  			if (dev_state == QLA8XXX_DEV_FAILED) {
4992  				ql4_printk(KERN_INFO, ha, "%s: don't retry "
4993  					   "recover adapter. H/W is in Failed "
4994  					   "state\n", __func__);
4995  				qla4xxx_dead_adapter_cleanup(ha);
4996  				clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
4997  				clear_bit(DPC_RESET_HA, &ha->dpc_flags);
4998  				clear_bit(DPC_RESET_HA_FW_CONTEXT,
4999  						&ha->dpc_flags);
5000  				status = QLA_ERROR;
5001  
5002  				goto exit_recover;
5003  			}
5004  		}
5005  
5006  		if (!test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags)) {
5007  			ha->retry_reset_ha_cnt = MAX_RESET_HA_RETRIES;
5008  			DEBUG2(printk("scsi%ld: recover adapter - retrying "
5009  				      "(%d) more times\n", ha->host_no,
5010  				      ha->retry_reset_ha_cnt));
5011  			set_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
5012  			status = QLA_ERROR;
5013  		} else {
5014  			if (ha->retry_reset_ha_cnt > 0) {
5015  				/* Schedule another Reset HA--DPC will retry */
5016  				ha->retry_reset_ha_cnt--;
5017  				DEBUG2(printk("scsi%ld: recover adapter - "
5018  					      "retry remaining %d\n",
5019  					      ha->host_no,
5020  					      ha->retry_reset_ha_cnt));
5021  				status = QLA_ERROR;
5022  			}
5023  
5024  			if (ha->retry_reset_ha_cnt == 0) {
5025  				/* Recover adapter retries have been exhausted.
5026  				 * Adapter DEAD */
5027  				DEBUG2(printk("scsi%ld: recover adapter "
5028  					      "failed - board disabled\n",
5029  					      ha->host_no));
5030  				qla4xxx_dead_adapter_cleanup(ha);
5031  				clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
5032  				clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5033  				clear_bit(DPC_RESET_HA_FW_CONTEXT,
5034  					  &ha->dpc_flags);
5035  				status = QLA_ERROR;
5036  			}
5037  		}
5038  	} else {
5039  		clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5040  		clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
5041  		clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags);
5042  	}
5043  
5044  exit_recover:
5045  	ha->adapter_error_count++;
5046  
5047  	if (test_bit(AF_ONLINE, &ha->flags))
5048  		ha->isp_ops->enable_intrs(ha);
5049  
5050  	scsi_unblock_requests(ha->host);
5051  
5052  	clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
5053  	DEBUG2(printk("scsi%ld: recover adapter: %s\n", ha->host_no,
5054  	    status == QLA_ERROR ? "FAILED" : "SUCCEEDED"));
5055  
5056  	return status;
5057  }
5058  
qla4xxx_relogin_devices(struct iscsi_cls_session * cls_session)5059  static void qla4xxx_relogin_devices(struct iscsi_cls_session *cls_session)
5060  {
5061  	struct iscsi_session *sess;
5062  	struct ddb_entry *ddb_entry;
5063  	struct scsi_qla_host *ha;
5064  
5065  	sess = cls_session->dd_data;
5066  	ddb_entry = sess->dd_data;
5067  	ha = ddb_entry->ha;
5068  	if (!iscsi_is_session_online(cls_session)) {
5069  		if (ddb_entry->fw_ddb_device_state == DDB_DS_SESSION_ACTIVE) {
5070  			ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5071  				   " unblock session\n", ha->host_no, __func__,
5072  				   ddb_entry->fw_ddb_index);
5073  			iscsi_unblock_session(ddb_entry->sess);
5074  		} else {
5075  			/* Trigger relogin */
5076  			if (ddb_entry->ddb_type == FLASH_DDB) {
5077  				if (!(test_bit(DF_RELOGIN, &ddb_entry->flags) ||
5078  				      test_bit(DF_DISABLE_RELOGIN,
5079  					       &ddb_entry->flags)))
5080  					qla4xxx_arm_relogin_timer(ddb_entry);
5081  			} else
5082  				iscsi_session_failure(cls_session->dd_data,
5083  						      ISCSI_ERR_CONN_FAILED);
5084  		}
5085  	}
5086  }
5087  
qla4xxx_unblock_flash_ddb(struct iscsi_cls_session * cls_session)5088  int qla4xxx_unblock_flash_ddb(struct iscsi_cls_session *cls_session)
5089  {
5090  	struct iscsi_session *sess;
5091  	struct ddb_entry *ddb_entry;
5092  	struct scsi_qla_host *ha;
5093  
5094  	sess = cls_session->dd_data;
5095  	ddb_entry = sess->dd_data;
5096  	ha = ddb_entry->ha;
5097  	ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5098  		   " unblock session\n", ha->host_no, __func__,
5099  		   ddb_entry->fw_ddb_index);
5100  
5101  	iscsi_unblock_session(ddb_entry->sess);
5102  
5103  	/* Start scan target */
5104  	if (test_bit(AF_ONLINE, &ha->flags)) {
5105  		ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5106  			   " start scan\n", ha->host_no, __func__,
5107  			   ddb_entry->fw_ddb_index);
5108  		queue_work(ddb_entry->sess->workq, &ddb_entry->sess->scan_work);
5109  	}
5110  	return QLA_SUCCESS;
5111  }
5112  
qla4xxx_unblock_ddb(struct iscsi_cls_session * cls_session)5113  int qla4xxx_unblock_ddb(struct iscsi_cls_session *cls_session)
5114  {
5115  	struct iscsi_session *sess;
5116  	struct ddb_entry *ddb_entry;
5117  	struct scsi_qla_host *ha;
5118  	int status = QLA_SUCCESS;
5119  
5120  	sess = cls_session->dd_data;
5121  	ddb_entry = sess->dd_data;
5122  	ha = ddb_entry->ha;
5123  	ql4_printk(KERN_INFO, ha, "scsi%ld: %s: ddb[%d]"
5124  		   " unblock user space session\n", ha->host_no, __func__,
5125  		   ddb_entry->fw_ddb_index);
5126  
5127  	if (!iscsi_is_session_online(cls_session)) {
5128  		iscsi_conn_start(ddb_entry->conn);
5129  		iscsi_conn_login_event(ddb_entry->conn,
5130  				       ISCSI_CONN_STATE_LOGGED_IN);
5131  	} else {
5132  		ql4_printk(KERN_INFO, ha,
5133  			   "scsi%ld: %s: ddb[%d] session [%d] already logged in\n",
5134  			   ha->host_no, __func__, ddb_entry->fw_ddb_index,
5135  			   cls_session->sid);
5136  		status = QLA_ERROR;
5137  	}
5138  
5139  	return status;
5140  }
5141  
qla4xxx_relogin_all_devices(struct scsi_qla_host * ha)5142  static void qla4xxx_relogin_all_devices(struct scsi_qla_host *ha)
5143  {
5144  	iscsi_host_for_each_session(ha->host, qla4xxx_relogin_devices);
5145  }
5146  
qla4xxx_relogin_flash_ddb(struct iscsi_cls_session * cls_sess)5147  static void qla4xxx_relogin_flash_ddb(struct iscsi_cls_session *cls_sess)
5148  {
5149  	uint16_t relogin_timer;
5150  	struct iscsi_session *sess;
5151  	struct ddb_entry *ddb_entry;
5152  	struct scsi_qla_host *ha;
5153  
5154  	sess = cls_sess->dd_data;
5155  	ddb_entry = sess->dd_data;
5156  	ha = ddb_entry->ha;
5157  
5158  	relogin_timer = max(ddb_entry->default_relogin_timeout,
5159  			    (uint16_t)RELOGIN_TOV);
5160  	atomic_set(&ddb_entry->relogin_timer, relogin_timer);
5161  
5162  	DEBUG2(ql4_printk(KERN_INFO, ha,
5163  			  "scsi%ld: Relogin index [%d]. TOV=%d\n", ha->host_no,
5164  			  ddb_entry->fw_ddb_index, relogin_timer));
5165  
5166  	qla4xxx_login_flash_ddb(cls_sess);
5167  }
5168  
qla4xxx_dpc_relogin(struct iscsi_cls_session * cls_sess)5169  static void qla4xxx_dpc_relogin(struct iscsi_cls_session *cls_sess)
5170  {
5171  	struct iscsi_session *sess;
5172  	struct ddb_entry *ddb_entry;
5173  	struct scsi_qla_host *ha;
5174  
5175  	sess = cls_sess->dd_data;
5176  	ddb_entry = sess->dd_data;
5177  	ha = ddb_entry->ha;
5178  
5179  	if (!(ddb_entry->ddb_type == FLASH_DDB))
5180  		return;
5181  
5182  	if (test_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags))
5183  		return;
5184  
5185  	if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags) &&
5186  	    !iscsi_is_session_online(cls_sess)) {
5187  		DEBUG2(ql4_printk(KERN_INFO, ha,
5188  				  "relogin issued\n"));
5189  		qla4xxx_relogin_flash_ddb(cls_sess);
5190  	}
5191  }
5192  
qla4xxx_wake_dpc(struct scsi_qla_host * ha)5193  void qla4xxx_wake_dpc(struct scsi_qla_host *ha)
5194  {
5195  	if (ha->dpc_thread)
5196  		queue_work(ha->dpc_thread, &ha->dpc_work);
5197  }
5198  
5199  static struct qla4_work_evt *
qla4xxx_alloc_work(struct scsi_qla_host * ha,uint32_t data_size,enum qla4_work_type type)5200  qla4xxx_alloc_work(struct scsi_qla_host *ha, uint32_t data_size,
5201  		   enum qla4_work_type type)
5202  {
5203  	struct qla4_work_evt *e;
5204  	uint32_t size = sizeof(struct qla4_work_evt) + data_size;
5205  
5206  	e = kzalloc(size, GFP_ATOMIC);
5207  	if (!e)
5208  		return NULL;
5209  
5210  	INIT_LIST_HEAD(&e->list);
5211  	e->type = type;
5212  	return e;
5213  }
5214  
qla4xxx_post_work(struct scsi_qla_host * ha,struct qla4_work_evt * e)5215  static void qla4xxx_post_work(struct scsi_qla_host *ha,
5216  			     struct qla4_work_evt *e)
5217  {
5218  	unsigned long flags;
5219  
5220  	spin_lock_irqsave(&ha->work_lock, flags);
5221  	list_add_tail(&e->list, &ha->work_list);
5222  	spin_unlock_irqrestore(&ha->work_lock, flags);
5223  	qla4xxx_wake_dpc(ha);
5224  }
5225  
qla4xxx_post_aen_work(struct scsi_qla_host * ha,enum iscsi_host_event_code aen_code,uint32_t data_size,uint8_t * data)5226  int qla4xxx_post_aen_work(struct scsi_qla_host *ha,
5227  			  enum iscsi_host_event_code aen_code,
5228  			  uint32_t data_size, uint8_t *data)
5229  {
5230  	struct qla4_work_evt *e;
5231  
5232  	e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_AEN);
5233  	if (!e)
5234  		return QLA_ERROR;
5235  
5236  	e->u.aen.code = aen_code;
5237  	e->u.aen.data_size = data_size;
5238  	memcpy(e->u.aen.data, data, data_size);
5239  
5240  	qla4xxx_post_work(ha, e);
5241  
5242  	return QLA_SUCCESS;
5243  }
5244  
qla4xxx_post_ping_evt_work(struct scsi_qla_host * ha,uint32_t status,uint32_t pid,uint32_t data_size,uint8_t * data)5245  int qla4xxx_post_ping_evt_work(struct scsi_qla_host *ha,
5246  			       uint32_t status, uint32_t pid,
5247  			       uint32_t data_size, uint8_t *data)
5248  {
5249  	struct qla4_work_evt *e;
5250  
5251  	e = qla4xxx_alloc_work(ha, data_size, QLA4_EVENT_PING_STATUS);
5252  	if (!e)
5253  		return QLA_ERROR;
5254  
5255  	e->u.ping.status = status;
5256  	e->u.ping.pid = pid;
5257  	e->u.ping.data_size = data_size;
5258  	memcpy(e->u.ping.data, data, data_size);
5259  
5260  	qla4xxx_post_work(ha, e);
5261  
5262  	return QLA_SUCCESS;
5263  }
5264  
qla4xxx_do_work(struct scsi_qla_host * ha)5265  static void qla4xxx_do_work(struct scsi_qla_host *ha)
5266  {
5267  	struct qla4_work_evt *e, *tmp;
5268  	unsigned long flags;
5269  	LIST_HEAD(work);
5270  
5271  	spin_lock_irqsave(&ha->work_lock, flags);
5272  	list_splice_init(&ha->work_list, &work);
5273  	spin_unlock_irqrestore(&ha->work_lock, flags);
5274  
5275  	list_for_each_entry_safe(e, tmp, &work, list) {
5276  		list_del_init(&e->list);
5277  
5278  		switch (e->type) {
5279  		case QLA4_EVENT_AEN:
5280  			iscsi_post_host_event(ha->host_no,
5281  					      &qla4xxx_iscsi_transport,
5282  					      e->u.aen.code,
5283  					      e->u.aen.data_size,
5284  					      e->u.aen.data);
5285  			break;
5286  		case QLA4_EVENT_PING_STATUS:
5287  			iscsi_ping_comp_event(ha->host_no,
5288  					      &qla4xxx_iscsi_transport,
5289  					      e->u.ping.status,
5290  					      e->u.ping.pid,
5291  					      e->u.ping.data_size,
5292  					      e->u.ping.data);
5293  			break;
5294  		default:
5295  			ql4_printk(KERN_WARNING, ha, "event type: 0x%x not "
5296  				   "supported", e->type);
5297  		}
5298  		kfree(e);
5299  	}
5300  }
5301  
5302  /**
5303   * qla4xxx_do_dpc - dpc routine
5304   * @work: Context to obtain pointer to host adapter structure.
5305   *
5306   * This routine is a task that is schedule by the interrupt handler
5307   * to perform the background processing for interrupts.  We put it
5308   * on a task queue that is consumed whenever the scheduler runs; that's
5309   * so you can do anything (i.e. put the process to sleep etc).  In fact,
5310   * the mid-level tries to sleep when it reaches the driver threshold
5311   * "host->can_queue". This can cause a panic if we were in our interrupt code.
5312   **/
qla4xxx_do_dpc(struct work_struct * work)5313  static void qla4xxx_do_dpc(struct work_struct *work)
5314  {
5315  	struct scsi_qla_host *ha =
5316  		container_of(work, struct scsi_qla_host, dpc_work);
5317  	int status = QLA_ERROR;
5318  
5319  	DEBUG2(ql4_printk(KERN_INFO, ha,
5320  			  "scsi%ld: %s: DPC handler waking up. flags = 0x%08lx, dpc_flags = 0x%08lx\n",
5321  			  ha->host_no, __func__, ha->flags, ha->dpc_flags));
5322  
5323  	/* Initialization not yet finished. Don't do anything yet. */
5324  	if (!test_bit(AF_INIT_DONE, &ha->flags))
5325  		return;
5326  
5327  	if (test_bit(AF_EEH_BUSY, &ha->flags)) {
5328  		DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n",
5329  		    ha->host_no, __func__, ha->flags));
5330  		return;
5331  	}
5332  
5333  	/* post events to application */
5334  	qla4xxx_do_work(ha);
5335  
5336  	if (is_qla80XX(ha)) {
5337  		if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) {
5338  			if (is_qla8032(ha) || is_qla8042(ha)) {
5339  				ql4_printk(KERN_INFO, ha, "%s: disabling pause transmit on port 0 & 1.\n",
5340  					   __func__);
5341  				/* disable pause frame for ISP83xx */
5342  				qla4_83xx_disable_pause(ha);
5343  			}
5344  
5345  			ha->isp_ops->idc_lock(ha);
5346  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
5347  					    QLA8XXX_DEV_FAILED);
5348  			ha->isp_ops->idc_unlock(ha);
5349  			ql4_printk(KERN_INFO, ha, "HW State: FAILED\n");
5350  			qla4_8xxx_device_state_handler(ha);
5351  		}
5352  
5353  		if (test_bit(DPC_POST_IDC_ACK, &ha->dpc_flags)) {
5354  			if (is_qla8042(ha)) {
5355  				if (ha->idc_info.info2 &
5356  				    ENABLE_INTERNAL_LOOPBACK) {
5357  					ql4_printk(KERN_INFO, ha, "%s: Disabling ACB\n",
5358  						   __func__);
5359  					status = qla4_84xx_config_acb(ha,
5360  							    ACB_CONFIG_DISABLE);
5361  					if (status != QLA_SUCCESS) {
5362  						ql4_printk(KERN_INFO, ha, "%s: ACB config failed\n",
5363  							   __func__);
5364  					}
5365  				}
5366  			}
5367  			qla4_83xx_post_idc_ack(ha);
5368  			clear_bit(DPC_POST_IDC_ACK, &ha->dpc_flags);
5369  		}
5370  
5371  		if (is_qla8042(ha) &&
5372  		    test_bit(DPC_RESTORE_ACB, &ha->dpc_flags)) {
5373  			ql4_printk(KERN_INFO, ha, "%s: Restoring ACB\n",
5374  				   __func__);
5375  			if (qla4_84xx_config_acb(ha, ACB_CONFIG_SET) !=
5376  			    QLA_SUCCESS) {
5377  				ql4_printk(KERN_INFO, ha, "%s: ACB config failed ",
5378  					   __func__);
5379  			}
5380  			clear_bit(DPC_RESTORE_ACB, &ha->dpc_flags);
5381  		}
5382  
5383  		if (test_and_clear_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
5384  			qla4_8xxx_need_qsnt_handler(ha);
5385  		}
5386  	}
5387  
5388  	if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) &&
5389  	    (test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
5390  	    test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) ||
5391  	    test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))) {
5392  		if ((is_qla8022(ha) && ql4xdontresethba) ||
5393  		    ((is_qla8032(ha) || is_qla8042(ha)) &&
5394  		     qla4_83xx_idc_dontreset(ha))) {
5395  			DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n",
5396  			    ha->host_no, __func__));
5397  			clear_bit(DPC_RESET_HA, &ha->dpc_flags);
5398  			clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags);
5399  			clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
5400  			goto dpc_post_reset_ha;
5401  		}
5402  		if (test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) ||
5403  		    test_bit(DPC_RESET_HA, &ha->dpc_flags))
5404  			qla4xxx_recover_adapter(ha);
5405  
5406  		if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) {
5407  			uint8_t wait_time = RESET_INTR_TOV;
5408  
5409  			while ((readw(&ha->reg->ctrl_status) &
5410  				(CSR_SOFT_RESET | CSR_FORCE_SOFT_RESET)) != 0) {
5411  				if (--wait_time == 0)
5412  					break;
5413  				msleep(1000);
5414  			}
5415  			if (wait_time == 0)
5416  				DEBUG2(printk("scsi%ld: %s: SR|FSR "
5417  					      "bit not cleared-- resetting\n",
5418  					      ha->host_no, __func__));
5419  			qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
5420  			if (ql4xxx_lock_drvr_wait(ha) == QLA_SUCCESS) {
5421  				qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
5422  				status = qla4xxx_recover_adapter(ha);
5423  			}
5424  			clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags);
5425  			if (status == QLA_SUCCESS)
5426  				ha->isp_ops->enable_intrs(ha);
5427  		}
5428  	}
5429  
5430  dpc_post_reset_ha:
5431  	/* ---- process AEN? --- */
5432  	if (test_and_clear_bit(DPC_AEN, &ha->dpc_flags))
5433  		qla4xxx_process_aen(ha, PROCESS_ALL_AENS);
5434  
5435  	/* ---- Get DHCP IP Address? --- */
5436  	if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags))
5437  		qla4xxx_get_dhcp_ip_address(ha);
5438  
5439  	/* ---- relogin device? --- */
5440  	if (adapter_up(ha) &&
5441  	    test_and_clear_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags)) {
5442  		iscsi_host_for_each_session(ha->host, qla4xxx_dpc_relogin);
5443  	}
5444  
5445  	/* ---- link change? --- */
5446  	if (!test_bit(AF_LOOPBACK, &ha->flags) &&
5447  	    test_and_clear_bit(DPC_LINK_CHANGED, &ha->dpc_flags)) {
5448  		if (!test_bit(AF_LINK_UP, &ha->flags)) {
5449  			/* ---- link down? --- */
5450  			qla4xxx_mark_all_devices_missing(ha);
5451  		} else {
5452  			/* ---- link up? --- *
5453  			 * F/W will auto login to all devices ONLY ONCE after
5454  			 * link up during driver initialization and runtime
5455  			 * fatal error recovery.  Therefore, the driver must
5456  			 * manually relogin to devices when recovering from
5457  			 * connection failures, logouts, expired KATO, etc. */
5458  			if (test_and_clear_bit(AF_BUILD_DDB_LIST, &ha->flags)) {
5459  				qla4xxx_build_ddb_list(ha, ha->is_reset);
5460  				iscsi_host_for_each_session(ha->host,
5461  						qla4xxx_login_flash_ddb);
5462  			} else
5463  				qla4xxx_relogin_all_devices(ha);
5464  		}
5465  	}
5466  	if (test_and_clear_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags)) {
5467  		if (qla4xxx_sysfs_ddb_export(ha))
5468  			ql4_printk(KERN_ERR, ha, "%s: Error exporting ddb to sysfs\n",
5469  				   __func__);
5470  	}
5471  }
5472  
5473  /**
5474   * qla4xxx_free_adapter - release the adapter
5475   * @ha: pointer to adapter structure
5476   **/
qla4xxx_free_adapter(struct scsi_qla_host * ha)5477  static void qla4xxx_free_adapter(struct scsi_qla_host *ha)
5478  {
5479  	qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
5480  
5481  	/* Turn-off interrupts on the card. */
5482  	ha->isp_ops->disable_intrs(ha);
5483  
5484  	if (is_qla40XX(ha)) {
5485  		writel(set_rmask(CSR_SCSI_PROCESSOR_INTR),
5486  		       &ha->reg->ctrl_status);
5487  		readl(&ha->reg->ctrl_status);
5488  	} else if (is_qla8022(ha)) {
5489  		writel(0, &ha->qla4_82xx_reg->host_int);
5490  		readl(&ha->qla4_82xx_reg->host_int);
5491  	} else if (is_qla8032(ha) || is_qla8042(ha)) {
5492  		writel(0, &ha->qla4_83xx_reg->risc_intr);
5493  		readl(&ha->qla4_83xx_reg->risc_intr);
5494  	}
5495  
5496  	/* Remove timer thread, if present */
5497  	if (ha->timer_active)
5498  		qla4xxx_stop_timer(ha);
5499  
5500  	/* Kill the kernel thread for this host */
5501  	if (ha->dpc_thread)
5502  		destroy_workqueue(ha->dpc_thread);
5503  
5504  	/* Kill the kernel thread for this host */
5505  	if (ha->task_wq)
5506  		destroy_workqueue(ha->task_wq);
5507  
5508  	/* Put firmware in known state */
5509  	ha->isp_ops->reset_firmware(ha);
5510  
5511  	if (is_qla80XX(ha)) {
5512  		ha->isp_ops->idc_lock(ha);
5513  		qla4_8xxx_clear_drv_active(ha);
5514  		ha->isp_ops->idc_unlock(ha);
5515  	}
5516  
5517  	/* Detach interrupts */
5518  	qla4xxx_free_irqs(ha);
5519  
5520  	/* free extra memory */
5521  	qla4xxx_mem_free(ha);
5522  }
5523  
qla4_8xxx_iospace_config(struct scsi_qla_host * ha)5524  int qla4_8xxx_iospace_config(struct scsi_qla_host *ha)
5525  {
5526  	int status = 0;
5527  	unsigned long mem_base, mem_len;
5528  	struct pci_dev *pdev = ha->pdev;
5529  
5530  	status = pci_request_regions(pdev, DRIVER_NAME);
5531  	if (status) {
5532  		printk(KERN_WARNING
5533  		    "scsi(%ld) Failed to reserve PIO regions (%s) "
5534  		    "status=%d\n", ha->host_no, pci_name(pdev), status);
5535  		goto iospace_error_exit;
5536  	}
5537  
5538  	DEBUG2(printk(KERN_INFO "%s: revision-id=%d\n",
5539  	    __func__, pdev->revision));
5540  	ha->revision_id = pdev->revision;
5541  
5542  	/* remap phys address */
5543  	mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
5544  	mem_len = pci_resource_len(pdev, 0);
5545  	DEBUG2(printk(KERN_INFO "%s: ioremap from %lx a size of %lx\n",
5546  	    __func__, mem_base, mem_len));
5547  
5548  	/* mapping of pcibase pointer */
5549  	ha->nx_pcibase = (unsigned long)ioremap(mem_base, mem_len);
5550  	if (!ha->nx_pcibase) {
5551  		printk(KERN_ERR
5552  		    "cannot remap MMIO (%s), aborting\n", pci_name(pdev));
5553  		pci_release_regions(ha->pdev);
5554  		goto iospace_error_exit;
5555  	}
5556  
5557  	/* Mapping of IO base pointer, door bell read and write pointer */
5558  
5559  	/* mapping of IO base pointer */
5560  	if (is_qla8022(ha)) {
5561  		ha->qla4_82xx_reg = (struct device_reg_82xx  __iomem *)
5562  				    ((uint8_t *)ha->nx_pcibase + 0xbc000 +
5563  				     (ha->pdev->devfn << 11));
5564  		ha->nx_db_wr_ptr = (ha->pdev->devfn == 4 ? QLA82XX_CAM_RAM_DB1 :
5565  				    QLA82XX_CAM_RAM_DB2);
5566  	} else if (is_qla8032(ha) || is_qla8042(ha)) {
5567  		ha->qla4_83xx_reg = (struct device_reg_83xx __iomem *)
5568  				    ((uint8_t *)ha->nx_pcibase);
5569  	}
5570  
5571  	return 0;
5572  iospace_error_exit:
5573  	return -ENOMEM;
5574  }
5575  
5576  /***
5577   * qla4xxx_iospace_config - maps registers
5578   * @ha: pointer to adapter structure
5579   *
5580   * This routines maps HBA's registers from the pci address space
5581   * into the kernel virtual address space for memory mapped i/o.
5582   **/
qla4xxx_iospace_config(struct scsi_qla_host * ha)5583  int qla4xxx_iospace_config(struct scsi_qla_host *ha)
5584  {
5585  	unsigned long pio, pio_len, pio_flags;
5586  	unsigned long mmio, mmio_len, mmio_flags;
5587  
5588  	pio = pci_resource_start(ha->pdev, 0);
5589  	pio_len = pci_resource_len(ha->pdev, 0);
5590  	pio_flags = pci_resource_flags(ha->pdev, 0);
5591  	if (pio_flags & IORESOURCE_IO) {
5592  		if (pio_len < MIN_IOBASE_LEN) {
5593  			ql4_printk(KERN_WARNING, ha,
5594  				"Invalid PCI I/O region size\n");
5595  			pio = 0;
5596  		}
5597  	} else {
5598  		ql4_printk(KERN_WARNING, ha, "region #0 not a PIO resource\n");
5599  		pio = 0;
5600  	}
5601  
5602  	/* Use MMIO operations for all accesses. */
5603  	mmio = pci_resource_start(ha->pdev, 1);
5604  	mmio_len = pci_resource_len(ha->pdev, 1);
5605  	mmio_flags = pci_resource_flags(ha->pdev, 1);
5606  
5607  	if (!(mmio_flags & IORESOURCE_MEM)) {
5608  		ql4_printk(KERN_ERR, ha,
5609  		    "region #0 not an MMIO resource, aborting\n");
5610  
5611  		goto iospace_error_exit;
5612  	}
5613  
5614  	if (mmio_len < MIN_IOBASE_LEN) {
5615  		ql4_printk(KERN_ERR, ha,
5616  		    "Invalid PCI mem region size, aborting\n");
5617  		goto iospace_error_exit;
5618  	}
5619  
5620  	if (pci_request_regions(ha->pdev, DRIVER_NAME)) {
5621  		ql4_printk(KERN_WARNING, ha,
5622  		    "Failed to reserve PIO/MMIO regions\n");
5623  
5624  		goto iospace_error_exit;
5625  	}
5626  
5627  	ha->pio_address = pio;
5628  	ha->pio_length = pio_len;
5629  	ha->reg = ioremap(mmio, MIN_IOBASE_LEN);
5630  	if (!ha->reg) {
5631  		ql4_printk(KERN_ERR, ha,
5632  		    "cannot remap MMIO, aborting\n");
5633  
5634  		goto iospace_error_exit;
5635  	}
5636  
5637  	return 0;
5638  
5639  iospace_error_exit:
5640  	return -ENOMEM;
5641  }
5642  
5643  static struct isp_operations qla4xxx_isp_ops = {
5644  	.iospace_config         = qla4xxx_iospace_config,
5645  	.pci_config             = qla4xxx_pci_config,
5646  	.disable_intrs          = qla4xxx_disable_intrs,
5647  	.enable_intrs           = qla4xxx_enable_intrs,
5648  	.start_firmware         = qla4xxx_start_firmware,
5649  	.intr_handler           = qla4xxx_intr_handler,
5650  	.interrupt_service_routine = qla4xxx_interrupt_service_routine,
5651  	.reset_chip             = qla4xxx_soft_reset,
5652  	.reset_firmware         = qla4xxx_hw_reset,
5653  	.queue_iocb             = qla4xxx_queue_iocb,
5654  	.complete_iocb          = qla4xxx_complete_iocb,
5655  	.rd_shdw_req_q_out      = qla4xxx_rd_shdw_req_q_out,
5656  	.rd_shdw_rsp_q_in       = qla4xxx_rd_shdw_rsp_q_in,
5657  	.get_sys_info           = qla4xxx_get_sys_info,
5658  	.queue_mailbox_command	= qla4xxx_queue_mbox_cmd,
5659  	.process_mailbox_interrupt = qla4xxx_process_mbox_intr,
5660  };
5661  
5662  static struct isp_operations qla4_82xx_isp_ops = {
5663  	.iospace_config         = qla4_8xxx_iospace_config,
5664  	.pci_config             = qla4_8xxx_pci_config,
5665  	.disable_intrs          = qla4_82xx_disable_intrs,
5666  	.enable_intrs           = qla4_82xx_enable_intrs,
5667  	.start_firmware         = qla4_8xxx_load_risc,
5668  	.restart_firmware	= qla4_82xx_try_start_fw,
5669  	.intr_handler           = qla4_82xx_intr_handler,
5670  	.interrupt_service_routine = qla4_82xx_interrupt_service_routine,
5671  	.need_reset		= qla4_8xxx_need_reset,
5672  	.reset_chip             = qla4_82xx_isp_reset,
5673  	.reset_firmware         = qla4_8xxx_stop_firmware,
5674  	.queue_iocb             = qla4_82xx_queue_iocb,
5675  	.complete_iocb          = qla4_82xx_complete_iocb,
5676  	.rd_shdw_req_q_out      = qla4_82xx_rd_shdw_req_q_out,
5677  	.rd_shdw_rsp_q_in       = qla4_82xx_rd_shdw_rsp_q_in,
5678  	.get_sys_info           = qla4_8xxx_get_sys_info,
5679  	.rd_reg_direct		= qla4_82xx_rd_32,
5680  	.wr_reg_direct		= qla4_82xx_wr_32,
5681  	.rd_reg_indirect	= qla4_82xx_md_rd_32,
5682  	.wr_reg_indirect	= qla4_82xx_md_wr_32,
5683  	.idc_lock		= qla4_82xx_idc_lock,
5684  	.idc_unlock		= qla4_82xx_idc_unlock,
5685  	.rom_lock_recovery	= qla4_82xx_rom_lock_recovery,
5686  	.queue_mailbox_command	= qla4_82xx_queue_mbox_cmd,
5687  	.process_mailbox_interrupt = qla4_82xx_process_mbox_intr,
5688  };
5689  
5690  static struct isp_operations qla4_83xx_isp_ops = {
5691  	.iospace_config		= qla4_8xxx_iospace_config,
5692  	.pci_config		= qla4_8xxx_pci_config,
5693  	.disable_intrs		= qla4_83xx_disable_intrs,
5694  	.enable_intrs		= qla4_83xx_enable_intrs,
5695  	.start_firmware		= qla4_8xxx_load_risc,
5696  	.restart_firmware	= qla4_83xx_start_firmware,
5697  	.intr_handler		= qla4_83xx_intr_handler,
5698  	.interrupt_service_routine = qla4_83xx_interrupt_service_routine,
5699  	.need_reset		= qla4_8xxx_need_reset,
5700  	.reset_chip		= qla4_83xx_isp_reset,
5701  	.reset_firmware		= qla4_8xxx_stop_firmware,
5702  	.queue_iocb		= qla4_83xx_queue_iocb,
5703  	.complete_iocb		= qla4_83xx_complete_iocb,
5704  	.rd_shdw_req_q_out	= qla4xxx_rd_shdw_req_q_out,
5705  	.rd_shdw_rsp_q_in	= qla4xxx_rd_shdw_rsp_q_in,
5706  	.get_sys_info		= qla4_8xxx_get_sys_info,
5707  	.rd_reg_direct		= qla4_83xx_rd_reg,
5708  	.wr_reg_direct		= qla4_83xx_wr_reg,
5709  	.rd_reg_indirect	= qla4_83xx_rd_reg_indirect,
5710  	.wr_reg_indirect	= qla4_83xx_wr_reg_indirect,
5711  	.idc_lock		= qla4_83xx_drv_lock,
5712  	.idc_unlock		= qla4_83xx_drv_unlock,
5713  	.rom_lock_recovery	= qla4_83xx_rom_lock_recovery,
5714  	.queue_mailbox_command	= qla4_83xx_queue_mbox_cmd,
5715  	.process_mailbox_interrupt = qla4_83xx_process_mbox_intr,
5716  };
5717  
qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host * ha)5718  uint16_t qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha)
5719  {
5720  	return (uint16_t)le32_to_cpu(ha->shadow_regs->req_q_out);
5721  }
5722  
qla4_82xx_rd_shdw_req_q_out(struct scsi_qla_host * ha)5723  uint16_t qla4_82xx_rd_shdw_req_q_out(struct scsi_qla_host *ha)
5724  {
5725  	return (uint16_t)le32_to_cpu(readl(&ha->qla4_82xx_reg->req_q_out));
5726  }
5727  
qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host * ha)5728  uint16_t qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha)
5729  {
5730  	return (uint16_t)le32_to_cpu(ha->shadow_regs->rsp_q_in);
5731  }
5732  
qla4_82xx_rd_shdw_rsp_q_in(struct scsi_qla_host * ha)5733  uint16_t qla4_82xx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha)
5734  {
5735  	return (uint16_t)le32_to_cpu(readl(&ha->qla4_82xx_reg->rsp_q_in));
5736  }
5737  
qla4xxx_show_boot_eth_info(void * data,int type,char * buf)5738  static ssize_t qla4xxx_show_boot_eth_info(void *data, int type, char *buf)
5739  {
5740  	struct scsi_qla_host *ha = data;
5741  	char *str = buf;
5742  	int rc;
5743  
5744  	switch (type) {
5745  	case ISCSI_BOOT_ETH_FLAGS:
5746  		rc = sprintf(str, "%d\n", (char)SYSFS_FLAG_FW_SEL_BOOT);
5747  		break;
5748  	case ISCSI_BOOT_ETH_INDEX:
5749  		rc = sprintf(str, "0\n");
5750  		break;
5751  	case ISCSI_BOOT_ETH_MAC:
5752  		rc = sysfs_format_mac(str, ha->my_mac,
5753  				      MAC_ADDR_LEN);
5754  		break;
5755  	default:
5756  		rc = -ENOSYS;
5757  		break;
5758  	}
5759  	return rc;
5760  }
5761  
qla4xxx_eth_get_attr_visibility(void * data,int type)5762  static umode_t qla4xxx_eth_get_attr_visibility(void *data, int type)
5763  {
5764  	int rc;
5765  
5766  	switch (type) {
5767  	case ISCSI_BOOT_ETH_FLAGS:
5768  	case ISCSI_BOOT_ETH_MAC:
5769  	case ISCSI_BOOT_ETH_INDEX:
5770  		rc = S_IRUGO;
5771  		break;
5772  	default:
5773  		rc = 0;
5774  		break;
5775  	}
5776  	return rc;
5777  }
5778  
qla4xxx_show_boot_ini_info(void * data,int type,char * buf)5779  static ssize_t qla4xxx_show_boot_ini_info(void *data, int type, char *buf)
5780  {
5781  	struct scsi_qla_host *ha = data;
5782  	char *str = buf;
5783  	int rc;
5784  
5785  	switch (type) {
5786  	case ISCSI_BOOT_INI_INITIATOR_NAME:
5787  		rc = sprintf(str, "%s\n", ha->name_string);
5788  		break;
5789  	default:
5790  		rc = -ENOSYS;
5791  		break;
5792  	}
5793  	return rc;
5794  }
5795  
qla4xxx_ini_get_attr_visibility(void * data,int type)5796  static umode_t qla4xxx_ini_get_attr_visibility(void *data, int type)
5797  {
5798  	int rc;
5799  
5800  	switch (type) {
5801  	case ISCSI_BOOT_INI_INITIATOR_NAME:
5802  		rc = S_IRUGO;
5803  		break;
5804  	default:
5805  		rc = 0;
5806  		break;
5807  	}
5808  	return rc;
5809  }
5810  
5811  static ssize_t
qla4xxx_show_boot_tgt_info(struct ql4_boot_session_info * boot_sess,int type,char * buf)5812  qla4xxx_show_boot_tgt_info(struct ql4_boot_session_info *boot_sess, int type,
5813  			   char *buf)
5814  {
5815  	struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0];
5816  	char *str = buf;
5817  	int rc;
5818  
5819  	switch (type) {
5820  	case ISCSI_BOOT_TGT_NAME:
5821  		rc = sprintf(buf, "%s\n", (char *)&boot_sess->target_name);
5822  		break;
5823  	case ISCSI_BOOT_TGT_IP_ADDR:
5824  		if (boot_sess->conn_list[0].dest_ipaddr.ip_type == 0x1)
5825  			rc = sprintf(buf, "%pI4\n",
5826  				     &boot_conn->dest_ipaddr.ip_address);
5827  		else
5828  			rc = sprintf(str, "%pI6\n",
5829  				     &boot_conn->dest_ipaddr.ip_address);
5830  		break;
5831  	case ISCSI_BOOT_TGT_PORT:
5832  			rc = sprintf(str, "%d\n", boot_conn->dest_port);
5833  		break;
5834  	case ISCSI_BOOT_TGT_CHAP_NAME:
5835  		rc = sprintf(str,  "%.*s\n",
5836  			     boot_conn->chap.target_chap_name_length,
5837  			     (char *)&boot_conn->chap.target_chap_name);
5838  		break;
5839  	case ISCSI_BOOT_TGT_CHAP_SECRET:
5840  		rc = sprintf(str,  "%.*s\n",
5841  			     boot_conn->chap.target_secret_length,
5842  			     (char *)&boot_conn->chap.target_secret);
5843  		break;
5844  	case ISCSI_BOOT_TGT_REV_CHAP_NAME:
5845  		rc = sprintf(str,  "%.*s\n",
5846  			     boot_conn->chap.intr_chap_name_length,
5847  			     (char *)&boot_conn->chap.intr_chap_name);
5848  		break;
5849  	case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
5850  		rc = sprintf(str,  "%.*s\n",
5851  			     boot_conn->chap.intr_secret_length,
5852  			     (char *)&boot_conn->chap.intr_secret);
5853  		break;
5854  	case ISCSI_BOOT_TGT_FLAGS:
5855  		rc = sprintf(str, "%d\n", (char)SYSFS_FLAG_FW_SEL_BOOT);
5856  		break;
5857  	case ISCSI_BOOT_TGT_NIC_ASSOC:
5858  		rc = sprintf(str, "0\n");
5859  		break;
5860  	default:
5861  		rc = -ENOSYS;
5862  		break;
5863  	}
5864  	return rc;
5865  }
5866  
qla4xxx_show_boot_tgt_pri_info(void * data,int type,char * buf)5867  static ssize_t qla4xxx_show_boot_tgt_pri_info(void *data, int type, char *buf)
5868  {
5869  	struct scsi_qla_host *ha = data;
5870  	struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_pri_sess);
5871  
5872  	return qla4xxx_show_boot_tgt_info(boot_sess, type, buf);
5873  }
5874  
qla4xxx_show_boot_tgt_sec_info(void * data,int type,char * buf)5875  static ssize_t qla4xxx_show_boot_tgt_sec_info(void *data, int type, char *buf)
5876  {
5877  	struct scsi_qla_host *ha = data;
5878  	struct ql4_boot_session_info *boot_sess = &(ha->boot_tgt.boot_sec_sess);
5879  
5880  	return qla4xxx_show_boot_tgt_info(boot_sess, type, buf);
5881  }
5882  
qla4xxx_tgt_get_attr_visibility(void * data,int type)5883  static umode_t qla4xxx_tgt_get_attr_visibility(void *data, int type)
5884  {
5885  	int rc;
5886  
5887  	switch (type) {
5888  	case ISCSI_BOOT_TGT_NAME:
5889  	case ISCSI_BOOT_TGT_IP_ADDR:
5890  	case ISCSI_BOOT_TGT_PORT:
5891  	case ISCSI_BOOT_TGT_CHAP_NAME:
5892  	case ISCSI_BOOT_TGT_CHAP_SECRET:
5893  	case ISCSI_BOOT_TGT_REV_CHAP_NAME:
5894  	case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
5895  	case ISCSI_BOOT_TGT_NIC_ASSOC:
5896  	case ISCSI_BOOT_TGT_FLAGS:
5897  		rc = S_IRUGO;
5898  		break;
5899  	default:
5900  		rc = 0;
5901  		break;
5902  	}
5903  	return rc;
5904  }
5905  
qla4xxx_boot_release(void * data)5906  static void qla4xxx_boot_release(void *data)
5907  {
5908  	struct scsi_qla_host *ha = data;
5909  
5910  	scsi_host_put(ha->host);
5911  }
5912  
get_fw_boot_info(struct scsi_qla_host * ha,uint16_t ddb_index[])5913  static int get_fw_boot_info(struct scsi_qla_host *ha, uint16_t ddb_index[])
5914  {
5915  	dma_addr_t buf_dma;
5916  	uint32_t addr, pri_addr, sec_addr;
5917  	uint32_t offset;
5918  	uint16_t func_num;
5919  	uint8_t val;
5920  	uint8_t *buf = NULL;
5921  	size_t size = 13 * sizeof(uint8_t);
5922  	int ret = QLA_SUCCESS;
5923  
5924  	func_num = PCI_FUNC(ha->pdev->devfn);
5925  
5926  	ql4_printk(KERN_INFO, ha, "%s: Get FW boot info for 0x%x func %d\n",
5927  		   __func__, ha->pdev->device, func_num);
5928  
5929  	if (is_qla40XX(ha)) {
5930  		if (func_num == 1) {
5931  			addr = NVRAM_PORT0_BOOT_MODE;
5932  			pri_addr = NVRAM_PORT0_BOOT_PRI_TGT;
5933  			sec_addr = NVRAM_PORT0_BOOT_SEC_TGT;
5934  		} else if (func_num == 3) {
5935  			addr = NVRAM_PORT1_BOOT_MODE;
5936  			pri_addr = NVRAM_PORT1_BOOT_PRI_TGT;
5937  			sec_addr = NVRAM_PORT1_BOOT_SEC_TGT;
5938  		} else {
5939  			ret = QLA_ERROR;
5940  			goto exit_boot_info;
5941  		}
5942  
5943  		/* Check Boot Mode */
5944  		val = rd_nvram_byte(ha, addr);
5945  		if (!(val & 0x07)) {
5946  			DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Adapter boot "
5947  					  "options : 0x%x\n", __func__, val));
5948  			ret = QLA_ERROR;
5949  			goto exit_boot_info;
5950  		}
5951  
5952  		/* get primary valid target index */
5953  		val = rd_nvram_byte(ha, pri_addr);
5954  		if (val & BIT_7)
5955  			ddb_index[0] = (val & 0x7f);
5956  
5957  		/* get secondary valid target index */
5958  		val = rd_nvram_byte(ha, sec_addr);
5959  		if (val & BIT_7)
5960  			ddb_index[1] = (val & 0x7f);
5961  		goto exit_boot_info;
5962  	} else if (is_qla80XX(ha)) {
5963  		buf = dma_alloc_coherent(&ha->pdev->dev, size,
5964  					 &buf_dma, GFP_KERNEL);
5965  		if (!buf) {
5966  			DEBUG2(ql4_printk(KERN_ERR, ha,
5967  					  "%s: Unable to allocate dma buffer\n",
5968  					   __func__));
5969  			ret = QLA_ERROR;
5970  			goto exit_boot_info;
5971  		}
5972  
5973  		if (ha->port_num == 0)
5974  			offset = BOOT_PARAM_OFFSET_PORT0;
5975  		else if (ha->port_num == 1)
5976  			offset = BOOT_PARAM_OFFSET_PORT1;
5977  		else {
5978  			ret = QLA_ERROR;
5979  			goto exit_boot_info_free;
5980  		}
5981  		addr = FLASH_RAW_ACCESS_ADDR + (ha->hw.flt_iscsi_param * 4) +
5982  		       offset;
5983  		if (qla4xxx_get_flash(ha, buf_dma, addr,
5984  				      13 * sizeof(uint8_t)) != QLA_SUCCESS) {
5985  			DEBUG2(ql4_printk(KERN_ERR, ha, "scsi%ld: %s: Get Flash"
5986  					  " failed\n", ha->host_no, __func__));
5987  			ret = QLA_ERROR;
5988  			goto exit_boot_info_free;
5989  		}
5990  		/* Check Boot Mode */
5991  		if (!(buf[1] & 0x07)) {
5992  			DEBUG2(ql4_printk(KERN_INFO, ha, "Firmware boot options"
5993  					  " : 0x%x\n", buf[1]));
5994  			ret = QLA_ERROR;
5995  			goto exit_boot_info_free;
5996  		}
5997  
5998  		/* get primary valid target index */
5999  		if (buf[2] & BIT_7)
6000  			ddb_index[0] = buf[2] & 0x7f;
6001  
6002  		/* get secondary valid target index */
6003  		if (buf[11] & BIT_7)
6004  			ddb_index[1] = buf[11] & 0x7f;
6005  	} else {
6006  		ret = QLA_ERROR;
6007  		goto exit_boot_info;
6008  	}
6009  
6010  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary target ID %d, Secondary"
6011  			  " target ID %d\n", __func__, ddb_index[0],
6012  			  ddb_index[1]));
6013  
6014  exit_boot_info_free:
6015  	dma_free_coherent(&ha->pdev->dev, size, buf, buf_dma);
6016  exit_boot_info:
6017  	ha->pri_ddb_idx = ddb_index[0];
6018  	ha->sec_ddb_idx = ddb_index[1];
6019  	return ret;
6020  }
6021  
6022  /**
6023   * qla4xxx_get_bidi_chap - Get a BIDI CHAP user and password
6024   * @ha: pointer to adapter structure
6025   * @username: CHAP username to be returned
6026   * @password: CHAP password to be returned
6027   *
6028   * If a boot entry has BIDI CHAP enabled then we need to set the BIDI CHAP
6029   * user and password in the sysfs entry in /sys/firmware/iscsi_boot#/.
6030   * So from the CHAP cache find the first BIDI CHAP entry and set it
6031   * to the boot record in sysfs.
6032   **/
qla4xxx_get_bidi_chap(struct scsi_qla_host * ha,char * username,char * password)6033  static int qla4xxx_get_bidi_chap(struct scsi_qla_host *ha, char *username,
6034  			    char *password)
6035  {
6036  	int i, ret = -EINVAL;
6037  	int max_chap_entries = 0;
6038  	struct ql4_chap_table *chap_table;
6039  
6040  	if (is_qla80XX(ha))
6041  		max_chap_entries = (ha->hw.flt_chap_size / 2) /
6042  						sizeof(struct ql4_chap_table);
6043  	else
6044  		max_chap_entries = MAX_CHAP_ENTRIES_40XX;
6045  
6046  	if (!ha->chap_list) {
6047  		ql4_printk(KERN_ERR, ha, "Do not have CHAP table cache\n");
6048  		return ret;
6049  	}
6050  
6051  	mutex_lock(&ha->chap_sem);
6052  	for (i = 0; i < max_chap_entries; i++) {
6053  		chap_table = (struct ql4_chap_table *)ha->chap_list + i;
6054  		if (chap_table->cookie !=
6055  		    cpu_to_le16(CHAP_VALID_COOKIE)) {
6056  			continue;
6057  		}
6058  
6059  		if (chap_table->flags & BIT_7) /* local */
6060  			continue;
6061  
6062  		if (!(chap_table->flags & BIT_6)) /* Not BIDI */
6063  			continue;
6064  
6065  		strscpy(password, chap_table->secret, QL4_CHAP_MAX_SECRET_LEN);
6066  		strscpy(username, chap_table->name, QL4_CHAP_MAX_NAME_LEN);
6067  		ret = 0;
6068  		break;
6069  	}
6070  	mutex_unlock(&ha->chap_sem);
6071  
6072  	return ret;
6073  }
6074  
6075  
qla4xxx_get_boot_target(struct scsi_qla_host * ha,struct ql4_boot_session_info * boot_sess,uint16_t ddb_index)6076  static int qla4xxx_get_boot_target(struct scsi_qla_host *ha,
6077  				   struct ql4_boot_session_info *boot_sess,
6078  				   uint16_t ddb_index)
6079  {
6080  	struct ql4_conn_info *boot_conn = &boot_sess->conn_list[0];
6081  	struct dev_db_entry *fw_ddb_entry;
6082  	dma_addr_t fw_ddb_entry_dma;
6083  	uint16_t idx;
6084  	uint16_t options;
6085  	int ret = QLA_SUCCESS;
6086  
6087  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
6088  					  &fw_ddb_entry_dma, GFP_KERNEL);
6089  	if (!fw_ddb_entry) {
6090  		DEBUG2(ql4_printk(KERN_ERR, ha,
6091  				  "%s: Unable to allocate dma buffer.\n",
6092  				  __func__));
6093  		ret = QLA_ERROR;
6094  		return ret;
6095  	}
6096  
6097  	if (qla4xxx_bootdb_by_index(ha, fw_ddb_entry,
6098  				   fw_ddb_entry_dma, ddb_index)) {
6099  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: No Flash DDB found at "
6100  				  "index [%d]\n", __func__, ddb_index));
6101  		ret = QLA_ERROR;
6102  		goto exit_boot_target;
6103  	}
6104  
6105  	/* Update target name and IP from DDB */
6106  	memcpy(boot_sess->target_name, fw_ddb_entry->iscsi_name,
6107  	       min(sizeof(boot_sess->target_name),
6108  		   sizeof(fw_ddb_entry->iscsi_name)));
6109  
6110  	options = le16_to_cpu(fw_ddb_entry->options);
6111  	if (options & DDB_OPT_IPV6_DEVICE) {
6112  		memcpy(&boot_conn->dest_ipaddr.ip_address,
6113  		       &fw_ddb_entry->ip_addr[0], IPv6_ADDR_LEN);
6114  	} else {
6115  		boot_conn->dest_ipaddr.ip_type = 0x1;
6116  		memcpy(&boot_conn->dest_ipaddr.ip_address,
6117  		       &fw_ddb_entry->ip_addr[0], IP_ADDR_LEN);
6118  	}
6119  
6120  	boot_conn->dest_port = le16_to_cpu(fw_ddb_entry->port);
6121  
6122  	/* update chap information */
6123  	idx = __le16_to_cpu(fw_ddb_entry->chap_tbl_idx);
6124  
6125  	if (BIT_7 & le16_to_cpu(fw_ddb_entry->iscsi_options))	{
6126  
6127  		DEBUG2(ql4_printk(KERN_INFO, ha, "Setting chap\n"));
6128  
6129  		ret = qla4xxx_get_chap(ha, (char *)&boot_conn->chap.
6130  				       target_chap_name,
6131  				       (char *)&boot_conn->chap.target_secret,
6132  				       idx);
6133  		if (ret) {
6134  			ql4_printk(KERN_ERR, ha, "Failed to set chap\n");
6135  			ret = QLA_ERROR;
6136  			goto exit_boot_target;
6137  		}
6138  
6139  		boot_conn->chap.target_chap_name_length = QL4_CHAP_MAX_NAME_LEN;
6140  		boot_conn->chap.target_secret_length = QL4_CHAP_MAX_SECRET_LEN;
6141  	}
6142  
6143  	if (BIT_4 & le16_to_cpu(fw_ddb_entry->iscsi_options)) {
6144  
6145  		DEBUG2(ql4_printk(KERN_INFO, ha, "Setting BIDI chap\n"));
6146  
6147  		ret = qla4xxx_get_bidi_chap(ha,
6148  				    (char *)&boot_conn->chap.intr_chap_name,
6149  				    (char *)&boot_conn->chap.intr_secret);
6150  
6151  		if (ret) {
6152  			ql4_printk(KERN_ERR, ha, "Failed to set BIDI chap\n");
6153  			ret = QLA_ERROR;
6154  			goto exit_boot_target;
6155  		}
6156  
6157  		boot_conn->chap.intr_chap_name_length = QL4_CHAP_MAX_NAME_LEN;
6158  		boot_conn->chap.intr_secret_length = QL4_CHAP_MAX_SECRET_LEN;
6159  	}
6160  
6161  exit_boot_target:
6162  	dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
6163  			  fw_ddb_entry, fw_ddb_entry_dma);
6164  	return ret;
6165  }
6166  
qla4xxx_get_boot_info(struct scsi_qla_host * ha)6167  static int qla4xxx_get_boot_info(struct scsi_qla_host *ha)
6168  {
6169  	uint16_t ddb_index[2];
6170  	int ret = QLA_ERROR;
6171  	int rval;
6172  
6173  	memset(ddb_index, 0, sizeof(ddb_index));
6174  	ddb_index[0] = 0xffff;
6175  	ddb_index[1] = 0xffff;
6176  	ret = get_fw_boot_info(ha, ddb_index);
6177  	if (ret != QLA_SUCCESS) {
6178  		DEBUG2(ql4_printk(KERN_INFO, ha,
6179  				"%s: No boot target configured.\n", __func__));
6180  		return ret;
6181  	}
6182  
6183  	if (ql4xdisablesysfsboot)
6184  		return QLA_SUCCESS;
6185  
6186  	if (ddb_index[0] == 0xffff)
6187  		goto sec_target;
6188  
6189  	rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_pri_sess),
6190  				      ddb_index[0]);
6191  	if (rval != QLA_SUCCESS) {
6192  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Primary boot target not "
6193  				  "configured\n", __func__));
6194  	} else
6195  		ret = QLA_SUCCESS;
6196  
6197  sec_target:
6198  	if (ddb_index[1] == 0xffff)
6199  		goto exit_get_boot_info;
6200  
6201  	rval = qla4xxx_get_boot_target(ha, &(ha->boot_tgt.boot_sec_sess),
6202  				      ddb_index[1]);
6203  	if (rval != QLA_SUCCESS) {
6204  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Secondary boot target not"
6205  				  " configured\n", __func__));
6206  	} else
6207  		ret = QLA_SUCCESS;
6208  
6209  exit_get_boot_info:
6210  	return ret;
6211  }
6212  
qla4xxx_setup_boot_info(struct scsi_qla_host * ha)6213  static int qla4xxx_setup_boot_info(struct scsi_qla_host *ha)
6214  {
6215  	struct iscsi_boot_kobj *boot_kobj;
6216  
6217  	if (qla4xxx_get_boot_info(ha) != QLA_SUCCESS)
6218  		return QLA_ERROR;
6219  
6220  	if (ql4xdisablesysfsboot) {
6221  		ql4_printk(KERN_INFO, ha,
6222  			   "%s: syfsboot disabled - driver will trigger login "
6223  			   "and publish session for discovery .\n", __func__);
6224  		return QLA_SUCCESS;
6225  	}
6226  
6227  
6228  	ha->boot_kset = iscsi_boot_create_host_kset(ha->host->host_no);
6229  	if (!ha->boot_kset)
6230  		goto kset_free;
6231  
6232  	if (!scsi_host_get(ha->host))
6233  		goto kset_free;
6234  	boot_kobj = iscsi_boot_create_target(ha->boot_kset, 0, ha,
6235  					     qla4xxx_show_boot_tgt_pri_info,
6236  					     qla4xxx_tgt_get_attr_visibility,
6237  					     qla4xxx_boot_release);
6238  	if (!boot_kobj)
6239  		goto put_host;
6240  
6241  	if (!scsi_host_get(ha->host))
6242  		goto kset_free;
6243  	boot_kobj = iscsi_boot_create_target(ha->boot_kset, 1, ha,
6244  					     qla4xxx_show_boot_tgt_sec_info,
6245  					     qla4xxx_tgt_get_attr_visibility,
6246  					     qla4xxx_boot_release);
6247  	if (!boot_kobj)
6248  		goto put_host;
6249  
6250  	if (!scsi_host_get(ha->host))
6251  		goto kset_free;
6252  	boot_kobj = iscsi_boot_create_initiator(ha->boot_kset, 0, ha,
6253  					       qla4xxx_show_boot_ini_info,
6254  					       qla4xxx_ini_get_attr_visibility,
6255  					       qla4xxx_boot_release);
6256  	if (!boot_kobj)
6257  		goto put_host;
6258  
6259  	if (!scsi_host_get(ha->host))
6260  		goto kset_free;
6261  	boot_kobj = iscsi_boot_create_ethernet(ha->boot_kset, 0, ha,
6262  					       qla4xxx_show_boot_eth_info,
6263  					       qla4xxx_eth_get_attr_visibility,
6264  					       qla4xxx_boot_release);
6265  	if (!boot_kobj)
6266  		goto put_host;
6267  
6268  	return QLA_SUCCESS;
6269  
6270  put_host:
6271  	scsi_host_put(ha->host);
6272  kset_free:
6273  	iscsi_boot_destroy_kset(ha->boot_kset);
6274  	return -ENOMEM;
6275  }
6276  
6277  
qla4xxx_get_param_ddb(struct ddb_entry * ddb_entry,struct ql4_tuple_ddb * tddb)6278  static void qla4xxx_get_param_ddb(struct ddb_entry *ddb_entry,
6279  				  struct ql4_tuple_ddb *tddb)
6280  {
6281  	struct iscsi_cls_session *cls_sess;
6282  	struct iscsi_cls_conn *cls_conn;
6283  	struct iscsi_session *sess;
6284  	struct iscsi_conn *conn;
6285  
6286  	DEBUG2(printk(KERN_INFO "Func: %s\n", __func__));
6287  	cls_sess = ddb_entry->sess;
6288  	sess = cls_sess->dd_data;
6289  	cls_conn = ddb_entry->conn;
6290  	conn = cls_conn->dd_data;
6291  
6292  	tddb->tpgt = sess->tpgt;
6293  	tddb->port = conn->persistent_port;
6294  	strscpy(tddb->iscsi_name, sess->targetname, ISCSI_NAME_SIZE);
6295  	strscpy(tddb->ip_addr, conn->persistent_address, DDB_IPADDR_LEN);
6296  }
6297  
qla4xxx_convert_param_ddb(struct dev_db_entry * fw_ddb_entry,struct ql4_tuple_ddb * tddb,uint8_t * flash_isid)6298  static void qla4xxx_convert_param_ddb(struct dev_db_entry *fw_ddb_entry,
6299  				      struct ql4_tuple_ddb *tddb,
6300  				      uint8_t *flash_isid)
6301  {
6302  	uint16_t options = 0;
6303  
6304  	tddb->tpgt = le32_to_cpu(fw_ddb_entry->tgt_portal_grp);
6305  	memcpy(&tddb->iscsi_name[0], &fw_ddb_entry->iscsi_name[0],
6306  	       min(sizeof(tddb->iscsi_name), sizeof(fw_ddb_entry->iscsi_name)));
6307  
6308  	options = le16_to_cpu(fw_ddb_entry->options);
6309  	if (options & DDB_OPT_IPV6_DEVICE)
6310  		sprintf(tddb->ip_addr, "%pI6", fw_ddb_entry->ip_addr);
6311  	else
6312  		sprintf(tddb->ip_addr, "%pI4", fw_ddb_entry->ip_addr);
6313  
6314  	tddb->port = le16_to_cpu(fw_ddb_entry->port);
6315  
6316  	if (flash_isid == NULL)
6317  		memcpy(&tddb->isid[0], &fw_ddb_entry->isid[0],
6318  		       sizeof(tddb->isid));
6319  	else
6320  		memcpy(&tddb->isid[0], &flash_isid[0], sizeof(tddb->isid));
6321  }
6322  
qla4xxx_compare_tuple_ddb(struct scsi_qla_host * ha,struct ql4_tuple_ddb * old_tddb,struct ql4_tuple_ddb * new_tddb,uint8_t is_isid_compare)6323  static int qla4xxx_compare_tuple_ddb(struct scsi_qla_host *ha,
6324  				     struct ql4_tuple_ddb *old_tddb,
6325  				     struct ql4_tuple_ddb *new_tddb,
6326  				     uint8_t is_isid_compare)
6327  {
6328  	if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name))
6329  		return QLA_ERROR;
6330  
6331  	if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr))
6332  		return QLA_ERROR;
6333  
6334  	if (old_tddb->port != new_tddb->port)
6335  		return QLA_ERROR;
6336  
6337  	/* For multi sessions, driver generates the ISID, so do not compare
6338  	 * ISID in reset path since it would be a comparison between the
6339  	 * driver generated ISID and firmware generated ISID. This could
6340  	 * lead to adding duplicated DDBs in the list as driver generated
6341  	 * ISID would not match firmware generated ISID.
6342  	 */
6343  	if (is_isid_compare) {
6344  		DEBUG2(ql4_printk(KERN_INFO, ha,
6345  			"%s: old ISID [%pmR] New ISID [%pmR]\n",
6346  			__func__, old_tddb->isid, new_tddb->isid));
6347  
6348  		if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0],
6349  			   sizeof(old_tddb->isid)))
6350  			return QLA_ERROR;
6351  	}
6352  
6353  	DEBUG2(ql4_printk(KERN_INFO, ha,
6354  			  "Match Found, fw[%d,%d,%s,%s], [%d,%d,%s,%s]",
6355  			  old_tddb->port, old_tddb->tpgt, old_tddb->ip_addr,
6356  			  old_tddb->iscsi_name, new_tddb->port, new_tddb->tpgt,
6357  			  new_tddb->ip_addr, new_tddb->iscsi_name));
6358  
6359  	return QLA_SUCCESS;
6360  }
6361  
qla4xxx_is_session_exists(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint32_t * index)6362  static int qla4xxx_is_session_exists(struct scsi_qla_host *ha,
6363  				     struct dev_db_entry *fw_ddb_entry,
6364  				     uint32_t *index)
6365  {
6366  	struct ddb_entry *ddb_entry;
6367  	struct ql4_tuple_ddb *fw_tddb = NULL;
6368  	struct ql4_tuple_ddb *tmp_tddb = NULL;
6369  	int idx;
6370  	int ret = QLA_ERROR;
6371  
6372  	fw_tddb = vzalloc(sizeof(*fw_tddb));
6373  	if (!fw_tddb) {
6374  		DEBUG2(ql4_printk(KERN_WARNING, ha,
6375  				  "Memory Allocation failed.\n"));
6376  		ret = QLA_SUCCESS;
6377  		goto exit_check;
6378  	}
6379  
6380  	tmp_tddb = vzalloc(sizeof(*tmp_tddb));
6381  	if (!tmp_tddb) {
6382  		DEBUG2(ql4_printk(KERN_WARNING, ha,
6383  				  "Memory Allocation failed.\n"));
6384  		ret = QLA_SUCCESS;
6385  		goto exit_check;
6386  	}
6387  
6388  	qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL);
6389  
6390  	for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
6391  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
6392  		if (ddb_entry == NULL)
6393  			continue;
6394  
6395  		qla4xxx_get_param_ddb(ddb_entry, tmp_tddb);
6396  		if (!qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, false)) {
6397  			ret = QLA_SUCCESS; /* found */
6398  			if (index != NULL)
6399  				*index = idx;
6400  			goto exit_check;
6401  		}
6402  	}
6403  
6404  exit_check:
6405  	vfree(fw_tddb);
6406  	vfree(tmp_tddb);
6407  	return ret;
6408  }
6409  
6410  /**
6411   * qla4xxx_check_existing_isid - check if target with same isid exist
6412   *				 in target list
6413   * @list_nt: list of target
6414   * @isid: isid to check
6415   *
6416   * This routine return QLA_SUCCESS if target with same isid exist
6417   **/
qla4xxx_check_existing_isid(struct list_head * list_nt,uint8_t * isid)6418  static int qla4xxx_check_existing_isid(struct list_head *list_nt, uint8_t *isid)
6419  {
6420  	struct qla_ddb_index *nt_ddb_idx, *nt_ddb_idx_tmp;
6421  	struct dev_db_entry *fw_ddb_entry;
6422  
6423  	list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6424  		fw_ddb_entry = &nt_ddb_idx->fw_ddb;
6425  
6426  		if (memcmp(&fw_ddb_entry->isid[0], &isid[0],
6427  			   sizeof(nt_ddb_idx->fw_ddb.isid)) == 0) {
6428  			return QLA_SUCCESS;
6429  		}
6430  	}
6431  	return QLA_ERROR;
6432  }
6433  
6434  /**
6435   * qla4xxx_update_isid - compare ddbs and updated isid
6436   * @ha: Pointer to host adapter structure.
6437   * @list_nt: list of nt target
6438   * @fw_ddb_entry: firmware ddb entry
6439   *
6440   * This routine update isid if ddbs have same iqn, same isid and
6441   * different IP addr.
6442   * Return QLA_SUCCESS if isid is updated.
6443   **/
qla4xxx_update_isid(struct scsi_qla_host * ha,struct list_head * list_nt,struct dev_db_entry * fw_ddb_entry)6444  static int qla4xxx_update_isid(struct scsi_qla_host *ha,
6445  			       struct list_head *list_nt,
6446  			       struct dev_db_entry *fw_ddb_entry)
6447  {
6448  	uint8_t base_value, i;
6449  
6450  	base_value = fw_ddb_entry->isid[1] & 0x1f;
6451  	for (i = 0; i < 8; i++) {
6452  		fw_ddb_entry->isid[1] = (base_value | (i << 5));
6453  		if (qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid))
6454  			break;
6455  	}
6456  
6457  	if (!qla4xxx_check_existing_isid(list_nt, fw_ddb_entry->isid))
6458  		return QLA_ERROR;
6459  
6460  	return QLA_SUCCESS;
6461  }
6462  
6463  /**
6464   * qla4xxx_should_update_isid - check if isid need to update
6465   * @ha: Pointer to host adapter structure.
6466   * @old_tddb: ddb tuple
6467   * @new_tddb: ddb tuple
6468   *
6469   * Return QLA_SUCCESS if different IP, different PORT, same iqn,
6470   * same isid
6471   **/
qla4xxx_should_update_isid(struct scsi_qla_host * ha,struct ql4_tuple_ddb * old_tddb,struct ql4_tuple_ddb * new_tddb)6472  static int qla4xxx_should_update_isid(struct scsi_qla_host *ha,
6473  				      struct ql4_tuple_ddb *old_tddb,
6474  				      struct ql4_tuple_ddb *new_tddb)
6475  {
6476  	if (strcmp(old_tddb->ip_addr, new_tddb->ip_addr) == 0) {
6477  		/* Same ip */
6478  		if (old_tddb->port == new_tddb->port)
6479  			return QLA_ERROR;
6480  	}
6481  
6482  	if (strcmp(old_tddb->iscsi_name, new_tddb->iscsi_name))
6483  		/* different iqn */
6484  		return QLA_ERROR;
6485  
6486  	if (memcmp(&old_tddb->isid[0], &new_tddb->isid[0],
6487  		   sizeof(old_tddb->isid)))
6488  		/* different isid */
6489  		return QLA_ERROR;
6490  
6491  	return QLA_SUCCESS;
6492  }
6493  
6494  /**
6495   * qla4xxx_is_flash_ddb_exists - check if fw_ddb_entry already exists in list_nt
6496   * @ha: Pointer to host adapter structure.
6497   * @list_nt: list of nt target.
6498   * @fw_ddb_entry: firmware ddb entry.
6499   *
6500   * This routine check if fw_ddb_entry already exists in list_nt to avoid
6501   * duplicate ddb in list_nt.
6502   * Return QLA_SUCCESS if duplicate ddb exit in list_nl.
6503   * Note: This function also update isid of DDB if required.
6504   **/
6505  
qla4xxx_is_flash_ddb_exists(struct scsi_qla_host * ha,struct list_head * list_nt,struct dev_db_entry * fw_ddb_entry)6506  static int qla4xxx_is_flash_ddb_exists(struct scsi_qla_host *ha,
6507  				       struct list_head *list_nt,
6508  				       struct dev_db_entry *fw_ddb_entry)
6509  {
6510  	struct qla_ddb_index  *nt_ddb_idx, *nt_ddb_idx_tmp;
6511  	struct ql4_tuple_ddb *fw_tddb = NULL;
6512  	struct ql4_tuple_ddb *tmp_tddb = NULL;
6513  	int rval, ret = QLA_ERROR;
6514  
6515  	fw_tddb = vzalloc(sizeof(*fw_tddb));
6516  	if (!fw_tddb) {
6517  		DEBUG2(ql4_printk(KERN_WARNING, ha,
6518  				  "Memory Allocation failed.\n"));
6519  		ret = QLA_SUCCESS;
6520  		goto exit_check;
6521  	}
6522  
6523  	tmp_tddb = vzalloc(sizeof(*tmp_tddb));
6524  	if (!tmp_tddb) {
6525  		DEBUG2(ql4_printk(KERN_WARNING, ha,
6526  				  "Memory Allocation failed.\n"));
6527  		ret = QLA_SUCCESS;
6528  		goto exit_check;
6529  	}
6530  
6531  	qla4xxx_convert_param_ddb(fw_ddb_entry, fw_tddb, NULL);
6532  
6533  	list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6534  		qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb,
6535  					  nt_ddb_idx->flash_isid);
6536  		ret = qla4xxx_compare_tuple_ddb(ha, fw_tddb, tmp_tddb, true);
6537  		/* found duplicate ddb */
6538  		if (ret == QLA_SUCCESS)
6539  			goto exit_check;
6540  	}
6541  
6542  	list_for_each_entry_safe(nt_ddb_idx, nt_ddb_idx_tmp, list_nt, list) {
6543  		qla4xxx_convert_param_ddb(&nt_ddb_idx->fw_ddb, tmp_tddb, NULL);
6544  
6545  		ret = qla4xxx_should_update_isid(ha, tmp_tddb, fw_tddb);
6546  		if (ret == QLA_SUCCESS) {
6547  			rval = qla4xxx_update_isid(ha, list_nt, fw_ddb_entry);
6548  			if (rval == QLA_SUCCESS)
6549  				ret = QLA_ERROR;
6550  			else
6551  				ret = QLA_SUCCESS;
6552  
6553  			goto exit_check;
6554  		}
6555  	}
6556  
6557  exit_check:
6558  	vfree(fw_tddb);
6559  	vfree(tmp_tddb);
6560  	return ret;
6561  }
6562  
qla4xxx_free_ddb_list(struct list_head * list_ddb)6563  static void qla4xxx_free_ddb_list(struct list_head *list_ddb)
6564  {
6565  	struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6566  
6567  	list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6568  		list_del_init(&ddb_idx->list);
6569  		vfree(ddb_idx);
6570  	}
6571  }
6572  
qla4xxx_get_ep_fwdb(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry)6573  static struct iscsi_endpoint *qla4xxx_get_ep_fwdb(struct scsi_qla_host *ha,
6574  					struct dev_db_entry *fw_ddb_entry)
6575  {
6576  	struct iscsi_endpoint *ep;
6577  	struct sockaddr_in *addr;
6578  	struct sockaddr_in6 *addr6;
6579  	struct sockaddr *t_addr;
6580  	struct sockaddr_storage *dst_addr;
6581  	char *ip;
6582  
6583  	/* TODO: need to destroy on unload iscsi_endpoint*/
6584  	dst_addr = vmalloc(sizeof(*dst_addr));
6585  	if (!dst_addr)
6586  		return NULL;
6587  
6588  	if (fw_ddb_entry->options & DDB_OPT_IPV6_DEVICE) {
6589  		t_addr = (struct sockaddr *)dst_addr;
6590  		t_addr->sa_family = AF_INET6;
6591  		addr6 = (struct sockaddr_in6 *)dst_addr;
6592  		ip = (char *)&addr6->sin6_addr;
6593  		memcpy(ip, fw_ddb_entry->ip_addr, IPv6_ADDR_LEN);
6594  		addr6->sin6_port = htons(le16_to_cpu(fw_ddb_entry->port));
6595  
6596  	} else {
6597  		t_addr = (struct sockaddr *)dst_addr;
6598  		t_addr->sa_family = AF_INET;
6599  		addr = (struct sockaddr_in *)dst_addr;
6600  		ip = (char *)&addr->sin_addr;
6601  		memcpy(ip, fw_ddb_entry->ip_addr, IP_ADDR_LEN);
6602  		addr->sin_port = htons(le16_to_cpu(fw_ddb_entry->port));
6603  	}
6604  
6605  	ep = qla4xxx_ep_connect(ha->host, (struct sockaddr *)dst_addr, 0);
6606  	vfree(dst_addr);
6607  	return ep;
6608  }
6609  
qla4xxx_verify_boot_idx(struct scsi_qla_host * ha,uint16_t idx)6610  static int qla4xxx_verify_boot_idx(struct scsi_qla_host *ha, uint16_t idx)
6611  {
6612  	if (ql4xdisablesysfsboot)
6613  		return QLA_SUCCESS;
6614  	if (idx == ha->pri_ddb_idx || idx == ha->sec_ddb_idx)
6615  		return QLA_ERROR;
6616  	return QLA_SUCCESS;
6617  }
6618  
qla4xxx_setup_flash_ddb_entry(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry,uint16_t idx)6619  static void qla4xxx_setup_flash_ddb_entry(struct scsi_qla_host *ha,
6620  					  struct ddb_entry *ddb_entry,
6621  					  uint16_t idx)
6622  {
6623  	uint16_t def_timeout;
6624  
6625  	ddb_entry->ddb_type = FLASH_DDB;
6626  	ddb_entry->fw_ddb_index = INVALID_ENTRY;
6627  	ddb_entry->fw_ddb_device_state = DDB_DS_NO_CONNECTION_ACTIVE;
6628  	ddb_entry->ha = ha;
6629  	ddb_entry->unblock_sess = qla4xxx_unblock_flash_ddb;
6630  	ddb_entry->ddb_change = qla4xxx_flash_ddb_change;
6631  	ddb_entry->chap_tbl_idx = INVALID_ENTRY;
6632  
6633  	atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY);
6634  	atomic_set(&ddb_entry->relogin_timer, 0);
6635  	atomic_set(&ddb_entry->relogin_retry_count, 0);
6636  	def_timeout = le16_to_cpu(ddb_entry->fw_ddb_entry.def_timeout);
6637  	ddb_entry->default_relogin_timeout =
6638  		(def_timeout > LOGIN_TOV) && (def_timeout < LOGIN_TOV * 10) ?
6639  		def_timeout : LOGIN_TOV;
6640  	ddb_entry->default_time2wait =
6641  		le16_to_cpu(ddb_entry->fw_ddb_entry.iscsi_def_time2wait);
6642  
6643  	if (ql4xdisablesysfsboot &&
6644  	    (idx == ha->pri_ddb_idx || idx == ha->sec_ddb_idx))
6645  		set_bit(DF_BOOT_TGT, &ddb_entry->flags);
6646  }
6647  
qla4xxx_wait_for_ip_configuration(struct scsi_qla_host * ha)6648  static void qla4xxx_wait_for_ip_configuration(struct scsi_qla_host *ha)
6649  {
6650  	uint32_t idx = 0;
6651  	uint32_t ip_idx[IP_ADDR_COUNT] = {0, 1, 2, 3}; /* 4 IP interfaces */
6652  	uint32_t sts[MBOX_REG_COUNT];
6653  	uint32_t ip_state;
6654  	unsigned long wtime;
6655  	int ret;
6656  
6657  	wtime = jiffies + (HZ * IP_CONFIG_TOV);
6658  	do {
6659  		for (idx = 0; idx < IP_ADDR_COUNT; idx++) {
6660  			if (ip_idx[idx] == -1)
6661  				continue;
6662  
6663  			ret = qla4xxx_get_ip_state(ha, 0, ip_idx[idx], sts);
6664  
6665  			if (ret == QLA_ERROR) {
6666  				ip_idx[idx] = -1;
6667  				continue;
6668  			}
6669  
6670  			ip_state = (sts[1] & IP_STATE_MASK) >> IP_STATE_SHIFT;
6671  
6672  			DEBUG2(ql4_printk(KERN_INFO, ha,
6673  					  "Waiting for IP state for idx = %d, state = 0x%x\n",
6674  					  ip_idx[idx], ip_state));
6675  			if (ip_state == IP_ADDRSTATE_UNCONFIGURED ||
6676  			    ip_state == IP_ADDRSTATE_INVALID ||
6677  			    ip_state == IP_ADDRSTATE_PREFERRED ||
6678  			    ip_state == IP_ADDRSTATE_DEPRICATED ||
6679  			    ip_state == IP_ADDRSTATE_DISABLING)
6680  				ip_idx[idx] = -1;
6681  		}
6682  
6683  		/* Break if all IP states checked */
6684  		if ((ip_idx[0] == -1) &&
6685  		    (ip_idx[1] == -1) &&
6686  		    (ip_idx[2] == -1) &&
6687  		    (ip_idx[3] == -1))
6688  			break;
6689  		schedule_timeout_uninterruptible(HZ);
6690  	} while (time_after(wtime, jiffies));
6691  }
6692  
qla4xxx_cmp_fw_stentry(struct dev_db_entry * fw_ddb_entry,struct dev_db_entry * flash_ddb_entry)6693  static int qla4xxx_cmp_fw_stentry(struct dev_db_entry *fw_ddb_entry,
6694  				  struct dev_db_entry *flash_ddb_entry)
6695  {
6696  	uint16_t options = 0;
6697  	size_t ip_len = IP_ADDR_LEN;
6698  
6699  	options = le16_to_cpu(fw_ddb_entry->options);
6700  	if (options & DDB_OPT_IPV6_DEVICE)
6701  		ip_len = IPv6_ADDR_LEN;
6702  
6703  	if (memcmp(fw_ddb_entry->ip_addr, flash_ddb_entry->ip_addr, ip_len))
6704  		return QLA_ERROR;
6705  
6706  	if (memcmp(&fw_ddb_entry->isid[0], &flash_ddb_entry->isid[0],
6707  		   sizeof(fw_ddb_entry->isid)))
6708  		return QLA_ERROR;
6709  
6710  	if (memcmp(&fw_ddb_entry->port, &flash_ddb_entry->port,
6711  		   sizeof(fw_ddb_entry->port)))
6712  		return QLA_ERROR;
6713  
6714  	return QLA_SUCCESS;
6715  }
6716  
qla4xxx_find_flash_st_idx(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint32_t fw_idx,uint32_t * flash_index)6717  static int qla4xxx_find_flash_st_idx(struct scsi_qla_host *ha,
6718  				     struct dev_db_entry *fw_ddb_entry,
6719  				     uint32_t fw_idx, uint32_t *flash_index)
6720  {
6721  	struct dev_db_entry *flash_ddb_entry;
6722  	dma_addr_t flash_ddb_entry_dma;
6723  	uint32_t idx = 0;
6724  	int max_ddbs;
6725  	int ret = QLA_ERROR, status;
6726  
6727  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6728  				     MAX_DEV_DB_ENTRIES;
6729  
6730  	flash_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
6731  					 &flash_ddb_entry_dma);
6732  	if (flash_ddb_entry == NULL || fw_ddb_entry == NULL) {
6733  		ql4_printk(KERN_ERR, ha, "Out of memory\n");
6734  		goto exit_find_st_idx;
6735  	}
6736  
6737  	status = qla4xxx_flashdb_by_index(ha, flash_ddb_entry,
6738  					  flash_ddb_entry_dma, fw_idx);
6739  	if (status == QLA_SUCCESS) {
6740  		status = qla4xxx_cmp_fw_stentry(fw_ddb_entry, flash_ddb_entry);
6741  		if (status == QLA_SUCCESS) {
6742  			*flash_index = fw_idx;
6743  			ret = QLA_SUCCESS;
6744  			goto exit_find_st_idx;
6745  		}
6746  	}
6747  
6748  	for (idx = 0; idx < max_ddbs; idx++) {
6749  		status = qla4xxx_flashdb_by_index(ha, flash_ddb_entry,
6750  						  flash_ddb_entry_dma, idx);
6751  		if (status == QLA_ERROR)
6752  			continue;
6753  
6754  		status = qla4xxx_cmp_fw_stentry(fw_ddb_entry, flash_ddb_entry);
6755  		if (status == QLA_SUCCESS) {
6756  			*flash_index = idx;
6757  			ret = QLA_SUCCESS;
6758  			goto exit_find_st_idx;
6759  		}
6760  	}
6761  
6762  	if (idx == max_ddbs)
6763  		ql4_printk(KERN_ERR, ha, "Failed to find ST [%d] in flash\n",
6764  			   fw_idx);
6765  
6766  exit_find_st_idx:
6767  	if (flash_ddb_entry)
6768  		dma_pool_free(ha->fw_ddb_dma_pool, flash_ddb_entry,
6769  			      flash_ddb_entry_dma);
6770  
6771  	return ret;
6772  }
6773  
qla4xxx_build_st_list(struct scsi_qla_host * ha,struct list_head * list_st)6774  static void qla4xxx_build_st_list(struct scsi_qla_host *ha,
6775  				  struct list_head *list_st)
6776  {
6777  	struct qla_ddb_index  *st_ddb_idx;
6778  	int max_ddbs;
6779  	int fw_idx_size;
6780  	struct dev_db_entry *fw_ddb_entry;
6781  	dma_addr_t fw_ddb_dma;
6782  	int ret;
6783  	uint32_t idx = 0, next_idx = 0;
6784  	uint32_t state = 0, conn_err = 0;
6785  	uint32_t flash_index = -1;
6786  	uint16_t conn_id = 0;
6787  
6788  	fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
6789  				      &fw_ddb_dma);
6790  	if (fw_ddb_entry == NULL) {
6791  		DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
6792  		goto exit_st_list;
6793  	}
6794  
6795  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6796  				     MAX_DEV_DB_ENTRIES;
6797  	fw_idx_size = sizeof(struct qla_ddb_index);
6798  
6799  	for (idx = 0; idx < max_ddbs; idx = next_idx) {
6800  		ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
6801  					      NULL, &next_idx, &state,
6802  					      &conn_err, NULL, &conn_id);
6803  		if (ret == QLA_ERROR)
6804  			break;
6805  
6806  		/* Ignore DDB if invalid state (unassigned) */
6807  		if (state == DDB_DS_UNASSIGNED)
6808  			goto continue_next_st;
6809  
6810  		/* Check if ST, add to the list_st */
6811  		if (strlen((char *) fw_ddb_entry->iscsi_name) != 0)
6812  			goto continue_next_st;
6813  
6814  		st_ddb_idx = vzalloc(fw_idx_size);
6815  		if (!st_ddb_idx)
6816  			break;
6817  
6818  		ret = qla4xxx_find_flash_st_idx(ha, fw_ddb_entry, idx,
6819  						&flash_index);
6820  		if (ret == QLA_ERROR) {
6821  			ql4_printk(KERN_ERR, ha,
6822  				   "No flash entry for ST at idx [%d]\n", idx);
6823  			st_ddb_idx->flash_ddb_idx = idx;
6824  		} else {
6825  			ql4_printk(KERN_INFO, ha,
6826  				   "ST at idx [%d] is stored at flash [%d]\n",
6827  				   idx, flash_index);
6828  			st_ddb_idx->flash_ddb_idx = flash_index;
6829  		}
6830  
6831  		st_ddb_idx->fw_ddb_idx = idx;
6832  
6833  		list_add_tail(&st_ddb_idx->list, list_st);
6834  continue_next_st:
6835  		if (next_idx == 0)
6836  			break;
6837  	}
6838  
6839  exit_st_list:
6840  	if (fw_ddb_entry)
6841  		dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
6842  }
6843  
6844  /**
6845   * qla4xxx_remove_failed_ddb - Remove inactive or failed ddb from list
6846   * @ha: pointer to adapter structure
6847   * @list_ddb: List from which failed ddb to be removed
6848   *
6849   * Iterate over the list of DDBs and find and remove DDBs that are either in
6850   * no connection active state or failed state
6851   **/
qla4xxx_remove_failed_ddb(struct scsi_qla_host * ha,struct list_head * list_ddb)6852  static void qla4xxx_remove_failed_ddb(struct scsi_qla_host *ha,
6853  				      struct list_head *list_ddb)
6854  {
6855  	struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6856  	uint32_t next_idx = 0;
6857  	uint32_t state = 0, conn_err = 0;
6858  	int ret;
6859  
6860  	list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6861  		ret = qla4xxx_get_fwddb_entry(ha, ddb_idx->fw_ddb_idx,
6862  					      NULL, 0, NULL, &next_idx, &state,
6863  					      &conn_err, NULL, NULL);
6864  		if (ret == QLA_ERROR)
6865  			continue;
6866  
6867  		if (state == DDB_DS_NO_CONNECTION_ACTIVE ||
6868  		    state == DDB_DS_SESSION_FAILED) {
6869  			list_del_init(&ddb_idx->list);
6870  			vfree(ddb_idx);
6871  		}
6872  	}
6873  }
6874  
qla4xxx_update_sess_disc_idx(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry,struct dev_db_entry * fw_ddb_entry)6875  static void qla4xxx_update_sess_disc_idx(struct scsi_qla_host *ha,
6876  					 struct ddb_entry *ddb_entry,
6877  					 struct dev_db_entry *fw_ddb_entry)
6878  {
6879  	struct iscsi_cls_session *cls_sess;
6880  	struct iscsi_session *sess;
6881  	uint32_t max_ddbs = 0;
6882  	uint16_t ddb_link = -1;
6883  
6884  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
6885  				     MAX_DEV_DB_ENTRIES;
6886  
6887  	cls_sess = ddb_entry->sess;
6888  	sess = cls_sess->dd_data;
6889  
6890  	ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
6891  	if (ddb_link < max_ddbs)
6892  		sess->discovery_parent_idx = ddb_link;
6893  	else
6894  		sess->discovery_parent_idx = DDB_NO_LINK;
6895  }
6896  
qla4xxx_sess_conn_setup(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,int is_reset,uint16_t idx)6897  static int qla4xxx_sess_conn_setup(struct scsi_qla_host *ha,
6898  				   struct dev_db_entry *fw_ddb_entry,
6899  				   int is_reset, uint16_t idx)
6900  {
6901  	struct iscsi_cls_session *cls_sess;
6902  	struct iscsi_session *sess;
6903  	struct iscsi_cls_conn *cls_conn;
6904  	struct iscsi_endpoint *ep;
6905  	uint16_t cmds_max = 32;
6906  	uint16_t conn_id = 0;
6907  	uint32_t initial_cmdsn = 0;
6908  	int ret = QLA_SUCCESS;
6909  
6910  	struct ddb_entry *ddb_entry = NULL;
6911  
6912  	/* Create session object, with INVALID_ENTRY,
6913  	 * the targer_id would get set when we issue the login
6914  	 */
6915  	cls_sess = iscsi_session_setup(&qla4xxx_iscsi_transport, ha->host,
6916  				       cmds_max, sizeof(struct ddb_entry),
6917  				       sizeof(struct ql4_task_data),
6918  				       initial_cmdsn, INVALID_ENTRY);
6919  	if (!cls_sess) {
6920  		ret = QLA_ERROR;
6921  		goto exit_setup;
6922  	}
6923  
6924  	/*
6925  	 * so calling module_put function to decrement the
6926  	 * reference count.
6927  	 **/
6928  	module_put(qla4xxx_iscsi_transport.owner);
6929  	sess = cls_sess->dd_data;
6930  	ddb_entry = sess->dd_data;
6931  	ddb_entry->sess = cls_sess;
6932  
6933  	cls_sess->recovery_tmo = ql4xsess_recovery_tmo;
6934  	memcpy(&ddb_entry->fw_ddb_entry, fw_ddb_entry,
6935  	       sizeof(struct dev_db_entry));
6936  
6937  	qla4xxx_setup_flash_ddb_entry(ha, ddb_entry, idx);
6938  
6939  	cls_conn = iscsi_conn_setup(cls_sess, sizeof(struct qla_conn), conn_id);
6940  
6941  	if (!cls_conn) {
6942  		ret = QLA_ERROR;
6943  		goto exit_setup;
6944  	}
6945  
6946  	ddb_entry->conn = cls_conn;
6947  
6948  	/* Setup ep, for displaying attributes in sysfs */
6949  	ep = qla4xxx_get_ep_fwdb(ha, fw_ddb_entry);
6950  	if (ep) {
6951  		ep->conn = cls_conn;
6952  		cls_conn->ep = ep;
6953  	} else {
6954  		DEBUG2(ql4_printk(KERN_ERR, ha, "Unable to get ep\n"));
6955  		ret = QLA_ERROR;
6956  		goto exit_setup;
6957  	}
6958  
6959  	/* Update sess/conn params */
6960  	qla4xxx_copy_fwddb_param(ha, fw_ddb_entry, cls_sess, cls_conn);
6961  	qla4xxx_update_sess_disc_idx(ha, ddb_entry, fw_ddb_entry);
6962  
6963  	if (is_reset == RESET_ADAPTER) {
6964  		iscsi_block_session(cls_sess);
6965  		/* Use the relogin path to discover new devices
6966  		 *  by short-circuiting the logic of setting
6967  		 *  timer to relogin - instead set the flags
6968  		 *  to initiate login right away.
6969  		 */
6970  		set_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags);
6971  		set_bit(DF_RELOGIN, &ddb_entry->flags);
6972  	}
6973  
6974  exit_setup:
6975  	return ret;
6976  }
6977  
qla4xxx_update_fw_ddb_link(struct scsi_qla_host * ha,struct list_head * list_ddb,struct dev_db_entry * fw_ddb_entry)6978  static void qla4xxx_update_fw_ddb_link(struct scsi_qla_host *ha,
6979  				       struct list_head *list_ddb,
6980  				       struct dev_db_entry *fw_ddb_entry)
6981  {
6982  	struct qla_ddb_index  *ddb_idx, *ddb_idx_tmp;
6983  	uint16_t ddb_link;
6984  
6985  	ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
6986  
6987  	list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, list_ddb, list) {
6988  		if (ddb_idx->fw_ddb_idx == ddb_link) {
6989  			DEBUG2(ql4_printk(KERN_INFO, ha,
6990  					  "Updating NT parent idx from [%d] to [%d]\n",
6991  					  ddb_link, ddb_idx->flash_ddb_idx));
6992  			fw_ddb_entry->ddb_link =
6993  					    cpu_to_le16(ddb_idx->flash_ddb_idx);
6994  			return;
6995  		}
6996  	}
6997  }
6998  
qla4xxx_build_nt_list(struct scsi_qla_host * ha,struct list_head * list_nt,struct list_head * list_st,int is_reset)6999  static void qla4xxx_build_nt_list(struct scsi_qla_host *ha,
7000  				  struct list_head *list_nt,
7001  				  struct list_head *list_st,
7002  				  int is_reset)
7003  {
7004  	struct dev_db_entry *fw_ddb_entry;
7005  	struct ddb_entry *ddb_entry = NULL;
7006  	dma_addr_t fw_ddb_dma;
7007  	int max_ddbs;
7008  	int fw_idx_size;
7009  	int ret;
7010  	uint32_t idx = 0, next_idx = 0;
7011  	uint32_t state = 0, conn_err = 0;
7012  	uint32_t ddb_idx = -1;
7013  	uint16_t conn_id = 0;
7014  	uint16_t ddb_link = -1;
7015  	struct qla_ddb_index  *nt_ddb_idx;
7016  
7017  	fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
7018  				      &fw_ddb_dma);
7019  	if (fw_ddb_entry == NULL) {
7020  		DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
7021  		goto exit_nt_list;
7022  	}
7023  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
7024  				     MAX_DEV_DB_ENTRIES;
7025  	fw_idx_size = sizeof(struct qla_ddb_index);
7026  
7027  	for (idx = 0; idx < max_ddbs; idx = next_idx) {
7028  		ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
7029  					      NULL, &next_idx, &state,
7030  					      &conn_err, NULL, &conn_id);
7031  		if (ret == QLA_ERROR)
7032  			break;
7033  
7034  		if (qla4xxx_verify_boot_idx(ha, idx) != QLA_SUCCESS)
7035  			goto continue_next_nt;
7036  
7037  		/* Check if NT, then add to list it */
7038  		if (strlen((char *) fw_ddb_entry->iscsi_name) == 0)
7039  			goto continue_next_nt;
7040  
7041  		ddb_link = le16_to_cpu(fw_ddb_entry->ddb_link);
7042  		if (ddb_link < max_ddbs)
7043  			qla4xxx_update_fw_ddb_link(ha, list_st, fw_ddb_entry);
7044  
7045  		if (!(state == DDB_DS_NO_CONNECTION_ACTIVE ||
7046  		    state == DDB_DS_SESSION_FAILED) &&
7047  		    (is_reset == INIT_ADAPTER))
7048  			goto continue_next_nt;
7049  
7050  		DEBUG2(ql4_printk(KERN_INFO, ha,
7051  				  "Adding  DDB to session = 0x%x\n", idx));
7052  
7053  		if (is_reset == INIT_ADAPTER) {
7054  			nt_ddb_idx = vmalloc(fw_idx_size);
7055  			if (!nt_ddb_idx)
7056  				break;
7057  
7058  			nt_ddb_idx->fw_ddb_idx = idx;
7059  
7060  			/* Copy original isid as it may get updated in function
7061  			 * qla4xxx_update_isid(). We need original isid in
7062  			 * function qla4xxx_compare_tuple_ddb to find duplicate
7063  			 * target */
7064  			memcpy(&nt_ddb_idx->flash_isid[0],
7065  			       &fw_ddb_entry->isid[0],
7066  			       sizeof(nt_ddb_idx->flash_isid));
7067  
7068  			ret = qla4xxx_is_flash_ddb_exists(ha, list_nt,
7069  							  fw_ddb_entry);
7070  			if (ret == QLA_SUCCESS) {
7071  				/* free nt_ddb_idx and do not add to list_nt */
7072  				vfree(nt_ddb_idx);
7073  				goto continue_next_nt;
7074  			}
7075  
7076  			/* Copy updated isid */
7077  			memcpy(&nt_ddb_idx->fw_ddb, fw_ddb_entry,
7078  			       sizeof(struct dev_db_entry));
7079  
7080  			list_add_tail(&nt_ddb_idx->list, list_nt);
7081  		} else if (is_reset == RESET_ADAPTER) {
7082  			ret = qla4xxx_is_session_exists(ha, fw_ddb_entry,
7083  							&ddb_idx);
7084  			if (ret == QLA_SUCCESS) {
7085  				ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha,
7086  								       ddb_idx);
7087  				if (ddb_entry != NULL)
7088  					qla4xxx_update_sess_disc_idx(ha,
7089  								     ddb_entry,
7090  								  fw_ddb_entry);
7091  				goto continue_next_nt;
7092  			}
7093  		}
7094  
7095  		ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, is_reset, idx);
7096  		if (ret == QLA_ERROR)
7097  			goto exit_nt_list;
7098  
7099  continue_next_nt:
7100  		if (next_idx == 0)
7101  			break;
7102  	}
7103  
7104  exit_nt_list:
7105  	if (fw_ddb_entry)
7106  		dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7107  }
7108  
qla4xxx_build_new_nt_list(struct scsi_qla_host * ha,struct list_head * list_nt,uint16_t target_id)7109  static void qla4xxx_build_new_nt_list(struct scsi_qla_host *ha,
7110  				      struct list_head *list_nt,
7111  				      uint16_t target_id)
7112  {
7113  	struct dev_db_entry *fw_ddb_entry;
7114  	dma_addr_t fw_ddb_dma;
7115  	int max_ddbs;
7116  	int fw_idx_size;
7117  	int ret;
7118  	uint32_t idx = 0, next_idx = 0;
7119  	uint32_t state = 0, conn_err = 0;
7120  	uint16_t conn_id = 0;
7121  	struct qla_ddb_index  *nt_ddb_idx;
7122  
7123  	fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
7124  				      &fw_ddb_dma);
7125  	if (fw_ddb_entry == NULL) {
7126  		DEBUG2(ql4_printk(KERN_ERR, ha, "Out of memory\n"));
7127  		goto exit_new_nt_list;
7128  	}
7129  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
7130  				     MAX_DEV_DB_ENTRIES;
7131  	fw_idx_size = sizeof(struct qla_ddb_index);
7132  
7133  	for (idx = 0; idx < max_ddbs; idx = next_idx) {
7134  		ret = qla4xxx_get_fwddb_entry(ha, idx, fw_ddb_entry, fw_ddb_dma,
7135  					      NULL, &next_idx, &state,
7136  					      &conn_err, NULL, &conn_id);
7137  		if (ret == QLA_ERROR)
7138  			break;
7139  
7140  		/* Check if NT, then add it to list */
7141  		if (strlen((char *)fw_ddb_entry->iscsi_name) == 0)
7142  			goto continue_next_new_nt;
7143  
7144  		if (!(state == DDB_DS_NO_CONNECTION_ACTIVE))
7145  			goto continue_next_new_nt;
7146  
7147  		DEBUG2(ql4_printk(KERN_INFO, ha,
7148  				  "Adding  DDB to session = 0x%x\n", idx));
7149  
7150  		nt_ddb_idx = vmalloc(fw_idx_size);
7151  		if (!nt_ddb_idx)
7152  			break;
7153  
7154  		nt_ddb_idx->fw_ddb_idx = idx;
7155  
7156  		ret = qla4xxx_is_session_exists(ha, fw_ddb_entry, NULL);
7157  		if (ret == QLA_SUCCESS) {
7158  			/* free nt_ddb_idx and do not add to list_nt */
7159  			vfree(nt_ddb_idx);
7160  			goto continue_next_new_nt;
7161  		}
7162  
7163  		if (target_id < max_ddbs)
7164  			fw_ddb_entry->ddb_link = cpu_to_le16(target_id);
7165  
7166  		list_add_tail(&nt_ddb_idx->list, list_nt);
7167  
7168  		ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, RESET_ADAPTER,
7169  					      idx);
7170  		if (ret == QLA_ERROR)
7171  			goto exit_new_nt_list;
7172  
7173  continue_next_new_nt:
7174  		if (next_idx == 0)
7175  			break;
7176  	}
7177  
7178  exit_new_nt_list:
7179  	if (fw_ddb_entry)
7180  		dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7181  }
7182  
7183  /**
7184   * qla4xxx_sysfs_ddb_is_non_persistent - check for non-persistence of ddb entry
7185   * @dev: dev associated with the sysfs entry
7186   * @data: pointer to flashnode session object
7187   *
7188   * Returns:
7189   *	1: if flashnode entry is non-persistent
7190   *	0: if flashnode entry is persistent
7191   **/
qla4xxx_sysfs_ddb_is_non_persistent(struct device * dev,void * data)7192  static int qla4xxx_sysfs_ddb_is_non_persistent(struct device *dev, void *data)
7193  {
7194  	struct iscsi_bus_flash_session *fnode_sess;
7195  
7196  	if (!iscsi_flashnode_bus_match(dev, NULL))
7197  		return 0;
7198  
7199  	fnode_sess = iscsi_dev_to_flash_session(dev);
7200  
7201  	return (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT);
7202  }
7203  
7204  /**
7205   * qla4xxx_sysfs_ddb_tgt_create - Create sysfs entry for target
7206   * @ha: pointer to host
7207   * @fw_ddb_entry: flash ddb data
7208   * @idx: target index
7209   * @user: if set then this call is made from userland else from kernel
7210   *
7211   * Returns:
7212   * On sucess: QLA_SUCCESS
7213   * On failure: QLA_ERROR
7214   *
7215   * This create separate sysfs entries for session and connection attributes of
7216   * the given fw ddb entry.
7217   * If this is invoked as a result of a userspace call then the entry is marked
7218   * as nonpersistent using flash_state field.
7219   **/
qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint16_t * idx,int user)7220  static int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
7221  					struct dev_db_entry *fw_ddb_entry,
7222  					uint16_t *idx, int user)
7223  {
7224  	struct iscsi_bus_flash_session *fnode_sess = NULL;
7225  	struct iscsi_bus_flash_conn *fnode_conn = NULL;
7226  	int rc = QLA_ERROR;
7227  
7228  	fnode_sess = iscsi_create_flashnode_sess(ha->host, *idx,
7229  						 &qla4xxx_iscsi_transport, 0);
7230  	if (!fnode_sess) {
7231  		ql4_printk(KERN_ERR, ha,
7232  			   "%s: Unable to create session sysfs entry for flashnode %d of host%lu\n",
7233  			   __func__, *idx, ha->host_no);
7234  		goto exit_tgt_create;
7235  	}
7236  
7237  	fnode_conn = iscsi_create_flashnode_conn(ha->host, fnode_sess,
7238  						 &qla4xxx_iscsi_transport, 0);
7239  	if (!fnode_conn) {
7240  		ql4_printk(KERN_ERR, ha,
7241  			   "%s: Unable to create conn sysfs entry for flashnode %d of host%lu\n",
7242  			   __func__, *idx, ha->host_no);
7243  		goto free_sess;
7244  	}
7245  
7246  	if (user) {
7247  		fnode_sess->flash_state = DEV_DB_NON_PERSISTENT;
7248  	} else {
7249  		fnode_sess->flash_state = DEV_DB_PERSISTENT;
7250  
7251  		if (*idx == ha->pri_ddb_idx || *idx == ha->sec_ddb_idx)
7252  			fnode_sess->is_boot_target = 1;
7253  		else
7254  			fnode_sess->is_boot_target = 0;
7255  	}
7256  
7257  	rc = qla4xxx_copy_from_fwddb_param(fnode_sess, fnode_conn,
7258  					   fw_ddb_entry);
7259  	if (rc)
7260  		goto free_sess;
7261  
7262  	ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
7263  		   __func__, fnode_sess->dev.kobj.name);
7264  
7265  	ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
7266  		   __func__, fnode_conn->dev.kobj.name);
7267  
7268  	return QLA_SUCCESS;
7269  
7270  free_sess:
7271  	iscsi_destroy_flashnode_sess(fnode_sess);
7272  
7273  exit_tgt_create:
7274  	return QLA_ERROR;
7275  }
7276  
7277  /**
7278   * qla4xxx_sysfs_ddb_add - Add new ddb entry in flash
7279   * @shost: pointer to host
7280   * @buf: type of ddb entry (ipv4/ipv6)
7281   * @len: length of buf
7282   *
7283   * This creates new ddb entry in the flash by finding first free index and
7284   * storing default ddb there. And then create sysfs entry for the new ddb entry.
7285   **/
qla4xxx_sysfs_ddb_add(struct Scsi_Host * shost,const char * buf,int len)7286  static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
7287  				 int len)
7288  {
7289  	struct scsi_qla_host *ha = to_qla_host(shost);
7290  	struct dev_db_entry *fw_ddb_entry = NULL;
7291  	dma_addr_t fw_ddb_entry_dma;
7292  	struct device *dev;
7293  	uint16_t idx = 0;
7294  	uint16_t max_ddbs = 0;
7295  	uint32_t options = 0;
7296  	uint32_t rval = QLA_ERROR;
7297  
7298  	if (strncasecmp(PORTAL_TYPE_IPV4, buf, 4) &&
7299  	    strncasecmp(PORTAL_TYPE_IPV6, buf, 4)) {
7300  		DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Invalid portal type\n",
7301  				  __func__));
7302  		goto exit_ddb_add;
7303  	}
7304  
7305  	max_ddbs =  is_qla40XX(ha) ? MAX_PRST_DEV_DB_ENTRIES :
7306  				     MAX_DEV_DB_ENTRIES;
7307  
7308  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7309  					  &fw_ddb_entry_dma, GFP_KERNEL);
7310  	if (!fw_ddb_entry) {
7311  		DEBUG2(ql4_printk(KERN_ERR, ha,
7312  				  "%s: Unable to allocate dma buffer\n",
7313  				  __func__));
7314  		goto exit_ddb_add;
7315  	}
7316  
7317  	dev = iscsi_find_flashnode_sess(ha->host, NULL,
7318  					qla4xxx_sysfs_ddb_is_non_persistent);
7319  	if (dev) {
7320  		ql4_printk(KERN_ERR, ha,
7321  			   "%s: A non-persistent entry %s found\n",
7322  			   __func__, dev->kobj.name);
7323  		put_device(dev);
7324  		goto exit_ddb_add;
7325  	}
7326  
7327  	/* Index 0 and 1 are reserved for boot target entries */
7328  	for (idx = 2; idx < max_ddbs; idx++) {
7329  		if (qla4xxx_flashdb_by_index(ha, fw_ddb_entry,
7330  					     fw_ddb_entry_dma, idx))
7331  			break;
7332  	}
7333  
7334  	if (idx == max_ddbs)
7335  		goto exit_ddb_add;
7336  
7337  	if (!strncasecmp("ipv6", buf, 4))
7338  		options |= IPV6_DEFAULT_DDB_ENTRY;
7339  
7340  	rval = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7341  	if (rval == QLA_ERROR)
7342  		goto exit_ddb_add;
7343  
7344  	rval = qla4xxx_sysfs_ddb_tgt_create(ha, fw_ddb_entry, &idx, 1);
7345  
7346  exit_ddb_add:
7347  	if (fw_ddb_entry)
7348  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7349  				  fw_ddb_entry, fw_ddb_entry_dma);
7350  	if (rval == QLA_SUCCESS)
7351  		return idx;
7352  	else
7353  		return -EIO;
7354  }
7355  
7356  /**
7357   * qla4xxx_sysfs_ddb_apply - write the target ddb contents to Flash
7358   * @fnode_sess: pointer to session attrs of flash ddb entry
7359   * @fnode_conn: pointer to connection attrs of flash ddb entry
7360   *
7361   * This writes the contents of target ddb buffer to Flash with a valid cookie
7362   * value in order to make the ddb entry persistent.
7363   **/
qla4xxx_sysfs_ddb_apply(struct iscsi_bus_flash_session * fnode_sess,struct iscsi_bus_flash_conn * fnode_conn)7364  static int  qla4xxx_sysfs_ddb_apply(struct iscsi_bus_flash_session *fnode_sess,
7365  				    struct iscsi_bus_flash_conn *fnode_conn)
7366  {
7367  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7368  	struct scsi_qla_host *ha = to_qla_host(shost);
7369  	uint32_t dev_db_start_offset = FLASH_OFFSET_DB_INFO;
7370  	struct dev_db_entry *fw_ddb_entry = NULL;
7371  	dma_addr_t fw_ddb_entry_dma;
7372  	uint32_t options = 0;
7373  	int rval = 0;
7374  
7375  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7376  					  &fw_ddb_entry_dma, GFP_KERNEL);
7377  	if (!fw_ddb_entry) {
7378  		DEBUG2(ql4_printk(KERN_ERR, ha,
7379  				  "%s: Unable to allocate dma buffer\n",
7380  				  __func__));
7381  		rval = -ENOMEM;
7382  		goto exit_ddb_apply;
7383  	}
7384  
7385  	if (!strncasecmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7386  		options |= IPV6_DEFAULT_DDB_ENTRY;
7387  
7388  	rval = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7389  	if (rval == QLA_ERROR)
7390  		goto exit_ddb_apply;
7391  
7392  	dev_db_start_offset += (fnode_sess->target_id *
7393  				sizeof(*fw_ddb_entry));
7394  
7395  	qla4xxx_copy_to_fwddb_param(fnode_sess, fnode_conn, fw_ddb_entry);
7396  	fw_ddb_entry->cookie = DDB_VALID_COOKIE;
7397  
7398  	rval = qla4xxx_set_flash(ha, fw_ddb_entry_dma, dev_db_start_offset,
7399  				 sizeof(*fw_ddb_entry), FLASH_OPT_RMW_COMMIT);
7400  
7401  	if (rval == QLA_SUCCESS) {
7402  		fnode_sess->flash_state = DEV_DB_PERSISTENT;
7403  		ql4_printk(KERN_INFO, ha,
7404  			   "%s: flash node %u of host %lu written to flash\n",
7405  			   __func__, fnode_sess->target_id, ha->host_no);
7406  	} else {
7407  		rval = -EIO;
7408  		ql4_printk(KERN_ERR, ha,
7409  			   "%s: Error while writing flash node %u of host %lu to flash\n",
7410  			   __func__, fnode_sess->target_id, ha->host_no);
7411  	}
7412  
7413  exit_ddb_apply:
7414  	if (fw_ddb_entry)
7415  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7416  				  fw_ddb_entry, fw_ddb_entry_dma);
7417  	return rval;
7418  }
7419  
qla4xxx_sysfs_ddb_conn_open(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint16_t idx)7420  static ssize_t qla4xxx_sysfs_ddb_conn_open(struct scsi_qla_host *ha,
7421  					   struct dev_db_entry *fw_ddb_entry,
7422  					   uint16_t idx)
7423  {
7424  	struct dev_db_entry *ddb_entry = NULL;
7425  	dma_addr_t ddb_entry_dma;
7426  	unsigned long wtime;
7427  	uint32_t mbx_sts = 0;
7428  	uint32_t state = 0, conn_err = 0;
7429  	uint16_t tmo = 0;
7430  	int ret = 0;
7431  
7432  	ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*ddb_entry),
7433  				       &ddb_entry_dma, GFP_KERNEL);
7434  	if (!ddb_entry) {
7435  		DEBUG2(ql4_printk(KERN_ERR, ha,
7436  				  "%s: Unable to allocate dma buffer\n",
7437  				  __func__));
7438  		return QLA_ERROR;
7439  	}
7440  
7441  	memcpy(ddb_entry, fw_ddb_entry, sizeof(*ddb_entry));
7442  
7443  	ret = qla4xxx_set_ddb_entry(ha, idx, ddb_entry_dma, &mbx_sts);
7444  	if (ret != QLA_SUCCESS) {
7445  		DEBUG2(ql4_printk(KERN_ERR, ha,
7446  				  "%s: Unable to set ddb entry for index %d\n",
7447  				  __func__, idx));
7448  		goto exit_ddb_conn_open;
7449  	}
7450  
7451  	qla4xxx_conn_open(ha, idx);
7452  
7453  	/* To ensure that sendtargets is done, wait for at least 12 secs */
7454  	tmo = ((ha->def_timeout > LOGIN_TOV) &&
7455  	       (ha->def_timeout < LOGIN_TOV * 10) ?
7456  	       ha->def_timeout : LOGIN_TOV);
7457  
7458  	DEBUG2(ql4_printk(KERN_INFO, ha,
7459  			  "Default time to wait for login to ddb %d\n", tmo));
7460  
7461  	wtime = jiffies + (HZ * tmo);
7462  	do {
7463  		ret = qla4xxx_get_fwddb_entry(ha, idx, NULL, 0, NULL,
7464  					      NULL, &state, &conn_err, NULL,
7465  					      NULL);
7466  		if (ret == QLA_ERROR)
7467  			continue;
7468  
7469  		if (state == DDB_DS_NO_CONNECTION_ACTIVE ||
7470  		    state == DDB_DS_SESSION_FAILED)
7471  			break;
7472  
7473  		schedule_timeout_uninterruptible(HZ / 10);
7474  	} while (time_after(wtime, jiffies));
7475  
7476  exit_ddb_conn_open:
7477  	if (ddb_entry)
7478  		dma_free_coherent(&ha->pdev->dev, sizeof(*ddb_entry),
7479  				  ddb_entry, ddb_entry_dma);
7480  	return ret;
7481  }
7482  
qla4xxx_ddb_login_st(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint16_t target_id)7483  static int qla4xxx_ddb_login_st(struct scsi_qla_host *ha,
7484  				struct dev_db_entry *fw_ddb_entry,
7485  				uint16_t target_id)
7486  {
7487  	struct qla_ddb_index *ddb_idx, *ddb_idx_tmp;
7488  	struct list_head list_nt;
7489  	uint16_t ddb_index;
7490  	int ret = 0;
7491  
7492  	if (test_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags)) {
7493  		ql4_printk(KERN_WARNING, ha,
7494  			   "%s: A discovery already in progress!\n", __func__);
7495  		return QLA_ERROR;
7496  	}
7497  
7498  	INIT_LIST_HEAD(&list_nt);
7499  
7500  	set_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags);
7501  
7502  	ret = qla4xxx_get_ddb_index(ha, &ddb_index);
7503  	if (ret == QLA_ERROR)
7504  		goto exit_login_st_clr_bit;
7505  
7506  	ret = qla4xxx_sysfs_ddb_conn_open(ha, fw_ddb_entry, ddb_index);
7507  	if (ret == QLA_ERROR)
7508  		goto exit_login_st;
7509  
7510  	qla4xxx_build_new_nt_list(ha, &list_nt, target_id);
7511  
7512  	list_for_each_entry_safe(ddb_idx, ddb_idx_tmp, &list_nt, list) {
7513  		list_del_init(&ddb_idx->list);
7514  		qla4xxx_clear_ddb_entry(ha, ddb_idx->fw_ddb_idx);
7515  		vfree(ddb_idx);
7516  	}
7517  
7518  exit_login_st:
7519  	if (qla4xxx_clear_ddb_entry(ha, ddb_index) == QLA_ERROR) {
7520  		ql4_printk(KERN_ERR, ha,
7521  			   "Unable to clear DDB index = 0x%x\n", ddb_index);
7522  	}
7523  
7524  	clear_bit(ddb_index, ha->ddb_idx_map);
7525  
7526  exit_login_st_clr_bit:
7527  	clear_bit(AF_ST_DISCOVERY_IN_PROGRESS, &ha->flags);
7528  	return ret;
7529  }
7530  
qla4xxx_ddb_login_nt(struct scsi_qla_host * ha,struct dev_db_entry * fw_ddb_entry,uint16_t idx)7531  static int qla4xxx_ddb_login_nt(struct scsi_qla_host *ha,
7532  				struct dev_db_entry *fw_ddb_entry,
7533  				uint16_t idx)
7534  {
7535  	int ret = QLA_ERROR;
7536  
7537  	ret = qla4xxx_is_session_exists(ha, fw_ddb_entry, NULL);
7538  	if (ret != QLA_SUCCESS)
7539  		ret = qla4xxx_sess_conn_setup(ha, fw_ddb_entry, RESET_ADAPTER,
7540  					      idx);
7541  	else
7542  		ret = -EPERM;
7543  
7544  	return ret;
7545  }
7546  
7547  /**
7548   * qla4xxx_sysfs_ddb_login - Login to the specified target
7549   * @fnode_sess: pointer to session attrs of flash ddb entry
7550   * @fnode_conn: pointer to connection attrs of flash ddb entry
7551   *
7552   * This logs in to the specified target
7553   **/
qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session * fnode_sess,struct iscsi_bus_flash_conn * fnode_conn)7554  static int qla4xxx_sysfs_ddb_login(struct iscsi_bus_flash_session *fnode_sess,
7555  				   struct iscsi_bus_flash_conn *fnode_conn)
7556  {
7557  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7558  	struct scsi_qla_host *ha = to_qla_host(shost);
7559  	struct dev_db_entry *fw_ddb_entry = NULL;
7560  	dma_addr_t fw_ddb_entry_dma;
7561  	uint32_t options = 0;
7562  	int ret = 0;
7563  
7564  	if (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT) {
7565  		ql4_printk(KERN_ERR, ha,
7566  			   "%s: Target info is not persistent\n", __func__);
7567  		ret = -EIO;
7568  		goto exit_ddb_login;
7569  	}
7570  
7571  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7572  					  &fw_ddb_entry_dma, GFP_KERNEL);
7573  	if (!fw_ddb_entry) {
7574  		DEBUG2(ql4_printk(KERN_ERR, ha,
7575  				  "%s: Unable to allocate dma buffer\n",
7576  				  __func__));
7577  		ret = -ENOMEM;
7578  		goto exit_ddb_login;
7579  	}
7580  
7581  	if (!strncasecmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7582  		options |= IPV6_DEFAULT_DDB_ENTRY;
7583  
7584  	ret = qla4xxx_get_default_ddb(ha, options, fw_ddb_entry_dma);
7585  	if (ret == QLA_ERROR)
7586  		goto exit_ddb_login;
7587  
7588  	qla4xxx_copy_to_fwddb_param(fnode_sess, fnode_conn, fw_ddb_entry);
7589  	fw_ddb_entry->cookie = DDB_VALID_COOKIE;
7590  
7591  	if (strlen((char *)fw_ddb_entry->iscsi_name) == 0)
7592  		ret = qla4xxx_ddb_login_st(ha, fw_ddb_entry,
7593  					   fnode_sess->target_id);
7594  	else
7595  		ret = qla4xxx_ddb_login_nt(ha, fw_ddb_entry,
7596  					   fnode_sess->target_id);
7597  
7598  	if (ret > 0)
7599  		ret = -EIO;
7600  
7601  exit_ddb_login:
7602  	if (fw_ddb_entry)
7603  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7604  				  fw_ddb_entry, fw_ddb_entry_dma);
7605  	return ret;
7606  }
7607  
7608  /**
7609   * qla4xxx_sysfs_ddb_logout_sid - Logout session for the specified target
7610   * @cls_sess: pointer to session to be logged out
7611   *
7612   * This performs session log out from the specified target
7613   **/
qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session * cls_sess)7614  static int qla4xxx_sysfs_ddb_logout_sid(struct iscsi_cls_session *cls_sess)
7615  {
7616  	struct iscsi_session *sess;
7617  	struct ddb_entry *ddb_entry = NULL;
7618  	struct scsi_qla_host *ha;
7619  	struct dev_db_entry *fw_ddb_entry = NULL;
7620  	dma_addr_t fw_ddb_entry_dma;
7621  	unsigned long flags;
7622  	unsigned long wtime;
7623  	uint32_t ddb_state;
7624  	int options;
7625  	int ret = 0;
7626  
7627  	sess = cls_sess->dd_data;
7628  	ddb_entry = sess->dd_data;
7629  	ha = ddb_entry->ha;
7630  
7631  	if (ddb_entry->ddb_type != FLASH_DDB) {
7632  		ql4_printk(KERN_ERR, ha, "%s: Not a flash node session\n",
7633  			   __func__);
7634  		ret = -ENXIO;
7635  		goto exit_ddb_logout;
7636  	}
7637  
7638  	if (test_bit(DF_BOOT_TGT, &ddb_entry->flags)) {
7639  		ql4_printk(KERN_ERR, ha,
7640  			   "%s: Logout from boot target entry is not permitted.\n",
7641  			   __func__);
7642  		ret = -EPERM;
7643  		goto exit_ddb_logout;
7644  	}
7645  
7646  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7647  					  &fw_ddb_entry_dma, GFP_KERNEL);
7648  	if (!fw_ddb_entry) {
7649  		ql4_printk(KERN_ERR, ha,
7650  			   "%s: Unable to allocate dma buffer\n", __func__);
7651  		ret = -ENOMEM;
7652  		goto exit_ddb_logout;
7653  	}
7654  
7655  	if (test_and_set_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags))
7656  		goto ddb_logout_init;
7657  
7658  	ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
7659  				      fw_ddb_entry, fw_ddb_entry_dma,
7660  				      NULL, NULL, &ddb_state, NULL,
7661  				      NULL, NULL);
7662  	if (ret == QLA_ERROR)
7663  		goto ddb_logout_init;
7664  
7665  	if (ddb_state == DDB_DS_SESSION_ACTIVE)
7666  		goto ddb_logout_init;
7667  
7668  	/* wait until next relogin is triggered using DF_RELOGIN and
7669  	 * clear DF_RELOGIN to avoid invocation of further relogin
7670  	 */
7671  	wtime = jiffies + (HZ * RELOGIN_TOV);
7672  	do {
7673  		if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags))
7674  			goto ddb_logout_init;
7675  
7676  		schedule_timeout_uninterruptible(HZ);
7677  	} while ((time_after(wtime, jiffies)));
7678  
7679  ddb_logout_init:
7680  	atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY);
7681  	atomic_set(&ddb_entry->relogin_timer, 0);
7682  
7683  	options = LOGOUT_OPTION_CLOSE_SESSION;
7684  	qla4xxx_session_logout_ddb(ha, ddb_entry, options);
7685  
7686  	memset(fw_ddb_entry, 0, sizeof(*fw_ddb_entry));
7687  	wtime = jiffies + (HZ * LOGOUT_TOV);
7688  	do {
7689  		ret = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
7690  					      fw_ddb_entry, fw_ddb_entry_dma,
7691  					      NULL, NULL, &ddb_state, NULL,
7692  					      NULL, NULL);
7693  		if (ret == QLA_ERROR)
7694  			goto ddb_logout_clr_sess;
7695  
7696  		if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
7697  		    (ddb_state == DDB_DS_SESSION_FAILED))
7698  			goto ddb_logout_clr_sess;
7699  
7700  		schedule_timeout_uninterruptible(HZ);
7701  	} while ((time_after(wtime, jiffies)));
7702  
7703  ddb_logout_clr_sess:
7704  	qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
7705  	/*
7706  	 * we have decremented the reference count of the driver
7707  	 * when we setup the session to have the driver unload
7708  	 * to be seamless without actually destroying the
7709  	 * session
7710  	 **/
7711  	try_module_get(qla4xxx_iscsi_transport.owner);
7712  	iscsi_destroy_endpoint(ddb_entry->conn->ep);
7713  
7714  	spin_lock_irqsave(&ha->hardware_lock, flags);
7715  	qla4xxx_free_ddb(ha, ddb_entry);
7716  	clear_bit(ddb_entry->fw_ddb_index, ha->ddb_idx_map);
7717  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
7718  
7719  	iscsi_session_teardown(ddb_entry->sess);
7720  
7721  	clear_bit(DF_DISABLE_RELOGIN, &ddb_entry->flags);
7722  	ret = QLA_SUCCESS;
7723  
7724  exit_ddb_logout:
7725  	if (fw_ddb_entry)
7726  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
7727  				  fw_ddb_entry, fw_ddb_entry_dma);
7728  	return ret;
7729  }
7730  
7731  /**
7732   * qla4xxx_sysfs_ddb_logout - Logout from the specified target
7733   * @fnode_sess: pointer to session attrs of flash ddb entry
7734   * @fnode_conn: pointer to connection attrs of flash ddb entry
7735   *
7736   * This performs log out from the specified target
7737   **/
qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session * fnode_sess,struct iscsi_bus_flash_conn * fnode_conn)7738  static int qla4xxx_sysfs_ddb_logout(struct iscsi_bus_flash_session *fnode_sess,
7739  				    struct iscsi_bus_flash_conn *fnode_conn)
7740  {
7741  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7742  	struct scsi_qla_host *ha = to_qla_host(shost);
7743  	struct ql4_tuple_ddb *flash_tddb = NULL;
7744  	struct ql4_tuple_ddb *tmp_tddb = NULL;
7745  	struct dev_db_entry *fw_ddb_entry = NULL;
7746  	struct ddb_entry *ddb_entry = NULL;
7747  	dma_addr_t fw_ddb_dma;
7748  	uint32_t next_idx = 0;
7749  	uint32_t state = 0, conn_err = 0;
7750  	uint16_t conn_id = 0;
7751  	int idx, index;
7752  	int status, ret = 0;
7753  
7754  	fw_ddb_entry = dma_pool_alloc(ha->fw_ddb_dma_pool, GFP_KERNEL,
7755  				      &fw_ddb_dma);
7756  	if (fw_ddb_entry == NULL) {
7757  		ql4_printk(KERN_ERR, ha, "%s:Out of memory\n", __func__);
7758  		ret = -ENOMEM;
7759  		goto exit_ddb_logout;
7760  	}
7761  
7762  	flash_tddb = vzalloc(sizeof(*flash_tddb));
7763  	if (!flash_tddb) {
7764  		ql4_printk(KERN_WARNING, ha,
7765  			   "%s:Memory Allocation failed.\n", __func__);
7766  		ret = -ENOMEM;
7767  		goto exit_ddb_logout;
7768  	}
7769  
7770  	tmp_tddb = vzalloc(sizeof(*tmp_tddb));
7771  	if (!tmp_tddb) {
7772  		ql4_printk(KERN_WARNING, ha,
7773  			   "%s:Memory Allocation failed.\n", __func__);
7774  		ret = -ENOMEM;
7775  		goto exit_ddb_logout;
7776  	}
7777  
7778  	if (!fnode_sess->targetname) {
7779  		ql4_printk(KERN_ERR, ha,
7780  			   "%s:Cannot logout from SendTarget entry\n",
7781  			   __func__);
7782  		ret = -EPERM;
7783  		goto exit_ddb_logout;
7784  	}
7785  
7786  	if (fnode_sess->is_boot_target) {
7787  		ql4_printk(KERN_ERR, ha,
7788  			   "%s: Logout from boot target entry is not permitted.\n",
7789  			   __func__);
7790  		ret = -EPERM;
7791  		goto exit_ddb_logout;
7792  	}
7793  
7794  	strscpy(flash_tddb->iscsi_name, fnode_sess->targetname,
7795  		ISCSI_NAME_SIZE);
7796  
7797  	if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7798  		sprintf(flash_tddb->ip_addr, "%pI6", fnode_conn->ipaddress);
7799  	else
7800  		sprintf(flash_tddb->ip_addr, "%pI4", fnode_conn->ipaddress);
7801  
7802  	flash_tddb->tpgt = fnode_sess->tpgt;
7803  	flash_tddb->port = fnode_conn->port;
7804  
7805  	COPY_ISID(flash_tddb->isid, fnode_sess->isid);
7806  
7807  	for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
7808  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
7809  		if (ddb_entry == NULL)
7810  			continue;
7811  
7812  		if (ddb_entry->ddb_type != FLASH_DDB)
7813  			continue;
7814  
7815  		index = ddb_entry->sess->target_id;
7816  		status = qla4xxx_get_fwddb_entry(ha, index, fw_ddb_entry,
7817  						 fw_ddb_dma, NULL, &next_idx,
7818  						 &state, &conn_err, NULL,
7819  						 &conn_id);
7820  		if (status == QLA_ERROR) {
7821  			ret = -ENOMEM;
7822  			break;
7823  		}
7824  
7825  		qla4xxx_convert_param_ddb(fw_ddb_entry, tmp_tddb, NULL);
7826  
7827  		status = qla4xxx_compare_tuple_ddb(ha, flash_tddb, tmp_tddb,
7828  						   true);
7829  		if (status == QLA_SUCCESS) {
7830  			ret = qla4xxx_sysfs_ddb_logout_sid(ddb_entry->sess);
7831  			break;
7832  		}
7833  	}
7834  
7835  	if (idx == MAX_DDB_ENTRIES)
7836  		ret = -ESRCH;
7837  
7838  exit_ddb_logout:
7839  	vfree(flash_tddb);
7840  	vfree(tmp_tddb);
7841  	if (fw_ddb_entry)
7842  		dma_pool_free(ha->fw_ddb_dma_pool, fw_ddb_entry, fw_ddb_dma);
7843  
7844  	return ret;
7845  }
7846  
7847  static int
qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session * fnode_sess,int param,char * buf)7848  qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
7849  			    int param, char *buf)
7850  {
7851  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
7852  	struct scsi_qla_host *ha = to_qla_host(shost);
7853  	struct iscsi_bus_flash_conn *fnode_conn;
7854  	struct ql4_chap_table chap_tbl;
7855  	struct device *dev;
7856  	int parent_type;
7857  	int rc = 0;
7858  
7859  	dev = iscsi_find_flashnode_conn(fnode_sess);
7860  	if (!dev)
7861  		return -EIO;
7862  
7863  	fnode_conn = iscsi_dev_to_flash_conn(dev);
7864  
7865  	switch (param) {
7866  	case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
7867  		rc = sprintf(buf, "%u\n", fnode_conn->is_fw_assigned_ipv6);
7868  		break;
7869  	case ISCSI_FLASHNODE_PORTAL_TYPE:
7870  		rc = sprintf(buf, "%s\n", fnode_sess->portal_type);
7871  		break;
7872  	case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
7873  		rc = sprintf(buf, "%u\n", fnode_sess->auto_snd_tgt_disable);
7874  		break;
7875  	case ISCSI_FLASHNODE_DISCOVERY_SESS:
7876  		rc = sprintf(buf, "%u\n", fnode_sess->discovery_sess);
7877  		break;
7878  	case ISCSI_FLASHNODE_ENTRY_EN:
7879  		rc = sprintf(buf, "%u\n", fnode_sess->entry_state);
7880  		break;
7881  	case ISCSI_FLASHNODE_HDR_DGST_EN:
7882  		rc = sprintf(buf, "%u\n", fnode_conn->hdrdgst_en);
7883  		break;
7884  	case ISCSI_FLASHNODE_DATA_DGST_EN:
7885  		rc = sprintf(buf, "%u\n", fnode_conn->datadgst_en);
7886  		break;
7887  	case ISCSI_FLASHNODE_IMM_DATA_EN:
7888  		rc = sprintf(buf, "%u\n", fnode_sess->imm_data_en);
7889  		break;
7890  	case ISCSI_FLASHNODE_INITIAL_R2T_EN:
7891  		rc = sprintf(buf, "%u\n", fnode_sess->initial_r2t_en);
7892  		break;
7893  	case ISCSI_FLASHNODE_DATASEQ_INORDER:
7894  		rc = sprintf(buf, "%u\n", fnode_sess->dataseq_inorder_en);
7895  		break;
7896  	case ISCSI_FLASHNODE_PDU_INORDER:
7897  		rc = sprintf(buf, "%u\n", fnode_sess->pdu_inorder_en);
7898  		break;
7899  	case ISCSI_FLASHNODE_CHAP_AUTH_EN:
7900  		rc = sprintf(buf, "%u\n", fnode_sess->chap_auth_en);
7901  		break;
7902  	case ISCSI_FLASHNODE_SNACK_REQ_EN:
7903  		rc = sprintf(buf, "%u\n", fnode_conn->snack_req_en);
7904  		break;
7905  	case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
7906  		rc = sprintf(buf, "%u\n", fnode_sess->discovery_logout_en);
7907  		break;
7908  	case ISCSI_FLASHNODE_BIDI_CHAP_EN:
7909  		rc = sprintf(buf, "%u\n", fnode_sess->bidi_chap_en);
7910  		break;
7911  	case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
7912  		rc = sprintf(buf, "%u\n", fnode_sess->discovery_auth_optional);
7913  		break;
7914  	case ISCSI_FLASHNODE_ERL:
7915  		rc = sprintf(buf, "%u\n", fnode_sess->erl);
7916  		break;
7917  	case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
7918  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_timestamp_stat);
7919  		break;
7920  	case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
7921  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_nagle_disable);
7922  		break;
7923  	case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
7924  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_wsf_disable);
7925  		break;
7926  	case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
7927  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_timer_scale);
7928  		break;
7929  	case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
7930  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_timestamp_en);
7931  		break;
7932  	case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
7933  		rc = sprintf(buf, "%u\n", fnode_conn->fragment_disable);
7934  		break;
7935  	case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
7936  		rc = sprintf(buf, "%u\n", fnode_conn->max_recv_dlength);
7937  		break;
7938  	case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
7939  		rc = sprintf(buf, "%u\n", fnode_conn->max_xmit_dlength);
7940  		break;
7941  	case ISCSI_FLASHNODE_FIRST_BURST:
7942  		rc = sprintf(buf, "%u\n", fnode_sess->first_burst);
7943  		break;
7944  	case ISCSI_FLASHNODE_DEF_TIME2WAIT:
7945  		rc = sprintf(buf, "%u\n", fnode_sess->time2wait);
7946  		break;
7947  	case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
7948  		rc = sprintf(buf, "%u\n", fnode_sess->time2retain);
7949  		break;
7950  	case ISCSI_FLASHNODE_MAX_R2T:
7951  		rc = sprintf(buf, "%u\n", fnode_sess->max_r2t);
7952  		break;
7953  	case ISCSI_FLASHNODE_KEEPALIVE_TMO:
7954  		rc = sprintf(buf, "%u\n", fnode_conn->keepalive_timeout);
7955  		break;
7956  	case ISCSI_FLASHNODE_ISID:
7957  		rc = sprintf(buf, "%pm\n", fnode_sess->isid);
7958  		break;
7959  	case ISCSI_FLASHNODE_TSID:
7960  		rc = sprintf(buf, "%u\n", fnode_sess->tsid);
7961  		break;
7962  	case ISCSI_FLASHNODE_PORT:
7963  		rc = sprintf(buf, "%d\n", fnode_conn->port);
7964  		break;
7965  	case ISCSI_FLASHNODE_MAX_BURST:
7966  		rc = sprintf(buf, "%u\n", fnode_sess->max_burst);
7967  		break;
7968  	case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
7969  		rc = sprintf(buf, "%u\n",
7970  			     fnode_sess->default_taskmgmt_timeout);
7971  		break;
7972  	case ISCSI_FLASHNODE_IPADDR:
7973  		if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7974  			rc = sprintf(buf, "%pI6\n", fnode_conn->ipaddress);
7975  		else
7976  			rc = sprintf(buf, "%pI4\n", fnode_conn->ipaddress);
7977  		break;
7978  	case ISCSI_FLASHNODE_ALIAS:
7979  		if (fnode_sess->targetalias)
7980  			rc = sprintf(buf, "%s\n", fnode_sess->targetalias);
7981  		else
7982  			rc = sprintf(buf, "\n");
7983  		break;
7984  	case ISCSI_FLASHNODE_REDIRECT_IPADDR:
7985  		if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
7986  			rc = sprintf(buf, "%pI6\n",
7987  				     fnode_conn->redirect_ipaddr);
7988  		else
7989  			rc = sprintf(buf, "%pI4\n",
7990  				     fnode_conn->redirect_ipaddr);
7991  		break;
7992  	case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
7993  		rc = sprintf(buf, "%u\n", fnode_conn->max_segment_size);
7994  		break;
7995  	case ISCSI_FLASHNODE_LOCAL_PORT:
7996  		rc = sprintf(buf, "%u\n", fnode_conn->local_port);
7997  		break;
7998  	case ISCSI_FLASHNODE_IPV4_TOS:
7999  		rc = sprintf(buf, "%u\n", fnode_conn->ipv4_tos);
8000  		break;
8001  	case ISCSI_FLASHNODE_IPV6_TC:
8002  		if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
8003  			rc = sprintf(buf, "%u\n",
8004  				     fnode_conn->ipv6_traffic_class);
8005  		else
8006  			rc = sprintf(buf, "\n");
8007  		break;
8008  	case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
8009  		rc = sprintf(buf, "%u\n", fnode_conn->ipv6_flow_label);
8010  		break;
8011  	case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
8012  		if (!strncmp(fnode_sess->portal_type, PORTAL_TYPE_IPV6, 4))
8013  			rc = sprintf(buf, "%pI6\n",
8014  				     fnode_conn->link_local_ipv6_addr);
8015  		else
8016  			rc = sprintf(buf, "\n");
8017  		break;
8018  	case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
8019  		rc = sprintf(buf, "%u\n", fnode_sess->discovery_parent_idx);
8020  		break;
8021  	case ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE:
8022  		if (fnode_sess->discovery_parent_type == DDB_ISNS)
8023  			parent_type = ISCSI_DISC_PARENT_ISNS;
8024  		else if (fnode_sess->discovery_parent_type == DDB_NO_LINK)
8025  			parent_type = ISCSI_DISC_PARENT_UNKNOWN;
8026  		else if (fnode_sess->discovery_parent_type < MAX_DDB_ENTRIES)
8027  			parent_type = ISCSI_DISC_PARENT_SENDTGT;
8028  		else
8029  			parent_type = ISCSI_DISC_PARENT_UNKNOWN;
8030  
8031  		rc = sprintf(buf, "%s\n",
8032  			     iscsi_get_discovery_parent_name(parent_type));
8033  		break;
8034  	case ISCSI_FLASHNODE_NAME:
8035  		if (fnode_sess->targetname)
8036  			rc = sprintf(buf, "%s\n", fnode_sess->targetname);
8037  		else
8038  			rc = sprintf(buf, "\n");
8039  		break;
8040  	case ISCSI_FLASHNODE_TPGT:
8041  		rc = sprintf(buf, "%u\n", fnode_sess->tpgt);
8042  		break;
8043  	case ISCSI_FLASHNODE_TCP_XMIT_WSF:
8044  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_xmit_wsf);
8045  		break;
8046  	case ISCSI_FLASHNODE_TCP_RECV_WSF:
8047  		rc = sprintf(buf, "%u\n", fnode_conn->tcp_recv_wsf);
8048  		break;
8049  	case ISCSI_FLASHNODE_CHAP_OUT_IDX:
8050  		rc = sprintf(buf, "%u\n", fnode_sess->chap_out_idx);
8051  		break;
8052  	case ISCSI_FLASHNODE_USERNAME:
8053  		if (fnode_sess->chap_auth_en) {
8054  			qla4xxx_get_uni_chap_at_index(ha,
8055  						      chap_tbl.name,
8056  						      chap_tbl.secret,
8057  						      fnode_sess->chap_out_idx);
8058  			rc = sprintf(buf, "%s\n", chap_tbl.name);
8059  		} else {
8060  			rc = sprintf(buf, "\n");
8061  		}
8062  		break;
8063  	case ISCSI_FLASHNODE_PASSWORD:
8064  		if (fnode_sess->chap_auth_en) {
8065  			qla4xxx_get_uni_chap_at_index(ha,
8066  						      chap_tbl.name,
8067  						      chap_tbl.secret,
8068  						      fnode_sess->chap_out_idx);
8069  			rc = sprintf(buf, "%s\n", chap_tbl.secret);
8070  		} else {
8071  			rc = sprintf(buf, "\n");
8072  		}
8073  		break;
8074  	case ISCSI_FLASHNODE_STATSN:
8075  		rc = sprintf(buf, "%u\n", fnode_conn->statsn);
8076  		break;
8077  	case ISCSI_FLASHNODE_EXP_STATSN:
8078  		rc = sprintf(buf, "%u\n", fnode_conn->exp_statsn);
8079  		break;
8080  	case ISCSI_FLASHNODE_IS_BOOT_TGT:
8081  		rc = sprintf(buf, "%u\n", fnode_sess->is_boot_target);
8082  		break;
8083  	default:
8084  		rc = -ENOSYS;
8085  		break;
8086  	}
8087  
8088  	put_device(dev);
8089  	return rc;
8090  }
8091  
8092  /**
8093   * qla4xxx_sysfs_ddb_set_param - Set parameter for firmware DDB entry
8094   * @fnode_sess: pointer to session attrs of flash ddb entry
8095   * @fnode_conn: pointer to connection attrs of flash ddb entry
8096   * @data: Parameters and their values to update
8097   * @len: len of data
8098   *
8099   * This sets the parameter of flash ddb entry and writes them to flash
8100   **/
8101  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)8102  qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
8103  			    struct iscsi_bus_flash_conn *fnode_conn,
8104  			    void *data, int len)
8105  {
8106  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
8107  	struct scsi_qla_host *ha = to_qla_host(shost);
8108  	struct iscsi_flashnode_param_info *fnode_param;
8109  	struct ql4_chap_table chap_tbl;
8110  	struct nlattr *attr;
8111  	uint16_t chap_out_idx = INVALID_ENTRY;
8112  	int rc = QLA_ERROR;
8113  	uint32_t rem = len;
8114  
8115  	memset((void *)&chap_tbl, 0, sizeof(chap_tbl));
8116  	nla_for_each_attr(attr, data, len, rem) {
8117  		if (nla_len(attr) < sizeof(*fnode_param)) {
8118  			rc = -EINVAL;
8119  			goto exit_set_param;
8120  		}
8121  
8122  		fnode_param = nla_data(attr);
8123  
8124  		switch (fnode_param->param) {
8125  		case ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6:
8126  			fnode_conn->is_fw_assigned_ipv6 = fnode_param->value[0];
8127  			break;
8128  		case ISCSI_FLASHNODE_PORTAL_TYPE:
8129  			memcpy(fnode_sess->portal_type, fnode_param->value,
8130  			       strlen(fnode_sess->portal_type));
8131  			break;
8132  		case ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE:
8133  			fnode_sess->auto_snd_tgt_disable =
8134  							fnode_param->value[0];
8135  			break;
8136  		case ISCSI_FLASHNODE_DISCOVERY_SESS:
8137  			fnode_sess->discovery_sess = fnode_param->value[0];
8138  			break;
8139  		case ISCSI_FLASHNODE_ENTRY_EN:
8140  			fnode_sess->entry_state = fnode_param->value[0];
8141  			break;
8142  		case ISCSI_FLASHNODE_HDR_DGST_EN:
8143  			fnode_conn->hdrdgst_en = fnode_param->value[0];
8144  			break;
8145  		case ISCSI_FLASHNODE_DATA_DGST_EN:
8146  			fnode_conn->datadgst_en = fnode_param->value[0];
8147  			break;
8148  		case ISCSI_FLASHNODE_IMM_DATA_EN:
8149  			fnode_sess->imm_data_en = fnode_param->value[0];
8150  			break;
8151  		case ISCSI_FLASHNODE_INITIAL_R2T_EN:
8152  			fnode_sess->initial_r2t_en = fnode_param->value[0];
8153  			break;
8154  		case ISCSI_FLASHNODE_DATASEQ_INORDER:
8155  			fnode_sess->dataseq_inorder_en = fnode_param->value[0];
8156  			break;
8157  		case ISCSI_FLASHNODE_PDU_INORDER:
8158  			fnode_sess->pdu_inorder_en = fnode_param->value[0];
8159  			break;
8160  		case ISCSI_FLASHNODE_CHAP_AUTH_EN:
8161  			fnode_sess->chap_auth_en = fnode_param->value[0];
8162  			/* Invalidate chap index if chap auth is disabled */
8163  			if (!fnode_sess->chap_auth_en)
8164  				fnode_sess->chap_out_idx = INVALID_ENTRY;
8165  
8166  			break;
8167  		case ISCSI_FLASHNODE_SNACK_REQ_EN:
8168  			fnode_conn->snack_req_en = fnode_param->value[0];
8169  			break;
8170  		case ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN:
8171  			fnode_sess->discovery_logout_en = fnode_param->value[0];
8172  			break;
8173  		case ISCSI_FLASHNODE_BIDI_CHAP_EN:
8174  			fnode_sess->bidi_chap_en = fnode_param->value[0];
8175  			break;
8176  		case ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL:
8177  			fnode_sess->discovery_auth_optional =
8178  							fnode_param->value[0];
8179  			break;
8180  		case ISCSI_FLASHNODE_ERL:
8181  			fnode_sess->erl = fnode_param->value[0];
8182  			break;
8183  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT:
8184  			fnode_conn->tcp_timestamp_stat = fnode_param->value[0];
8185  			break;
8186  		case ISCSI_FLASHNODE_TCP_NAGLE_DISABLE:
8187  			fnode_conn->tcp_nagle_disable = fnode_param->value[0];
8188  			break;
8189  		case ISCSI_FLASHNODE_TCP_WSF_DISABLE:
8190  			fnode_conn->tcp_wsf_disable = fnode_param->value[0];
8191  			break;
8192  		case ISCSI_FLASHNODE_TCP_TIMER_SCALE:
8193  			fnode_conn->tcp_timer_scale = fnode_param->value[0];
8194  			break;
8195  		case ISCSI_FLASHNODE_TCP_TIMESTAMP_EN:
8196  			fnode_conn->tcp_timestamp_en = fnode_param->value[0];
8197  			break;
8198  		case ISCSI_FLASHNODE_IP_FRAG_DISABLE:
8199  			fnode_conn->fragment_disable = fnode_param->value[0];
8200  			break;
8201  		case ISCSI_FLASHNODE_MAX_RECV_DLENGTH:
8202  			fnode_conn->max_recv_dlength =
8203  					*(unsigned *)fnode_param->value;
8204  			break;
8205  		case ISCSI_FLASHNODE_MAX_XMIT_DLENGTH:
8206  			fnode_conn->max_xmit_dlength =
8207  					*(unsigned *)fnode_param->value;
8208  			break;
8209  		case ISCSI_FLASHNODE_FIRST_BURST:
8210  			fnode_sess->first_burst =
8211  					*(unsigned *)fnode_param->value;
8212  			break;
8213  		case ISCSI_FLASHNODE_DEF_TIME2WAIT:
8214  			fnode_sess->time2wait = *(uint16_t *)fnode_param->value;
8215  			break;
8216  		case ISCSI_FLASHNODE_DEF_TIME2RETAIN:
8217  			fnode_sess->time2retain =
8218  						*(uint16_t *)fnode_param->value;
8219  			break;
8220  		case ISCSI_FLASHNODE_MAX_R2T:
8221  			fnode_sess->max_r2t =
8222  					*(uint16_t *)fnode_param->value;
8223  			break;
8224  		case ISCSI_FLASHNODE_KEEPALIVE_TMO:
8225  			fnode_conn->keepalive_timeout =
8226  				*(uint16_t *)fnode_param->value;
8227  			break;
8228  		case ISCSI_FLASHNODE_ISID:
8229  			memcpy(fnode_sess->isid, fnode_param->value,
8230  			       sizeof(fnode_sess->isid));
8231  			break;
8232  		case ISCSI_FLASHNODE_TSID:
8233  			fnode_sess->tsid = *(uint16_t *)fnode_param->value;
8234  			break;
8235  		case ISCSI_FLASHNODE_PORT:
8236  			fnode_conn->port = *(uint16_t *)fnode_param->value;
8237  			break;
8238  		case ISCSI_FLASHNODE_MAX_BURST:
8239  			fnode_sess->max_burst = *(unsigned *)fnode_param->value;
8240  			break;
8241  		case ISCSI_FLASHNODE_DEF_TASKMGMT_TMO:
8242  			fnode_sess->default_taskmgmt_timeout =
8243  						*(uint16_t *)fnode_param->value;
8244  			break;
8245  		case ISCSI_FLASHNODE_IPADDR:
8246  			memcpy(fnode_conn->ipaddress, fnode_param->value,
8247  			       IPv6_ADDR_LEN);
8248  			break;
8249  		case ISCSI_FLASHNODE_ALIAS:
8250  			rc = iscsi_switch_str_param(&fnode_sess->targetalias,
8251  						    (char *)fnode_param->value);
8252  			break;
8253  		case ISCSI_FLASHNODE_REDIRECT_IPADDR:
8254  			memcpy(fnode_conn->redirect_ipaddr, fnode_param->value,
8255  			       IPv6_ADDR_LEN);
8256  			break;
8257  		case ISCSI_FLASHNODE_MAX_SEGMENT_SIZE:
8258  			fnode_conn->max_segment_size =
8259  					*(unsigned *)fnode_param->value;
8260  			break;
8261  		case ISCSI_FLASHNODE_LOCAL_PORT:
8262  			fnode_conn->local_port =
8263  						*(uint16_t *)fnode_param->value;
8264  			break;
8265  		case ISCSI_FLASHNODE_IPV4_TOS:
8266  			fnode_conn->ipv4_tos = fnode_param->value[0];
8267  			break;
8268  		case ISCSI_FLASHNODE_IPV6_TC:
8269  			fnode_conn->ipv6_traffic_class = fnode_param->value[0];
8270  			break;
8271  		case ISCSI_FLASHNODE_IPV6_FLOW_LABEL:
8272  			fnode_conn->ipv6_flow_label = fnode_param->value[0];
8273  			break;
8274  		case ISCSI_FLASHNODE_NAME:
8275  			rc = iscsi_switch_str_param(&fnode_sess->targetname,
8276  						    (char *)fnode_param->value);
8277  			break;
8278  		case ISCSI_FLASHNODE_TPGT:
8279  			fnode_sess->tpgt = *(uint16_t *)fnode_param->value;
8280  			break;
8281  		case ISCSI_FLASHNODE_LINK_LOCAL_IPV6:
8282  			memcpy(fnode_conn->link_local_ipv6_addr,
8283  			       fnode_param->value, IPv6_ADDR_LEN);
8284  			break;
8285  		case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
8286  			fnode_sess->discovery_parent_idx =
8287  						*(uint16_t *)fnode_param->value;
8288  			break;
8289  		case ISCSI_FLASHNODE_TCP_XMIT_WSF:
8290  			fnode_conn->tcp_xmit_wsf =
8291  						*(uint8_t *)fnode_param->value;
8292  			break;
8293  		case ISCSI_FLASHNODE_TCP_RECV_WSF:
8294  			fnode_conn->tcp_recv_wsf =
8295  						*(uint8_t *)fnode_param->value;
8296  			break;
8297  		case ISCSI_FLASHNODE_STATSN:
8298  			fnode_conn->statsn = *(uint32_t *)fnode_param->value;
8299  			break;
8300  		case ISCSI_FLASHNODE_EXP_STATSN:
8301  			fnode_conn->exp_statsn =
8302  						*(uint32_t *)fnode_param->value;
8303  			break;
8304  		case ISCSI_FLASHNODE_CHAP_OUT_IDX:
8305  			chap_out_idx = *(uint16_t *)fnode_param->value;
8306  			if (!qla4xxx_get_uni_chap_at_index(ha,
8307  							   chap_tbl.name,
8308  							   chap_tbl.secret,
8309  							   chap_out_idx)) {
8310  				fnode_sess->chap_out_idx = chap_out_idx;
8311  				/* Enable chap auth if chap index is valid */
8312  				fnode_sess->chap_auth_en = QL4_PARAM_ENABLE;
8313  			}
8314  			break;
8315  		default:
8316  			ql4_printk(KERN_ERR, ha,
8317  				   "%s: No such sysfs attribute\n", __func__);
8318  			rc = -ENOSYS;
8319  			goto exit_set_param;
8320  		}
8321  	}
8322  
8323  	rc = qla4xxx_sysfs_ddb_apply(fnode_sess, fnode_conn);
8324  
8325  exit_set_param:
8326  	return rc;
8327  }
8328  
8329  /**
8330   * qla4xxx_sysfs_ddb_delete - Delete firmware DDB entry
8331   * @fnode_sess: pointer to session attrs of flash ddb entry
8332   *
8333   * This invalidates the flash ddb entry at the given index
8334   **/
qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session * fnode_sess)8335  static int qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess)
8336  {
8337  	struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
8338  	struct scsi_qla_host *ha = to_qla_host(shost);
8339  	uint32_t dev_db_start_offset;
8340  	uint32_t dev_db_end_offset;
8341  	struct dev_db_entry *fw_ddb_entry = NULL;
8342  	dma_addr_t fw_ddb_entry_dma;
8343  	uint16_t *ddb_cookie = NULL;
8344  	size_t ddb_size = 0;
8345  	void *pddb = NULL;
8346  	int target_id;
8347  	int rc = 0;
8348  
8349  	if (fnode_sess->is_boot_target) {
8350  		rc = -EPERM;
8351  		DEBUG2(ql4_printk(KERN_ERR, ha,
8352  				  "%s: Deletion of boot target entry is not permitted.\n",
8353  				  __func__));
8354  		goto exit_ddb_del;
8355  	}
8356  
8357  	if (fnode_sess->flash_state == DEV_DB_NON_PERSISTENT)
8358  		goto sysfs_ddb_del;
8359  
8360  	if (is_qla40XX(ha)) {
8361  		dev_db_start_offset = FLASH_OFFSET_DB_INFO;
8362  		dev_db_end_offset = FLASH_OFFSET_DB_END;
8363  		dev_db_start_offset += (fnode_sess->target_id *
8364  				       sizeof(*fw_ddb_entry));
8365  		ddb_size = sizeof(*fw_ddb_entry);
8366  	} else {
8367  		dev_db_start_offset = FLASH_RAW_ACCESS_ADDR +
8368  				      (ha->hw.flt_region_ddb << 2);
8369  		/* flt_ddb_size is DDB table size for both ports
8370  		 * so divide it by 2 to calculate the offset for second port
8371  		 */
8372  		if (ha->port_num == 1)
8373  			dev_db_start_offset += (ha->hw.flt_ddb_size / 2);
8374  
8375  		dev_db_end_offset = dev_db_start_offset +
8376  				    (ha->hw.flt_ddb_size / 2);
8377  
8378  		dev_db_start_offset += (fnode_sess->target_id *
8379  				       sizeof(*fw_ddb_entry));
8380  		dev_db_start_offset += offsetof(struct dev_db_entry, cookie);
8381  
8382  		ddb_size = sizeof(*ddb_cookie);
8383  	}
8384  
8385  	DEBUG2(ql4_printk(KERN_ERR, ha, "%s: start offset=%u, end offset=%u\n",
8386  			  __func__, dev_db_start_offset, dev_db_end_offset));
8387  
8388  	if (dev_db_start_offset > dev_db_end_offset) {
8389  		rc = -EIO;
8390  		DEBUG2(ql4_printk(KERN_ERR, ha, "%s:Invalid DDB index %u\n",
8391  				  __func__, fnode_sess->target_id));
8392  		goto exit_ddb_del;
8393  	}
8394  
8395  	pddb = dma_alloc_coherent(&ha->pdev->dev, ddb_size,
8396  				  &fw_ddb_entry_dma, GFP_KERNEL);
8397  	if (!pddb) {
8398  		rc = -ENOMEM;
8399  		DEBUG2(ql4_printk(KERN_ERR, ha,
8400  				  "%s: Unable to allocate dma buffer\n",
8401  				  __func__));
8402  		goto exit_ddb_del;
8403  	}
8404  
8405  	if (is_qla40XX(ha)) {
8406  		fw_ddb_entry = pddb;
8407  		memset(fw_ddb_entry, 0, ddb_size);
8408  		ddb_cookie = &fw_ddb_entry->cookie;
8409  	} else {
8410  		ddb_cookie = pddb;
8411  	}
8412  
8413  	/* invalidate the cookie */
8414  	*ddb_cookie = 0xFFEE;
8415  	qla4xxx_set_flash(ha, fw_ddb_entry_dma, dev_db_start_offset,
8416  			  ddb_size, FLASH_OPT_RMW_COMMIT);
8417  
8418  sysfs_ddb_del:
8419  	target_id = fnode_sess->target_id;
8420  	iscsi_destroy_flashnode_sess(fnode_sess);
8421  	ql4_printk(KERN_INFO, ha,
8422  		   "%s: session and conn entries for flashnode %u of host %lu deleted\n",
8423  		   __func__, target_id, ha->host_no);
8424  exit_ddb_del:
8425  	if (pddb)
8426  		dma_free_coherent(&ha->pdev->dev, ddb_size, pddb,
8427  				  fw_ddb_entry_dma);
8428  	return rc;
8429  }
8430  
8431  /**
8432   * qla4xxx_sysfs_ddb_export - Create sysfs entries for firmware DDBs
8433   * @ha: pointer to adapter structure
8434   *
8435   * Export the firmware DDB for all send targets and normal targets to sysfs.
8436   **/
qla4xxx_sysfs_ddb_export(struct scsi_qla_host * ha)8437  int qla4xxx_sysfs_ddb_export(struct scsi_qla_host *ha)
8438  {
8439  	struct dev_db_entry *fw_ddb_entry = NULL;
8440  	dma_addr_t fw_ddb_entry_dma;
8441  	uint16_t max_ddbs;
8442  	uint16_t idx = 0;
8443  	int ret = QLA_SUCCESS;
8444  
8445  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev,
8446  					  sizeof(*fw_ddb_entry),
8447  					  &fw_ddb_entry_dma, GFP_KERNEL);
8448  	if (!fw_ddb_entry) {
8449  		DEBUG2(ql4_printk(KERN_ERR, ha,
8450  				  "%s: Unable to allocate dma buffer\n",
8451  				  __func__));
8452  		return -ENOMEM;
8453  	}
8454  
8455  	max_ddbs =  is_qla40XX(ha) ? MAX_PRST_DEV_DB_ENTRIES :
8456  				     MAX_DEV_DB_ENTRIES;
8457  
8458  	for (idx = 0; idx < max_ddbs; idx++) {
8459  		if (qla4xxx_flashdb_by_index(ha, fw_ddb_entry, fw_ddb_entry_dma,
8460  					     idx))
8461  			continue;
8462  
8463  		ret = qla4xxx_sysfs_ddb_tgt_create(ha, fw_ddb_entry, &idx, 0);
8464  		if (ret) {
8465  			ret = -EIO;
8466  			break;
8467  		}
8468  	}
8469  
8470  	dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry), fw_ddb_entry,
8471  			  fw_ddb_entry_dma);
8472  
8473  	return ret;
8474  }
8475  
qla4xxx_sysfs_ddb_remove(struct scsi_qla_host * ha)8476  static void qla4xxx_sysfs_ddb_remove(struct scsi_qla_host *ha)
8477  {
8478  	iscsi_destroy_all_flashnode(ha->host);
8479  }
8480  
8481  /**
8482   * qla4xxx_build_ddb_list - Build ddb list and setup sessions
8483   * @ha: pointer to adapter structure
8484   * @is_reset: Is this init path or reset path
8485   *
8486   * Create a list of sendtargets (st) from firmware DDBs, issue send targets
8487   * using connection open, then create the list of normal targets (nt)
8488   * from firmware DDBs. Based on the list of nt setup session and connection
8489   * objects.
8490   **/
qla4xxx_build_ddb_list(struct scsi_qla_host * ha,int is_reset)8491  void qla4xxx_build_ddb_list(struct scsi_qla_host *ha, int is_reset)
8492  {
8493  	uint16_t tmo = 0;
8494  	struct list_head list_st, list_nt;
8495  	struct qla_ddb_index  *st_ddb_idx, *st_ddb_idx_tmp;
8496  	unsigned long wtime;
8497  
8498  	if (!test_bit(AF_LINK_UP, &ha->flags)) {
8499  		set_bit(AF_BUILD_DDB_LIST, &ha->flags);
8500  		ha->is_reset = is_reset;
8501  		return;
8502  	}
8503  
8504  	INIT_LIST_HEAD(&list_st);
8505  	INIT_LIST_HEAD(&list_nt);
8506  
8507  	qla4xxx_build_st_list(ha, &list_st);
8508  
8509  	/* Before issuing conn open mbox, ensure all IPs states are configured
8510  	 * Note, conn open fails if IPs are not configured
8511  	 */
8512  	qla4xxx_wait_for_ip_configuration(ha);
8513  
8514  	/* Go thru the STs and fire the sendtargets by issuing conn open mbx */
8515  	list_for_each_entry_safe(st_ddb_idx, st_ddb_idx_tmp, &list_st, list) {
8516  		qla4xxx_conn_open(ha, st_ddb_idx->fw_ddb_idx);
8517  	}
8518  
8519  	/* Wait to ensure all sendtargets are done for min 12 sec wait */
8520  	tmo = ((ha->def_timeout > LOGIN_TOV) &&
8521  	       (ha->def_timeout < LOGIN_TOV * 10) ?
8522  	       ha->def_timeout : LOGIN_TOV);
8523  
8524  	DEBUG2(ql4_printk(KERN_INFO, ha,
8525  			  "Default time to wait for build ddb %d\n", tmo));
8526  
8527  	wtime = jiffies + (HZ * tmo);
8528  	do {
8529  		if (list_empty(&list_st))
8530  			break;
8531  
8532  		qla4xxx_remove_failed_ddb(ha, &list_st);
8533  		schedule_timeout_uninterruptible(HZ / 10);
8534  	} while (time_after(wtime, jiffies));
8535  
8536  
8537  	qla4xxx_build_nt_list(ha, &list_nt, &list_st, is_reset);
8538  
8539  	qla4xxx_free_ddb_list(&list_st);
8540  	qla4xxx_free_ddb_list(&list_nt);
8541  
8542  	qla4xxx_free_ddb_index(ha);
8543  }
8544  
8545  /**
8546   * qla4xxx_wait_login_resp_boot_tgt -  Wait for iSCSI boot target login
8547   * response.
8548   * @ha: pointer to adapter structure
8549   *
8550   * When the boot entry is normal iSCSI target then DF_BOOT_TGT flag will be
8551   * set in DDB and we will wait for login response of boot targets during
8552   * probe.
8553   **/
qla4xxx_wait_login_resp_boot_tgt(struct scsi_qla_host * ha)8554  static void qla4xxx_wait_login_resp_boot_tgt(struct scsi_qla_host *ha)
8555  {
8556  	struct ddb_entry *ddb_entry;
8557  	struct dev_db_entry *fw_ddb_entry = NULL;
8558  	dma_addr_t fw_ddb_entry_dma;
8559  	unsigned long wtime;
8560  	uint32_t ddb_state;
8561  	int max_ddbs, idx, ret;
8562  
8563  	max_ddbs =  is_qla40XX(ha) ? MAX_DEV_DB_ENTRIES_40XX :
8564  				     MAX_DEV_DB_ENTRIES;
8565  
8566  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8567  					  &fw_ddb_entry_dma, GFP_KERNEL);
8568  	if (!fw_ddb_entry) {
8569  		ql4_printk(KERN_ERR, ha,
8570  			   "%s: Unable to allocate dma buffer\n", __func__);
8571  		goto exit_login_resp;
8572  	}
8573  
8574  	wtime = jiffies + (HZ * BOOT_LOGIN_RESP_TOV);
8575  
8576  	for (idx = 0; idx < max_ddbs; idx++) {
8577  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
8578  		if (ddb_entry == NULL)
8579  			continue;
8580  
8581  		if (test_bit(DF_BOOT_TGT, &ddb_entry->flags)) {
8582  			DEBUG2(ql4_printk(KERN_INFO, ha,
8583  					  "%s: DDB index [%d]\n", __func__,
8584  					  ddb_entry->fw_ddb_index));
8585  			do {
8586  				ret = qla4xxx_get_fwddb_entry(ha,
8587  						ddb_entry->fw_ddb_index,
8588  						fw_ddb_entry, fw_ddb_entry_dma,
8589  						NULL, NULL, &ddb_state, NULL,
8590  						NULL, NULL);
8591  				if (ret == QLA_ERROR)
8592  					goto exit_login_resp;
8593  
8594  				if ((ddb_state == DDB_DS_SESSION_ACTIVE) ||
8595  				    (ddb_state == DDB_DS_SESSION_FAILED))
8596  					break;
8597  
8598  				schedule_timeout_uninterruptible(HZ);
8599  
8600  			} while ((time_after(wtime, jiffies)));
8601  
8602  			if (!time_after(wtime, jiffies)) {
8603  				DEBUG2(ql4_printk(KERN_INFO, ha,
8604  						  "%s: Login response wait timer expired\n",
8605  						  __func__));
8606  				 goto exit_login_resp;
8607  			}
8608  		}
8609  	}
8610  
8611  exit_login_resp:
8612  	if (fw_ddb_entry)
8613  		dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8614  				  fw_ddb_entry, fw_ddb_entry_dma);
8615  }
8616  
8617  /**
8618   * qla4xxx_probe_adapter - callback function to probe HBA
8619   * @pdev: pointer to pci_dev structure
8620   * @ent: pointer to pci_device entry
8621   *
8622   * This routine will probe for Qlogic 4xxx iSCSI host adapters.
8623   * It returns zero if successful. It also initializes all data necessary for
8624   * the driver.
8625   **/
qla4xxx_probe_adapter(struct pci_dev * pdev,const struct pci_device_id * ent)8626  static int qla4xxx_probe_adapter(struct pci_dev *pdev,
8627  				 const struct pci_device_id *ent)
8628  {
8629  	int ret = -ENODEV, status;
8630  	struct Scsi_Host *host;
8631  	struct scsi_qla_host *ha;
8632  	uint8_t init_retry_count = 0;
8633  	char buf[34];
8634  	struct qla4_8xxx_legacy_intr_set *nx_legacy_intr;
8635  	uint32_t dev_state;
8636  
8637  	if (pci_enable_device(pdev))
8638  		return -1;
8639  
8640  	host = iscsi_host_alloc(&qla4xxx_driver_template, sizeof(*ha), 0);
8641  	if (host == NULL) {
8642  		printk(KERN_WARNING
8643  		       "qla4xxx: Couldn't allocate host from scsi layer!\n");
8644  		goto probe_disable_device;
8645  	}
8646  
8647  	/* Clear our data area */
8648  	ha = to_qla_host(host);
8649  	memset(ha, 0, sizeof(*ha));
8650  
8651  	/* Save the information from PCI BIOS.	*/
8652  	ha->pdev = pdev;
8653  	ha->host = host;
8654  	ha->host_no = host->host_no;
8655  	ha->func_num = PCI_FUNC(ha->pdev->devfn);
8656  
8657  	/* Setup Runtime configurable options */
8658  	if (is_qla8022(ha)) {
8659  		ha->isp_ops = &qla4_82xx_isp_ops;
8660  		ha->reg_tbl = (uint32_t *) qla4_82xx_reg_tbl;
8661  		ha->qdr_sn_window = -1;
8662  		ha->ddr_mn_window = -1;
8663  		ha->curr_window = 255;
8664  		nx_legacy_intr = &legacy_intr[ha->func_num];
8665  		ha->nx_legacy_intr.int_vec_bit = nx_legacy_intr->int_vec_bit;
8666  		ha->nx_legacy_intr.tgt_status_reg =
8667  			nx_legacy_intr->tgt_status_reg;
8668  		ha->nx_legacy_intr.tgt_mask_reg = nx_legacy_intr->tgt_mask_reg;
8669  		ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg;
8670  	} else if (is_qla8032(ha) || is_qla8042(ha)) {
8671  		ha->isp_ops = &qla4_83xx_isp_ops;
8672  		ha->reg_tbl = (uint32_t *)qla4_83xx_reg_tbl;
8673  	} else {
8674  		ha->isp_ops = &qla4xxx_isp_ops;
8675  	}
8676  
8677  	if (is_qla80XX(ha)) {
8678  		rwlock_init(&ha->hw_lock);
8679  		ha->pf_bit = ha->func_num << 16;
8680  		/* Set EEH reset type to fundamental if required by hba */
8681  		pdev->needs_freset = 1;
8682  	}
8683  
8684  	/* Configure PCI I/O space. */
8685  	ret = ha->isp_ops->iospace_config(ha);
8686  	if (ret)
8687  		goto probe_failed_ioconfig;
8688  
8689  	ql4_printk(KERN_INFO, ha, "Found an ISP%04x, irq %d, iobase 0x%p\n",
8690  		   pdev->device, pdev->irq, ha->reg);
8691  
8692  	qla4xxx_config_dma_addressing(ha);
8693  
8694  	/* Initialize lists and spinlocks. */
8695  	INIT_LIST_HEAD(&ha->free_srb_q);
8696  
8697  	mutex_init(&ha->mbox_sem);
8698  	mutex_init(&ha->chap_sem);
8699  	init_completion(&ha->mbx_intr_comp);
8700  	init_completion(&ha->disable_acb_comp);
8701  	init_completion(&ha->idc_comp);
8702  	init_completion(&ha->link_up_comp);
8703  
8704  	spin_lock_init(&ha->hardware_lock);
8705  	spin_lock_init(&ha->work_lock);
8706  
8707  	/* Initialize work list */
8708  	INIT_LIST_HEAD(&ha->work_list);
8709  
8710  	/* Allocate dma buffers */
8711  	if (qla4xxx_mem_alloc(ha)) {
8712  		ql4_printk(KERN_WARNING, ha,
8713  		    "[ERROR] Failed to allocate memory for adapter\n");
8714  
8715  		ret = -ENOMEM;
8716  		goto probe_failed;
8717  	}
8718  
8719  	host->cmd_per_lun = 3;
8720  	host->max_channel = 0;
8721  	host->max_lun = MAX_LUNS - 1;
8722  	host->max_id = MAX_TARGETS;
8723  	host->max_cmd_len = IOCB_MAX_CDB_LEN;
8724  	host->can_queue = MAX_SRBS ;
8725  	host->transportt = qla4xxx_scsi_transport;
8726  
8727  	pci_set_drvdata(pdev, ha);
8728  
8729  	ret = scsi_add_host(host, &pdev->dev);
8730  	if (ret)
8731  		goto probe_failed;
8732  
8733  	if (is_qla80XX(ha))
8734  		qla4_8xxx_get_flash_info(ha);
8735  
8736  	if (is_qla8032(ha) || is_qla8042(ha)) {
8737  		qla4_83xx_read_reset_template(ha);
8738  		/*
8739  		 * NOTE: If ql4dontresethba==1, set IDC_CTRL DONTRESET_BIT0.
8740  		 * If DONRESET_BIT0 is set, drivers should not set dev_state
8741  		 * to NEED_RESET. But if NEED_RESET is set, drivers should
8742  		 * should honor the reset.
8743  		 */
8744  		if (ql4xdontresethba == 1)
8745  			qla4_83xx_set_idc_dontreset(ha);
8746  	}
8747  
8748  	/*
8749  	 * Initialize the Host adapter request/response queues and
8750  	 * firmware
8751  	 * NOTE: interrupts enabled upon successful completion
8752  	 */
8753  	status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER);
8754  
8755  	/* Dont retry adapter initialization if IRQ allocation failed */
8756  	if (is_qla80XX(ha) && (status == QLA_ERROR))
8757  		goto skip_retry_init;
8758  
8759  	while ((!test_bit(AF_ONLINE, &ha->flags)) &&
8760  	    init_retry_count++ < MAX_INIT_RETRIES) {
8761  
8762  		if (is_qla80XX(ha)) {
8763  			ha->isp_ops->idc_lock(ha);
8764  			dev_state = qla4_8xxx_rd_direct(ha,
8765  							QLA8XXX_CRB_DEV_STATE);
8766  			ha->isp_ops->idc_unlock(ha);
8767  			if (dev_state == QLA8XXX_DEV_FAILED) {
8768  				ql4_printk(KERN_WARNING, ha, "%s: don't retry "
8769  				    "initialize adapter. H/W is in failed state\n",
8770  				    __func__);
8771  				break;
8772  			}
8773  		}
8774  		DEBUG2(printk("scsi: %s: retrying adapter initialization "
8775  			      "(%d)\n", __func__, init_retry_count));
8776  
8777  		if (ha->isp_ops->reset_chip(ha) == QLA_ERROR)
8778  			continue;
8779  
8780  		status = qla4xxx_initialize_adapter(ha, INIT_ADAPTER);
8781  		if (is_qla80XX(ha) && (status == QLA_ERROR)) {
8782  			if (qla4_8xxx_check_init_adapter_retry(ha) == QLA_ERROR)
8783  				goto skip_retry_init;
8784  		}
8785  	}
8786  
8787  skip_retry_init:
8788  	if (!test_bit(AF_ONLINE, &ha->flags)) {
8789  		ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n");
8790  
8791  		if ((is_qla8022(ha) && ql4xdontresethba) ||
8792  		    ((is_qla8032(ha) || is_qla8042(ha)) &&
8793  		     qla4_83xx_idc_dontreset(ha))) {
8794  			/* Put the device in failed state. */
8795  			DEBUG2(printk(KERN_ERR "HW STATE: FAILED\n"));
8796  			ha->isp_ops->idc_lock(ha);
8797  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
8798  					    QLA8XXX_DEV_FAILED);
8799  			ha->isp_ops->idc_unlock(ha);
8800  		}
8801  		ret = -ENODEV;
8802  		goto remove_host;
8803  	}
8804  
8805  	/* Startup the kernel thread for this host adapter. */
8806  	DEBUG2(printk("scsi: %s: Starting kernel thread for "
8807  		      "qla4xxx_dpc\n", __func__));
8808  	sprintf(buf, "qla4xxx_%lu_dpc", ha->host_no);
8809  	ha->dpc_thread = create_singlethread_workqueue(buf);
8810  	if (!ha->dpc_thread) {
8811  		ql4_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n");
8812  		ret = -ENODEV;
8813  		goto remove_host;
8814  	}
8815  	INIT_WORK(&ha->dpc_work, qla4xxx_do_dpc);
8816  
8817  	ha->task_wq = alloc_workqueue("qla4xxx_%lu_task", WQ_MEM_RECLAIM, 1,
8818  				      ha->host_no);
8819  	if (!ha->task_wq) {
8820  		ql4_printk(KERN_WARNING, ha, "Unable to start task thread!\n");
8821  		ret = -ENODEV;
8822  		goto remove_host;
8823  	}
8824  
8825  	/*
8826  	 * For ISP-8XXX, request_irqs is called in qla4_8xxx_load_risc
8827  	 * (which is called indirectly by qla4xxx_initialize_adapter),
8828  	 * so that irqs will be registered after crbinit but before
8829  	 * mbx_intr_enable.
8830  	 */
8831  	if (is_qla40XX(ha)) {
8832  		ret = qla4xxx_request_irqs(ha);
8833  		if (ret) {
8834  			ql4_printk(KERN_WARNING, ha, "Failed to reserve "
8835  			    "interrupt %d already in use.\n", pdev->irq);
8836  			goto remove_host;
8837  		}
8838  	}
8839  
8840  	pci_save_state(ha->pdev);
8841  	ha->isp_ops->enable_intrs(ha);
8842  
8843  	/* Start timer thread. */
8844  	qla4xxx_start_timer(ha, 1);
8845  
8846  	set_bit(AF_INIT_DONE, &ha->flags);
8847  
8848  	qla4_8xxx_alloc_sysfs_attr(ha);
8849  
8850  	printk(KERN_INFO
8851  	       " QLogic iSCSI HBA Driver version: %s\n"
8852  	       "  QLogic ISP%04x @ %s, host#=%ld, fw=%02d.%02d.%02d.%02d\n",
8853  	       qla4xxx_version_str, ha->pdev->device, pci_name(ha->pdev),
8854  	       ha->host_no, ha->fw_info.fw_major, ha->fw_info.fw_minor,
8855  	       ha->fw_info.fw_patch, ha->fw_info.fw_build);
8856  
8857  	/* Set the driver version */
8858  	if (is_qla80XX(ha))
8859  		qla4_8xxx_set_param(ha, SET_DRVR_VERSION);
8860  
8861  	if (qla4xxx_setup_boot_info(ha))
8862  		ql4_printk(KERN_ERR, ha,
8863  			   "%s: No iSCSI boot target configured\n", __func__);
8864  
8865  	set_bit(DPC_SYSFS_DDB_EXPORT, &ha->dpc_flags);
8866  	/* Perform the build ddb list and login to each */
8867  	qla4xxx_build_ddb_list(ha, INIT_ADAPTER);
8868  	iscsi_host_for_each_session(ha->host, qla4xxx_login_flash_ddb);
8869  	qla4xxx_wait_login_resp_boot_tgt(ha);
8870  
8871  	qla4xxx_create_chap_list(ha);
8872  
8873  	qla4xxx_create_ifaces(ha);
8874  	return 0;
8875  
8876  remove_host:
8877  	scsi_remove_host(ha->host);
8878  
8879  probe_failed:
8880  	qla4xxx_free_adapter(ha);
8881  
8882  probe_failed_ioconfig:
8883  	scsi_host_put(ha->host);
8884  
8885  probe_disable_device:
8886  	pci_disable_device(pdev);
8887  
8888  	return ret;
8889  }
8890  
8891  /**
8892   * qla4xxx_prevent_other_port_reinit - prevent other port from re-initialize
8893   * @ha: pointer to adapter structure
8894   *
8895   * Mark the other ISP-4xxx port to indicate that the driver is being removed,
8896   * so that the other port will not re-initialize while in the process of
8897   * removing the ha due to driver unload or hba hotplug.
8898   **/
qla4xxx_prevent_other_port_reinit(struct scsi_qla_host * ha)8899  static void qla4xxx_prevent_other_port_reinit(struct scsi_qla_host *ha)
8900  {
8901  	struct scsi_qla_host *other_ha = NULL;
8902  	struct pci_dev *other_pdev = NULL;
8903  	int fn = ISP4XXX_PCI_FN_2;
8904  
8905  	/*iscsi function numbers for ISP4xxx is 1 and 3*/
8906  	if (PCI_FUNC(ha->pdev->devfn) & BIT_1)
8907  		fn = ISP4XXX_PCI_FN_1;
8908  
8909  	other_pdev =
8910  		pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
8911  		ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
8912  		fn));
8913  
8914  	/* Get other_ha if other_pdev is valid and state is enable*/
8915  	if (other_pdev) {
8916  		if (atomic_read(&other_pdev->enable_cnt)) {
8917  			other_ha = pci_get_drvdata(other_pdev);
8918  			if (other_ha) {
8919  				set_bit(AF_HA_REMOVAL, &other_ha->flags);
8920  				DEBUG2(ql4_printk(KERN_INFO, ha, "%s: "
8921  				    "Prevent %s reinit\n", __func__,
8922  				    dev_name(&other_ha->pdev->dev)));
8923  			}
8924  		}
8925  		pci_dev_put(other_pdev);
8926  	}
8927  }
8928  
qla4xxx_destroy_ddb(struct scsi_qla_host * ha,struct ddb_entry * ddb_entry)8929  static void qla4xxx_destroy_ddb(struct scsi_qla_host *ha,
8930  		struct ddb_entry *ddb_entry)
8931  {
8932  	struct dev_db_entry *fw_ddb_entry = NULL;
8933  	dma_addr_t fw_ddb_entry_dma;
8934  	unsigned long wtime;
8935  	uint32_t ddb_state;
8936  	int options;
8937  	int status;
8938  
8939  	options = LOGOUT_OPTION_CLOSE_SESSION;
8940  	if (qla4xxx_session_logout_ddb(ha, ddb_entry, options) == QLA_ERROR) {
8941  		ql4_printk(KERN_ERR, ha, "%s: Logout failed\n", __func__);
8942  		goto clear_ddb;
8943  	}
8944  
8945  	fw_ddb_entry = dma_alloc_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8946  					  &fw_ddb_entry_dma, GFP_KERNEL);
8947  	if (!fw_ddb_entry) {
8948  		ql4_printk(KERN_ERR, ha,
8949  			   "%s: Unable to allocate dma buffer\n", __func__);
8950  		goto clear_ddb;
8951  	}
8952  
8953  	wtime = jiffies + (HZ * LOGOUT_TOV);
8954  	do {
8955  		status = qla4xxx_get_fwddb_entry(ha, ddb_entry->fw_ddb_index,
8956  						 fw_ddb_entry, fw_ddb_entry_dma,
8957  						 NULL, NULL, &ddb_state, NULL,
8958  						 NULL, NULL);
8959  		if (status == QLA_ERROR)
8960  			goto free_ddb;
8961  
8962  		if ((ddb_state == DDB_DS_NO_CONNECTION_ACTIVE) ||
8963  		    (ddb_state == DDB_DS_SESSION_FAILED))
8964  			goto free_ddb;
8965  
8966  		schedule_timeout_uninterruptible(HZ);
8967  	} while ((time_after(wtime, jiffies)));
8968  
8969  free_ddb:
8970  	dma_free_coherent(&ha->pdev->dev, sizeof(*fw_ddb_entry),
8971  			  fw_ddb_entry, fw_ddb_entry_dma);
8972  clear_ddb:
8973  	qla4xxx_clear_ddb_entry(ha, ddb_entry->fw_ddb_index);
8974  }
8975  
qla4xxx_destroy_fw_ddb_session(struct scsi_qla_host * ha)8976  static void qla4xxx_destroy_fw_ddb_session(struct scsi_qla_host *ha)
8977  {
8978  	struct ddb_entry *ddb_entry;
8979  	int idx;
8980  
8981  	for (idx = 0; idx < MAX_DDB_ENTRIES; idx++) {
8982  
8983  		ddb_entry = qla4xxx_lookup_ddb_by_fw_index(ha, idx);
8984  		if ((ddb_entry != NULL) &&
8985  		    (ddb_entry->ddb_type == FLASH_DDB)) {
8986  
8987  			qla4xxx_destroy_ddb(ha, ddb_entry);
8988  			/*
8989  			 * we have decremented the reference count of the driver
8990  			 * when we setup the session to have the driver unload
8991  			 * to be seamless without actually destroying the
8992  			 * session
8993  			 **/
8994  			try_module_get(qla4xxx_iscsi_transport.owner);
8995  			iscsi_destroy_endpoint(ddb_entry->conn->ep);
8996  			qla4xxx_free_ddb(ha, ddb_entry);
8997  			iscsi_session_teardown(ddb_entry->sess);
8998  		}
8999  	}
9000  }
9001  /**
9002   * qla4xxx_remove_adapter - callback function to remove adapter.
9003   * @pdev: PCI device pointer
9004   **/
qla4xxx_remove_adapter(struct pci_dev * pdev)9005  static void qla4xxx_remove_adapter(struct pci_dev *pdev)
9006  {
9007  	struct scsi_qla_host *ha;
9008  
9009  	/*
9010  	 * If the PCI device is disabled then it means probe_adapter had
9011  	 * failed and resources already cleaned up on probe_adapter exit.
9012  	 */
9013  	if (!pci_is_enabled(pdev))
9014  		return;
9015  
9016  	ha = pci_get_drvdata(pdev);
9017  
9018  	if (is_qla40XX(ha))
9019  		qla4xxx_prevent_other_port_reinit(ha);
9020  
9021  	/* destroy iface from sysfs */
9022  	qla4xxx_destroy_ifaces(ha);
9023  
9024  	if ((!ql4xdisablesysfsboot) && ha->boot_kset)
9025  		iscsi_boot_destroy_kset(ha->boot_kset);
9026  
9027  	qla4xxx_destroy_fw_ddb_session(ha);
9028  	qla4_8xxx_free_sysfs_attr(ha);
9029  
9030  	qla4xxx_sysfs_ddb_remove(ha);
9031  	scsi_remove_host(ha->host);
9032  
9033  	qla4xxx_free_adapter(ha);
9034  
9035  	scsi_host_put(ha->host);
9036  
9037  	pci_disable_device(pdev);
9038  }
9039  
9040  /**
9041   * qla4xxx_config_dma_addressing() - Configure OS DMA addressing method.
9042   * @ha: HA context
9043   */
qla4xxx_config_dma_addressing(struct scsi_qla_host * ha)9044  static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha)
9045  {
9046  	/* Update our PCI device dma_mask for full 64 bit mask */
9047  	if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
9048  		dev_dbg(&ha->pdev->dev,
9049  			  "Failed to set 64 bit PCI consistent mask; "
9050  			   "using 32 bit.\n");
9051  		dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(32));
9052  	}
9053  }
9054  
qla4xxx_slave_alloc(struct scsi_device * sdev)9055  static int qla4xxx_slave_alloc(struct scsi_device *sdev)
9056  {
9057  	struct iscsi_cls_session *cls_sess;
9058  	struct iscsi_session *sess;
9059  	struct ddb_entry *ddb;
9060  	int queue_depth = QL4_DEF_QDEPTH;
9061  
9062  	cls_sess = starget_to_session(sdev->sdev_target);
9063  	sess = cls_sess->dd_data;
9064  	ddb = sess->dd_data;
9065  
9066  	sdev->hostdata = ddb;
9067  
9068  	if (ql4xmaxqdepth != 0 && ql4xmaxqdepth <= 0xffffU)
9069  		queue_depth = ql4xmaxqdepth;
9070  
9071  	scsi_change_queue_depth(sdev, queue_depth);
9072  	return 0;
9073  }
9074  
9075  /**
9076   * qla4xxx_del_from_active_array - returns an active srb
9077   * @ha: Pointer to host adapter structure.
9078   * @index: index into the active_array
9079   *
9080   * This routine removes and returns the srb at the specified index
9081   **/
qla4xxx_del_from_active_array(struct scsi_qla_host * ha,uint32_t index)9082  struct srb *qla4xxx_del_from_active_array(struct scsi_qla_host *ha,
9083      uint32_t index)
9084  {
9085  	struct srb *srb = NULL;
9086  	struct scsi_cmnd *cmd = NULL;
9087  
9088  	cmd = scsi_host_find_tag(ha->host, index);
9089  	if (!cmd)
9090  		return srb;
9091  
9092  	srb = qla4xxx_cmd_priv(cmd)->srb;
9093  	if (!srb)
9094  		return srb;
9095  
9096  	/* update counters */
9097  	if (srb->flags & SRB_DMA_VALID) {
9098  		ha->iocb_cnt -= srb->iocb_cnt;
9099  		if (srb->cmd)
9100  			srb->cmd->host_scribble =
9101  				(unsigned char *)(unsigned long) MAX_SRBS;
9102  	}
9103  	return srb;
9104  }
9105  
9106  /**
9107   * qla4xxx_eh_wait_on_command - waits for command to be returned by firmware
9108   * @ha: Pointer to host adapter structure.
9109   * @cmd: Scsi Command to wait on.
9110   *
9111   * This routine waits for the command to be returned by the Firmware
9112   * for some max time.
9113   **/
qla4xxx_eh_wait_on_command(struct scsi_qla_host * ha,struct scsi_cmnd * cmd)9114  static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha,
9115  				      struct scsi_cmnd *cmd)
9116  {
9117  	int done = 0;
9118  	struct srb *rp;
9119  	uint32_t max_wait_time = EH_WAIT_CMD_TOV;
9120  	int ret = SUCCESS;
9121  
9122  	/* Dont wait on command if PCI error is being handled
9123  	 * by PCI AER driver
9124  	 */
9125  	if (unlikely(pci_channel_offline(ha->pdev)) ||
9126  	    (test_bit(AF_EEH_BUSY, &ha->flags))) {
9127  		ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n",
9128  		    ha->host_no, __func__);
9129  		return ret;
9130  	}
9131  
9132  	do {
9133  		/* Checking to see if its returned to OS */
9134  		rp = qla4xxx_cmd_priv(cmd)->srb;
9135  		if (rp == NULL) {
9136  			done++;
9137  			break;
9138  		}
9139  
9140  		msleep(2000);
9141  	} while (max_wait_time--);
9142  
9143  	return done;
9144  }
9145  
9146  /**
9147   * qla4xxx_wait_for_hba_online - waits for HBA to come online
9148   * @ha: Pointer to host adapter structure
9149   **/
qla4xxx_wait_for_hba_online(struct scsi_qla_host * ha)9150  static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha)
9151  {
9152  	unsigned long wait_online;
9153  
9154  	wait_online = jiffies + (HBA_ONLINE_TOV * HZ);
9155  	while (time_before(jiffies, wait_online)) {
9156  
9157  		if (adapter_up(ha))
9158  			return QLA_SUCCESS;
9159  
9160  		msleep(2000);
9161  	}
9162  
9163  	return QLA_ERROR;
9164  }
9165  
9166  /**
9167   * qla4xxx_eh_wait_for_commands - wait for active cmds to finish.
9168   * @ha: pointer to HBA
9169   * @stgt: pointer to SCSI target
9170   * @sdev: pointer to SCSI device
9171   *
9172   * This function waits for all outstanding commands to a lun to complete. It
9173   * returns 0 if all pending commands are returned and 1 otherwise.
9174   **/
qla4xxx_eh_wait_for_commands(struct scsi_qla_host * ha,struct scsi_target * stgt,struct scsi_device * sdev)9175  static int qla4xxx_eh_wait_for_commands(struct scsi_qla_host *ha,
9176  					struct scsi_target *stgt,
9177  					struct scsi_device *sdev)
9178  {
9179  	int cnt;
9180  	int status = 0;
9181  	struct scsi_cmnd *cmd;
9182  
9183  	/*
9184  	 * Waiting for all commands for the designated target or dev
9185  	 * in the active array
9186  	 */
9187  	for (cnt = 0; cnt < ha->host->can_queue; cnt++) {
9188  		cmd = scsi_host_find_tag(ha->host, cnt);
9189  		if (cmd && stgt == scsi_target(cmd->device) &&
9190  		    (!sdev || sdev == cmd->device)) {
9191  			if (!qla4xxx_eh_wait_on_command(ha, cmd)) {
9192  				status++;
9193  				break;
9194  			}
9195  		}
9196  	}
9197  	return status;
9198  }
9199  
9200  /**
9201   * qla4xxx_eh_abort - callback for abort task.
9202   * @cmd: Pointer to Linux's SCSI command structure
9203   *
9204   * This routine is called by the Linux OS to abort the specified
9205   * command.
9206   **/
qla4xxx_eh_abort(struct scsi_cmnd * cmd)9207  static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
9208  {
9209  	struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9210  	unsigned int id = cmd->device->id;
9211  	uint64_t lun = cmd->device->lun;
9212  	unsigned long flags;
9213  	struct srb *srb = NULL;
9214  	int ret = SUCCESS;
9215  	int wait = 0;
9216  	int rval;
9217  
9218  	ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%llu: Abort command issued cmd=%p, cdb=0x%x\n",
9219  		   ha->host_no, id, lun, cmd, cmd->cmnd[0]);
9220  
9221  	rval = qla4xxx_isp_check_reg(ha);
9222  	if (rval != QLA_SUCCESS) {
9223  		ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9224  		return FAILED;
9225  	}
9226  
9227  	spin_lock_irqsave(&ha->hardware_lock, flags);
9228  	srb = qla4xxx_cmd_priv(cmd)->srb;
9229  	if (!srb) {
9230  		spin_unlock_irqrestore(&ha->hardware_lock, flags);
9231  		ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%llu: Specified command has already completed.\n",
9232  			   ha->host_no, id, lun);
9233  		return SUCCESS;
9234  	}
9235  	kref_get(&srb->srb_ref);
9236  	spin_unlock_irqrestore(&ha->hardware_lock, flags);
9237  
9238  	if (qla4xxx_abort_task(ha, srb) != QLA_SUCCESS) {
9239  		DEBUG3(printk("scsi%ld:%d:%llu: Abort_task mbx failed.\n",
9240  		    ha->host_no, id, lun));
9241  		ret = FAILED;
9242  	} else {
9243  		DEBUG3(printk("scsi%ld:%d:%llu: Abort_task mbx success.\n",
9244  		    ha->host_no, id, lun));
9245  		wait = 1;
9246  	}
9247  
9248  	kref_put(&srb->srb_ref, qla4xxx_srb_compl);
9249  
9250  	/* Wait for command to complete */
9251  	if (wait) {
9252  		if (!qla4xxx_eh_wait_on_command(ha, cmd)) {
9253  			DEBUG2(printk("scsi%ld:%d:%llu: Abort handler timed out\n",
9254  			    ha->host_no, id, lun));
9255  			ret = FAILED;
9256  		}
9257  	}
9258  
9259  	ql4_printk(KERN_INFO, ha,
9260  	    "scsi%ld:%d:%llu: Abort command - %s\n",
9261  	    ha->host_no, id, lun, (ret == SUCCESS) ? "succeeded" : "failed");
9262  
9263  	return ret;
9264  }
9265  
9266  /**
9267   * qla4xxx_eh_device_reset - callback for target reset.
9268   * @cmd: Pointer to Linux's SCSI command structure
9269   *
9270   * This routine is called by the Linux OS to reset all luns on the
9271   * specified target.
9272   **/
qla4xxx_eh_device_reset(struct scsi_cmnd * cmd)9273  static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd)
9274  {
9275  	struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9276  	struct ddb_entry *ddb_entry = cmd->device->hostdata;
9277  	int ret = FAILED, stat;
9278  	int rval;
9279  
9280  	if (!ddb_entry)
9281  		return ret;
9282  
9283  	ret = iscsi_block_scsi_eh(cmd);
9284  	if (ret)
9285  		return ret;
9286  	ret = FAILED;
9287  
9288  	ql4_printk(KERN_INFO, ha,
9289  		   "scsi%ld:%d:%d:%llu: DEVICE RESET ISSUED.\n", ha->host_no,
9290  		   cmd->device->channel, cmd->device->id, cmd->device->lun);
9291  
9292  	DEBUG2(printk(KERN_INFO
9293  		      "scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x,"
9294  		      "dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no,
9295  		      cmd, jiffies, scsi_cmd_to_rq(cmd)->timeout / HZ,
9296  		      ha->dpc_flags, cmd->result, cmd->allowed));
9297  
9298  	rval = qla4xxx_isp_check_reg(ha);
9299  	if (rval != QLA_SUCCESS) {
9300  		ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9301  		return FAILED;
9302  	}
9303  
9304  	/* FIXME: wait for hba to go online */
9305  	stat = qla4xxx_reset_lun(ha, ddb_entry, cmd->device->lun);
9306  	if (stat != QLA_SUCCESS) {
9307  		ql4_printk(KERN_INFO, ha, "DEVICE RESET FAILED. %d\n", stat);
9308  		goto eh_dev_reset_done;
9309  	}
9310  
9311  	if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device),
9312  					 cmd->device)) {
9313  		ql4_printk(KERN_INFO, ha,
9314  			   "DEVICE RESET FAILED - waiting for "
9315  			   "commands.\n");
9316  		goto eh_dev_reset_done;
9317  	}
9318  
9319  	/* Send marker. */
9320  	if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun,
9321  		MM_LUN_RESET) != QLA_SUCCESS)
9322  		goto eh_dev_reset_done;
9323  
9324  	ql4_printk(KERN_INFO, ha,
9325  		   "scsi(%ld:%d:%d:%llu): DEVICE RESET SUCCEEDED.\n",
9326  		   ha->host_no, cmd->device->channel, cmd->device->id,
9327  		   cmd->device->lun);
9328  
9329  	ret = SUCCESS;
9330  
9331  eh_dev_reset_done:
9332  
9333  	return ret;
9334  }
9335  
9336  /**
9337   * qla4xxx_eh_target_reset - callback for target reset.
9338   * @cmd: Pointer to Linux's SCSI command structure
9339   *
9340   * This routine is called by the Linux OS to reset the target.
9341   **/
qla4xxx_eh_target_reset(struct scsi_cmnd * cmd)9342  static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd)
9343  {
9344  	struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
9345  	struct ddb_entry *ddb_entry = cmd->device->hostdata;
9346  	int stat, ret;
9347  	int rval;
9348  
9349  	if (!ddb_entry)
9350  		return FAILED;
9351  
9352  	ret = iscsi_block_scsi_eh(cmd);
9353  	if (ret)
9354  		return ret;
9355  
9356  	starget_printk(KERN_INFO, scsi_target(cmd->device),
9357  		       "WARM TARGET RESET ISSUED.\n");
9358  
9359  	DEBUG2(printk(KERN_INFO
9360  		      "scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, "
9361  		      "to=%x,dpc_flags=%lx, status=%x allowed=%d\n",
9362  		      ha->host_no, cmd, jiffies, scsi_cmd_to_rq(cmd)->timeout / HZ,
9363  		      ha->dpc_flags, cmd->result, cmd->allowed));
9364  
9365  	rval = qla4xxx_isp_check_reg(ha);
9366  	if (rval != QLA_SUCCESS) {
9367  		ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9368  		return FAILED;
9369  	}
9370  
9371  	stat = qla4xxx_reset_target(ha, ddb_entry);
9372  	if (stat != QLA_SUCCESS) {
9373  		starget_printk(KERN_INFO, scsi_target(cmd->device),
9374  			       "WARM TARGET RESET FAILED.\n");
9375  		return FAILED;
9376  	}
9377  
9378  	if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device),
9379  					 NULL)) {
9380  		starget_printk(KERN_INFO, scsi_target(cmd->device),
9381  			       "WARM TARGET DEVICE RESET FAILED - "
9382  			       "waiting for commands.\n");
9383  		return FAILED;
9384  	}
9385  
9386  	/* Send marker. */
9387  	if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun,
9388  		MM_TGT_WARM_RESET) != QLA_SUCCESS) {
9389  		starget_printk(KERN_INFO, scsi_target(cmd->device),
9390  			       "WARM TARGET DEVICE RESET FAILED - "
9391  			       "marker iocb failed.\n");
9392  		return FAILED;
9393  	}
9394  
9395  	starget_printk(KERN_INFO, scsi_target(cmd->device),
9396  		       "WARM TARGET RESET SUCCEEDED.\n");
9397  	return SUCCESS;
9398  }
9399  
9400  /**
9401   * qla4xxx_is_eh_active - check if error handler is running
9402   * @shost: Pointer to SCSI Host struct
9403   *
9404   * This routine finds that if reset host is called in EH
9405   * scenario or from some application like sg_reset
9406   **/
qla4xxx_is_eh_active(struct Scsi_Host * shost)9407  static int qla4xxx_is_eh_active(struct Scsi_Host *shost)
9408  {
9409  	if (shost->shost_state == SHOST_RECOVERY)
9410  		return 1;
9411  	return 0;
9412  }
9413  
9414  /**
9415   * qla4xxx_eh_host_reset - kernel callback
9416   * @cmd: Pointer to Linux's SCSI command structure
9417   *
9418   * This routine is invoked by the Linux kernel to perform fatal error
9419   * recovery on the specified adapter.
9420   **/
qla4xxx_eh_host_reset(struct scsi_cmnd * cmd)9421  static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd)
9422  {
9423  	int return_status = FAILED;
9424  	struct scsi_qla_host *ha;
9425  	int rval;
9426  
9427  	ha = to_qla_host(cmd->device->host);
9428  
9429  	rval = qla4xxx_isp_check_reg(ha);
9430  	if (rval != QLA_SUCCESS) {
9431  		ql4_printk(KERN_INFO, ha, "PCI/Register disconnect, exiting.\n");
9432  		return FAILED;
9433  	}
9434  
9435  	if ((is_qla8032(ha) || is_qla8042(ha)) && ql4xdontresethba)
9436  		qla4_83xx_set_idc_dontreset(ha);
9437  
9438  	/*
9439  	 * For ISP8324 and ISP8042, if IDC_CTRL DONTRESET_BIT0 is set by other
9440  	 * protocol drivers, we should not set device_state to NEED_RESET
9441  	 */
9442  	if (ql4xdontresethba ||
9443  	    ((is_qla8032(ha) || is_qla8042(ha)) &&
9444  	     qla4_83xx_idc_dontreset(ha))) {
9445  		DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n",
9446  		     ha->host_no, __func__));
9447  
9448  		/* Clear outstanding srb in queues */
9449  		if (qla4xxx_is_eh_active(cmd->device->host))
9450  			qla4xxx_abort_active_cmds(ha, DID_ABORT << 16);
9451  
9452  		return FAILED;
9453  	}
9454  
9455  	ql4_printk(KERN_INFO, ha,
9456  		   "scsi(%ld:%d:%d:%llu): HOST RESET ISSUED.\n", ha->host_no,
9457  		   cmd->device->channel, cmd->device->id, cmd->device->lun);
9458  
9459  	if (qla4xxx_wait_for_hba_online(ha) != QLA_SUCCESS) {
9460  		DEBUG2(printk("scsi%ld:%d: %s: Unable to reset host.  Adapter "
9461  			      "DEAD.\n", ha->host_no, cmd->device->channel,
9462  			      __func__));
9463  
9464  		return FAILED;
9465  	}
9466  
9467  	if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9468  		if (is_qla80XX(ha))
9469  			set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags);
9470  		else
9471  			set_bit(DPC_RESET_HA, &ha->dpc_flags);
9472  	}
9473  
9474  	if (qla4xxx_recover_adapter(ha) == QLA_SUCCESS)
9475  		return_status = SUCCESS;
9476  
9477  	ql4_printk(KERN_INFO, ha, "HOST RESET %s.\n",
9478  		   return_status == FAILED ? "FAILED" : "SUCCEEDED");
9479  
9480  	return return_status;
9481  }
9482  
qla4xxx_context_reset(struct scsi_qla_host * ha)9483  static int qla4xxx_context_reset(struct scsi_qla_host *ha)
9484  {
9485  	uint32_t mbox_cmd[MBOX_REG_COUNT];
9486  	uint32_t mbox_sts[MBOX_REG_COUNT];
9487  	struct addr_ctrl_blk_def *acb = NULL;
9488  	uint32_t acb_len = sizeof(struct addr_ctrl_blk_def);
9489  	int rval = QLA_SUCCESS;
9490  	dma_addr_t acb_dma;
9491  
9492  	acb = dma_alloc_coherent(&ha->pdev->dev,
9493  				 sizeof(struct addr_ctrl_blk_def),
9494  				 &acb_dma, GFP_KERNEL);
9495  	if (!acb) {
9496  		ql4_printk(KERN_ERR, ha, "%s: Unable to alloc acb\n",
9497  			   __func__);
9498  		rval = -ENOMEM;
9499  		goto exit_port_reset;
9500  	}
9501  
9502  	memset(acb, 0, acb_len);
9503  
9504  	rval = qla4xxx_get_acb(ha, acb_dma, PRIMARI_ACB, acb_len);
9505  	if (rval != QLA_SUCCESS) {
9506  		rval = -EIO;
9507  		goto exit_free_acb;
9508  	}
9509  
9510  	rval = qla4xxx_disable_acb(ha);
9511  	if (rval != QLA_SUCCESS) {
9512  		rval = -EIO;
9513  		goto exit_free_acb;
9514  	}
9515  
9516  	wait_for_completion_timeout(&ha->disable_acb_comp,
9517  				    DISABLE_ACB_TOV * HZ);
9518  
9519  	rval = qla4xxx_set_acb(ha, &mbox_cmd[0], &mbox_sts[0], acb_dma);
9520  	if (rval != QLA_SUCCESS) {
9521  		rval = -EIO;
9522  		goto exit_free_acb;
9523  	}
9524  
9525  exit_free_acb:
9526  	dma_free_coherent(&ha->pdev->dev, sizeof(struct addr_ctrl_blk_def),
9527  			  acb, acb_dma);
9528  exit_port_reset:
9529  	DEBUG2(ql4_printk(KERN_INFO, ha, "%s %s\n", __func__,
9530  			  rval == QLA_SUCCESS ? "SUCCEEDED" : "FAILED"));
9531  	return rval;
9532  }
9533  
qla4xxx_host_reset(struct Scsi_Host * shost,int reset_type)9534  static int qla4xxx_host_reset(struct Scsi_Host *shost, int reset_type)
9535  {
9536  	struct scsi_qla_host *ha = to_qla_host(shost);
9537  	int rval = QLA_SUCCESS;
9538  	uint32_t idc_ctrl;
9539  
9540  	if (ql4xdontresethba) {
9541  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: Don't Reset HBA\n",
9542  				  __func__));
9543  		rval = -EPERM;
9544  		goto exit_host_reset;
9545  	}
9546  
9547  	if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
9548  		goto recover_adapter;
9549  
9550  	switch (reset_type) {
9551  	case SCSI_ADAPTER_RESET:
9552  		set_bit(DPC_RESET_HA, &ha->dpc_flags);
9553  		break;
9554  	case SCSI_FIRMWARE_RESET:
9555  		if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9556  			if (is_qla80XX(ha))
9557  				/* set firmware context reset */
9558  				set_bit(DPC_RESET_HA_FW_CONTEXT,
9559  					&ha->dpc_flags);
9560  			else {
9561  				rval = qla4xxx_context_reset(ha);
9562  				goto exit_host_reset;
9563  			}
9564  		}
9565  		break;
9566  	}
9567  
9568  recover_adapter:
9569  	/* For ISP8324 and ISP8042 set graceful reset bit in IDC_DRV_CTRL if
9570  	 * reset is issued by application */
9571  	if ((is_qla8032(ha) || is_qla8042(ha)) &&
9572  	    test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
9573  		idc_ctrl = qla4_83xx_rd_reg(ha, QLA83XX_IDC_DRV_CTRL);
9574  		qla4_83xx_wr_reg(ha, QLA83XX_IDC_DRV_CTRL,
9575  				 (idc_ctrl | GRACEFUL_RESET_BIT1));
9576  	}
9577  
9578  	rval = qla4xxx_recover_adapter(ha);
9579  	if (rval != QLA_SUCCESS) {
9580  		DEBUG2(ql4_printk(KERN_INFO, ha, "%s: recover adapter fail\n",
9581  				  __func__));
9582  		rval = -EIO;
9583  	}
9584  
9585  exit_host_reset:
9586  	return rval;
9587  }
9588  
9589  /* PCI AER driver recovers from all correctable errors w/o
9590   * driver intervention. For uncorrectable errors PCI AER
9591   * driver calls the following device driver's callbacks
9592   *
9593   * - Fatal Errors - link_reset
9594   * - Non-Fatal Errors - driver's error_detected() which
9595   * returns CAN_RECOVER, NEED_RESET or DISCONNECT.
9596   *
9597   * PCI AER driver calls
9598   * CAN_RECOVER - driver's mmio_enabled(), mmio_enabled()
9599   *               returns RECOVERED or NEED_RESET if fw_hung
9600   * NEED_RESET - driver's slot_reset()
9601   * DISCONNECT - device is dead & cannot recover
9602   * RECOVERED - driver's resume()
9603   */
9604  static pci_ers_result_t
qla4xxx_pci_error_detected(struct pci_dev * pdev,pci_channel_state_t state)9605  qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
9606  {
9607  	struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9608  
9609  	ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n",
9610  	    ha->host_no, __func__, state);
9611  
9612  	if (!is_aer_supported(ha))
9613  		return PCI_ERS_RESULT_NONE;
9614  
9615  	switch (state) {
9616  	case pci_channel_io_normal:
9617  		clear_bit(AF_EEH_BUSY, &ha->flags);
9618  		return PCI_ERS_RESULT_CAN_RECOVER;
9619  	case pci_channel_io_frozen:
9620  		set_bit(AF_EEH_BUSY, &ha->flags);
9621  		qla4xxx_mailbox_premature_completion(ha);
9622  		qla4xxx_free_irqs(ha);
9623  		pci_disable_device(pdev);
9624  		/* Return back all IOs */
9625  		qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
9626  		return PCI_ERS_RESULT_NEED_RESET;
9627  	case pci_channel_io_perm_failure:
9628  		set_bit(AF_EEH_BUSY, &ha->flags);
9629  		set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags);
9630  		qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
9631  		return PCI_ERS_RESULT_DISCONNECT;
9632  	}
9633  	return PCI_ERS_RESULT_NEED_RESET;
9634  }
9635  
9636  /**
9637   * qla4xxx_pci_mmio_enabled() - gets called if
9638   * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER
9639   * and read/write to the device still works.
9640   * @pdev: PCI device pointer
9641   **/
9642  static pci_ers_result_t
qla4xxx_pci_mmio_enabled(struct pci_dev * pdev)9643  qla4xxx_pci_mmio_enabled(struct pci_dev *pdev)
9644  {
9645  	struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9646  
9647  	if (!is_aer_supported(ha))
9648  		return PCI_ERS_RESULT_NONE;
9649  
9650  	return PCI_ERS_RESULT_RECOVERED;
9651  }
9652  
qla4_8xxx_error_recovery(struct scsi_qla_host * ha)9653  static uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha)
9654  {
9655  	uint32_t rval = QLA_ERROR;
9656  	int fn;
9657  	struct pci_dev *other_pdev = NULL;
9658  
9659  	ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__);
9660  
9661  	set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
9662  
9663  	if (test_bit(AF_ONLINE, &ha->flags)) {
9664  		clear_bit(AF_ONLINE, &ha->flags);
9665  		clear_bit(AF_LINK_UP, &ha->flags);
9666  		iscsi_host_for_each_session(ha->host, qla4xxx_fail_session);
9667  		qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
9668  	}
9669  
9670  	fn = PCI_FUNC(ha->pdev->devfn);
9671  	if (is_qla8022(ha)) {
9672  		while (fn > 0) {
9673  			fn--;
9674  			ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at func %x\n",
9675  				   ha->host_no, __func__, fn);
9676  			/* Get the pci device given the domain, bus,
9677  			 * slot/function number */
9678  			other_pdev = pci_get_domain_bus_and_slot(
9679  					   pci_domain_nr(ha->pdev->bus),
9680  					   ha->pdev->bus->number,
9681  					   PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
9682  					   fn));
9683  
9684  			if (!other_pdev)
9685  				continue;
9686  
9687  			if (atomic_read(&other_pdev->enable_cnt)) {
9688  				ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI func in enabled state%x\n",
9689  					   ha->host_no, __func__, fn);
9690  				pci_dev_put(other_pdev);
9691  				break;
9692  			}
9693  			pci_dev_put(other_pdev);
9694  		}
9695  	} else {
9696  		/* this case is meant for ISP83xx/ISP84xx only */
9697  		if (qla4_83xx_can_perform_reset(ha)) {
9698  			/* reset fn as iSCSI is going to perform the reset */
9699  			fn = 0;
9700  		}
9701  	}
9702  
9703  	/* The first function on the card, the reset owner will
9704  	 * start & initialize the firmware. The other functions
9705  	 * on the card will reset the firmware context
9706  	 */
9707  	if (!fn) {
9708  		ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset "
9709  		    "0x%x is the owner\n", ha->host_no, __func__,
9710  		    ha->pdev->devfn);
9711  
9712  		ha->isp_ops->idc_lock(ha);
9713  		qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9714  				    QLA8XXX_DEV_COLD);
9715  		ha->isp_ops->idc_unlock(ha);
9716  
9717  		rval = qla4_8xxx_update_idc_reg(ha);
9718  		if (rval == QLA_ERROR) {
9719  			ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: FAILED\n",
9720  				   ha->host_no, __func__);
9721  			ha->isp_ops->idc_lock(ha);
9722  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9723  					    QLA8XXX_DEV_FAILED);
9724  			ha->isp_ops->idc_unlock(ha);
9725  			goto exit_error_recovery;
9726  		}
9727  
9728  		clear_bit(AF_FW_RECOVERY, &ha->flags);
9729  		rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
9730  
9731  		if (rval != QLA_SUCCESS) {
9732  			ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
9733  			    "FAILED\n", ha->host_no, __func__);
9734  			qla4xxx_free_irqs(ha);
9735  			ha->isp_ops->idc_lock(ha);
9736  			qla4_8xxx_clear_drv_active(ha);
9737  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9738  					    QLA8XXX_DEV_FAILED);
9739  			ha->isp_ops->idc_unlock(ha);
9740  		} else {
9741  			ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
9742  			    "READY\n", ha->host_no, __func__);
9743  			ha->isp_ops->idc_lock(ha);
9744  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
9745  					    QLA8XXX_DEV_READY);
9746  			/* Clear driver state register */
9747  			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DRV_STATE, 0);
9748  			qla4_8xxx_set_drv_active(ha);
9749  			ha->isp_ops->idc_unlock(ha);
9750  			ha->isp_ops->enable_intrs(ha);
9751  		}
9752  	} else {
9753  		ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not "
9754  		    "the reset owner\n", ha->host_no, __func__,
9755  		    ha->pdev->devfn);
9756  		if ((qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE) ==
9757  		     QLA8XXX_DEV_READY)) {
9758  			clear_bit(AF_FW_RECOVERY, &ha->flags);
9759  			rval = qla4xxx_initialize_adapter(ha, RESET_ADAPTER);
9760  			if (rval == QLA_SUCCESS)
9761  				ha->isp_ops->enable_intrs(ha);
9762  			else
9763  				qla4xxx_free_irqs(ha);
9764  
9765  			ha->isp_ops->idc_lock(ha);
9766  			qla4_8xxx_set_drv_active(ha);
9767  			ha->isp_ops->idc_unlock(ha);
9768  		}
9769  	}
9770  exit_error_recovery:
9771  	clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
9772  	return rval;
9773  }
9774  
9775  static pci_ers_result_t
qla4xxx_pci_slot_reset(struct pci_dev * pdev)9776  qla4xxx_pci_slot_reset(struct pci_dev *pdev)
9777  {
9778  	pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
9779  	struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9780  	int rc;
9781  
9782  	ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n",
9783  	    ha->host_no, __func__);
9784  
9785  	if (!is_aer_supported(ha))
9786  		return PCI_ERS_RESULT_NONE;
9787  
9788  	/* Restore the saved state of PCIe device -
9789  	 * BAR registers, PCI Config space, PCIX, MSI,
9790  	 * IOV states
9791  	 */
9792  	pci_restore_state(pdev);
9793  
9794  	/* pci_restore_state() clears the saved_state flag of the device
9795  	 * save restored state which resets saved_state flag
9796  	 */
9797  	pci_save_state(pdev);
9798  
9799  	/* Initialize device or resume if in suspended state */
9800  	rc = pci_enable_device(pdev);
9801  	if (rc) {
9802  		ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Can't re-enable "
9803  		    "device after reset\n", ha->host_no, __func__);
9804  		goto exit_slot_reset;
9805  	}
9806  
9807  	ha->isp_ops->disable_intrs(ha);
9808  
9809  	if (is_qla80XX(ha)) {
9810  		if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) {
9811  			ret = PCI_ERS_RESULT_RECOVERED;
9812  			goto exit_slot_reset;
9813  		} else
9814  			goto exit_slot_reset;
9815  	}
9816  
9817  exit_slot_reset:
9818  	ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n"
9819  	    "device after reset\n", ha->host_no, __func__, ret);
9820  	return ret;
9821  }
9822  
9823  static void
qla4xxx_pci_resume(struct pci_dev * pdev)9824  qla4xxx_pci_resume(struct pci_dev *pdev)
9825  {
9826  	struct scsi_qla_host *ha = pci_get_drvdata(pdev);
9827  	int ret;
9828  
9829  	ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n",
9830  	    ha->host_no, __func__);
9831  
9832  	ret = qla4xxx_wait_for_hba_online(ha);
9833  	if (ret != QLA_SUCCESS) {
9834  		ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to "
9835  		    "resume I/O from slot/link_reset\n", ha->host_no,
9836  		     __func__);
9837  	}
9838  
9839  	clear_bit(AF_EEH_BUSY, &ha->flags);
9840  }
9841  
9842  static const struct pci_error_handlers qla4xxx_err_handler = {
9843  	.error_detected = qla4xxx_pci_error_detected,
9844  	.mmio_enabled = qla4xxx_pci_mmio_enabled,
9845  	.slot_reset = qla4xxx_pci_slot_reset,
9846  	.resume = qla4xxx_pci_resume,
9847  };
9848  
9849  static struct pci_device_id qla4xxx_pci_tbl[] = {
9850  	{
9851  		.vendor		= PCI_VENDOR_ID_QLOGIC,
9852  		.device		= PCI_DEVICE_ID_QLOGIC_ISP4010,
9853  		.subvendor	= PCI_ANY_ID,
9854  		.subdevice	= PCI_ANY_ID,
9855  	},
9856  	{
9857  		.vendor		= PCI_VENDOR_ID_QLOGIC,
9858  		.device		= PCI_DEVICE_ID_QLOGIC_ISP4022,
9859  		.subvendor	= PCI_ANY_ID,
9860  		.subdevice	= PCI_ANY_ID,
9861  	},
9862  	{
9863  		.vendor		= PCI_VENDOR_ID_QLOGIC,
9864  		.device		= PCI_DEVICE_ID_QLOGIC_ISP4032,
9865  		.subvendor	= PCI_ANY_ID,
9866  		.subdevice	= PCI_ANY_ID,
9867  	},
9868  	{
9869  		.vendor         = PCI_VENDOR_ID_QLOGIC,
9870  		.device         = PCI_DEVICE_ID_QLOGIC_ISP8022,
9871  		.subvendor      = PCI_ANY_ID,
9872  		.subdevice      = PCI_ANY_ID,
9873  	},
9874  	{
9875  		.vendor		= PCI_VENDOR_ID_QLOGIC,
9876  		.device		= PCI_DEVICE_ID_QLOGIC_ISP8324,
9877  		.subvendor	= PCI_ANY_ID,
9878  		.subdevice	= PCI_ANY_ID,
9879  	},
9880  	{
9881  		.vendor		= PCI_VENDOR_ID_QLOGIC,
9882  		.device		= PCI_DEVICE_ID_QLOGIC_ISP8042,
9883  		.subvendor	= PCI_ANY_ID,
9884  		.subdevice	= PCI_ANY_ID,
9885  	},
9886  	{0, 0},
9887  };
9888  MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl);
9889  
9890  static struct pci_driver qla4xxx_pci_driver = {
9891  	.name		= DRIVER_NAME,
9892  	.id_table	= qla4xxx_pci_tbl,
9893  	.probe		= qla4xxx_probe_adapter,
9894  	.remove		= qla4xxx_remove_adapter,
9895  	.err_handler = &qla4xxx_err_handler,
9896  };
9897  
qla4xxx_module_init(void)9898  static int __init qla4xxx_module_init(void)
9899  {
9900  	int ret;
9901  
9902  	if (ql4xqfulltracking)
9903  		qla4xxx_driver_template.track_queue_depth = 1;
9904  
9905  	/* Allocate cache for SRBs. */
9906  	srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0,
9907  				       SLAB_HWCACHE_ALIGN, NULL);
9908  	if (srb_cachep == NULL) {
9909  		printk(KERN_ERR
9910  		       "%s: Unable to allocate SRB cache..."
9911  		       "Failing load!\n", DRIVER_NAME);
9912  		ret = -ENOMEM;
9913  		goto no_srp_cache;
9914  	}
9915  
9916  	/* Derive version string. */
9917  	strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION);
9918  	if (ql4xextended_error_logging)
9919  		strcat(qla4xxx_version_str, "-debug");
9920  
9921  	qla4xxx_scsi_transport =
9922  		iscsi_register_transport(&qla4xxx_iscsi_transport);
9923  	if (!qla4xxx_scsi_transport){
9924  		ret = -ENODEV;
9925  		goto release_srb_cache;
9926  	}
9927  
9928  	ret = pci_register_driver(&qla4xxx_pci_driver);
9929  	if (ret)
9930  		goto unregister_transport;
9931  
9932  	printk(KERN_INFO "QLogic iSCSI HBA Driver\n");
9933  	return 0;
9934  
9935  unregister_transport:
9936  	iscsi_unregister_transport(&qla4xxx_iscsi_transport);
9937  release_srb_cache:
9938  	kmem_cache_destroy(srb_cachep);
9939  no_srp_cache:
9940  	return ret;
9941  }
9942  
qla4xxx_module_exit(void)9943  static void __exit qla4xxx_module_exit(void)
9944  {
9945  	pci_unregister_driver(&qla4xxx_pci_driver);
9946  	iscsi_unregister_transport(&qla4xxx_iscsi_transport);
9947  	kmem_cache_destroy(srb_cachep);
9948  }
9949  
9950  module_init(qla4xxx_module_init);
9951  module_exit(qla4xxx_module_exit);
9952  
9953  MODULE_AUTHOR("QLogic Corporation");
9954  MODULE_DESCRIPTION("QLogic iSCSI HBA Driver");
9955  MODULE_LICENSE("GPL");
9956  MODULE_VERSION(QLA4XXX_DRIVER_VERSION);
9957