1	/* bnx2i_hwi.c: QLogic NetXtreme II iSCSI driver.
2	*
3	* Copyright (c) 2006 - 2013 Broadcom Corporation
4	* Copyright (c) 2007, 2008 Red Hat, Inc. All rights reserved.
5	* Copyright (c) 2007, 2008 Mike Christie
6	* Copyright (c) 2014, QLogic Corporation
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation.
11	*
12	* Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
13	* Previously Maintained by: Eddie Wai (eddie.wai@broadcom.com)
14	* Maintained by: QLogic-Storage-Upstream@qlogic.com
15	*/
16
17	#include <linux/gfp.h>
18	#include <scsi/scsi_tcq.h>
19	#include <scsi/libiscsi.h>
20	#include "bnx2i.h"
21
22	DECLARE_PER_CPU(struct bnx2i_percpu_s, bnx2i_percpu);
23
24	/**
25	* bnx2i_get_cid_num - get cid from ep
26	* @ep: endpoint pointer
27	*
28	* Only applicable to 57710 family of devices
29	*/
30	static u32 bnx2i_get_cid_num(struct bnx2i_endpoint *ep)
31	{
32	u32 cid;
33
34	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
35	cid = ep->ep_cid;
36	else
37	cid = GET_CID_NUM(ep->ep_cid);
38	return cid;
39	}
40
41
42	/**
43	* bnx2i_adjust_qp_size - Adjust SQ/RQ/CQ size for 57710 device type
44	* @hba: Adapter for which adjustments is to be made
45	*
46	* Only applicable to 57710 family of devices
47	*/
48	static void bnx2i_adjust_qp_size(struct bnx2i_hba *hba)
49	{
50	u32 num_elements_per_pg;
51
52	if (test_bit(BNX2I_NX2_DEV_5706, &hba->cnic_dev_type) ||
53	test_bit(BNX2I_NX2_DEV_5708, &hba->cnic_dev_type) ||
54	test_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type)) {
55	if (!is_power_of_2(n: hba->max_sqes))
56	hba->max_sqes = rounddown_pow_of_two(hba->max_sqes);
57
58	if (!is_power_of_2(n: hba->max_rqes))
59	hba->max_rqes = rounddown_pow_of_two(hba->max_rqes);
60	}
61
62	/* Adjust each queue size if the user selection does not
63	* yield integral num of page buffers
64	*/
65	/* adjust SQ */
66	num_elements_per_pg = CNIC_PAGE_SIZE / BNX2I_SQ_WQE_SIZE;
67	if (hba->max_sqes < num_elements_per_pg)
68	hba->max_sqes = num_elements_per_pg;
69	else if (hba->max_sqes % num_elements_per_pg)
70	hba->max_sqes = (hba->max_sqes + num_elements_per_pg - 1) &
71	~(num_elements_per_pg - 1);
72
73	/* adjust CQ */
74	num_elements_per_pg = CNIC_PAGE_SIZE / BNX2I_CQE_SIZE;
75	if (hba->max_cqes < num_elements_per_pg)
76	hba->max_cqes = num_elements_per_pg;
77	else if (hba->max_cqes % num_elements_per_pg)
78	hba->max_cqes = (hba->max_cqes + num_elements_per_pg - 1) &
79	~(num_elements_per_pg - 1);
80
81	/* adjust RQ */
82	num_elements_per_pg = CNIC_PAGE_SIZE / BNX2I_RQ_WQE_SIZE;
83	if (hba->max_rqes < num_elements_per_pg)
84	hba->max_rqes = num_elements_per_pg;
85	else if (hba->max_rqes % num_elements_per_pg)
86	hba->max_rqes = (hba->max_rqes + num_elements_per_pg - 1) &
87	~(num_elements_per_pg - 1);
88	}
89
90
91	/**
92	* bnx2i_get_link_state - get network interface link state
93	* @hba: adapter instance pointer
94	*
95	* updates adapter structure flag based on netdev state
96	*/
97	static void bnx2i_get_link_state(struct bnx2i_hba *hba)
98	{
99	if (test_bit(__LINK_STATE_NOCARRIER, &hba->netdev->state))
100	set_bit(ADAPTER_STATE_LINK_DOWN, addr: &hba->adapter_state);
101	else
102	clear_bit(ADAPTER_STATE_LINK_DOWN, addr: &hba->adapter_state);
103	}
104
105
106	/**
107	* bnx2i_iscsi_license_error - displays iscsi license related error message
108	* @hba: adapter instance pointer
109	* @error_code: error classification
110	*
111	* Puts out an error log when driver is unable to offload iscsi connection
112	* due to license restrictions
113	*/
114	static void bnx2i_iscsi_license_error(struct bnx2i_hba *hba, u32 error_code)
115	{
116	if (error_code == ISCSI_KCQE_COMPLETION_STATUS_ISCSI_NOT_SUPPORTED)
117	/* iSCSI offload not supported on this device */
118	printk(KERN_ERR "bnx2i: iSCSI not supported, dev=%s\n",
119	hba->netdev->name);
120	if (error_code == ISCSI_KCQE_COMPLETION_STATUS_LOM_ISCSI_NOT_ENABLED)
121	/* iSCSI offload not supported on this LOM device */
122	printk(KERN_ERR "bnx2i: LOM is not enable to "
123	"offload iSCSI connections, dev=%s\n",
124	hba->netdev->name);
125	set_bit(ADAPTER_STATE_INIT_FAILED, addr: &hba->adapter_state);
126	}
127
128
129	/**
130	* bnx2i_arm_cq_event_coalescing - arms CQ to enable EQ notification
131	* @ep: endpoint (transport identifier) structure
132	* @action: action, ARM or DISARM. For now only ARM_CQE is used
133	*
134	* Arm'ing CQ will enable chip to generate global EQ events inorder to interrupt
135	* the driver. EQ event is generated CQ index is hit or at least 1 CQ is
136	* outstanding and on chip timer expires
137	*/
138	int bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint *ep, u8 action)
139	{
140	struct bnx2i_5771x_cq_db *cq_db;
141	u16 cq_index;
142	u16 next_index = 0;
143	u32 num_active_cmds;
144
145	/* Coalesce CQ entries only on 10G devices */
146	if (!test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
147	return 0;
148
149	/* Do not update CQ DB multiple times before firmware writes
150	* '0xFFFF' to CQDB->SQN field. Deviation may cause spurious
151	* interrupts and other unwanted results
152	*/
153	cq_db = (struct bnx2i_5771x_cq_db *) ep->qp.cq_pgtbl_virt;
154
155	if (action != CNIC_ARM_CQE_FP)
156	if (cq_db->sqn[0] && cq_db->sqn[0] != 0xFFFF)
157	return 0;
158
159	if (action == CNIC_ARM_CQE || action == CNIC_ARM_CQE_FP) {
160	num_active_cmds = atomic_read(v: &ep->num_active_cmds);
161	if (num_active_cmds <= event_coal_min)
162	next_index = 1;
163	else {
164	next_index = num_active_cmds >> ep->ec_shift;
165	if (next_index > num_active_cmds - event_coal_min)
166	next_index = num_active_cmds - event_coal_min;
167	}
168	if (!next_index)
169	next_index = 1;
170	cq_index = ep->qp.cqe_exp_seq_sn + next_index - 1;
171	if (cq_index > ep->qp.cqe_size * 2)
172	cq_index -= ep->qp.cqe_size * 2;
173	if (!cq_index)
174	cq_index = 1;
175
176	cq_db->sqn[0] = cq_index;
177	}
178	return next_index;
179	}
180
181
182	/**
183	* bnx2i_get_rq_buf - copy RQ buffer contents to driver buffer
184	* @bnx2i_conn: iscsi connection on which RQ event occurred
185	* @ptr: driver buffer to which RQ buffer contents is to
186	* be copied
187	* @len: length of valid data inside RQ buf
188	*
189	* Copies RQ buffer contents from shared (DMA'able) memory region to
190	* driver buffer. RQ is used to DMA unsolicitated iscsi pdu's and
191	* scsi sense info
192	*/
193	void bnx2i_get_rq_buf(struct bnx2i_conn *bnx2i_conn, char *ptr, int len)
194	{
195	if (!bnx2i_conn->ep->qp.rqe_left)
196	return;
197
198	bnx2i_conn->ep->qp.rqe_left--;
199	memcpy(ptr, (u8 *) bnx2i_conn->ep->qp.rq_cons_qe, len);
200	if (bnx2i_conn->ep->qp.rq_cons_qe == bnx2i_conn->ep->qp.rq_last_qe) {
201	bnx2i_conn->ep->qp.rq_cons_qe = bnx2i_conn->ep->qp.rq_first_qe;
202	bnx2i_conn->ep->qp.rq_cons_idx = 0;
203	} else {
204	bnx2i_conn->ep->qp.rq_cons_qe++;
205	bnx2i_conn->ep->qp.rq_cons_idx++;
206	}
207	}
208
209
210	static void bnx2i_ring_577xx_doorbell(struct bnx2i_conn *conn)
211	{
212	struct bnx2i_5771x_dbell dbell;
213	u32 msg;
214
215	memset(&dbell, 0, sizeof(dbell));
216	dbell.dbell.header = (B577XX_ISCSI_CONNECTION_TYPE <<
217	B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT);
218	msg = *((u32 *)&dbell);
219	/* TODO : get doorbell register mapping */
220	writel(cpu_to_le32(msg), addr: conn->ep->qp.ctx_base);
221	}
222
223
224	/**
225	* bnx2i_put_rq_buf - Replenish RQ buffer, if required ring on chip doorbell
226	* @bnx2i_conn: iscsi connection on which event to post
227	* @count: number of RQ buffer being posted to chip
228	*
229	* No need to ring hardware doorbell for 57710 family of devices
230	*/
231	void bnx2i_put_rq_buf(struct bnx2i_conn *bnx2i_conn, int count)
232	{
233	struct bnx2i_5771x_sq_rq_db *rq_db;
234	u16 hi_bit = (bnx2i_conn->ep->qp.rq_prod_idx & 0x8000);
235	struct bnx2i_endpoint *ep = bnx2i_conn->ep;
236
237	ep->qp.rqe_left += count;
238	ep->qp.rq_prod_idx &= 0x7FFF;
239	ep->qp.rq_prod_idx += count;
240
241	if (ep->qp.rq_prod_idx > bnx2i_conn->hba->max_rqes) {
242	ep->qp.rq_prod_idx %= bnx2i_conn->hba->max_rqes;
243	if (!hi_bit)
244	ep->qp.rq_prod_idx |= 0x8000;
245	} else
246	ep->qp.rq_prod_idx |= hi_bit;
247
248	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) {
249	rq_db = (struct bnx2i_5771x_sq_rq_db *) ep->qp.rq_pgtbl_virt;
250	rq_db->prod_idx = ep->qp.rq_prod_idx;
251	/* no need to ring hardware doorbell for 57710 */
252	} else {
253	writew(val: ep->qp.rq_prod_idx,
254	addr: ep->qp.ctx_base + CNIC_RECV_DOORBELL);
255	}
256	}
257
258
259	/**
260	* bnx2i_ring_sq_dbell - Ring SQ doorbell to wake-up the processing engine
261	* @bnx2i_conn: iscsi connection to which new SQ entries belong
262	* @count: number of SQ WQEs to post
263	*
264	* SQ DB is updated in host memory and TX Doorbell is rung for 57710 family
265	* of devices. For 5706/5708/5709 new SQ WQE count is written into the
266	* doorbell register
267	*/
268	static void bnx2i_ring_sq_dbell(struct bnx2i_conn *bnx2i_conn, int count)
269	{
270	struct bnx2i_5771x_sq_rq_db *sq_db;
271	struct bnx2i_endpoint *ep = bnx2i_conn->ep;
272
273	atomic_inc(v: &ep->num_active_cmds);
274	wmb(); /* flush SQ WQE memory before the doorbell is rung */
275	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) {
276	sq_db = (struct bnx2i_5771x_sq_rq_db *) ep->qp.sq_pgtbl_virt;
277	sq_db->prod_idx = ep->qp.sq_prod_idx;
278	bnx2i_ring_577xx_doorbell(conn: bnx2i_conn);
279	} else
280	writew(val: count, addr: ep->qp.ctx_base + CNIC_SEND_DOORBELL);
281	}
282
283
284	/**
285	* bnx2i_ring_dbell_update_sq_params - update SQ driver parameters
286	* @bnx2i_conn: iscsi connection to which new SQ entries belong
287	* @count: number of SQ WQEs to post
288	*
289	* this routine will update SQ driver parameters and ring the doorbell
290	*/
291	static void bnx2i_ring_dbell_update_sq_params(struct bnx2i_conn *bnx2i_conn,
292	int count)
293	{
294	int tmp_cnt;
295
296	if (count == 1) {
297	if (bnx2i_conn->ep->qp.sq_prod_qe ==
298	bnx2i_conn->ep->qp.sq_last_qe)
299	bnx2i_conn->ep->qp.sq_prod_qe =
300	bnx2i_conn->ep->qp.sq_first_qe;
301	else
302	bnx2i_conn->ep->qp.sq_prod_qe++;
303	} else {
304	if ((bnx2i_conn->ep->qp.sq_prod_qe + count) <=
305	bnx2i_conn->ep->qp.sq_last_qe)
306	bnx2i_conn->ep->qp.sq_prod_qe += count;
307	else {
308	tmp_cnt = bnx2i_conn->ep->qp.sq_last_qe -
309	bnx2i_conn->ep->qp.sq_prod_qe;
310	bnx2i_conn->ep->qp.sq_prod_qe =
311	&bnx2i_conn->ep->qp.sq_first_qe[count -
312	(tmp_cnt + 1)];
313	}
314	}
315	bnx2i_conn->ep->qp.sq_prod_idx += count;
316	/* Ring the doorbell */
317	bnx2i_ring_sq_dbell(bnx2i_conn, count: bnx2i_conn->ep->qp.sq_prod_idx);
318	}
319
320
321	/**
322	* bnx2i_send_iscsi_login - post iSCSI login request MP WQE to hardware
323	* @bnx2i_conn: iscsi connection
324	* @task: transport layer's command structure pointer which is requesting
325	* a WQE to sent to chip for further processing
326	*
327	* prepare and post an iSCSI Login request WQE to CNIC firmware
328	*/
329	int bnx2i_send_iscsi_login(struct bnx2i_conn *bnx2i_conn,
330	struct iscsi_task *task)
331	{
332	struct bnx2i_login_request *login_wqe;
333	struct iscsi_login_req *login_hdr;
334	u32 dword;
335
336	login_hdr = (struct iscsi_login_req *)task->hdr;
337	login_wqe = (struct bnx2i_login_request *)
338	bnx2i_conn->ep->qp.sq_prod_qe;
339
340	login_wqe->op_code = login_hdr->opcode;
341	login_wqe->op_attr = login_hdr->flags;
342	login_wqe->version_max = login_hdr->max_version;
343	login_wqe->version_min = login_hdr->min_version;
344	login_wqe->data_length = ntoh24(login_hdr->dlength);
345	login_wqe->isid_lo = *((u32 *) login_hdr->isid);
346	login_wqe->isid_hi = *((u16 *) login_hdr->isid + 2);
347	login_wqe->tsih = login_hdr->tsih;
348	login_wqe->itt = task->itt |
349	(ISCSI_TASK_TYPE_MPATH << ISCSI_LOGIN_REQUEST_TYPE_SHIFT);
350	login_wqe->cid = login_hdr->cid;
351
352	login_wqe->cmd_sn = be32_to_cpu(login_hdr->cmdsn);
353	login_wqe->exp_stat_sn = be32_to_cpu(login_hdr->exp_statsn);
354	login_wqe->flags = ISCSI_LOGIN_REQUEST_UPDATE_EXP_STAT_SN;
355
356	login_wqe->resp_bd_list_addr_lo = (u32) bnx2i_conn->gen_pdu.resp_bd_dma;
357	login_wqe->resp_bd_list_addr_hi =
358	(u32) ((u64) bnx2i_conn->gen_pdu.resp_bd_dma >> 32);
359
360	dword = ((1 << ISCSI_LOGIN_REQUEST_NUM_RESP_BDS_SHIFT) |
361	(bnx2i_conn->gen_pdu.resp_buf_size <<
362	ISCSI_LOGIN_REQUEST_RESP_BUFFER_LENGTH_SHIFT));
363	login_wqe->resp_buffer = dword;
364	login_wqe->bd_list_addr_lo = (u32) bnx2i_conn->gen_pdu.req_bd_dma;
365	login_wqe->bd_list_addr_hi =
366	(u32) ((u64) bnx2i_conn->gen_pdu.req_bd_dma >> 32);
367	login_wqe->num_bds = 1;
368	login_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
369
370	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
371	return 0;
372	}
373
374	/**
375	* bnx2i_send_iscsi_tmf - post iSCSI task management request MP WQE to hardware
376	* @bnx2i_conn: iscsi connection
377	* @mtask: driver command structure which is requesting
378	* a WQE to sent to chip for further processing
379	*
380	* prepare and post an iSCSI Login request WQE to CNIC firmware
381	*/
382	int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn,
383	struct iscsi_task *mtask)
384	{
385	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
386	struct iscsi_tm *tmfabort_hdr;
387	struct scsi_cmnd *ref_sc;
388	struct iscsi_task *ctask;
389	struct bnx2i_tmf_request *tmfabort_wqe;
390	u32 dword;
391	u32 scsi_lun[2];
392
393	tmfabort_hdr = (struct iscsi_tm *)mtask->hdr;
394	tmfabort_wqe = (struct bnx2i_tmf_request *)
395	bnx2i_conn->ep->qp.sq_prod_qe;
396
397	tmfabort_wqe->op_code = tmfabort_hdr->opcode;
398	tmfabort_wqe->op_attr = tmfabort_hdr->flags;
399
400	tmfabort_wqe->itt = (mtask->itt | (ISCSI_TASK_TYPE_MPATH << 14));
401	tmfabort_wqe->reserved2 = 0;
402	tmfabort_wqe->cmd_sn = be32_to_cpu(tmfabort_hdr->cmdsn);
403
404	switch (tmfabort_hdr->flags & ISCSI_FLAG_TM_FUNC_MASK) {
405	case ISCSI_TM_FUNC_ABORT_TASK:
406	case ISCSI_TM_FUNC_TASK_REASSIGN:
407	ctask = iscsi_itt_to_task(conn, tmfabort_hdr->rtt);
408	if (!ctask || !ctask->sc)
409	/*
410	* the iscsi layer must have completed the cmd while
411	* was starting up.
412	*
413	* Note: In the case of a SCSI cmd timeout, the task's
414	* sc is still active; hence ctask->sc != 0
415	* In this case, the task must be aborted
416	*/
417	return 0;
418
419	ref_sc = ctask->sc;
420	if (ref_sc->sc_data_direction == DMA_TO_DEVICE)
421	dword = (ISCSI_TASK_TYPE_WRITE <<
422	ISCSI_CMD_REQUEST_TYPE_SHIFT);
423	else
424	dword = (ISCSI_TASK_TYPE_READ <<
425	ISCSI_CMD_REQUEST_TYPE_SHIFT);
426	tmfabort_wqe->ref_itt = (dword |
427	(tmfabort_hdr->rtt & ISCSI_ITT_MASK));
428	break;
429	default:
430	tmfabort_wqe->ref_itt = RESERVED_ITT;
431	}
432	memcpy(scsi_lun, &tmfabort_hdr->lun, sizeof(struct scsi_lun));
433	tmfabort_wqe->lun[0] = be32_to_cpu(scsi_lun[0]);
434	tmfabort_wqe->lun[1] = be32_to_cpu(scsi_lun[1]);
435
436	tmfabort_wqe->ref_cmd_sn = be32_to_cpu(tmfabort_hdr->refcmdsn);
437
438	tmfabort_wqe->bd_list_addr_lo = (u32) bnx2i_conn->hba->mp_bd_dma;
439	tmfabort_wqe->bd_list_addr_hi = (u32)
440	((u64) bnx2i_conn->hba->mp_bd_dma >> 32);
441	tmfabort_wqe->num_bds = 1;
442	tmfabort_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
443
444	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
445	return 0;
446	}
447
448	/**
449	* bnx2i_send_iscsi_text - post iSCSI text WQE to hardware
450	* @bnx2i_conn: iscsi connection
451	* @mtask: driver command structure which is requesting
452	* a WQE to sent to chip for further processing
453	*
454	* prepare and post an iSCSI Text request WQE to CNIC firmware
455	*/
456	int bnx2i_send_iscsi_text(struct bnx2i_conn *bnx2i_conn,
457	struct iscsi_task *mtask)
458	{
459	struct bnx2i_text_request *text_wqe;
460	struct iscsi_text *text_hdr;
461	u32 dword;
462
463	text_hdr = (struct iscsi_text *)mtask->hdr;
464	text_wqe = (struct bnx2i_text_request *) bnx2i_conn->ep->qp.sq_prod_qe;
465
466	memset(text_wqe, 0, sizeof(struct bnx2i_text_request));
467
468	text_wqe->op_code = text_hdr->opcode;
469	text_wqe->op_attr = text_hdr->flags;
470	text_wqe->data_length = ntoh24(text_hdr->dlength);
471	text_wqe->itt = mtask->itt |
472	(ISCSI_TASK_TYPE_MPATH << ISCSI_TEXT_REQUEST_TYPE_SHIFT);
473	text_wqe->ttt = be32_to_cpu(text_hdr->ttt);
474
475	text_wqe->cmd_sn = be32_to_cpu(text_hdr->cmdsn);
476
477	text_wqe->resp_bd_list_addr_lo = (u32) bnx2i_conn->gen_pdu.resp_bd_dma;
478	text_wqe->resp_bd_list_addr_hi =
479	(u32) ((u64) bnx2i_conn->gen_pdu.resp_bd_dma >> 32);
480
481	dword = ((1 << ISCSI_TEXT_REQUEST_NUM_RESP_BDS_SHIFT) |
482	(bnx2i_conn->gen_pdu.resp_buf_size <<
483	ISCSI_TEXT_REQUEST_RESP_BUFFER_LENGTH_SHIFT));
484	text_wqe->resp_buffer = dword;
485	text_wqe->bd_list_addr_lo = (u32) bnx2i_conn->gen_pdu.req_bd_dma;
486	text_wqe->bd_list_addr_hi =
487	(u32) ((u64) bnx2i_conn->gen_pdu.req_bd_dma >> 32);
488	text_wqe->num_bds = 1;
489	text_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
490
491	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
492	return 0;
493	}
494
495
496	/**
497	* bnx2i_send_iscsi_scsicmd - post iSCSI scsicmd request WQE to hardware
498	* @bnx2i_conn: iscsi connection
499	* @cmd: driver command structure which is requesting
500	* a WQE to sent to chip for further processing
501	*
502	* prepare and post an iSCSI SCSI-CMD request WQE to CNIC firmware
503	*/
504	int bnx2i_send_iscsi_scsicmd(struct bnx2i_conn *bnx2i_conn,
505	struct bnx2i_cmd *cmd)
506	{
507	struct bnx2i_cmd_request *scsi_cmd_wqe;
508
509	scsi_cmd_wqe = (struct bnx2i_cmd_request *)
510	bnx2i_conn->ep->qp.sq_prod_qe;
511	memcpy(scsi_cmd_wqe, &cmd->req, sizeof(struct bnx2i_cmd_request));
512	scsi_cmd_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
513
514	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
515	return 0;
516	}
517
518	/**
519	* bnx2i_send_iscsi_nopout - post iSCSI NOPOUT request WQE to hardware
520	* @bnx2i_conn: iscsi connection
521	* @task: transport layer's command structure pointer which is
522	* requesting a WQE to sent to chip for further processing
523	* @datap: payload buffer pointer
524	* @data_len: payload data length
525	* @unsol: indicated whether nopout pdu is unsolicited pdu or
526	* in response to target's NOPIN w/ TTT != FFFFFFFF
527	*
528	* prepare and post a nopout request WQE to CNIC firmware
529	*/
530	int bnx2i_send_iscsi_nopout(struct bnx2i_conn *bnx2i_conn,
531	struct iscsi_task *task,
532	char *datap, int data_len, int unsol)
533	{
534	struct bnx2i_endpoint *ep = bnx2i_conn->ep;
535	struct bnx2i_nop_out_request *nopout_wqe;
536	struct iscsi_nopout *nopout_hdr;
537
538	nopout_hdr = (struct iscsi_nopout *)task->hdr;
539	nopout_wqe = (struct bnx2i_nop_out_request *)ep->qp.sq_prod_qe;
540
541	memset(nopout_wqe, 0x00, sizeof(struct bnx2i_nop_out_request));
542
543	nopout_wqe->op_code = nopout_hdr->opcode;
544	nopout_wqe->op_attr = ISCSI_FLAG_CMD_FINAL;
545	memcpy(nopout_wqe->lun, &nopout_hdr->lun, 8);
546
547	/* 57710 requires LUN field to be swapped */
548	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
549	swap(nopout_wqe->lun[0], nopout_wqe->lun[1]);
550
551	nopout_wqe->itt = ((u16)task->itt |
552	(ISCSI_TASK_TYPE_MPATH <<
553	ISCSI_TMF_REQUEST_TYPE_SHIFT));
554	nopout_wqe->ttt = be32_to_cpu(nopout_hdr->ttt);
555	nopout_wqe->flags = 0;
556	if (!unsol)
557	nopout_wqe->flags = ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION;
558	else if (nopout_hdr->itt == RESERVED_ITT)
559	nopout_wqe->flags = ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION;
560
561	nopout_wqe->cmd_sn = be32_to_cpu(nopout_hdr->cmdsn);
562	nopout_wqe->data_length = data_len;
563	if (data_len) {
564	/* handle payload data, not required in first release */
565	printk(KERN_ALERT "NOPOUT: WARNING!! payload len != 0\n");
566	} else {
567	nopout_wqe->bd_list_addr_lo = (u32)
568	bnx2i_conn->hba->mp_bd_dma;
569	nopout_wqe->bd_list_addr_hi =
570	(u32) ((u64) bnx2i_conn->hba->mp_bd_dma >> 32);
571	nopout_wqe->num_bds = 1;
572	}
573	nopout_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
574
575	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
576	return 0;
577	}
578
579
580	/**
581	* bnx2i_send_iscsi_logout - post iSCSI logout request WQE to hardware
582	* @bnx2i_conn: iscsi connection
583	* @task: transport layer's command structure pointer which is
584	* requesting a WQE to sent to chip for further processing
585	*
586	* prepare and post logout request WQE to CNIC firmware
587	*/
588	int bnx2i_send_iscsi_logout(struct bnx2i_conn *bnx2i_conn,
589	struct iscsi_task *task)
590	{
591	struct bnx2i_logout_request *logout_wqe;
592	struct iscsi_logout *logout_hdr;
593
594	logout_hdr = (struct iscsi_logout *)task->hdr;
595
596	logout_wqe = (struct bnx2i_logout_request *)
597	bnx2i_conn->ep->qp.sq_prod_qe;
598	memset(logout_wqe, 0x00, sizeof(struct bnx2i_logout_request));
599
600	logout_wqe->op_code = logout_hdr->opcode;
601	logout_wqe->cmd_sn = be32_to_cpu(logout_hdr->cmdsn);
602	logout_wqe->op_attr =
603	logout_hdr->flags | ISCSI_LOGOUT_REQUEST_ALWAYS_ONE;
604	logout_wqe->itt = ((u16)task->itt |
605	(ISCSI_TASK_TYPE_MPATH <<
606	ISCSI_LOGOUT_REQUEST_TYPE_SHIFT));
607	logout_wqe->data_length = 0;
608	logout_wqe->cid = 0;
609
610	logout_wqe->bd_list_addr_lo = (u32) bnx2i_conn->hba->mp_bd_dma;
611	logout_wqe->bd_list_addr_hi = (u32)
612	((u64) bnx2i_conn->hba->mp_bd_dma >> 32);
613	logout_wqe->num_bds = 1;
614	logout_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */
615
616	bnx2i_conn->ep->state = EP_STATE_LOGOUT_SENT;
617
618	bnx2i_ring_dbell_update_sq_params(bnx2i_conn, count: 1);
619	return 0;
620	}
621
622
623	/**
624	* bnx2i_update_iscsi_conn - post iSCSI logout request WQE to hardware
625	* @conn: iscsi connection which requires iscsi parameter update
626	*
627	* sends down iSCSI Conn Update request to move iSCSI conn to FFP
628	*/
629	void bnx2i_update_iscsi_conn(struct iscsi_conn *conn)
630	{
631	struct bnx2i_conn *bnx2i_conn = conn->dd_data;
632	struct bnx2i_hba *hba = bnx2i_conn->hba;
633	struct kwqe *kwqe_arr[2];
634	struct iscsi_kwqe_conn_update *update_wqe;
635	struct iscsi_kwqe_conn_update conn_update_kwqe;
636
637	update_wqe = &conn_update_kwqe;
638
639	update_wqe->hdr.op_code = ISCSI_KWQE_OPCODE_UPDATE_CONN;
640	update_wqe->hdr.flags =
641	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
642
643	/* 5771x requires conn context id to be passed as is */
644	if (test_bit(BNX2I_NX2_DEV_57710, &bnx2i_conn->ep->hba->cnic_dev_type))
645	update_wqe->context_id = bnx2i_conn->ep->ep_cid;
646	else
647	update_wqe->context_id = (bnx2i_conn->ep->ep_cid >> 7);
648	update_wqe->conn_flags = 0;
649	if (conn->hdrdgst_en)
650	update_wqe->conn_flags |= ISCSI_KWQE_CONN_UPDATE_HEADER_DIGEST;
651	if (conn->datadgst_en)
652	update_wqe->conn_flags |= ISCSI_KWQE_CONN_UPDATE_DATA_DIGEST;
653	if (conn->session->initial_r2t_en)
654	update_wqe->conn_flags |= ISCSI_KWQE_CONN_UPDATE_INITIAL_R2T;
655	if (conn->session->imm_data_en)
656	update_wqe->conn_flags |= ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA;
657
658	update_wqe->max_send_pdu_length = conn->max_xmit_dlength;
659	update_wqe->max_recv_pdu_length = conn->max_recv_dlength;
660	update_wqe->first_burst_length = conn->session->first_burst;
661	update_wqe->max_burst_length = conn->session->max_burst;
662	update_wqe->exp_stat_sn = conn->exp_statsn;
663	update_wqe->max_outstanding_r2ts = conn->session->max_r2t;
664	update_wqe->session_error_recovery_level = conn->session->erl;
665	iscsi_conn_printk(KERN_ALERT, conn,
666	"bnx2i: conn update - MBL 0x%x FBL 0x%x"
667	"MRDSL_I 0x%x MRDSL_T 0x%x \n",
668	update_wqe->max_burst_length,
669	update_wqe->first_burst_length,
670	update_wqe->max_recv_pdu_length,
671	update_wqe->max_send_pdu_length);
672
673	kwqe_arr[0] = (struct kwqe *) update_wqe;
674	if (hba->cnic && hba->cnic->submit_kwqes)
675	hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 1);
676	}
677
678
679	/**
680	* bnx2i_ep_ofld_timer - post iSCSI logout request WQE to hardware
681	* @t: timer context used to fetch the endpoint (transport
682	* handle) structure pointer
683	*
684	* routine to handle connection offload/destroy request timeout
685	*/
686	void bnx2i_ep_ofld_timer(struct timer_list *t)
687	{
688	struct bnx2i_endpoint *ep = from_timer(ep, t, ofld_timer);
689
690	if (ep->state == EP_STATE_OFLD_START) {
691	printk(KERN_ALERT "ofld_timer: CONN_OFLD timeout\n");
692	ep->state = EP_STATE_OFLD_FAILED;
693	} else if (ep->state == EP_STATE_DISCONN_START) {
694	printk(KERN_ALERT "ofld_timer: CONN_DISCON timeout\n");
695	ep->state = EP_STATE_DISCONN_TIMEDOUT;
696	} else if (ep->state == EP_STATE_CLEANUP_START) {
697	printk(KERN_ALERT "ofld_timer: CONN_CLEANUP timeout\n");
698	ep->state = EP_STATE_CLEANUP_FAILED;
699	}
700
701	wake_up_interruptible(&ep->ofld_wait);
702	}
703
704
705	static int bnx2i_power_of2(u32 val)
706	{
707	u32 power = 0;
708	if (val & (val - 1))
709	return power;
710	val--;
711	while (val) {
712	val = val >> 1;
713	power++;
714	}
715	return power;
716	}
717
718
719	/**
720	* bnx2i_send_cmd_cleanup_req - send iscsi cmd context clean-up request
721	* @hba: adapter structure pointer
722	* @cmd: driver command structure which is requesting
723	* a WQE to sent to chip for further processing
724	*
725	* prepares and posts CONN_OFLD_REQ1/2 KWQE
726	*/
727	void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba *hba, struct bnx2i_cmd *cmd)
728	{
729	struct bnx2i_cleanup_request *cmd_cleanup;
730
731	cmd_cleanup =
732	(struct bnx2i_cleanup_request *)cmd->conn->ep->qp.sq_prod_qe;
733	memset(cmd_cleanup, 0x00, sizeof(struct bnx2i_cleanup_request));
734
735	cmd_cleanup->op_code = ISCSI_OPCODE_CLEANUP_REQUEST;
736	cmd_cleanup->itt = cmd->req.itt;
737	cmd_cleanup->cq_index = 0; /* CQ# used for completion, 5771x only */
738
739	bnx2i_ring_dbell_update_sq_params(bnx2i_conn: cmd->conn, count: 1);
740	}
741
742
743	/**
744	* bnx2i_send_conn_destroy - initiates iscsi connection teardown process
745	* @hba: adapter structure pointer
746	* @ep: endpoint (transport identifier) structure
747	*
748	* this routine prepares and posts CONN_OFLD_REQ1/2 KWQE to initiate
749	* iscsi connection context clean-up process
750	*/
751	int bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
752	{
753	struct kwqe *kwqe_arr[2];
754	struct iscsi_kwqe_conn_destroy conn_cleanup;
755	int rc = -EINVAL;
756
757	memset(&conn_cleanup, 0x00, sizeof(struct iscsi_kwqe_conn_destroy));
758
759	conn_cleanup.hdr.op_code = ISCSI_KWQE_OPCODE_DESTROY_CONN;
760	conn_cleanup.hdr.flags =
761	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
762	/* 5771x requires conn context id to be passed as is */
763	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
764	conn_cleanup.context_id = ep->ep_cid;
765	else
766	conn_cleanup.context_id = (ep->ep_cid >> 7);
767
768	conn_cleanup.reserved0 = (u16)ep->ep_iscsi_cid;
769
770	kwqe_arr[0] = (struct kwqe *) &conn_cleanup;
771	if (hba->cnic && hba->cnic->submit_kwqes)
772	rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 1);
773
774	return rc;
775	}
776
777
778	/**
779	* bnx2i_570x_send_conn_ofld_req - initiates iscsi conn context setup process
780	* @hba: adapter structure pointer
781	* @ep: endpoint (transport identifier) structure
782	*
783	* 5706/5708/5709 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
784	*/
785	static int bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba,
786	struct bnx2i_endpoint *ep)
787	{
788	struct kwqe *kwqe_arr[2];
789	struct iscsi_kwqe_conn_offload1 ofld_req1;
790	struct iscsi_kwqe_conn_offload2 ofld_req2;
791	dma_addr_t dma_addr;
792	int num_kwqes = 2;
793	u32 *ptbl;
794	int rc = -EINVAL;
795
796	ofld_req1.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN1;
797	ofld_req1.hdr.flags =
798	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
799
800	ofld_req1.iscsi_conn_id = (u16) ep->ep_iscsi_cid;
801
802	dma_addr = ep->qp.sq_pgtbl_phys;
803	ofld_req1.sq_page_table_addr_lo = (u32) dma_addr;
804	ofld_req1.sq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
805
806	dma_addr = ep->qp.cq_pgtbl_phys;
807	ofld_req1.cq_page_table_addr_lo = (u32) dma_addr;
808	ofld_req1.cq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
809
810	ofld_req2.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN2;
811	ofld_req2.hdr.flags =
812	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
813
814	dma_addr = ep->qp.rq_pgtbl_phys;
815	ofld_req2.rq_page_table_addr_lo = (u32) dma_addr;
816	ofld_req2.rq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
817
818	ptbl = (u32 *) ep->qp.sq_pgtbl_virt;
819
820	ofld_req2.sq_first_pte.hi = *ptbl++;
821	ofld_req2.sq_first_pte.lo = *ptbl;
822
823	ptbl = (u32 *) ep->qp.cq_pgtbl_virt;
824	ofld_req2.cq_first_pte.hi = *ptbl++;
825	ofld_req2.cq_first_pte.lo = *ptbl;
826
827	kwqe_arr[0] = (struct kwqe *) &ofld_req1;
828	kwqe_arr[1] = (struct kwqe *) &ofld_req2;
829	ofld_req2.num_additional_wqes = 0;
830
831	if (hba->cnic && hba->cnic->submit_kwqes)
832	rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
833
834	return rc;
835	}
836
837
838	/**
839	* bnx2i_5771x_send_conn_ofld_req - initiates iscsi connection context creation
840	* @hba: adapter structure pointer
841	* @ep: endpoint (transport identifier) structure
842	*
843	* 57710 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
844	*/
845	static int bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba,
846	struct bnx2i_endpoint *ep)
847	{
848	struct kwqe *kwqe_arr[5];
849	struct iscsi_kwqe_conn_offload1 ofld_req1;
850	struct iscsi_kwqe_conn_offload2 ofld_req2;
851	struct iscsi_kwqe_conn_offload3 ofld_req3[1];
852	dma_addr_t dma_addr;
853	int num_kwqes = 2;
854	u32 *ptbl;
855	int rc = -EINVAL;
856
857	ofld_req1.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN1;
858	ofld_req1.hdr.flags =
859	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
860
861	ofld_req1.iscsi_conn_id = (u16) ep->ep_iscsi_cid;
862
863	dma_addr = ep->qp.sq_pgtbl_phys + ISCSI_SQ_DB_SIZE;
864	ofld_req1.sq_page_table_addr_lo = (u32) dma_addr;
865	ofld_req1.sq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
866
867	dma_addr = ep->qp.cq_pgtbl_phys + ISCSI_CQ_DB_SIZE;
868	ofld_req1.cq_page_table_addr_lo = (u32) dma_addr;
869	ofld_req1.cq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
870
871	ofld_req2.hdr.op_code = ISCSI_KWQE_OPCODE_OFFLOAD_CONN2;
872	ofld_req2.hdr.flags =
873	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
874
875	dma_addr = ep->qp.rq_pgtbl_phys + ISCSI_RQ_DB_SIZE;
876	ofld_req2.rq_page_table_addr_lo = (u32) dma_addr;
877	ofld_req2.rq_page_table_addr_hi = (u32) ((u64) dma_addr >> 32);
878
879	ptbl = (u32 *)((u8 *)ep->qp.sq_pgtbl_virt + ISCSI_SQ_DB_SIZE);
880	ofld_req2.sq_first_pte.hi = *ptbl++;
881	ofld_req2.sq_first_pte.lo = *ptbl;
882
883	ptbl = (u32 *)((u8 *)ep->qp.cq_pgtbl_virt + ISCSI_CQ_DB_SIZE);
884	ofld_req2.cq_first_pte.hi = *ptbl++;
885	ofld_req2.cq_first_pte.lo = *ptbl;
886
887	kwqe_arr[0] = (struct kwqe *) &ofld_req1;
888	kwqe_arr[1] = (struct kwqe *) &ofld_req2;
889
890	ofld_req2.num_additional_wqes = 1;
891	memset(ofld_req3, 0x00, sizeof(ofld_req3[0]));
892	ptbl = (u32 *)((u8 *)ep->qp.rq_pgtbl_virt + ISCSI_RQ_DB_SIZE);
893	ofld_req3[0].qp_first_pte[0].hi = *ptbl++;
894	ofld_req3[0].qp_first_pte[0].lo = *ptbl;
895
896	kwqe_arr[2] = (struct kwqe *) ofld_req3;
897	/* need if we decide to go with multiple KCQE's per conn */
898	num_kwqes += 1;
899
900	if (hba->cnic && hba->cnic->submit_kwqes)
901	rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes);
902
903	return rc;
904	}
905
906	/**
907	* bnx2i_send_conn_ofld_req - initiates iscsi connection context setup process
908	*
909	* @hba: adapter structure pointer
910	* @ep: endpoint (transport identifier) structure
911	*
912	* this routine prepares and posts CONN_OFLD_REQ1/2 KWQE
913	*/
914	int bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
915	{
916	int rc;
917
918	if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type))
919	rc = bnx2i_5771x_send_conn_ofld_req(hba, ep);
920	else
921	rc = bnx2i_570x_send_conn_ofld_req(hba, ep);
922
923	return rc;
924	}
925
926
927	/**
928	* setup_qp_page_tables - iscsi QP page table setup function
929	* @ep: endpoint (transport identifier) structure
930	*
931	* Sets up page tables for SQ/RQ/CQ, 1G/sec (5706/5708/5709) devices requires
932	* 64-bit address in big endian format. Whereas 10G/sec (57710) requires
933	* PT in little endian format
934	*/
935	static void setup_qp_page_tables(struct bnx2i_endpoint *ep)
936	{
937	int num_pages;
938	u32 *ptbl;
939	dma_addr_t page;
940	int cnic_dev_10g;
941
942	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
943	cnic_dev_10g = 1;
944	else
945	cnic_dev_10g = 0;
946
947	/* SQ page table */
948	memset(ep->qp.sq_pgtbl_virt, 0, ep->qp.sq_pgtbl_size);
949	num_pages = ep->qp.sq_mem_size / CNIC_PAGE_SIZE;
950	page = ep->qp.sq_phys;
951
952	if (cnic_dev_10g)
953	ptbl = (u32 *)((u8 *)ep->qp.sq_pgtbl_virt + ISCSI_SQ_DB_SIZE);
954	else
955	ptbl = (u32 *) ep->qp.sq_pgtbl_virt;
956	while (num_pages--) {
957	if (cnic_dev_10g) {
958	/* PTE is written in little endian format for 57710 */
959	*ptbl = (u32) page;
960	ptbl++;
961	*ptbl = (u32) ((u64) page >> 32);
962	ptbl++;
963	page += CNIC_PAGE_SIZE;
964	} else {
965	/* PTE is written in big endian format for
966	* 5706/5708/5709 devices */
967	*ptbl = (u32) ((u64) page >> 32);
968	ptbl++;
969	*ptbl = (u32) page;
970	ptbl++;
971	page += CNIC_PAGE_SIZE;
972	}
973	}
974
975	/* RQ page table */
976	memset(ep->qp.rq_pgtbl_virt, 0, ep->qp.rq_pgtbl_size);
977	num_pages = ep->qp.rq_mem_size / CNIC_PAGE_SIZE;
978	page = ep->qp.rq_phys;
979
980	if (cnic_dev_10g)
981	ptbl = (u32 *)((u8 *)ep->qp.rq_pgtbl_virt + ISCSI_RQ_DB_SIZE);
982	else
983	ptbl = (u32 *) ep->qp.rq_pgtbl_virt;
984	while (num_pages--) {
985	if (cnic_dev_10g) {
986	/* PTE is written in little endian format for 57710 */
987	*ptbl = (u32) page;
988	ptbl++;
989	*ptbl = (u32) ((u64) page >> 32);
990	ptbl++;
991	page += CNIC_PAGE_SIZE;
992	} else {
993	/* PTE is written in big endian format for
994	* 5706/5708/5709 devices */
995	*ptbl = (u32) ((u64) page >> 32);
996	ptbl++;
997	*ptbl = (u32) page;
998	ptbl++;
999	page += CNIC_PAGE_SIZE;
1000	}
1001	}
1002
1003	/* CQ page table */
1004	memset(ep->qp.cq_pgtbl_virt, 0, ep->qp.cq_pgtbl_size);
1005	num_pages = ep->qp.cq_mem_size / CNIC_PAGE_SIZE;
1006	page = ep->qp.cq_phys;
1007
1008	if (cnic_dev_10g)
1009	ptbl = (u32 *)((u8 *)ep->qp.cq_pgtbl_virt + ISCSI_CQ_DB_SIZE);
1010	else
1011	ptbl = (u32 *) ep->qp.cq_pgtbl_virt;
1012	while (num_pages--) {
1013	if (cnic_dev_10g) {
1014	/* PTE is written in little endian format for 57710 */
1015	*ptbl = (u32) page;
1016	ptbl++;
1017	*ptbl = (u32) ((u64) page >> 32);
1018	ptbl++;
1019	page += CNIC_PAGE_SIZE;
1020	} else {
1021	/* PTE is written in big endian format for
1022	* 5706/5708/5709 devices */
1023	*ptbl = (u32) ((u64) page >> 32);
1024	ptbl++;
1025	*ptbl = (u32) page;
1026	ptbl++;
1027	page += CNIC_PAGE_SIZE;
1028	}
1029	}
1030	}
1031
1032
1033	/**
1034	* bnx2i_alloc_qp_resc - allocates required resources for QP.
1035	* @hba: adapter structure pointer
1036	* @ep: endpoint (transport identifier) structure
1037	*
1038	* Allocate QP (transport layer for iSCSI connection) resources, DMA'able
1039	* memory for SQ/RQ/CQ and page tables. EP structure elements such
1040	* as producer/consumer indexes/pointers, queue sizes and page table
1041	* contents are setup
1042	*/
1043	int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
1044	{
1045	struct bnx2i_5771x_cq_db *cq_db;
1046
1047	ep->hba = hba;
1048	ep->conn = NULL;
1049	ep->ep_cid = ep->ep_iscsi_cid = ep->ep_pg_cid = 0;
1050
1051	/* Allocate page table memory for SQ which is page aligned */
1052	ep->qp.sq_mem_size = hba->max_sqes * BNX2I_SQ_WQE_SIZE;
1053	ep->qp.sq_mem_size =
1054	(ep->qp.sq_mem_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1055	ep->qp.sq_pgtbl_size =
1056	(ep->qp.sq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);
1057	ep->qp.sq_pgtbl_size =
1058	(ep->qp.sq_pgtbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1059
1060	ep->qp.sq_pgtbl_virt =
1061	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.sq_pgtbl_size,
1062	dma_handle: &ep->qp.sq_pgtbl_phys, GFP_KERNEL);
1063	if (!ep->qp.sq_pgtbl_virt) {
1064	printk(KERN_ALERT "bnx2i: unable to alloc SQ PT mem (%d)\n",
1065	ep->qp.sq_pgtbl_size);
1066	goto mem_alloc_err;
1067	}
1068
1069	/* Allocate memory area for actual SQ element */
1070	ep->qp.sq_virt =
1071	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.sq_mem_size,
1072	dma_handle: &ep->qp.sq_phys, GFP_KERNEL);
1073	if (!ep->qp.sq_virt) {
1074	printk(KERN_ALERT "bnx2i: unable to alloc SQ BD memory %d\n",
1075	ep->qp.sq_mem_size);
1076	goto mem_alloc_err;
1077	}
1078
1079	ep->qp.sq_first_qe = ep->qp.sq_virt;
1080	ep->qp.sq_prod_qe = ep->qp.sq_first_qe;
1081	ep->qp.sq_cons_qe = ep->qp.sq_first_qe;
1082	ep->qp.sq_last_qe = &ep->qp.sq_first_qe[hba->max_sqes - 1];
1083	ep->qp.sq_prod_idx = 0;
1084	ep->qp.sq_cons_idx = 0;
1085	ep->qp.sqe_left = hba->max_sqes;
1086
1087	/* Allocate page table memory for CQ which is page aligned */
1088	ep->qp.cq_mem_size = hba->max_cqes * BNX2I_CQE_SIZE;
1089	ep->qp.cq_mem_size =
1090	(ep->qp.cq_mem_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1091	ep->qp.cq_pgtbl_size =
1092	(ep->qp.cq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);
1093	ep->qp.cq_pgtbl_size =
1094	(ep->qp.cq_pgtbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1095
1096	ep->qp.cq_pgtbl_virt =
1097	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.cq_pgtbl_size,
1098	dma_handle: &ep->qp.cq_pgtbl_phys, GFP_KERNEL);
1099	if (!ep->qp.cq_pgtbl_virt) {
1100	printk(KERN_ALERT "bnx2i: unable to alloc CQ PT memory %d\n",
1101	ep->qp.cq_pgtbl_size);
1102	goto mem_alloc_err;
1103	}
1104
1105	/* Allocate memory area for actual CQ element */
1106	ep->qp.cq_virt =
1107	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.cq_mem_size,
1108	dma_handle: &ep->qp.cq_phys, GFP_KERNEL);
1109	if (!ep->qp.cq_virt) {
1110	printk(KERN_ALERT "bnx2i: unable to alloc CQ BD memory %d\n",
1111	ep->qp.cq_mem_size);
1112	goto mem_alloc_err;
1113	}
1114
1115	ep->qp.cq_first_qe = ep->qp.cq_virt;
1116	ep->qp.cq_prod_qe = ep->qp.cq_first_qe;
1117	ep->qp.cq_cons_qe = ep->qp.cq_first_qe;
1118	ep->qp.cq_last_qe = &ep->qp.cq_first_qe[hba->max_cqes - 1];
1119	ep->qp.cq_prod_idx = 0;
1120	ep->qp.cq_cons_idx = 0;
1121	ep->qp.cqe_left = hba->max_cqes;
1122	ep->qp.cqe_exp_seq_sn = ISCSI_INITIAL_SN;
1123	ep->qp.cqe_size = hba->max_cqes;
1124
1125	/* Invalidate all EQ CQE index, req only for 57710 */
1126	cq_db = (struct bnx2i_5771x_cq_db *) ep->qp.cq_pgtbl_virt;
1127	memset(cq_db->sqn, 0xFF, sizeof(cq_db->sqn[0]) * BNX2X_MAX_CQS);
1128
1129	/* Allocate page table memory for RQ which is page aligned */
1130	ep->qp.rq_mem_size = hba->max_rqes * BNX2I_RQ_WQE_SIZE;
1131	ep->qp.rq_mem_size =
1132	(ep->qp.rq_mem_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1133	ep->qp.rq_pgtbl_size =
1134	(ep->qp.rq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);
1135	ep->qp.rq_pgtbl_size =
1136	(ep->qp.rq_pgtbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
1137
1138	ep->qp.rq_pgtbl_virt =
1139	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.rq_pgtbl_size,
1140	dma_handle: &ep->qp.rq_pgtbl_phys, GFP_KERNEL);
1141	if (!ep->qp.rq_pgtbl_virt) {
1142	printk(KERN_ALERT "bnx2i: unable to alloc RQ PT mem %d\n",
1143	ep->qp.rq_pgtbl_size);
1144	goto mem_alloc_err;
1145	}
1146
1147	/* Allocate memory area for actual RQ element */
1148	ep->qp.rq_virt =
1149	dma_alloc_coherent(dev: &hba->pcidev->dev, size: ep->qp.rq_mem_size,
1150	dma_handle: &ep->qp.rq_phys, GFP_KERNEL);
1151	if (!ep->qp.rq_virt) {
1152	printk(KERN_ALERT "bnx2i: unable to alloc RQ BD memory %d\n",
1153	ep->qp.rq_mem_size);
1154	goto mem_alloc_err;
1155	}
1156
1157	ep->qp.rq_first_qe = ep->qp.rq_virt;
1158	ep->qp.rq_prod_qe = ep->qp.rq_first_qe;
1159	ep->qp.rq_cons_qe = ep->qp.rq_first_qe;
1160	ep->qp.rq_last_qe = &ep->qp.rq_first_qe[hba->max_rqes - 1];
1161	ep->qp.rq_prod_idx = 0x8000;
1162	ep->qp.rq_cons_idx = 0;
1163	ep->qp.rqe_left = hba->max_rqes;
1164
1165	setup_qp_page_tables(ep);
1166
1167	return 0;
1168
1169	mem_alloc_err:
1170	bnx2i_free_qp_resc(hba, ep);
1171	return -ENOMEM;
1172	}
1173
1174
1175
1176	/**
1177	* bnx2i_free_qp_resc - free memory resources held by QP
1178	* @hba: adapter structure pointer
1179	* @ep: endpoint (transport identifier) structure
1180	*
1181	* Free QP resources - SQ/RQ/CQ memory and page tables.
1182	*/
1183	void bnx2i_free_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
1184	{
1185	if (ep->qp.ctx_base) {
1186	iounmap(addr: ep->qp.ctx_base);
1187	ep->qp.ctx_base = NULL;
1188	}
1189	/* Free SQ mem */
1190	if (ep->qp.sq_pgtbl_virt) {
1191	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.sq_pgtbl_size,
1192	cpu_addr: ep->qp.sq_pgtbl_virt, dma_handle: ep->qp.sq_pgtbl_phys);
1193	ep->qp.sq_pgtbl_virt = NULL;
1194	ep->qp.sq_pgtbl_phys = 0;
1195	}
1196	if (ep->qp.sq_virt) {
1197	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.sq_mem_size,
1198	cpu_addr: ep->qp.sq_virt, dma_handle: ep->qp.sq_phys);
1199	ep->qp.sq_virt = NULL;
1200	ep->qp.sq_phys = 0;
1201	}
1202
1203	/* Free RQ mem */
1204	if (ep->qp.rq_pgtbl_virt) {
1205	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.rq_pgtbl_size,
1206	cpu_addr: ep->qp.rq_pgtbl_virt, dma_handle: ep->qp.rq_pgtbl_phys);
1207	ep->qp.rq_pgtbl_virt = NULL;
1208	ep->qp.rq_pgtbl_phys = 0;
1209	}
1210	if (ep->qp.rq_virt) {
1211	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.rq_mem_size,
1212	cpu_addr: ep->qp.rq_virt, dma_handle: ep->qp.rq_phys);
1213	ep->qp.rq_virt = NULL;
1214	ep->qp.rq_phys = 0;
1215	}
1216
1217	/* Free CQ mem */
1218	if (ep->qp.cq_pgtbl_virt) {
1219	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.cq_pgtbl_size,
1220	cpu_addr: ep->qp.cq_pgtbl_virt, dma_handle: ep->qp.cq_pgtbl_phys);
1221	ep->qp.cq_pgtbl_virt = NULL;
1222	ep->qp.cq_pgtbl_phys = 0;
1223	}
1224	if (ep->qp.cq_virt) {
1225	dma_free_coherent(dev: &hba->pcidev->dev, size: ep->qp.cq_mem_size,
1226	cpu_addr: ep->qp.cq_virt, dma_handle: ep->qp.cq_phys);
1227	ep->qp.cq_virt = NULL;
1228	ep->qp.cq_phys = 0;
1229	}
1230	}
1231
1232
1233	/**
1234	* bnx2i_send_fw_iscsi_init_msg - initiates initial handshake with iscsi f/w
1235	* @hba: adapter structure pointer
1236	*
1237	* Send down iscsi_init KWQEs which initiates the initial handshake with the f/w
1238	* This results in iSCSi support validation and on-chip context manager
1239	* initialization. Firmware completes this handshake with a CQE carrying
1240	* the result of iscsi support validation. Parameter carried by
1241	* iscsi init request determines the number of offloaded connection and
1242	* tolerance level for iscsi protocol violation this hba/chip can support
1243	*/
1244	int bnx2i_send_fw_iscsi_init_msg(struct bnx2i_hba *hba)
1245	{
1246	struct kwqe *kwqe_arr[3];
1247	struct iscsi_kwqe_init1 iscsi_init;
1248	struct iscsi_kwqe_init2 iscsi_init2;
1249	int rc = 0;
1250	u64 mask64;
1251
1252	memset(&iscsi_init, 0x00, sizeof(struct iscsi_kwqe_init1));
1253	memset(&iscsi_init2, 0x00, sizeof(struct iscsi_kwqe_init2));
1254
1255	bnx2i_adjust_qp_size(hba);
1256
1257	iscsi_init.flags =
1258	(CNIC_PAGE_BITS - 8) << ISCSI_KWQE_INIT1_PAGE_SIZE_SHIFT;
1259	if (en_tcp_dack)
1260	iscsi_init.flags |= ISCSI_KWQE_INIT1_DELAYED_ACK_ENABLE;
1261	iscsi_init.reserved0 = 0;
1262	iscsi_init.num_cqs = 1;
1263	iscsi_init.hdr.op_code = ISCSI_KWQE_OPCODE_INIT1;
1264	iscsi_init.hdr.flags =
1265	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
1266
1267	iscsi_init.dummy_buffer_addr_lo = (u32) hba->dummy_buf_dma;
1268	iscsi_init.dummy_buffer_addr_hi =
1269	(u32) ((u64) hba->dummy_buf_dma >> 32);
1270
1271	hba->num_ccell = hba->max_sqes >> 1;
1272	hba->ctx_ccell_tasks =
1273	((hba->num_ccell & 0xFFFF) | (hba->max_sqes << 16));
1274	iscsi_init.num_ccells_per_conn = hba->num_ccell;
1275	iscsi_init.num_tasks_per_conn = hba->max_sqes;
1276	iscsi_init.sq_wqes_per_page = CNIC_PAGE_SIZE / BNX2I_SQ_WQE_SIZE;
1277	iscsi_init.sq_num_wqes = hba->max_sqes;
1278	iscsi_init.cq_log_wqes_per_page =
1279	(u8) bnx2i_power_of2(CNIC_PAGE_SIZE / BNX2I_CQE_SIZE);
1280	iscsi_init.cq_num_wqes = hba->max_cqes;
1281	iscsi_init.cq_num_pages = (hba->max_cqes * BNX2I_CQE_SIZE +
1282	(CNIC_PAGE_SIZE - 1)) / CNIC_PAGE_SIZE;
1283	iscsi_init.sq_num_pages = (hba->max_sqes * BNX2I_SQ_WQE_SIZE +
1284	(CNIC_PAGE_SIZE - 1)) / CNIC_PAGE_SIZE;
1285	iscsi_init.rq_buffer_size = BNX2I_RQ_WQE_SIZE;
1286	iscsi_init.rq_num_wqes = hba->max_rqes;
1287
1288
1289	iscsi_init2.hdr.op_code = ISCSI_KWQE_OPCODE_INIT2;
1290	iscsi_init2.hdr.flags =
1291	(ISCSI_KWQE_LAYER_CODE << ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT);
1292	iscsi_init2.max_cq_sqn = hba->max_cqes * 2 + 1;
1293	mask64 = 0x0ULL;
1294	mask64 |= (
1295	/* CISCO MDS */
1296	(1UL <<
1297	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV) |
1298	/* HP MSA1510i */
1299	(1UL <<
1300	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN) |
1301	/* EMC */
1302	(1ULL << ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN));
1303	if (error_mask1) {
1304	iscsi_init2.error_bit_map[0] = error_mask1;
1305	mask64 ^= (u32)(mask64);
1306	mask64 |= error_mask1;
1307	} else
1308	iscsi_init2.error_bit_map[0] = (u32) mask64;
1309
1310	if (error_mask2) {
1311	iscsi_init2.error_bit_map[1] = error_mask2;
1312	mask64 &= 0xffffffff;
1313	mask64 |= ((u64)error_mask2 << 32);
1314	} else
1315	iscsi_init2.error_bit_map[1] = (u32) (mask64 >> 32);
1316
1317	iscsi_error_mask = mask64;
1318
1319	kwqe_arr[0] = (struct kwqe *) &iscsi_init;
1320	kwqe_arr[1] = (struct kwqe *) &iscsi_init2;
1321
1322	if (hba->cnic && hba->cnic->submit_kwqes)
1323	rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 2);
1324	return rc;
1325	}
1326
1327
1328	/**
1329	* bnx2i_process_scsi_cmd_resp - this function handles scsi cmd completion.
1330	* @session: iscsi session
1331	* @bnx2i_conn: bnx2i connection
1332	* @cqe: pointer to newly DMA'ed CQE entry for processing
1333	*
1334	* process SCSI CMD Response CQE & complete the request to SCSI-ML
1335	*/
1336	int bnx2i_process_scsi_cmd_resp(struct iscsi_session *session,
1337	struct bnx2i_conn *bnx2i_conn,
1338	struct cqe *cqe)
1339	{
1340	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1341	struct bnx2i_hba *hba = bnx2i_conn->hba;
1342	struct bnx2i_cmd_response *resp_cqe;
1343	struct bnx2i_cmd *bnx2i_cmd;
1344	struct iscsi_task *task;
1345	struct iscsi_scsi_rsp *hdr;
1346	u32 datalen = 0;
1347
1348	resp_cqe = (struct bnx2i_cmd_response *)cqe;
1349	spin_lock_bh(lock: &session->back_lock);
1350	task = iscsi_itt_to_task(conn,
1351	resp_cqe->itt & ISCSI_CMD_RESPONSE_INDEX);
1352	if (!task)
1353	goto fail;
1354
1355	bnx2i_cmd = task->dd_data;
1356
1357	if (bnx2i_cmd->req.op_attr & ISCSI_CMD_REQUEST_READ) {
1358	conn->datain_pdus_cnt +=
1359	resp_cqe->task_stat.read_stat.num_data_ins;
1360	conn->rxdata_octets +=
1361	bnx2i_cmd->req.total_data_transfer_length;
1362	ADD_STATS_64(hba, rx_pdus,
1363	resp_cqe->task_stat.read_stat.num_data_ins);
1364	ADD_STATS_64(hba, rx_bytes,
1365	bnx2i_cmd->req.total_data_transfer_length);
1366	} else {
1367	conn->dataout_pdus_cnt +=
1368	resp_cqe->task_stat.write_stat.num_data_outs;
1369	conn->r2t_pdus_cnt +=
1370	resp_cqe->task_stat.write_stat.num_r2ts;
1371	conn->txdata_octets +=
1372	bnx2i_cmd->req.total_data_transfer_length;
1373	ADD_STATS_64(hba, tx_pdus,
1374	resp_cqe->task_stat.write_stat.num_data_outs);
1375	ADD_STATS_64(hba, tx_bytes,
1376	bnx2i_cmd->req.total_data_transfer_length);
1377	ADD_STATS_64(hba, rx_pdus,
1378	resp_cqe->task_stat.write_stat.num_r2ts);
1379	}
1380	bnx2i_iscsi_unmap_sg_list(cmd: bnx2i_cmd);
1381
1382	hdr = (struct iscsi_scsi_rsp *)task->hdr;
1383	resp_cqe = (struct bnx2i_cmd_response *)cqe;
1384	hdr->opcode = resp_cqe->op_code;
1385	hdr->max_cmdsn = cpu_to_be32(resp_cqe->max_cmd_sn);
1386	hdr->exp_cmdsn = cpu_to_be32(resp_cqe->exp_cmd_sn);
1387	hdr->response = resp_cqe->response;
1388	hdr->cmd_status = resp_cqe->status;
1389	hdr->flags = resp_cqe->response_flags;
1390	hdr->residual_count = cpu_to_be32(resp_cqe->residual_count);
1391
1392	if (resp_cqe->op_code == ISCSI_OP_SCSI_DATA_IN)
1393	goto done;
1394
1395	if (resp_cqe->status == SAM_STAT_CHECK_CONDITION) {
1396	datalen = resp_cqe->data_length;
1397	if (datalen < 2)
1398	goto done;
1399
1400	if (datalen > BNX2I_RQ_WQE_SIZE) {
1401	iscsi_conn_printk(KERN_ERR, conn,
1402	"sense data len %d > RQ sz\n",
1403	datalen);
1404	datalen = BNX2I_RQ_WQE_SIZE;
1405	} else if (datalen > ISCSI_DEF_MAX_RECV_SEG_LEN) {
1406	iscsi_conn_printk(KERN_ERR, conn,
1407	"sense data len %d > conn data\n",
1408	datalen);
1409	datalen = ISCSI_DEF_MAX_RECV_SEG_LEN;
1410	}
1411
1412	bnx2i_get_rq_buf(bnx2i_conn: bnx2i_cmd->conn, ptr: conn->data, len: datalen);
1413	bnx2i_put_rq_buf(bnx2i_conn: bnx2i_cmd->conn, count: 1);
1414	}
1415
1416	done:
1417	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr,
1418	conn->data, datalen);
1419	fail:
1420	spin_unlock_bh(lock: &session->back_lock);
1421	return 0;
1422	}
1423
1424
1425	/**
1426	* bnx2i_process_login_resp - this function handles iscsi login response
1427	* @session: iscsi session pointer
1428	* @bnx2i_conn: iscsi connection pointer
1429	* @cqe: pointer to newly DMA'ed CQE entry for processing
1430	*
1431	* process Login Response CQE & complete it to open-iscsi user daemon
1432	*/
1433	static int bnx2i_process_login_resp(struct iscsi_session *session,
1434	struct bnx2i_conn *bnx2i_conn,
1435	struct cqe *cqe)
1436	{
1437	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1438	struct iscsi_task *task;
1439	struct bnx2i_login_response *login;
1440	struct iscsi_login_rsp *resp_hdr;
1441	int pld_len;
1442	int pad_len;
1443
1444	login = (struct bnx2i_login_response *) cqe;
1445	spin_lock(lock: &session->back_lock);
1446	task = iscsi_itt_to_task(conn,
1447	login->itt & ISCSI_LOGIN_RESPONSE_INDEX);
1448	if (!task)
1449	goto done;
1450
1451	resp_hdr = (struct iscsi_login_rsp *) &bnx2i_conn->gen_pdu.resp_hdr;
1452	memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
1453	resp_hdr->opcode = login->op_code;
1454	resp_hdr->flags = login->response_flags;
1455	resp_hdr->max_version = login->version_max;
1456	resp_hdr->active_version = login->version_active;
1457	resp_hdr->hlength = 0;
1458
1459	hton24(resp_hdr->dlength, login->data_length);
1460	memcpy(resp_hdr->isid, &login->isid_lo, 6);
1461	resp_hdr->tsih = cpu_to_be16(login->tsih);
1462	resp_hdr->itt = task->hdr->itt;
1463	resp_hdr->statsn = cpu_to_be32(login->stat_sn);
1464	resp_hdr->exp_cmdsn = cpu_to_be32(login->exp_cmd_sn);
1465	resp_hdr->max_cmdsn = cpu_to_be32(login->max_cmd_sn);
1466	resp_hdr->status_class = login->status_class;
1467	resp_hdr->status_detail = login->status_detail;
1468	pld_len = login->data_length;
1469	bnx2i_conn->gen_pdu.resp_wr_ptr =
1470	bnx2i_conn->gen_pdu.resp_buf + pld_len;
1471
1472	pad_len = 0;
1473	if (pld_len & 0x3)
1474	pad_len = 4 - (pld_len % 4);
1475
1476	if (pad_len) {
1477	int i = 0;
1478	for (i = 0; i < pad_len; i++) {
1479	bnx2i_conn->gen_pdu.resp_wr_ptr[0] = 0;
1480	bnx2i_conn->gen_pdu.resp_wr_ptr++;
1481	}
1482	}
1483
1484	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr,
1485	bnx2i_conn->gen_pdu.resp_buf,
1486	bnx2i_conn->gen_pdu.resp_wr_ptr - bnx2i_conn->gen_pdu.resp_buf);
1487	done:
1488	spin_unlock(lock: &session->back_lock);
1489	return 0;
1490	}
1491
1492
1493	/**
1494	* bnx2i_process_text_resp - this function handles iscsi text response
1495	* @session: iscsi session pointer
1496	* @bnx2i_conn: iscsi connection pointer
1497	* @cqe: pointer to newly DMA'ed CQE entry for processing
1498	*
1499	* process iSCSI Text Response CQE& complete it to open-iscsi user daemon
1500	*/
1501	static int bnx2i_process_text_resp(struct iscsi_session *session,
1502	struct bnx2i_conn *bnx2i_conn,
1503	struct cqe *cqe)
1504	{
1505	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1506	struct iscsi_task *task;
1507	struct bnx2i_text_response *text;
1508	struct iscsi_text_rsp *resp_hdr;
1509	int pld_len;
1510	int pad_len;
1511
1512	text = (struct bnx2i_text_response *) cqe;
1513	spin_lock(lock: &session->back_lock);
1514	task = iscsi_itt_to_task(conn, text->itt & ISCSI_LOGIN_RESPONSE_INDEX);
1515	if (!task)
1516	goto done;
1517
1518	resp_hdr = (struct iscsi_text_rsp *)&bnx2i_conn->gen_pdu.resp_hdr;
1519	memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
1520	resp_hdr->opcode = text->op_code;
1521	resp_hdr->flags = text->response_flags;
1522	resp_hdr->hlength = 0;
1523
1524	hton24(resp_hdr->dlength, text->data_length);
1525	resp_hdr->itt = task->hdr->itt;
1526	resp_hdr->ttt = cpu_to_be32(text->ttt);
1527	resp_hdr->statsn = task->hdr->exp_statsn;
1528	resp_hdr->exp_cmdsn = cpu_to_be32(text->exp_cmd_sn);
1529	resp_hdr->max_cmdsn = cpu_to_be32(text->max_cmd_sn);
1530	pld_len = text->data_length;
1531	bnx2i_conn->gen_pdu.resp_wr_ptr = bnx2i_conn->gen_pdu.resp_buf +
1532	pld_len;
1533	pad_len = 0;
1534	if (pld_len & 0x3)
1535	pad_len = 4 - (pld_len % 4);
1536
1537	if (pad_len) {
1538	int i = 0;
1539	for (i = 0; i < pad_len; i++) {
1540	bnx2i_conn->gen_pdu.resp_wr_ptr[0] = 0;
1541	bnx2i_conn->gen_pdu.resp_wr_ptr++;
1542	}
1543	}
1544	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr,
1545	bnx2i_conn->gen_pdu.resp_buf,
1546	bnx2i_conn->gen_pdu.resp_wr_ptr -
1547	bnx2i_conn->gen_pdu.resp_buf);
1548	done:
1549	spin_unlock(lock: &session->back_lock);
1550	return 0;
1551	}
1552
1553
1554	/**
1555	* bnx2i_process_tmf_resp - this function handles iscsi TMF response
1556	* @session: iscsi session pointer
1557	* @bnx2i_conn: iscsi connection pointer
1558	* @cqe: pointer to newly DMA'ed CQE entry for processing
1559	*
1560	* process iSCSI TMF Response CQE and wake up the driver eh thread.
1561	*/
1562	static int bnx2i_process_tmf_resp(struct iscsi_session *session,
1563	struct bnx2i_conn *bnx2i_conn,
1564	struct cqe *cqe)
1565	{
1566	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1567	struct iscsi_task *task;
1568	struct bnx2i_tmf_response *tmf_cqe;
1569	struct iscsi_tm_rsp *resp_hdr;
1570
1571	tmf_cqe = (struct bnx2i_tmf_response *)cqe;
1572	spin_lock(lock: &session->back_lock);
1573	task = iscsi_itt_to_task(conn,
1574	tmf_cqe->itt & ISCSI_TMF_RESPONSE_INDEX);
1575	if (!task)
1576	goto done;
1577
1578	resp_hdr = (struct iscsi_tm_rsp *) &bnx2i_conn->gen_pdu.resp_hdr;
1579	memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
1580	resp_hdr->opcode = tmf_cqe->op_code;
1581	resp_hdr->max_cmdsn = cpu_to_be32(tmf_cqe->max_cmd_sn);
1582	resp_hdr->exp_cmdsn = cpu_to_be32(tmf_cqe->exp_cmd_sn);
1583	resp_hdr->itt = task->hdr->itt;
1584	resp_hdr->response = tmf_cqe->response;
1585
1586	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0);
1587	done:
1588	spin_unlock(lock: &session->back_lock);
1589	return 0;
1590	}
1591
1592	/**
1593	* bnx2i_process_logout_resp - this function handles iscsi logout response
1594	* @session: iscsi session pointer
1595	* @bnx2i_conn: iscsi connection pointer
1596	* @cqe: pointer to newly DMA'ed CQE entry for processing
1597	*
1598	* process iSCSI Logout Response CQE & make function call to
1599	* notify the user daemon.
1600	*/
1601	static int bnx2i_process_logout_resp(struct iscsi_session *session,
1602	struct bnx2i_conn *bnx2i_conn,
1603	struct cqe *cqe)
1604	{
1605	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1606	struct iscsi_task *task;
1607	struct bnx2i_logout_response *logout;
1608	struct iscsi_logout_rsp *resp_hdr;
1609
1610	logout = (struct bnx2i_logout_response *) cqe;
1611	spin_lock(lock: &session->back_lock);
1612	task = iscsi_itt_to_task(conn,
1613	logout->itt & ISCSI_LOGOUT_RESPONSE_INDEX);
1614	if (!task)
1615	goto done;
1616
1617	resp_hdr = (struct iscsi_logout_rsp *) &bnx2i_conn->gen_pdu.resp_hdr;
1618	memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
1619	resp_hdr->opcode = logout->op_code;
1620	resp_hdr->flags = logout->response;
1621	resp_hdr->hlength = 0;
1622
1623	resp_hdr->itt = task->hdr->itt;
1624	resp_hdr->statsn = task->hdr->exp_statsn;
1625	resp_hdr->exp_cmdsn = cpu_to_be32(logout->exp_cmd_sn);
1626	resp_hdr->max_cmdsn = cpu_to_be32(logout->max_cmd_sn);
1627
1628	resp_hdr->t2wait = cpu_to_be32(logout->time_to_wait);
1629	resp_hdr->t2retain = cpu_to_be32(logout->time_to_retain);
1630
1631	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0);
1632
1633	bnx2i_conn->ep->state = EP_STATE_LOGOUT_RESP_RCVD;
1634	done:
1635	spin_unlock(lock: &session->back_lock);
1636	return 0;
1637	}
1638
1639	/**
1640	* bnx2i_process_nopin_local_cmpl - this function handles iscsi nopin CQE
1641	* @session: iscsi session pointer
1642	* @bnx2i_conn: iscsi connection pointer
1643	* @cqe: pointer to newly DMA'ed CQE entry for processing
1644	*
1645	* process iSCSI NOPIN local completion CQE, frees IIT and command structures
1646	*/
1647	static void bnx2i_process_nopin_local_cmpl(struct iscsi_session *session,
1648	struct bnx2i_conn *bnx2i_conn,
1649	struct cqe *cqe)
1650	{
1651	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1652	struct bnx2i_nop_in_msg *nop_in;
1653	struct iscsi_task *task;
1654
1655	nop_in = (struct bnx2i_nop_in_msg *)cqe;
1656	spin_lock(lock: &session->back_lock);
1657	task = iscsi_itt_to_task(conn,
1658	nop_in->itt & ISCSI_NOP_IN_MSG_INDEX);
1659	if (task)
1660	__iscsi_put_task(task);
1661	spin_unlock(lock: &session->back_lock);
1662	}
1663
1664	/**
1665	* bnx2i_unsol_pdu_adjust_rq - makes adjustments to RQ after unsol pdu is recvd
1666	* @bnx2i_conn: iscsi connection
1667	*
1668	* Firmware advances RQ producer index for every unsolicited PDU even if
1669	* payload data length is '0'. This function makes corresponding
1670	* adjustments on the driver side to match this f/w behavior
1671	*/
1672	static void bnx2i_unsol_pdu_adjust_rq(struct bnx2i_conn *bnx2i_conn)
1673	{
1674	char dummy_rq_data[2];
1675	bnx2i_get_rq_buf(bnx2i_conn, ptr: dummy_rq_data, len: 1);
1676	bnx2i_put_rq_buf(bnx2i_conn, count: 1);
1677	}
1678
1679
1680	/**
1681	* bnx2i_process_nopin_mesg - this function handles iscsi nopin CQE
1682	* @session: iscsi session pointer
1683	* @bnx2i_conn: iscsi connection pointer
1684	* @cqe: pointer to newly DMA'ed CQE entry for processing
1685	*
1686	* process iSCSI target's proactive iSCSI NOPIN request
1687	*/
1688	static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
1689	struct bnx2i_conn *bnx2i_conn,
1690	struct cqe *cqe)
1691	{
1692	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1693	struct iscsi_task *task;
1694	struct bnx2i_nop_in_msg *nop_in;
1695	struct iscsi_nopin *hdr;
1696	int tgt_async_nop = 0;
1697
1698	nop_in = (struct bnx2i_nop_in_msg *)cqe;
1699
1700	spin_lock(lock: &session->back_lock);
1701	hdr = (struct iscsi_nopin *)&bnx2i_conn->gen_pdu.resp_hdr;
1702	memset(hdr, 0, sizeof(struct iscsi_hdr));
1703	hdr->opcode = nop_in->op_code;
1704	hdr->max_cmdsn = cpu_to_be32(nop_in->max_cmd_sn);
1705	hdr->exp_cmdsn = cpu_to_be32(nop_in->exp_cmd_sn);
1706	hdr->ttt = cpu_to_be32(nop_in->ttt);
1707
1708	if (nop_in->itt == (u16) RESERVED_ITT) {
1709	bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
1710	hdr->itt = RESERVED_ITT;
1711	tgt_async_nop = 1;
1712	goto done;
1713	}
1714
1715	/* this is a response to one of our nop-outs */
1716	task = iscsi_itt_to_task(conn,
1717	(itt_t) (nop_in->itt & ISCSI_NOP_IN_MSG_INDEX));
1718	if (task) {
1719	hdr->flags = ISCSI_FLAG_CMD_FINAL;
1720	hdr->itt = task->hdr->itt;
1721	hdr->ttt = cpu_to_be32(nop_in->ttt);
1722	memcpy(&hdr->lun, nop_in->lun, 8);
1723	}
1724	done:
1725	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
1726	spin_unlock(lock: &session->back_lock);
1727
1728	return tgt_async_nop;
1729	}
1730
1731
1732	/**
1733	* bnx2i_process_async_mesg - this function handles iscsi async message
1734	* @session: iscsi session pointer
1735	* @bnx2i_conn: iscsi connection pointer
1736	* @cqe: pointer to newly DMA'ed CQE entry for processing
1737	*
1738	* process iSCSI ASYNC Message
1739	*/
1740	static void bnx2i_process_async_mesg(struct iscsi_session *session,
1741	struct bnx2i_conn *bnx2i_conn,
1742	struct cqe *cqe)
1743	{
1744	struct bnx2i_async_msg *async_cqe;
1745	struct iscsi_async *resp_hdr;
1746	u8 async_event;
1747
1748	bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
1749
1750	async_cqe = (struct bnx2i_async_msg *)cqe;
1751	async_event = async_cqe->async_event;
1752
1753	if (async_event == ISCSI_ASYNC_MSG_SCSI_EVENT) {
1754	iscsi_conn_printk(KERN_ALERT, bnx2i_conn->cls_conn->dd_data,
1755	"async: scsi events not supported\n");
1756	return;
1757	}
1758
1759	spin_lock(lock: &session->back_lock);
1760	resp_hdr = (struct iscsi_async *) &bnx2i_conn->gen_pdu.resp_hdr;
1761	memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
1762	resp_hdr->opcode = async_cqe->op_code;
1763	resp_hdr->flags = 0x80;
1764
1765	memcpy(&resp_hdr->lun, async_cqe->lun, 8);
1766	resp_hdr->exp_cmdsn = cpu_to_be32(async_cqe->exp_cmd_sn);
1767	resp_hdr->max_cmdsn = cpu_to_be32(async_cqe->max_cmd_sn);
1768
1769	resp_hdr->async_event = async_cqe->async_event;
1770	resp_hdr->async_vcode = async_cqe->async_vcode;
1771
1772	resp_hdr->param1 = cpu_to_be16(async_cqe->param1);
1773	resp_hdr->param2 = cpu_to_be16(async_cqe->param2);
1774	resp_hdr->param3 = cpu_to_be16(async_cqe->param3);
1775
1776	__iscsi_complete_pdu(bnx2i_conn->cls_conn->dd_data,
1777	(struct iscsi_hdr *)resp_hdr, NULL, 0);
1778	spin_unlock(lock: &session->back_lock);
1779	}
1780
1781
1782	/**
1783	* bnx2i_process_reject_mesg - process iscsi reject pdu
1784	* @session: iscsi session pointer
1785	* @bnx2i_conn: iscsi connection pointer
1786	* @cqe: pointer to newly DMA'ed CQE entry for processing
1787	*
1788	* process iSCSI REJECT message
1789	*/
1790	static void bnx2i_process_reject_mesg(struct iscsi_session *session,
1791	struct bnx2i_conn *bnx2i_conn,
1792	struct cqe *cqe)
1793	{
1794	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1795	struct bnx2i_reject_msg *reject;
1796	struct iscsi_reject *hdr;
1797
1798	reject = (struct bnx2i_reject_msg *) cqe;
1799	if (reject->data_length) {
1800	bnx2i_get_rq_buf(bnx2i_conn, ptr: conn->data, len: reject->data_length);
1801	bnx2i_put_rq_buf(bnx2i_conn, count: 1);
1802	} else
1803	bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
1804
1805	spin_lock(lock: &session->back_lock);
1806	hdr = (struct iscsi_reject *) &bnx2i_conn->gen_pdu.resp_hdr;
1807	memset(hdr, 0, sizeof(struct iscsi_hdr));
1808	hdr->opcode = reject->op_code;
1809	hdr->reason = reject->reason;
1810	hton24(hdr->dlength, reject->data_length);
1811	hdr->max_cmdsn = cpu_to_be32(reject->max_cmd_sn);
1812	hdr->exp_cmdsn = cpu_to_be32(reject->exp_cmd_sn);
1813	hdr->ffffffff = cpu_to_be32(RESERVED_ITT);
1814	__iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, conn->data,
1815	reject->data_length);
1816	spin_unlock(lock: &session->back_lock);
1817	}
1818
1819	/**
1820	* bnx2i_process_cmd_cleanup_resp - process scsi command clean-up completion
1821	* @session: iscsi session pointer
1822	* @bnx2i_conn: iscsi connection pointer
1823	* @cqe: pointer to newly DMA'ed CQE entry for processing
1824	*
1825	* process command cleanup response CQE during conn shutdown or error recovery
1826	*/
1827	static void bnx2i_process_cmd_cleanup_resp(struct iscsi_session *session,
1828	struct bnx2i_conn *bnx2i_conn,
1829	struct cqe *cqe)
1830	{
1831	struct bnx2i_cleanup_response *cmd_clean_rsp;
1832	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1833	struct iscsi_task *task;
1834
1835	cmd_clean_rsp = (struct bnx2i_cleanup_response *)cqe;
1836	spin_lock(lock: &session->back_lock);
1837	task = iscsi_itt_to_task(conn,
1838	cmd_clean_rsp->itt & ISCSI_CLEANUP_RESPONSE_INDEX);
1839	if (!task)
1840	printk(KERN_ALERT "bnx2i: cmd clean ITT %x not active\n",
1841	cmd_clean_rsp->itt & ISCSI_CLEANUP_RESPONSE_INDEX);
1842	spin_unlock(lock: &session->back_lock);
1843	complete(&bnx2i_conn->cmd_cleanup_cmpl);
1844	}
1845
1846
1847	/**
1848	* bnx2i_percpu_io_thread - thread per cpu for ios
1849	*
1850	* @arg: ptr to bnx2i_percpu_info structure
1851	*/
1852	int bnx2i_percpu_io_thread(void *arg)
1853	{
1854	struct bnx2i_percpu_s *p = arg;
1855	struct bnx2i_work *work, *tmp;
1856	LIST_HEAD(work_list);
1857
1858	set_user_nice(current, MIN_NICE);
1859
1860	while (!kthread_should_stop()) {
1861	spin_lock_bh(lock: &p->p_work_lock);
1862	while (!list_empty(head: &p->work_list)) {
1863	list_splice_init(list: &p->work_list, head: &work_list);
1864	spin_unlock_bh(lock: &p->p_work_lock);
1865
1866	list_for_each_entry_safe(work, tmp, &work_list, list) {
1867	list_del_init(entry: &work->list);
1868	/* work allocated in the bh, freed here */
1869	bnx2i_process_scsi_cmd_resp(session: work->session,
1870	bnx2i_conn: work->bnx2i_conn,
1871	cqe: &work->cqe);
1872	atomic_dec(v: &work->bnx2i_conn->work_cnt);
1873	kfree(objp: work);
1874	}
1875	spin_lock_bh(lock: &p->p_work_lock);
1876	}
1877	set_current_state(TASK_INTERRUPTIBLE);
1878	spin_unlock_bh(lock: &p->p_work_lock);
1879	schedule();
1880	}
1881	__set_current_state(TASK_RUNNING);
1882
1883	return 0;
1884	}
1885
1886
1887	/**
1888	* bnx2i_queue_scsi_cmd_resp - queue cmd completion to the percpu thread
1889	* @session: iscsi session
1890	* @bnx2i_conn: bnx2i connection
1891	* @cqe: pointer to newly DMA'ed CQE entry for processing
1892	*
1893	* this function is called by generic KCQ handler to queue all pending cmd
1894	* completion CQEs
1895	*
1896	* The implementation is to queue the cmd response based on the
1897	* last recorded command for the given connection. The
1898	* cpu_id gets recorded upon task_xmit. No out-of-order completion!
1899	*/
1900	static int bnx2i_queue_scsi_cmd_resp(struct iscsi_session *session,
1901	struct bnx2i_conn *bnx2i_conn,
1902	struct bnx2i_nop_in_msg *cqe)
1903	{
1904	struct bnx2i_work *bnx2i_work = NULL;
1905	struct bnx2i_percpu_s *p = NULL;
1906	struct iscsi_task *task;
1907	struct scsi_cmnd *sc;
1908	int rc = 0;
1909
1910	spin_lock(lock: &session->back_lock);
1911	task = iscsi_itt_to_task(bnx2i_conn->cls_conn->dd_data,
1912	cqe->itt & ISCSI_CMD_RESPONSE_INDEX);
1913	if (!task || !task->sc) {
1914	spin_unlock(lock: &session->back_lock);
1915	return -EINVAL;
1916	}
1917	sc = task->sc;
1918
1919	spin_unlock(lock: &session->back_lock);
1920
1921	p = &per_cpu(bnx2i_percpu, blk_mq_rq_cpu(scsi_cmd_to_rq(sc)));
1922	spin_lock(lock: &p->p_work_lock);
1923	if (unlikely(!p->iothread)) {
1924	rc = -EINVAL;
1925	goto err;
1926	}
1927	/* Alloc and copy to the cqe */
1928	bnx2i_work = kzalloc(size: sizeof(struct bnx2i_work), GFP_ATOMIC);
1929	if (bnx2i_work) {
1930	INIT_LIST_HEAD(list: &bnx2i_work->list);
1931	bnx2i_work->session = session;
1932	bnx2i_work->bnx2i_conn = bnx2i_conn;
1933	memcpy(&bnx2i_work->cqe, cqe, sizeof(struct cqe));
1934	list_add_tail(new: &bnx2i_work->list, head: &p->work_list);
1935	atomic_inc(v: &bnx2i_conn->work_cnt);
1936	wake_up_process(tsk: p->iothread);
1937	spin_unlock(lock: &p->p_work_lock);
1938	goto done;
1939	} else
1940	rc = -ENOMEM;
1941	err:
1942	spin_unlock(lock: &p->p_work_lock);
1943	bnx2i_process_scsi_cmd_resp(session, bnx2i_conn, cqe: (struct cqe *)cqe);
1944	done:
1945	return rc;
1946	}
1947
1948
1949	/**
1950	* bnx2i_process_new_cqes - process newly DMA'ed CQE's
1951	* @bnx2i_conn: bnx2i connection
1952	*
1953	* this function is called by generic KCQ handler to process all pending CQE's
1954	*/
1955	static int bnx2i_process_new_cqes(struct bnx2i_conn *bnx2i_conn)
1956	{
1957	struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data;
1958	struct iscsi_session *session = conn->session;
1959	struct bnx2i_hba *hba = bnx2i_conn->hba;
1960	struct qp_info *qp;
1961	struct bnx2i_nop_in_msg *nopin;
1962	int tgt_async_msg;
1963	int cqe_cnt = 0;
1964
1965	if (bnx2i_conn->ep == NULL)
1966	return 0;
1967
1968	qp = &bnx2i_conn->ep->qp;
1969
1970	if (!qp->cq_virt) {
1971	printk(KERN_ALERT "bnx2i (%s): cq resr freed in bh execution!",
1972	hba->netdev->name);
1973	goto out;
1974	}
1975	while (1) {
1976	nopin = (struct bnx2i_nop_in_msg *) qp->cq_cons_qe;
1977	if (nopin->cq_req_sn != qp->cqe_exp_seq_sn)
1978	break;
1979
1980	if (unlikely(test_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags))) {
1981	if (nopin->op_code == ISCSI_OP_NOOP_IN &&
1982	nopin->itt == (u16) RESERVED_ITT) {
1983	printk(KERN_ALERT "bnx2i: Unsolicited "
1984	"NOP-In detected for suspended "
1985	"connection dev=%s!\n",
1986	hba->netdev->name);
1987	bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
1988	goto cqe_out;
1989	}
1990	break;
1991	}
1992	tgt_async_msg = 0;
1993
1994	switch (nopin->op_code) {
1995	case ISCSI_OP_SCSI_CMD_RSP:
1996	case ISCSI_OP_SCSI_DATA_IN:
1997	/* Run the kthread engine only for data cmds
1998	All other cmds will be completed in this bh! */
1999	bnx2i_queue_scsi_cmd_resp(session, bnx2i_conn, cqe: nopin);
2000	goto done;
2001	case ISCSI_OP_LOGIN_RSP:
2002	bnx2i_process_login_resp(session, bnx2i_conn,
2003	cqe: qp->cq_cons_qe);
2004	break;
2005	case ISCSI_OP_SCSI_TMFUNC_RSP:
2006	bnx2i_process_tmf_resp(session, bnx2i_conn,
2007	cqe: qp->cq_cons_qe);
2008	break;
2009	case ISCSI_OP_TEXT_RSP:
2010	bnx2i_process_text_resp(session, bnx2i_conn,
2011	cqe: qp->cq_cons_qe);
2012	break;
2013	case ISCSI_OP_LOGOUT_RSP:
2014	bnx2i_process_logout_resp(session, bnx2i_conn,
2015	cqe: qp->cq_cons_qe);
2016	break;
2017	case ISCSI_OP_NOOP_IN:
2018	if (bnx2i_process_nopin_mesg(session, bnx2i_conn,
2019	cqe: qp->cq_cons_qe))
2020	tgt_async_msg = 1;
2021	break;
2022	case ISCSI_OPCODE_NOPOUT_LOCAL_COMPLETION:
2023	bnx2i_process_nopin_local_cmpl(session, bnx2i_conn,
2024	cqe: qp->cq_cons_qe);
2025	break;
2026	case ISCSI_OP_ASYNC_EVENT:
2027	bnx2i_process_async_mesg(session, bnx2i_conn,
2028	cqe: qp->cq_cons_qe);
2029	tgt_async_msg = 1;
2030	break;
2031	case ISCSI_OP_REJECT:
2032	bnx2i_process_reject_mesg(session, bnx2i_conn,
2033	cqe: qp->cq_cons_qe);
2034	break;
2035	case ISCSI_OPCODE_CLEANUP_RESPONSE:
2036	bnx2i_process_cmd_cleanup_resp(session, bnx2i_conn,
2037	cqe: qp->cq_cons_qe);
2038	break;
2039	default:
2040	printk(KERN_ALERT "bnx2i: unknown opcode 0x%x\n",
2041	nopin->op_code);
2042	}
2043
2044	ADD_STATS_64(hba, rx_pdus, 1);
2045	ADD_STATS_64(hba, rx_bytes, nopin->data_length);
2046	done:
2047	if (!tgt_async_msg) {
2048	if (!atomic_read(v: &bnx2i_conn->ep->num_active_cmds))
2049	printk(KERN_ALERT "bnx2i (%s): no active cmd! "
2050	"op 0x%x\n",
2051	hba->netdev->name,
2052	nopin->op_code);
2053	else
2054	atomic_dec(v: &bnx2i_conn->ep->num_active_cmds);
2055	}
2056	cqe_out:
2057	/* clear out in production version only, till beta keep opcode
2058	* field intact, will be helpful in debugging (context dump)
2059	* nopin->op_code = 0;
2060	*/
2061	cqe_cnt++;
2062	qp->cqe_exp_seq_sn++;
2063	if (qp->cqe_exp_seq_sn == (qp->cqe_size * 2 + 1))
2064	qp->cqe_exp_seq_sn = ISCSI_INITIAL_SN;
2065
2066	if (qp->cq_cons_qe == qp->cq_last_qe) {
2067	qp->cq_cons_qe = qp->cq_first_qe;
2068	qp->cq_cons_idx = 0;
2069	} else {
2070	qp->cq_cons_qe++;
2071	qp->cq_cons_idx++;
2072	}
2073	}
2074	out:
2075	return cqe_cnt;
2076	}
2077
2078	/**
2079	* bnx2i_fastpath_notification - process global event queue (KCQ)
2080	* @hba: adapter structure pointer
2081	* @new_cqe_kcqe: pointer to newly DMA'ed KCQE entry
2082	*
2083	* Fast path event notification handler, KCQ entry carries context id
2084	* of the connection that has 1 or more pending CQ entries
2085	*/
2086	static void bnx2i_fastpath_notification(struct bnx2i_hba *hba,
2087	struct iscsi_kcqe *new_cqe_kcqe)
2088	{
2089	struct bnx2i_conn *bnx2i_conn;
2090	u32 iscsi_cid;
2091	int nxt_idx;
2092
2093	iscsi_cid = new_cqe_kcqe->iscsi_conn_id;
2094	bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
2095
2096	if (!bnx2i_conn) {
2097	printk(KERN_ALERT "cid #%x not valid\n", iscsi_cid);
2098	return;
2099	}
2100	if (!bnx2i_conn->ep) {
2101	printk(KERN_ALERT "cid #%x - ep not bound\n", iscsi_cid);
2102	return;
2103	}
2104
2105	bnx2i_process_new_cqes(bnx2i_conn);
2106	nxt_idx = bnx2i_arm_cq_event_coalescing(ep: bnx2i_conn->ep,
2107	CNIC_ARM_CQE_FP);
2108	if (nxt_idx && nxt_idx == bnx2i_process_new_cqes(bnx2i_conn))
2109	bnx2i_arm_cq_event_coalescing(ep: bnx2i_conn->ep, CNIC_ARM_CQE_FP);
2110	}
2111
2112
2113	/**
2114	* bnx2i_process_update_conn_cmpl - process iscsi conn update completion KCQE
2115	* @hba: adapter structure pointer
2116	* @update_kcqe: kcqe pointer
2117	*
2118	* CONN_UPDATE completion handler, this completes iSCSI connection FFP migration
2119	*/
2120	static void bnx2i_process_update_conn_cmpl(struct bnx2i_hba *hba,
2121	struct iscsi_kcqe *update_kcqe)
2122	{
2123	struct bnx2i_conn *conn;
2124	u32 iscsi_cid;
2125
2126	iscsi_cid = update_kcqe->iscsi_conn_id;
2127	conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
2128
2129	if (!conn) {
2130	printk(KERN_ALERT "conn_update: cid %x not valid\n", iscsi_cid);
2131	return;
2132	}
2133	if (!conn->ep) {
2134	printk(KERN_ALERT "cid %x does not have ep bound\n", iscsi_cid);
2135	return;
2136	}
2137
2138	if (update_kcqe->completion_status) {
2139	printk(KERN_ALERT "request failed cid %x\n", iscsi_cid);
2140	conn->ep->state = EP_STATE_ULP_UPDATE_FAILED;
2141	} else
2142	conn->ep->state = EP_STATE_ULP_UPDATE_COMPL;
2143
2144	wake_up_interruptible(&conn->ep->ofld_wait);
2145	}
2146
2147
2148	/**
2149	* bnx2i_recovery_que_add_conn - add connection to recovery queue
2150	* @hba: adapter structure pointer
2151	* @bnx2i_conn: iscsi connection
2152	*
2153	* Add connection to recovery queue and schedule adapter eh worker
2154	*/
2155	static void bnx2i_recovery_que_add_conn(struct bnx2i_hba *hba,
2156	struct bnx2i_conn *bnx2i_conn)
2157	{
2158	iscsi_conn_failure(conn: bnx2i_conn->cls_conn->dd_data,
2159	err: ISCSI_ERR_CONN_FAILED);
2160	}
2161
2162
2163	/**
2164	* bnx2i_process_tcp_error - process error notification on a given connection
2165	*
2166	* @hba: adapter structure pointer
2167	* @tcp_err: tcp error kcqe pointer
2168	*
2169	* handles tcp level error notifications from FW.
2170	*/
2171	static void bnx2i_process_tcp_error(struct bnx2i_hba *hba,
2172	struct iscsi_kcqe *tcp_err)
2173	{
2174	struct bnx2i_conn *bnx2i_conn;
2175	u32 iscsi_cid;
2176
2177	iscsi_cid = tcp_err->iscsi_conn_id;
2178	bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
2179
2180	if (!bnx2i_conn) {
2181	printk(KERN_ALERT "bnx2i - cid 0x%x not valid\n", iscsi_cid);
2182	return;
2183	}
2184
2185	printk(KERN_ALERT "bnx2i - cid 0x%x had TCP errors, error code 0x%x\n",
2186	iscsi_cid, tcp_err->completion_status);
2187	bnx2i_recovery_que_add_conn(hba: bnx2i_conn->hba, bnx2i_conn);
2188	}
2189
2190
2191	/**
2192	* bnx2i_process_iscsi_error - process error notification on a given connection
2193	* @hba: adapter structure pointer
2194	* @iscsi_err: iscsi error kcqe pointer
2195	*
2196	* handles iscsi error notifications from the FW. Firmware based in initial
2197	* handshake classifies iscsi protocol / TCP rfc violation into either
2198	* warning or error indications. If indication is of "Error" type, driver
2199	* will initiate session recovery for that connection/session. For
2200	* "Warning" type indication, driver will put out a system log message
2201	* (there will be only one message for each type for the life of the
2202	* session, this is to avoid un-necessarily overloading the system)
2203	*/
2204	static void bnx2i_process_iscsi_error(struct bnx2i_hba *hba,
2205	struct iscsi_kcqe *iscsi_err)
2206	{
2207	struct bnx2i_conn *bnx2i_conn;
2208	u32 iscsi_cid;
2209	const char *additional_notice = "";
2210	const char *message;
2211	int need_recovery;
2212	u64 err_mask64;
2213
2214	iscsi_cid = iscsi_err->iscsi_conn_id;
2215	bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
2216	if (!bnx2i_conn) {
2217	printk(KERN_ALERT "bnx2i - cid 0x%x not valid\n", iscsi_cid);
2218	return;
2219	}
2220
2221	err_mask64 = (0x1ULL << iscsi_err->completion_status);
2222
2223	if (err_mask64 & iscsi_error_mask) {
2224	need_recovery = 0;
2225	message = "iscsi_warning";
2226	} else {
2227	need_recovery = 1;
2228	message = "iscsi_error";
2229	}
2230
2231	switch (iscsi_err->completion_status) {
2232	case ISCSI_KCQE_COMPLETION_STATUS_HDR_DIG_ERR:
2233	additional_notice = "hdr digest err";
2234	break;
2235	case ISCSI_KCQE_COMPLETION_STATUS_DATA_DIG_ERR:
2236	additional_notice = "data digest err";
2237	break;
2238	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_OPCODE:
2239	additional_notice = "wrong opcode rcvd";
2240	break;
2241	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_AHS_LEN:
2242	additional_notice = "AHS len > 0 rcvd";
2243	break;
2244	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ITT:
2245	additional_notice = "invalid ITT rcvd";
2246	break;
2247	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_STATSN:
2248	additional_notice = "wrong StatSN rcvd";
2249	break;
2250	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN:
2251	additional_notice = "wrong DataSN rcvd";
2252	break;
2253	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T:
2254	additional_notice = "pend R2T violation";
2255	break;
2256	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_0:
2257	additional_notice = "ERL0, UO";
2258	break;
2259	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_1:
2260	additional_notice = "ERL0, U1";
2261	break;
2262	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_2:
2263	additional_notice = "ERL0, U2";
2264	break;
2265	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_3:
2266	additional_notice = "ERL0, U3";
2267	break;
2268	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_4:
2269	additional_notice = "ERL0, U4";
2270	break;
2271	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_5:
2272	additional_notice = "ERL0, U5";
2273	break;
2274	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_6:
2275	additional_notice = "ERL0, U6";
2276	break;
2277	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_RCV_LEN:
2278	additional_notice = "invalid resi len";
2279	break;
2280	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_RCV_PDU_LEN:
2281	additional_notice = "MRDSL violation";
2282	break;
2283	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_F_BIT_ZERO:
2284	additional_notice = "F-bit not set";
2285	break;
2286	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV:
2287	additional_notice = "invalid TTT";
2288	break;
2289	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATASN:
2290	additional_notice = "invalid DataSN";
2291	break;
2292	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_BURST_LEN:
2293	additional_notice = "burst len violation";
2294	break;
2295	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_BUFFER_OFF:
2296	additional_notice = "buf offset violation";
2297	break;
2298	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN:
2299	additional_notice = "invalid LUN field";
2300	break;
2301	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_R2TSN:
2302	additional_notice = "invalid R2TSN field";
2303	break;
2304	#define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0 \
2305	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_0
2306	case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0:
2307	additional_notice = "invalid cmd len1";
2308	break;
2309	#define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1 \
2310	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_1
2311	case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1:
2312	additional_notice = "invalid cmd len2";
2313	break;
2314	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_EXCEED:
2315	additional_notice = "pend r2t exceeds MaxOutstandingR2T value";
2316	break;
2317	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_IS_RSRV:
2318	additional_notice = "TTT is rsvd";
2319	break;
2320	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_BURST_LEN:
2321	additional_notice = "MBL violation";
2322	break;
2323	#define BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO \
2324	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATA_SEG_LEN_NOT_ZERO
2325	case BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO:
2326	additional_notice = "data seg len != 0";
2327	break;
2328	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REJECT_PDU_LEN:
2329	additional_notice = "reject pdu len error";
2330	break;
2331	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ASYNC_PDU_LEN:
2332	additional_notice = "async pdu len error";
2333	break;
2334	case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_NOPIN_PDU_LEN:
2335	additional_notice = "nopin pdu len error";
2336	break;
2337	#define BNX2_ERR_PEND_R2T_IN_CLEANUP \
2338	ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_IN_CLEANUP
2339	case BNX2_ERR_PEND_R2T_IN_CLEANUP:
2340	additional_notice = "pend r2t in cleanup";
2341	break;
2342
2343	case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_FRAGMENT:
2344	additional_notice = "IP fragments rcvd";
2345	break;
2346	case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_OPTIONS:
2347	additional_notice = "IP options error";
2348	break;
2349	case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_URGENT_FLAG:
2350	additional_notice = "urgent flag error";
2351	break;
2352	default:
2353	printk(KERN_ALERT "iscsi_err - unknown err %x\n",
2354	iscsi_err->completion_status);
2355	}
2356
2357	if (need_recovery) {
2358	iscsi_conn_printk(KERN_ALERT,
2359	bnx2i_conn->cls_conn->dd_data,
2360	"bnx2i: %s - %s\n",
2361	message, additional_notice);
2362
2363	iscsi_conn_printk(KERN_ALERT,
2364	bnx2i_conn->cls_conn->dd_data,
2365	"conn_err - hostno %d conn %p, "
2366	"iscsi_cid %x cid %x\n",
2367	bnx2i_conn->hba->shost->host_no,
2368	bnx2i_conn, bnx2i_conn->ep->ep_iscsi_cid,
2369	bnx2i_conn->ep->ep_cid);
2370	bnx2i_recovery_que_add_conn(hba: bnx2i_conn->hba, bnx2i_conn);
2371	} else
2372	if (!test_and_set_bit(nr: iscsi_err->completion_status,
2373	addr: (void *) &bnx2i_conn->violation_notified))
2374	iscsi_conn_printk(KERN_ALERT,
2375	bnx2i_conn->cls_conn->dd_data,
2376	"bnx2i: %s - %s\n",
2377	message, additional_notice);
2378	}
2379
2380
2381	/**
2382	* bnx2i_process_conn_destroy_cmpl - process iscsi conn destroy completion
2383	* @hba: adapter structure pointer
2384	* @conn_destroy: conn destroy kcqe pointer
2385	*
2386	* handles connection destroy completion request.
2387	*/
2388	static void bnx2i_process_conn_destroy_cmpl(struct bnx2i_hba *hba,
2389	struct iscsi_kcqe *conn_destroy)
2390	{
2391	struct bnx2i_endpoint *ep;
2392
2393	ep = bnx2i_find_ep_in_destroy_list(hba, iscsi_cid: conn_destroy->iscsi_conn_id);
2394	if (!ep) {
2395	printk(KERN_ALERT "bnx2i_conn_destroy_cmpl: no pending "
2396	"offload request, unexpected completion\n");
2397	return;
2398	}
2399
2400	if (hba != ep->hba) {
2401	printk(KERN_ALERT "conn destroy- error hba mismatch\n");
2402	return;
2403	}
2404
2405	if (conn_destroy->completion_status) {
2406	printk(KERN_ALERT "conn_destroy_cmpl: op failed\n");
2407	ep->state = EP_STATE_CLEANUP_FAILED;
2408	} else
2409	ep->state = EP_STATE_CLEANUP_CMPL;
2410	wake_up_interruptible(&ep->ofld_wait);
2411	}
2412
2413
2414	/**
2415	* bnx2i_process_ofld_cmpl - process initial iscsi conn offload completion
2416	* @hba: adapter structure pointer
2417	* @ofld_kcqe: conn offload kcqe pointer
2418	*
2419	* handles initial connection offload completion, ep_connect() thread is
2420	* woken-up to continue with LLP connect process
2421	*/
2422	static void bnx2i_process_ofld_cmpl(struct bnx2i_hba *hba,
2423	struct iscsi_kcqe *ofld_kcqe)
2424	{
2425	u32 cid_addr;
2426	struct bnx2i_endpoint *ep;
2427
2428	ep = bnx2i_find_ep_in_ofld_list(hba, iscsi_cid: ofld_kcqe->iscsi_conn_id);
2429	if (!ep) {
2430	printk(KERN_ALERT "ofld_cmpl: no pend offload request\n");
2431	return;
2432	}
2433
2434	if (hba != ep->hba) {
2435	printk(KERN_ALERT "ofld_cmpl: error hba mismatch\n");
2436	return;
2437	}
2438
2439	if (ofld_kcqe->completion_status) {
2440	ep->state = EP_STATE_OFLD_FAILED;
2441	if (ofld_kcqe->completion_status ==
2442	ISCSI_KCQE_COMPLETION_STATUS_CTX_ALLOC_FAILURE)
2443	printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - unable "
2444	"to allocate iSCSI context resources\n",
2445	hba->netdev->name);
2446	else if (ofld_kcqe->completion_status ==
2447	ISCSI_KCQE_COMPLETION_STATUS_INVALID_OPCODE)
2448	printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - invalid "
2449	"opcode\n", hba->netdev->name);
2450	else if (ofld_kcqe->completion_status ==
2451	ISCSI_KCQE_COMPLETION_STATUS_CID_BUSY)
2452	/* error status code valid only for 5771x chipset */
2453	ep->state = EP_STATE_OFLD_FAILED_CID_BUSY;
2454	else
2455	printk(KERN_ALERT "bnx2i (%s): ofld1 cmpl - invalid "
2456	"error code %d\n", hba->netdev->name,
2457	ofld_kcqe->completion_status);
2458	} else {
2459	ep->state = EP_STATE_OFLD_COMPL;
2460	cid_addr = ofld_kcqe->iscsi_conn_context_id;
2461	ep->ep_cid = cid_addr;
2462	ep->qp.ctx_base = NULL;
2463	}
2464	wake_up_interruptible(&ep->ofld_wait);
2465	}
2466
2467	/**
2468	* bnx2i_indicate_kcqe - process iscsi conn update completion KCQE
2469	* @context: adapter structure pointer
2470	* @kcqe: kcqe pointer
2471	* @num_cqe: number of kcqes to process
2472	*
2473	* Generic KCQ event handler/dispatcher
2474	*/
2475	static void bnx2i_indicate_kcqe(void *context, struct kcqe *kcqe[],
2476	u32 num_cqe)
2477	{
2478	struct bnx2i_hba *hba = context;
2479	int i = 0;
2480	struct iscsi_kcqe *ikcqe = NULL;
2481
2482	while (i < num_cqe) {
2483	ikcqe = (struct iscsi_kcqe *) kcqe[i++];
2484
2485	if (ikcqe->op_code ==
2486	ISCSI_KCQE_OPCODE_CQ_EVENT_NOTIFICATION)
2487	bnx2i_fastpath_notification(hba, new_cqe_kcqe: ikcqe);
2488	else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_OFFLOAD_CONN)
2489	bnx2i_process_ofld_cmpl(hba, ofld_kcqe: ikcqe);
2490	else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_UPDATE_CONN)
2491	bnx2i_process_update_conn_cmpl(hba, update_kcqe: ikcqe);
2492	else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_INIT) {
2493	if (ikcqe->completion_status !=
2494	ISCSI_KCQE_COMPLETION_STATUS_SUCCESS)
2495	bnx2i_iscsi_license_error(hba, error_code: ikcqe->\
2496	completion_status);
2497	else {
2498	set_bit(ADAPTER_STATE_UP, addr: &hba->adapter_state);
2499	bnx2i_get_link_state(hba);
2500	printk(KERN_INFO "bnx2i [%.2x:%.2x.%.2x]: "
2501	"ISCSI_INIT passed\n",
2502	(u8)hba->pcidev->bus->number,
2503	hba->pci_devno,
2504	(u8)hba->pci_func);
2505
2506
2507	}
2508	} else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_DESTROY_CONN)
2509	bnx2i_process_conn_destroy_cmpl(hba, conn_destroy: ikcqe);
2510	else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_ISCSI_ERROR)
2511	bnx2i_process_iscsi_error(hba, iscsi_err: ikcqe);
2512	else if (ikcqe->op_code == ISCSI_KCQE_OPCODE_TCP_ERROR)
2513	bnx2i_process_tcp_error(hba, tcp_err: ikcqe);
2514	else
2515	printk(KERN_ALERT "bnx2i: unknown opcode 0x%x\n",
2516	ikcqe->op_code);
2517	}
2518	}
2519
2520
2521	/**
2522	* bnx2i_indicate_netevent - Generic netdev event handler
2523	* @context: adapter structure pointer
2524	* @event: event type
2525	* @vlan_id: vlans id - associated vlan id with this event
2526	*
2527	* Handles four netdev events, NETDEV_UP, NETDEV_DOWN,
2528	* NETDEV_GOING_DOWN and NETDEV_CHANGE
2529	*/
2530	static void bnx2i_indicate_netevent(void *context, unsigned long event,
2531	u16 vlan_id)
2532	{
2533	struct bnx2i_hba *hba = context;
2534
2535	/* Ignore all netevent coming from vlans */
2536	if (vlan_id != 0)
2537	return;
2538
2539	switch (event) {
2540	case NETDEV_UP:
2541	if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state))
2542	bnx2i_send_fw_iscsi_init_msg(hba);
2543	break;
2544	case NETDEV_DOWN:
2545	clear_bit(ADAPTER_STATE_GOING_DOWN, addr: &hba->adapter_state);
2546	clear_bit(ADAPTER_STATE_UP, addr: &hba->adapter_state);
2547	break;
2548	case NETDEV_GOING_DOWN:
2549	set_bit(ADAPTER_STATE_GOING_DOWN, addr: &hba->adapter_state);
2550	iscsi_host_for_each_session(shost: hba->shost,
2551	fn: bnx2i_drop_session);
2552	break;
2553	case NETDEV_CHANGE:
2554	bnx2i_get_link_state(hba);
2555	break;
2556	default:
2557	;
2558	}
2559	}
2560
2561
2562	/**
2563	* bnx2i_cm_connect_cmpl - process iscsi conn establishment completion
2564	* @cm_sk: cnic sock structure pointer
2565	*
2566	* function callback exported via bnx2i - cnic driver interface to
2567	* indicate completion of option-2 TCP connect request.
2568	*/
2569	static void bnx2i_cm_connect_cmpl(struct cnic_sock *cm_sk)
2570	{
2571	struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
2572
2573	if (test_bit(ADAPTER_STATE_GOING_DOWN, &ep->hba->adapter_state))
2574	ep->state = EP_STATE_CONNECT_FAILED;
2575	else if (test_bit(SK_F_OFFLD_COMPLETE, &cm_sk->flags))
2576	ep->state = EP_STATE_CONNECT_COMPL;
2577	else
2578	ep->state = EP_STATE_CONNECT_FAILED;
2579
2580	wake_up_interruptible(&ep->ofld_wait);
2581	}
2582
2583
2584	/**
2585	* bnx2i_cm_close_cmpl - process tcp conn close completion
2586	* @cm_sk: cnic sock structure pointer
2587	*
2588	* function callback exported via bnx2i - cnic driver interface to
2589	* indicate completion of option-2 graceful TCP connect shutdown
2590	*/
2591	static void bnx2i_cm_close_cmpl(struct cnic_sock *cm_sk)
2592	{
2593	struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
2594
2595	ep->state = EP_STATE_DISCONN_COMPL;
2596	wake_up_interruptible(&ep->ofld_wait);
2597	}
2598
2599
2600	/**
2601	* bnx2i_cm_abort_cmpl - process abortive tcp conn teardown completion
2602	* @cm_sk: cnic sock structure pointer
2603	*
2604	* function callback exported via bnx2i - cnic driver interface to
2605	* indicate completion of option-2 abortive TCP connect termination
2606	*/
2607	static void bnx2i_cm_abort_cmpl(struct cnic_sock *cm_sk)
2608	{
2609	struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
2610
2611	ep->state = EP_STATE_DISCONN_COMPL;
2612	wake_up_interruptible(&ep->ofld_wait);
2613	}
2614
2615
2616	/**
2617	* bnx2i_cm_remote_close - process received TCP FIN
2618	* @cm_sk: cnic sock structure pointer
2619	*
2620	* function callback exported via bnx2i - cnic driver interface to indicate
2621	* async TCP events such as FIN
2622	*/
2623	static void bnx2i_cm_remote_close(struct cnic_sock *cm_sk)
2624	{
2625	struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
2626
2627	ep->state = EP_STATE_TCP_FIN_RCVD;
2628	if (ep->conn)
2629	bnx2i_recovery_que_add_conn(hba: ep->hba, bnx2i_conn: ep->conn);
2630	}
2631
2632	/**
2633	* bnx2i_cm_remote_abort - process TCP RST and start conn cleanup
2634	* @cm_sk: cnic sock structure pointer
2635	*
2636	* function callback exported via bnx2i - cnic driver interface to
2637	* indicate async TCP events (RST) sent by the peer.
2638	*/
2639	static void bnx2i_cm_remote_abort(struct cnic_sock *cm_sk)
2640	{
2641	struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context;
2642	u32 old_state = ep->state;
2643
2644	ep->state = EP_STATE_TCP_RST_RCVD;
2645	if (old_state == EP_STATE_DISCONN_START)
2646	wake_up_interruptible(&ep->ofld_wait);
2647	else
2648	if (ep->conn)
2649	bnx2i_recovery_que_add_conn(hba: ep->hba, bnx2i_conn: ep->conn);
2650	}
2651
2652
2653	static int bnx2i_send_nl_mesg(void *context, u32 msg_type,
2654	char *buf, u16 buflen)
2655	{
2656	struct bnx2i_hba *hba = context;
2657	int rc;
2658
2659	if (!hba)
2660	return -ENODEV;
2661
2662	rc = iscsi_offload_mesg(shost: hba->shost, transport: &bnx2i_iscsi_transport,
2663	type: msg_type, data: buf, data_size: buflen);
2664	if (rc)
2665	printk(KERN_ALERT "bnx2i: private nl message send error\n");
2666
2667	return rc;
2668	}
2669
2670
2671	/*
2672	* bnx2i_cnic_cb - global template of bnx2i - cnic driver interface structure
2673	* carrying callback function pointers
2674	*/
2675	struct cnic_ulp_ops bnx2i_cnic_cb = {
2676	.cnic_init = bnx2i_ulp_init,
2677	.cnic_exit = bnx2i_ulp_exit,
2678	.cnic_start = bnx2i_start,
2679	.cnic_stop = bnx2i_stop,
2680	.indicate_kcqes = bnx2i_indicate_kcqe,
2681	.indicate_netevent = bnx2i_indicate_netevent,
2682	.cm_connect_complete = bnx2i_cm_connect_cmpl,
2683	.cm_close_complete = bnx2i_cm_close_cmpl,
2684	.cm_abort_complete = bnx2i_cm_abort_cmpl,
2685	.cm_remote_close = bnx2i_cm_remote_close,
2686	.cm_remote_abort = bnx2i_cm_remote_abort,
2687	.iscsi_nl_send_msg = bnx2i_send_nl_mesg,
2688	.cnic_get_stats = bnx2i_get_stats,
2689	.owner = THIS_MODULE
2690	};
2691
2692
2693	/**
2694	* bnx2i_map_ep_dbell_regs - map connection doorbell registers
2695	* @ep: bnx2i endpoint
2696	*
2697	* maps connection's SQ and RQ doorbell registers, 5706/5708/5709 hosts these
2698	* register in BAR #0. Whereas in 57710 these register are accessed by
2699	* mapping BAR #1
2700	*/
2701	int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep)
2702	{
2703	u32 cid_num;
2704	u32 reg_off;
2705	u32 first_l4l5;
2706	u32 ctx_sz;
2707	u32 config2;
2708	resource_size_t reg_base;
2709
2710	cid_num = bnx2i_get_cid_num(ep);
2711
2712	if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) {
2713	reg_base = pci_resource_start(ep->hba->pcidev,
2714	BNX2X_DOORBELL_PCI_BAR);
2715	reg_off = (1 << BNX2X_DB_SHIFT) * (cid_num & 0x1FFFF);
2716	ep->qp.ctx_base = ioremap(offset: reg_base + reg_off, size: 4);
2717	if (!ep->qp.ctx_base)
2718	return -ENOMEM;
2719	goto arm_cq;
2720	}
2721
2722	if ((test_bit(BNX2I_NX2_DEV_5709, &ep->hba->cnic_dev_type)) &&
2723	(ep->hba->mail_queue_access == BNX2I_MQ_BIN_MODE)) {
2724	config2 = REG_RD(ep->hba, BNX2_MQ_CONFIG2);
2725	first_l4l5 = config2 & BNX2_MQ_CONFIG2_FIRST_L4L5;
2726	ctx_sz = (config2 & BNX2_MQ_CONFIG2_CONT_SZ) >> 3;
2727	if (ctx_sz)
2728	reg_off = CTX_OFFSET + MAX_CID_CNT * MB_KERNEL_CTX_SIZE
2729	+ BNX2I_570X_PAGE_SIZE_DEFAULT *
2730	(((cid_num - first_l4l5) / ctx_sz) + 256);
2731	else
2732	reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num);
2733	} else
2734	/* 5709 device in normal node and 5706/5708 devices */
2735	reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num);
2736
2737	ep->qp.ctx_base = ioremap(offset: ep->hba->reg_base + reg_off,
2738	MB_KERNEL_CTX_SIZE);
2739	if (!ep->qp.ctx_base)
2740	return -ENOMEM;
2741
2742	arm_cq:
2743	bnx2i_arm_cq_event_coalescing(ep, CNIC_ARM_CQE);
2744	return 0;
2745	}
2746