1 /* bnx2i_hwi.c: Broadcom NetXtreme II iSCSI driver.
3 * Copyright (c) 2006 - 2009 Broadcom Corporation
4 * Copyright (c) 2007, 2008 Red Hat, Inc. All rights reserved.
5 * Copyright (c) 2007, 2008 Mike Christie
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation.
11 * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
14 #include <linux/gfp.h>
15 #include <scsi/scsi_tcq.h>
16 #include <scsi/libiscsi.h>
20 * bnx2i_get_cid_num - get cid from ep
21 * @ep: endpoint pointer
23 * Only applicable to 57710 family of devices
25 static u32
bnx2i_get_cid_num(struct bnx2i_endpoint
*ep
)
29 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
32 cid
= GET_CID_NUM(ep
->ep_cid
);
38 * bnx2i_adjust_qp_size - Adjust SQ/RQ/CQ size for 57710 device type
39 * @hba: Adapter for which adjustments is to be made
41 * Only applicable to 57710 family of devices
43 static void bnx2i_adjust_qp_size(struct bnx2i_hba
*hba
)
45 u32 num_elements_per_pg
;
47 if (test_bit(BNX2I_NX2_DEV_5706
, &hba
->cnic_dev_type
) ||
48 test_bit(BNX2I_NX2_DEV_5708
, &hba
->cnic_dev_type
) ||
49 test_bit(BNX2I_NX2_DEV_5709
, &hba
->cnic_dev_type
)) {
50 if (!is_power_of_2(hba
->max_sqes
))
51 hba
->max_sqes
= rounddown_pow_of_two(hba
->max_sqes
);
53 if (!is_power_of_2(hba
->max_rqes
))
54 hba
->max_rqes
= rounddown_pow_of_two(hba
->max_rqes
);
57 /* Adjust each queue size if the user selection does not
58 * yield integral num of page buffers
61 num_elements_per_pg
= PAGE_SIZE
/ BNX2I_SQ_WQE_SIZE
;
62 if (hba
->max_sqes
< num_elements_per_pg
)
63 hba
->max_sqes
= num_elements_per_pg
;
64 else if (hba
->max_sqes
% num_elements_per_pg
)
65 hba
->max_sqes
= (hba
->max_sqes
+ num_elements_per_pg
- 1) &
66 ~(num_elements_per_pg
- 1);
69 num_elements_per_pg
= PAGE_SIZE
/ BNX2I_CQE_SIZE
;
70 if (hba
->max_cqes
< num_elements_per_pg
)
71 hba
->max_cqes
= num_elements_per_pg
;
72 else if (hba
->max_cqes
% num_elements_per_pg
)
73 hba
->max_cqes
= (hba
->max_cqes
+ num_elements_per_pg
- 1) &
74 ~(num_elements_per_pg
- 1);
77 num_elements_per_pg
= PAGE_SIZE
/ BNX2I_RQ_WQE_SIZE
;
78 if (hba
->max_rqes
< num_elements_per_pg
)
79 hba
->max_rqes
= num_elements_per_pg
;
80 else if (hba
->max_rqes
% num_elements_per_pg
)
81 hba
->max_rqes
= (hba
->max_rqes
+ num_elements_per_pg
- 1) &
82 ~(num_elements_per_pg
- 1);
87 * bnx2i_get_link_state - get network interface link state
88 * @hba: adapter instance pointer
90 * updates adapter structure flag based on netdev state
92 static void bnx2i_get_link_state(struct bnx2i_hba
*hba
)
94 if (test_bit(__LINK_STATE_NOCARRIER
, &hba
->netdev
->state
))
95 set_bit(ADAPTER_STATE_LINK_DOWN
, &hba
->adapter_state
);
97 clear_bit(ADAPTER_STATE_LINK_DOWN
, &hba
->adapter_state
);
102 * bnx2i_iscsi_license_error - displays iscsi license related error message
103 * @hba: adapter instance pointer
104 * @error_code: error classification
106 * Puts out an error log when driver is unable to offload iscsi connection
107 * due to license restrictions
109 static void bnx2i_iscsi_license_error(struct bnx2i_hba
*hba
, u32 error_code
)
111 if (error_code
== ISCSI_KCQE_COMPLETION_STATUS_ISCSI_NOT_SUPPORTED
)
112 /* iSCSI offload not supported on this device */
113 printk(KERN_ERR
"bnx2i: iSCSI not supported, dev=%s\n",
115 if (error_code
== ISCSI_KCQE_COMPLETION_STATUS_LOM_ISCSI_NOT_ENABLED
)
116 /* iSCSI offload not supported on this LOM device */
117 printk(KERN_ERR
"bnx2i: LOM is not enable to "
118 "offload iSCSI connections, dev=%s\n",
120 set_bit(ADAPTER_STATE_INIT_FAILED
, &hba
->adapter_state
);
125 * bnx2i_arm_cq_event_coalescing - arms CQ to enable EQ notification
126 * @ep: endpoint (transport indentifier) structure
127 * @action: action, ARM or DISARM. For now only ARM_CQE is used
129 * Arm'ing CQ will enable chip to generate global EQ events inorder to interrupt
130 * the driver. EQ event is generated CQ index is hit or at least 1 CQ is
131 * outstanding and on chip timer expires
133 void bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint
*ep
, u8 action
)
135 struct bnx2i_5771x_cq_db
*cq_db
;
141 /* Coalesce CQ entries only on 10G devices */
142 if (!test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
145 /* Do not update CQ DB multiple times before firmware writes
146 * '0xFFFF' to CQDB->SQN field. Deviation may cause spurious
147 * interrupts and other unwanted results
149 cq_db
= (struct bnx2i_5771x_cq_db
*) ep
->qp
.cq_pgtbl_virt
;
150 if (cq_db
->sqn
[0] && cq_db
->sqn
[0] != 0xFFFF)
153 if (action
== CNIC_ARM_CQE
) {
154 num_active_cmds
= ep
->num_active_cmds
;
155 if (num_active_cmds
<= event_coal_min
)
158 next_index
= event_coal_min
+
159 (num_active_cmds
- event_coal_min
) / event_coal_div
;
162 cq_index
= ep
->qp
.cqe_exp_seq_sn
+ next_index
- 1;
163 if (cq_index
> ep
->qp
.cqe_size
* 2)
164 cq_index
-= ep
->qp
.cqe_size
* 2;
168 cq_db
->sqn
[0] = cq_index
;
174 * bnx2i_get_rq_buf - copy RQ buffer contents to driver buffer
175 * @conn: iscsi connection on which RQ event occured
176 * @ptr: driver buffer to which RQ buffer contents is to
178 * @len: length of valid data inside RQ buf
180 * Copies RQ buffer contents from shared (DMA'able) memory region to
181 * driver buffer. RQ is used to DMA unsolicitated iscsi pdu's and
184 void bnx2i_get_rq_buf(struct bnx2i_conn
*bnx2i_conn
, char *ptr
, int len
)
186 if (!bnx2i_conn
->ep
->qp
.rqe_left
)
189 bnx2i_conn
->ep
->qp
.rqe_left
--;
190 memcpy(ptr
, (u8
*) bnx2i_conn
->ep
->qp
.rq_cons_qe
, len
);
191 if (bnx2i_conn
->ep
->qp
.rq_cons_qe
== bnx2i_conn
->ep
->qp
.rq_last_qe
) {
192 bnx2i_conn
->ep
->qp
.rq_cons_qe
= bnx2i_conn
->ep
->qp
.rq_first_qe
;
193 bnx2i_conn
->ep
->qp
.rq_cons_idx
= 0;
195 bnx2i_conn
->ep
->qp
.rq_cons_qe
++;
196 bnx2i_conn
->ep
->qp
.rq_cons_idx
++;
201 static void bnx2i_ring_577xx_doorbell(struct bnx2i_conn
*conn
)
203 struct bnx2i_5771x_dbell dbell
;
206 memset(&dbell
, 0, sizeof(dbell
));
207 dbell
.dbell
.header
= (B577XX_ISCSI_CONNECTION_TYPE
<<
208 B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT
);
209 msg
= *((u32
*)&dbell
);
210 /* TODO : get doorbell register mapping */
211 writel(cpu_to_le32(msg
), conn
->ep
->qp
.ctx_base
);
216 * bnx2i_put_rq_buf - Replenish RQ buffer, if required ring on chip doorbell
217 * @conn: iscsi connection on which event to post
218 * @count: number of RQ buffer being posted to chip
220 * No need to ring hardware doorbell for 57710 family of devices
222 void bnx2i_put_rq_buf(struct bnx2i_conn
*bnx2i_conn
, int count
)
224 struct bnx2i_5771x_sq_rq_db
*rq_db
;
225 u16 hi_bit
= (bnx2i_conn
->ep
->qp
.rq_prod_idx
& 0x8000);
226 struct bnx2i_endpoint
*ep
= bnx2i_conn
->ep
;
228 ep
->qp
.rqe_left
+= count
;
229 ep
->qp
.rq_prod_idx
&= 0x7FFF;
230 ep
->qp
.rq_prod_idx
+= count
;
232 if (ep
->qp
.rq_prod_idx
> bnx2i_conn
->hba
->max_rqes
) {
233 ep
->qp
.rq_prod_idx
%= bnx2i_conn
->hba
->max_rqes
;
235 ep
->qp
.rq_prod_idx
|= 0x8000;
237 ep
->qp
.rq_prod_idx
|= hi_bit
;
239 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
240 rq_db
= (struct bnx2i_5771x_sq_rq_db
*) ep
->qp
.rq_pgtbl_virt
;
241 rq_db
->prod_idx
= ep
->qp
.rq_prod_idx
;
242 /* no need to ring hardware doorbell for 57710 */
244 writew(ep
->qp
.rq_prod_idx
,
245 ep
->qp
.ctx_base
+ CNIC_RECV_DOORBELL
);
252 * bnx2i_ring_sq_dbell - Ring SQ doorbell to wake-up the processing engine
253 * @conn: iscsi connection to which new SQ entries belong
254 * @count: number of SQ WQEs to post
256 * SQ DB is updated in host memory and TX Doorbell is rung for 57710 family
257 * of devices. For 5706/5708/5709 new SQ WQE count is written into the
260 static void bnx2i_ring_sq_dbell(struct bnx2i_conn
*bnx2i_conn
, int count
)
262 struct bnx2i_5771x_sq_rq_db
*sq_db
;
263 struct bnx2i_endpoint
*ep
= bnx2i_conn
->ep
;
265 ep
->num_active_cmds
++;
266 wmb(); /* flush SQ WQE memory before the doorbell is rung */
267 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
268 sq_db
= (struct bnx2i_5771x_sq_rq_db
*) ep
->qp
.sq_pgtbl_virt
;
269 sq_db
->prod_idx
= ep
->qp
.sq_prod_idx
;
270 bnx2i_ring_577xx_doorbell(bnx2i_conn
);
272 writew(count
, ep
->qp
.ctx_base
+ CNIC_SEND_DOORBELL
);
274 mmiowb(); /* flush posted PCI writes */
279 * bnx2i_ring_dbell_update_sq_params - update SQ driver parameters
280 * @conn: iscsi connection to which new SQ entries belong
281 * @count: number of SQ WQEs to post
283 * this routine will update SQ driver parameters and ring the doorbell
285 static void bnx2i_ring_dbell_update_sq_params(struct bnx2i_conn
*bnx2i_conn
,
291 if (bnx2i_conn
->ep
->qp
.sq_prod_qe
==
292 bnx2i_conn
->ep
->qp
.sq_last_qe
)
293 bnx2i_conn
->ep
->qp
.sq_prod_qe
=
294 bnx2i_conn
->ep
->qp
.sq_first_qe
;
296 bnx2i_conn
->ep
->qp
.sq_prod_qe
++;
298 if ((bnx2i_conn
->ep
->qp
.sq_prod_qe
+ count
) <=
299 bnx2i_conn
->ep
->qp
.sq_last_qe
)
300 bnx2i_conn
->ep
->qp
.sq_prod_qe
+= count
;
302 tmp_cnt
= bnx2i_conn
->ep
->qp
.sq_last_qe
-
303 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
304 bnx2i_conn
->ep
->qp
.sq_prod_qe
=
305 &bnx2i_conn
->ep
->qp
.sq_first_qe
[count
-
309 bnx2i_conn
->ep
->qp
.sq_prod_idx
+= count
;
310 /* Ring the doorbell */
311 bnx2i_ring_sq_dbell(bnx2i_conn
, bnx2i_conn
->ep
->qp
.sq_prod_idx
);
316 * bnx2i_send_iscsi_login - post iSCSI login request MP WQE to hardware
317 * @conn: iscsi connection
318 * @cmd: driver command structure which is requesting
319 * a WQE to sent to chip for further processing
321 * prepare and post an iSCSI Login request WQE to CNIC firmware
323 int bnx2i_send_iscsi_login(struct bnx2i_conn
*bnx2i_conn
,
324 struct iscsi_task
*task
)
326 struct bnx2i_cmd
*bnx2i_cmd
;
327 struct bnx2i_login_request
*login_wqe
;
328 struct iscsi_login
*login_hdr
;
331 bnx2i_cmd
= (struct bnx2i_cmd
*)task
->dd_data
;
332 login_hdr
= (struct iscsi_login
*)task
->hdr
;
333 login_wqe
= (struct bnx2i_login_request
*)
334 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
336 login_wqe
->op_code
= login_hdr
->opcode
;
337 login_wqe
->op_attr
= login_hdr
->flags
;
338 login_wqe
->version_max
= login_hdr
->max_version
;
339 login_wqe
->version_min
= login_hdr
->min_version
;
340 login_wqe
->data_length
= ntoh24(login_hdr
->dlength
);
341 login_wqe
->isid_lo
= *((u32
*) login_hdr
->isid
);
342 login_wqe
->isid_hi
= *((u16
*) login_hdr
->isid
+ 2);
343 login_wqe
->tsih
= login_hdr
->tsih
;
344 login_wqe
->itt
= task
->itt
|
345 (ISCSI_TASK_TYPE_MPATH
<< ISCSI_LOGIN_REQUEST_TYPE_SHIFT
);
346 login_wqe
->cid
= login_hdr
->cid
;
348 login_wqe
->cmd_sn
= be32_to_cpu(login_hdr
->cmdsn
);
349 login_wqe
->exp_stat_sn
= be32_to_cpu(login_hdr
->exp_statsn
);
350 login_wqe
->flags
= ISCSI_LOGIN_REQUEST_UPDATE_EXP_STAT_SN
;
352 login_wqe
->resp_bd_list_addr_lo
= (u32
) bnx2i_conn
->gen_pdu
.resp_bd_dma
;
353 login_wqe
->resp_bd_list_addr_hi
=
354 (u32
) ((u64
) bnx2i_conn
->gen_pdu
.resp_bd_dma
>> 32);
356 dword
= ((1 << ISCSI_LOGIN_REQUEST_NUM_RESP_BDS_SHIFT
) |
357 (bnx2i_conn
->gen_pdu
.resp_buf_size
<<
358 ISCSI_LOGIN_REQUEST_RESP_BUFFER_LENGTH_SHIFT
));
359 login_wqe
->resp_buffer
= dword
;
360 login_wqe
->bd_list_addr_lo
= (u32
) bnx2i_conn
->gen_pdu
.req_bd_dma
;
361 login_wqe
->bd_list_addr_hi
=
362 (u32
) ((u64
) bnx2i_conn
->gen_pdu
.req_bd_dma
>> 32);
363 login_wqe
->num_bds
= 1;
364 login_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
366 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
371 * bnx2i_send_iscsi_tmf - post iSCSI task management request MP WQE to hardware
372 * @conn: iscsi connection
373 * @mtask: driver command structure which is requesting
374 * a WQE to sent to chip for further processing
376 * prepare and post an iSCSI Login request WQE to CNIC firmware
378 int bnx2i_send_iscsi_tmf(struct bnx2i_conn
*bnx2i_conn
,
379 struct iscsi_task
*mtask
)
381 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
382 struct iscsi_tm
*tmfabort_hdr
;
383 struct scsi_cmnd
*ref_sc
;
384 struct iscsi_task
*ctask
;
385 struct bnx2i_cmd
*bnx2i_cmd
;
386 struct bnx2i_tmf_request
*tmfabort_wqe
;
390 bnx2i_cmd
= (struct bnx2i_cmd
*)mtask
->dd_data
;
391 tmfabort_hdr
= (struct iscsi_tm
*)mtask
->hdr
;
392 tmfabort_wqe
= (struct bnx2i_tmf_request
*)
393 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
395 tmfabort_wqe
->op_code
= tmfabort_hdr
->opcode
;
396 tmfabort_wqe
->op_attr
= 0;
397 tmfabort_wqe
->op_attr
=
398 ISCSI_TMF_REQUEST_ALWAYS_ONE
| ISCSI_TM_FUNC_ABORT_TASK
;
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
);
404 ctask
= iscsi_itt_to_task(conn
, tmfabort_hdr
->rtt
);
405 if (!ctask
|| !ctask
->sc
)
407 * the iscsi layer must have completed the cmd while this
410 * Note: In the case of a SCSI cmd timeout, the task's sc
411 * is still active; hence ctask->sc != 0
412 * In this case, the task must be aborted
418 /* Retrieve LUN directly from the ref_sc */
419 int_to_scsilun(ref_sc
->device
->lun
, (struct scsi_lun
*) scsi_lun
);
420 tmfabort_wqe
->lun
[0] = be32_to_cpu(scsi_lun
[0]);
421 tmfabort_wqe
->lun
[1] = be32_to_cpu(scsi_lun
[1]);
423 if (ref_sc
->sc_data_direction
== DMA_TO_DEVICE
)
424 dword
= (ISCSI_TASK_TYPE_WRITE
<< ISCSI_CMD_REQUEST_TYPE_SHIFT
);
426 dword
= (ISCSI_TASK_TYPE_READ
<< ISCSI_CMD_REQUEST_TYPE_SHIFT
);
427 tmfabort_wqe
->ref_itt
= (dword
| (tmfabort_hdr
->rtt
& ISCSI_ITT_MASK
));
428 tmfabort_wqe
->ref_cmd_sn
= be32_to_cpu(tmfabort_hdr
->refcmdsn
);
430 tmfabort_wqe
->bd_list_addr_lo
= (u32
) bnx2i_conn
->hba
->mp_bd_dma
;
431 tmfabort_wqe
->bd_list_addr_hi
= (u32
)
432 ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
433 tmfabort_wqe
->num_bds
= 1;
434 tmfabort_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
436 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
441 * bnx2i_send_iscsi_scsicmd - post iSCSI scsicmd request WQE to hardware
442 * @conn: iscsi connection
443 * @cmd: driver command structure which is requesting
444 * a WQE to sent to chip for further processing
446 * prepare and post an iSCSI SCSI-CMD request WQE to CNIC firmware
448 int bnx2i_send_iscsi_scsicmd(struct bnx2i_conn
*bnx2i_conn
,
449 struct bnx2i_cmd
*cmd
)
451 struct bnx2i_cmd_request
*scsi_cmd_wqe
;
453 scsi_cmd_wqe
= (struct bnx2i_cmd_request
*)
454 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
455 memcpy(scsi_cmd_wqe
, &cmd
->req
, sizeof(struct bnx2i_cmd_request
));
456 scsi_cmd_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
458 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
463 * bnx2i_send_iscsi_nopout - post iSCSI NOPOUT request WQE to hardware
464 * @conn: iscsi connection
465 * @cmd: driver command structure which is requesting
466 * a WQE to sent to chip for further processing
467 * @ttt: TTT to be used when building pdu header
468 * @datap: payload buffer pointer
469 * @data_len: payload data length
470 * @unsol: indicated whether nopout pdu is unsolicited pdu or
471 * in response to target's NOPIN w/ TTT != FFFFFFFF
473 * prepare and post a nopout request WQE to CNIC firmware
475 int bnx2i_send_iscsi_nopout(struct bnx2i_conn
*bnx2i_conn
,
476 struct iscsi_task
*task
, u32 ttt
,
477 char *datap
, int data_len
, int unsol
)
479 struct bnx2i_endpoint
*ep
= bnx2i_conn
->ep
;
480 struct bnx2i_cmd
*bnx2i_cmd
;
481 struct bnx2i_nop_out_request
*nopout_wqe
;
482 struct iscsi_nopout
*nopout_hdr
;
484 bnx2i_cmd
= (struct bnx2i_cmd
*)task
->dd_data
;
485 nopout_hdr
= (struct iscsi_nopout
*)task
->hdr
;
486 nopout_wqe
= (struct bnx2i_nop_out_request
*)ep
->qp
.sq_prod_qe
;
487 nopout_wqe
->op_code
= nopout_hdr
->opcode
;
488 nopout_wqe
->op_attr
= ISCSI_FLAG_CMD_FINAL
;
489 memcpy(nopout_wqe
->lun
, nopout_hdr
->lun
, 8);
491 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
492 u32 tmp
= nopout_hdr
->lun
[0];
493 /* 57710 requires LUN field to be swapped */
494 nopout_hdr
->lun
[0] = nopout_hdr
->lun
[1];
495 nopout_hdr
->lun
[1] = tmp
;
498 nopout_wqe
->itt
= ((u16
)task
->itt
|
499 (ISCSI_TASK_TYPE_MPATH
<<
500 ISCSI_TMF_REQUEST_TYPE_SHIFT
));
501 nopout_wqe
->ttt
= ttt
;
502 nopout_wqe
->flags
= 0;
504 nopout_wqe
->flags
= ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION
;
505 else if (nopout_hdr
->itt
== RESERVED_ITT
)
506 nopout_wqe
->flags
= ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION
;
508 nopout_wqe
->cmd_sn
= be32_to_cpu(nopout_hdr
->cmdsn
);
509 nopout_wqe
->data_length
= data_len
;
511 /* handle payload data, not required in first release */
512 printk(KERN_ALERT
"NOPOUT: WARNING!! payload len != 0\n");
514 nopout_wqe
->bd_list_addr_lo
= (u32
)
515 bnx2i_conn
->hba
->mp_bd_dma
;
516 nopout_wqe
->bd_list_addr_hi
=
517 (u32
) ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
518 nopout_wqe
->num_bds
= 1;
520 nopout_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
522 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
528 * bnx2i_send_iscsi_logout - post iSCSI logout request WQE to hardware
529 * @conn: iscsi connection
530 * @cmd: driver command structure which is requesting
531 * a WQE to sent to chip for further processing
533 * prepare and post logout request WQE to CNIC firmware
535 int bnx2i_send_iscsi_logout(struct bnx2i_conn
*bnx2i_conn
,
536 struct iscsi_task
*task
)
538 struct bnx2i_cmd
*bnx2i_cmd
;
539 struct bnx2i_logout_request
*logout_wqe
;
540 struct iscsi_logout
*logout_hdr
;
542 bnx2i_cmd
= (struct bnx2i_cmd
*)task
->dd_data
;
543 logout_hdr
= (struct iscsi_logout
*)task
->hdr
;
545 logout_wqe
= (struct bnx2i_logout_request
*)
546 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
547 memset(logout_wqe
, 0x00, sizeof(struct bnx2i_logout_request
));
549 logout_wqe
->op_code
= logout_hdr
->opcode
;
550 logout_wqe
->cmd_sn
= be32_to_cpu(logout_hdr
->cmdsn
);
551 logout_wqe
->op_attr
=
552 logout_hdr
->flags
| ISCSI_LOGOUT_REQUEST_ALWAYS_ONE
;
553 logout_wqe
->itt
= ((u16
)task
->itt
|
554 (ISCSI_TASK_TYPE_MPATH
<<
555 ISCSI_LOGOUT_REQUEST_TYPE_SHIFT
));
556 logout_wqe
->data_length
= 0;
559 logout_wqe
->bd_list_addr_lo
= (u32
) bnx2i_conn
->hba
->mp_bd_dma
;
560 logout_wqe
->bd_list_addr_hi
= (u32
)
561 ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
562 logout_wqe
->num_bds
= 1;
563 logout_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
565 bnx2i_conn
->ep
->state
= EP_STATE_LOGOUT_SENT
;
567 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
573 * bnx2i_update_iscsi_conn - post iSCSI logout request WQE to hardware
574 * @conn: iscsi connection which requires iscsi parameter update
576 * sends down iSCSI Conn Update request to move iSCSI conn to FFP
578 void bnx2i_update_iscsi_conn(struct iscsi_conn
*conn
)
580 struct bnx2i_conn
*bnx2i_conn
= conn
->dd_data
;
581 struct bnx2i_hba
*hba
= bnx2i_conn
->hba
;
582 struct kwqe
*kwqe_arr
[2];
583 struct iscsi_kwqe_conn_update
*update_wqe
;
584 struct iscsi_kwqe_conn_update conn_update_kwqe
;
586 update_wqe
= &conn_update_kwqe
;
588 update_wqe
->hdr
.op_code
= ISCSI_KWQE_OPCODE_UPDATE_CONN
;
589 update_wqe
->hdr
.flags
=
590 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
592 /* 5771x requires conn context id to be passed as is */
593 if (test_bit(BNX2I_NX2_DEV_57710
, &bnx2i_conn
->ep
->hba
->cnic_dev_type
))
594 update_wqe
->context_id
= bnx2i_conn
->ep
->ep_cid
;
596 update_wqe
->context_id
= (bnx2i_conn
->ep
->ep_cid
>> 7);
597 update_wqe
->conn_flags
= 0;
598 if (conn
->hdrdgst_en
)
599 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_HEADER_DIGEST
;
600 if (conn
->datadgst_en
)
601 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_DATA_DIGEST
;
602 if (conn
->session
->initial_r2t_en
)
603 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_INITIAL_R2T
;
604 if (conn
->session
->imm_data_en
)
605 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA
;
607 update_wqe
->max_send_pdu_length
= conn
->max_xmit_dlength
;
608 update_wqe
->max_recv_pdu_length
= conn
->max_recv_dlength
;
609 update_wqe
->first_burst_length
= conn
->session
->first_burst
;
610 update_wqe
->max_burst_length
= conn
->session
->max_burst
;
611 update_wqe
->exp_stat_sn
= conn
->exp_statsn
;
612 update_wqe
->max_outstanding_r2ts
= conn
->session
->max_r2t
;
613 update_wqe
->session_error_recovery_level
= conn
->session
->erl
;
614 iscsi_conn_printk(KERN_ALERT
, conn
,
615 "bnx2i: conn update - MBL 0x%x FBL 0x%x"
616 "MRDSL_I 0x%x MRDSL_T 0x%x \n",
617 update_wqe
->max_burst_length
,
618 update_wqe
->first_burst_length
,
619 update_wqe
->max_recv_pdu_length
,
620 update_wqe
->max_send_pdu_length
);
622 kwqe_arr
[0] = (struct kwqe
*) update_wqe
;
623 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
624 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 1);
629 * bnx2i_ep_ofld_timer - post iSCSI logout request WQE to hardware
630 * @data: endpoint (transport handle) structure pointer
632 * routine to handle connection offload/destroy request timeout
634 void bnx2i_ep_ofld_timer(unsigned long data
)
636 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) data
;
638 if (ep
->state
== EP_STATE_OFLD_START
) {
639 printk(KERN_ALERT
"ofld_timer: CONN_OFLD timeout\n");
640 ep
->state
= EP_STATE_OFLD_FAILED
;
641 } else if (ep
->state
== EP_STATE_DISCONN_START
) {
642 printk(KERN_ALERT
"ofld_timer: CONN_DISCON timeout\n");
643 ep
->state
= EP_STATE_DISCONN_TIMEDOUT
;
644 } else if (ep
->state
== EP_STATE_CLEANUP_START
) {
645 printk(KERN_ALERT
"ofld_timer: CONN_CLEANUP timeout\n");
646 ep
->state
= EP_STATE_CLEANUP_FAILED
;
649 wake_up_interruptible(&ep
->ofld_wait
);
653 static int bnx2i_power_of2(u32 val
)
668 * bnx2i_send_cmd_cleanup_req - send iscsi cmd context clean-up request
669 * @hba: adapter structure pointer
670 * @cmd: driver command structure which is requesting
671 * a WQE to sent to chip for further processing
673 * prepares and posts CONN_OFLD_REQ1/2 KWQE
675 void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba
*hba
, struct bnx2i_cmd
*cmd
)
677 struct bnx2i_cleanup_request
*cmd_cleanup
;
680 (struct bnx2i_cleanup_request
*)cmd
->conn
->ep
->qp
.sq_prod_qe
;
681 memset(cmd_cleanup
, 0x00, sizeof(struct bnx2i_cleanup_request
));
683 cmd_cleanup
->op_code
= ISCSI_OPCODE_CLEANUP_REQUEST
;
684 cmd_cleanup
->itt
= cmd
->req
.itt
;
685 cmd_cleanup
->cq_index
= 0; /* CQ# used for completion, 5771x only */
687 bnx2i_ring_dbell_update_sq_params(cmd
->conn
, 1);
692 * bnx2i_send_conn_destroy - initiates iscsi connection teardown process
693 * @hba: adapter structure pointer
694 * @ep: endpoint (transport indentifier) structure
696 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE to initiate
697 * iscsi connection context clean-up process
699 void bnx2i_send_conn_destroy(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
701 struct kwqe
*kwqe_arr
[2];
702 struct iscsi_kwqe_conn_destroy conn_cleanup
;
704 memset(&conn_cleanup
, 0x00, sizeof(struct iscsi_kwqe_conn_destroy
));
706 conn_cleanup
.hdr
.op_code
= ISCSI_KWQE_OPCODE_DESTROY_CONN
;
707 conn_cleanup
.hdr
.flags
=
708 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
709 /* 5771x requires conn context id to be passed as is */
710 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
711 conn_cleanup
.context_id
= ep
->ep_cid
;
713 conn_cleanup
.context_id
= (ep
->ep_cid
>> 7);
715 conn_cleanup
.reserved0
= (u16
)ep
->ep_iscsi_cid
;
717 kwqe_arr
[0] = (struct kwqe
*) &conn_cleanup
;
718 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
719 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 1);
724 * bnx2i_570x_send_conn_ofld_req - initiates iscsi conn context setup process
725 * @hba: adapter structure pointer
726 * @ep: endpoint (transport indentifier) structure
728 * 5706/5708/5709 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
730 static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba
*hba
,
731 struct bnx2i_endpoint
*ep
)
733 struct kwqe
*kwqe_arr
[2];
734 struct iscsi_kwqe_conn_offload1 ofld_req1
;
735 struct iscsi_kwqe_conn_offload2 ofld_req2
;
740 ofld_req1
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN1
;
741 ofld_req1
.hdr
.flags
=
742 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
744 ofld_req1
.iscsi_conn_id
= (u16
) ep
->ep_iscsi_cid
;
746 dma_addr
= ep
->qp
.sq_pgtbl_phys
;
747 ofld_req1
.sq_page_table_addr_lo
= (u32
) dma_addr
;
748 ofld_req1
.sq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
750 dma_addr
= ep
->qp
.cq_pgtbl_phys
;
751 ofld_req1
.cq_page_table_addr_lo
= (u32
) dma_addr
;
752 ofld_req1
.cq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
754 ofld_req2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN2
;
755 ofld_req2
.hdr
.flags
=
756 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
758 dma_addr
= ep
->qp
.rq_pgtbl_phys
;
759 ofld_req2
.rq_page_table_addr_lo
= (u32
) dma_addr
;
760 ofld_req2
.rq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
762 ptbl
= (u32
*) ep
->qp
.sq_pgtbl_virt
;
764 ofld_req2
.sq_first_pte
.hi
= *ptbl
++;
765 ofld_req2
.sq_first_pte
.lo
= *ptbl
;
767 ptbl
= (u32
*) ep
->qp
.cq_pgtbl_virt
;
768 ofld_req2
.cq_first_pte
.hi
= *ptbl
++;
769 ofld_req2
.cq_first_pte
.lo
= *ptbl
;
771 kwqe_arr
[0] = (struct kwqe
*) &ofld_req1
;
772 kwqe_arr
[1] = (struct kwqe
*) &ofld_req2
;
773 ofld_req2
.num_additional_wqes
= 0;
775 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
776 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, num_kwqes
);
781 * bnx2i_5771x_send_conn_ofld_req - initiates iscsi connection context creation
782 * @hba: adapter structure pointer
783 * @ep: endpoint (transport indentifier) structure
785 * 57710 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
787 static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba
*hba
,
788 struct bnx2i_endpoint
*ep
)
790 struct kwqe
*kwqe_arr
[5];
791 struct iscsi_kwqe_conn_offload1 ofld_req1
;
792 struct iscsi_kwqe_conn_offload2 ofld_req2
;
793 struct iscsi_kwqe_conn_offload3 ofld_req3
[1];
798 ofld_req1
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN1
;
799 ofld_req1
.hdr
.flags
=
800 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
802 ofld_req1
.iscsi_conn_id
= (u16
) ep
->ep_iscsi_cid
;
804 dma_addr
= ep
->qp
.sq_pgtbl_phys
+ ISCSI_SQ_DB_SIZE
;
805 ofld_req1
.sq_page_table_addr_lo
= (u32
) dma_addr
;
806 ofld_req1
.sq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
808 dma_addr
= ep
->qp
.cq_pgtbl_phys
+ ISCSI_CQ_DB_SIZE
;
809 ofld_req1
.cq_page_table_addr_lo
= (u32
) dma_addr
;
810 ofld_req1
.cq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
812 ofld_req2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN2
;
813 ofld_req2
.hdr
.flags
=
814 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
816 dma_addr
= ep
->qp
.rq_pgtbl_phys
+ ISCSI_RQ_DB_SIZE
;
817 ofld_req2
.rq_page_table_addr_lo
= (u32
) dma_addr
;
818 ofld_req2
.rq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
820 ptbl
= (u32
*)((u8
*)ep
->qp
.sq_pgtbl_virt
+ ISCSI_SQ_DB_SIZE
);
821 ofld_req2
.sq_first_pte
.hi
= *ptbl
++;
822 ofld_req2
.sq_first_pte
.lo
= *ptbl
;
824 ptbl
= (u32
*)((u8
*)ep
->qp
.cq_pgtbl_virt
+ ISCSI_CQ_DB_SIZE
);
825 ofld_req2
.cq_first_pte
.hi
= *ptbl
++;
826 ofld_req2
.cq_first_pte
.lo
= *ptbl
;
828 kwqe_arr
[0] = (struct kwqe
*) &ofld_req1
;
829 kwqe_arr
[1] = (struct kwqe
*) &ofld_req2
;
831 ofld_req2
.num_additional_wqes
= 1;
832 memset(ofld_req3
, 0x00, sizeof(ofld_req3
[0]));
833 ptbl
= (u32
*)((u8
*)ep
->qp
.rq_pgtbl_virt
+ ISCSI_RQ_DB_SIZE
);
834 ofld_req3
[0].qp_first_pte
[0].hi
= *ptbl
++;
835 ofld_req3
[0].qp_first_pte
[0].lo
= *ptbl
;
837 kwqe_arr
[2] = (struct kwqe
*) ofld_req3
;
838 /* need if we decide to go with multiple KCQE's per conn */
841 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
842 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, num_kwqes
);
846 * bnx2i_send_conn_ofld_req - initiates iscsi connection context setup process
848 * @hba: adapter structure pointer
849 * @ep: endpoint (transport indentifier) structure
851 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE
853 void bnx2i_send_conn_ofld_req(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
855 if (test_bit(BNX2I_NX2_DEV_57710
, &hba
->cnic_dev_type
))
856 bnx2i_5771x_send_conn_ofld_req(hba
, ep
);
858 bnx2i_570x_send_conn_ofld_req(hba
, ep
);
863 * setup_qp_page_tables - iscsi QP page table setup function
864 * @ep: endpoint (transport indentifier) structure
866 * Sets up page tables for SQ/RQ/CQ, 1G/sec (5706/5708/5709) devices requires
867 * 64-bit address in big endian format. Whereas 10G/sec (57710) requires
868 * PT in little endian format
870 static void setup_qp_page_tables(struct bnx2i_endpoint
*ep
)
877 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
883 memset(ep
->qp
.sq_pgtbl_virt
, 0, ep
->qp
.sq_pgtbl_size
);
884 num_pages
= ep
->qp
.sq_mem_size
/ PAGE_SIZE
;
885 page
= ep
->qp
.sq_phys
;
888 ptbl
= (u32
*)((u8
*)ep
->qp
.sq_pgtbl_virt
+ ISCSI_SQ_DB_SIZE
);
890 ptbl
= (u32
*) ep
->qp
.sq_pgtbl_virt
;
891 while (num_pages
--) {
893 /* PTE is written in little endian format for 57710 */
896 *ptbl
= (u32
) ((u64
) page
>> 32);
900 /* PTE is written in big endian format for
901 * 5706/5708/5709 devices */
902 *ptbl
= (u32
) ((u64
) page
>> 32);
911 memset(ep
->qp
.rq_pgtbl_virt
, 0, ep
->qp
.rq_pgtbl_size
);
912 num_pages
= ep
->qp
.rq_mem_size
/ PAGE_SIZE
;
913 page
= ep
->qp
.rq_phys
;
916 ptbl
= (u32
*)((u8
*)ep
->qp
.rq_pgtbl_virt
+ ISCSI_RQ_DB_SIZE
);
918 ptbl
= (u32
*) ep
->qp
.rq_pgtbl_virt
;
919 while (num_pages
--) {
921 /* PTE is written in little endian format for 57710 */
924 *ptbl
= (u32
) ((u64
) page
>> 32);
928 /* PTE is written in big endian format for
929 * 5706/5708/5709 devices */
930 *ptbl
= (u32
) ((u64
) page
>> 32);
939 memset(ep
->qp
.cq_pgtbl_virt
, 0, ep
->qp
.cq_pgtbl_size
);
940 num_pages
= ep
->qp
.cq_mem_size
/ PAGE_SIZE
;
941 page
= ep
->qp
.cq_phys
;
944 ptbl
= (u32
*)((u8
*)ep
->qp
.cq_pgtbl_virt
+ ISCSI_CQ_DB_SIZE
);
946 ptbl
= (u32
*) ep
->qp
.cq_pgtbl_virt
;
947 while (num_pages
--) {
949 /* PTE is written in little endian format for 57710 */
952 *ptbl
= (u32
) ((u64
) page
>> 32);
956 /* PTE is written in big endian format for
957 * 5706/5708/5709 devices */
958 *ptbl
= (u32
) ((u64
) page
>> 32);
969 * bnx2i_alloc_qp_resc - allocates required resources for QP.
970 * @hba: adapter structure pointer
971 * @ep: endpoint (transport indentifier) structure
973 * Allocate QP (transport layer for iSCSI connection) resources, DMA'able
974 * memory for SQ/RQ/CQ and page tables. EP structure elements such
975 * as producer/consumer indexes/pointers, queue sizes and page table
978 int bnx2i_alloc_qp_resc(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
980 struct bnx2i_5771x_cq_db
*cq_db
;
984 ep
->ep_cid
= ep
->ep_iscsi_cid
= ep
->ep_pg_cid
= 0;
986 /* Allocate page table memory for SQ which is page aligned */
987 ep
->qp
.sq_mem_size
= hba
->max_sqes
* BNX2I_SQ_WQE_SIZE
;
989 (ep
->qp
.sq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
990 ep
->qp
.sq_pgtbl_size
=
991 (ep
->qp
.sq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
992 ep
->qp
.sq_pgtbl_size
=
993 (ep
->qp
.sq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
995 ep
->qp
.sq_pgtbl_virt
=
996 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_pgtbl_size
,
997 &ep
->qp
.sq_pgtbl_phys
, GFP_KERNEL
);
998 if (!ep
->qp
.sq_pgtbl_virt
) {
999 printk(KERN_ALERT
"bnx2i: unable to alloc SQ PT mem (%d)\n",
1000 ep
->qp
.sq_pgtbl_size
);
1004 /* Allocate memory area for actual SQ element */
1006 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_mem_size
,
1007 &ep
->qp
.sq_phys
, GFP_KERNEL
);
1008 if (!ep
->qp
.sq_virt
) {
1009 printk(KERN_ALERT
"bnx2i: unable to alloc SQ BD memory %d\n",
1010 ep
->qp
.sq_mem_size
);
1014 memset(ep
->qp
.sq_virt
, 0x00, ep
->qp
.sq_mem_size
);
1015 ep
->qp
.sq_first_qe
= ep
->qp
.sq_virt
;
1016 ep
->qp
.sq_prod_qe
= ep
->qp
.sq_first_qe
;
1017 ep
->qp
.sq_cons_qe
= ep
->qp
.sq_first_qe
;
1018 ep
->qp
.sq_last_qe
= &ep
->qp
.sq_first_qe
[hba
->max_sqes
- 1];
1019 ep
->qp
.sq_prod_idx
= 0;
1020 ep
->qp
.sq_cons_idx
= 0;
1021 ep
->qp
.sqe_left
= hba
->max_sqes
;
1023 /* Allocate page table memory for CQ which is page aligned */
1024 ep
->qp
.cq_mem_size
= hba
->max_cqes
* BNX2I_CQE_SIZE
;
1025 ep
->qp
.cq_mem_size
=
1026 (ep
->qp
.cq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1027 ep
->qp
.cq_pgtbl_size
=
1028 (ep
->qp
.cq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
1029 ep
->qp
.cq_pgtbl_size
=
1030 (ep
->qp
.cq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1032 ep
->qp
.cq_pgtbl_virt
=
1033 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_pgtbl_size
,
1034 &ep
->qp
.cq_pgtbl_phys
, GFP_KERNEL
);
1035 if (!ep
->qp
.cq_pgtbl_virt
) {
1036 printk(KERN_ALERT
"bnx2i: unable to alloc CQ PT memory %d\n",
1037 ep
->qp
.cq_pgtbl_size
);
1041 /* Allocate memory area for actual CQ element */
1043 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_mem_size
,
1044 &ep
->qp
.cq_phys
, GFP_KERNEL
);
1045 if (!ep
->qp
.cq_virt
) {
1046 printk(KERN_ALERT
"bnx2i: unable to alloc CQ BD memory %d\n",
1047 ep
->qp
.cq_mem_size
);
1050 memset(ep
->qp
.cq_virt
, 0x00, ep
->qp
.cq_mem_size
);
1052 ep
->qp
.cq_first_qe
= ep
->qp
.cq_virt
;
1053 ep
->qp
.cq_prod_qe
= ep
->qp
.cq_first_qe
;
1054 ep
->qp
.cq_cons_qe
= ep
->qp
.cq_first_qe
;
1055 ep
->qp
.cq_last_qe
= &ep
->qp
.cq_first_qe
[hba
->max_cqes
- 1];
1056 ep
->qp
.cq_prod_idx
= 0;
1057 ep
->qp
.cq_cons_idx
= 0;
1058 ep
->qp
.cqe_left
= hba
->max_cqes
;
1059 ep
->qp
.cqe_exp_seq_sn
= ISCSI_INITIAL_SN
;
1060 ep
->qp
.cqe_size
= hba
->max_cqes
;
1062 /* Invalidate all EQ CQE index, req only for 57710 */
1063 cq_db
= (struct bnx2i_5771x_cq_db
*) ep
->qp
.cq_pgtbl_virt
;
1064 memset(cq_db
->sqn
, 0xFF, sizeof(cq_db
->sqn
[0]) * BNX2X_MAX_CQS
);
1066 /* Allocate page table memory for RQ which is page aligned */
1067 ep
->qp
.rq_mem_size
= hba
->max_rqes
* BNX2I_RQ_WQE_SIZE
;
1068 ep
->qp
.rq_mem_size
=
1069 (ep
->qp
.rq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1070 ep
->qp
.rq_pgtbl_size
=
1071 (ep
->qp
.rq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
1072 ep
->qp
.rq_pgtbl_size
=
1073 (ep
->qp
.rq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1075 ep
->qp
.rq_pgtbl_virt
=
1076 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_pgtbl_size
,
1077 &ep
->qp
.rq_pgtbl_phys
, GFP_KERNEL
);
1078 if (!ep
->qp
.rq_pgtbl_virt
) {
1079 printk(KERN_ALERT
"bnx2i: unable to alloc RQ PT mem %d\n",
1080 ep
->qp
.rq_pgtbl_size
);
1084 /* Allocate memory area for actual RQ element */
1086 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_mem_size
,
1087 &ep
->qp
.rq_phys
, GFP_KERNEL
);
1088 if (!ep
->qp
.rq_virt
) {
1089 printk(KERN_ALERT
"bnx2i: unable to alloc RQ BD memory %d\n",
1090 ep
->qp
.rq_mem_size
);
1094 ep
->qp
.rq_first_qe
= ep
->qp
.rq_virt
;
1095 ep
->qp
.rq_prod_qe
= ep
->qp
.rq_first_qe
;
1096 ep
->qp
.rq_cons_qe
= ep
->qp
.rq_first_qe
;
1097 ep
->qp
.rq_last_qe
= &ep
->qp
.rq_first_qe
[hba
->max_rqes
- 1];
1098 ep
->qp
.rq_prod_idx
= 0x8000;
1099 ep
->qp
.rq_cons_idx
= 0;
1100 ep
->qp
.rqe_left
= hba
->max_rqes
;
1102 setup_qp_page_tables(ep
);
1107 bnx2i_free_qp_resc(hba
, ep
);
1114 * bnx2i_free_qp_resc - free memory resources held by QP
1115 * @hba: adapter structure pointer
1116 * @ep: endpoint (transport indentifier) structure
1118 * Free QP resources - SQ/RQ/CQ memory and page tables.
1120 void bnx2i_free_qp_resc(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
1122 if (ep
->qp
.ctx_base
) {
1123 iounmap(ep
->qp
.ctx_base
);
1124 ep
->qp
.ctx_base
= NULL
;
1127 if (ep
->qp
.sq_pgtbl_virt
) {
1128 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_pgtbl_size
,
1129 ep
->qp
.sq_pgtbl_virt
, ep
->qp
.sq_pgtbl_phys
);
1130 ep
->qp
.sq_pgtbl_virt
= NULL
;
1131 ep
->qp
.sq_pgtbl_phys
= 0;
1133 if (ep
->qp
.sq_virt
) {
1134 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_mem_size
,
1135 ep
->qp
.sq_virt
, ep
->qp
.sq_phys
);
1136 ep
->qp
.sq_virt
= NULL
;
1141 if (ep
->qp
.rq_pgtbl_virt
) {
1142 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_pgtbl_size
,
1143 ep
->qp
.rq_pgtbl_virt
, ep
->qp
.rq_pgtbl_phys
);
1144 ep
->qp
.rq_pgtbl_virt
= NULL
;
1145 ep
->qp
.rq_pgtbl_phys
= 0;
1147 if (ep
->qp
.rq_virt
) {
1148 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_mem_size
,
1149 ep
->qp
.rq_virt
, ep
->qp
.rq_phys
);
1150 ep
->qp
.rq_virt
= NULL
;
1155 if (ep
->qp
.cq_pgtbl_virt
) {
1156 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_pgtbl_size
,
1157 ep
->qp
.cq_pgtbl_virt
, ep
->qp
.cq_pgtbl_phys
);
1158 ep
->qp
.cq_pgtbl_virt
= NULL
;
1159 ep
->qp
.cq_pgtbl_phys
= 0;
1161 if (ep
->qp
.cq_virt
) {
1162 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_mem_size
,
1163 ep
->qp
.cq_virt
, ep
->qp
.cq_phys
);
1164 ep
->qp
.cq_virt
= NULL
;
1171 * bnx2i_send_fw_iscsi_init_msg - initiates initial handshake with iscsi f/w
1172 * @hba: adapter structure pointer
1174 * Send down iscsi_init KWQEs which initiates the initial handshake with the f/w
1175 * This results in iSCSi support validation and on-chip context manager
1176 * initialization. Firmware completes this handshake with a CQE carrying
1177 * the result of iscsi support validation. Parameter carried by
1178 * iscsi init request determines the number of offloaded connection and
1179 * tolerance level for iscsi protocol violation this hba/chip can support
1181 int bnx2i_send_fw_iscsi_init_msg(struct bnx2i_hba
*hba
)
1183 struct kwqe
*kwqe_arr
[3];
1184 struct iscsi_kwqe_init1 iscsi_init
;
1185 struct iscsi_kwqe_init2 iscsi_init2
;
1189 bnx2i_adjust_qp_size(hba
);
1192 ISCSI_PAGE_SIZE_4K
<< ISCSI_KWQE_INIT1_PAGE_SIZE_SHIFT
;
1194 iscsi_init
.flags
|= ISCSI_KWQE_INIT1_DELAYED_ACK_ENABLE
;
1195 iscsi_init
.reserved0
= 0;
1196 iscsi_init
.num_cqs
= 1;
1197 iscsi_init
.hdr
.op_code
= ISCSI_KWQE_OPCODE_INIT1
;
1198 iscsi_init
.hdr
.flags
=
1199 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
1201 iscsi_init
.dummy_buffer_addr_lo
= (u32
) hba
->dummy_buf_dma
;
1202 iscsi_init
.dummy_buffer_addr_hi
=
1203 (u32
) ((u64
) hba
->dummy_buf_dma
>> 32);
1205 hba
->ctx_ccell_tasks
=
1206 ((hba
->num_ccell
& 0xFFFF) | (hba
->max_sqes
<< 16));
1207 iscsi_init
.num_ccells_per_conn
= hba
->num_ccell
;
1208 iscsi_init
.num_tasks_per_conn
= hba
->max_sqes
;
1209 iscsi_init
.sq_wqes_per_page
= PAGE_SIZE
/ BNX2I_SQ_WQE_SIZE
;
1210 iscsi_init
.sq_num_wqes
= hba
->max_sqes
;
1211 iscsi_init
.cq_log_wqes_per_page
=
1212 (u8
) bnx2i_power_of2(PAGE_SIZE
/ BNX2I_CQE_SIZE
);
1213 iscsi_init
.cq_num_wqes
= hba
->max_cqes
;
1214 iscsi_init
.cq_num_pages
= (hba
->max_cqes
* BNX2I_CQE_SIZE
+
1215 (PAGE_SIZE
- 1)) / PAGE_SIZE
;
1216 iscsi_init
.sq_num_pages
= (hba
->max_sqes
* BNX2I_SQ_WQE_SIZE
+
1217 (PAGE_SIZE
- 1)) / PAGE_SIZE
;
1218 iscsi_init
.rq_buffer_size
= BNX2I_RQ_WQE_SIZE
;
1219 iscsi_init
.rq_num_wqes
= hba
->max_rqes
;
1222 iscsi_init2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_INIT2
;
1223 iscsi_init2
.hdr
.flags
=
1224 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
1225 iscsi_init2
.max_cq_sqn
= hba
->max_cqes
* 2 + 1;
1230 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV
) |
1233 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN
) |
1235 (1ULL << ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN
));
1237 iscsi_init2
.error_bit_map
[0] = error_mask1
;
1239 iscsi_init2
.error_bit_map
[0] = (u32
) mask64
;
1242 iscsi_init2
.error_bit_map
[1] = error_mask2
;
1244 iscsi_init2
.error_bit_map
[1] = (u32
) (mask64
>> 32);
1246 iscsi_error_mask
= mask64
;
1248 kwqe_arr
[0] = (struct kwqe
*) &iscsi_init
;
1249 kwqe_arr
[1] = (struct kwqe
*) &iscsi_init2
;
1251 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
1252 rc
= hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 2);
1258 * bnx2i_process_scsi_cmd_resp - this function handles scsi cmd completion.
1259 * @conn: iscsi connection
1260 * @cqe: pointer to newly DMA'ed CQE entry for processing
1262 * process SCSI CMD Response CQE & complete the request to SCSI-ML
1264 static int bnx2i_process_scsi_cmd_resp(struct iscsi_session
*session
,
1265 struct bnx2i_conn
*bnx2i_conn
,
1268 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1269 struct bnx2i_cmd_response
*resp_cqe
;
1270 struct bnx2i_cmd
*bnx2i_cmd
;
1271 struct iscsi_task
*task
;
1272 struct iscsi_cmd_rsp
*hdr
;
1275 resp_cqe
= (struct bnx2i_cmd_response
*)cqe
;
1276 spin_lock(&session
->lock
);
1277 task
= iscsi_itt_to_task(conn
,
1278 resp_cqe
->itt
& ISCSI_CMD_RESPONSE_INDEX
);
1282 bnx2i_cmd
= task
->dd_data
;
1284 if (bnx2i_cmd
->req
.op_attr
& ISCSI_CMD_REQUEST_READ
) {
1285 conn
->datain_pdus_cnt
+=
1286 resp_cqe
->task_stat
.read_stat
.num_data_outs
;
1287 conn
->rxdata_octets
+=
1288 bnx2i_cmd
->req
.total_data_transfer_length
;
1290 conn
->dataout_pdus_cnt
+=
1291 resp_cqe
->task_stat
.read_stat
.num_data_outs
;
1292 conn
->r2t_pdus_cnt
+=
1293 resp_cqe
->task_stat
.read_stat
.num_r2ts
;
1294 conn
->txdata_octets
+=
1295 bnx2i_cmd
->req
.total_data_transfer_length
;
1297 bnx2i_iscsi_unmap_sg_list(bnx2i_cmd
);
1299 hdr
= (struct iscsi_cmd_rsp
*)task
->hdr
;
1300 resp_cqe
= (struct bnx2i_cmd_response
*)cqe
;
1301 hdr
->opcode
= resp_cqe
->op_code
;
1302 hdr
->max_cmdsn
= cpu_to_be32(resp_cqe
->max_cmd_sn
);
1303 hdr
->exp_cmdsn
= cpu_to_be32(resp_cqe
->exp_cmd_sn
);
1304 hdr
->response
= resp_cqe
->response
;
1305 hdr
->cmd_status
= resp_cqe
->status
;
1306 hdr
->flags
= resp_cqe
->response_flags
;
1307 hdr
->residual_count
= cpu_to_be32(resp_cqe
->residual_count
);
1309 if (resp_cqe
->op_code
== ISCSI_OP_SCSI_DATA_IN
)
1312 if (resp_cqe
->status
== SAM_STAT_CHECK_CONDITION
) {
1313 datalen
= resp_cqe
->data_length
;
1317 if (datalen
> BNX2I_RQ_WQE_SIZE
) {
1318 iscsi_conn_printk(KERN_ERR
, conn
,
1319 "sense data len %d > RQ sz\n",
1321 datalen
= BNX2I_RQ_WQE_SIZE
;
1322 } else if (datalen
> ISCSI_DEF_MAX_RECV_SEG_LEN
) {
1323 iscsi_conn_printk(KERN_ERR
, conn
,
1324 "sense data len %d > conn data\n",
1326 datalen
= ISCSI_DEF_MAX_RECV_SEG_LEN
;
1329 bnx2i_get_rq_buf(bnx2i_cmd
->conn
, conn
->data
, datalen
);
1330 bnx2i_put_rq_buf(bnx2i_cmd
->conn
, 1);
1334 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
,
1335 conn
->data
, datalen
);
1337 spin_unlock(&session
->lock
);
1343 * bnx2i_process_login_resp - this function handles iscsi login response
1344 * @session: iscsi session pointer
1345 * @bnx2i_conn: iscsi connection pointer
1346 * @cqe: pointer to newly DMA'ed CQE entry for processing
1348 * process Login Response CQE & complete it to open-iscsi user daemon
1350 static int bnx2i_process_login_resp(struct iscsi_session
*session
,
1351 struct bnx2i_conn
*bnx2i_conn
,
1354 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1355 struct iscsi_task
*task
;
1356 struct bnx2i_login_response
*login
;
1357 struct iscsi_login_rsp
*resp_hdr
;
1361 login
= (struct bnx2i_login_response
*) cqe
;
1362 spin_lock(&session
->lock
);
1363 task
= iscsi_itt_to_task(conn
,
1364 login
->itt
& ISCSI_LOGIN_RESPONSE_INDEX
);
1368 resp_hdr
= (struct iscsi_login_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1369 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1370 resp_hdr
->opcode
= login
->op_code
;
1371 resp_hdr
->flags
= login
->response_flags
;
1372 resp_hdr
->max_version
= login
->version_max
;
1373 resp_hdr
->active_version
= login
->version_active
;
1374 resp_hdr
->hlength
= 0;
1376 hton24(resp_hdr
->dlength
, login
->data_length
);
1377 memcpy(resp_hdr
->isid
, &login
->isid_lo
, 6);
1378 resp_hdr
->tsih
= cpu_to_be16(login
->tsih
);
1379 resp_hdr
->itt
= task
->hdr
->itt
;
1380 resp_hdr
->statsn
= cpu_to_be32(login
->stat_sn
);
1381 resp_hdr
->exp_cmdsn
= cpu_to_be32(login
->exp_cmd_sn
);
1382 resp_hdr
->max_cmdsn
= cpu_to_be32(login
->max_cmd_sn
);
1383 resp_hdr
->status_class
= login
->status_class
;
1384 resp_hdr
->status_detail
= login
->status_detail
;
1385 pld_len
= login
->data_length
;
1386 bnx2i_conn
->gen_pdu
.resp_wr_ptr
=
1387 bnx2i_conn
->gen_pdu
.resp_buf
+ pld_len
;
1391 pad_len
= 4 - (pld_len
% 4);
1395 for (i
= 0; i
< pad_len
; i
++) {
1396 bnx2i_conn
->gen_pdu
.resp_wr_ptr
[0] = 0;
1397 bnx2i_conn
->gen_pdu
.resp_wr_ptr
++;
1401 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
,
1402 bnx2i_conn
->gen_pdu
.resp_buf
,
1403 bnx2i_conn
->gen_pdu
.resp_wr_ptr
- bnx2i_conn
->gen_pdu
.resp_buf
);
1405 spin_unlock(&session
->lock
);
1410 * bnx2i_process_tmf_resp - this function handles iscsi TMF response
1411 * @session: iscsi session pointer
1412 * @bnx2i_conn: iscsi connection pointer
1413 * @cqe: pointer to newly DMA'ed CQE entry for processing
1415 * process iSCSI TMF Response CQE and wake up the driver eh thread.
1417 static int bnx2i_process_tmf_resp(struct iscsi_session
*session
,
1418 struct bnx2i_conn
*bnx2i_conn
,
1421 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1422 struct iscsi_task
*task
;
1423 struct bnx2i_tmf_response
*tmf_cqe
;
1424 struct iscsi_tm_rsp
*resp_hdr
;
1426 tmf_cqe
= (struct bnx2i_tmf_response
*)cqe
;
1427 spin_lock(&session
->lock
);
1428 task
= iscsi_itt_to_task(conn
,
1429 tmf_cqe
->itt
& ISCSI_TMF_RESPONSE_INDEX
);
1433 resp_hdr
= (struct iscsi_tm_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1434 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1435 resp_hdr
->opcode
= tmf_cqe
->op_code
;
1436 resp_hdr
->max_cmdsn
= cpu_to_be32(tmf_cqe
->max_cmd_sn
);
1437 resp_hdr
->exp_cmdsn
= cpu_to_be32(tmf_cqe
->exp_cmd_sn
);
1438 resp_hdr
->itt
= task
->hdr
->itt
;
1439 resp_hdr
->response
= tmf_cqe
->response
;
1441 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1443 spin_unlock(&session
->lock
);
1448 * bnx2i_process_logout_resp - this function handles iscsi logout response
1449 * @session: iscsi session pointer
1450 * @bnx2i_conn: iscsi connection pointer
1451 * @cqe: pointer to newly DMA'ed CQE entry for processing
1453 * process iSCSI Logout Response CQE & make function call to
1454 * notify the user daemon.
1456 static int bnx2i_process_logout_resp(struct iscsi_session
*session
,
1457 struct bnx2i_conn
*bnx2i_conn
,
1460 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1461 struct iscsi_task
*task
;
1462 struct bnx2i_logout_response
*logout
;
1463 struct iscsi_logout_rsp
*resp_hdr
;
1465 logout
= (struct bnx2i_logout_response
*) cqe
;
1466 spin_lock(&session
->lock
);
1467 task
= iscsi_itt_to_task(conn
,
1468 logout
->itt
& ISCSI_LOGOUT_RESPONSE_INDEX
);
1472 resp_hdr
= (struct iscsi_logout_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1473 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1474 resp_hdr
->opcode
= logout
->op_code
;
1475 resp_hdr
->flags
= logout
->response
;
1476 resp_hdr
->hlength
= 0;
1478 resp_hdr
->itt
= task
->hdr
->itt
;
1479 resp_hdr
->statsn
= task
->hdr
->exp_statsn
;
1480 resp_hdr
->exp_cmdsn
= cpu_to_be32(logout
->exp_cmd_sn
);
1481 resp_hdr
->max_cmdsn
= cpu_to_be32(logout
->max_cmd_sn
);
1483 resp_hdr
->t2wait
= cpu_to_be32(logout
->time_to_wait
);
1484 resp_hdr
->t2retain
= cpu_to_be32(logout
->time_to_retain
);
1486 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1488 bnx2i_conn
->ep
->state
= EP_STATE_LOGOUT_RESP_RCVD
;
1490 spin_unlock(&session
->lock
);
1495 * bnx2i_process_nopin_local_cmpl - this function handles iscsi nopin CQE
1496 * @session: iscsi session pointer
1497 * @bnx2i_conn: iscsi connection pointer
1498 * @cqe: pointer to newly DMA'ed CQE entry for processing
1500 * process iSCSI NOPIN local completion CQE, frees IIT and command structures
1502 static void bnx2i_process_nopin_local_cmpl(struct iscsi_session
*session
,
1503 struct bnx2i_conn
*bnx2i_conn
,
1506 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1507 struct bnx2i_nop_in_msg
*nop_in
;
1508 struct iscsi_task
*task
;
1510 nop_in
= (struct bnx2i_nop_in_msg
*)cqe
;
1511 spin_lock(&session
->lock
);
1512 task
= iscsi_itt_to_task(conn
,
1513 nop_in
->itt
& ISCSI_NOP_IN_MSG_INDEX
);
1515 iscsi_put_task(task
);
1516 spin_unlock(&session
->lock
);
1520 * bnx2i_unsol_pdu_adjust_rq - makes adjustments to RQ after unsol pdu is recvd
1521 * @conn: iscsi connection
1523 * Firmware advances RQ producer index for every unsolicited PDU even if
1524 * payload data length is '0'. This function makes corresponding
1525 * adjustments on the driver side to match this f/w behavior
1527 static void bnx2i_unsol_pdu_adjust_rq(struct bnx2i_conn
*bnx2i_conn
)
1529 char dummy_rq_data
[2];
1530 bnx2i_get_rq_buf(bnx2i_conn
, dummy_rq_data
, 1);
1531 bnx2i_put_rq_buf(bnx2i_conn
, 1);
1536 * bnx2i_process_nopin_mesg - this function handles iscsi nopin CQE
1537 * @session: iscsi session pointer
1538 * @bnx2i_conn: iscsi connection pointer
1539 * @cqe: pointer to newly DMA'ed CQE entry for processing
1541 * process iSCSI target's proactive iSCSI NOPIN request
1543 static int bnx2i_process_nopin_mesg(struct iscsi_session
*session
,
1544 struct bnx2i_conn
*bnx2i_conn
,
1547 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1548 struct iscsi_task
*task
;
1549 struct bnx2i_nop_in_msg
*nop_in
;
1550 struct iscsi_nopin
*hdr
;
1552 int tgt_async_nop
= 0;
1554 nop_in
= (struct bnx2i_nop_in_msg
*)cqe
;
1555 itt
= nop_in
->itt
& ISCSI_NOP_IN_MSG_INDEX
;
1557 spin_lock(&session
->lock
);
1558 hdr
= (struct iscsi_nopin
*)&bnx2i_conn
->gen_pdu
.resp_hdr
;
1559 memset(hdr
, 0, sizeof(struct iscsi_hdr
));
1560 hdr
->opcode
= nop_in
->op_code
;
1561 hdr
->max_cmdsn
= cpu_to_be32(nop_in
->max_cmd_sn
);
1562 hdr
->exp_cmdsn
= cpu_to_be32(nop_in
->exp_cmd_sn
);
1563 hdr
->ttt
= cpu_to_be32(nop_in
->ttt
);
1565 if (itt
== (u16
) RESERVED_ITT
) {
1566 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1567 hdr
->itt
= RESERVED_ITT
;
1572 /* this is a response to one of our nop-outs */
1573 task
= iscsi_itt_to_task(conn
, itt
);
1575 hdr
->flags
= ISCSI_FLAG_CMD_FINAL
;
1576 hdr
->itt
= task
->hdr
->itt
;
1577 hdr
->ttt
= cpu_to_be32(nop_in
->ttt
);
1578 memcpy(hdr
->lun
, nop_in
->lun
, 8);
1581 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
, NULL
, 0);
1582 spin_unlock(&session
->lock
);
1584 return tgt_async_nop
;
1589 * bnx2i_process_async_mesg - this function handles iscsi async message
1590 * @session: iscsi session pointer
1591 * @bnx2i_conn: iscsi connection pointer
1592 * @cqe: pointer to newly DMA'ed CQE entry for processing
1594 * process iSCSI ASYNC Message
1596 static void bnx2i_process_async_mesg(struct iscsi_session
*session
,
1597 struct bnx2i_conn
*bnx2i_conn
,
1600 struct bnx2i_async_msg
*async_cqe
;
1601 struct iscsi_async
*resp_hdr
;
1604 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1606 async_cqe
= (struct bnx2i_async_msg
*)cqe
;
1607 async_event
= async_cqe
->async_event
;
1609 if (async_event
== ISCSI_ASYNC_MSG_SCSI_EVENT
) {
1610 iscsi_conn_printk(KERN_ALERT
, bnx2i_conn
->cls_conn
->dd_data
,
1611 "async: scsi events not supported\n");
1615 spin_lock(&session
->lock
);
1616 resp_hdr
= (struct iscsi_async
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1617 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1618 resp_hdr
->opcode
= async_cqe
->op_code
;
1619 resp_hdr
->flags
= 0x80;
1621 memcpy(resp_hdr
->lun
, async_cqe
->lun
, 8);
1622 resp_hdr
->exp_cmdsn
= cpu_to_be32(async_cqe
->exp_cmd_sn
);
1623 resp_hdr
->max_cmdsn
= cpu_to_be32(async_cqe
->max_cmd_sn
);
1625 resp_hdr
->async_event
= async_cqe
->async_event
;
1626 resp_hdr
->async_vcode
= async_cqe
->async_vcode
;
1628 resp_hdr
->param1
= cpu_to_be16(async_cqe
->param1
);
1629 resp_hdr
->param2
= cpu_to_be16(async_cqe
->param2
);
1630 resp_hdr
->param3
= cpu_to_be16(async_cqe
->param3
);
1632 __iscsi_complete_pdu(bnx2i_conn
->cls_conn
->dd_data
,
1633 (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1634 spin_unlock(&session
->lock
);
1639 * bnx2i_process_reject_mesg - process iscsi reject pdu
1640 * @session: iscsi session pointer
1641 * @bnx2i_conn: iscsi connection pointer
1642 * @cqe: pointer to newly DMA'ed CQE entry for processing
1644 * process iSCSI REJECT message
1646 static void bnx2i_process_reject_mesg(struct iscsi_session
*session
,
1647 struct bnx2i_conn
*bnx2i_conn
,
1650 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1651 struct bnx2i_reject_msg
*reject
;
1652 struct iscsi_reject
*hdr
;
1654 reject
= (struct bnx2i_reject_msg
*) cqe
;
1655 if (reject
->data_length
) {
1656 bnx2i_get_rq_buf(bnx2i_conn
, conn
->data
, reject
->data_length
);
1657 bnx2i_put_rq_buf(bnx2i_conn
, 1);
1659 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1661 spin_lock(&session
->lock
);
1662 hdr
= (struct iscsi_reject
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1663 memset(hdr
, 0, sizeof(struct iscsi_hdr
));
1664 hdr
->opcode
= reject
->op_code
;
1665 hdr
->reason
= reject
->reason
;
1666 hton24(hdr
->dlength
, reject
->data_length
);
1667 hdr
->max_cmdsn
= cpu_to_be32(reject
->max_cmd_sn
);
1668 hdr
->exp_cmdsn
= cpu_to_be32(reject
->exp_cmd_sn
);
1669 hdr
->ffffffff
= cpu_to_be32(RESERVED_ITT
);
1670 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
, conn
->data
,
1671 reject
->data_length
);
1672 spin_unlock(&session
->lock
);
1676 * bnx2i_process_cmd_cleanup_resp - process scsi command clean-up completion
1677 * @session: iscsi session pointer
1678 * @bnx2i_conn: iscsi connection pointer
1679 * @cqe: pointer to newly DMA'ed CQE entry for processing
1681 * process command cleanup response CQE during conn shutdown or error recovery
1683 static void bnx2i_process_cmd_cleanup_resp(struct iscsi_session
*session
,
1684 struct bnx2i_conn
*bnx2i_conn
,
1687 struct bnx2i_cleanup_response
*cmd_clean_rsp
;
1688 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1689 struct iscsi_task
*task
;
1691 cmd_clean_rsp
= (struct bnx2i_cleanup_response
*)cqe
;
1692 spin_lock(&session
->lock
);
1693 task
= iscsi_itt_to_task(conn
,
1694 cmd_clean_rsp
->itt
& ISCSI_CLEANUP_RESPONSE_INDEX
);
1696 printk(KERN_ALERT
"bnx2i: cmd clean ITT %x not active\n",
1697 cmd_clean_rsp
->itt
& ISCSI_CLEANUP_RESPONSE_INDEX
);
1698 spin_unlock(&session
->lock
);
1699 complete(&bnx2i_conn
->cmd_cleanup_cmpl
);
1705 * bnx2i_process_new_cqes - process newly DMA'ed CQE's
1706 * @bnx2i_conn: iscsi connection
1708 * this function is called by generic KCQ handler to process all pending CQE's
1710 static void bnx2i_process_new_cqes(struct bnx2i_conn
*bnx2i_conn
)
1712 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1713 struct iscsi_session
*session
= conn
->session
;
1714 struct qp_info
*qp
= &bnx2i_conn
->ep
->qp
;
1715 struct bnx2i_nop_in_msg
*nopin
;
1719 nopin
= (struct bnx2i_nop_in_msg
*) qp
->cq_cons_qe
;
1720 if (nopin
->cq_req_sn
!= qp
->cqe_exp_seq_sn
)
1723 if (unlikely(test_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
)))
1728 switch (nopin
->op_code
) {
1729 case ISCSI_OP_SCSI_CMD_RSP
:
1730 case ISCSI_OP_SCSI_DATA_IN
:
1731 bnx2i_process_scsi_cmd_resp(session
, bnx2i_conn
,
1734 case ISCSI_OP_LOGIN_RSP
:
1735 bnx2i_process_login_resp(session
, bnx2i_conn
,
1738 case ISCSI_OP_SCSI_TMFUNC_RSP
:
1739 bnx2i_process_tmf_resp(session
, bnx2i_conn
,
1742 case ISCSI_OP_LOGOUT_RSP
:
1743 bnx2i_process_logout_resp(session
, bnx2i_conn
,
1746 case ISCSI_OP_NOOP_IN
:
1747 if (bnx2i_process_nopin_mesg(session
, bnx2i_conn
,
1751 case ISCSI_OPCODE_NOPOUT_LOCAL_COMPLETION
:
1752 bnx2i_process_nopin_local_cmpl(session
, bnx2i_conn
,
1755 case ISCSI_OP_ASYNC_EVENT
:
1756 bnx2i_process_async_mesg(session
, bnx2i_conn
,
1760 case ISCSI_OP_REJECT
:
1761 bnx2i_process_reject_mesg(session
, bnx2i_conn
,
1764 case ISCSI_OPCODE_CLEANUP_RESPONSE
:
1765 bnx2i_process_cmd_cleanup_resp(session
, bnx2i_conn
,
1769 printk(KERN_ALERT
"bnx2i: unknown opcode 0x%x\n",
1774 bnx2i_conn
->ep
->num_active_cmds
--;
1776 /* clear out in production version only, till beta keep opcode
1777 * field intact, will be helpful in debugging (context dump)
1778 * nopin->op_code = 0;
1780 qp
->cqe_exp_seq_sn
++;
1781 if (qp
->cqe_exp_seq_sn
== (qp
->cqe_size
* 2 + 1))
1782 qp
->cqe_exp_seq_sn
= ISCSI_INITIAL_SN
;
1784 if (qp
->cq_cons_qe
== qp
->cq_last_qe
) {
1785 qp
->cq_cons_qe
= qp
->cq_first_qe
;
1786 qp
->cq_cons_idx
= 0;
1792 bnx2i_arm_cq_event_coalescing(bnx2i_conn
->ep
, CNIC_ARM_CQE
);
1796 * bnx2i_fastpath_notification - process global event queue (KCQ)
1797 * @hba: adapter structure pointer
1798 * @new_cqe_kcqe: pointer to newly DMA'ed KCQE entry
1800 * Fast path event notification handler, KCQ entry carries context id
1801 * of the connection that has 1 or more pending CQ entries
1803 static void bnx2i_fastpath_notification(struct bnx2i_hba
*hba
,
1804 struct iscsi_kcqe
*new_cqe_kcqe
)
1806 struct bnx2i_conn
*conn
;
1809 iscsi_cid
= new_cqe_kcqe
->iscsi_conn_id
;
1810 conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1813 printk(KERN_ALERT
"cid #%x not valid\n", iscsi_cid
);
1817 printk(KERN_ALERT
"cid #%x - ep not bound\n", iscsi_cid
);
1821 bnx2i_process_new_cqes(conn
);
1826 * bnx2i_process_update_conn_cmpl - process iscsi conn update completion KCQE
1827 * @hba: adapter structure pointer
1828 * @update_kcqe: kcqe pointer
1830 * CONN_UPDATE completion handler, this completes iSCSI connection FFP migration
1832 static void bnx2i_process_update_conn_cmpl(struct bnx2i_hba
*hba
,
1833 struct iscsi_kcqe
*update_kcqe
)
1835 struct bnx2i_conn
*conn
;
1838 iscsi_cid
= update_kcqe
->iscsi_conn_id
;
1839 conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1842 printk(KERN_ALERT
"conn_update: cid %x not valid\n", iscsi_cid
);
1846 printk(KERN_ALERT
"cid %x does not have ep bound\n", iscsi_cid
);
1850 if (update_kcqe
->completion_status
) {
1851 printk(KERN_ALERT
"request failed cid %x\n", iscsi_cid
);
1852 conn
->ep
->state
= EP_STATE_ULP_UPDATE_FAILED
;
1854 conn
->ep
->state
= EP_STATE_ULP_UPDATE_COMPL
;
1856 wake_up_interruptible(&conn
->ep
->ofld_wait
);
1861 * bnx2i_recovery_que_add_conn - add connection to recovery queue
1862 * @hba: adapter structure pointer
1863 * @bnx2i_conn: iscsi connection
1865 * Add connection to recovery queue and schedule adapter eh worker
1867 static void bnx2i_recovery_que_add_conn(struct bnx2i_hba
*hba
,
1868 struct bnx2i_conn
*bnx2i_conn
)
1870 iscsi_conn_failure(bnx2i_conn
->cls_conn
->dd_data
,
1871 ISCSI_ERR_CONN_FAILED
);
1876 * bnx2i_process_tcp_error - process error notification on a given connection
1878 * @hba: adapter structure pointer
1879 * @tcp_err: tcp error kcqe pointer
1881 * handles tcp level error notifications from FW.
1883 static void bnx2i_process_tcp_error(struct bnx2i_hba
*hba
,
1884 struct iscsi_kcqe
*tcp_err
)
1886 struct bnx2i_conn
*bnx2i_conn
;
1889 iscsi_cid
= tcp_err
->iscsi_conn_id
;
1890 bnx2i_conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1893 printk(KERN_ALERT
"bnx2i - cid 0x%x not valid\n", iscsi_cid
);
1897 printk(KERN_ALERT
"bnx2i - cid 0x%x had TCP errors, error code 0x%x\n",
1898 iscsi_cid
, tcp_err
->completion_status
);
1899 bnx2i_recovery_que_add_conn(bnx2i_conn
->hba
, bnx2i_conn
);
1904 * bnx2i_process_iscsi_error - process error notification on a given connection
1905 * @hba: adapter structure pointer
1906 * @iscsi_err: iscsi error kcqe pointer
1908 * handles iscsi error notifications from the FW. Firmware based in initial
1909 * handshake classifies iscsi protocol / TCP rfc violation into either
1910 * warning or error indications. If indication is of "Error" type, driver
1911 * will initiate session recovery for that connection/session. For
1912 * "Warning" type indication, driver will put out a system log message
1913 * (there will be only one message for each type for the life of the
1914 * session, this is to avoid un-necessarily overloading the system)
1916 static void bnx2i_process_iscsi_error(struct bnx2i_hba
*hba
,
1917 struct iscsi_kcqe
*iscsi_err
)
1919 struct bnx2i_conn
*bnx2i_conn
;
1921 char warn_notice
[] = "iscsi_warning";
1922 char error_notice
[] = "iscsi_error";
1923 char additional_notice
[64];
1928 iscsi_cid
= iscsi_err
->iscsi_conn_id
;
1929 bnx2i_conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1931 printk(KERN_ALERT
"bnx2i - cid 0x%x not valid\n", iscsi_cid
);
1935 err_mask64
= (0x1ULL
<< iscsi_err
->completion_status
);
1937 if (err_mask64
& iscsi_error_mask
) {
1939 message
= warn_notice
;
1942 message
= error_notice
;
1945 switch (iscsi_err
->completion_status
) {
1946 case ISCSI_KCQE_COMPLETION_STATUS_HDR_DIG_ERR
:
1947 strcpy(additional_notice
, "hdr digest err");
1949 case ISCSI_KCQE_COMPLETION_STATUS_DATA_DIG_ERR
:
1950 strcpy(additional_notice
, "data digest err");
1952 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_OPCODE
:
1953 strcpy(additional_notice
, "wrong opcode rcvd");
1955 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_AHS_LEN
:
1956 strcpy(additional_notice
, "AHS len > 0 rcvd");
1958 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ITT
:
1959 strcpy(additional_notice
, "invalid ITT rcvd");
1961 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_STATSN
:
1962 strcpy(additional_notice
, "wrong StatSN rcvd");
1964 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN
:
1965 strcpy(additional_notice
, "wrong DataSN rcvd");
1967 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T
:
1968 strcpy(additional_notice
, "pend R2T violation");
1970 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_0
:
1971 strcpy(additional_notice
, "ERL0, UO");
1973 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_1
:
1974 strcpy(additional_notice
, "ERL0, U1");
1976 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_2
:
1977 strcpy(additional_notice
, "ERL0, U2");
1979 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_3
:
1980 strcpy(additional_notice
, "ERL0, U3");
1982 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_4
:
1983 strcpy(additional_notice
, "ERL0, U4");
1985 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_5
:
1986 strcpy(additional_notice
, "ERL0, U5");
1988 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_6
:
1989 strcpy(additional_notice
, "ERL0, U6");
1991 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_RCV_LEN
:
1992 strcpy(additional_notice
, "invalid resi len");
1994 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_RCV_PDU_LEN
:
1995 strcpy(additional_notice
, "MRDSL violation");
1997 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_F_BIT_ZERO
:
1998 strcpy(additional_notice
, "F-bit not set");
2000 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV
:
2001 strcpy(additional_notice
, "invalid TTT");
2003 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATASN
:
2004 strcpy(additional_notice
, "invalid DataSN");
2006 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_BURST_LEN
:
2007 strcpy(additional_notice
, "burst len violation");
2009 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_BUFFER_OFF
:
2010 strcpy(additional_notice
, "buf offset violation");
2012 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN
:
2013 strcpy(additional_notice
, "invalid LUN field");
2015 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_R2TSN
:
2016 strcpy(additional_notice
, "invalid R2TSN field");
2018 #define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0 \
2019 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_0
2020 case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0
:
2021 strcpy(additional_notice
, "invalid cmd len1");
2023 #define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1 \
2024 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_1
2025 case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1
:
2026 strcpy(additional_notice
, "invalid cmd len2");
2028 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_EXCEED
:
2029 strcpy(additional_notice
,
2030 "pend r2t exceeds MaxOutstandingR2T value");
2032 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_IS_RSRV
:
2033 strcpy(additional_notice
, "TTT is rsvd");
2035 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_BURST_LEN
:
2036 strcpy(additional_notice
, "MBL violation");
2038 #define BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO \
2039 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATA_SEG_LEN_NOT_ZERO
2040 case BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO
:
2041 strcpy(additional_notice
, "data seg len != 0");
2043 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REJECT_PDU_LEN
:
2044 strcpy(additional_notice
, "reject pdu len error");
2046 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ASYNC_PDU_LEN
:
2047 strcpy(additional_notice
, "async pdu len error");
2049 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_NOPIN_PDU_LEN
:
2050 strcpy(additional_notice
, "nopin pdu len error");
2052 #define BNX2_ERR_PEND_R2T_IN_CLEANUP \
2053 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_IN_CLEANUP
2054 case BNX2_ERR_PEND_R2T_IN_CLEANUP
:
2055 strcpy(additional_notice
, "pend r2t in cleanup");
2058 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_FRAGMENT
:
2059 strcpy(additional_notice
, "IP fragments rcvd");
2061 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_OPTIONS
:
2062 strcpy(additional_notice
, "IP options error");
2064 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_URGENT_FLAG
:
2065 strcpy(additional_notice
, "urgent flag error");
2068 printk(KERN_ALERT
"iscsi_err - unknown err %x\n",
2069 iscsi_err
->completion_status
);
2072 if (need_recovery
) {
2073 iscsi_conn_printk(KERN_ALERT
,
2074 bnx2i_conn
->cls_conn
->dd_data
,
2076 message
, additional_notice
);
2078 iscsi_conn_printk(KERN_ALERT
,
2079 bnx2i_conn
->cls_conn
->dd_data
,
2080 "conn_err - hostno %d conn %p, "
2081 "iscsi_cid %x cid %x\n",
2082 bnx2i_conn
->hba
->shost
->host_no
,
2083 bnx2i_conn
, bnx2i_conn
->ep
->ep_iscsi_cid
,
2084 bnx2i_conn
->ep
->ep_cid
);
2085 bnx2i_recovery_que_add_conn(bnx2i_conn
->hba
, bnx2i_conn
);
2087 if (!test_and_set_bit(iscsi_err
->completion_status
,
2088 (void *) &bnx2i_conn
->violation_notified
))
2089 iscsi_conn_printk(KERN_ALERT
,
2090 bnx2i_conn
->cls_conn
->dd_data
,
2092 message
, additional_notice
);
2097 * bnx2i_process_conn_destroy_cmpl - process iscsi conn destroy completion
2098 * @hba: adapter structure pointer
2099 * @conn_destroy: conn destroy kcqe pointer
2101 * handles connection destroy completion request.
2103 static void bnx2i_process_conn_destroy_cmpl(struct bnx2i_hba
*hba
,
2104 struct iscsi_kcqe
*conn_destroy
)
2106 struct bnx2i_endpoint
*ep
;
2108 ep
= bnx2i_find_ep_in_destroy_list(hba
, conn_destroy
->iscsi_conn_id
);
2110 printk(KERN_ALERT
"bnx2i_conn_destroy_cmpl: no pending "
2111 "offload request, unexpected complection\n");
2115 if (hba
!= ep
->hba
) {
2116 printk(KERN_ALERT
"conn destroy- error hba mis-match\n");
2120 if (conn_destroy
->completion_status
) {
2121 printk(KERN_ALERT
"conn_destroy_cmpl: op failed\n");
2122 ep
->state
= EP_STATE_CLEANUP_FAILED
;
2124 ep
->state
= EP_STATE_CLEANUP_CMPL
;
2125 wake_up_interruptible(&ep
->ofld_wait
);
2130 * bnx2i_process_ofld_cmpl - process initial iscsi conn offload completion
2131 * @hba: adapter structure pointer
2132 * @ofld_kcqe: conn offload kcqe pointer
2134 * handles initial connection offload completion, ep_connect() thread is
2135 * woken-up to continue with LLP connect process
2137 static void bnx2i_process_ofld_cmpl(struct bnx2i_hba
*hba
,
2138 struct iscsi_kcqe
*ofld_kcqe
)
2141 struct bnx2i_endpoint
*ep
;
2144 ep
= bnx2i_find_ep_in_ofld_list(hba
, ofld_kcqe
->iscsi_conn_id
);
2146 printk(KERN_ALERT
"ofld_cmpl: no pend offload request\n");
2150 if (hba
!= ep
->hba
) {
2151 printk(KERN_ALERT
"ofld_cmpl: error hba mis-match\n");
2155 if (ofld_kcqe
->completion_status
) {
2156 if (ofld_kcqe
->completion_status
==
2157 ISCSI_KCQE_COMPLETION_STATUS_CTX_ALLOC_FAILURE
)
2158 printk(KERN_ALERT
"bnx2i: unable to allocate"
2159 " iSCSI context resources\n");
2160 ep
->state
= EP_STATE_OFLD_FAILED
;
2162 ep
->state
= EP_STATE_OFLD_COMPL
;
2163 cid_addr
= ofld_kcqe
->iscsi_conn_context_id
;
2164 cid_num
= bnx2i_get_cid_num(ep
);
2165 ep
->ep_cid
= cid_addr
;
2166 ep
->qp
.ctx_base
= NULL
;
2168 wake_up_interruptible(&ep
->ofld_wait
);
2172 * bnx2i_indicate_kcqe - process iscsi conn update completion KCQE
2173 * @hba: adapter structure pointer
2174 * @update_kcqe: kcqe pointer
2176 * Generic KCQ event handler/dispatcher
2178 static void bnx2i_indicate_kcqe(void *context
, struct kcqe
*kcqe
[],
2181 struct bnx2i_hba
*hba
= context
;
2183 struct iscsi_kcqe
*ikcqe
= NULL
;
2185 while (i
< num_cqe
) {
2186 ikcqe
= (struct iscsi_kcqe
*) kcqe
[i
++];
2188 if (ikcqe
->op_code
==
2189 ISCSI_KCQE_OPCODE_CQ_EVENT_NOTIFICATION
)
2190 bnx2i_fastpath_notification(hba
, ikcqe
);
2191 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_OFFLOAD_CONN
)
2192 bnx2i_process_ofld_cmpl(hba
, ikcqe
);
2193 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_UPDATE_CONN
)
2194 bnx2i_process_update_conn_cmpl(hba
, ikcqe
);
2195 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_INIT
) {
2196 if (ikcqe
->completion_status
!=
2197 ISCSI_KCQE_COMPLETION_STATUS_SUCCESS
)
2198 bnx2i_iscsi_license_error(hba
, ikcqe
->\
2201 set_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
);
2202 bnx2i_get_link_state(hba
);
2203 printk(KERN_INFO
"bnx2i [%.2x:%.2x.%.2x]: "
2204 "ISCSI_INIT passed\n",
2205 (u8
)hba
->pcidev
->bus
->number
,
2211 } else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_DESTROY_CONN
)
2212 bnx2i_process_conn_destroy_cmpl(hba
, ikcqe
);
2213 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_ISCSI_ERROR
)
2214 bnx2i_process_iscsi_error(hba
, ikcqe
);
2215 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_TCP_ERROR
)
2216 bnx2i_process_tcp_error(hba
, ikcqe
);
2218 printk(KERN_ALERT
"bnx2i: unknown opcode 0x%x\n",
2225 * bnx2i_indicate_netevent - Generic netdev event handler
2226 * @context: adapter structure pointer
2227 * @event: event type
2229 * Handles four netdev events, NETDEV_UP, NETDEV_DOWN,
2230 * NETDEV_GOING_DOWN and NETDEV_CHANGE
2232 static void bnx2i_indicate_netevent(void *context
, unsigned long event
)
2234 struct bnx2i_hba
*hba
= context
;
2238 if (!test_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
))
2239 bnx2i_send_fw_iscsi_init_msg(hba
);
2242 clear_bit(ADAPTER_STATE_GOING_DOWN
, &hba
->adapter_state
);
2243 clear_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
);
2245 case NETDEV_GOING_DOWN
:
2246 set_bit(ADAPTER_STATE_GOING_DOWN
, &hba
->adapter_state
);
2247 iscsi_host_for_each_session(hba
->shost
,
2248 bnx2i_drop_session
);
2251 bnx2i_get_link_state(hba
);
2260 * bnx2i_cm_connect_cmpl - process iscsi conn establishment completion
2261 * @cm_sk: cnic sock structure pointer
2263 * function callback exported via bnx2i - cnic driver interface to
2264 * indicate completion of option-2 TCP connect request.
2266 static void bnx2i_cm_connect_cmpl(struct cnic_sock
*cm_sk
)
2268 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2270 if (test_bit(ADAPTER_STATE_GOING_DOWN
, &ep
->hba
->adapter_state
))
2271 ep
->state
= EP_STATE_CONNECT_FAILED
;
2272 else if (test_bit(SK_F_OFFLD_COMPLETE
, &cm_sk
->flags
))
2273 ep
->state
= EP_STATE_CONNECT_COMPL
;
2275 ep
->state
= EP_STATE_CONNECT_FAILED
;
2277 wake_up_interruptible(&ep
->ofld_wait
);
2282 * bnx2i_cm_close_cmpl - process tcp conn close completion
2283 * @cm_sk: cnic sock structure pointer
2285 * function callback exported via bnx2i - cnic driver interface to
2286 * indicate completion of option-2 graceful TCP connect shutdown
2288 static void bnx2i_cm_close_cmpl(struct cnic_sock
*cm_sk
)
2290 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2292 ep
->state
= EP_STATE_DISCONN_COMPL
;
2293 wake_up_interruptible(&ep
->ofld_wait
);
2298 * bnx2i_cm_abort_cmpl - process abortive tcp conn teardown completion
2299 * @cm_sk: cnic sock structure pointer
2301 * function callback exported via bnx2i - cnic driver interface to
2302 * indicate completion of option-2 abortive TCP connect termination
2304 static void bnx2i_cm_abort_cmpl(struct cnic_sock
*cm_sk
)
2306 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2308 ep
->state
= EP_STATE_DISCONN_COMPL
;
2309 wake_up_interruptible(&ep
->ofld_wait
);
2314 * bnx2i_cm_remote_close - process received TCP FIN
2315 * @hba: adapter structure pointer
2316 * @update_kcqe: kcqe pointer
2318 * function callback exported via bnx2i - cnic driver interface to indicate
2319 * async TCP events such as FIN
2321 static void bnx2i_cm_remote_close(struct cnic_sock
*cm_sk
)
2323 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2325 ep
->state
= EP_STATE_TCP_FIN_RCVD
;
2327 bnx2i_recovery_que_add_conn(ep
->hba
, ep
->conn
);
2331 * bnx2i_cm_remote_abort - process TCP RST and start conn cleanup
2332 * @hba: adapter structure pointer
2333 * @update_kcqe: kcqe pointer
2335 * function callback exported via bnx2i - cnic driver interface to
2336 * indicate async TCP events (RST) sent by the peer.
2338 static void bnx2i_cm_remote_abort(struct cnic_sock
*cm_sk
)
2340 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2342 ep
->state
= EP_STATE_TCP_RST_RCVD
;
2344 bnx2i_recovery_que_add_conn(ep
->hba
, ep
->conn
);
2348 static void bnx2i_send_nl_mesg(struct cnic_dev
*dev
, u32 msg_type
,
2349 char *buf
, u16 buflen
)
2351 struct bnx2i_hba
*hba
;
2353 hba
= bnx2i_find_hba_for_cnic(dev
);
2357 if (iscsi_offload_mesg(hba
->shost
, &bnx2i_iscsi_transport
,
2358 msg_type
, buf
, buflen
))
2359 printk(KERN_ALERT
"bnx2i: private nl message send error\n");
2365 * bnx2i_cnic_cb - global template of bnx2i - cnic driver interface structure
2366 * carrying callback function pointers
2369 struct cnic_ulp_ops bnx2i_cnic_cb
= {
2370 .cnic_init
= bnx2i_ulp_init
,
2371 .cnic_exit
= bnx2i_ulp_exit
,
2372 .cnic_start
= bnx2i_start
,
2373 .cnic_stop
= bnx2i_stop
,
2374 .indicate_kcqes
= bnx2i_indicate_kcqe
,
2375 .indicate_netevent
= bnx2i_indicate_netevent
,
2376 .cm_connect_complete
= bnx2i_cm_connect_cmpl
,
2377 .cm_close_complete
= bnx2i_cm_close_cmpl
,
2378 .cm_abort_complete
= bnx2i_cm_abort_cmpl
,
2379 .cm_remote_close
= bnx2i_cm_remote_close
,
2380 .cm_remote_abort
= bnx2i_cm_remote_abort
,
2381 .iscsi_nl_send_msg
= bnx2i_send_nl_mesg
,
2382 .owner
= THIS_MODULE
2387 * bnx2i_map_ep_dbell_regs - map connection doorbell registers
2388 * @ep: bnx2i endpoint
2390 * maps connection's SQ and RQ doorbell registers, 5706/5708/5709 hosts these
2391 * register in BAR #0. Whereas in 57710 these register are accessed by
2394 int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint
*ep
)
2401 resource_size_t reg_base
;
2403 cid_num
= bnx2i_get_cid_num(ep
);
2405 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
2406 reg_base
= pci_resource_start(ep
->hba
->pcidev
,
2407 BNX2X_DOORBELL_PCI_BAR
);
2408 reg_off
= PAGE_SIZE
* (cid_num
& 0x1FFFF) + DPM_TRIGER_TYPE
;
2409 ep
->qp
.ctx_base
= ioremap_nocache(reg_base
+ reg_off
, 4);
2413 reg_base
= ep
->hba
->netdev
->base_addr
;
2414 if ((test_bit(BNX2I_NX2_DEV_5709
, &ep
->hba
->cnic_dev_type
)) &&
2415 (ep
->hba
->mail_queue_access
== BNX2I_MQ_BIN_MODE
)) {
2416 config2
= REG_RD(ep
->hba
, BNX2_MQ_CONFIG2
);
2417 first_l4l5
= config2
& BNX2_MQ_CONFIG2_FIRST_L4L5
;
2418 ctx_sz
= (config2
& BNX2_MQ_CONFIG2_CONT_SZ
) >> 3;
2420 reg_off
= CTX_OFFSET
+ MAX_CID_CNT
* MB_KERNEL_CTX_SIZE
2421 + BNX2I_570X_PAGE_SIZE_DEFAULT
*
2422 (((cid_num
- first_l4l5
) / ctx_sz
) + 256);
2424 reg_off
= CTX_OFFSET
+ (MB_KERNEL_CTX_SIZE
* cid_num
);
2426 /* 5709 device in normal node and 5706/5708 devices */
2427 reg_off
= CTX_OFFSET
+ (MB_KERNEL_CTX_SIZE
* cid_num
);
2429 ep
->qp
.ctx_base
= ioremap_nocache(reg_base
+ reg_off
,
2430 MB_KERNEL_CTX_SIZE
);
2431 if (!ep
->qp
.ctx_base
)
2435 bnx2i_arm_cq_event_coalescing(ep
, CNIC_ARM_CQE
);