xref: /openbmc/linux/drivers/scsi/bnx2i/bnx2i_iscsi.c (revision c819e2cf)
1 /*
2  * bnx2i_iscsi.c: QLogic NetXtreme II iSCSI driver.
3  *
4  * Copyright (c) 2006 - 2013 Broadcom Corporation
5  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
6  * Copyright (c) 2007, 2008 Mike Christie
7  * Copyright (c) 2014, QLogic Corporation
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation.
12  *
13  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
14  * Previously Maintained by: Eddie Wai (eddie.wai@broadcom.com)
15  * Maintained by: QLogic-Storage-Upstream@qlogic.com
16  */
17 
18 #include <linux/slab.h>
19 #include <scsi/scsi_tcq.h>
20 #include <scsi/libiscsi.h>
21 #include "bnx2i.h"
22 
23 struct scsi_transport_template *bnx2i_scsi_xport_template;
24 struct iscsi_transport bnx2i_iscsi_transport;
25 static struct scsi_host_template bnx2i_host_template;
26 
27 /*
28  * Global endpoint resource info
29  */
30 static DEFINE_SPINLOCK(bnx2i_resc_lock); /* protects global resources */
31 
32 DECLARE_PER_CPU(struct bnx2i_percpu_s, bnx2i_percpu);
33 
34 static int bnx2i_adapter_ready(struct bnx2i_hba *hba)
35 {
36 	int retval = 0;
37 
38 	if (!hba || !test_bit(ADAPTER_STATE_UP, &hba->adapter_state) ||
39 	    test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state) ||
40 	    test_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state))
41 		retval = -EPERM;
42 	return retval;
43 }
44 
45 /**
46  * bnx2i_get_write_cmd_bd_idx - identifies various BD bookmarks
47  * @cmd:		iscsi cmd struct pointer
48  * @buf_off:		absolute buffer offset
49  * @start_bd_off:	u32 pointer to return the offset within the BD
50  *			indicated by 'start_bd_idx' on which 'buf_off' falls
51  * @start_bd_idx:	index of the BD on which 'buf_off' falls
52  *
53  * identifies & marks various bd info for scsi command's imm data,
54  * unsolicited data and the first solicited data seq.
55  */
56 static void bnx2i_get_write_cmd_bd_idx(struct bnx2i_cmd *cmd, u32 buf_off,
57 				       u32 *start_bd_off, u32 *start_bd_idx)
58 {
59 	struct iscsi_bd *bd_tbl = cmd->io_tbl.bd_tbl;
60 	u32 cur_offset = 0;
61 	u32 cur_bd_idx = 0;
62 
63 	if (buf_off) {
64 		while (buf_off >= (cur_offset + bd_tbl->buffer_length)) {
65 			cur_offset += bd_tbl->buffer_length;
66 			cur_bd_idx++;
67 			bd_tbl++;
68 		}
69 	}
70 
71 	*start_bd_off = buf_off - cur_offset;
72 	*start_bd_idx = cur_bd_idx;
73 }
74 
75 /**
76  * bnx2i_setup_write_cmd_bd_info - sets up BD various information
77  * @task:	transport layer's cmd struct pointer
78  *
79  * identifies & marks various bd info for scsi command's immediate data,
80  * unsolicited data and first solicited data seq which includes BD start
81  * index & BD buf off. his function takes into account iscsi parameter such
82  * as immediate data and unsolicited data is support on this connection.
83  */
84 static void bnx2i_setup_write_cmd_bd_info(struct iscsi_task *task)
85 {
86 	struct bnx2i_cmd *cmd = task->dd_data;
87 	u32 start_bd_offset;
88 	u32 start_bd_idx;
89 	u32 buffer_offset = 0;
90 	u32 cmd_len = cmd->req.total_data_transfer_length;
91 
92 	/* if ImmediateData is turned off & IntialR2T is turned on,
93 	 * there will be no immediate or unsolicited data, just return.
94 	 */
95 	if (!iscsi_task_has_unsol_data(task) && !task->imm_count)
96 		return;
97 
98 	/* Immediate data */
99 	buffer_offset += task->imm_count;
100 	if (task->imm_count == cmd_len)
101 		return;
102 
103 	if (iscsi_task_has_unsol_data(task)) {
104 		bnx2i_get_write_cmd_bd_idx(cmd, buffer_offset,
105 					   &start_bd_offset, &start_bd_idx);
106 		cmd->req.ud_buffer_offset = start_bd_offset;
107 		cmd->req.ud_start_bd_index = start_bd_idx;
108 		buffer_offset += task->unsol_r2t.data_length;
109 	}
110 
111 	if (buffer_offset != cmd_len) {
112 		bnx2i_get_write_cmd_bd_idx(cmd, buffer_offset,
113 					   &start_bd_offset, &start_bd_idx);
114 		if ((start_bd_offset > task->conn->session->first_burst) ||
115 		    (start_bd_idx > scsi_sg_count(cmd->scsi_cmd))) {
116 			int i = 0;
117 
118 			iscsi_conn_printk(KERN_ALERT, task->conn,
119 					  "bnx2i- error, buf offset 0x%x "
120 					  "bd_valid %d use_sg %d\n",
121 					  buffer_offset, cmd->io_tbl.bd_valid,
122 					  scsi_sg_count(cmd->scsi_cmd));
123 			for (i = 0; i < cmd->io_tbl.bd_valid; i++)
124 				iscsi_conn_printk(KERN_ALERT, task->conn,
125 						  "bnx2i err, bd[%d]: len %x\n",
126 						  i, cmd->io_tbl.bd_tbl[i].\
127 						  buffer_length);
128 		}
129 		cmd->req.sd_buffer_offset = start_bd_offset;
130 		cmd->req.sd_start_bd_index = start_bd_idx;
131 	}
132 }
133 
134 
135 
136 /**
137  * bnx2i_map_scsi_sg - maps IO buffer and prepares the BD table
138  * @hba:	adapter instance
139  * @cmd:	iscsi cmd struct pointer
140  *
141  * map SG list
142  */
143 static int bnx2i_map_scsi_sg(struct bnx2i_hba *hba, struct bnx2i_cmd *cmd)
144 {
145 	struct scsi_cmnd *sc = cmd->scsi_cmd;
146 	struct iscsi_bd *bd = cmd->io_tbl.bd_tbl;
147 	struct scatterlist *sg;
148 	int byte_count = 0;
149 	int bd_count = 0;
150 	int sg_count;
151 	int sg_len;
152 	u64 addr;
153 	int i;
154 
155 	BUG_ON(scsi_sg_count(sc) > ISCSI_MAX_BDS_PER_CMD);
156 
157 	sg_count = scsi_dma_map(sc);
158 
159 	scsi_for_each_sg(sc, sg, sg_count, i) {
160 		sg_len = sg_dma_len(sg);
161 		addr = (u64) sg_dma_address(sg);
162 		bd[bd_count].buffer_addr_lo = addr & 0xffffffff;
163 		bd[bd_count].buffer_addr_hi = addr >> 32;
164 		bd[bd_count].buffer_length = sg_len;
165 		bd[bd_count].flags = 0;
166 		if (bd_count == 0)
167 			bd[bd_count].flags = ISCSI_BD_FIRST_IN_BD_CHAIN;
168 
169 		byte_count += sg_len;
170 		bd_count++;
171 	}
172 
173 	if (bd_count)
174 		bd[bd_count - 1].flags |= ISCSI_BD_LAST_IN_BD_CHAIN;
175 
176 	BUG_ON(byte_count != scsi_bufflen(sc));
177 	return bd_count;
178 }
179 
180 /**
181  * bnx2i_iscsi_map_sg_list - maps SG list
182  * @cmd:	iscsi cmd struct pointer
183  *
184  * creates BD list table for the command
185  */
186 static void bnx2i_iscsi_map_sg_list(struct bnx2i_cmd *cmd)
187 {
188 	int bd_count;
189 
190 	bd_count  = bnx2i_map_scsi_sg(cmd->conn->hba, cmd);
191 	if (!bd_count) {
192 		struct iscsi_bd *bd = cmd->io_tbl.bd_tbl;
193 
194 		bd[0].buffer_addr_lo = bd[0].buffer_addr_hi = 0;
195 		bd[0].buffer_length = bd[0].flags = 0;
196 	}
197 	cmd->io_tbl.bd_valid = bd_count;
198 }
199 
200 
201 /**
202  * bnx2i_iscsi_unmap_sg_list - unmaps SG list
203  * @cmd:	iscsi cmd struct pointer
204  *
205  * unmap IO buffers and invalidate the BD table
206  */
207 void bnx2i_iscsi_unmap_sg_list(struct bnx2i_cmd *cmd)
208 {
209 	struct scsi_cmnd *sc = cmd->scsi_cmd;
210 
211 	if (cmd->io_tbl.bd_valid && sc) {
212 		scsi_dma_unmap(sc);
213 		cmd->io_tbl.bd_valid = 0;
214 	}
215 }
216 
217 static void bnx2i_setup_cmd_wqe_template(struct bnx2i_cmd *cmd)
218 {
219 	memset(&cmd->req, 0x00, sizeof(cmd->req));
220 	cmd->req.op_code = 0xFF;
221 	cmd->req.bd_list_addr_lo = (u32) cmd->io_tbl.bd_tbl_dma;
222 	cmd->req.bd_list_addr_hi =
223 		(u32) ((u64) cmd->io_tbl.bd_tbl_dma >> 32);
224 
225 }
226 
227 
228 /**
229  * bnx2i_bind_conn_to_iscsi_cid - bind conn structure to 'iscsi_cid'
230  * @hba:	pointer to adapter instance
231  * @conn:	pointer to iscsi connection
232  * @iscsi_cid:	iscsi context ID, range 0 - (MAX_CONN - 1)
233  *
234  * update iscsi cid table entry with connection pointer. This enables
235  *	driver to quickly get hold of connection structure pointer in
236  *	completion/interrupt thread using iscsi context ID
237  */
238 static int bnx2i_bind_conn_to_iscsi_cid(struct bnx2i_hba *hba,
239 					struct bnx2i_conn *bnx2i_conn,
240 					u32 iscsi_cid)
241 {
242 	if (hba && hba->cid_que.conn_cid_tbl[iscsi_cid]) {
243 		iscsi_conn_printk(KERN_ALERT, bnx2i_conn->cls_conn->dd_data,
244 				 "conn bind - entry #%d not free\n", iscsi_cid);
245 		return -EBUSY;
246 	}
247 
248 	hba->cid_que.conn_cid_tbl[iscsi_cid] = bnx2i_conn;
249 	return 0;
250 }
251 
252 
253 /**
254  * bnx2i_get_conn_from_id - maps an iscsi cid to corresponding conn ptr
255  * @hba:	pointer to adapter instance
256  * @iscsi_cid:	iscsi context ID, range 0 - (MAX_CONN - 1)
257  */
258 struct bnx2i_conn *bnx2i_get_conn_from_id(struct bnx2i_hba *hba,
259 					  u16 iscsi_cid)
260 {
261 	if (!hba->cid_que.conn_cid_tbl) {
262 		printk(KERN_ERR "bnx2i: ERROR - missing conn<->cid table\n");
263 		return NULL;
264 
265 	} else if (iscsi_cid >= hba->max_active_conns) {
266 		printk(KERN_ERR "bnx2i: wrong cid #%d\n", iscsi_cid);
267 		return NULL;
268 	}
269 	return hba->cid_que.conn_cid_tbl[iscsi_cid];
270 }
271 
272 
273 /**
274  * bnx2i_alloc_iscsi_cid - allocates a iscsi_cid from free pool
275  * @hba:	pointer to adapter instance
276  */
277 static u32 bnx2i_alloc_iscsi_cid(struct bnx2i_hba *hba)
278 {
279 	int idx;
280 
281 	if (!hba->cid_que.cid_free_cnt)
282 		return -1;
283 
284 	idx = hba->cid_que.cid_q_cons_idx;
285 	hba->cid_que.cid_q_cons_idx++;
286 	if (hba->cid_que.cid_q_cons_idx == hba->cid_que.cid_q_max_idx)
287 		hba->cid_que.cid_q_cons_idx = 0;
288 
289 	hba->cid_que.cid_free_cnt--;
290 	return hba->cid_que.cid_que[idx];
291 }
292 
293 
294 /**
295  * bnx2i_free_iscsi_cid - returns tcp port to free list
296  * @hba: 		pointer to adapter instance
297  * @iscsi_cid:		iscsi context ID to free
298  */
299 static void bnx2i_free_iscsi_cid(struct bnx2i_hba *hba, u16 iscsi_cid)
300 {
301 	int idx;
302 
303 	if (iscsi_cid == (u16) -1)
304 		return;
305 
306 	hba->cid_que.cid_free_cnt++;
307 
308 	idx = hba->cid_que.cid_q_prod_idx;
309 	hba->cid_que.cid_que[idx] = iscsi_cid;
310 	hba->cid_que.conn_cid_tbl[iscsi_cid] = NULL;
311 	hba->cid_que.cid_q_prod_idx++;
312 	if (hba->cid_que.cid_q_prod_idx == hba->cid_que.cid_q_max_idx)
313 		hba->cid_que.cid_q_prod_idx = 0;
314 }
315 
316 
317 /**
318  * bnx2i_setup_free_cid_que - sets up free iscsi cid queue
319  * @hba:	pointer to adapter instance
320  *
321  * allocates memory for iscsi cid queue & 'cid - conn ptr' mapping table,
322  * 	and initialize table attributes
323  */
324 static int bnx2i_setup_free_cid_que(struct bnx2i_hba *hba)
325 {
326 	int mem_size;
327 	int i;
328 
329 	mem_size = hba->max_active_conns * sizeof(u32);
330 	mem_size = (mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
331 
332 	hba->cid_que.cid_que_base = kmalloc(mem_size, GFP_KERNEL);
333 	if (!hba->cid_que.cid_que_base)
334 		return -ENOMEM;
335 
336 	mem_size = hba->max_active_conns * sizeof(struct bnx2i_conn *);
337 	mem_size = (mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
338 	hba->cid_que.conn_cid_tbl = kmalloc(mem_size, GFP_KERNEL);
339 	if (!hba->cid_que.conn_cid_tbl) {
340 		kfree(hba->cid_que.cid_que_base);
341 		hba->cid_que.cid_que_base = NULL;
342 		return -ENOMEM;
343 	}
344 
345 	hba->cid_que.cid_que = (u32 *)hba->cid_que.cid_que_base;
346 	hba->cid_que.cid_q_prod_idx = 0;
347 	hba->cid_que.cid_q_cons_idx = 0;
348 	hba->cid_que.cid_q_max_idx = hba->max_active_conns;
349 	hba->cid_que.cid_free_cnt = hba->max_active_conns;
350 
351 	for (i = 0; i < hba->max_active_conns; i++) {
352 		hba->cid_que.cid_que[i] = i;
353 		hba->cid_que.conn_cid_tbl[i] = NULL;
354 	}
355 	return 0;
356 }
357 
358 
359 /**
360  * bnx2i_release_free_cid_que - releases 'iscsi_cid' queue resources
361  * @hba:	pointer to adapter instance
362  */
363 static void bnx2i_release_free_cid_que(struct bnx2i_hba *hba)
364 {
365 	kfree(hba->cid_que.cid_que_base);
366 	hba->cid_que.cid_que_base = NULL;
367 
368 	kfree(hba->cid_que.conn_cid_tbl);
369 	hba->cid_que.conn_cid_tbl = NULL;
370 }
371 
372 
373 /**
374  * bnx2i_alloc_ep - allocates ep structure from global pool
375  * @hba:	pointer to adapter instance
376  *
377  * routine allocates a free endpoint structure from global pool and
378  *	a tcp port to be used for this connection.  Global resource lock,
379  *	'bnx2i_resc_lock' is held while accessing shared global data structures
380  */
381 static struct iscsi_endpoint *bnx2i_alloc_ep(struct bnx2i_hba *hba)
382 {
383 	struct iscsi_endpoint *ep;
384 	struct bnx2i_endpoint *bnx2i_ep;
385 	u32 ec_div;
386 
387 	ep = iscsi_create_endpoint(sizeof(*bnx2i_ep));
388 	if (!ep) {
389 		printk(KERN_ERR "bnx2i: Could not allocate ep\n");
390 		return NULL;
391 	}
392 
393 	bnx2i_ep = ep->dd_data;
394 	bnx2i_ep->cls_ep = ep;
395 	INIT_LIST_HEAD(&bnx2i_ep->link);
396 	bnx2i_ep->state = EP_STATE_IDLE;
397 	bnx2i_ep->ep_iscsi_cid = (u16) -1;
398 	bnx2i_ep->hba = hba;
399 	bnx2i_ep->hba_age = hba->age;
400 
401 	ec_div = event_coal_div;
402 	while (ec_div >>= 1)
403 		bnx2i_ep->ec_shift += 1;
404 
405 	hba->ofld_conns_active++;
406 	init_waitqueue_head(&bnx2i_ep->ofld_wait);
407 	return ep;
408 }
409 
410 
411 /**
412  * bnx2i_free_ep - free endpoint
413  * @ep:		pointer to iscsi endpoint structure
414  */
415 static void bnx2i_free_ep(struct iscsi_endpoint *ep)
416 {
417 	struct bnx2i_endpoint *bnx2i_ep = ep->dd_data;
418 	unsigned long flags;
419 
420 	spin_lock_irqsave(&bnx2i_resc_lock, flags);
421 	bnx2i_ep->state = EP_STATE_IDLE;
422 	bnx2i_ep->hba->ofld_conns_active--;
423 
424 	if (bnx2i_ep->ep_iscsi_cid != (u16) -1)
425 		bnx2i_free_iscsi_cid(bnx2i_ep->hba, bnx2i_ep->ep_iscsi_cid);
426 
427 	if (bnx2i_ep->conn) {
428 		bnx2i_ep->conn->ep = NULL;
429 		bnx2i_ep->conn = NULL;
430 	}
431 
432 	bnx2i_ep->hba = NULL;
433 	spin_unlock_irqrestore(&bnx2i_resc_lock, flags);
434 	iscsi_destroy_endpoint(ep);
435 }
436 
437 
438 /**
439  * bnx2i_alloc_bdt - allocates buffer descriptor (BD) table for the command
440  * @hba:	adapter instance pointer
441  * @session:	iscsi session pointer
442  * @cmd:	iscsi command structure
443  */
444 static int bnx2i_alloc_bdt(struct bnx2i_hba *hba, struct iscsi_session *session,
445 			   struct bnx2i_cmd *cmd)
446 {
447 	struct io_bdt *io = &cmd->io_tbl;
448 	struct iscsi_bd *bd;
449 
450 	io->bd_tbl = dma_alloc_coherent(&hba->pcidev->dev,
451 					ISCSI_MAX_BDS_PER_CMD * sizeof(*bd),
452 					&io->bd_tbl_dma, GFP_KERNEL);
453 	if (!io->bd_tbl) {
454 		iscsi_session_printk(KERN_ERR, session, "Could not "
455 				     "allocate bdt.\n");
456 		return -ENOMEM;
457 	}
458 	io->bd_valid = 0;
459 	return 0;
460 }
461 
462 /**
463  * bnx2i_destroy_cmd_pool - destroys iscsi command pool and release BD table
464  * @hba:	adapter instance pointer
465  * @session:	iscsi session pointer
466  * @cmd:	iscsi command structure
467  */
468 static void bnx2i_destroy_cmd_pool(struct bnx2i_hba *hba,
469 				   struct iscsi_session *session)
470 {
471 	int i;
472 
473 	for (i = 0; i < session->cmds_max; i++) {
474 		struct iscsi_task *task = session->cmds[i];
475 		struct bnx2i_cmd *cmd = task->dd_data;
476 
477 		if (cmd->io_tbl.bd_tbl)
478 			dma_free_coherent(&hba->pcidev->dev,
479 					  ISCSI_MAX_BDS_PER_CMD *
480 					  sizeof(struct iscsi_bd),
481 					  cmd->io_tbl.bd_tbl,
482 					  cmd->io_tbl.bd_tbl_dma);
483 	}
484 
485 }
486 
487 
488 /**
489  * bnx2i_setup_cmd_pool - sets up iscsi command pool for the session
490  * @hba:	adapter instance pointer
491  * @session:	iscsi session pointer
492  */
493 static int bnx2i_setup_cmd_pool(struct bnx2i_hba *hba,
494 				struct iscsi_session *session)
495 {
496 	int i;
497 
498 	for (i = 0; i < session->cmds_max; i++) {
499 		struct iscsi_task *task = session->cmds[i];
500 		struct bnx2i_cmd *cmd = task->dd_data;
501 
502 		task->hdr = &cmd->hdr;
503 		task->hdr_max = sizeof(struct iscsi_hdr);
504 
505 		if (bnx2i_alloc_bdt(hba, session, cmd))
506 			goto free_bdts;
507 	}
508 
509 	return 0;
510 
511 free_bdts:
512 	bnx2i_destroy_cmd_pool(hba, session);
513 	return -ENOMEM;
514 }
515 
516 
517 /**
518  * bnx2i_setup_mp_bdt - allocate BD table resources
519  * @hba:	pointer to adapter structure
520  *
521  * Allocate memory for dummy buffer and associated BD
522  * table to be used by middle path (MP) requests
523  */
524 static int bnx2i_setup_mp_bdt(struct bnx2i_hba *hba)
525 {
526 	int rc = 0;
527 	struct iscsi_bd *mp_bdt;
528 	u64 addr;
529 
530 	hba->mp_bd_tbl = dma_alloc_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
531 					    &hba->mp_bd_dma, GFP_KERNEL);
532 	if (!hba->mp_bd_tbl) {
533 		printk(KERN_ERR "unable to allocate Middle Path BDT\n");
534 		rc = -1;
535 		goto out;
536 	}
537 
538 	hba->dummy_buffer = dma_alloc_coherent(&hba->pcidev->dev,
539 					       CNIC_PAGE_SIZE,
540 					       &hba->dummy_buf_dma, GFP_KERNEL);
541 	if (!hba->dummy_buffer) {
542 		printk(KERN_ERR "unable to alloc Middle Path Dummy Buffer\n");
543 		dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
544 				  hba->mp_bd_tbl, hba->mp_bd_dma);
545 		hba->mp_bd_tbl = NULL;
546 		rc = -1;
547 		goto out;
548 	}
549 
550 	mp_bdt = (struct iscsi_bd *) hba->mp_bd_tbl;
551 	addr = (unsigned long) hba->dummy_buf_dma;
552 	mp_bdt->buffer_addr_lo = addr & 0xffffffff;
553 	mp_bdt->buffer_addr_hi = addr >> 32;
554 	mp_bdt->buffer_length = CNIC_PAGE_SIZE;
555 	mp_bdt->flags = ISCSI_BD_LAST_IN_BD_CHAIN |
556 			ISCSI_BD_FIRST_IN_BD_CHAIN;
557 out:
558 	return rc;
559 }
560 
561 
562 /**
563  * bnx2i_free_mp_bdt - releases ITT back to free pool
564  * @hba:	pointer to adapter instance
565  *
566  * free MP dummy buffer and associated BD table
567  */
568 static void bnx2i_free_mp_bdt(struct bnx2i_hba *hba)
569 {
570 	if (hba->mp_bd_tbl) {
571 		dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
572 				  hba->mp_bd_tbl, hba->mp_bd_dma);
573 		hba->mp_bd_tbl = NULL;
574 	}
575 	if (hba->dummy_buffer) {
576 		dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
577 				  hba->dummy_buffer, hba->dummy_buf_dma);
578 		hba->dummy_buffer = NULL;
579 	}
580 		return;
581 }
582 
583 /**
584  * bnx2i_drop_session - notifies iscsid of connection error.
585  * @hba:	adapter instance pointer
586  * @session:	iscsi session pointer
587  *
588  * This notifies iscsid that there is a error, so it can initiate
589  * recovery.
590  *
591  * This relies on caller using the iscsi class iterator so the object
592  * is refcounted and does not disapper from under us.
593  */
594 void bnx2i_drop_session(struct iscsi_cls_session *cls_session)
595 {
596 	iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
597 }
598 
599 /**
600  * bnx2i_ep_destroy_list_add - add an entry to EP destroy list
601  * @hba:	pointer to adapter instance
602  * @ep:		pointer to endpoint (transport identifier) structure
603  *
604  * EP destroy queue manager
605  */
606 static int bnx2i_ep_destroy_list_add(struct bnx2i_hba *hba,
607 				     struct bnx2i_endpoint *ep)
608 {
609 	write_lock_bh(&hba->ep_rdwr_lock);
610 	list_add_tail(&ep->link, &hba->ep_destroy_list);
611 	write_unlock_bh(&hba->ep_rdwr_lock);
612 	return 0;
613 }
614 
615 /**
616  * bnx2i_ep_destroy_list_del - add an entry to EP destroy list
617  *
618  * @hba: 		pointer to adapter instance
619  * @ep: 		pointer to endpoint (transport identifier) structure
620  *
621  * EP destroy queue manager
622  */
623 static int bnx2i_ep_destroy_list_del(struct bnx2i_hba *hba,
624 				     struct bnx2i_endpoint *ep)
625 {
626 	write_lock_bh(&hba->ep_rdwr_lock);
627 	list_del_init(&ep->link);
628 	write_unlock_bh(&hba->ep_rdwr_lock);
629 
630 	return 0;
631 }
632 
633 /**
634  * bnx2i_ep_ofld_list_add - add an entry to ep offload pending list
635  * @hba:	pointer to adapter instance
636  * @ep:		pointer to endpoint (transport identifier) structure
637  *
638  * pending conn offload completion queue manager
639  */
640 static int bnx2i_ep_ofld_list_add(struct bnx2i_hba *hba,
641 				  struct bnx2i_endpoint *ep)
642 {
643 	write_lock_bh(&hba->ep_rdwr_lock);
644 	list_add_tail(&ep->link, &hba->ep_ofld_list);
645 	write_unlock_bh(&hba->ep_rdwr_lock);
646 	return 0;
647 }
648 
649 /**
650  * bnx2i_ep_ofld_list_del - add an entry to ep offload pending list
651  * @hba: 		pointer to adapter instance
652  * @ep: 		pointer to endpoint (transport identifier) structure
653  *
654  * pending conn offload completion queue manager
655  */
656 static int bnx2i_ep_ofld_list_del(struct bnx2i_hba *hba,
657 				  struct bnx2i_endpoint *ep)
658 {
659 	write_lock_bh(&hba->ep_rdwr_lock);
660 	list_del_init(&ep->link);
661 	write_unlock_bh(&hba->ep_rdwr_lock);
662 	return 0;
663 }
664 
665 
666 /**
667  * bnx2i_find_ep_in_ofld_list - find iscsi_cid in pending list of endpoints
668  *
669  * @hba: 		pointer to adapter instance
670  * @iscsi_cid:		iscsi context ID to find
671  *
672  */
673 struct bnx2i_endpoint *
674 bnx2i_find_ep_in_ofld_list(struct bnx2i_hba *hba, u32 iscsi_cid)
675 {
676 	struct list_head *list;
677 	struct list_head *tmp;
678 	struct bnx2i_endpoint *ep;
679 
680 	read_lock_bh(&hba->ep_rdwr_lock);
681 	list_for_each_safe(list, tmp, &hba->ep_ofld_list) {
682 		ep = (struct bnx2i_endpoint *)list;
683 
684 		if (ep->ep_iscsi_cid == iscsi_cid)
685 			break;
686 		ep = NULL;
687 	}
688 	read_unlock_bh(&hba->ep_rdwr_lock);
689 
690 	if (!ep)
691 		printk(KERN_ERR "l5 cid %d not found\n", iscsi_cid);
692 	return ep;
693 }
694 
695 /**
696  * bnx2i_find_ep_in_destroy_list - find iscsi_cid in destroy list
697  * @hba: 		pointer to adapter instance
698  * @iscsi_cid:		iscsi context ID to find
699  *
700  */
701 struct bnx2i_endpoint *
702 bnx2i_find_ep_in_destroy_list(struct bnx2i_hba *hba, u32 iscsi_cid)
703 {
704 	struct list_head *list;
705 	struct list_head *tmp;
706 	struct bnx2i_endpoint *ep;
707 
708 	read_lock_bh(&hba->ep_rdwr_lock);
709 	list_for_each_safe(list, tmp, &hba->ep_destroy_list) {
710 		ep = (struct bnx2i_endpoint *)list;
711 
712 		if (ep->ep_iscsi_cid == iscsi_cid)
713 			break;
714 		ep = NULL;
715 	}
716 	read_unlock_bh(&hba->ep_rdwr_lock);
717 
718 	if (!ep)
719 		printk(KERN_ERR "l5 cid %d not found\n", iscsi_cid);
720 
721 	return ep;
722 }
723 
724 /**
725  * bnx2i_ep_active_list_add - add an entry to ep active list
726  * @hba:	pointer to adapter instance
727  * @ep:		pointer to endpoint (transport identifier) structure
728  *
729  * current active conn queue manager
730  */
731 static void bnx2i_ep_active_list_add(struct bnx2i_hba *hba,
732 				     struct bnx2i_endpoint *ep)
733 {
734 	write_lock_bh(&hba->ep_rdwr_lock);
735 	list_add_tail(&ep->link, &hba->ep_active_list);
736 	write_unlock_bh(&hba->ep_rdwr_lock);
737 }
738 
739 
740 /**
741  * bnx2i_ep_active_list_del - deletes an entry to ep active list
742  * @hba:	pointer to adapter instance
743  * @ep:		pointer to endpoint (transport identifier) structure
744  *
745  * current active conn queue manager
746  */
747 static void bnx2i_ep_active_list_del(struct bnx2i_hba *hba,
748 				     struct bnx2i_endpoint *ep)
749 {
750 	write_lock_bh(&hba->ep_rdwr_lock);
751 	list_del_init(&ep->link);
752 	write_unlock_bh(&hba->ep_rdwr_lock);
753 }
754 
755 
756 /**
757  * bnx2i_setup_host_queue_size - assigns shost->can_queue param
758  * @hba:	pointer to adapter instance
759  * @shost:	scsi host pointer
760  *
761  * Initializes 'can_queue' parameter based on how many outstanding commands
762  * 	the device can handle. Each device 5708/5709/57710 has different
763  *	capabilities
764  */
765 static void bnx2i_setup_host_queue_size(struct bnx2i_hba *hba,
766 					struct Scsi_Host *shost)
767 {
768 	if (test_bit(BNX2I_NX2_DEV_5708, &hba->cnic_dev_type))
769 		shost->can_queue = ISCSI_MAX_CMDS_PER_HBA_5708;
770 	else if (test_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type))
771 		shost->can_queue = ISCSI_MAX_CMDS_PER_HBA_5709;
772 	else if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type))
773 		shost->can_queue = ISCSI_MAX_CMDS_PER_HBA_57710;
774 	else
775 		shost->can_queue = ISCSI_MAX_CMDS_PER_HBA_5708;
776 }
777 
778 
779 /**
780  * bnx2i_alloc_hba - allocate and init adapter instance
781  * @cnic:	cnic device pointer
782  *
783  * allocate & initialize adapter structure and call other
784  *	support routines to do per adapter initialization
785  */
786 struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
787 {
788 	struct Scsi_Host *shost;
789 	struct bnx2i_hba *hba;
790 
791 	shost = iscsi_host_alloc(&bnx2i_host_template, sizeof(*hba), 0);
792 	if (!shost)
793 		return NULL;
794 	shost->dma_boundary = cnic->pcidev->dma_mask;
795 	shost->transportt = bnx2i_scsi_xport_template;
796 	shost->max_id = ISCSI_MAX_CONNS_PER_HBA;
797 	shost->max_channel = 0;
798 	shost->max_lun = 512;
799 	shost->max_cmd_len = 16;
800 
801 	hba = iscsi_host_priv(shost);
802 	hba->shost = shost;
803 	hba->netdev = cnic->netdev;
804 	/* Get PCI related information and update hba struct members */
805 	hba->pcidev = cnic->pcidev;
806 	pci_dev_get(hba->pcidev);
807 	hba->pci_did = hba->pcidev->device;
808 	hba->pci_vid = hba->pcidev->vendor;
809 	hba->pci_sdid = hba->pcidev->subsystem_device;
810 	hba->pci_svid = hba->pcidev->subsystem_vendor;
811 	hba->pci_func = PCI_FUNC(hba->pcidev->devfn);
812 	hba->pci_devno = PCI_SLOT(hba->pcidev->devfn);
813 
814 	bnx2i_identify_device(hba, cnic);
815 	bnx2i_setup_host_queue_size(hba, shost);
816 
817 	hba->reg_base = pci_resource_start(hba->pcidev, 0);
818 	if (test_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type)) {
819 		hba->regview = pci_iomap(hba->pcidev, 0, BNX2_MQ_CONFIG2);
820 		if (!hba->regview)
821 			goto ioreg_map_err;
822 	} else if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
823 		hba->regview = pci_iomap(hba->pcidev, 0, 4096);
824 		if (!hba->regview)
825 			goto ioreg_map_err;
826 	}
827 
828 	if (bnx2i_setup_mp_bdt(hba))
829 		goto mp_bdt_mem_err;
830 
831 	INIT_LIST_HEAD(&hba->ep_ofld_list);
832 	INIT_LIST_HEAD(&hba->ep_active_list);
833 	INIT_LIST_HEAD(&hba->ep_destroy_list);
834 	rwlock_init(&hba->ep_rdwr_lock);
835 
836 	hba->mtu_supported = BNX2I_MAX_MTU_SUPPORTED;
837 
838 	/* different values for 5708/5709/57710 */
839 	hba->max_active_conns = ISCSI_MAX_CONNS_PER_HBA;
840 
841 	if (bnx2i_setup_free_cid_que(hba))
842 		goto cid_que_err;
843 
844 	/* SQ/RQ/CQ size can be changed via sysfx interface */
845 	if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
846 		if (sq_size && sq_size <= BNX2I_5770X_SQ_WQES_MAX)
847 			hba->max_sqes = sq_size;
848 		else
849 			hba->max_sqes = BNX2I_5770X_SQ_WQES_DEFAULT;
850 	} else {	/* 5706/5708/5709 */
851 		if (sq_size && sq_size <= BNX2I_570X_SQ_WQES_MAX)
852 			hba->max_sqes = sq_size;
853 		else
854 			hba->max_sqes = BNX2I_570X_SQ_WQES_DEFAULT;
855 	}
856 
857 	hba->max_rqes = rq_size;
858 	hba->max_cqes = hba->max_sqes + rq_size;
859 	if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
860 		if (hba->max_cqes > BNX2I_5770X_CQ_WQES_MAX)
861 			hba->max_cqes = BNX2I_5770X_CQ_WQES_MAX;
862 	} else if (hba->max_cqes > BNX2I_570X_CQ_WQES_MAX)
863 		hba->max_cqes = BNX2I_570X_CQ_WQES_MAX;
864 
865 	hba->num_ccell = hba->max_sqes / 2;
866 
867 	spin_lock_init(&hba->lock);
868 	mutex_init(&hba->net_dev_lock);
869 	init_waitqueue_head(&hba->eh_wait);
870 	if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
871 		hba->hba_shutdown_tmo = 30 * HZ;
872 		hba->conn_teardown_tmo = 20 * HZ;
873 		hba->conn_ctx_destroy_tmo = 6 * HZ;
874 	} else {	/* 5706/5708/5709 */
875 		hba->hba_shutdown_tmo = 20 * HZ;
876 		hba->conn_teardown_tmo = 10 * HZ;
877 		hba->conn_ctx_destroy_tmo = 2 * HZ;
878 	}
879 
880 #ifdef CONFIG_32BIT
881 	spin_lock_init(&hba->stat_lock);
882 #endif
883 	memset(&hba->stats, 0, sizeof(struct iscsi_stats_info));
884 
885 	if (iscsi_host_add(shost, &hba->pcidev->dev))
886 		goto free_dump_mem;
887 	return hba;
888 
889 free_dump_mem:
890 	bnx2i_release_free_cid_que(hba);
891 cid_que_err:
892 	bnx2i_free_mp_bdt(hba);
893 mp_bdt_mem_err:
894 	if (hba->regview) {
895 		pci_iounmap(hba->pcidev, hba->regview);
896 		hba->regview = NULL;
897 	}
898 ioreg_map_err:
899 	pci_dev_put(hba->pcidev);
900 	scsi_host_put(shost);
901 	return NULL;
902 }
903 
904 /**
905  * bnx2i_free_hba- releases hba structure and resources held by the adapter
906  * @hba:	pointer to adapter instance
907  *
908  * free adapter structure and call various cleanup routines.
909  */
910 void bnx2i_free_hba(struct bnx2i_hba *hba)
911 {
912 	struct Scsi_Host *shost = hba->shost;
913 
914 	iscsi_host_remove(shost);
915 	INIT_LIST_HEAD(&hba->ep_ofld_list);
916 	INIT_LIST_HEAD(&hba->ep_active_list);
917 	INIT_LIST_HEAD(&hba->ep_destroy_list);
918 	pci_dev_put(hba->pcidev);
919 
920 	if (hba->regview) {
921 		pci_iounmap(hba->pcidev, hba->regview);
922 		hba->regview = NULL;
923 	}
924 	bnx2i_free_mp_bdt(hba);
925 	bnx2i_release_free_cid_que(hba);
926 	iscsi_host_free(shost);
927 }
928 
929 /**
930  * bnx2i_conn_free_login_resources - free DMA resources used for login process
931  * @hba:		pointer to adapter instance
932  * @bnx2i_conn:		iscsi connection pointer
933  *
934  * Login related resources, mostly BDT & payload DMA memory is freed
935  */
936 static void bnx2i_conn_free_login_resources(struct bnx2i_hba *hba,
937 					    struct bnx2i_conn *bnx2i_conn)
938 {
939 	if (bnx2i_conn->gen_pdu.resp_bd_tbl) {
940 		dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
941 				  bnx2i_conn->gen_pdu.resp_bd_tbl,
942 				  bnx2i_conn->gen_pdu.resp_bd_dma);
943 		bnx2i_conn->gen_pdu.resp_bd_tbl = NULL;
944 	}
945 
946 	if (bnx2i_conn->gen_pdu.req_bd_tbl) {
947 		dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
948 				  bnx2i_conn->gen_pdu.req_bd_tbl,
949 				  bnx2i_conn->gen_pdu.req_bd_dma);
950 		bnx2i_conn->gen_pdu.req_bd_tbl = NULL;
951 	}
952 
953 	if (bnx2i_conn->gen_pdu.resp_buf) {
954 		dma_free_coherent(&hba->pcidev->dev,
955 				  ISCSI_DEF_MAX_RECV_SEG_LEN,
956 				  bnx2i_conn->gen_pdu.resp_buf,
957 				  bnx2i_conn->gen_pdu.resp_dma_addr);
958 		bnx2i_conn->gen_pdu.resp_buf = NULL;
959 	}
960 
961 	if (bnx2i_conn->gen_pdu.req_buf) {
962 		dma_free_coherent(&hba->pcidev->dev,
963 				  ISCSI_DEF_MAX_RECV_SEG_LEN,
964 				  bnx2i_conn->gen_pdu.req_buf,
965 				  bnx2i_conn->gen_pdu.req_dma_addr);
966 		bnx2i_conn->gen_pdu.req_buf = NULL;
967 	}
968 }
969 
970 /**
971  * bnx2i_conn_alloc_login_resources - alloc DMA resources for login/nop.
972  * @hba:		pointer to adapter instance
973  * @bnx2i_conn:		iscsi connection pointer
974  *
975  * Mgmt task DNA resources are allocated in this routine.
976  */
977 static int bnx2i_conn_alloc_login_resources(struct bnx2i_hba *hba,
978 					    struct bnx2i_conn *bnx2i_conn)
979 {
980 	/* Allocate memory for login request/response buffers */
981 	bnx2i_conn->gen_pdu.req_buf =
982 		dma_alloc_coherent(&hba->pcidev->dev,
983 				   ISCSI_DEF_MAX_RECV_SEG_LEN,
984 				   &bnx2i_conn->gen_pdu.req_dma_addr,
985 				   GFP_KERNEL);
986 	if (bnx2i_conn->gen_pdu.req_buf == NULL)
987 		goto login_req_buf_failure;
988 
989 	bnx2i_conn->gen_pdu.req_buf_size = 0;
990 	bnx2i_conn->gen_pdu.req_wr_ptr = bnx2i_conn->gen_pdu.req_buf;
991 
992 	bnx2i_conn->gen_pdu.resp_buf =
993 		dma_alloc_coherent(&hba->pcidev->dev,
994 				   ISCSI_DEF_MAX_RECV_SEG_LEN,
995 				   &bnx2i_conn->gen_pdu.resp_dma_addr,
996 				   GFP_KERNEL);
997 	if (bnx2i_conn->gen_pdu.resp_buf == NULL)
998 		goto login_resp_buf_failure;
999 
1000 	bnx2i_conn->gen_pdu.resp_buf_size = ISCSI_DEF_MAX_RECV_SEG_LEN;
1001 	bnx2i_conn->gen_pdu.resp_wr_ptr = bnx2i_conn->gen_pdu.resp_buf;
1002 
1003 	bnx2i_conn->gen_pdu.req_bd_tbl =
1004 		dma_alloc_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
1005 				   &bnx2i_conn->gen_pdu.req_bd_dma, GFP_KERNEL);
1006 	if (bnx2i_conn->gen_pdu.req_bd_tbl == NULL)
1007 		goto login_req_bd_tbl_failure;
1008 
1009 	bnx2i_conn->gen_pdu.resp_bd_tbl =
1010 		dma_alloc_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
1011 				   &bnx2i_conn->gen_pdu.resp_bd_dma,
1012 				   GFP_KERNEL);
1013 	if (bnx2i_conn->gen_pdu.resp_bd_tbl == NULL)
1014 		goto login_resp_bd_tbl_failure;
1015 
1016 	return 0;
1017 
1018 login_resp_bd_tbl_failure:
1019 	dma_free_coherent(&hba->pcidev->dev, CNIC_PAGE_SIZE,
1020 			  bnx2i_conn->gen_pdu.req_bd_tbl,
1021 			  bnx2i_conn->gen_pdu.req_bd_dma);
1022 	bnx2i_conn->gen_pdu.req_bd_tbl = NULL;
1023 
1024 login_req_bd_tbl_failure:
1025 	dma_free_coherent(&hba->pcidev->dev, ISCSI_DEF_MAX_RECV_SEG_LEN,
1026 			  bnx2i_conn->gen_pdu.resp_buf,
1027 			  bnx2i_conn->gen_pdu.resp_dma_addr);
1028 	bnx2i_conn->gen_pdu.resp_buf = NULL;
1029 login_resp_buf_failure:
1030 	dma_free_coherent(&hba->pcidev->dev, ISCSI_DEF_MAX_RECV_SEG_LEN,
1031 			  bnx2i_conn->gen_pdu.req_buf,
1032 			  bnx2i_conn->gen_pdu.req_dma_addr);
1033 	bnx2i_conn->gen_pdu.req_buf = NULL;
1034 login_req_buf_failure:
1035 	iscsi_conn_printk(KERN_ERR, bnx2i_conn->cls_conn->dd_data,
1036 			  "login resource alloc failed!!\n");
1037 	return -ENOMEM;
1038 
1039 }
1040 
1041 
1042 /**
1043  * bnx2i_iscsi_prep_generic_pdu_bd - prepares BD table.
1044  * @bnx2i_conn:		iscsi connection pointer
1045  *
1046  * Allocates buffers and BD tables before shipping requests to cnic
1047  *	for PDUs prepared by 'iscsid' daemon
1048  */
1049 static void bnx2i_iscsi_prep_generic_pdu_bd(struct bnx2i_conn *bnx2i_conn)
1050 {
1051 	struct iscsi_bd *bd_tbl;
1052 
1053 	bd_tbl = (struct iscsi_bd *) bnx2i_conn->gen_pdu.req_bd_tbl;
1054 
1055 	bd_tbl->buffer_addr_hi =
1056 		(u32) ((u64) bnx2i_conn->gen_pdu.req_dma_addr >> 32);
1057 	bd_tbl->buffer_addr_lo = (u32) bnx2i_conn->gen_pdu.req_dma_addr;
1058 	bd_tbl->buffer_length = bnx2i_conn->gen_pdu.req_wr_ptr -
1059 				bnx2i_conn->gen_pdu.req_buf;
1060 	bd_tbl->reserved0 = 0;
1061 	bd_tbl->flags = ISCSI_BD_LAST_IN_BD_CHAIN |
1062 			ISCSI_BD_FIRST_IN_BD_CHAIN;
1063 
1064 	bd_tbl = (struct iscsi_bd  *) bnx2i_conn->gen_pdu.resp_bd_tbl;
1065 	bd_tbl->buffer_addr_hi = (u64) bnx2i_conn->gen_pdu.resp_dma_addr >> 32;
1066 	bd_tbl->buffer_addr_lo = (u32) bnx2i_conn->gen_pdu.resp_dma_addr;
1067 	bd_tbl->buffer_length = ISCSI_DEF_MAX_RECV_SEG_LEN;
1068 	bd_tbl->reserved0 = 0;
1069 	bd_tbl->flags = ISCSI_BD_LAST_IN_BD_CHAIN |
1070 			ISCSI_BD_FIRST_IN_BD_CHAIN;
1071 }
1072 
1073 
1074 /**
1075  * bnx2i_iscsi_send_generic_request - called to send mgmt tasks.
1076  * @task:	transport layer task pointer
1077  *
1078  * called to transmit PDUs prepared by the 'iscsid' daemon. iSCSI login,
1079  *	Nop-out and Logout requests flow through this path.
1080  */
1081 static int bnx2i_iscsi_send_generic_request(struct iscsi_task *task)
1082 {
1083 	struct bnx2i_cmd *cmd = task->dd_data;
1084 	struct bnx2i_conn *bnx2i_conn = cmd->conn;
1085 	int rc = 0;
1086 	char *buf;
1087 	int data_len;
1088 
1089 	bnx2i_iscsi_prep_generic_pdu_bd(bnx2i_conn);
1090 	switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {
1091 	case ISCSI_OP_LOGIN:
1092 		bnx2i_send_iscsi_login(bnx2i_conn, task);
1093 		break;
1094 	case ISCSI_OP_NOOP_OUT:
1095 		data_len = bnx2i_conn->gen_pdu.req_buf_size;
1096 		buf = bnx2i_conn->gen_pdu.req_buf;
1097 		if (data_len)
1098 			rc = bnx2i_send_iscsi_nopout(bnx2i_conn, task,
1099 						     buf, data_len, 1);
1100 		else
1101 			rc = bnx2i_send_iscsi_nopout(bnx2i_conn, task,
1102 						     NULL, 0, 1);
1103 		break;
1104 	case ISCSI_OP_LOGOUT:
1105 		rc = bnx2i_send_iscsi_logout(bnx2i_conn, task);
1106 		break;
1107 	case ISCSI_OP_SCSI_TMFUNC:
1108 		rc = bnx2i_send_iscsi_tmf(bnx2i_conn, task);
1109 		break;
1110 	case ISCSI_OP_TEXT:
1111 		rc = bnx2i_send_iscsi_text(bnx2i_conn, task);
1112 		break;
1113 	default:
1114 		iscsi_conn_printk(KERN_ALERT, bnx2i_conn->cls_conn->dd_data,
1115 				  "send_gen: unsupported op 0x%x\n",
1116 				  task->hdr->opcode);
1117 	}
1118 	return rc;
1119 }
1120 
1121 
1122 /**********************************************************************
1123  *		SCSI-ML Interface
1124  **********************************************************************/
1125 
1126 /**
1127  * bnx2i_cpy_scsi_cdb - copies LUN & CDB fields in required format to sq wqe
1128  * @sc:		SCSI-ML command pointer
1129  * @cmd:	iscsi cmd pointer
1130  */
1131 static void bnx2i_cpy_scsi_cdb(struct scsi_cmnd *sc, struct bnx2i_cmd *cmd)
1132 {
1133 	u32 dword;
1134 	int lpcnt;
1135 	u8 *srcp;
1136 	u32 *dstp;
1137 	u32 scsi_lun[2];
1138 
1139 	int_to_scsilun(sc->device->lun, (struct scsi_lun *) scsi_lun);
1140 	cmd->req.lun[0] = be32_to_cpu(scsi_lun[0]);
1141 	cmd->req.lun[1] = be32_to_cpu(scsi_lun[1]);
1142 
1143 	lpcnt = cmd->scsi_cmd->cmd_len / sizeof(dword);
1144 	srcp = (u8 *) sc->cmnd;
1145 	dstp = (u32 *) cmd->req.cdb;
1146 	while (lpcnt--) {
1147 		memcpy(&dword, (const void *) srcp, 4);
1148 		*dstp = cpu_to_be32(dword);
1149 		srcp += 4;
1150 		dstp++;
1151 	}
1152 	if (sc->cmd_len & 0x3) {
1153 		dword = (u32) srcp[0] | ((u32) srcp[1] << 8);
1154 		*dstp = cpu_to_be32(dword);
1155 	}
1156 }
1157 
1158 static void bnx2i_cleanup_task(struct iscsi_task *task)
1159 {
1160 	struct iscsi_conn *conn = task->conn;
1161 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1162 	struct bnx2i_hba *hba = bnx2i_conn->hba;
1163 
1164 	/*
1165 	 * mgmt task or cmd was never sent to us to transmit.
1166 	 */
1167 	if (!task->sc || task->state == ISCSI_TASK_PENDING)
1168 		return;
1169 	/*
1170 	 * need to clean-up task context to claim dma buffers
1171 	 */
1172 	if (task->state == ISCSI_TASK_ABRT_TMF) {
1173 		bnx2i_send_cmd_cleanup_req(hba, task->dd_data);
1174 
1175 		spin_unlock_bh(&conn->session->back_lock);
1176 		wait_for_completion_timeout(&bnx2i_conn->cmd_cleanup_cmpl,
1177 				msecs_to_jiffies(ISCSI_CMD_CLEANUP_TIMEOUT));
1178 		spin_lock_bh(&conn->session->back_lock);
1179 	}
1180 	bnx2i_iscsi_unmap_sg_list(task->dd_data);
1181 }
1182 
1183 /**
1184  * bnx2i_mtask_xmit - transmit mtask to chip for further processing
1185  * @conn:	transport layer conn structure pointer
1186  * @task:	transport layer command structure pointer
1187  */
1188 static int
1189 bnx2i_mtask_xmit(struct iscsi_conn *conn, struct iscsi_task *task)
1190 {
1191 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1192 	struct bnx2i_hba *hba = bnx2i_conn->hba;
1193 	struct bnx2i_cmd *cmd = task->dd_data;
1194 
1195 	memset(bnx2i_conn->gen_pdu.req_buf, 0, ISCSI_DEF_MAX_RECV_SEG_LEN);
1196 
1197 	bnx2i_setup_cmd_wqe_template(cmd);
1198 	bnx2i_conn->gen_pdu.req_buf_size = task->data_count;
1199 
1200 	/* Tx PDU/data length count */
1201 	ADD_STATS_64(hba, tx_pdus, 1);
1202 	ADD_STATS_64(hba, tx_bytes, task->data_count);
1203 
1204 	if (task->data_count) {
1205 		memcpy(bnx2i_conn->gen_pdu.req_buf, task->data,
1206 		       task->data_count);
1207 		bnx2i_conn->gen_pdu.req_wr_ptr =
1208 			bnx2i_conn->gen_pdu.req_buf + task->data_count;
1209 	}
1210 	cmd->conn = conn->dd_data;
1211 	cmd->scsi_cmd = NULL;
1212 	return bnx2i_iscsi_send_generic_request(task);
1213 }
1214 
1215 /**
1216  * bnx2i_task_xmit - transmit iscsi command to chip for further processing
1217  * @task:	transport layer command structure pointer
1218  *
1219  * maps SG buffers and send request to chip/firmware in the form of SQ WQE
1220  */
1221 static int bnx2i_task_xmit(struct iscsi_task *task)
1222 {
1223 	struct iscsi_conn *conn = task->conn;
1224 	struct iscsi_session *session = conn->session;
1225 	struct Scsi_Host *shost = iscsi_session_to_shost(session->cls_session);
1226 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
1227 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1228 	struct scsi_cmnd *sc = task->sc;
1229 	struct bnx2i_cmd *cmd = task->dd_data;
1230 	struct iscsi_scsi_req *hdr = (struct iscsi_scsi_req *)task->hdr;
1231 
1232 	if (atomic_read(&bnx2i_conn->ep->num_active_cmds) + 1  >
1233 	    hba->max_sqes)
1234 		return -ENOMEM;
1235 
1236 	/*
1237 	 * If there is no scsi_cmnd this must be a mgmt task
1238 	 */
1239 	if (!sc)
1240 		return bnx2i_mtask_xmit(conn, task);
1241 
1242 	bnx2i_setup_cmd_wqe_template(cmd);
1243 	cmd->req.op_code = ISCSI_OP_SCSI_CMD;
1244 	cmd->conn = bnx2i_conn;
1245 	cmd->scsi_cmd = sc;
1246 	cmd->req.total_data_transfer_length = scsi_bufflen(sc);
1247 	cmd->req.cmd_sn = be32_to_cpu(hdr->cmdsn);
1248 
1249 	bnx2i_iscsi_map_sg_list(cmd);
1250 	bnx2i_cpy_scsi_cdb(sc, cmd);
1251 
1252 	cmd->req.op_attr = ISCSI_ATTR_SIMPLE;
1253 	if (sc->sc_data_direction == DMA_TO_DEVICE) {
1254 		cmd->req.op_attr |= ISCSI_CMD_REQUEST_WRITE;
1255 		cmd->req.itt = task->itt |
1256 			(ISCSI_TASK_TYPE_WRITE << ISCSI_CMD_REQUEST_TYPE_SHIFT);
1257 		bnx2i_setup_write_cmd_bd_info(task);
1258 	} else {
1259 		if (scsi_bufflen(sc))
1260 			cmd->req.op_attr |= ISCSI_CMD_REQUEST_READ;
1261 		cmd->req.itt = task->itt |
1262 			(ISCSI_TASK_TYPE_READ << ISCSI_CMD_REQUEST_TYPE_SHIFT);
1263 	}
1264 
1265 	cmd->req.num_bds = cmd->io_tbl.bd_valid;
1266 	if (!cmd->io_tbl.bd_valid) {
1267 		cmd->req.bd_list_addr_lo = (u32) hba->mp_bd_dma;
1268 		cmd->req.bd_list_addr_hi = (u32) ((u64) hba->mp_bd_dma >> 32);
1269 		cmd->req.num_bds = 1;
1270 	}
1271 
1272 	bnx2i_send_iscsi_scsicmd(bnx2i_conn, cmd);
1273 	return 0;
1274 }
1275 
1276 /**
1277  * bnx2i_session_create - create a new iscsi session
1278  * @cmds_max:		max commands supported
1279  * @qdepth:		scsi queue depth to support
1280  * @initial_cmdsn:	initial iscsi CMDSN to be used for this session
1281  *
1282  * Creates a new iSCSI session instance on given device.
1283  */
1284 static struct iscsi_cls_session *
1285 bnx2i_session_create(struct iscsi_endpoint *ep,
1286 		     uint16_t cmds_max, uint16_t qdepth,
1287 		     uint32_t initial_cmdsn)
1288 {
1289 	struct Scsi_Host *shost;
1290 	struct iscsi_cls_session *cls_session;
1291 	struct bnx2i_hba *hba;
1292 	struct bnx2i_endpoint *bnx2i_ep;
1293 
1294 	if (!ep) {
1295 		printk(KERN_ERR "bnx2i: missing ep.\n");
1296 		return NULL;
1297 	}
1298 
1299 	bnx2i_ep = ep->dd_data;
1300 	shost = bnx2i_ep->hba->shost;
1301 	hba = iscsi_host_priv(shost);
1302 	if (bnx2i_adapter_ready(hba))
1303 		return NULL;
1304 
1305 	/*
1306 	 * user can override hw limit as long as it is within
1307 	 * the min/max.
1308 	 */
1309 	if (cmds_max > hba->max_sqes)
1310 		cmds_max = hba->max_sqes;
1311 	else if (cmds_max < BNX2I_SQ_WQES_MIN)
1312 		cmds_max = BNX2I_SQ_WQES_MIN;
1313 
1314 	cls_session = iscsi_session_setup(&bnx2i_iscsi_transport, shost,
1315 					  cmds_max, 0, sizeof(struct bnx2i_cmd),
1316 					  initial_cmdsn, ISCSI_MAX_TARGET);
1317 	if (!cls_session)
1318 		return NULL;
1319 
1320 	if (bnx2i_setup_cmd_pool(hba, cls_session->dd_data))
1321 		goto session_teardown;
1322 	return cls_session;
1323 
1324 session_teardown:
1325 	iscsi_session_teardown(cls_session);
1326 	return NULL;
1327 }
1328 
1329 
1330 /**
1331  * bnx2i_session_destroy - destroys iscsi session
1332  * @cls_session:	pointer to iscsi cls session
1333  *
1334  * Destroys previously created iSCSI session instance and releases
1335  *	all resources held by it
1336  */
1337 static void bnx2i_session_destroy(struct iscsi_cls_session *cls_session)
1338 {
1339 	struct iscsi_session *session = cls_session->dd_data;
1340 	struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
1341 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
1342 
1343 	bnx2i_destroy_cmd_pool(hba, session);
1344 	iscsi_session_teardown(cls_session);
1345 }
1346 
1347 
1348 /**
1349  * bnx2i_conn_create - create iscsi connection instance
1350  * @cls_session:	pointer to iscsi cls session
1351  * @cid:		iscsi cid as per rfc (not NX2's CID terminology)
1352  *
1353  * Creates a new iSCSI connection instance for a given session
1354  */
1355 static struct iscsi_cls_conn *
1356 bnx2i_conn_create(struct iscsi_cls_session *cls_session, uint32_t cid)
1357 {
1358 	struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
1359 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
1360 	struct bnx2i_conn *bnx2i_conn;
1361 	struct iscsi_cls_conn *cls_conn;
1362 	struct iscsi_conn *conn;
1363 
1364 	cls_conn = iscsi_conn_setup(cls_session, sizeof(*bnx2i_conn),
1365 				    cid);
1366 	if (!cls_conn)
1367 		return NULL;
1368 	conn = cls_conn->dd_data;
1369 
1370 	bnx2i_conn = conn->dd_data;
1371 	bnx2i_conn->cls_conn = cls_conn;
1372 	bnx2i_conn->hba = hba;
1373 
1374 	atomic_set(&bnx2i_conn->work_cnt, 0);
1375 
1376 	/* 'ep' ptr will be assigned in bind() call */
1377 	bnx2i_conn->ep = NULL;
1378 	init_completion(&bnx2i_conn->cmd_cleanup_cmpl);
1379 
1380 	if (bnx2i_conn_alloc_login_resources(hba, bnx2i_conn)) {
1381 		iscsi_conn_printk(KERN_ALERT, conn,
1382 				  "conn_new: login resc alloc failed!!\n");
1383 		goto free_conn;
1384 	}
1385 
1386 	return cls_conn;
1387 
1388 free_conn:
1389 	iscsi_conn_teardown(cls_conn);
1390 	return NULL;
1391 }
1392 
1393 /**
1394  * bnx2i_conn_bind - binds iscsi sess, conn and ep objects together
1395  * @cls_session:	pointer to iscsi cls session
1396  * @cls_conn:		pointer to iscsi cls conn
1397  * @transport_fd:	64-bit EP handle
1398  * @is_leading:		leading connection on this session?
1399  *
1400  * Binds together iSCSI session instance, iSCSI connection instance
1401  *	and the TCP connection. This routine returns error code if
1402  *	TCP connection does not belong on the device iSCSI sess/conn
1403  *	is bound
1404  */
1405 static int bnx2i_conn_bind(struct iscsi_cls_session *cls_session,
1406 			   struct iscsi_cls_conn *cls_conn,
1407 			   uint64_t transport_fd, int is_leading)
1408 {
1409 	struct iscsi_conn *conn = cls_conn->dd_data;
1410 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1411 	struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
1412 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
1413 	struct bnx2i_endpoint *bnx2i_ep;
1414 	struct iscsi_endpoint *ep;
1415 	int ret_code;
1416 
1417 	ep = iscsi_lookup_endpoint(transport_fd);
1418 	if (!ep)
1419 		return -EINVAL;
1420 	/*
1421 	 * Forcefully terminate all in progress connection recovery at the
1422 	 * earliest, either in bind(), send_pdu(LOGIN), or conn_start()
1423 	 */
1424 	if (bnx2i_adapter_ready(hba))
1425 		return -EIO;
1426 
1427 	bnx2i_ep = ep->dd_data;
1428 	if ((bnx2i_ep->state == EP_STATE_TCP_FIN_RCVD) ||
1429 	    (bnx2i_ep->state == EP_STATE_TCP_RST_RCVD))
1430 		/* Peer disconnect via' FIN or RST */
1431 		return -EINVAL;
1432 
1433 	if (iscsi_conn_bind(cls_session, cls_conn, is_leading))
1434 		return -EINVAL;
1435 
1436 	if (bnx2i_ep->hba != hba) {
1437 		/* Error - TCP connection does not belong to this device
1438 		 */
1439 		iscsi_conn_printk(KERN_ALERT, cls_conn->dd_data,
1440 				  "conn bind, ep=0x%p (%s) does not",
1441 				  bnx2i_ep, bnx2i_ep->hba->netdev->name);
1442 		iscsi_conn_printk(KERN_ALERT, cls_conn->dd_data,
1443 				  "belong to hba (%s)\n",
1444 				  hba->netdev->name);
1445 		return -EEXIST;
1446 	}
1447 	bnx2i_ep->conn = bnx2i_conn;
1448 	bnx2i_conn->ep = bnx2i_ep;
1449 	bnx2i_conn->iscsi_conn_cid = bnx2i_ep->ep_iscsi_cid;
1450 	bnx2i_conn->fw_cid = bnx2i_ep->ep_cid;
1451 
1452 	ret_code = bnx2i_bind_conn_to_iscsi_cid(hba, bnx2i_conn,
1453 						bnx2i_ep->ep_iscsi_cid);
1454 
1455 	/* 5706/5708/5709 FW takes RQ as full when initiated, but for 57710
1456 	 * driver needs to explicitly replenish RQ index during setup.
1457 	 */
1458 	if (test_bit(BNX2I_NX2_DEV_57710, &bnx2i_ep->hba->cnic_dev_type))
1459 		bnx2i_put_rq_buf(bnx2i_conn, 0);
1460 
1461 	bnx2i_arm_cq_event_coalescing(bnx2i_conn->ep, CNIC_ARM_CQE);
1462 	return ret_code;
1463 }
1464 
1465 
1466 /**
1467  * bnx2i_conn_destroy - destroy iscsi connection instance & release resources
1468  * @cls_conn:	pointer to iscsi cls conn
1469  *
1470  * Destroy an iSCSI connection instance and release memory resources held by
1471  *	this connection
1472  */
1473 static void bnx2i_conn_destroy(struct iscsi_cls_conn *cls_conn)
1474 {
1475 	struct iscsi_conn *conn = cls_conn->dd_data;
1476 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1477 	struct Scsi_Host *shost;
1478 	struct bnx2i_hba *hba;
1479 	struct bnx2i_work *work, *tmp;
1480 	unsigned cpu = 0;
1481 	struct bnx2i_percpu_s *p;
1482 
1483 	shost = iscsi_session_to_shost(iscsi_conn_to_session(cls_conn));
1484 	hba = iscsi_host_priv(shost);
1485 
1486 	bnx2i_conn_free_login_resources(hba, bnx2i_conn);
1487 
1488 	if (atomic_read(&bnx2i_conn->work_cnt)) {
1489 		for_each_online_cpu(cpu) {
1490 			p = &per_cpu(bnx2i_percpu, cpu);
1491 			spin_lock_bh(&p->p_work_lock);
1492 			list_for_each_entry_safe(work, tmp,
1493 						 &p->work_list, list) {
1494 				if (work->session == conn->session &&
1495 				    work->bnx2i_conn == bnx2i_conn) {
1496 					list_del_init(&work->list);
1497 					kfree(work);
1498 					if (!atomic_dec_and_test(
1499 							&bnx2i_conn->work_cnt))
1500 						break;
1501 				}
1502 			}
1503 			spin_unlock_bh(&p->p_work_lock);
1504 		}
1505 	}
1506 
1507 	iscsi_conn_teardown(cls_conn);
1508 }
1509 
1510 
1511 /**
1512  * bnx2i_ep_get_param - return iscsi ep parameter to caller
1513  * @ep:		pointer to iscsi endpoint
1514  * @param:	parameter type identifier
1515  * @buf: 	buffer pointer
1516  *
1517  * returns iSCSI ep parameters
1518  */
1519 static int bnx2i_ep_get_param(struct iscsi_endpoint *ep,
1520 			      enum iscsi_param param, char *buf)
1521 {
1522 	struct bnx2i_endpoint *bnx2i_ep = ep->dd_data;
1523 	struct bnx2i_hba *hba = bnx2i_ep->hba;
1524 	int len = -ENOTCONN;
1525 
1526 	if (!hba)
1527 		return -ENOTCONN;
1528 
1529 	switch (param) {
1530 	case ISCSI_PARAM_CONN_PORT:
1531 		mutex_lock(&hba->net_dev_lock);
1532 		if (bnx2i_ep->cm_sk)
1533 			len = sprintf(buf, "%hu\n", bnx2i_ep->cm_sk->dst_port);
1534 		mutex_unlock(&hba->net_dev_lock);
1535 		break;
1536 	case ISCSI_PARAM_CONN_ADDRESS:
1537 		mutex_lock(&hba->net_dev_lock);
1538 		if (bnx2i_ep->cm_sk)
1539 			len = sprintf(buf, "%pI4\n", &bnx2i_ep->cm_sk->dst_ip);
1540 		mutex_unlock(&hba->net_dev_lock);
1541 		break;
1542 	default:
1543 		return -ENOSYS;
1544 	}
1545 
1546 	return len;
1547 }
1548 
1549 /**
1550  * bnx2i_host_get_param - returns host (adapter) related parameters
1551  * @shost:	scsi host pointer
1552  * @param:	parameter type identifier
1553  * @buf:	buffer pointer
1554  */
1555 static int bnx2i_host_get_param(struct Scsi_Host *shost,
1556 				enum iscsi_host_param param, char *buf)
1557 {
1558 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
1559 	int len = 0;
1560 
1561 	switch (param) {
1562 	case ISCSI_HOST_PARAM_HWADDRESS:
1563 		len = sysfs_format_mac(buf, hba->cnic->mac_addr, 6);
1564 		break;
1565 	case ISCSI_HOST_PARAM_NETDEV_NAME:
1566 		len = sprintf(buf, "%s\n", hba->netdev->name);
1567 		break;
1568 	case ISCSI_HOST_PARAM_IPADDRESS: {
1569 		struct list_head *active_list = &hba->ep_active_list;
1570 
1571 		read_lock_bh(&hba->ep_rdwr_lock);
1572 		if (!list_empty(&hba->ep_active_list)) {
1573 			struct bnx2i_endpoint *bnx2i_ep;
1574 			struct cnic_sock *csk;
1575 
1576 			bnx2i_ep = list_first_entry(active_list,
1577 						    struct bnx2i_endpoint,
1578 						    link);
1579 			csk = bnx2i_ep->cm_sk;
1580 			if (test_bit(SK_F_IPV6, &csk->flags))
1581 				len = sprintf(buf, "%pI6\n", csk->src_ip);
1582 			else
1583 				len = sprintf(buf, "%pI4\n", csk->src_ip);
1584 		}
1585 		read_unlock_bh(&hba->ep_rdwr_lock);
1586 		break;
1587 	}
1588 	default:
1589 		return iscsi_host_get_param(shost, param, buf);
1590 	}
1591 	return len;
1592 }
1593 
1594 /**
1595  * bnx2i_conn_start - completes iscsi connection migration to FFP
1596  * @cls_conn:	pointer to iscsi cls conn
1597  *
1598  * last call in FFP migration to handover iscsi conn to the driver
1599  */
1600 static int bnx2i_conn_start(struct iscsi_cls_conn *cls_conn)
1601 {
1602 	struct iscsi_conn *conn = cls_conn->dd_data;
1603 	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
1604 
1605 	bnx2i_conn->ep->state = EP_STATE_ULP_UPDATE_START;
1606 	bnx2i_update_iscsi_conn(conn);
1607 
1608 	/*
1609 	 * this should normally not sleep for a long time so it should
1610 	 * not disrupt the caller.
1611 	 */
1612 	bnx2i_conn->ep->ofld_timer.expires = 1 * HZ + jiffies;
1613 	bnx2i_conn->ep->ofld_timer.function = bnx2i_ep_ofld_timer;
1614 	bnx2i_conn->ep->ofld_timer.data = (unsigned long) bnx2i_conn->ep;
1615 	add_timer(&bnx2i_conn->ep->ofld_timer);
1616 	/* update iSCSI context for this conn, wait for CNIC to complete */
1617 	wait_event_interruptible(bnx2i_conn->ep->ofld_wait,
1618 			bnx2i_conn->ep->state != EP_STATE_ULP_UPDATE_START);
1619 
1620 	if (signal_pending(current))
1621 		flush_signals(current);
1622 	del_timer_sync(&bnx2i_conn->ep->ofld_timer);
1623 
1624 	iscsi_conn_start(cls_conn);
1625 	return 0;
1626 }
1627 
1628 
1629 /**
1630  * bnx2i_conn_get_stats - returns iSCSI stats
1631  * @cls_conn:	pointer to iscsi cls conn
1632  * @stats:	pointer to iscsi statistic struct
1633  */
1634 static void bnx2i_conn_get_stats(struct iscsi_cls_conn *cls_conn,
1635 				 struct iscsi_stats *stats)
1636 {
1637 	struct iscsi_conn *conn = cls_conn->dd_data;
1638 
1639 	stats->txdata_octets = conn->txdata_octets;
1640 	stats->rxdata_octets = conn->rxdata_octets;
1641 	stats->scsicmd_pdus = conn->scsicmd_pdus_cnt;
1642 	stats->dataout_pdus = conn->dataout_pdus_cnt;
1643 	stats->scsirsp_pdus = conn->scsirsp_pdus_cnt;
1644 	stats->datain_pdus = conn->datain_pdus_cnt;
1645 	stats->r2t_pdus = conn->r2t_pdus_cnt;
1646 	stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt;
1647 	stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt;
1648 	stats->digest_err = 0;
1649 	stats->timeout_err = 0;
1650 	strcpy(stats->custom[0].desc, "eh_abort_cnt");
1651 	stats->custom[0].value = conn->eh_abort_cnt;
1652 	stats->custom_length = 1;
1653 }
1654 
1655 
1656 /**
1657  * bnx2i_check_route - checks if target IP route belongs to one of NX2 devices
1658  * @dst_addr:	target IP address
1659  *
1660  * check if route resolves to BNX2 device
1661  */
1662 static struct bnx2i_hba *bnx2i_check_route(struct sockaddr *dst_addr)
1663 {
1664 	struct sockaddr_in *desti = (struct sockaddr_in *) dst_addr;
1665 	struct bnx2i_hba *hba;
1666 	struct cnic_dev *cnic = NULL;
1667 
1668 	hba = get_adapter_list_head();
1669 	if (hba && hba->cnic)
1670 		cnic = hba->cnic->cm_select_dev(desti, CNIC_ULP_ISCSI);
1671 	if (!cnic) {
1672 		printk(KERN_ALERT "bnx2i: no route,"
1673 		       "can't connect using cnic\n");
1674 		goto no_nx2_route;
1675 	}
1676 	hba = bnx2i_find_hba_for_cnic(cnic);
1677 	if (!hba)
1678 		goto no_nx2_route;
1679 
1680 	if (bnx2i_adapter_ready(hba)) {
1681 		printk(KERN_ALERT "bnx2i: check route, hba not found\n");
1682 		goto no_nx2_route;
1683 	}
1684 	if (hba->netdev->mtu > hba->mtu_supported) {
1685 		printk(KERN_ALERT "bnx2i: %s network i/f mtu is set to %d\n",
1686 				  hba->netdev->name, hba->netdev->mtu);
1687 		printk(KERN_ALERT "bnx2i: iSCSI HBA can support mtu of %d\n",
1688 				  hba->mtu_supported);
1689 		goto no_nx2_route;
1690 	}
1691 	return hba;
1692 no_nx2_route:
1693 	return NULL;
1694 }
1695 
1696 
1697 /**
1698  * bnx2i_tear_down_conn - tear down iscsi/tcp connection and free resources
1699  * @hba:	pointer to adapter instance
1700  * @ep:		endpoint (transport identifier) structure
1701  *
1702  * destroys cm_sock structure and on chip iscsi context
1703  */
1704 static int bnx2i_tear_down_conn(struct bnx2i_hba *hba,
1705 				 struct bnx2i_endpoint *ep)
1706 {
1707 	if (test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic) && ep->cm_sk)
1708 		hba->cnic->cm_destroy(ep->cm_sk);
1709 
1710 	if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type) &&
1711 	    ep->state == EP_STATE_DISCONN_TIMEDOUT) {
1712 		if (ep->conn && ep->conn->cls_conn &&
1713 		    ep->conn->cls_conn->dd_data) {
1714 			struct iscsi_conn *conn = ep->conn->cls_conn->dd_data;
1715 
1716 			/* Must suspend all rx queue activity for this ep */
1717 			set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1718 		}
1719 		/* CONN_DISCONNECT timeout may or may not be an issue depending
1720 		 * on what transcribed in TCP layer, different targets behave
1721 		 * differently
1722 		 */
1723 		printk(KERN_ALERT "bnx2i (%s): - WARN - CONN_DISCON timed out, "
1724 				  "please submit GRC Dump, NW/PCIe trace, "
1725 				  "driver msgs to developers for analysis\n",
1726 				  hba->netdev->name);
1727 	}
1728 
1729 	ep->state = EP_STATE_CLEANUP_START;
1730 	init_timer(&ep->ofld_timer);
1731 	ep->ofld_timer.expires = hba->conn_ctx_destroy_tmo + jiffies;
1732 	ep->ofld_timer.function = bnx2i_ep_ofld_timer;
1733 	ep->ofld_timer.data = (unsigned long) ep;
1734 	add_timer(&ep->ofld_timer);
1735 
1736 	bnx2i_ep_destroy_list_add(hba, ep);
1737 
1738 	/* destroy iSCSI context, wait for it to complete */
1739 	if (bnx2i_send_conn_destroy(hba, ep))
1740 		ep->state = EP_STATE_CLEANUP_CMPL;
1741 
1742 	wait_event_interruptible(ep->ofld_wait,
1743 				 (ep->state != EP_STATE_CLEANUP_START));
1744 
1745 	if (signal_pending(current))
1746 		flush_signals(current);
1747 	del_timer_sync(&ep->ofld_timer);
1748 
1749 	bnx2i_ep_destroy_list_del(hba, ep);
1750 
1751 	if (ep->state != EP_STATE_CLEANUP_CMPL)
1752 		/* should never happen */
1753 		printk(KERN_ALERT "bnx2i - conn destroy failed\n");
1754 
1755 	return 0;
1756 }
1757 
1758 
1759 /**
1760  * bnx2i_ep_connect - establish TCP connection to target portal
1761  * @shost:		scsi host
1762  * @dst_addr:		target IP address
1763  * @non_blocking:	blocking or non-blocking call
1764  *
1765  * this routine initiates the TCP/IP connection by invoking Option-2 i/f
1766  *	with l5_core and the CNIC. This is a multi-step process of resolving
1767  *	route to target, create a iscsi connection context, handshaking with
1768  *	CNIC module to create/initialize the socket struct and finally
1769  *	sending down option-2 request to complete TCP 3-way handshake
1770  */
1771 static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
1772 					       struct sockaddr *dst_addr,
1773 					       int non_blocking)
1774 {
1775 	u32 iscsi_cid = BNX2I_CID_RESERVED;
1776 	struct sockaddr_in *desti = (struct sockaddr_in *) dst_addr;
1777 	struct sockaddr_in6 *desti6;
1778 	struct bnx2i_endpoint *bnx2i_ep;
1779 	struct bnx2i_hba *hba;
1780 	struct cnic_dev *cnic;
1781 	struct cnic_sockaddr saddr;
1782 	struct iscsi_endpoint *ep;
1783 	int rc = 0;
1784 
1785 	if (shost) {
1786 		/* driver is given scsi host to work with */
1787 		hba = iscsi_host_priv(shost);
1788 	} else
1789 		/*
1790 		 * check if the given destination can be reached through
1791 		 * a iscsi capable NetXtreme2 device
1792 		 */
1793 		hba = bnx2i_check_route(dst_addr);
1794 
1795 	if (!hba) {
1796 		rc = -EINVAL;
1797 		goto nohba;
1798 	}
1799 	mutex_lock(&hba->net_dev_lock);
1800 
1801 	if (bnx2i_adapter_ready(hba) || !hba->cid_que.cid_free_cnt) {
1802 		rc = -EPERM;
1803 		goto check_busy;
1804 	}
1805 	cnic = hba->cnic;
1806 	ep = bnx2i_alloc_ep(hba);
1807 	if (!ep) {
1808 		rc = -ENOMEM;
1809 		goto check_busy;
1810 	}
1811 	bnx2i_ep = ep->dd_data;
1812 
1813 	atomic_set(&bnx2i_ep->num_active_cmds, 0);
1814 	iscsi_cid = bnx2i_alloc_iscsi_cid(hba);
1815 	if (iscsi_cid == -1) {
1816 		printk(KERN_ALERT "bnx2i (%s): alloc_ep - unable to allocate "
1817 			"iscsi cid\n", hba->netdev->name);
1818 		rc = -ENOMEM;
1819 		bnx2i_free_ep(ep);
1820 		goto check_busy;
1821 	}
1822 	bnx2i_ep->hba_age = hba->age;
1823 
1824 	rc = bnx2i_alloc_qp_resc(hba, bnx2i_ep);
1825 	if (rc != 0) {
1826 		printk(KERN_ALERT "bnx2i (%s): ep_conn - alloc QP resc error"
1827 			"\n", hba->netdev->name);
1828 		rc = -ENOMEM;
1829 		goto qp_resc_err;
1830 	}
1831 
1832 	bnx2i_ep->ep_iscsi_cid = (u16)iscsi_cid;
1833 	bnx2i_ep->state = EP_STATE_OFLD_START;
1834 	bnx2i_ep_ofld_list_add(hba, bnx2i_ep);
1835 
1836 	init_timer(&bnx2i_ep->ofld_timer);
1837 	bnx2i_ep->ofld_timer.expires = 2 * HZ + jiffies;
1838 	bnx2i_ep->ofld_timer.function = bnx2i_ep_ofld_timer;
1839 	bnx2i_ep->ofld_timer.data = (unsigned long) bnx2i_ep;
1840 	add_timer(&bnx2i_ep->ofld_timer);
1841 
1842 	if (bnx2i_send_conn_ofld_req(hba, bnx2i_ep)) {
1843 		if (bnx2i_ep->state == EP_STATE_OFLD_FAILED_CID_BUSY) {
1844 			printk(KERN_ALERT "bnx2i (%s): iscsi cid %d is busy\n",
1845 				hba->netdev->name, bnx2i_ep->ep_iscsi_cid);
1846 			rc = -EBUSY;
1847 		} else
1848 			rc = -ENOSPC;
1849 		printk(KERN_ALERT "bnx2i (%s): unable to send conn offld kwqe"
1850 			"\n", hba->netdev->name);
1851 		bnx2i_ep_ofld_list_del(hba, bnx2i_ep);
1852 		goto conn_failed;
1853 	}
1854 
1855 	/* Wait for CNIC hardware to setup conn context and return 'cid' */
1856 	wait_event_interruptible(bnx2i_ep->ofld_wait,
1857 				 bnx2i_ep->state != EP_STATE_OFLD_START);
1858 
1859 	if (signal_pending(current))
1860 		flush_signals(current);
1861 	del_timer_sync(&bnx2i_ep->ofld_timer);
1862 
1863 	bnx2i_ep_ofld_list_del(hba, bnx2i_ep);
1864 
1865 	if (bnx2i_ep->state != EP_STATE_OFLD_COMPL) {
1866 		if (bnx2i_ep->state == EP_STATE_OFLD_FAILED_CID_BUSY) {
1867 			printk(KERN_ALERT "bnx2i (%s): iscsi cid %d is busy\n",
1868 				hba->netdev->name, bnx2i_ep->ep_iscsi_cid);
1869 			rc = -EBUSY;
1870 		} else
1871 			rc = -ENOSPC;
1872 		goto conn_failed;
1873 	}
1874 
1875 	rc = cnic->cm_create(cnic, CNIC_ULP_ISCSI, bnx2i_ep->ep_cid,
1876 			     iscsi_cid, &bnx2i_ep->cm_sk, bnx2i_ep);
1877 	if (rc) {
1878 		rc = -EINVAL;
1879 		/* Need to terminate and cleanup the connection */
1880 		goto release_ep;
1881 	}
1882 
1883 	bnx2i_ep->cm_sk->rcv_buf = 256 * 1024;
1884 	bnx2i_ep->cm_sk->snd_buf = 256 * 1024;
1885 	clear_bit(SK_TCP_TIMESTAMP, &bnx2i_ep->cm_sk->tcp_flags);
1886 
1887 	memset(&saddr, 0, sizeof(saddr));
1888 	if (dst_addr->sa_family == AF_INET) {
1889 		desti = (struct sockaddr_in *) dst_addr;
1890 		saddr.remote.v4 = *desti;
1891 		saddr.local.v4.sin_family = desti->sin_family;
1892 	} else if (dst_addr->sa_family == AF_INET6) {
1893 		desti6 = (struct sockaddr_in6 *) dst_addr;
1894 		saddr.remote.v6 = *desti6;
1895 		saddr.local.v6.sin6_family = desti6->sin6_family;
1896 	}
1897 
1898 	bnx2i_ep->timestamp = jiffies;
1899 	bnx2i_ep->state = EP_STATE_CONNECT_START;
1900 	if (!test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic)) {
1901 		rc = -EINVAL;
1902 		goto conn_failed;
1903 	} else
1904 		rc = cnic->cm_connect(bnx2i_ep->cm_sk, &saddr);
1905 	if (rc)
1906 		goto release_ep;
1907 
1908 	bnx2i_ep_active_list_add(hba, bnx2i_ep);
1909 
1910 	if (bnx2i_map_ep_dbell_regs(bnx2i_ep))
1911 		goto del_active_ep;
1912 
1913 	mutex_unlock(&hba->net_dev_lock);
1914 	return ep;
1915 
1916 del_active_ep:
1917 	bnx2i_ep_active_list_del(hba, bnx2i_ep);
1918 release_ep:
1919 	if (bnx2i_tear_down_conn(hba, bnx2i_ep)) {
1920 		mutex_unlock(&hba->net_dev_lock);
1921 		return ERR_PTR(rc);
1922 	}
1923 conn_failed:
1924 	bnx2i_free_qp_resc(hba, bnx2i_ep);
1925 qp_resc_err:
1926 	bnx2i_free_ep(ep);
1927 check_busy:
1928 	mutex_unlock(&hba->net_dev_lock);
1929 nohba:
1930 	return ERR_PTR(rc);
1931 }
1932 
1933 
1934 /**
1935  * bnx2i_ep_poll - polls for TCP connection establishement
1936  * @ep:			TCP connection (endpoint) handle
1937  * @timeout_ms:		timeout value in milli secs
1938  *
1939  * polls for TCP connect request to complete
1940  */
1941 static int bnx2i_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
1942 {
1943 	struct bnx2i_endpoint *bnx2i_ep;
1944 	int rc = 0;
1945 
1946 	bnx2i_ep = ep->dd_data;
1947 	if ((bnx2i_ep->state == EP_STATE_IDLE) ||
1948 	    (bnx2i_ep->state == EP_STATE_CONNECT_FAILED) ||
1949 	    (bnx2i_ep->state == EP_STATE_OFLD_FAILED))
1950 		return -1;
1951 	if (bnx2i_ep->state == EP_STATE_CONNECT_COMPL)
1952 		return 1;
1953 
1954 	rc = wait_event_interruptible_timeout(bnx2i_ep->ofld_wait,
1955 					      ((bnx2i_ep->state ==
1956 						EP_STATE_OFLD_FAILED) ||
1957 					       (bnx2i_ep->state ==
1958 						EP_STATE_CONNECT_FAILED) ||
1959 					       (bnx2i_ep->state ==
1960 						EP_STATE_CONNECT_COMPL)),
1961 					      msecs_to_jiffies(timeout_ms));
1962 	if (bnx2i_ep->state == EP_STATE_OFLD_FAILED)
1963 		rc = -1;
1964 
1965 	if (rc > 0)
1966 		return 1;
1967 	else if (!rc)
1968 		return 0;	/* timeout */
1969 	else
1970 		return rc;
1971 }
1972 
1973 
1974 /**
1975  * bnx2i_ep_tcp_conn_active - check EP state transition
1976  * @ep:		endpoint pointer
1977  *
1978  * check if underlying TCP connection is active
1979  */
1980 static int bnx2i_ep_tcp_conn_active(struct bnx2i_endpoint *bnx2i_ep)
1981 {
1982 	int ret;
1983 	int cnic_dev_10g = 0;
1984 
1985 	if (test_bit(BNX2I_NX2_DEV_57710, &bnx2i_ep->hba->cnic_dev_type))
1986 		cnic_dev_10g = 1;
1987 
1988 	switch (bnx2i_ep->state) {
1989 	case EP_STATE_CLEANUP_FAILED:
1990 	case EP_STATE_OFLD_FAILED:
1991 	case EP_STATE_DISCONN_TIMEDOUT:
1992 		ret = 0;
1993 		break;
1994 	case EP_STATE_CONNECT_START:
1995 	case EP_STATE_CONNECT_FAILED:
1996 	case EP_STATE_CONNECT_COMPL:
1997 	case EP_STATE_ULP_UPDATE_START:
1998 	case EP_STATE_ULP_UPDATE_COMPL:
1999 	case EP_STATE_TCP_FIN_RCVD:
2000 	case EP_STATE_LOGOUT_SENT:
2001 	case EP_STATE_LOGOUT_RESP_RCVD:
2002 	case EP_STATE_ULP_UPDATE_FAILED:
2003 		ret = 1;
2004 		break;
2005 	case EP_STATE_TCP_RST_RCVD:
2006 		if (cnic_dev_10g)
2007 			ret = 0;
2008 		else
2009 			ret = 1;
2010 		break;
2011 	default:
2012 		ret = 0;
2013 	}
2014 
2015 	return ret;
2016 }
2017 
2018 
2019 /*
2020  * bnx2i_hw_ep_disconnect - executes TCP connection teardown process in the hw
2021  * @ep:		TCP connection (bnx2i endpoint) handle
2022  *
2023  * executes  TCP connection teardown process
2024  */
2025 int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
2026 {
2027 	struct bnx2i_hba *hba = bnx2i_ep->hba;
2028 	struct cnic_dev *cnic;
2029 	struct iscsi_session *session = NULL;
2030 	struct iscsi_conn *conn = NULL;
2031 	int ret = 0;
2032 	int close = 0;
2033 	int close_ret = 0;
2034 
2035 	if (!hba)
2036 		return 0;
2037 
2038 	cnic = hba->cnic;
2039 	if (!cnic)
2040 		return 0;
2041 
2042 	if (bnx2i_ep->state == EP_STATE_IDLE ||
2043 	    bnx2i_ep->state == EP_STATE_DISCONN_TIMEDOUT)
2044 		return 0;
2045 
2046 	if (!bnx2i_ep_tcp_conn_active(bnx2i_ep))
2047 		goto destroy_conn;
2048 
2049 	if (bnx2i_ep->conn) {
2050 		conn = bnx2i_ep->conn->cls_conn->dd_data;
2051 		session = conn->session;
2052 	}
2053 
2054 	init_timer(&bnx2i_ep->ofld_timer);
2055 	bnx2i_ep->ofld_timer.expires = hba->conn_teardown_tmo + jiffies;
2056 	bnx2i_ep->ofld_timer.function = bnx2i_ep_ofld_timer;
2057 	bnx2i_ep->ofld_timer.data = (unsigned long) bnx2i_ep;
2058 	add_timer(&bnx2i_ep->ofld_timer);
2059 
2060 	if (!test_bit(BNX2I_CNIC_REGISTERED, &hba->reg_with_cnic))
2061 		goto out;
2062 
2063 	if (session) {
2064 		spin_lock_bh(&session->frwd_lock);
2065 		if (bnx2i_ep->state != EP_STATE_TCP_FIN_RCVD) {
2066 			if (session->state == ISCSI_STATE_LOGGING_OUT) {
2067 				if (bnx2i_ep->state == EP_STATE_LOGOUT_SENT) {
2068 					/* Logout sent, but no resp */
2069 					printk(KERN_ALERT "bnx2i (%s): WARNING"
2070 						" logout response was not "
2071 						"received!\n",
2072 						bnx2i_ep->hba->netdev->name);
2073 				} else if (bnx2i_ep->state ==
2074 					   EP_STATE_LOGOUT_RESP_RCVD)
2075 					close = 1;
2076 			}
2077 		} else
2078 			close = 1;
2079 
2080 		spin_unlock_bh(&session->frwd_lock);
2081 	}
2082 
2083 	bnx2i_ep->state = EP_STATE_DISCONN_START;
2084 
2085 	if (close)
2086 		close_ret = cnic->cm_close(bnx2i_ep->cm_sk);
2087 	else
2088 		close_ret = cnic->cm_abort(bnx2i_ep->cm_sk);
2089 
2090 	if (close_ret)
2091 		printk(KERN_ALERT "bnx2i (%s): close/abort(%d) returned %d\n",
2092 			bnx2i_ep->hba->netdev->name, close, close_ret);
2093 	else
2094 		/* wait for option-2 conn teardown */
2095 		wait_event_interruptible(bnx2i_ep->ofld_wait,
2096 				 bnx2i_ep->state != EP_STATE_DISCONN_START);
2097 
2098 	if (signal_pending(current))
2099 		flush_signals(current);
2100 	del_timer_sync(&bnx2i_ep->ofld_timer);
2101 
2102 destroy_conn:
2103 	bnx2i_ep_active_list_del(hba, bnx2i_ep);
2104 	if (bnx2i_tear_down_conn(hba, bnx2i_ep))
2105 		return -EINVAL;
2106 out:
2107 	bnx2i_ep->state = EP_STATE_IDLE;
2108 	return ret;
2109 }
2110 
2111 
2112 /**
2113  * bnx2i_ep_disconnect - executes TCP connection teardown process
2114  * @ep:		TCP connection (iscsi endpoint) handle
2115  *
2116  * executes  TCP connection teardown process
2117  */
2118 static void bnx2i_ep_disconnect(struct iscsi_endpoint *ep)
2119 {
2120 	struct bnx2i_endpoint *bnx2i_ep;
2121 	struct bnx2i_conn *bnx2i_conn = NULL;
2122 	struct iscsi_conn *conn = NULL;
2123 	struct bnx2i_hba *hba;
2124 
2125 	bnx2i_ep = ep->dd_data;
2126 
2127 	/* driver should not attempt connection cleanup until TCP_CONNECT
2128 	 * completes either successfully or fails. Timeout is 9-secs, so
2129 	 * wait for it to complete
2130 	 */
2131 	while ((bnx2i_ep->state == EP_STATE_CONNECT_START) &&
2132 		!time_after(jiffies, bnx2i_ep->timestamp + (12 * HZ)))
2133 		msleep(250);
2134 
2135 	if (bnx2i_ep->conn) {
2136 		bnx2i_conn = bnx2i_ep->conn;
2137 		conn = bnx2i_conn->cls_conn->dd_data;
2138 		iscsi_suspend_queue(conn);
2139 	}
2140 	hba = bnx2i_ep->hba;
2141 
2142 	mutex_lock(&hba->net_dev_lock);
2143 
2144 	if (bnx2i_ep->state == EP_STATE_DISCONN_TIMEDOUT)
2145 		goto out;
2146 
2147 	if (bnx2i_ep->state == EP_STATE_IDLE)
2148 		goto free_resc;
2149 
2150 	if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state) ||
2151 	    (bnx2i_ep->hba_age != hba->age)) {
2152 		bnx2i_ep_active_list_del(hba, bnx2i_ep);
2153 		goto free_resc;
2154 	}
2155 
2156 	/* Do all chip cleanup here */
2157 	if (bnx2i_hw_ep_disconnect(bnx2i_ep)) {
2158 		mutex_unlock(&hba->net_dev_lock);
2159 		return;
2160 	}
2161 free_resc:
2162 	bnx2i_free_qp_resc(hba, bnx2i_ep);
2163 
2164 	if (bnx2i_conn)
2165 		bnx2i_conn->ep = NULL;
2166 
2167 	bnx2i_free_ep(ep);
2168 out:
2169 	mutex_unlock(&hba->net_dev_lock);
2170 
2171 	wake_up_interruptible(&hba->eh_wait);
2172 }
2173 
2174 
2175 /**
2176  * bnx2i_nl_set_path - ISCSI_UEVENT_PATH_UPDATE user message handler
2177  * @buf:	pointer to buffer containing iscsi path message
2178  *
2179  */
2180 static int bnx2i_nl_set_path(struct Scsi_Host *shost, struct iscsi_path *params)
2181 {
2182 	struct bnx2i_hba *hba = iscsi_host_priv(shost);
2183 	char *buf = (char *) params;
2184 	u16 len = sizeof(*params);
2185 
2186 	/* handled by cnic driver */
2187 	hba->cnic->iscsi_nl_msg_recv(hba->cnic, ISCSI_UEVENT_PATH_UPDATE, buf,
2188 				     len);
2189 
2190 	return 0;
2191 }
2192 
2193 static umode_t bnx2i_attr_is_visible(int param_type, int param)
2194 {
2195 	switch (param_type) {
2196 	case ISCSI_HOST_PARAM:
2197 		switch (param) {
2198 		case ISCSI_HOST_PARAM_NETDEV_NAME:
2199 		case ISCSI_HOST_PARAM_HWADDRESS:
2200 		case ISCSI_HOST_PARAM_IPADDRESS:
2201 			return S_IRUGO;
2202 		default:
2203 			return 0;
2204 		}
2205 	case ISCSI_PARAM:
2206 		switch (param) {
2207 		case ISCSI_PARAM_MAX_RECV_DLENGTH:
2208 		case ISCSI_PARAM_MAX_XMIT_DLENGTH:
2209 		case ISCSI_PARAM_HDRDGST_EN:
2210 		case ISCSI_PARAM_DATADGST_EN:
2211 		case ISCSI_PARAM_CONN_ADDRESS:
2212 		case ISCSI_PARAM_CONN_PORT:
2213 		case ISCSI_PARAM_EXP_STATSN:
2214 		case ISCSI_PARAM_PERSISTENT_ADDRESS:
2215 		case ISCSI_PARAM_PERSISTENT_PORT:
2216 		case ISCSI_PARAM_PING_TMO:
2217 		case ISCSI_PARAM_RECV_TMO:
2218 		case ISCSI_PARAM_INITIAL_R2T_EN:
2219 		case ISCSI_PARAM_MAX_R2T:
2220 		case ISCSI_PARAM_IMM_DATA_EN:
2221 		case ISCSI_PARAM_FIRST_BURST:
2222 		case ISCSI_PARAM_MAX_BURST:
2223 		case ISCSI_PARAM_PDU_INORDER_EN:
2224 		case ISCSI_PARAM_DATASEQ_INORDER_EN:
2225 		case ISCSI_PARAM_ERL:
2226 		case ISCSI_PARAM_TARGET_NAME:
2227 		case ISCSI_PARAM_TPGT:
2228 		case ISCSI_PARAM_USERNAME:
2229 		case ISCSI_PARAM_PASSWORD:
2230 		case ISCSI_PARAM_USERNAME_IN:
2231 		case ISCSI_PARAM_PASSWORD_IN:
2232 		case ISCSI_PARAM_FAST_ABORT:
2233 		case ISCSI_PARAM_ABORT_TMO:
2234 		case ISCSI_PARAM_LU_RESET_TMO:
2235 		case ISCSI_PARAM_TGT_RESET_TMO:
2236 		case ISCSI_PARAM_IFACE_NAME:
2237 		case ISCSI_PARAM_INITIATOR_NAME:
2238 		case ISCSI_PARAM_BOOT_ROOT:
2239 		case ISCSI_PARAM_BOOT_NIC:
2240 		case ISCSI_PARAM_BOOT_TARGET:
2241 			return S_IRUGO;
2242 		default:
2243 			return 0;
2244 		}
2245 	}
2246 
2247 	return 0;
2248 }
2249 
2250 /*
2251  * 'Scsi_Host_Template' structure and 'iscsi_tranport' structure template
2252  * used while registering with the scsi host and iSCSI transport module.
2253  */
2254 static struct scsi_host_template bnx2i_host_template = {
2255 	.module			= THIS_MODULE,
2256 	.name			= "QLogic Offload iSCSI Initiator",
2257 	.proc_name		= "bnx2i",
2258 	.queuecommand		= iscsi_queuecommand,
2259 	.eh_abort_handler	= iscsi_eh_abort,
2260 	.eh_device_reset_handler = iscsi_eh_device_reset,
2261 	.eh_target_reset_handler = iscsi_eh_recover_target,
2262 	.change_queue_depth	= scsi_change_queue_depth,
2263 	.target_alloc		= iscsi_target_alloc,
2264 	.can_queue		= 2048,
2265 	.max_sectors		= 127,
2266 	.cmd_per_lun		= 128,
2267 	.this_id		= -1,
2268 	.use_clustering		= ENABLE_CLUSTERING,
2269 	.sg_tablesize		= ISCSI_MAX_BDS_PER_CMD,
2270 	.shost_attrs		= bnx2i_dev_attributes,
2271 	.track_queue_depth	= 1,
2272 };
2273 
2274 struct iscsi_transport bnx2i_iscsi_transport = {
2275 	.owner			= THIS_MODULE,
2276 	.name			= "bnx2i",
2277 	.caps			= CAP_RECOVERY_L0 | CAP_HDRDGST |
2278 				  CAP_MULTI_R2T | CAP_DATADGST |
2279 				  CAP_DATA_PATH_OFFLOAD |
2280 				  CAP_TEXT_NEGO,
2281 	.create_session		= bnx2i_session_create,
2282 	.destroy_session	= bnx2i_session_destroy,
2283 	.create_conn		= bnx2i_conn_create,
2284 	.bind_conn		= bnx2i_conn_bind,
2285 	.destroy_conn		= bnx2i_conn_destroy,
2286 	.attr_is_visible	= bnx2i_attr_is_visible,
2287 	.set_param		= iscsi_set_param,
2288 	.get_conn_param		= iscsi_conn_get_param,
2289 	.get_session_param	= iscsi_session_get_param,
2290 	.get_host_param		= bnx2i_host_get_param,
2291 	.start_conn		= bnx2i_conn_start,
2292 	.stop_conn		= iscsi_conn_stop,
2293 	.send_pdu		= iscsi_conn_send_pdu,
2294 	.xmit_task		= bnx2i_task_xmit,
2295 	.get_stats		= bnx2i_conn_get_stats,
2296 	/* TCP connect - disconnect - option-2 interface calls */
2297 	.get_ep_param		= bnx2i_ep_get_param,
2298 	.ep_connect		= bnx2i_ep_connect,
2299 	.ep_poll		= bnx2i_ep_poll,
2300 	.ep_disconnect		= bnx2i_ep_disconnect,
2301 	.set_path		= bnx2i_nl_set_path,
2302 	/* Error recovery timeout call */
2303 	.session_recovery_timedout = iscsi_session_recovery_timedout,
2304 	.cleanup_task		= bnx2i_cleanup_task,
2305 };
2306