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
;
389 bnx2i_cmd
= (struct bnx2i_cmd
*)mtask
->dd_data
;
390 tmfabort_hdr
= (struct iscsi_tm
*)mtask
->hdr
;
391 tmfabort_wqe
= (struct bnx2i_tmf_request
*)
392 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
394 tmfabort_wqe
->op_code
= tmfabort_hdr
->opcode
;
395 tmfabort_wqe
->op_attr
= tmfabort_hdr
->flags
;
397 tmfabort_wqe
->itt
= (mtask
->itt
| (ISCSI_TASK_TYPE_MPATH
<< 14));
398 tmfabort_wqe
->reserved2
= 0;
399 tmfabort_wqe
->cmd_sn
= be32_to_cpu(tmfabort_hdr
->cmdsn
);
401 switch (tmfabort_hdr
->flags
& ISCSI_FLAG_TM_FUNC_MASK
) {
402 case ISCSI_TM_FUNC_ABORT_TASK
:
403 case ISCSI_TM_FUNC_TASK_REASSIGN
:
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
410 * Note: In the case of a SCSI cmd timeout, the task's
411 * sc is still active; hence ctask->sc != 0
412 * In this case, the task must be aborted
417 if (ref_sc
->sc_data_direction
== DMA_TO_DEVICE
)
418 dword
= (ISCSI_TASK_TYPE_WRITE
<<
419 ISCSI_CMD_REQUEST_TYPE_SHIFT
);
421 dword
= (ISCSI_TASK_TYPE_READ
<<
422 ISCSI_CMD_REQUEST_TYPE_SHIFT
);
423 tmfabort_wqe
->ref_itt
= (dword
|
424 (tmfabort_hdr
->rtt
& ISCSI_ITT_MASK
));
427 tmfabort_wqe
->ref_itt
= RESERVED_ITT
;
429 memcpy(tmfabort_wqe
->lun
, tmfabort_hdr
->lun
, sizeof(struct scsi_lun
));
430 tmfabort_wqe
->ref_cmd_sn
= be32_to_cpu(tmfabort_hdr
->refcmdsn
);
432 tmfabort_wqe
->bd_list_addr_lo
= (u32
) bnx2i_conn
->hba
->mp_bd_dma
;
433 tmfabort_wqe
->bd_list_addr_hi
= (u32
)
434 ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
435 tmfabort_wqe
->num_bds
= 1;
436 tmfabort_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
438 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
443 * bnx2i_send_iscsi_scsicmd - post iSCSI scsicmd request WQE to hardware
444 * @conn: iscsi connection
445 * @cmd: driver command structure which is requesting
446 * a WQE to sent to chip for further processing
448 * prepare and post an iSCSI SCSI-CMD request WQE to CNIC firmware
450 int bnx2i_send_iscsi_scsicmd(struct bnx2i_conn
*bnx2i_conn
,
451 struct bnx2i_cmd
*cmd
)
453 struct bnx2i_cmd_request
*scsi_cmd_wqe
;
455 scsi_cmd_wqe
= (struct bnx2i_cmd_request
*)
456 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
457 memcpy(scsi_cmd_wqe
, &cmd
->req
, sizeof(struct bnx2i_cmd_request
));
458 scsi_cmd_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
460 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
465 * bnx2i_send_iscsi_nopout - post iSCSI NOPOUT request WQE to hardware
466 * @conn: iscsi connection
467 * @cmd: driver command structure which is requesting
468 * a WQE to sent to chip for further processing
469 * @datap: payload buffer pointer
470 * @data_len: payload data length
471 * @unsol: indicated whether nopout pdu is unsolicited pdu or
472 * in response to target's NOPIN w/ TTT != FFFFFFFF
474 * prepare and post a nopout request WQE to CNIC firmware
476 int bnx2i_send_iscsi_nopout(struct bnx2i_conn
*bnx2i_conn
,
477 struct iscsi_task
*task
,
478 char *datap
, int data_len
, int unsol
)
480 struct bnx2i_endpoint
*ep
= bnx2i_conn
->ep
;
481 struct bnx2i_cmd
*bnx2i_cmd
;
482 struct bnx2i_nop_out_request
*nopout_wqe
;
483 struct iscsi_nopout
*nopout_hdr
;
485 bnx2i_cmd
= (struct bnx2i_cmd
*)task
->dd_data
;
486 nopout_hdr
= (struct iscsi_nopout
*)task
->hdr
;
487 nopout_wqe
= (struct bnx2i_nop_out_request
*)ep
->qp
.sq_prod_qe
;
488 nopout_wqe
->op_code
= nopout_hdr
->opcode
;
489 nopout_wqe
->op_attr
= ISCSI_FLAG_CMD_FINAL
;
490 memcpy(nopout_wqe
->lun
, nopout_hdr
->lun
, 8);
492 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
493 u32 tmp
= nopout_hdr
->lun
[0];
494 /* 57710 requires LUN field to be swapped */
495 nopout_hdr
->lun
[0] = nopout_hdr
->lun
[1];
496 nopout_hdr
->lun
[1] = tmp
;
499 nopout_wqe
->itt
= ((u16
)task
->itt
|
500 (ISCSI_TASK_TYPE_MPATH
<<
501 ISCSI_TMF_REQUEST_TYPE_SHIFT
));
502 nopout_wqe
->ttt
= nopout_hdr
->ttt
;
503 nopout_wqe
->flags
= 0;
505 nopout_wqe
->flags
= ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION
;
506 else if (nopout_hdr
->itt
== RESERVED_ITT
)
507 nopout_wqe
->flags
= ISCSI_NOP_OUT_REQUEST_LOCAL_COMPLETION
;
509 nopout_wqe
->cmd_sn
= be32_to_cpu(nopout_hdr
->cmdsn
);
510 nopout_wqe
->data_length
= data_len
;
512 /* handle payload data, not required in first release */
513 printk(KERN_ALERT
"NOPOUT: WARNING!! payload len != 0\n");
515 nopout_wqe
->bd_list_addr_lo
= (u32
)
516 bnx2i_conn
->hba
->mp_bd_dma
;
517 nopout_wqe
->bd_list_addr_hi
=
518 (u32
) ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
519 nopout_wqe
->num_bds
= 1;
521 nopout_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
523 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
529 * bnx2i_send_iscsi_logout - post iSCSI logout request WQE to hardware
530 * @conn: iscsi connection
531 * @cmd: driver command structure which is requesting
532 * a WQE to sent to chip for further processing
534 * prepare and post logout request WQE to CNIC firmware
536 int bnx2i_send_iscsi_logout(struct bnx2i_conn
*bnx2i_conn
,
537 struct iscsi_task
*task
)
539 struct bnx2i_cmd
*bnx2i_cmd
;
540 struct bnx2i_logout_request
*logout_wqe
;
541 struct iscsi_logout
*logout_hdr
;
543 bnx2i_cmd
= (struct bnx2i_cmd
*)task
->dd_data
;
544 logout_hdr
= (struct iscsi_logout
*)task
->hdr
;
546 logout_wqe
= (struct bnx2i_logout_request
*)
547 bnx2i_conn
->ep
->qp
.sq_prod_qe
;
548 memset(logout_wqe
, 0x00, sizeof(struct bnx2i_logout_request
));
550 logout_wqe
->op_code
= logout_hdr
->opcode
;
551 logout_wqe
->cmd_sn
= be32_to_cpu(logout_hdr
->cmdsn
);
552 logout_wqe
->op_attr
=
553 logout_hdr
->flags
| ISCSI_LOGOUT_REQUEST_ALWAYS_ONE
;
554 logout_wqe
->itt
= ((u16
)task
->itt
|
555 (ISCSI_TASK_TYPE_MPATH
<<
556 ISCSI_LOGOUT_REQUEST_TYPE_SHIFT
));
557 logout_wqe
->data_length
= 0;
560 logout_wqe
->bd_list_addr_lo
= (u32
) bnx2i_conn
->hba
->mp_bd_dma
;
561 logout_wqe
->bd_list_addr_hi
= (u32
)
562 ((u64
) bnx2i_conn
->hba
->mp_bd_dma
>> 32);
563 logout_wqe
->num_bds
= 1;
564 logout_wqe
->cq_index
= 0; /* CQ# used for completion, 5771x only */
566 bnx2i_conn
->ep
->state
= EP_STATE_LOGOUT_SENT
;
568 bnx2i_ring_dbell_update_sq_params(bnx2i_conn
, 1);
574 * bnx2i_update_iscsi_conn - post iSCSI logout request WQE to hardware
575 * @conn: iscsi connection which requires iscsi parameter update
577 * sends down iSCSI Conn Update request to move iSCSI conn to FFP
579 void bnx2i_update_iscsi_conn(struct iscsi_conn
*conn
)
581 struct bnx2i_conn
*bnx2i_conn
= conn
->dd_data
;
582 struct bnx2i_hba
*hba
= bnx2i_conn
->hba
;
583 struct kwqe
*kwqe_arr
[2];
584 struct iscsi_kwqe_conn_update
*update_wqe
;
585 struct iscsi_kwqe_conn_update conn_update_kwqe
;
587 update_wqe
= &conn_update_kwqe
;
589 update_wqe
->hdr
.op_code
= ISCSI_KWQE_OPCODE_UPDATE_CONN
;
590 update_wqe
->hdr
.flags
=
591 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
593 /* 5771x requires conn context id to be passed as is */
594 if (test_bit(BNX2I_NX2_DEV_57710
, &bnx2i_conn
->ep
->hba
->cnic_dev_type
))
595 update_wqe
->context_id
= bnx2i_conn
->ep
->ep_cid
;
597 update_wqe
->context_id
= (bnx2i_conn
->ep
->ep_cid
>> 7);
598 update_wqe
->conn_flags
= 0;
599 if (conn
->hdrdgst_en
)
600 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_HEADER_DIGEST
;
601 if (conn
->datadgst_en
)
602 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_DATA_DIGEST
;
603 if (conn
->session
->initial_r2t_en
)
604 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_INITIAL_R2T
;
605 if (conn
->session
->imm_data_en
)
606 update_wqe
->conn_flags
|= ISCSI_KWQE_CONN_UPDATE_IMMEDIATE_DATA
;
608 update_wqe
->max_send_pdu_length
= conn
->max_xmit_dlength
;
609 update_wqe
->max_recv_pdu_length
= conn
->max_recv_dlength
;
610 update_wqe
->first_burst_length
= conn
->session
->first_burst
;
611 update_wqe
->max_burst_length
= conn
->session
->max_burst
;
612 update_wqe
->exp_stat_sn
= conn
->exp_statsn
;
613 update_wqe
->max_outstanding_r2ts
= conn
->session
->max_r2t
;
614 update_wqe
->session_error_recovery_level
= conn
->session
->erl
;
615 iscsi_conn_printk(KERN_ALERT
, conn
,
616 "bnx2i: conn update - MBL 0x%x FBL 0x%x"
617 "MRDSL_I 0x%x MRDSL_T 0x%x \n",
618 update_wqe
->max_burst_length
,
619 update_wqe
->first_burst_length
,
620 update_wqe
->max_recv_pdu_length
,
621 update_wqe
->max_send_pdu_length
);
623 kwqe_arr
[0] = (struct kwqe
*) update_wqe
;
624 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
625 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 1);
630 * bnx2i_ep_ofld_timer - post iSCSI logout request WQE to hardware
631 * @data: endpoint (transport handle) structure pointer
633 * routine to handle connection offload/destroy request timeout
635 void bnx2i_ep_ofld_timer(unsigned long data
)
637 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) data
;
639 if (ep
->state
== EP_STATE_OFLD_START
) {
640 printk(KERN_ALERT
"ofld_timer: CONN_OFLD timeout\n");
641 ep
->state
= EP_STATE_OFLD_FAILED
;
642 } else if (ep
->state
== EP_STATE_DISCONN_START
) {
643 printk(KERN_ALERT
"ofld_timer: CONN_DISCON timeout\n");
644 ep
->state
= EP_STATE_DISCONN_TIMEDOUT
;
645 } else if (ep
->state
== EP_STATE_CLEANUP_START
) {
646 printk(KERN_ALERT
"ofld_timer: CONN_CLEANUP timeout\n");
647 ep
->state
= EP_STATE_CLEANUP_FAILED
;
650 wake_up_interruptible(&ep
->ofld_wait
);
654 static int bnx2i_power_of2(u32 val
)
669 * bnx2i_send_cmd_cleanup_req - send iscsi cmd context clean-up request
670 * @hba: adapter structure pointer
671 * @cmd: driver command structure which is requesting
672 * a WQE to sent to chip for further processing
674 * prepares and posts CONN_OFLD_REQ1/2 KWQE
676 void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba
*hba
, struct bnx2i_cmd
*cmd
)
678 struct bnx2i_cleanup_request
*cmd_cleanup
;
681 (struct bnx2i_cleanup_request
*)cmd
->conn
->ep
->qp
.sq_prod_qe
;
682 memset(cmd_cleanup
, 0x00, sizeof(struct bnx2i_cleanup_request
));
684 cmd_cleanup
->op_code
= ISCSI_OPCODE_CLEANUP_REQUEST
;
685 cmd_cleanup
->itt
= cmd
->req
.itt
;
686 cmd_cleanup
->cq_index
= 0; /* CQ# used for completion, 5771x only */
688 bnx2i_ring_dbell_update_sq_params(cmd
->conn
, 1);
693 * bnx2i_send_conn_destroy - initiates iscsi connection teardown process
694 * @hba: adapter structure pointer
695 * @ep: endpoint (transport indentifier) structure
697 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE to initiate
698 * iscsi connection context clean-up process
700 void bnx2i_send_conn_destroy(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
702 struct kwqe
*kwqe_arr
[2];
703 struct iscsi_kwqe_conn_destroy conn_cleanup
;
705 memset(&conn_cleanup
, 0x00, sizeof(struct iscsi_kwqe_conn_destroy
));
707 conn_cleanup
.hdr
.op_code
= ISCSI_KWQE_OPCODE_DESTROY_CONN
;
708 conn_cleanup
.hdr
.flags
=
709 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
710 /* 5771x requires conn context id to be passed as is */
711 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
712 conn_cleanup
.context_id
= ep
->ep_cid
;
714 conn_cleanup
.context_id
= (ep
->ep_cid
>> 7);
716 conn_cleanup
.reserved0
= (u16
)ep
->ep_iscsi_cid
;
718 kwqe_arr
[0] = (struct kwqe
*) &conn_cleanup
;
719 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
720 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 1);
725 * bnx2i_570x_send_conn_ofld_req - initiates iscsi conn context setup process
726 * @hba: adapter structure pointer
727 * @ep: endpoint (transport indentifier) structure
729 * 5706/5708/5709 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
731 static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba
*hba
,
732 struct bnx2i_endpoint
*ep
)
734 struct kwqe
*kwqe_arr
[2];
735 struct iscsi_kwqe_conn_offload1 ofld_req1
;
736 struct iscsi_kwqe_conn_offload2 ofld_req2
;
741 ofld_req1
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN1
;
742 ofld_req1
.hdr
.flags
=
743 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
745 ofld_req1
.iscsi_conn_id
= (u16
) ep
->ep_iscsi_cid
;
747 dma_addr
= ep
->qp
.sq_pgtbl_phys
;
748 ofld_req1
.sq_page_table_addr_lo
= (u32
) dma_addr
;
749 ofld_req1
.sq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
751 dma_addr
= ep
->qp
.cq_pgtbl_phys
;
752 ofld_req1
.cq_page_table_addr_lo
= (u32
) dma_addr
;
753 ofld_req1
.cq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
755 ofld_req2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN2
;
756 ofld_req2
.hdr
.flags
=
757 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
759 dma_addr
= ep
->qp
.rq_pgtbl_phys
;
760 ofld_req2
.rq_page_table_addr_lo
= (u32
) dma_addr
;
761 ofld_req2
.rq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
763 ptbl
= (u32
*) ep
->qp
.sq_pgtbl_virt
;
765 ofld_req2
.sq_first_pte
.hi
= *ptbl
++;
766 ofld_req2
.sq_first_pte
.lo
= *ptbl
;
768 ptbl
= (u32
*) ep
->qp
.cq_pgtbl_virt
;
769 ofld_req2
.cq_first_pte
.hi
= *ptbl
++;
770 ofld_req2
.cq_first_pte
.lo
= *ptbl
;
772 kwqe_arr
[0] = (struct kwqe
*) &ofld_req1
;
773 kwqe_arr
[1] = (struct kwqe
*) &ofld_req2
;
774 ofld_req2
.num_additional_wqes
= 0;
776 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
777 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, num_kwqes
);
782 * bnx2i_5771x_send_conn_ofld_req - initiates iscsi connection context creation
783 * @hba: adapter structure pointer
784 * @ep: endpoint (transport indentifier) structure
786 * 57710 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE
788 static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba
*hba
,
789 struct bnx2i_endpoint
*ep
)
791 struct kwqe
*kwqe_arr
[5];
792 struct iscsi_kwqe_conn_offload1 ofld_req1
;
793 struct iscsi_kwqe_conn_offload2 ofld_req2
;
794 struct iscsi_kwqe_conn_offload3 ofld_req3
[1];
799 ofld_req1
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN1
;
800 ofld_req1
.hdr
.flags
=
801 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
803 ofld_req1
.iscsi_conn_id
= (u16
) ep
->ep_iscsi_cid
;
805 dma_addr
= ep
->qp
.sq_pgtbl_phys
+ ISCSI_SQ_DB_SIZE
;
806 ofld_req1
.sq_page_table_addr_lo
= (u32
) dma_addr
;
807 ofld_req1
.sq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
809 dma_addr
= ep
->qp
.cq_pgtbl_phys
+ ISCSI_CQ_DB_SIZE
;
810 ofld_req1
.cq_page_table_addr_lo
= (u32
) dma_addr
;
811 ofld_req1
.cq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
813 ofld_req2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_OFFLOAD_CONN2
;
814 ofld_req2
.hdr
.flags
=
815 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
817 dma_addr
= ep
->qp
.rq_pgtbl_phys
+ ISCSI_RQ_DB_SIZE
;
818 ofld_req2
.rq_page_table_addr_lo
= (u32
) dma_addr
;
819 ofld_req2
.rq_page_table_addr_hi
= (u32
) ((u64
) dma_addr
>> 32);
821 ptbl
= (u32
*)((u8
*)ep
->qp
.sq_pgtbl_virt
+ ISCSI_SQ_DB_SIZE
);
822 ofld_req2
.sq_first_pte
.hi
= *ptbl
++;
823 ofld_req2
.sq_first_pte
.lo
= *ptbl
;
825 ptbl
= (u32
*)((u8
*)ep
->qp
.cq_pgtbl_virt
+ ISCSI_CQ_DB_SIZE
);
826 ofld_req2
.cq_first_pte
.hi
= *ptbl
++;
827 ofld_req2
.cq_first_pte
.lo
= *ptbl
;
829 kwqe_arr
[0] = (struct kwqe
*) &ofld_req1
;
830 kwqe_arr
[1] = (struct kwqe
*) &ofld_req2
;
832 ofld_req2
.num_additional_wqes
= 1;
833 memset(ofld_req3
, 0x00, sizeof(ofld_req3
[0]));
834 ptbl
= (u32
*)((u8
*)ep
->qp
.rq_pgtbl_virt
+ ISCSI_RQ_DB_SIZE
);
835 ofld_req3
[0].qp_first_pte
[0].hi
= *ptbl
++;
836 ofld_req3
[0].qp_first_pte
[0].lo
= *ptbl
;
838 kwqe_arr
[2] = (struct kwqe
*) ofld_req3
;
839 /* need if we decide to go with multiple KCQE's per conn */
842 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
843 hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, num_kwqes
);
847 * bnx2i_send_conn_ofld_req - initiates iscsi connection context setup process
849 * @hba: adapter structure pointer
850 * @ep: endpoint (transport indentifier) structure
852 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE
854 void bnx2i_send_conn_ofld_req(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
856 if (test_bit(BNX2I_NX2_DEV_57710
, &hba
->cnic_dev_type
))
857 bnx2i_5771x_send_conn_ofld_req(hba
, ep
);
859 bnx2i_570x_send_conn_ofld_req(hba
, ep
);
864 * setup_qp_page_tables - iscsi QP page table setup function
865 * @ep: endpoint (transport indentifier) structure
867 * Sets up page tables for SQ/RQ/CQ, 1G/sec (5706/5708/5709) devices requires
868 * 64-bit address in big endian format. Whereas 10G/sec (57710) requires
869 * PT in little endian format
871 static void setup_qp_page_tables(struct bnx2i_endpoint
*ep
)
878 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
))
884 memset(ep
->qp
.sq_pgtbl_virt
, 0, ep
->qp
.sq_pgtbl_size
);
885 num_pages
= ep
->qp
.sq_mem_size
/ PAGE_SIZE
;
886 page
= ep
->qp
.sq_phys
;
889 ptbl
= (u32
*)((u8
*)ep
->qp
.sq_pgtbl_virt
+ ISCSI_SQ_DB_SIZE
);
891 ptbl
= (u32
*) ep
->qp
.sq_pgtbl_virt
;
892 while (num_pages
--) {
894 /* PTE is written in little endian format for 57710 */
897 *ptbl
= (u32
) ((u64
) page
>> 32);
901 /* PTE is written in big endian format for
902 * 5706/5708/5709 devices */
903 *ptbl
= (u32
) ((u64
) page
>> 32);
912 memset(ep
->qp
.rq_pgtbl_virt
, 0, ep
->qp
.rq_pgtbl_size
);
913 num_pages
= ep
->qp
.rq_mem_size
/ PAGE_SIZE
;
914 page
= ep
->qp
.rq_phys
;
917 ptbl
= (u32
*)((u8
*)ep
->qp
.rq_pgtbl_virt
+ ISCSI_RQ_DB_SIZE
);
919 ptbl
= (u32
*) ep
->qp
.rq_pgtbl_virt
;
920 while (num_pages
--) {
922 /* PTE is written in little endian format for 57710 */
925 *ptbl
= (u32
) ((u64
) page
>> 32);
929 /* PTE is written in big endian format for
930 * 5706/5708/5709 devices */
931 *ptbl
= (u32
) ((u64
) page
>> 32);
940 memset(ep
->qp
.cq_pgtbl_virt
, 0, ep
->qp
.cq_pgtbl_size
);
941 num_pages
= ep
->qp
.cq_mem_size
/ PAGE_SIZE
;
942 page
= ep
->qp
.cq_phys
;
945 ptbl
= (u32
*)((u8
*)ep
->qp
.cq_pgtbl_virt
+ ISCSI_CQ_DB_SIZE
);
947 ptbl
= (u32
*) ep
->qp
.cq_pgtbl_virt
;
948 while (num_pages
--) {
950 /* PTE is written in little endian format for 57710 */
953 *ptbl
= (u32
) ((u64
) page
>> 32);
957 /* PTE is written in big endian format for
958 * 5706/5708/5709 devices */
959 *ptbl
= (u32
) ((u64
) page
>> 32);
970 * bnx2i_alloc_qp_resc - allocates required resources for QP.
971 * @hba: adapter structure pointer
972 * @ep: endpoint (transport indentifier) structure
974 * Allocate QP (transport layer for iSCSI connection) resources, DMA'able
975 * memory for SQ/RQ/CQ and page tables. EP structure elements such
976 * as producer/consumer indexes/pointers, queue sizes and page table
979 int bnx2i_alloc_qp_resc(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
981 struct bnx2i_5771x_cq_db
*cq_db
;
985 ep
->ep_cid
= ep
->ep_iscsi_cid
= ep
->ep_pg_cid
= 0;
987 /* Allocate page table memory for SQ which is page aligned */
988 ep
->qp
.sq_mem_size
= hba
->max_sqes
* BNX2I_SQ_WQE_SIZE
;
990 (ep
->qp
.sq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
991 ep
->qp
.sq_pgtbl_size
=
992 (ep
->qp
.sq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
993 ep
->qp
.sq_pgtbl_size
=
994 (ep
->qp
.sq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
996 ep
->qp
.sq_pgtbl_virt
=
997 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_pgtbl_size
,
998 &ep
->qp
.sq_pgtbl_phys
, GFP_KERNEL
);
999 if (!ep
->qp
.sq_pgtbl_virt
) {
1000 printk(KERN_ALERT
"bnx2i: unable to alloc SQ PT mem (%d)\n",
1001 ep
->qp
.sq_pgtbl_size
);
1005 /* Allocate memory area for actual SQ element */
1007 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_mem_size
,
1008 &ep
->qp
.sq_phys
, GFP_KERNEL
);
1009 if (!ep
->qp
.sq_virt
) {
1010 printk(KERN_ALERT
"bnx2i: unable to alloc SQ BD memory %d\n",
1011 ep
->qp
.sq_mem_size
);
1015 memset(ep
->qp
.sq_virt
, 0x00, ep
->qp
.sq_mem_size
);
1016 ep
->qp
.sq_first_qe
= ep
->qp
.sq_virt
;
1017 ep
->qp
.sq_prod_qe
= ep
->qp
.sq_first_qe
;
1018 ep
->qp
.sq_cons_qe
= ep
->qp
.sq_first_qe
;
1019 ep
->qp
.sq_last_qe
= &ep
->qp
.sq_first_qe
[hba
->max_sqes
- 1];
1020 ep
->qp
.sq_prod_idx
= 0;
1021 ep
->qp
.sq_cons_idx
= 0;
1022 ep
->qp
.sqe_left
= hba
->max_sqes
;
1024 /* Allocate page table memory for CQ which is page aligned */
1025 ep
->qp
.cq_mem_size
= hba
->max_cqes
* BNX2I_CQE_SIZE
;
1026 ep
->qp
.cq_mem_size
=
1027 (ep
->qp
.cq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1028 ep
->qp
.cq_pgtbl_size
=
1029 (ep
->qp
.cq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
1030 ep
->qp
.cq_pgtbl_size
=
1031 (ep
->qp
.cq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1033 ep
->qp
.cq_pgtbl_virt
=
1034 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_pgtbl_size
,
1035 &ep
->qp
.cq_pgtbl_phys
, GFP_KERNEL
);
1036 if (!ep
->qp
.cq_pgtbl_virt
) {
1037 printk(KERN_ALERT
"bnx2i: unable to alloc CQ PT memory %d\n",
1038 ep
->qp
.cq_pgtbl_size
);
1042 /* Allocate memory area for actual CQ element */
1044 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_mem_size
,
1045 &ep
->qp
.cq_phys
, GFP_KERNEL
);
1046 if (!ep
->qp
.cq_virt
) {
1047 printk(KERN_ALERT
"bnx2i: unable to alloc CQ BD memory %d\n",
1048 ep
->qp
.cq_mem_size
);
1051 memset(ep
->qp
.cq_virt
, 0x00, ep
->qp
.cq_mem_size
);
1053 ep
->qp
.cq_first_qe
= ep
->qp
.cq_virt
;
1054 ep
->qp
.cq_prod_qe
= ep
->qp
.cq_first_qe
;
1055 ep
->qp
.cq_cons_qe
= ep
->qp
.cq_first_qe
;
1056 ep
->qp
.cq_last_qe
= &ep
->qp
.cq_first_qe
[hba
->max_cqes
- 1];
1057 ep
->qp
.cq_prod_idx
= 0;
1058 ep
->qp
.cq_cons_idx
= 0;
1059 ep
->qp
.cqe_left
= hba
->max_cqes
;
1060 ep
->qp
.cqe_exp_seq_sn
= ISCSI_INITIAL_SN
;
1061 ep
->qp
.cqe_size
= hba
->max_cqes
;
1063 /* Invalidate all EQ CQE index, req only for 57710 */
1064 cq_db
= (struct bnx2i_5771x_cq_db
*) ep
->qp
.cq_pgtbl_virt
;
1065 memset(cq_db
->sqn
, 0xFF, sizeof(cq_db
->sqn
[0]) * BNX2X_MAX_CQS
);
1067 /* Allocate page table memory for RQ which is page aligned */
1068 ep
->qp
.rq_mem_size
= hba
->max_rqes
* BNX2I_RQ_WQE_SIZE
;
1069 ep
->qp
.rq_mem_size
=
1070 (ep
->qp
.rq_mem_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1071 ep
->qp
.rq_pgtbl_size
=
1072 (ep
->qp
.rq_mem_size
/ PAGE_SIZE
) * sizeof(void *);
1073 ep
->qp
.rq_pgtbl_size
=
1074 (ep
->qp
.rq_pgtbl_size
+ (PAGE_SIZE
- 1)) & PAGE_MASK
;
1076 ep
->qp
.rq_pgtbl_virt
=
1077 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_pgtbl_size
,
1078 &ep
->qp
.rq_pgtbl_phys
, GFP_KERNEL
);
1079 if (!ep
->qp
.rq_pgtbl_virt
) {
1080 printk(KERN_ALERT
"bnx2i: unable to alloc RQ PT mem %d\n",
1081 ep
->qp
.rq_pgtbl_size
);
1085 /* Allocate memory area for actual RQ element */
1087 dma_alloc_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_mem_size
,
1088 &ep
->qp
.rq_phys
, GFP_KERNEL
);
1089 if (!ep
->qp
.rq_virt
) {
1090 printk(KERN_ALERT
"bnx2i: unable to alloc RQ BD memory %d\n",
1091 ep
->qp
.rq_mem_size
);
1095 ep
->qp
.rq_first_qe
= ep
->qp
.rq_virt
;
1096 ep
->qp
.rq_prod_qe
= ep
->qp
.rq_first_qe
;
1097 ep
->qp
.rq_cons_qe
= ep
->qp
.rq_first_qe
;
1098 ep
->qp
.rq_last_qe
= &ep
->qp
.rq_first_qe
[hba
->max_rqes
- 1];
1099 ep
->qp
.rq_prod_idx
= 0x8000;
1100 ep
->qp
.rq_cons_idx
= 0;
1101 ep
->qp
.rqe_left
= hba
->max_rqes
;
1103 setup_qp_page_tables(ep
);
1108 bnx2i_free_qp_resc(hba
, ep
);
1115 * bnx2i_free_qp_resc - free memory resources held by QP
1116 * @hba: adapter structure pointer
1117 * @ep: endpoint (transport indentifier) structure
1119 * Free QP resources - SQ/RQ/CQ memory and page tables.
1121 void bnx2i_free_qp_resc(struct bnx2i_hba
*hba
, struct bnx2i_endpoint
*ep
)
1123 if (ep
->qp
.ctx_base
) {
1124 iounmap(ep
->qp
.ctx_base
);
1125 ep
->qp
.ctx_base
= NULL
;
1128 if (ep
->qp
.sq_pgtbl_virt
) {
1129 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_pgtbl_size
,
1130 ep
->qp
.sq_pgtbl_virt
, ep
->qp
.sq_pgtbl_phys
);
1131 ep
->qp
.sq_pgtbl_virt
= NULL
;
1132 ep
->qp
.sq_pgtbl_phys
= 0;
1134 if (ep
->qp
.sq_virt
) {
1135 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.sq_mem_size
,
1136 ep
->qp
.sq_virt
, ep
->qp
.sq_phys
);
1137 ep
->qp
.sq_virt
= NULL
;
1142 if (ep
->qp
.rq_pgtbl_virt
) {
1143 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_pgtbl_size
,
1144 ep
->qp
.rq_pgtbl_virt
, ep
->qp
.rq_pgtbl_phys
);
1145 ep
->qp
.rq_pgtbl_virt
= NULL
;
1146 ep
->qp
.rq_pgtbl_phys
= 0;
1148 if (ep
->qp
.rq_virt
) {
1149 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.rq_mem_size
,
1150 ep
->qp
.rq_virt
, ep
->qp
.rq_phys
);
1151 ep
->qp
.rq_virt
= NULL
;
1156 if (ep
->qp
.cq_pgtbl_virt
) {
1157 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_pgtbl_size
,
1158 ep
->qp
.cq_pgtbl_virt
, ep
->qp
.cq_pgtbl_phys
);
1159 ep
->qp
.cq_pgtbl_virt
= NULL
;
1160 ep
->qp
.cq_pgtbl_phys
= 0;
1162 if (ep
->qp
.cq_virt
) {
1163 dma_free_coherent(&hba
->pcidev
->dev
, ep
->qp
.cq_mem_size
,
1164 ep
->qp
.cq_virt
, ep
->qp
.cq_phys
);
1165 ep
->qp
.cq_virt
= NULL
;
1172 * bnx2i_send_fw_iscsi_init_msg - initiates initial handshake with iscsi f/w
1173 * @hba: adapter structure pointer
1175 * Send down iscsi_init KWQEs which initiates the initial handshake with the f/w
1176 * This results in iSCSi support validation and on-chip context manager
1177 * initialization. Firmware completes this handshake with a CQE carrying
1178 * the result of iscsi support validation. Parameter carried by
1179 * iscsi init request determines the number of offloaded connection and
1180 * tolerance level for iscsi protocol violation this hba/chip can support
1182 int bnx2i_send_fw_iscsi_init_msg(struct bnx2i_hba
*hba
)
1184 struct kwqe
*kwqe_arr
[3];
1185 struct iscsi_kwqe_init1 iscsi_init
;
1186 struct iscsi_kwqe_init2 iscsi_init2
;
1190 bnx2i_adjust_qp_size(hba
);
1193 ISCSI_PAGE_SIZE_4K
<< ISCSI_KWQE_INIT1_PAGE_SIZE_SHIFT
;
1195 iscsi_init
.flags
|= ISCSI_KWQE_INIT1_DELAYED_ACK_ENABLE
;
1196 iscsi_init
.reserved0
= 0;
1197 iscsi_init
.num_cqs
= 1;
1198 iscsi_init
.hdr
.op_code
= ISCSI_KWQE_OPCODE_INIT1
;
1199 iscsi_init
.hdr
.flags
=
1200 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
1202 iscsi_init
.dummy_buffer_addr_lo
= (u32
) hba
->dummy_buf_dma
;
1203 iscsi_init
.dummy_buffer_addr_hi
=
1204 (u32
) ((u64
) hba
->dummy_buf_dma
>> 32);
1206 hba
->ctx_ccell_tasks
=
1207 ((hba
->num_ccell
& 0xFFFF) | (hba
->max_sqes
<< 16));
1208 iscsi_init
.num_ccells_per_conn
= hba
->num_ccell
;
1209 iscsi_init
.num_tasks_per_conn
= hba
->max_sqes
;
1210 iscsi_init
.sq_wqes_per_page
= PAGE_SIZE
/ BNX2I_SQ_WQE_SIZE
;
1211 iscsi_init
.sq_num_wqes
= hba
->max_sqes
;
1212 iscsi_init
.cq_log_wqes_per_page
=
1213 (u8
) bnx2i_power_of2(PAGE_SIZE
/ BNX2I_CQE_SIZE
);
1214 iscsi_init
.cq_num_wqes
= hba
->max_cqes
;
1215 iscsi_init
.cq_num_pages
= (hba
->max_cqes
* BNX2I_CQE_SIZE
+
1216 (PAGE_SIZE
- 1)) / PAGE_SIZE
;
1217 iscsi_init
.sq_num_pages
= (hba
->max_sqes
* BNX2I_SQ_WQE_SIZE
+
1218 (PAGE_SIZE
- 1)) / PAGE_SIZE
;
1219 iscsi_init
.rq_buffer_size
= BNX2I_RQ_WQE_SIZE
;
1220 iscsi_init
.rq_num_wqes
= hba
->max_rqes
;
1223 iscsi_init2
.hdr
.op_code
= ISCSI_KWQE_OPCODE_INIT2
;
1224 iscsi_init2
.hdr
.flags
=
1225 (ISCSI_KWQE_LAYER_CODE
<< ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT
);
1226 iscsi_init2
.max_cq_sqn
= hba
->max_cqes
* 2 + 1;
1231 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV
) |
1234 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN
) |
1236 (1ULL << ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN
));
1238 iscsi_init2
.error_bit_map
[0] = error_mask1
;
1240 iscsi_init2
.error_bit_map
[0] = (u32
) mask64
;
1243 iscsi_init2
.error_bit_map
[1] = error_mask2
;
1245 iscsi_init2
.error_bit_map
[1] = (u32
) (mask64
>> 32);
1247 iscsi_error_mask
= mask64
;
1249 kwqe_arr
[0] = (struct kwqe
*) &iscsi_init
;
1250 kwqe_arr
[1] = (struct kwqe
*) &iscsi_init2
;
1252 if (hba
->cnic
&& hba
->cnic
->submit_kwqes
)
1253 rc
= hba
->cnic
->submit_kwqes(hba
->cnic
, kwqe_arr
, 2);
1259 * bnx2i_process_scsi_cmd_resp - this function handles scsi cmd completion.
1260 * @conn: iscsi connection
1261 * @cqe: pointer to newly DMA'ed CQE entry for processing
1263 * process SCSI CMD Response CQE & complete the request to SCSI-ML
1265 static int bnx2i_process_scsi_cmd_resp(struct iscsi_session
*session
,
1266 struct bnx2i_conn
*bnx2i_conn
,
1269 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1270 struct bnx2i_cmd_response
*resp_cqe
;
1271 struct bnx2i_cmd
*bnx2i_cmd
;
1272 struct iscsi_task
*task
;
1273 struct iscsi_cmd_rsp
*hdr
;
1276 resp_cqe
= (struct bnx2i_cmd_response
*)cqe
;
1277 spin_lock(&session
->lock
);
1278 task
= iscsi_itt_to_task(conn
,
1279 resp_cqe
->itt
& ISCSI_CMD_RESPONSE_INDEX
);
1283 bnx2i_cmd
= task
->dd_data
;
1285 if (bnx2i_cmd
->req
.op_attr
& ISCSI_CMD_REQUEST_READ
) {
1286 conn
->datain_pdus_cnt
+=
1287 resp_cqe
->task_stat
.read_stat
.num_data_outs
;
1288 conn
->rxdata_octets
+=
1289 bnx2i_cmd
->req
.total_data_transfer_length
;
1291 conn
->dataout_pdus_cnt
+=
1292 resp_cqe
->task_stat
.read_stat
.num_data_outs
;
1293 conn
->r2t_pdus_cnt
+=
1294 resp_cqe
->task_stat
.read_stat
.num_r2ts
;
1295 conn
->txdata_octets
+=
1296 bnx2i_cmd
->req
.total_data_transfer_length
;
1298 bnx2i_iscsi_unmap_sg_list(bnx2i_cmd
);
1300 hdr
= (struct iscsi_cmd_rsp
*)task
->hdr
;
1301 resp_cqe
= (struct bnx2i_cmd_response
*)cqe
;
1302 hdr
->opcode
= resp_cqe
->op_code
;
1303 hdr
->max_cmdsn
= cpu_to_be32(resp_cqe
->max_cmd_sn
);
1304 hdr
->exp_cmdsn
= cpu_to_be32(resp_cqe
->exp_cmd_sn
);
1305 hdr
->response
= resp_cqe
->response
;
1306 hdr
->cmd_status
= resp_cqe
->status
;
1307 hdr
->flags
= resp_cqe
->response_flags
;
1308 hdr
->residual_count
= cpu_to_be32(resp_cqe
->residual_count
);
1310 if (resp_cqe
->op_code
== ISCSI_OP_SCSI_DATA_IN
)
1313 if (resp_cqe
->status
== SAM_STAT_CHECK_CONDITION
) {
1314 datalen
= resp_cqe
->data_length
;
1318 if (datalen
> BNX2I_RQ_WQE_SIZE
) {
1319 iscsi_conn_printk(KERN_ERR
, conn
,
1320 "sense data len %d > RQ sz\n",
1322 datalen
= BNX2I_RQ_WQE_SIZE
;
1323 } else if (datalen
> ISCSI_DEF_MAX_RECV_SEG_LEN
) {
1324 iscsi_conn_printk(KERN_ERR
, conn
,
1325 "sense data len %d > conn data\n",
1327 datalen
= ISCSI_DEF_MAX_RECV_SEG_LEN
;
1330 bnx2i_get_rq_buf(bnx2i_cmd
->conn
, conn
->data
, datalen
);
1331 bnx2i_put_rq_buf(bnx2i_cmd
->conn
, 1);
1335 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
,
1336 conn
->data
, datalen
);
1338 spin_unlock(&session
->lock
);
1344 * bnx2i_process_login_resp - this function handles iscsi login response
1345 * @session: iscsi session pointer
1346 * @bnx2i_conn: iscsi connection pointer
1347 * @cqe: pointer to newly DMA'ed CQE entry for processing
1349 * process Login Response CQE & complete it to open-iscsi user daemon
1351 static int bnx2i_process_login_resp(struct iscsi_session
*session
,
1352 struct bnx2i_conn
*bnx2i_conn
,
1355 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1356 struct iscsi_task
*task
;
1357 struct bnx2i_login_response
*login
;
1358 struct iscsi_login_rsp
*resp_hdr
;
1362 login
= (struct bnx2i_login_response
*) cqe
;
1363 spin_lock(&session
->lock
);
1364 task
= iscsi_itt_to_task(conn
,
1365 login
->itt
& ISCSI_LOGIN_RESPONSE_INDEX
);
1369 resp_hdr
= (struct iscsi_login_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1370 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1371 resp_hdr
->opcode
= login
->op_code
;
1372 resp_hdr
->flags
= login
->response_flags
;
1373 resp_hdr
->max_version
= login
->version_max
;
1374 resp_hdr
->active_version
= login
->version_active
;
1375 resp_hdr
->hlength
= 0;
1377 hton24(resp_hdr
->dlength
, login
->data_length
);
1378 memcpy(resp_hdr
->isid
, &login
->isid_lo
, 6);
1379 resp_hdr
->tsih
= cpu_to_be16(login
->tsih
);
1380 resp_hdr
->itt
= task
->hdr
->itt
;
1381 resp_hdr
->statsn
= cpu_to_be32(login
->stat_sn
);
1382 resp_hdr
->exp_cmdsn
= cpu_to_be32(login
->exp_cmd_sn
);
1383 resp_hdr
->max_cmdsn
= cpu_to_be32(login
->max_cmd_sn
);
1384 resp_hdr
->status_class
= login
->status_class
;
1385 resp_hdr
->status_detail
= login
->status_detail
;
1386 pld_len
= login
->data_length
;
1387 bnx2i_conn
->gen_pdu
.resp_wr_ptr
=
1388 bnx2i_conn
->gen_pdu
.resp_buf
+ pld_len
;
1392 pad_len
= 4 - (pld_len
% 4);
1396 for (i
= 0; i
< pad_len
; i
++) {
1397 bnx2i_conn
->gen_pdu
.resp_wr_ptr
[0] = 0;
1398 bnx2i_conn
->gen_pdu
.resp_wr_ptr
++;
1402 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
,
1403 bnx2i_conn
->gen_pdu
.resp_buf
,
1404 bnx2i_conn
->gen_pdu
.resp_wr_ptr
- bnx2i_conn
->gen_pdu
.resp_buf
);
1406 spin_unlock(&session
->lock
);
1411 * bnx2i_process_tmf_resp - this function handles iscsi TMF response
1412 * @session: iscsi session pointer
1413 * @bnx2i_conn: iscsi connection pointer
1414 * @cqe: pointer to newly DMA'ed CQE entry for processing
1416 * process iSCSI TMF Response CQE and wake up the driver eh thread.
1418 static int bnx2i_process_tmf_resp(struct iscsi_session
*session
,
1419 struct bnx2i_conn
*bnx2i_conn
,
1422 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1423 struct iscsi_task
*task
;
1424 struct bnx2i_tmf_response
*tmf_cqe
;
1425 struct iscsi_tm_rsp
*resp_hdr
;
1427 tmf_cqe
= (struct bnx2i_tmf_response
*)cqe
;
1428 spin_lock(&session
->lock
);
1429 task
= iscsi_itt_to_task(conn
,
1430 tmf_cqe
->itt
& ISCSI_TMF_RESPONSE_INDEX
);
1434 resp_hdr
= (struct iscsi_tm_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1435 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1436 resp_hdr
->opcode
= tmf_cqe
->op_code
;
1437 resp_hdr
->max_cmdsn
= cpu_to_be32(tmf_cqe
->max_cmd_sn
);
1438 resp_hdr
->exp_cmdsn
= cpu_to_be32(tmf_cqe
->exp_cmd_sn
);
1439 resp_hdr
->itt
= task
->hdr
->itt
;
1440 resp_hdr
->response
= tmf_cqe
->response
;
1442 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1444 spin_unlock(&session
->lock
);
1449 * bnx2i_process_logout_resp - this function handles iscsi logout response
1450 * @session: iscsi session pointer
1451 * @bnx2i_conn: iscsi connection pointer
1452 * @cqe: pointer to newly DMA'ed CQE entry for processing
1454 * process iSCSI Logout Response CQE & make function call to
1455 * notify the user daemon.
1457 static int bnx2i_process_logout_resp(struct iscsi_session
*session
,
1458 struct bnx2i_conn
*bnx2i_conn
,
1461 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1462 struct iscsi_task
*task
;
1463 struct bnx2i_logout_response
*logout
;
1464 struct iscsi_logout_rsp
*resp_hdr
;
1466 logout
= (struct bnx2i_logout_response
*) cqe
;
1467 spin_lock(&session
->lock
);
1468 task
= iscsi_itt_to_task(conn
,
1469 logout
->itt
& ISCSI_LOGOUT_RESPONSE_INDEX
);
1473 resp_hdr
= (struct iscsi_logout_rsp
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1474 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1475 resp_hdr
->opcode
= logout
->op_code
;
1476 resp_hdr
->flags
= logout
->response
;
1477 resp_hdr
->hlength
= 0;
1479 resp_hdr
->itt
= task
->hdr
->itt
;
1480 resp_hdr
->statsn
= task
->hdr
->exp_statsn
;
1481 resp_hdr
->exp_cmdsn
= cpu_to_be32(logout
->exp_cmd_sn
);
1482 resp_hdr
->max_cmdsn
= cpu_to_be32(logout
->max_cmd_sn
);
1484 resp_hdr
->t2wait
= cpu_to_be32(logout
->time_to_wait
);
1485 resp_hdr
->t2retain
= cpu_to_be32(logout
->time_to_retain
);
1487 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1489 bnx2i_conn
->ep
->state
= EP_STATE_LOGOUT_RESP_RCVD
;
1491 spin_unlock(&session
->lock
);
1496 * bnx2i_process_nopin_local_cmpl - this function handles iscsi nopin CQE
1497 * @session: iscsi session pointer
1498 * @bnx2i_conn: iscsi connection pointer
1499 * @cqe: pointer to newly DMA'ed CQE entry for processing
1501 * process iSCSI NOPIN local completion CQE, frees IIT and command structures
1503 static void bnx2i_process_nopin_local_cmpl(struct iscsi_session
*session
,
1504 struct bnx2i_conn
*bnx2i_conn
,
1507 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1508 struct bnx2i_nop_in_msg
*nop_in
;
1509 struct iscsi_task
*task
;
1511 nop_in
= (struct bnx2i_nop_in_msg
*)cqe
;
1512 spin_lock(&session
->lock
);
1513 task
= iscsi_itt_to_task(conn
,
1514 nop_in
->itt
& ISCSI_NOP_IN_MSG_INDEX
);
1516 iscsi_put_task(task
);
1517 spin_unlock(&session
->lock
);
1521 * bnx2i_unsol_pdu_adjust_rq - makes adjustments to RQ after unsol pdu is recvd
1522 * @conn: iscsi connection
1524 * Firmware advances RQ producer index for every unsolicited PDU even if
1525 * payload data length is '0'. This function makes corresponding
1526 * adjustments on the driver side to match this f/w behavior
1528 static void bnx2i_unsol_pdu_adjust_rq(struct bnx2i_conn
*bnx2i_conn
)
1530 char dummy_rq_data
[2];
1531 bnx2i_get_rq_buf(bnx2i_conn
, dummy_rq_data
, 1);
1532 bnx2i_put_rq_buf(bnx2i_conn
, 1);
1537 * bnx2i_process_nopin_mesg - this function handles iscsi nopin CQE
1538 * @session: iscsi session pointer
1539 * @bnx2i_conn: iscsi connection pointer
1540 * @cqe: pointer to newly DMA'ed CQE entry for processing
1542 * process iSCSI target's proactive iSCSI NOPIN request
1544 static int bnx2i_process_nopin_mesg(struct iscsi_session
*session
,
1545 struct bnx2i_conn
*bnx2i_conn
,
1548 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1549 struct iscsi_task
*task
;
1550 struct bnx2i_nop_in_msg
*nop_in
;
1551 struct iscsi_nopin
*hdr
;
1553 int tgt_async_nop
= 0;
1555 nop_in
= (struct bnx2i_nop_in_msg
*)cqe
;
1556 itt
= nop_in
->itt
& ISCSI_NOP_IN_MSG_INDEX
;
1558 spin_lock(&session
->lock
);
1559 hdr
= (struct iscsi_nopin
*)&bnx2i_conn
->gen_pdu
.resp_hdr
;
1560 memset(hdr
, 0, sizeof(struct iscsi_hdr
));
1561 hdr
->opcode
= nop_in
->op_code
;
1562 hdr
->max_cmdsn
= cpu_to_be32(nop_in
->max_cmd_sn
);
1563 hdr
->exp_cmdsn
= cpu_to_be32(nop_in
->exp_cmd_sn
);
1564 hdr
->ttt
= cpu_to_be32(nop_in
->ttt
);
1566 if (itt
== (u16
) RESERVED_ITT
) {
1567 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1568 hdr
->itt
= RESERVED_ITT
;
1573 /* this is a response to one of our nop-outs */
1574 task
= iscsi_itt_to_task(conn
, itt
);
1576 hdr
->flags
= ISCSI_FLAG_CMD_FINAL
;
1577 hdr
->itt
= task
->hdr
->itt
;
1578 hdr
->ttt
= cpu_to_be32(nop_in
->ttt
);
1579 memcpy(hdr
->lun
, nop_in
->lun
, 8);
1582 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
, NULL
, 0);
1583 spin_unlock(&session
->lock
);
1585 return tgt_async_nop
;
1590 * bnx2i_process_async_mesg - this function handles iscsi async message
1591 * @session: iscsi session pointer
1592 * @bnx2i_conn: iscsi connection pointer
1593 * @cqe: pointer to newly DMA'ed CQE entry for processing
1595 * process iSCSI ASYNC Message
1597 static void bnx2i_process_async_mesg(struct iscsi_session
*session
,
1598 struct bnx2i_conn
*bnx2i_conn
,
1601 struct bnx2i_async_msg
*async_cqe
;
1602 struct iscsi_async
*resp_hdr
;
1605 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1607 async_cqe
= (struct bnx2i_async_msg
*)cqe
;
1608 async_event
= async_cqe
->async_event
;
1610 if (async_event
== ISCSI_ASYNC_MSG_SCSI_EVENT
) {
1611 iscsi_conn_printk(KERN_ALERT
, bnx2i_conn
->cls_conn
->dd_data
,
1612 "async: scsi events not supported\n");
1616 spin_lock(&session
->lock
);
1617 resp_hdr
= (struct iscsi_async
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1618 memset(resp_hdr
, 0, sizeof(struct iscsi_hdr
));
1619 resp_hdr
->opcode
= async_cqe
->op_code
;
1620 resp_hdr
->flags
= 0x80;
1622 memcpy(resp_hdr
->lun
, async_cqe
->lun
, 8);
1623 resp_hdr
->exp_cmdsn
= cpu_to_be32(async_cqe
->exp_cmd_sn
);
1624 resp_hdr
->max_cmdsn
= cpu_to_be32(async_cqe
->max_cmd_sn
);
1626 resp_hdr
->async_event
= async_cqe
->async_event
;
1627 resp_hdr
->async_vcode
= async_cqe
->async_vcode
;
1629 resp_hdr
->param1
= cpu_to_be16(async_cqe
->param1
);
1630 resp_hdr
->param2
= cpu_to_be16(async_cqe
->param2
);
1631 resp_hdr
->param3
= cpu_to_be16(async_cqe
->param3
);
1633 __iscsi_complete_pdu(bnx2i_conn
->cls_conn
->dd_data
,
1634 (struct iscsi_hdr
*)resp_hdr
, NULL
, 0);
1635 spin_unlock(&session
->lock
);
1640 * bnx2i_process_reject_mesg - process iscsi reject pdu
1641 * @session: iscsi session pointer
1642 * @bnx2i_conn: iscsi connection pointer
1643 * @cqe: pointer to newly DMA'ed CQE entry for processing
1645 * process iSCSI REJECT message
1647 static void bnx2i_process_reject_mesg(struct iscsi_session
*session
,
1648 struct bnx2i_conn
*bnx2i_conn
,
1651 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1652 struct bnx2i_reject_msg
*reject
;
1653 struct iscsi_reject
*hdr
;
1655 reject
= (struct bnx2i_reject_msg
*) cqe
;
1656 if (reject
->data_length
) {
1657 bnx2i_get_rq_buf(bnx2i_conn
, conn
->data
, reject
->data_length
);
1658 bnx2i_put_rq_buf(bnx2i_conn
, 1);
1660 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn
);
1662 spin_lock(&session
->lock
);
1663 hdr
= (struct iscsi_reject
*) &bnx2i_conn
->gen_pdu
.resp_hdr
;
1664 memset(hdr
, 0, sizeof(struct iscsi_hdr
));
1665 hdr
->opcode
= reject
->op_code
;
1666 hdr
->reason
= reject
->reason
;
1667 hton24(hdr
->dlength
, reject
->data_length
);
1668 hdr
->max_cmdsn
= cpu_to_be32(reject
->max_cmd_sn
);
1669 hdr
->exp_cmdsn
= cpu_to_be32(reject
->exp_cmd_sn
);
1670 hdr
->ffffffff
= cpu_to_be32(RESERVED_ITT
);
1671 __iscsi_complete_pdu(conn
, (struct iscsi_hdr
*)hdr
, conn
->data
,
1672 reject
->data_length
);
1673 spin_unlock(&session
->lock
);
1677 * bnx2i_process_cmd_cleanup_resp - process scsi command clean-up completion
1678 * @session: iscsi session pointer
1679 * @bnx2i_conn: iscsi connection pointer
1680 * @cqe: pointer to newly DMA'ed CQE entry for processing
1682 * process command cleanup response CQE during conn shutdown or error recovery
1684 static void bnx2i_process_cmd_cleanup_resp(struct iscsi_session
*session
,
1685 struct bnx2i_conn
*bnx2i_conn
,
1688 struct bnx2i_cleanup_response
*cmd_clean_rsp
;
1689 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1690 struct iscsi_task
*task
;
1692 cmd_clean_rsp
= (struct bnx2i_cleanup_response
*)cqe
;
1693 spin_lock(&session
->lock
);
1694 task
= iscsi_itt_to_task(conn
,
1695 cmd_clean_rsp
->itt
& ISCSI_CLEANUP_RESPONSE_INDEX
);
1697 printk(KERN_ALERT
"bnx2i: cmd clean ITT %x not active\n",
1698 cmd_clean_rsp
->itt
& ISCSI_CLEANUP_RESPONSE_INDEX
);
1699 spin_unlock(&session
->lock
);
1700 complete(&bnx2i_conn
->cmd_cleanup_cmpl
);
1706 * bnx2i_process_new_cqes - process newly DMA'ed CQE's
1707 * @bnx2i_conn: iscsi connection
1709 * this function is called by generic KCQ handler to process all pending CQE's
1711 static void bnx2i_process_new_cqes(struct bnx2i_conn
*bnx2i_conn
)
1713 struct iscsi_conn
*conn
= bnx2i_conn
->cls_conn
->dd_data
;
1714 struct iscsi_session
*session
= conn
->session
;
1715 struct qp_info
*qp
= &bnx2i_conn
->ep
->qp
;
1716 struct bnx2i_nop_in_msg
*nopin
;
1720 nopin
= (struct bnx2i_nop_in_msg
*) qp
->cq_cons_qe
;
1721 if (nopin
->cq_req_sn
!= qp
->cqe_exp_seq_sn
)
1724 if (unlikely(test_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
)))
1729 switch (nopin
->op_code
) {
1730 case ISCSI_OP_SCSI_CMD_RSP
:
1731 case ISCSI_OP_SCSI_DATA_IN
:
1732 bnx2i_process_scsi_cmd_resp(session
, bnx2i_conn
,
1735 case ISCSI_OP_LOGIN_RSP
:
1736 bnx2i_process_login_resp(session
, bnx2i_conn
,
1739 case ISCSI_OP_SCSI_TMFUNC_RSP
:
1740 bnx2i_process_tmf_resp(session
, bnx2i_conn
,
1743 case ISCSI_OP_LOGOUT_RSP
:
1744 bnx2i_process_logout_resp(session
, bnx2i_conn
,
1747 case ISCSI_OP_NOOP_IN
:
1748 if (bnx2i_process_nopin_mesg(session
, bnx2i_conn
,
1752 case ISCSI_OPCODE_NOPOUT_LOCAL_COMPLETION
:
1753 bnx2i_process_nopin_local_cmpl(session
, bnx2i_conn
,
1756 case ISCSI_OP_ASYNC_EVENT
:
1757 bnx2i_process_async_mesg(session
, bnx2i_conn
,
1761 case ISCSI_OP_REJECT
:
1762 bnx2i_process_reject_mesg(session
, bnx2i_conn
,
1765 case ISCSI_OPCODE_CLEANUP_RESPONSE
:
1766 bnx2i_process_cmd_cleanup_resp(session
, bnx2i_conn
,
1770 printk(KERN_ALERT
"bnx2i: unknown opcode 0x%x\n",
1775 bnx2i_conn
->ep
->num_active_cmds
--;
1777 /* clear out in production version only, till beta keep opcode
1778 * field intact, will be helpful in debugging (context dump)
1779 * nopin->op_code = 0;
1781 qp
->cqe_exp_seq_sn
++;
1782 if (qp
->cqe_exp_seq_sn
== (qp
->cqe_size
* 2 + 1))
1783 qp
->cqe_exp_seq_sn
= ISCSI_INITIAL_SN
;
1785 if (qp
->cq_cons_qe
== qp
->cq_last_qe
) {
1786 qp
->cq_cons_qe
= qp
->cq_first_qe
;
1787 qp
->cq_cons_idx
= 0;
1793 bnx2i_arm_cq_event_coalescing(bnx2i_conn
->ep
, CNIC_ARM_CQE
);
1797 * bnx2i_fastpath_notification - process global event queue (KCQ)
1798 * @hba: adapter structure pointer
1799 * @new_cqe_kcqe: pointer to newly DMA'ed KCQE entry
1801 * Fast path event notification handler, KCQ entry carries context id
1802 * of the connection that has 1 or more pending CQ entries
1804 static void bnx2i_fastpath_notification(struct bnx2i_hba
*hba
,
1805 struct iscsi_kcqe
*new_cqe_kcqe
)
1807 struct bnx2i_conn
*conn
;
1810 iscsi_cid
= new_cqe_kcqe
->iscsi_conn_id
;
1811 conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1814 printk(KERN_ALERT
"cid #%x not valid\n", iscsi_cid
);
1818 printk(KERN_ALERT
"cid #%x - ep not bound\n", iscsi_cid
);
1822 bnx2i_process_new_cqes(conn
);
1827 * bnx2i_process_update_conn_cmpl - process iscsi conn update completion KCQE
1828 * @hba: adapter structure pointer
1829 * @update_kcqe: kcqe pointer
1831 * CONN_UPDATE completion handler, this completes iSCSI connection FFP migration
1833 static void bnx2i_process_update_conn_cmpl(struct bnx2i_hba
*hba
,
1834 struct iscsi_kcqe
*update_kcqe
)
1836 struct bnx2i_conn
*conn
;
1839 iscsi_cid
= update_kcqe
->iscsi_conn_id
;
1840 conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1843 printk(KERN_ALERT
"conn_update: cid %x not valid\n", iscsi_cid
);
1847 printk(KERN_ALERT
"cid %x does not have ep bound\n", iscsi_cid
);
1851 if (update_kcqe
->completion_status
) {
1852 printk(KERN_ALERT
"request failed cid %x\n", iscsi_cid
);
1853 conn
->ep
->state
= EP_STATE_ULP_UPDATE_FAILED
;
1855 conn
->ep
->state
= EP_STATE_ULP_UPDATE_COMPL
;
1857 wake_up_interruptible(&conn
->ep
->ofld_wait
);
1862 * bnx2i_recovery_que_add_conn - add connection to recovery queue
1863 * @hba: adapter structure pointer
1864 * @bnx2i_conn: iscsi connection
1866 * Add connection to recovery queue and schedule adapter eh worker
1868 static void bnx2i_recovery_que_add_conn(struct bnx2i_hba
*hba
,
1869 struct bnx2i_conn
*bnx2i_conn
)
1871 iscsi_conn_failure(bnx2i_conn
->cls_conn
->dd_data
,
1872 ISCSI_ERR_CONN_FAILED
);
1877 * bnx2i_process_tcp_error - process error notification on a given connection
1879 * @hba: adapter structure pointer
1880 * @tcp_err: tcp error kcqe pointer
1882 * handles tcp level error notifications from FW.
1884 static void bnx2i_process_tcp_error(struct bnx2i_hba
*hba
,
1885 struct iscsi_kcqe
*tcp_err
)
1887 struct bnx2i_conn
*bnx2i_conn
;
1890 iscsi_cid
= tcp_err
->iscsi_conn_id
;
1891 bnx2i_conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1894 printk(KERN_ALERT
"bnx2i - cid 0x%x not valid\n", iscsi_cid
);
1898 printk(KERN_ALERT
"bnx2i - cid 0x%x had TCP errors, error code 0x%x\n",
1899 iscsi_cid
, tcp_err
->completion_status
);
1900 bnx2i_recovery_que_add_conn(bnx2i_conn
->hba
, bnx2i_conn
);
1905 * bnx2i_process_iscsi_error - process error notification on a given connection
1906 * @hba: adapter structure pointer
1907 * @iscsi_err: iscsi error kcqe pointer
1909 * handles iscsi error notifications from the FW. Firmware based in initial
1910 * handshake classifies iscsi protocol / TCP rfc violation into either
1911 * warning or error indications. If indication is of "Error" type, driver
1912 * will initiate session recovery for that connection/session. For
1913 * "Warning" type indication, driver will put out a system log message
1914 * (there will be only one message for each type for the life of the
1915 * session, this is to avoid un-necessarily overloading the system)
1917 static void bnx2i_process_iscsi_error(struct bnx2i_hba
*hba
,
1918 struct iscsi_kcqe
*iscsi_err
)
1920 struct bnx2i_conn
*bnx2i_conn
;
1922 char warn_notice
[] = "iscsi_warning";
1923 char error_notice
[] = "iscsi_error";
1924 char additional_notice
[64];
1929 iscsi_cid
= iscsi_err
->iscsi_conn_id
;
1930 bnx2i_conn
= bnx2i_get_conn_from_id(hba
, iscsi_cid
);
1932 printk(KERN_ALERT
"bnx2i - cid 0x%x not valid\n", iscsi_cid
);
1936 err_mask64
= (0x1ULL
<< iscsi_err
->completion_status
);
1938 if (err_mask64
& iscsi_error_mask
) {
1940 message
= warn_notice
;
1943 message
= error_notice
;
1946 switch (iscsi_err
->completion_status
) {
1947 case ISCSI_KCQE_COMPLETION_STATUS_HDR_DIG_ERR
:
1948 strcpy(additional_notice
, "hdr digest err");
1950 case ISCSI_KCQE_COMPLETION_STATUS_DATA_DIG_ERR
:
1951 strcpy(additional_notice
, "data digest err");
1953 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_OPCODE
:
1954 strcpy(additional_notice
, "wrong opcode rcvd");
1956 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_AHS_LEN
:
1957 strcpy(additional_notice
, "AHS len > 0 rcvd");
1959 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ITT
:
1960 strcpy(additional_notice
, "invalid ITT rcvd");
1962 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_STATSN
:
1963 strcpy(additional_notice
, "wrong StatSN rcvd");
1965 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN
:
1966 strcpy(additional_notice
, "wrong DataSN rcvd");
1968 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T
:
1969 strcpy(additional_notice
, "pend R2T violation");
1971 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_0
:
1972 strcpy(additional_notice
, "ERL0, UO");
1974 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_1
:
1975 strcpy(additional_notice
, "ERL0, U1");
1977 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_2
:
1978 strcpy(additional_notice
, "ERL0, U2");
1980 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_3
:
1981 strcpy(additional_notice
, "ERL0, U3");
1983 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_4
:
1984 strcpy(additional_notice
, "ERL0, U4");
1986 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_5
:
1987 strcpy(additional_notice
, "ERL0, U5");
1989 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_6
:
1990 strcpy(additional_notice
, "ERL0, U6");
1992 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_RCV_LEN
:
1993 strcpy(additional_notice
, "invalid resi len");
1995 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_RCV_PDU_LEN
:
1996 strcpy(additional_notice
, "MRDSL violation");
1998 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_F_BIT_ZERO
:
1999 strcpy(additional_notice
, "F-bit not set");
2001 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV
:
2002 strcpy(additional_notice
, "invalid TTT");
2004 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATASN
:
2005 strcpy(additional_notice
, "invalid DataSN");
2007 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_BURST_LEN
:
2008 strcpy(additional_notice
, "burst len violation");
2010 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_BUFFER_OFF
:
2011 strcpy(additional_notice
, "buf offset violation");
2013 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN
:
2014 strcpy(additional_notice
, "invalid LUN field");
2016 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_R2TSN
:
2017 strcpy(additional_notice
, "invalid R2TSN field");
2019 #define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0 \
2020 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_0
2021 case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_0
:
2022 strcpy(additional_notice
, "invalid cmd len1");
2024 #define BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1 \
2025 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DESIRED_DATA_TRNS_LEN_1
2026 case BNX2I_ERR_DESIRED_DATA_TRNS_LEN_1
:
2027 strcpy(additional_notice
, "invalid cmd len2");
2029 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_EXCEED
:
2030 strcpy(additional_notice
,
2031 "pend r2t exceeds MaxOutstandingR2T value");
2033 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_IS_RSRV
:
2034 strcpy(additional_notice
, "TTT is rsvd");
2036 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_BURST_LEN
:
2037 strcpy(additional_notice
, "MBL violation");
2039 #define BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO \
2040 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATA_SEG_LEN_NOT_ZERO
2041 case BNX2I_ERR_DATA_SEG_LEN_NOT_ZERO
:
2042 strcpy(additional_notice
, "data seg len != 0");
2044 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REJECT_PDU_LEN
:
2045 strcpy(additional_notice
, "reject pdu len error");
2047 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ASYNC_PDU_LEN
:
2048 strcpy(additional_notice
, "async pdu len error");
2050 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_NOPIN_PDU_LEN
:
2051 strcpy(additional_notice
, "nopin pdu len error");
2053 #define BNX2_ERR_PEND_R2T_IN_CLEANUP \
2054 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_IN_CLEANUP
2055 case BNX2_ERR_PEND_R2T_IN_CLEANUP
:
2056 strcpy(additional_notice
, "pend r2t in cleanup");
2059 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_FRAGMENT
:
2060 strcpy(additional_notice
, "IP fragments rcvd");
2062 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_OPTIONS
:
2063 strcpy(additional_notice
, "IP options error");
2065 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_URGENT_FLAG
:
2066 strcpy(additional_notice
, "urgent flag error");
2069 printk(KERN_ALERT
"iscsi_err - unknown err %x\n",
2070 iscsi_err
->completion_status
);
2073 if (need_recovery
) {
2074 iscsi_conn_printk(KERN_ALERT
,
2075 bnx2i_conn
->cls_conn
->dd_data
,
2077 message
, additional_notice
);
2079 iscsi_conn_printk(KERN_ALERT
,
2080 bnx2i_conn
->cls_conn
->dd_data
,
2081 "conn_err - hostno %d conn %p, "
2082 "iscsi_cid %x cid %x\n",
2083 bnx2i_conn
->hba
->shost
->host_no
,
2084 bnx2i_conn
, bnx2i_conn
->ep
->ep_iscsi_cid
,
2085 bnx2i_conn
->ep
->ep_cid
);
2086 bnx2i_recovery_que_add_conn(bnx2i_conn
->hba
, bnx2i_conn
);
2088 if (!test_and_set_bit(iscsi_err
->completion_status
,
2089 (void *) &bnx2i_conn
->violation_notified
))
2090 iscsi_conn_printk(KERN_ALERT
,
2091 bnx2i_conn
->cls_conn
->dd_data
,
2093 message
, additional_notice
);
2098 * bnx2i_process_conn_destroy_cmpl - process iscsi conn destroy completion
2099 * @hba: adapter structure pointer
2100 * @conn_destroy: conn destroy kcqe pointer
2102 * handles connection destroy completion request.
2104 static void bnx2i_process_conn_destroy_cmpl(struct bnx2i_hba
*hba
,
2105 struct iscsi_kcqe
*conn_destroy
)
2107 struct bnx2i_endpoint
*ep
;
2109 ep
= bnx2i_find_ep_in_destroy_list(hba
, conn_destroy
->iscsi_conn_id
);
2111 printk(KERN_ALERT
"bnx2i_conn_destroy_cmpl: no pending "
2112 "offload request, unexpected complection\n");
2116 if (hba
!= ep
->hba
) {
2117 printk(KERN_ALERT
"conn destroy- error hba mis-match\n");
2121 if (conn_destroy
->completion_status
) {
2122 printk(KERN_ALERT
"conn_destroy_cmpl: op failed\n");
2123 ep
->state
= EP_STATE_CLEANUP_FAILED
;
2125 ep
->state
= EP_STATE_CLEANUP_CMPL
;
2126 wake_up_interruptible(&ep
->ofld_wait
);
2131 * bnx2i_process_ofld_cmpl - process initial iscsi conn offload completion
2132 * @hba: adapter structure pointer
2133 * @ofld_kcqe: conn offload kcqe pointer
2135 * handles initial connection offload completion, ep_connect() thread is
2136 * woken-up to continue with LLP connect process
2138 static void bnx2i_process_ofld_cmpl(struct bnx2i_hba
*hba
,
2139 struct iscsi_kcqe
*ofld_kcqe
)
2142 struct bnx2i_endpoint
*ep
;
2145 ep
= bnx2i_find_ep_in_ofld_list(hba
, ofld_kcqe
->iscsi_conn_id
);
2147 printk(KERN_ALERT
"ofld_cmpl: no pend offload request\n");
2151 if (hba
!= ep
->hba
) {
2152 printk(KERN_ALERT
"ofld_cmpl: error hba mis-match\n");
2156 if (ofld_kcqe
->completion_status
) {
2157 if (ofld_kcqe
->completion_status
==
2158 ISCSI_KCQE_COMPLETION_STATUS_CTX_ALLOC_FAILURE
)
2159 printk(KERN_ALERT
"bnx2i: unable to allocate"
2160 " iSCSI context resources\n");
2161 ep
->state
= EP_STATE_OFLD_FAILED
;
2163 ep
->state
= EP_STATE_OFLD_COMPL
;
2164 cid_addr
= ofld_kcqe
->iscsi_conn_context_id
;
2165 cid_num
= bnx2i_get_cid_num(ep
);
2166 ep
->ep_cid
= cid_addr
;
2167 ep
->qp
.ctx_base
= NULL
;
2169 wake_up_interruptible(&ep
->ofld_wait
);
2173 * bnx2i_indicate_kcqe - process iscsi conn update completion KCQE
2174 * @hba: adapter structure pointer
2175 * @update_kcqe: kcqe pointer
2177 * Generic KCQ event handler/dispatcher
2179 static void bnx2i_indicate_kcqe(void *context
, struct kcqe
*kcqe
[],
2182 struct bnx2i_hba
*hba
= context
;
2184 struct iscsi_kcqe
*ikcqe
= NULL
;
2186 while (i
< num_cqe
) {
2187 ikcqe
= (struct iscsi_kcqe
*) kcqe
[i
++];
2189 if (ikcqe
->op_code
==
2190 ISCSI_KCQE_OPCODE_CQ_EVENT_NOTIFICATION
)
2191 bnx2i_fastpath_notification(hba
, ikcqe
);
2192 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_OFFLOAD_CONN
)
2193 bnx2i_process_ofld_cmpl(hba
, ikcqe
);
2194 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_UPDATE_CONN
)
2195 bnx2i_process_update_conn_cmpl(hba
, ikcqe
);
2196 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_INIT
) {
2197 if (ikcqe
->completion_status
!=
2198 ISCSI_KCQE_COMPLETION_STATUS_SUCCESS
)
2199 bnx2i_iscsi_license_error(hba
, ikcqe
->\
2202 set_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
);
2203 bnx2i_get_link_state(hba
);
2204 printk(KERN_INFO
"bnx2i [%.2x:%.2x.%.2x]: "
2205 "ISCSI_INIT passed\n",
2206 (u8
)hba
->pcidev
->bus
->number
,
2212 } else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_DESTROY_CONN
)
2213 bnx2i_process_conn_destroy_cmpl(hba
, ikcqe
);
2214 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_ISCSI_ERROR
)
2215 bnx2i_process_iscsi_error(hba
, ikcqe
);
2216 else if (ikcqe
->op_code
== ISCSI_KCQE_OPCODE_TCP_ERROR
)
2217 bnx2i_process_tcp_error(hba
, ikcqe
);
2219 printk(KERN_ALERT
"bnx2i: unknown opcode 0x%x\n",
2226 * bnx2i_indicate_netevent - Generic netdev event handler
2227 * @context: adapter structure pointer
2228 * @event: event type
2230 * Handles four netdev events, NETDEV_UP, NETDEV_DOWN,
2231 * NETDEV_GOING_DOWN and NETDEV_CHANGE
2233 static void bnx2i_indicate_netevent(void *context
, unsigned long event
)
2235 struct bnx2i_hba
*hba
= context
;
2239 if (!test_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
))
2240 bnx2i_send_fw_iscsi_init_msg(hba
);
2243 clear_bit(ADAPTER_STATE_GOING_DOWN
, &hba
->adapter_state
);
2244 clear_bit(ADAPTER_STATE_UP
, &hba
->adapter_state
);
2246 case NETDEV_GOING_DOWN
:
2247 set_bit(ADAPTER_STATE_GOING_DOWN
, &hba
->adapter_state
);
2248 iscsi_host_for_each_session(hba
->shost
,
2249 bnx2i_drop_session
);
2252 bnx2i_get_link_state(hba
);
2261 * bnx2i_cm_connect_cmpl - process iscsi conn establishment completion
2262 * @cm_sk: cnic sock structure pointer
2264 * function callback exported via bnx2i - cnic driver interface to
2265 * indicate completion of option-2 TCP connect request.
2267 static void bnx2i_cm_connect_cmpl(struct cnic_sock
*cm_sk
)
2269 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2271 if (test_bit(ADAPTER_STATE_GOING_DOWN
, &ep
->hba
->adapter_state
))
2272 ep
->state
= EP_STATE_CONNECT_FAILED
;
2273 else if (test_bit(SK_F_OFFLD_COMPLETE
, &cm_sk
->flags
))
2274 ep
->state
= EP_STATE_CONNECT_COMPL
;
2276 ep
->state
= EP_STATE_CONNECT_FAILED
;
2278 wake_up_interruptible(&ep
->ofld_wait
);
2283 * bnx2i_cm_close_cmpl - process tcp conn close completion
2284 * @cm_sk: cnic sock structure pointer
2286 * function callback exported via bnx2i - cnic driver interface to
2287 * indicate completion of option-2 graceful TCP connect shutdown
2289 static void bnx2i_cm_close_cmpl(struct cnic_sock
*cm_sk
)
2291 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2293 ep
->state
= EP_STATE_DISCONN_COMPL
;
2294 wake_up_interruptible(&ep
->ofld_wait
);
2299 * bnx2i_cm_abort_cmpl - process abortive tcp conn teardown completion
2300 * @cm_sk: cnic sock structure pointer
2302 * function callback exported via bnx2i - cnic driver interface to
2303 * indicate completion of option-2 abortive TCP connect termination
2305 static void bnx2i_cm_abort_cmpl(struct cnic_sock
*cm_sk
)
2307 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2309 ep
->state
= EP_STATE_DISCONN_COMPL
;
2310 wake_up_interruptible(&ep
->ofld_wait
);
2315 * bnx2i_cm_remote_close - process received TCP FIN
2316 * @hba: adapter structure pointer
2317 * @update_kcqe: kcqe pointer
2319 * function callback exported via bnx2i - cnic driver interface to indicate
2320 * async TCP events such as FIN
2322 static void bnx2i_cm_remote_close(struct cnic_sock
*cm_sk
)
2324 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2326 ep
->state
= EP_STATE_TCP_FIN_RCVD
;
2328 bnx2i_recovery_que_add_conn(ep
->hba
, ep
->conn
);
2332 * bnx2i_cm_remote_abort - process TCP RST and start conn cleanup
2333 * @hba: adapter structure pointer
2334 * @update_kcqe: kcqe pointer
2336 * function callback exported via bnx2i - cnic driver interface to
2337 * indicate async TCP events (RST) sent by the peer.
2339 static void bnx2i_cm_remote_abort(struct cnic_sock
*cm_sk
)
2341 struct bnx2i_endpoint
*ep
= (struct bnx2i_endpoint
*) cm_sk
->context
;
2343 ep
->state
= EP_STATE_TCP_RST_RCVD
;
2345 bnx2i_recovery_que_add_conn(ep
->hba
, ep
->conn
);
2349 static void bnx2i_send_nl_mesg(struct cnic_dev
*dev
, u32 msg_type
,
2350 char *buf
, u16 buflen
)
2352 struct bnx2i_hba
*hba
;
2354 hba
= bnx2i_find_hba_for_cnic(dev
);
2358 if (iscsi_offload_mesg(hba
->shost
, &bnx2i_iscsi_transport
,
2359 msg_type
, buf
, buflen
))
2360 printk(KERN_ALERT
"bnx2i: private nl message send error\n");
2366 * bnx2i_cnic_cb - global template of bnx2i - cnic driver interface structure
2367 * carrying callback function pointers
2370 struct cnic_ulp_ops bnx2i_cnic_cb
= {
2371 .cnic_init
= bnx2i_ulp_init
,
2372 .cnic_exit
= bnx2i_ulp_exit
,
2373 .cnic_start
= bnx2i_start
,
2374 .cnic_stop
= bnx2i_stop
,
2375 .indicate_kcqes
= bnx2i_indicate_kcqe
,
2376 .indicate_netevent
= bnx2i_indicate_netevent
,
2377 .cm_connect_complete
= bnx2i_cm_connect_cmpl
,
2378 .cm_close_complete
= bnx2i_cm_close_cmpl
,
2379 .cm_abort_complete
= bnx2i_cm_abort_cmpl
,
2380 .cm_remote_close
= bnx2i_cm_remote_close
,
2381 .cm_remote_abort
= bnx2i_cm_remote_abort
,
2382 .iscsi_nl_send_msg
= bnx2i_send_nl_mesg
,
2383 .owner
= THIS_MODULE
2388 * bnx2i_map_ep_dbell_regs - map connection doorbell registers
2389 * @ep: bnx2i endpoint
2391 * maps connection's SQ and RQ doorbell registers, 5706/5708/5709 hosts these
2392 * register in BAR #0. Whereas in 57710 these register are accessed by
2395 int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint
*ep
)
2402 resource_size_t reg_base
;
2404 cid_num
= bnx2i_get_cid_num(ep
);
2406 if (test_bit(BNX2I_NX2_DEV_57710
, &ep
->hba
->cnic_dev_type
)) {
2407 reg_base
= pci_resource_start(ep
->hba
->pcidev
,
2408 BNX2X_DOORBELL_PCI_BAR
);
2409 reg_off
= BNX2I_5771X_DBELL_PAGE_SIZE
* (cid_num
& 0x1FFFF) +
2411 ep
->qp
.ctx_base
= ioremap_nocache(reg_base
+ reg_off
, 4);
2415 reg_base
= ep
->hba
->netdev
->base_addr
;
2416 if ((test_bit(BNX2I_NX2_DEV_5709
, &ep
->hba
->cnic_dev_type
)) &&
2417 (ep
->hba
->mail_queue_access
== BNX2I_MQ_BIN_MODE
)) {
2418 config2
= REG_RD(ep
->hba
, BNX2_MQ_CONFIG2
);
2419 first_l4l5
= config2
& BNX2_MQ_CONFIG2_FIRST_L4L5
;
2420 ctx_sz
= (config2
& BNX2_MQ_CONFIG2_CONT_SZ
) >> 3;
2422 reg_off
= CTX_OFFSET
+ MAX_CID_CNT
* MB_KERNEL_CTX_SIZE
2423 + BNX2I_570X_PAGE_SIZE_DEFAULT
*
2424 (((cid_num
- first_l4l5
) / ctx_sz
) + 256);
2426 reg_off
= CTX_OFFSET
+ (MB_KERNEL_CTX_SIZE
* cid_num
);
2428 /* 5709 device in normal node and 5706/5708 devices */
2429 reg_off
= CTX_OFFSET
+ (MB_KERNEL_CTX_SIZE
* cid_num
);
2431 ep
->qp
.ctx_base
= ioremap_nocache(reg_base
+ reg_off
,
2432 MB_KERNEL_CTX_SIZE
);
2433 if (!ep
->qp
.ctx_base
)
2437 bnx2i_arm_cq_event_coalescing(ep
, CNIC_ARM_CQE
);