1/* bnx2i_hwi.c: Broadcom NetXtreme II iSCSI driver. 2 * 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 6 * 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. 10 * 11 * Written by: Anil Veerabhadrappa (anilgv@broadcom.com) 12 */ 13 14#include <linux/gfp.h> 15#include <scsi/scsi_tcq.h> 16#include <scsi/libiscsi.h> 17#include "bnx2i.h" 18 19/** 20 * bnx2i_get_cid_num - get cid from ep 21 * @ep: endpoint pointer 22 * 23 * Only applicable to 57710 family of devices 24 */ 25static u32 bnx2i_get_cid_num(struct bnx2i_endpoint *ep) 26{ 27 u32 cid; 28 29 if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) 30 cid = ep->ep_cid; 31 else 32 cid = GET_CID_NUM(ep->ep_cid); 33 return cid; 34} 35 36 37/** 38 * bnx2i_adjust_qp_size - Adjust SQ/RQ/CQ size for 57710 device type 39 * @hba: Adapter for which adjustments is to be made 40 * 41 * Only applicable to 57710 family of devices 42 */ 43static void bnx2i_adjust_qp_size(struct bnx2i_hba *hba) 44{ 45 u32 num_elements_per_pg; 46 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); 52 53 if (!is_power_of_2(hba->max_rqes)) 54 hba->max_rqes = rounddown_pow_of_two(hba->max_rqes); 55 } 56 57 /* Adjust each queue size if the user selection does not 58 * yield integral num of page buffers 59 */ 60 /* adjust SQ */ 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); 67 68 /* adjust CQ */ 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); 75 76 /* adjust RQ */ 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); 83} 84 85 86/** 87 * bnx2i_get_link_state - get network interface link state 88 * @hba: adapter instance pointer 89 * 90 * updates adapter structure flag based on netdev state 91 */ 92static void bnx2i_get_link_state(struct bnx2i_hba *hba) 93{ 94 if (test_bit(__LINK_STATE_NOCARRIER, &hba->netdev->state)) 95 set_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state); 96 else 97 clear_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state); 98} 99 100 101/** 102 * bnx2i_iscsi_license_error - displays iscsi license related error message 103 * @hba: adapter instance pointer 104 * @error_code: error classification 105 * 106 * Puts out an error log when driver is unable to offload iscsi connection 107 * due to license restrictions 108 */ 109static void bnx2i_iscsi_license_error(struct bnx2i_hba *hba, u32 error_code) 110{ 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", 114 hba->netdev->name); 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", 119 hba->netdev->name); 120 set_bit(ADAPTER_STATE_INIT_FAILED, &hba->adapter_state); 121} 122 123 124/** 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 128 * 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 132 */ 133void bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint *ep, u8 action) 134{ 135 struct bnx2i_5771x_cq_db *cq_db; 136 u16 cq_index; 137 u16 next_index; 138 u32 num_active_cmds; 139 140 141 /* Coalesce CQ entries only on 10G devices */ 142 if (!test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) 143 return; 144 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 148 */ 149 cq_db = (struct bnx2i_5771x_cq_db *) ep->qp.cq_pgtbl_virt; 150 if (cq_db->sqn[0] && cq_db->sqn[0] != 0xFFFF) 151 return; 152 153 if (action == CNIC_ARM_CQE) { 154 num_active_cmds = ep->num_active_cmds; 155 if (num_active_cmds <= event_coal_min) 156 next_index = 1; 157 else 158 next_index = event_coal_min + 159 (num_active_cmds - event_coal_min) / event_coal_div; 160 if (!next_index) 161 next_index = 1; 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; 165 if (!cq_index) 166 cq_index = 1; 167 168 cq_db->sqn[0] = cq_index; 169 } 170} 171 172 173/** 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 177 * be copied 178 * @len: length of valid data inside RQ buf 179 * 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 182 * scsi sense info 183 */ 184void bnx2i_get_rq_buf(struct bnx2i_conn *bnx2i_conn, char *ptr, int len) 185{ 186 if (!bnx2i_conn->ep->qp.rqe_left) 187 return; 188 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; 194 } else { 195 bnx2i_conn->ep->qp.rq_cons_qe++; 196 bnx2i_conn->ep->qp.rq_cons_idx++; 197 } 198} 199 200 201static void bnx2i_ring_577xx_doorbell(struct bnx2i_conn *conn) 202{ 203 struct bnx2i_5771x_dbell dbell; 204 u32 msg; 205 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); 212} 213 214 215/** 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 219 * 220 * No need to ring hardware doorbell for 57710 family of devices 221 */ 222void bnx2i_put_rq_buf(struct bnx2i_conn *bnx2i_conn, int count) 223{ 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; 227 228 ep->qp.rqe_left += count; 229 ep->qp.rq_prod_idx &= 0x7FFF; 230 ep->qp.rq_prod_idx += count; 231 232 if (ep->qp.rq_prod_idx > bnx2i_conn->hba->max_rqes) { 233 ep->qp.rq_prod_idx %= bnx2i_conn->hba->max_rqes; 234 if (!hi_bit) 235 ep->qp.rq_prod_idx |= 0x8000; 236 } else 237 ep->qp.rq_prod_idx |= hi_bit; 238 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 */ 243 } else { 244 writew(ep->qp.rq_prod_idx, 245 ep->qp.ctx_base + CNIC_RECV_DOORBELL); 246 } 247 mmiowb(); 248} 249 250 251/** 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 255 * 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 258 * doorbell register 259 */ 260static void bnx2i_ring_sq_dbell(struct bnx2i_conn *bnx2i_conn, int count) 261{ 262 struct bnx2i_5771x_sq_rq_db *sq_db; 263 struct bnx2i_endpoint *ep = bnx2i_conn->ep; 264 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); 271 } else 272 writew(count, ep->qp.ctx_base + CNIC_SEND_DOORBELL); 273 274 mmiowb(); /* flush posted PCI writes */ 275} 276 277 278/** 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 282 * 283 * this routine will update SQ driver parameters and ring the doorbell 284 */ 285static void bnx2i_ring_dbell_update_sq_params(struct bnx2i_conn *bnx2i_conn, 286 int count) 287{ 288 int tmp_cnt; 289 290 if (count == 1) { 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; 295 else 296 bnx2i_conn->ep->qp.sq_prod_qe++; 297 } else { 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; 301 else { 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 - 306 (tmp_cnt + 1)]; 307 } 308 } 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); 312} 313 314 315/** 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 320 * 321 * prepare and post an iSCSI Login request WQE to CNIC firmware 322 */ 323int bnx2i_send_iscsi_login(struct bnx2i_conn *bnx2i_conn, 324 struct iscsi_task *task) 325{ 326 struct bnx2i_cmd *bnx2i_cmd; 327 struct bnx2i_login_request *login_wqe; 328 struct iscsi_login *login_hdr; 329 u32 dword; 330 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; 335 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; 347 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; 351 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); 355 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 */ 365 366 bnx2i_ring_dbell_update_sq_params(bnx2i_conn, 1); 367 return 0; 368} 369 370/** 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 375 * 376 * prepare and post an iSCSI Login request WQE to CNIC firmware 377 */ 378int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn, 379 struct iscsi_task *mtask) 380{ 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; 387 u32 dword; 388 u32 scsi_lun[2]; 389 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; 394 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; 399 400 tmfabort_wqe->itt = (mtask->itt | (ISCSI_TASK_TYPE_MPATH << 14)); 401 tmfabort_wqe->reserved2 = 0; 402 tmfabort_wqe->cmd_sn = be32_to_cpu(tmfabort_hdr->cmdsn); 403 404 ctask = iscsi_itt_to_task(conn, tmfabort_hdr->rtt); 405 if (!ctask || !ctask->sc) 406 /* 407 * the iscsi layer must have completed the cmd while this 408 * was starting up. 409 * 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 413 */ 414 return 0; 415 416 ref_sc = ctask->sc; 417 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]); 422 423 if (ref_sc->sc_data_direction == DMA_TO_DEVICE) 424 dword = (ISCSI_TASK_TYPE_WRITE << ISCSI_CMD_REQUEST_TYPE_SHIFT); 425 else 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); 429 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 */ 435 436 bnx2i_ring_dbell_update_sq_params(bnx2i_conn, 1); 437 return 0; 438} 439 440/** 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 445 * 446 * prepare and post an iSCSI SCSI-CMD request WQE to CNIC firmware 447 */ 448int bnx2i_send_iscsi_scsicmd(struct bnx2i_conn *bnx2i_conn, 449 struct bnx2i_cmd *cmd) 450{ 451 struct bnx2i_cmd_request *scsi_cmd_wqe; 452 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 */ 457 458 bnx2i_ring_dbell_update_sq_params(bnx2i_conn, 1); 459 return 0; 460} 461 462/** 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 472 * 473 * prepare and post a nopout request WQE to CNIC firmware 474 */ 475int bnx2i_send_iscsi_nopout(struct bnx2i_conn *bnx2i_conn, 476 struct iscsi_task *task, u32 ttt, 477 char *datap, int data_len, int unsol) 478{ 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; 483 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); 490 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; 496 } 497 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; 503 if (!unsol) 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; 507 508 nopout_wqe->cmd_sn = be32_to_cpu(nopout_hdr->cmdsn); 509 nopout_wqe->data_length = data_len; 510 if (data_len) { 511 /* handle payload data, not required in first release */ 512 printk(KERN_ALERT "NOPOUT: WARNING!! payload len != 0\n"); 513 } else { 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; 519 } 520 nopout_wqe->cq_index = 0; /* CQ# used for completion, 5771x only */ 521 522 bnx2i_ring_dbell_update_sq_params(bnx2i_conn, 1); 523 return 0; 524} 525 526 527/** 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 532 * 533 * prepare and post logout request WQE to CNIC firmware 534 */ 535int bnx2i_send_iscsi_logout(struct bnx2i_conn *bnx2i_conn, 536 struct iscsi_task *task) 537{ 538 struct bnx2i_cmd *bnx2i_cmd; 539 struct bnx2i_logout_request *logout_wqe; 540 struct iscsi_logout *logout_hdr; 541 542 bnx2i_cmd = (struct bnx2i_cmd *)task->dd_data; 543 logout_hdr = (struct iscsi_logout *)task->hdr; 544 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)); 548 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; 557 logout_wqe->cid = 0; 558 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 */ 564 565 bnx2i_conn->ep->state = EP_STATE_LOGOUT_SENT; 566 567 bnx2i_ring_dbell_update_sq_params(bnx2i_conn, 1); 568 return 0; 569} 570 571 572/** 573 * bnx2i_update_iscsi_conn - post iSCSI logout request WQE to hardware 574 * @conn: iscsi connection which requires iscsi parameter update 575 * 576 * sends down iSCSI Conn Update request to move iSCSI conn to FFP 577 */ 578void bnx2i_update_iscsi_conn(struct iscsi_conn *conn) 579{ 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; 585 586 update_wqe = &conn_update_kwqe; 587 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); 591 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; 595 else 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; 606 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); 621 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); 625} 626 627 628/** 629 * bnx2i_ep_ofld_timer - post iSCSI logout request WQE to hardware 630 * @data: endpoint (transport handle) structure pointer 631 * 632 * routine to handle connection offload/destroy request timeout 633 */ 634void bnx2i_ep_ofld_timer(unsigned long data) 635{ 636 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) data; 637 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; 647 } 648 649 wake_up_interruptible(&ep->ofld_wait); 650} 651 652 653static int bnx2i_power_of2(u32 val) 654{ 655 u32 power = 0; 656 if (val & (val - 1)) 657 return power; 658 val--; 659 while (val) { 660 val = val >> 1; 661 power++; 662 } 663 return power; 664} 665 666 667/** 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 672 * 673 * prepares and posts CONN_OFLD_REQ1/2 KWQE 674 */ 675void bnx2i_send_cmd_cleanup_req(struct bnx2i_hba *hba, struct bnx2i_cmd *cmd) 676{ 677 struct bnx2i_cleanup_request *cmd_cleanup; 678 679 cmd_cleanup = 680 (struct bnx2i_cleanup_request *)cmd->conn->ep->qp.sq_prod_qe; 681 memset(cmd_cleanup, 0x00, sizeof(struct bnx2i_cleanup_request)); 682 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 */ 686 687 bnx2i_ring_dbell_update_sq_params(cmd->conn, 1); 688} 689 690 691/** 692 * bnx2i_send_conn_destroy - initiates iscsi connection teardown process 693 * @hba: adapter structure pointer 694 * @ep: endpoint (transport indentifier) structure 695 * 696 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE to initiate 697 * iscsi connection context clean-up process 698 */ 699void bnx2i_send_conn_destroy(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep) 700{ 701 struct kwqe *kwqe_arr[2]; 702 struct iscsi_kwqe_conn_destroy conn_cleanup; 703 704 memset(&conn_cleanup, 0x00, sizeof(struct iscsi_kwqe_conn_destroy)); 705 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; 712 else 713 conn_cleanup.context_id = (ep->ep_cid >> 7); 714 715 conn_cleanup.reserved0 = (u16)ep->ep_iscsi_cid; 716 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); 720} 721 722 723/** 724 * bnx2i_570x_send_conn_ofld_req - initiates iscsi conn context setup process 725 * @hba: adapter structure pointer 726 * @ep: endpoint (transport indentifier) structure 727 * 728 * 5706/5708/5709 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE 729 */ 730static void bnx2i_570x_send_conn_ofld_req(struct bnx2i_hba *hba, 731 struct bnx2i_endpoint *ep) 732{ 733 struct kwqe *kwqe_arr[2]; 734 struct iscsi_kwqe_conn_offload1 ofld_req1; 735 struct iscsi_kwqe_conn_offload2 ofld_req2; 736 dma_addr_t dma_addr; 737 int num_kwqes = 2; 738 u32 *ptbl; 739 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); 743 744 ofld_req1.iscsi_conn_id = (u16) ep->ep_iscsi_cid; 745 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); 749 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); 753 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); 757 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); 761 762 ptbl = (u32 *) ep->qp.sq_pgtbl_virt; 763 764 ofld_req2.sq_first_pte.hi = *ptbl++; 765 ofld_req2.sq_first_pte.lo = *ptbl; 766 767 ptbl = (u32 *) ep->qp.cq_pgtbl_virt; 768 ofld_req2.cq_first_pte.hi = *ptbl++; 769 ofld_req2.cq_first_pte.lo = *ptbl; 770 771 kwqe_arr[0] = (struct kwqe *) &ofld_req1; 772 kwqe_arr[1] = (struct kwqe *) &ofld_req2; 773 ofld_req2.num_additional_wqes = 0; 774 775 if (hba->cnic && hba->cnic->submit_kwqes) 776 hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes); 777} 778 779 780/** 781 * bnx2i_5771x_send_conn_ofld_req - initiates iscsi connection context creation 782 * @hba: adapter structure pointer 783 * @ep: endpoint (transport indentifier) structure 784 * 785 * 57710 specific - prepares and posts CONN_OFLD_REQ1/2 KWQE 786 */ 787static void bnx2i_5771x_send_conn_ofld_req(struct bnx2i_hba *hba, 788 struct bnx2i_endpoint *ep) 789{ 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]; 794 dma_addr_t dma_addr; 795 int num_kwqes = 2; 796 u32 *ptbl; 797 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); 801 802 ofld_req1.iscsi_conn_id = (u16) ep->ep_iscsi_cid; 803 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); 807 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); 811 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); 815 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); 819 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; 823 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; 827 828 kwqe_arr[0] = (struct kwqe *) &ofld_req1; 829 kwqe_arr[1] = (struct kwqe *) &ofld_req2; 830 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; 836 837 kwqe_arr[2] = (struct kwqe *) ofld_req3; 838 /* need if we decide to go with multiple KCQE's per conn */ 839 num_kwqes += 1; 840 841 if (hba->cnic && hba->cnic->submit_kwqes) 842 hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, num_kwqes); 843} 844 845/** 846 * bnx2i_send_conn_ofld_req - initiates iscsi connection context setup process 847 * 848 * @hba: adapter structure pointer 849 * @ep: endpoint (transport indentifier) structure 850 * 851 * this routine prepares and posts CONN_OFLD_REQ1/2 KWQE 852 */ 853void bnx2i_send_conn_ofld_req(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep) 854{ 855 if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) 856 bnx2i_5771x_send_conn_ofld_req(hba, ep); 857 else 858 bnx2i_570x_send_conn_ofld_req(hba, ep); 859} 860 861 862/** 863 * setup_qp_page_tables - iscsi QP page table setup function 864 * @ep: endpoint (transport indentifier) structure 865 * 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 869 */ 870static void setup_qp_page_tables(struct bnx2i_endpoint *ep) 871{ 872 int num_pages; 873 u32 *ptbl; 874 dma_addr_t page; 875 int cnic_dev_10g; 876 877 if (test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type)) 878 cnic_dev_10g = 1; 879 else 880 cnic_dev_10g = 0; 881 882 /* SQ page table */ 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; 886 887 if (cnic_dev_10g) 888 ptbl = (u32 *)((u8 *)ep->qp.sq_pgtbl_virt + ISCSI_SQ_DB_SIZE); 889 else 890 ptbl = (u32 *) ep->qp.sq_pgtbl_virt; 891 while (num_pages--) { 892 if (cnic_dev_10g) { 893 /* PTE is written in little endian format for 57710 */ 894 *ptbl = (u32) page; 895 ptbl++; 896 *ptbl = (u32) ((u64) page >> 32); 897 ptbl++; 898 page += PAGE_SIZE; 899 } else { 900 /* PTE is written in big endian format for 901 * 5706/5708/5709 devices */ 902 *ptbl = (u32) ((u64) page >> 32); 903 ptbl++; 904 *ptbl = (u32) page; 905 ptbl++; 906 page += PAGE_SIZE; 907 } 908 } 909 910 /* RQ page table */ 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; 914 915 if (cnic_dev_10g) 916 ptbl = (u32 *)((u8 *)ep->qp.rq_pgtbl_virt + ISCSI_RQ_DB_SIZE); 917 else 918 ptbl = (u32 *) ep->qp.rq_pgtbl_virt; 919 while (num_pages--) { 920 if (cnic_dev_10g) { 921 /* PTE is written in little endian format for 57710 */ 922 *ptbl = (u32) page; 923 ptbl++; 924 *ptbl = (u32) ((u64) page >> 32); 925 ptbl++; 926 page += PAGE_SIZE; 927 } else { 928 /* PTE is written in big endian format for 929 * 5706/5708/5709 devices */ 930 *ptbl = (u32) ((u64) page >> 32); 931 ptbl++; 932 *ptbl = (u32) page; 933 ptbl++; 934 page += PAGE_SIZE; 935 } 936 } 937 938 /* CQ page table */ 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; 942 943 if (cnic_dev_10g) 944 ptbl = (u32 *)((u8 *)ep->qp.cq_pgtbl_virt + ISCSI_CQ_DB_SIZE); 945 else 946 ptbl = (u32 *) ep->qp.cq_pgtbl_virt; 947 while (num_pages--) { 948 if (cnic_dev_10g) { 949 /* PTE is written in little endian format for 57710 */ 950 *ptbl = (u32) page; 951 ptbl++; 952 *ptbl = (u32) ((u64) page >> 32); 953 ptbl++; 954 page += PAGE_SIZE; 955 } else { 956 /* PTE is written in big endian format for 957 * 5706/5708/5709 devices */ 958 *ptbl = (u32) ((u64) page >> 32); 959 ptbl++; 960 *ptbl = (u32) page; 961 ptbl++; 962 page += PAGE_SIZE; 963 } 964 } 965} 966 967 968/** 969 * bnx2i_alloc_qp_resc - allocates required resources for QP. 970 * @hba: adapter structure pointer 971 * @ep: endpoint (transport indentifier) structure 972 * 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 976 * contents are setup 977 */ 978int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep) 979{ 980 struct bnx2i_5771x_cq_db *cq_db; 981 982 ep->hba = hba; 983 ep->conn = NULL; 984 ep->ep_cid = ep->ep_iscsi_cid = ep->ep_pg_cid = 0; 985 986 /* Allocate page table memory for SQ which is page aligned */ 987 ep->qp.sq_mem_size = hba->max_sqes * BNX2I_SQ_WQE_SIZE; 988 ep->qp.sq_mem_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; 994 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); 1001 goto mem_alloc_err; 1002 } 1003 1004 /* Allocate memory area for actual SQ element */ 1005 ep->qp.sq_virt = 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); 1011 goto mem_alloc_err; 1012 } 1013 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; 1022 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; 1031 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); 1038 goto mem_alloc_err; 1039 } 1040 1041 /* Allocate memory area for actual CQ element */ 1042 ep->qp.cq_virt = 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); 1048 goto mem_alloc_err; 1049 } 1050 memset(ep->qp.cq_virt, 0x00, ep->qp.cq_mem_size); 1051 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; 1061 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); 1065 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; 1074 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); 1081 goto mem_alloc_err; 1082 } 1083 1084 /* Allocate memory area for actual RQ element */ 1085 ep->qp.rq_virt = 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); 1091 goto mem_alloc_err; 1092 } 1093 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; 1101 1102 setup_qp_page_tables(ep); 1103 1104 return 0; 1105 1106mem_alloc_err: 1107 bnx2i_free_qp_resc(hba, ep); 1108 return -ENOMEM; 1109} 1110 1111 1112 1113/** 1114 * bnx2i_free_qp_resc - free memory resources held by QP 1115 * @hba: adapter structure pointer 1116 * @ep: endpoint (transport indentifier) structure 1117 * 1118 * Free QP resources - SQ/RQ/CQ memory and page tables. 1119 */ 1120void bnx2i_free_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep) 1121{ 1122 if (ep->qp.ctx_base) { 1123 iounmap(ep->qp.ctx_base); 1124 ep->qp.ctx_base = NULL; 1125 } 1126 /* Free SQ mem */ 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; 1132 } 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; 1137 ep->qp.sq_phys = 0; 1138 } 1139 1140 /* Free RQ mem */ 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; 1146 } 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; 1151 ep->qp.rq_phys = 0; 1152 } 1153 1154 /* Free CQ mem */ 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; 1160 } 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; 1165 ep->qp.cq_phys = 0; 1166 } 1167} 1168 1169 1170/** 1171 * bnx2i_send_fw_iscsi_init_msg - initiates initial handshake with iscsi f/w 1172 * @hba: adapter structure pointer 1173 * 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 1180 */ 1181int bnx2i_send_fw_iscsi_init_msg(struct bnx2i_hba *hba) 1182{ 1183 struct kwqe *kwqe_arr[3]; 1184 struct iscsi_kwqe_init1 iscsi_init; 1185 struct iscsi_kwqe_init2 iscsi_init2; 1186 int rc = 0; 1187 u64 mask64; 1188 1189 bnx2i_adjust_qp_size(hba); 1190 1191 iscsi_init.flags = 1192 ISCSI_PAGE_SIZE_4K << ISCSI_KWQE_INIT1_PAGE_SIZE_SHIFT; 1193 if (en_tcp_dack) 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); 1200 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); 1204 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; 1220 1221 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; 1226 mask64 = 0x0ULL; 1227 mask64 |= ( 1228 /* CISCO MDS */ 1229 (1UL << 1230 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV) | 1231 /* HP MSA1510i */ 1232 (1UL << 1233 ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN) | 1234 /* EMC */ 1235 (1ULL << ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN)); 1236 if (error_mask1) 1237 iscsi_init2.error_bit_map[0] = error_mask1; 1238 else 1239 iscsi_init2.error_bit_map[0] = (u32) mask64; 1240 1241 if (error_mask2) 1242 iscsi_init2.error_bit_map[1] = error_mask2; 1243 else 1244 iscsi_init2.error_bit_map[1] = (u32) (mask64 >> 32); 1245 1246 iscsi_error_mask = mask64; 1247 1248 kwqe_arr[0] = (struct kwqe *) &iscsi_init; 1249 kwqe_arr[1] = (struct kwqe *) &iscsi_init2; 1250 1251 if (hba->cnic && hba->cnic->submit_kwqes) 1252 rc = hba->cnic->submit_kwqes(hba->cnic, kwqe_arr, 2); 1253 return rc; 1254} 1255 1256 1257/** 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 1261 * 1262 * process SCSI CMD Response CQE & complete the request to SCSI-ML 1263 */ 1264static int bnx2i_process_scsi_cmd_resp(struct iscsi_session *session, 1265 struct bnx2i_conn *bnx2i_conn, 1266 struct cqe *cqe) 1267{ 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; 1273 u32 datalen = 0; 1274 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); 1279 if (!task) 1280 goto fail; 1281 1282 bnx2i_cmd = task->dd_data; 1283 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; 1289 } else { 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; 1296 } 1297 bnx2i_iscsi_unmap_sg_list(bnx2i_cmd); 1298 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); 1308 1309 if (resp_cqe->op_code == ISCSI_OP_SCSI_DATA_IN) 1310 goto done; 1311 1312 if (resp_cqe->status == SAM_STAT_CHECK_CONDITION) { 1313 datalen = resp_cqe->data_length; 1314 if (datalen < 2) 1315 goto done; 1316 1317 if (datalen > BNX2I_RQ_WQE_SIZE) { 1318 iscsi_conn_printk(KERN_ERR, conn, 1319 "sense data len %d > RQ sz\n", 1320 datalen); 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", 1325 datalen); 1326 datalen = ISCSI_DEF_MAX_RECV_SEG_LEN; 1327 } 1328 1329 bnx2i_get_rq_buf(bnx2i_cmd->conn, conn->data, datalen); 1330 bnx2i_put_rq_buf(bnx2i_cmd->conn, 1); 1331 } 1332 1333done: 1334 __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, 1335 conn->data, datalen); 1336fail: 1337 spin_unlock(&session->lock); 1338 return 0; 1339} 1340 1341 1342/** 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 1347 * 1348 * process Login Response CQE & complete it to open-iscsi user daemon 1349 */ 1350static int bnx2i_process_login_resp(struct iscsi_session *session, 1351 struct bnx2i_conn *bnx2i_conn, 1352 struct cqe *cqe) 1353{ 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; 1358 int pld_len; 1359 int pad_len; 1360 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); 1365 if (!task) 1366 goto done; 1367 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; 1375 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; 1388 1389 pad_len = 0; 1390 if (pld_len & 0x3) 1391 pad_len = 4 - (pld_len % 4); 1392 1393 if (pad_len) { 1394 int i = 0; 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++; 1398 } 1399 } 1400 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); 1404done: 1405 spin_unlock(&session->lock); 1406 return 0; 1407} 1408 1409/** 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 1414 * 1415 * process iSCSI TMF Response CQE and wake up the driver eh thread. 1416 */ 1417static int bnx2i_process_tmf_resp(struct iscsi_session *session, 1418 struct bnx2i_conn *bnx2i_conn, 1419 struct cqe *cqe) 1420{ 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; 1425 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); 1430 if (!task) 1431 goto done; 1432 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; 1440 1441 __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0); 1442done: 1443 spin_unlock(&session->lock); 1444 return 0; 1445} 1446 1447/** 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 1452 * 1453 * process iSCSI Logout Response CQE & make function call to 1454 * notify the user daemon. 1455 */ 1456static int bnx2i_process_logout_resp(struct iscsi_session *session, 1457 struct bnx2i_conn *bnx2i_conn, 1458 struct cqe *cqe) 1459{ 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; 1464 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); 1469 if (!task) 1470 goto done; 1471 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; 1477 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); 1482 1483 resp_hdr->t2wait = cpu_to_be32(logout->time_to_wait); 1484 resp_hdr->t2retain = cpu_to_be32(logout->time_to_retain); 1485 1486 __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0); 1487 1488 bnx2i_conn->ep->state = EP_STATE_LOGOUT_RESP_RCVD; 1489done: 1490 spin_unlock(&session->lock); 1491 return 0; 1492} 1493 1494/** 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 1499 * 1500 * process iSCSI NOPIN local completion CQE, frees IIT and command structures 1501 */ 1502static void bnx2i_process_nopin_local_cmpl(struct iscsi_session *session, 1503 struct bnx2i_conn *bnx2i_conn, 1504 struct cqe *cqe) 1505{ 1506 struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data; 1507 struct bnx2i_nop_in_msg *nop_in; 1508 struct iscsi_task *task; 1509 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); 1514 if (task) 1515 iscsi_put_task(task); 1516 spin_unlock(&session->lock); 1517} 1518 1519/** 1520 * bnx2i_unsol_pdu_adjust_rq - makes adjustments to RQ after unsol pdu is recvd 1521 * @conn: iscsi connection 1522 * 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 1526 */ 1527static void bnx2i_unsol_pdu_adjust_rq(struct bnx2i_conn *bnx2i_conn) 1528{ 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); 1532} 1533 1534 1535/** 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 1540 * 1541 * process iSCSI target's proactive iSCSI NOPIN request 1542 */ 1543static int bnx2i_process_nopin_mesg(struct iscsi_session *session, 1544 struct bnx2i_conn *bnx2i_conn, 1545 struct cqe *cqe) 1546{ 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; 1551 u32 itt; 1552 int tgt_async_nop = 0; 1553 1554 nop_in = (struct bnx2i_nop_in_msg *)cqe; 1555 itt = nop_in->itt & ISCSI_NOP_IN_MSG_INDEX; 1556 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); 1564 1565 if (itt == (u16) RESERVED_ITT) { 1566 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn); 1567 hdr->itt = RESERVED_ITT; 1568 tgt_async_nop = 1; 1569 goto done; 1570 } 1571 1572 /* this is a response to one of our nop-outs */ 1573 task = iscsi_itt_to_task(conn, itt); 1574 if (task) { 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); 1579 } 1580done: 1581 __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0); 1582 spin_unlock(&session->lock); 1583 1584 return tgt_async_nop; 1585} 1586 1587 1588/** 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 1593 * 1594 * process iSCSI ASYNC Message 1595 */ 1596static void bnx2i_process_async_mesg(struct iscsi_session *session, 1597 struct bnx2i_conn *bnx2i_conn, 1598 struct cqe *cqe) 1599{ 1600 struct bnx2i_async_msg *async_cqe; 1601 struct iscsi_async *resp_hdr; 1602 u8 async_event; 1603 1604 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn); 1605 1606 async_cqe = (struct bnx2i_async_msg *)cqe; 1607 async_event = async_cqe->async_event; 1608 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"); 1612 return; 1613 } 1614 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; 1620 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); 1624 1625 resp_hdr->async_event = async_cqe->async_event; 1626 resp_hdr->async_vcode = async_cqe->async_vcode; 1627 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); 1631 1632 __iscsi_complete_pdu(bnx2i_conn->cls_conn->dd_data, 1633 (struct iscsi_hdr *)resp_hdr, NULL, 0); 1634 spin_unlock(&session->lock); 1635} 1636 1637 1638/** 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 1643 * 1644 * process iSCSI REJECT message 1645 */ 1646static void bnx2i_process_reject_mesg(struct iscsi_session *session, 1647 struct bnx2i_conn *bnx2i_conn, 1648 struct cqe *cqe) 1649{ 1650 struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data; 1651 struct bnx2i_reject_msg *reject; 1652 struct iscsi_reject *hdr; 1653 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); 1658 } else 1659 bnx2i_unsol_pdu_adjust_rq(bnx2i_conn); 1660 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); 1673} 1674 1675/** 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 1680 * 1681 * process command cleanup response CQE during conn shutdown or error recovery 1682 */ 1683static void bnx2i_process_cmd_cleanup_resp(struct iscsi_session *session, 1684 struct bnx2i_conn *bnx2i_conn, 1685 struct cqe *cqe) 1686{ 1687 struct bnx2i_cleanup_response *cmd_clean_rsp; 1688 struct iscsi_conn *conn = bnx2i_conn->cls_conn->dd_data; 1689 struct iscsi_task *task; 1690 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); 1695 if (!task) 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); 1700} 1701 1702 1703 1704/** 1705 * bnx2i_process_new_cqes - process newly DMA'ed CQE's 1706 * @bnx2i_conn: iscsi connection 1707 * 1708 * this function is called by generic KCQ handler to process all pending CQE's 1709 */ 1710static void bnx2i_process_new_cqes(struct bnx2i_conn *bnx2i_conn) 1711{ 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; 1716 int tgt_async_msg; 1717 1718 while (1) { 1719 nopin = (struct bnx2i_nop_in_msg *) qp->cq_cons_qe; 1720 if (nopin->cq_req_sn != qp->cqe_exp_seq_sn) 1721 break; 1722 1723 if (unlikely(test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx))) 1724 break; 1725 1726 tgt_async_msg = 0; 1727 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, 1732 qp->cq_cons_qe); 1733 break; 1734 case ISCSI_OP_LOGIN_RSP: 1735 bnx2i_process_login_resp(session, bnx2i_conn, 1736 qp->cq_cons_qe); 1737 break; 1738 case ISCSI_OP_SCSI_TMFUNC_RSP: 1739 bnx2i_process_tmf_resp(session, bnx2i_conn, 1740 qp->cq_cons_qe); 1741 break; 1742 case ISCSI_OP_LOGOUT_RSP: 1743 bnx2i_process_logout_resp(session, bnx2i_conn, 1744 qp->cq_cons_qe); 1745 break; 1746 case ISCSI_OP_NOOP_IN: 1747 if (bnx2i_process_nopin_mesg(session, bnx2i_conn, 1748 qp->cq_cons_qe)) 1749 tgt_async_msg = 1; 1750 break; 1751 case ISCSI_OPCODE_NOPOUT_LOCAL_COMPLETION: 1752 bnx2i_process_nopin_local_cmpl(session, bnx2i_conn, 1753 qp->cq_cons_qe); 1754 break; 1755 case ISCSI_OP_ASYNC_EVENT: 1756 bnx2i_process_async_mesg(session, bnx2i_conn, 1757 qp->cq_cons_qe); 1758 tgt_async_msg = 1; 1759 break; 1760 case ISCSI_OP_REJECT: 1761 bnx2i_process_reject_mesg(session, bnx2i_conn, 1762 qp->cq_cons_qe); 1763 break; 1764 case ISCSI_OPCODE_CLEANUP_RESPONSE: 1765 bnx2i_process_cmd_cleanup_resp(session, bnx2i_conn, 1766 qp->cq_cons_qe); 1767 break; 1768 default: 1769 printk(KERN_ALERT "bnx2i: unknown opcode 0x%x\n", 1770 nopin->op_code); 1771 } 1772 1773 if (!tgt_async_msg) 1774 bnx2i_conn->ep->num_active_cmds--; 1775 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; 1779 */ 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; 1783 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; 1787 } else { 1788 qp->cq_cons_qe++; 1789 qp->cq_cons_idx++; 1790 } 1791 } 1792 bnx2i_arm_cq_event_coalescing(bnx2i_conn->ep, CNIC_ARM_CQE); 1793} 1794 1795/** 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 1799 * 1800 * Fast path event notification handler, KCQ entry carries context id 1801 * of the connection that has 1 or more pending CQ entries 1802 */ 1803static void bnx2i_fastpath_notification(struct bnx2i_hba *hba, 1804 struct iscsi_kcqe *new_cqe_kcqe) 1805{ 1806 struct bnx2i_conn *conn; 1807 u32 iscsi_cid; 1808 1809 iscsi_cid = new_cqe_kcqe->iscsi_conn_id; 1810 conn = bnx2i_get_conn_from_id(hba, iscsi_cid); 1811 1812 if (!conn) { 1813 printk(KERN_ALERT "cid #%x not valid\n", iscsi_cid); 1814 return; 1815 } 1816 if (!conn->ep) { 1817 printk(KERN_ALERT "cid #%x - ep not bound\n", iscsi_cid); 1818 return; 1819 } 1820 1821 bnx2i_process_new_cqes(conn); 1822} 1823 1824 1825/** 1826 * bnx2i_process_update_conn_cmpl - process iscsi conn update completion KCQE 1827 * @hba: adapter structure pointer 1828 * @update_kcqe: kcqe pointer 1829 * 1830 * CONN_UPDATE completion handler, this completes iSCSI connection FFP migration 1831 */ 1832static void bnx2i_process_update_conn_cmpl(struct bnx2i_hba *hba, 1833 struct iscsi_kcqe *update_kcqe) 1834{ 1835 struct bnx2i_conn *conn; 1836 u32 iscsi_cid; 1837 1838 iscsi_cid = update_kcqe->iscsi_conn_id; 1839 conn = bnx2i_get_conn_from_id(hba, iscsi_cid); 1840 1841 if (!conn) { 1842 printk(KERN_ALERT "conn_update: cid %x not valid\n", iscsi_cid); 1843 return; 1844 } 1845 if (!conn->ep) { 1846 printk(KERN_ALERT "cid %x does not have ep bound\n", iscsi_cid); 1847 return; 1848 } 1849 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; 1853 } else 1854 conn->ep->state = EP_STATE_ULP_UPDATE_COMPL; 1855 1856 wake_up_interruptible(&conn->ep->ofld_wait); 1857} 1858 1859 1860/** 1861 * bnx2i_recovery_que_add_conn - add connection to recovery queue 1862 * @hba: adapter structure pointer 1863 * @bnx2i_conn: iscsi connection 1864 * 1865 * Add connection to recovery queue and schedule adapter eh worker 1866 */ 1867static void bnx2i_recovery_que_add_conn(struct bnx2i_hba *hba, 1868 struct bnx2i_conn *bnx2i_conn) 1869{ 1870 iscsi_conn_failure(bnx2i_conn->cls_conn->dd_data, 1871 ISCSI_ERR_CONN_FAILED); 1872} 1873 1874 1875/** 1876 * bnx2i_process_tcp_error - process error notification on a given connection 1877 * 1878 * @hba: adapter structure pointer 1879 * @tcp_err: tcp error kcqe pointer 1880 * 1881 * handles tcp level error notifications from FW. 1882 */ 1883static void bnx2i_process_tcp_error(struct bnx2i_hba *hba, 1884 struct iscsi_kcqe *tcp_err) 1885{ 1886 struct bnx2i_conn *bnx2i_conn; 1887 u32 iscsi_cid; 1888 1889 iscsi_cid = tcp_err->iscsi_conn_id; 1890 bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid); 1891 1892 if (!bnx2i_conn) { 1893 printk(KERN_ALERT "bnx2i - cid 0x%x not valid\n", iscsi_cid); 1894 return; 1895 } 1896 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); 1900} 1901 1902 1903/** 1904 * bnx2i_process_iscsi_error - process error notification on a given connection 1905 * @hba: adapter structure pointer 1906 * @iscsi_err: iscsi error kcqe pointer 1907 * 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) 1915 */ 1916static void bnx2i_process_iscsi_error(struct bnx2i_hba *hba, 1917 struct iscsi_kcqe *iscsi_err) 1918{ 1919 struct bnx2i_conn *bnx2i_conn; 1920 u32 iscsi_cid; 1921 char warn_notice[] = "iscsi_warning"; 1922 char error_notice[] = "iscsi_error"; 1923 char additional_notice[64]; 1924 char *message; 1925 int need_recovery; 1926 u64 err_mask64; 1927 1928 iscsi_cid = iscsi_err->iscsi_conn_id; 1929 bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid); 1930 if (!bnx2i_conn) { 1931 printk(KERN_ALERT "bnx2i - cid 0x%x not valid\n", iscsi_cid); 1932 return; 1933 } 1934 1935 err_mask64 = (0x1ULL << iscsi_err->completion_status); 1936 1937 if (err_mask64 & iscsi_error_mask) { 1938 need_recovery = 0; 1939 message = warn_notice; 1940 } else { 1941 need_recovery = 1; 1942 message = error_notice; 1943 } 1944 1945 switch (iscsi_err->completion_status) { 1946 case ISCSI_KCQE_COMPLETION_STATUS_HDR_DIG_ERR: 1947 strcpy(additional_notice, "hdr digest err"); 1948 break; 1949 case ISCSI_KCQE_COMPLETION_STATUS_DATA_DIG_ERR: 1950 strcpy(additional_notice, "data digest err"); 1951 break; 1952 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_OPCODE: 1953 strcpy(additional_notice, "wrong opcode rcvd"); 1954 break; 1955 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_AHS_LEN: 1956 strcpy(additional_notice, "AHS len > 0 rcvd"); 1957 break; 1958 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ITT: 1959 strcpy(additional_notice, "invalid ITT rcvd"); 1960 break; 1961 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_STATSN: 1962 strcpy(additional_notice, "wrong StatSN rcvd"); 1963 break; 1964 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_EXP_DATASN: 1965 strcpy(additional_notice, "wrong DataSN rcvd"); 1966 break; 1967 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T: 1968 strcpy(additional_notice, "pend R2T violation"); 1969 break; 1970 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_0: 1971 strcpy(additional_notice, "ERL0, UO"); 1972 break; 1973 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_1: 1974 strcpy(additional_notice, "ERL0, U1"); 1975 break; 1976 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_2: 1977 strcpy(additional_notice, "ERL0, U2"); 1978 break; 1979 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_3: 1980 strcpy(additional_notice, "ERL0, U3"); 1981 break; 1982 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_4: 1983 strcpy(additional_notice, "ERL0, U4"); 1984 break; 1985 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_5: 1986 strcpy(additional_notice, "ERL0, U5"); 1987 break; 1988 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_O_U_6: 1989 strcpy(additional_notice, "ERL0, U6"); 1990 break; 1991 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_RCV_LEN: 1992 strcpy(additional_notice, "invalid resi len"); 1993 break; 1994 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_RCV_PDU_LEN: 1995 strcpy(additional_notice, "MRDSL violation"); 1996 break; 1997 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_F_BIT_ZERO: 1998 strcpy(additional_notice, "F-bit not set"); 1999 break; 2000 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_NOT_RSRV: 2001 strcpy(additional_notice, "invalid TTT"); 2002 break; 2003 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_DATASN: 2004 strcpy(additional_notice, "invalid DataSN"); 2005 break; 2006 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REMAIN_BURST_LEN: 2007 strcpy(additional_notice, "burst len violation"); 2008 break; 2009 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_BUFFER_OFF: 2010 strcpy(additional_notice, "buf offset violation"); 2011 break; 2012 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_LUN: 2013 strcpy(additional_notice, "invalid LUN field"); 2014 break; 2015 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_R2TSN: 2016 strcpy(additional_notice, "invalid R2TSN field"); 2017 break; 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"); 2022 break; 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"); 2027 break; 2028 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_PEND_R2T_EXCEED: 2029 strcpy(additional_notice, 2030 "pend r2t exceeds MaxOutstandingR2T value"); 2031 break; 2032 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_TTT_IS_RSRV: 2033 strcpy(additional_notice, "TTT is rsvd"); 2034 break; 2035 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_MAX_BURST_LEN: 2036 strcpy(additional_notice, "MBL violation"); 2037 break; 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"); 2042 break; 2043 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_REJECT_PDU_LEN: 2044 strcpy(additional_notice, "reject pdu len error"); 2045 break; 2046 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_ASYNC_PDU_LEN: 2047 strcpy(additional_notice, "async pdu len error"); 2048 break; 2049 case ISCSI_KCQE_COMPLETION_STATUS_PROTOCOL_ERR_NOPIN_PDU_LEN: 2050 strcpy(additional_notice, "nopin pdu len error"); 2051 break; 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"); 2056 break; 2057 2058 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_FRAGMENT: 2059 strcpy(additional_notice, "IP fragments rcvd"); 2060 break; 2061 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_IP_OPTIONS: 2062 strcpy(additional_notice, "IP options error"); 2063 break; 2064 case ISCI_KCQE_COMPLETION_STATUS_TCP_ERROR_URGENT_FLAG: 2065 strcpy(additional_notice, "urgent flag error"); 2066 break; 2067 default: 2068 printk(KERN_ALERT "iscsi_err - unknown err %x\n", 2069 iscsi_err->completion_status); 2070 } 2071 2072 if (need_recovery) { 2073 iscsi_conn_printk(KERN_ALERT, 2074 bnx2i_conn->cls_conn->dd_data, 2075 "bnx2i: %s - %s\n", 2076 message, additional_notice); 2077 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); 2086 } else 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, 2091 "bnx2i: %s - %s\n", 2092 message, additional_notice); 2093} 2094 2095 2096/** 2097 * bnx2i_process_conn_destroy_cmpl - process iscsi conn destroy completion 2098 * @hba: adapter structure pointer 2099 * @conn_destroy: conn destroy kcqe pointer 2100 * 2101 * handles connection destroy completion request. 2102 */ 2103static void bnx2i_process_conn_destroy_cmpl(struct bnx2i_hba *hba, 2104 struct iscsi_kcqe *conn_destroy) 2105{ 2106 struct bnx2i_endpoint *ep; 2107 2108 ep = bnx2i_find_ep_in_destroy_list(hba, conn_destroy->iscsi_conn_id); 2109 if (!ep) { 2110 printk(KERN_ALERT "bnx2i_conn_destroy_cmpl: no pending " 2111 "offload request, unexpected complection\n"); 2112 return; 2113 } 2114 2115 if (hba != ep->hba) { 2116 printk(KERN_ALERT "conn destroy- error hba mis-match\n"); 2117 return; 2118 } 2119 2120 if (conn_destroy->completion_status) { 2121 printk(KERN_ALERT "conn_destroy_cmpl: op failed\n"); 2122 ep->state = EP_STATE_CLEANUP_FAILED; 2123 } else 2124 ep->state = EP_STATE_CLEANUP_CMPL; 2125 wake_up_interruptible(&ep->ofld_wait); 2126} 2127 2128 2129/** 2130 * bnx2i_process_ofld_cmpl - process initial iscsi conn offload completion 2131 * @hba: adapter structure pointer 2132 * @ofld_kcqe: conn offload kcqe pointer 2133 * 2134 * handles initial connection offload completion, ep_connect() thread is 2135 * woken-up to continue with LLP connect process 2136 */ 2137static void bnx2i_process_ofld_cmpl(struct bnx2i_hba *hba, 2138 struct iscsi_kcqe *ofld_kcqe) 2139{ 2140 u32 cid_addr; 2141 struct bnx2i_endpoint *ep; 2142 u32 cid_num; 2143 2144 ep = bnx2i_find_ep_in_ofld_list(hba, ofld_kcqe->iscsi_conn_id); 2145 if (!ep) { 2146 printk(KERN_ALERT "ofld_cmpl: no pend offload request\n"); 2147 return; 2148 } 2149 2150 if (hba != ep->hba) { 2151 printk(KERN_ALERT "ofld_cmpl: error hba mis-match\n"); 2152 return; 2153 } 2154 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; 2161 } else { 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; 2167 } 2168 wake_up_interruptible(&ep->ofld_wait); 2169} 2170 2171/** 2172 * bnx2i_indicate_kcqe - process iscsi conn update completion KCQE 2173 * @hba: adapter structure pointer 2174 * @update_kcqe: kcqe pointer 2175 * 2176 * Generic KCQ event handler/dispatcher 2177 */ 2178static void bnx2i_indicate_kcqe(void *context, struct kcqe *kcqe[], 2179 u32 num_cqe) 2180{ 2181 struct bnx2i_hba *hba = context; 2182 int i = 0; 2183 struct iscsi_kcqe *ikcqe = NULL; 2184 2185 while (i < num_cqe) { 2186 ikcqe = (struct iscsi_kcqe *) kcqe[i++]; 2187 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->\ 2199 completion_status); 2200 else { 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, 2206 hba->pci_devno, 2207 (u8)hba->pci_func); 2208 2209 2210 } 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); 2217 else 2218 printk(KERN_ALERT "bnx2i: unknown opcode 0x%x\n", 2219 ikcqe->op_code); 2220 } 2221} 2222 2223 2224/** 2225 * bnx2i_indicate_netevent - Generic netdev event handler 2226 * @context: adapter structure pointer 2227 * @event: event type 2228 * 2229 * Handles four netdev events, NETDEV_UP, NETDEV_DOWN, 2230 * NETDEV_GOING_DOWN and NETDEV_CHANGE 2231 */ 2232static void bnx2i_indicate_netevent(void *context, unsigned long event) 2233{ 2234 struct bnx2i_hba *hba = context; 2235 2236 switch (event) { 2237 case NETDEV_UP: 2238 if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state)) 2239 bnx2i_send_fw_iscsi_init_msg(hba); 2240 break; 2241 case NETDEV_DOWN: 2242 clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state); 2243 clear_bit(ADAPTER_STATE_UP, &hba->adapter_state); 2244 break; 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); 2249 break; 2250 case NETDEV_CHANGE: 2251 bnx2i_get_link_state(hba); 2252 break; 2253 default: 2254 ; 2255 } 2256} 2257 2258 2259/** 2260 * bnx2i_cm_connect_cmpl - process iscsi conn establishment completion 2261 * @cm_sk: cnic sock structure pointer 2262 * 2263 * function callback exported via bnx2i - cnic driver interface to 2264 * indicate completion of option-2 TCP connect request. 2265 */ 2266static void bnx2i_cm_connect_cmpl(struct cnic_sock *cm_sk) 2267{ 2268 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context; 2269 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; 2274 else 2275 ep->state = EP_STATE_CONNECT_FAILED; 2276 2277 wake_up_interruptible(&ep->ofld_wait); 2278} 2279 2280 2281/** 2282 * bnx2i_cm_close_cmpl - process tcp conn close completion 2283 * @cm_sk: cnic sock structure pointer 2284 * 2285 * function callback exported via bnx2i - cnic driver interface to 2286 * indicate completion of option-2 graceful TCP connect shutdown 2287 */ 2288static void bnx2i_cm_close_cmpl(struct cnic_sock *cm_sk) 2289{ 2290 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context; 2291 2292 ep->state = EP_STATE_DISCONN_COMPL; 2293 wake_up_interruptible(&ep->ofld_wait); 2294} 2295 2296 2297/** 2298 * bnx2i_cm_abort_cmpl - process abortive tcp conn teardown completion 2299 * @cm_sk: cnic sock structure pointer 2300 * 2301 * function callback exported via bnx2i - cnic driver interface to 2302 * indicate completion of option-2 abortive TCP connect termination 2303 */ 2304static void bnx2i_cm_abort_cmpl(struct cnic_sock *cm_sk) 2305{ 2306 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context; 2307 2308 ep->state = EP_STATE_DISCONN_COMPL; 2309 wake_up_interruptible(&ep->ofld_wait); 2310} 2311 2312 2313/** 2314 * bnx2i_cm_remote_close - process received TCP FIN 2315 * @hba: adapter structure pointer 2316 * @update_kcqe: kcqe pointer 2317 * 2318 * function callback exported via bnx2i - cnic driver interface to indicate 2319 * async TCP events such as FIN 2320 */ 2321static void bnx2i_cm_remote_close(struct cnic_sock *cm_sk) 2322{ 2323 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context; 2324 2325 ep->state = EP_STATE_TCP_FIN_RCVD; 2326 if (ep->conn) 2327 bnx2i_recovery_que_add_conn(ep->hba, ep->conn); 2328} 2329 2330/** 2331 * bnx2i_cm_remote_abort - process TCP RST and start conn cleanup 2332 * @hba: adapter structure pointer 2333 * @update_kcqe: kcqe pointer 2334 * 2335 * function callback exported via bnx2i - cnic driver interface to 2336 * indicate async TCP events (RST) sent by the peer. 2337 */ 2338static void bnx2i_cm_remote_abort(struct cnic_sock *cm_sk) 2339{ 2340 struct bnx2i_endpoint *ep = (struct bnx2i_endpoint *) cm_sk->context; 2341 2342 ep->state = EP_STATE_TCP_RST_RCVD; 2343 if (ep->conn) 2344 bnx2i_recovery_que_add_conn(ep->hba, ep->conn); 2345} 2346 2347 2348static void bnx2i_send_nl_mesg(struct cnic_dev *dev, u32 msg_type, 2349 char *buf, u16 buflen) 2350{ 2351 struct bnx2i_hba *hba; 2352 2353 hba = bnx2i_find_hba_for_cnic(dev); 2354 if (!hba) 2355 return; 2356 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"); 2360 2361} 2362 2363 2364/** 2365 * bnx2i_cnic_cb - global template of bnx2i - cnic driver interface structure 2366 * carrying callback function pointers 2367 * 2368 */ 2369struct 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 2383}; 2384 2385 2386/** 2387 * bnx2i_map_ep_dbell_regs - map connection doorbell registers 2388 * @ep: bnx2i endpoint 2389 * 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 2392 * mapping BAR #1 2393 */ 2394int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep) 2395{ 2396 u32 cid_num; 2397 u32 reg_off; 2398 u32 first_l4l5; 2399 u32 ctx_sz; 2400 u32 config2; 2401 resource_size_t reg_base; 2402 2403 cid_num = bnx2i_get_cid_num(ep); 2404 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); 2410 goto arm_cq; 2411 } 2412 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; 2419 if (ctx_sz) 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); 2423 else 2424 reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num); 2425 } else 2426 /* 5709 device in normal node and 5706/5708 devices */ 2427 reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num); 2428 2429 ep->qp.ctx_base = ioremap_nocache(reg_base + reg_off, 2430 MB_KERNEL_CTX_SIZE); 2431 if (!ep->qp.ctx_base) 2432 return -ENOMEM; 2433 2434arm_cq: 2435 bnx2i_arm_cq_event_coalescing(ep, CNIC_ARM_CQE); 2436 return 0; 2437} 2438