1 /* 2 * bnx2fc_els.c: QLogic Linux FCoE offload driver. 3 * This file contains helper routines that handle ELS requests 4 * and responses. 5 * 6 * Copyright (c) 2008-2013 Broadcom Corporation 7 * Copyright (c) 2014-2016 QLogic Corporation 8 * Copyright (c) 2016-2017 Cavium Inc. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation. 13 * 14 * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com) 15 */ 16 17 #include "bnx2fc.h" 18 19 static void bnx2fc_logo_resp(struct fc_seq *seq, struct fc_frame *fp, 20 void *arg); 21 static void bnx2fc_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, 22 void *arg); 23 static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op, 24 void *data, u32 data_len, 25 void (*cb_func)(struct bnx2fc_els_cb_arg *cb_arg), 26 struct bnx2fc_els_cb_arg *cb_arg, u32 timer_msec); 27 28 static void bnx2fc_rrq_compl(struct bnx2fc_els_cb_arg *cb_arg) 29 { 30 struct bnx2fc_cmd *orig_io_req; 31 struct bnx2fc_cmd *rrq_req; 32 int rc = 0; 33 34 BUG_ON(!cb_arg); 35 rrq_req = cb_arg->io_req; 36 orig_io_req = cb_arg->aborted_io_req; 37 BUG_ON(!orig_io_req); 38 BNX2FC_ELS_DBG("rrq_compl: orig xid = 0x%x, rrq_xid = 0x%x\n", 39 orig_io_req->xid, rrq_req->xid); 40 41 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 42 43 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &rrq_req->req_flags)) { 44 /* 45 * els req is timed out. cleanup the IO with FW and 46 * drop the completion. Remove from active_cmd_queue. 47 */ 48 BNX2FC_ELS_DBG("rrq xid - 0x%x timed out, clean it up\n", 49 rrq_req->xid); 50 51 if (rrq_req->on_active_queue) { 52 list_del_init(&rrq_req->link); 53 rrq_req->on_active_queue = 0; 54 rc = bnx2fc_initiate_cleanup(rrq_req); 55 BUG_ON(rc); 56 } 57 } 58 kfree(cb_arg); 59 } 60 int bnx2fc_send_rrq(struct bnx2fc_cmd *aborted_io_req) 61 { 62 63 struct fc_els_rrq rrq; 64 struct bnx2fc_rport *tgt = aborted_io_req->tgt; 65 struct fc_lport *lport = NULL; 66 struct bnx2fc_els_cb_arg *cb_arg = NULL; 67 u32 sid = 0; 68 u32 r_a_tov = 0; 69 unsigned long start = jiffies; 70 int rc; 71 72 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) 73 return -EINVAL; 74 75 lport = tgt->rdata->local_port; 76 sid = tgt->sid; 77 r_a_tov = lport->r_a_tov; 78 79 BNX2FC_ELS_DBG("Sending RRQ orig_xid = 0x%x\n", 80 aborted_io_req->xid); 81 memset(&rrq, 0, sizeof(rrq)); 82 83 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_NOIO); 84 if (!cb_arg) { 85 printk(KERN_ERR PFX "Unable to allocate cb_arg for RRQ\n"); 86 rc = -ENOMEM; 87 goto rrq_err; 88 } 89 90 cb_arg->aborted_io_req = aborted_io_req; 91 92 rrq.rrq_cmd = ELS_RRQ; 93 hton24(rrq.rrq_s_id, sid); 94 rrq.rrq_ox_id = htons(aborted_io_req->xid); 95 rrq.rrq_rx_id = htons(aborted_io_req->task->rxwr_txrd.var_ctx.rx_id); 96 97 retry_rrq: 98 rc = bnx2fc_initiate_els(tgt, ELS_RRQ, &rrq, sizeof(rrq), 99 bnx2fc_rrq_compl, cb_arg, 100 r_a_tov); 101 if (rc == -ENOMEM) { 102 if (time_after(jiffies, start + (10 * HZ))) { 103 BNX2FC_ELS_DBG("rrq Failed\n"); 104 rc = FAILED; 105 goto rrq_err; 106 } 107 msleep(20); 108 goto retry_rrq; 109 } 110 rrq_err: 111 if (rc) { 112 BNX2FC_ELS_DBG("RRQ failed - release orig io req 0x%x\n", 113 aborted_io_req->xid); 114 kfree(cb_arg); 115 spin_lock_bh(&tgt->tgt_lock); 116 kref_put(&aborted_io_req->refcount, bnx2fc_cmd_release); 117 spin_unlock_bh(&tgt->tgt_lock); 118 } 119 return rc; 120 } 121 122 static void bnx2fc_l2_els_compl(struct bnx2fc_els_cb_arg *cb_arg) 123 { 124 struct bnx2fc_cmd *els_req; 125 struct bnx2fc_rport *tgt; 126 struct bnx2fc_mp_req *mp_req; 127 struct fc_frame_header *fc_hdr; 128 unsigned char *buf; 129 void *resp_buf; 130 u32 resp_len, hdr_len; 131 u16 l2_oxid; 132 int frame_len; 133 int rc = 0; 134 135 l2_oxid = cb_arg->l2_oxid; 136 BNX2FC_ELS_DBG("ELS COMPL - l2_oxid = 0x%x\n", l2_oxid); 137 138 els_req = cb_arg->io_req; 139 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &els_req->req_flags)) { 140 /* 141 * els req is timed out. cleanup the IO with FW and 142 * drop the completion. libfc will handle the els timeout 143 */ 144 if (els_req->on_active_queue) { 145 list_del_init(&els_req->link); 146 els_req->on_active_queue = 0; 147 rc = bnx2fc_initiate_cleanup(els_req); 148 BUG_ON(rc); 149 } 150 goto free_arg; 151 } 152 153 tgt = els_req->tgt; 154 mp_req = &(els_req->mp_req); 155 fc_hdr = &(mp_req->resp_fc_hdr); 156 resp_len = mp_req->resp_len; 157 resp_buf = mp_req->resp_buf; 158 159 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC); 160 if (!buf) { 161 printk(KERN_ERR PFX "Unable to alloc mp buf\n"); 162 goto free_arg; 163 } 164 hdr_len = sizeof(*fc_hdr); 165 if (hdr_len + resp_len > PAGE_SIZE) { 166 printk(KERN_ERR PFX "l2_els_compl: resp len is " 167 "beyond page size\n"); 168 goto free_buf; 169 } 170 memcpy(buf, fc_hdr, hdr_len); 171 memcpy(buf + hdr_len, resp_buf, resp_len); 172 frame_len = hdr_len + resp_len; 173 174 bnx2fc_process_l2_frame_compl(tgt, buf, frame_len, l2_oxid); 175 176 free_buf: 177 kfree(buf); 178 free_arg: 179 kfree(cb_arg); 180 } 181 182 int bnx2fc_send_adisc(struct bnx2fc_rport *tgt, struct fc_frame *fp) 183 { 184 struct fc_els_adisc *adisc; 185 struct fc_frame_header *fh; 186 struct bnx2fc_els_cb_arg *cb_arg; 187 struct fc_lport *lport = tgt->rdata->local_port; 188 u32 r_a_tov = lport->r_a_tov; 189 int rc; 190 191 fh = fc_frame_header_get(fp); 192 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 193 if (!cb_arg) { 194 printk(KERN_ERR PFX "Unable to allocate cb_arg for ADISC\n"); 195 return -ENOMEM; 196 } 197 198 cb_arg->l2_oxid = ntohs(fh->fh_ox_id); 199 200 BNX2FC_ELS_DBG("send ADISC: l2_oxid = 0x%x\n", cb_arg->l2_oxid); 201 adisc = fc_frame_payload_get(fp, sizeof(*adisc)); 202 /* adisc is initialized by libfc */ 203 rc = bnx2fc_initiate_els(tgt, ELS_ADISC, adisc, sizeof(*adisc), 204 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov); 205 if (rc) 206 kfree(cb_arg); 207 return rc; 208 } 209 210 int bnx2fc_send_logo(struct bnx2fc_rport *tgt, struct fc_frame *fp) 211 { 212 struct fc_els_logo *logo; 213 struct fc_frame_header *fh; 214 struct bnx2fc_els_cb_arg *cb_arg; 215 struct fc_lport *lport = tgt->rdata->local_port; 216 u32 r_a_tov = lport->r_a_tov; 217 int rc; 218 219 fh = fc_frame_header_get(fp); 220 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 221 if (!cb_arg) { 222 printk(KERN_ERR PFX "Unable to allocate cb_arg for LOGO\n"); 223 return -ENOMEM; 224 } 225 226 cb_arg->l2_oxid = ntohs(fh->fh_ox_id); 227 228 BNX2FC_ELS_DBG("Send LOGO: l2_oxid = 0x%x\n", cb_arg->l2_oxid); 229 logo = fc_frame_payload_get(fp, sizeof(*logo)); 230 /* logo is initialized by libfc */ 231 rc = bnx2fc_initiate_els(tgt, ELS_LOGO, logo, sizeof(*logo), 232 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov); 233 if (rc) 234 kfree(cb_arg); 235 return rc; 236 } 237 238 int bnx2fc_send_rls(struct bnx2fc_rport *tgt, struct fc_frame *fp) 239 { 240 struct fc_els_rls *rls; 241 struct fc_frame_header *fh; 242 struct bnx2fc_els_cb_arg *cb_arg; 243 struct fc_lport *lport = tgt->rdata->local_port; 244 u32 r_a_tov = lport->r_a_tov; 245 int rc; 246 247 fh = fc_frame_header_get(fp); 248 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 249 if (!cb_arg) { 250 printk(KERN_ERR PFX "Unable to allocate cb_arg for LOGO\n"); 251 return -ENOMEM; 252 } 253 254 cb_arg->l2_oxid = ntohs(fh->fh_ox_id); 255 256 rls = fc_frame_payload_get(fp, sizeof(*rls)); 257 /* rls is initialized by libfc */ 258 rc = bnx2fc_initiate_els(tgt, ELS_RLS, rls, sizeof(*rls), 259 bnx2fc_l2_els_compl, cb_arg, 2 * r_a_tov); 260 if (rc) 261 kfree(cb_arg); 262 return rc; 263 } 264 265 static void bnx2fc_srr_compl(struct bnx2fc_els_cb_arg *cb_arg) 266 { 267 struct bnx2fc_mp_req *mp_req; 268 struct fc_frame_header *fc_hdr, *fh; 269 struct bnx2fc_cmd *srr_req; 270 struct bnx2fc_cmd *orig_io_req; 271 struct fc_frame *fp; 272 unsigned char *buf; 273 void *resp_buf; 274 u32 resp_len, hdr_len; 275 u8 opcode; 276 int rc = 0; 277 278 orig_io_req = cb_arg->aborted_io_req; 279 srr_req = cb_arg->io_req; 280 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &srr_req->req_flags)) { 281 /* SRR timedout */ 282 BNX2FC_IO_DBG(srr_req, "srr timed out, abort " 283 "orig_io - 0x%x\n", 284 orig_io_req->xid); 285 rc = bnx2fc_initiate_abts(srr_req); 286 if (rc != SUCCESS) { 287 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts " 288 "failed. issue cleanup\n"); 289 bnx2fc_initiate_cleanup(srr_req); 290 } 291 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags) || 292 test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) { 293 BNX2FC_IO_DBG(srr_req, "srr_compl:xid 0x%x flags = %lx", 294 orig_io_req->xid, orig_io_req->req_flags); 295 goto srr_compl_done; 296 } 297 orig_io_req->srr_retry++; 298 if (orig_io_req->srr_retry <= SRR_RETRY_COUNT) { 299 struct bnx2fc_rport *tgt = orig_io_req->tgt; 300 spin_unlock_bh(&tgt->tgt_lock); 301 rc = bnx2fc_send_srr(orig_io_req, 302 orig_io_req->srr_offset, 303 orig_io_req->srr_rctl); 304 spin_lock_bh(&tgt->tgt_lock); 305 if (!rc) 306 goto srr_compl_done; 307 } 308 309 rc = bnx2fc_initiate_abts(orig_io_req); 310 if (rc != SUCCESS) { 311 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts " 312 "failed xid = 0x%x. issue cleanup\n", 313 orig_io_req->xid); 314 bnx2fc_initiate_cleanup(orig_io_req); 315 } 316 goto srr_compl_done; 317 } 318 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags) || 319 test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) { 320 BNX2FC_IO_DBG(srr_req, "srr_compl:xid - 0x%x flags = %lx", 321 orig_io_req->xid, orig_io_req->req_flags); 322 goto srr_compl_done; 323 } 324 mp_req = &(srr_req->mp_req); 325 fc_hdr = &(mp_req->resp_fc_hdr); 326 resp_len = mp_req->resp_len; 327 resp_buf = mp_req->resp_buf; 328 329 hdr_len = sizeof(*fc_hdr); 330 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC); 331 if (!buf) { 332 printk(KERN_ERR PFX "srr buf: mem alloc failure\n"); 333 goto srr_compl_done; 334 } 335 memcpy(buf, fc_hdr, hdr_len); 336 memcpy(buf + hdr_len, resp_buf, resp_len); 337 338 fp = fc_frame_alloc(NULL, resp_len); 339 if (!fp) { 340 printk(KERN_ERR PFX "fc_frame_alloc failure\n"); 341 goto free_buf; 342 } 343 344 fh = (struct fc_frame_header *) fc_frame_header_get(fp); 345 /* Copy FC Frame header and payload into the frame */ 346 memcpy(fh, buf, hdr_len + resp_len); 347 348 opcode = fc_frame_payload_op(fp); 349 switch (opcode) { 350 case ELS_LS_ACC: 351 BNX2FC_IO_DBG(srr_req, "SRR success\n"); 352 break; 353 case ELS_LS_RJT: 354 BNX2FC_IO_DBG(srr_req, "SRR rejected\n"); 355 rc = bnx2fc_initiate_abts(orig_io_req); 356 if (rc != SUCCESS) { 357 BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts " 358 "failed xid = 0x%x. issue cleanup\n", 359 orig_io_req->xid); 360 bnx2fc_initiate_cleanup(orig_io_req); 361 } 362 break; 363 default: 364 BNX2FC_IO_DBG(srr_req, "srr compl - invalid opcode = %d\n", 365 opcode); 366 break; 367 } 368 fc_frame_free(fp); 369 free_buf: 370 kfree(buf); 371 srr_compl_done: 372 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 373 } 374 375 static void bnx2fc_rec_compl(struct bnx2fc_els_cb_arg *cb_arg) 376 { 377 struct bnx2fc_cmd *orig_io_req, *new_io_req; 378 struct bnx2fc_cmd *rec_req; 379 struct bnx2fc_mp_req *mp_req; 380 struct fc_frame_header *fc_hdr, *fh; 381 struct fc_els_ls_rjt *rjt; 382 struct fc_els_rec_acc *acc; 383 struct bnx2fc_rport *tgt; 384 struct fcoe_err_report_entry *err_entry; 385 struct scsi_cmnd *sc_cmd; 386 enum fc_rctl r_ctl; 387 unsigned char *buf; 388 void *resp_buf; 389 struct fc_frame *fp; 390 u8 opcode; 391 u32 offset; 392 u32 e_stat; 393 u32 resp_len, hdr_len; 394 int rc = 0; 395 bool send_seq_clnp = false; 396 bool abort_io = false; 397 398 BNX2FC_MISC_DBG("Entered rec_compl callback\n"); 399 rec_req = cb_arg->io_req; 400 orig_io_req = cb_arg->aborted_io_req; 401 BNX2FC_IO_DBG(rec_req, "rec_compl: orig xid = 0x%x", orig_io_req->xid); 402 tgt = orig_io_req->tgt; 403 404 /* Handle REC timeout case */ 405 if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &rec_req->req_flags)) { 406 BNX2FC_IO_DBG(rec_req, "timed out, abort " 407 "orig_io - 0x%x\n", 408 orig_io_req->xid); 409 /* els req is timed out. send abts for els */ 410 rc = bnx2fc_initiate_abts(rec_req); 411 if (rc != SUCCESS) { 412 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts " 413 "failed. issue cleanup\n"); 414 bnx2fc_initiate_cleanup(rec_req); 415 } 416 orig_io_req->rec_retry++; 417 /* REC timedout. send ABTS to the orig IO req */ 418 if (orig_io_req->rec_retry <= REC_RETRY_COUNT) { 419 spin_unlock_bh(&tgt->tgt_lock); 420 rc = bnx2fc_send_rec(orig_io_req); 421 spin_lock_bh(&tgt->tgt_lock); 422 if (!rc) 423 goto rec_compl_done; 424 } 425 rc = bnx2fc_initiate_abts(orig_io_req); 426 if (rc != SUCCESS) { 427 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts " 428 "failed xid = 0x%x. issue cleanup\n", 429 orig_io_req->xid); 430 bnx2fc_initiate_cleanup(orig_io_req); 431 } 432 goto rec_compl_done; 433 } 434 435 if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags)) { 436 BNX2FC_IO_DBG(rec_req, "completed" 437 "orig_io - 0x%x\n", 438 orig_io_req->xid); 439 goto rec_compl_done; 440 } 441 if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) { 442 BNX2FC_IO_DBG(rec_req, "abts in prog " 443 "orig_io - 0x%x\n", 444 orig_io_req->xid); 445 goto rec_compl_done; 446 } 447 448 mp_req = &(rec_req->mp_req); 449 fc_hdr = &(mp_req->resp_fc_hdr); 450 resp_len = mp_req->resp_len; 451 acc = resp_buf = mp_req->resp_buf; 452 453 hdr_len = sizeof(*fc_hdr); 454 455 buf = kzalloc(PAGE_SIZE, GFP_ATOMIC); 456 if (!buf) { 457 printk(KERN_ERR PFX "rec buf: mem alloc failure\n"); 458 goto rec_compl_done; 459 } 460 memcpy(buf, fc_hdr, hdr_len); 461 memcpy(buf + hdr_len, resp_buf, resp_len); 462 463 fp = fc_frame_alloc(NULL, resp_len); 464 if (!fp) { 465 printk(KERN_ERR PFX "fc_frame_alloc failure\n"); 466 goto free_buf; 467 } 468 469 fh = (struct fc_frame_header *) fc_frame_header_get(fp); 470 /* Copy FC Frame header and payload into the frame */ 471 memcpy(fh, buf, hdr_len + resp_len); 472 473 opcode = fc_frame_payload_op(fp); 474 if (opcode == ELS_LS_RJT) { 475 BNX2FC_IO_DBG(rec_req, "opcode is RJT\n"); 476 rjt = fc_frame_payload_get(fp, sizeof(*rjt)); 477 if ((rjt->er_reason == ELS_RJT_LOGIC || 478 rjt->er_reason == ELS_RJT_UNAB) && 479 rjt->er_explan == ELS_EXPL_OXID_RXID) { 480 BNX2FC_IO_DBG(rec_req, "handle CMD LOST case\n"); 481 new_io_req = bnx2fc_cmd_alloc(tgt); 482 if (!new_io_req) 483 goto abort_io; 484 new_io_req->sc_cmd = orig_io_req->sc_cmd; 485 /* cleanup orig_io_req that is with the FW */ 486 set_bit(BNX2FC_FLAG_CMD_LOST, 487 &orig_io_req->req_flags); 488 bnx2fc_initiate_cleanup(orig_io_req); 489 /* Post a new IO req with the same sc_cmd */ 490 BNX2FC_IO_DBG(rec_req, "Post IO request again\n"); 491 rc = bnx2fc_post_io_req(tgt, new_io_req); 492 if (!rc) 493 goto free_frame; 494 BNX2FC_IO_DBG(rec_req, "REC: io post err\n"); 495 } 496 abort_io: 497 rc = bnx2fc_initiate_abts(orig_io_req); 498 if (rc != SUCCESS) { 499 BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts " 500 "failed. issue cleanup\n"); 501 bnx2fc_initiate_cleanup(orig_io_req); 502 } 503 } else if (opcode == ELS_LS_ACC) { 504 /* REVISIT: Check if the exchange is already aborted */ 505 offset = ntohl(acc->reca_fc4value); 506 e_stat = ntohl(acc->reca_e_stat); 507 if (e_stat & ESB_ST_SEQ_INIT) { 508 BNX2FC_IO_DBG(rec_req, "target has the seq init\n"); 509 goto free_frame; 510 } 511 BNX2FC_IO_DBG(rec_req, "e_stat = 0x%x, offset = 0x%x\n", 512 e_stat, offset); 513 /* Seq initiative is with us */ 514 err_entry = (struct fcoe_err_report_entry *) 515 &orig_io_req->err_entry; 516 sc_cmd = orig_io_req->sc_cmd; 517 if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) { 518 /* SCSI WRITE command */ 519 if (offset == orig_io_req->data_xfer_len) { 520 BNX2FC_IO_DBG(rec_req, "WRITE - resp lost\n"); 521 /* FCP_RSP lost */ 522 r_ctl = FC_RCTL_DD_CMD_STATUS; 523 offset = 0; 524 } else { 525 /* start transmitting from offset */ 526 BNX2FC_IO_DBG(rec_req, "XFER_RDY/DATA lost\n"); 527 send_seq_clnp = true; 528 r_ctl = FC_RCTL_DD_DATA_DESC; 529 if (bnx2fc_initiate_seq_cleanup(orig_io_req, 530 offset, r_ctl)) 531 abort_io = true; 532 /* XFER_RDY */ 533 } 534 } else { 535 /* SCSI READ command */ 536 if (err_entry->data.rx_buf_off == 537 orig_io_req->data_xfer_len) { 538 /* FCP_RSP lost */ 539 BNX2FC_IO_DBG(rec_req, "READ - resp lost\n"); 540 r_ctl = FC_RCTL_DD_CMD_STATUS; 541 offset = 0; 542 } else { 543 /* request retransmission from this offset */ 544 send_seq_clnp = true; 545 offset = err_entry->data.rx_buf_off; 546 BNX2FC_IO_DBG(rec_req, "RD DATA lost\n"); 547 /* FCP_DATA lost */ 548 r_ctl = FC_RCTL_DD_SOL_DATA; 549 if (bnx2fc_initiate_seq_cleanup(orig_io_req, 550 offset, r_ctl)) 551 abort_io = true; 552 } 553 } 554 if (abort_io) { 555 rc = bnx2fc_initiate_abts(orig_io_req); 556 if (rc != SUCCESS) { 557 BNX2FC_IO_DBG(rec_req, "rec_compl:initiate_abts" 558 " failed. issue cleanup\n"); 559 bnx2fc_initiate_cleanup(orig_io_req); 560 } 561 } else if (!send_seq_clnp) { 562 BNX2FC_IO_DBG(rec_req, "Send SRR - FCP_RSP\n"); 563 spin_unlock_bh(&tgt->tgt_lock); 564 rc = bnx2fc_send_srr(orig_io_req, offset, r_ctl); 565 spin_lock_bh(&tgt->tgt_lock); 566 567 if (rc) { 568 BNX2FC_IO_DBG(rec_req, "Unable to send SRR" 569 " IO will abort\n"); 570 } 571 } 572 } 573 free_frame: 574 fc_frame_free(fp); 575 free_buf: 576 kfree(buf); 577 rec_compl_done: 578 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 579 kfree(cb_arg); 580 } 581 582 int bnx2fc_send_rec(struct bnx2fc_cmd *orig_io_req) 583 { 584 struct fc_els_rec rec; 585 struct bnx2fc_rport *tgt = orig_io_req->tgt; 586 struct fc_lport *lport = tgt->rdata->local_port; 587 struct bnx2fc_els_cb_arg *cb_arg = NULL; 588 u32 sid = tgt->sid; 589 u32 r_a_tov = lport->r_a_tov; 590 int rc; 591 592 BNX2FC_IO_DBG(orig_io_req, "Sending REC\n"); 593 memset(&rec, 0, sizeof(rec)); 594 595 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 596 if (!cb_arg) { 597 printk(KERN_ERR PFX "Unable to allocate cb_arg for REC\n"); 598 rc = -ENOMEM; 599 goto rec_err; 600 } 601 kref_get(&orig_io_req->refcount); 602 603 cb_arg->aborted_io_req = orig_io_req; 604 605 rec.rec_cmd = ELS_REC; 606 hton24(rec.rec_s_id, sid); 607 rec.rec_ox_id = htons(orig_io_req->xid); 608 rec.rec_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id); 609 610 rc = bnx2fc_initiate_els(tgt, ELS_REC, &rec, sizeof(rec), 611 bnx2fc_rec_compl, cb_arg, 612 r_a_tov); 613 if (rc) { 614 BNX2FC_IO_DBG(orig_io_req, "REC failed - release\n"); 615 spin_lock_bh(&tgt->tgt_lock); 616 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 617 spin_unlock_bh(&tgt->tgt_lock); 618 kfree(cb_arg); 619 } 620 rec_err: 621 return rc; 622 } 623 624 int bnx2fc_send_srr(struct bnx2fc_cmd *orig_io_req, u32 offset, u8 r_ctl) 625 { 626 struct fcp_srr srr; 627 struct bnx2fc_rport *tgt = orig_io_req->tgt; 628 struct fc_lport *lport = tgt->rdata->local_port; 629 struct bnx2fc_els_cb_arg *cb_arg = NULL; 630 u32 r_a_tov = lport->r_a_tov; 631 int rc; 632 633 BNX2FC_IO_DBG(orig_io_req, "Sending SRR\n"); 634 memset(&srr, 0, sizeof(srr)); 635 636 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 637 if (!cb_arg) { 638 printk(KERN_ERR PFX "Unable to allocate cb_arg for SRR\n"); 639 rc = -ENOMEM; 640 goto srr_err; 641 } 642 kref_get(&orig_io_req->refcount); 643 644 cb_arg->aborted_io_req = orig_io_req; 645 646 srr.srr_op = ELS_SRR; 647 srr.srr_ox_id = htons(orig_io_req->xid); 648 srr.srr_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id); 649 srr.srr_rel_off = htonl(offset); 650 srr.srr_r_ctl = r_ctl; 651 orig_io_req->srr_offset = offset; 652 orig_io_req->srr_rctl = r_ctl; 653 654 rc = bnx2fc_initiate_els(tgt, ELS_SRR, &srr, sizeof(srr), 655 bnx2fc_srr_compl, cb_arg, 656 r_a_tov); 657 if (rc) { 658 BNX2FC_IO_DBG(orig_io_req, "SRR failed - release\n"); 659 spin_lock_bh(&tgt->tgt_lock); 660 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 661 spin_unlock_bh(&tgt->tgt_lock); 662 kfree(cb_arg); 663 } else 664 set_bit(BNX2FC_FLAG_SRR_SENT, &orig_io_req->req_flags); 665 666 srr_err: 667 return rc; 668 } 669 670 static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op, 671 void *data, u32 data_len, 672 void (*cb_func)(struct bnx2fc_els_cb_arg *cb_arg), 673 struct bnx2fc_els_cb_arg *cb_arg, u32 timer_msec) 674 { 675 struct fcoe_port *port = tgt->port; 676 struct bnx2fc_interface *interface = port->priv; 677 struct fc_rport *rport = tgt->rport; 678 struct fc_lport *lport = port->lport; 679 struct bnx2fc_cmd *els_req; 680 struct bnx2fc_mp_req *mp_req; 681 struct fc_frame_header *fc_hdr; 682 struct fcoe_task_ctx_entry *task; 683 struct fcoe_task_ctx_entry *task_page; 684 int rc = 0; 685 int task_idx, index; 686 u32 did, sid; 687 u16 xid; 688 689 rc = fc_remote_port_chkready(rport); 690 if (rc) { 691 printk(KERN_ERR PFX "els 0x%x: rport not ready\n", op); 692 rc = -EINVAL; 693 goto els_err; 694 } 695 if (lport->state != LPORT_ST_READY || !(lport->link_up)) { 696 printk(KERN_ERR PFX "els 0x%x: link is not ready\n", op); 697 rc = -EINVAL; 698 goto els_err; 699 } 700 if (!(test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags))) { 701 printk(KERN_ERR PFX "els 0x%x: tgt not ready\n", op); 702 rc = -EINVAL; 703 goto els_err; 704 } 705 els_req = bnx2fc_elstm_alloc(tgt, BNX2FC_ELS); 706 if (!els_req) { 707 rc = -ENOMEM; 708 goto els_err; 709 } 710 711 els_req->sc_cmd = NULL; 712 els_req->port = port; 713 els_req->tgt = tgt; 714 els_req->cb_func = cb_func; 715 cb_arg->io_req = els_req; 716 els_req->cb_arg = cb_arg; 717 els_req->data_xfer_len = data_len; 718 719 mp_req = (struct bnx2fc_mp_req *)&(els_req->mp_req); 720 rc = bnx2fc_init_mp_req(els_req); 721 if (rc == FAILED) { 722 printk(KERN_ERR PFX "ELS MP request init failed\n"); 723 spin_lock_bh(&tgt->tgt_lock); 724 kref_put(&els_req->refcount, bnx2fc_cmd_release); 725 spin_unlock_bh(&tgt->tgt_lock); 726 rc = -ENOMEM; 727 goto els_err; 728 } else { 729 /* rc SUCCESS */ 730 rc = 0; 731 } 732 733 /* Set the data_xfer_len to the size of ELS payload */ 734 mp_req->req_len = data_len; 735 els_req->data_xfer_len = mp_req->req_len; 736 737 /* Fill ELS Payload */ 738 if ((op >= ELS_LS_RJT) && (op <= ELS_AUTH_ELS)) { 739 memcpy(mp_req->req_buf, data, data_len); 740 } else { 741 printk(KERN_ERR PFX "Invalid ELS op 0x%x\n", op); 742 els_req->cb_func = NULL; 743 els_req->cb_arg = NULL; 744 spin_lock_bh(&tgt->tgt_lock); 745 kref_put(&els_req->refcount, bnx2fc_cmd_release); 746 spin_unlock_bh(&tgt->tgt_lock); 747 rc = -EINVAL; 748 } 749 750 if (rc) 751 goto els_err; 752 753 /* Fill FC header */ 754 fc_hdr = &(mp_req->req_fc_hdr); 755 756 did = tgt->rport->port_id; 757 sid = tgt->sid; 758 759 if (op == ELS_SRR) 760 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS4_REQ, did, sid, 761 FC_TYPE_FCP, FC_FC_FIRST_SEQ | 762 FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 763 else 764 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS_REQ, did, sid, 765 FC_TYPE_ELS, FC_FC_FIRST_SEQ | 766 FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 767 768 /* Obtain exchange id */ 769 xid = els_req->xid; 770 task_idx = xid/BNX2FC_TASKS_PER_PAGE; 771 index = xid % BNX2FC_TASKS_PER_PAGE; 772 773 /* Initialize task context for this IO request */ 774 task_page = (struct fcoe_task_ctx_entry *) 775 interface->hba->task_ctx[task_idx]; 776 task = &(task_page[index]); 777 bnx2fc_init_mp_task(els_req, task); 778 779 spin_lock_bh(&tgt->tgt_lock); 780 781 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) { 782 printk(KERN_ERR PFX "initiate_els.. session not ready\n"); 783 els_req->cb_func = NULL; 784 els_req->cb_arg = NULL; 785 kref_put(&els_req->refcount, bnx2fc_cmd_release); 786 spin_unlock_bh(&tgt->tgt_lock); 787 return -EINVAL; 788 } 789 790 if (timer_msec) 791 bnx2fc_cmd_timer_set(els_req, timer_msec); 792 bnx2fc_add_2_sq(tgt, xid); 793 794 els_req->on_active_queue = 1; 795 list_add_tail(&els_req->link, &tgt->els_queue); 796 797 /* Ring doorbell */ 798 bnx2fc_ring_doorbell(tgt); 799 spin_unlock_bh(&tgt->tgt_lock); 800 801 els_err: 802 return rc; 803 } 804 805 void bnx2fc_process_els_compl(struct bnx2fc_cmd *els_req, 806 struct fcoe_task_ctx_entry *task, u8 num_rq) 807 { 808 struct bnx2fc_mp_req *mp_req; 809 struct fc_frame_header *fc_hdr; 810 u64 *hdr; 811 u64 *temp_hdr; 812 813 BNX2FC_ELS_DBG("Entered process_els_compl xid = 0x%x" 814 "cmd_type = %d\n", els_req->xid, els_req->cmd_type); 815 816 if (test_and_set_bit(BNX2FC_FLAG_ELS_DONE, 817 &els_req->req_flags)) { 818 BNX2FC_ELS_DBG("Timer context finished processing this " 819 "els - 0x%x\n", els_req->xid); 820 /* This IO doesn't receive cleanup completion */ 821 kref_put(&els_req->refcount, bnx2fc_cmd_release); 822 return; 823 } 824 825 /* Cancel the timeout_work, as we received the response */ 826 if (cancel_delayed_work(&els_req->timeout_work)) 827 kref_put(&els_req->refcount, 828 bnx2fc_cmd_release); /* drop timer hold */ 829 830 if (els_req->on_active_queue) { 831 list_del_init(&els_req->link); 832 els_req->on_active_queue = 0; 833 } 834 835 mp_req = &(els_req->mp_req); 836 fc_hdr = &(mp_req->resp_fc_hdr); 837 838 hdr = (u64 *)fc_hdr; 839 temp_hdr = (u64 *) 840 &task->rxwr_only.union_ctx.comp_info.mp_rsp.fc_hdr; 841 hdr[0] = cpu_to_be64(temp_hdr[0]); 842 hdr[1] = cpu_to_be64(temp_hdr[1]); 843 hdr[2] = cpu_to_be64(temp_hdr[2]); 844 845 mp_req->resp_len = 846 task->rxwr_only.union_ctx.comp_info.mp_rsp.mp_payload_len; 847 848 /* Parse ELS response */ 849 if ((els_req->cb_func) && (els_req->cb_arg)) { 850 els_req->cb_func(els_req->cb_arg); 851 els_req->cb_arg = NULL; 852 } 853 854 kref_put(&els_req->refcount, bnx2fc_cmd_release); 855 } 856 857 #define BNX2FC_FCOE_MAC_METHOD_GRANGED_MAC 1 858 #define BNX2FC_FCOE_MAC_METHOD_FCF_MAP 2 859 #define BNX2FC_FCOE_MAC_METHOD_FCOE_SET_MAC 3 860 static void bnx2fc_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, 861 void *arg) 862 { 863 struct fcoe_ctlr *fip = arg; 864 struct fc_exch *exch = fc_seq_exch(seq); 865 struct fc_lport *lport = exch->lp; 866 867 struct fc_frame_header *fh; 868 u8 *granted_mac; 869 u8 fcoe_mac[6]; 870 u8 fc_map[3]; 871 int method; 872 873 if (IS_ERR(fp)) 874 goto done; 875 876 fh = fc_frame_header_get(fp); 877 granted_mac = fr_cb(fp)->granted_mac; 878 879 /* 880 * We set the source MAC for FCoE traffic based on the Granted MAC 881 * address from the switch. 882 * 883 * If granted_mac is non-zero, we use that. 884 * If the granted_mac is zeroed out, create the FCoE MAC based on 885 * the sel_fcf->fc_map and the d_id fo the FLOGI frame. 886 * If sel_fcf->fc_map is 0, then we use the default FCF-MAC plus the 887 * d_id of the FLOGI frame. 888 */ 889 if (!is_zero_ether_addr(granted_mac)) { 890 ether_addr_copy(fcoe_mac, granted_mac); 891 method = BNX2FC_FCOE_MAC_METHOD_GRANGED_MAC; 892 } else if (fip->sel_fcf && fip->sel_fcf->fc_map != 0) { 893 hton24(fc_map, fip->sel_fcf->fc_map); 894 fcoe_mac[0] = fc_map[0]; 895 fcoe_mac[1] = fc_map[1]; 896 fcoe_mac[2] = fc_map[2]; 897 fcoe_mac[3] = fh->fh_d_id[0]; 898 fcoe_mac[4] = fh->fh_d_id[1]; 899 fcoe_mac[5] = fh->fh_d_id[2]; 900 method = BNX2FC_FCOE_MAC_METHOD_FCF_MAP; 901 } else { 902 fc_fcoe_set_mac(fcoe_mac, fh->fh_d_id); 903 method = BNX2FC_FCOE_MAC_METHOD_FCOE_SET_MAC; 904 } 905 906 BNX2FC_HBA_DBG(lport, "fcoe_mac=%pM method=%d\n", fcoe_mac, method); 907 fip->update_mac(lport, fcoe_mac); 908 done: 909 fc_lport_flogi_resp(seq, fp, lport); 910 } 911 912 static void bnx2fc_logo_resp(struct fc_seq *seq, struct fc_frame *fp, 913 void *arg) 914 { 915 struct fcoe_ctlr *fip = arg; 916 struct fc_exch *exch = fc_seq_exch(seq); 917 struct fc_lport *lport = exch->lp; 918 static u8 zero_mac[ETH_ALEN] = { 0 }; 919 920 if (!IS_ERR(fp)) 921 fip->update_mac(lport, zero_mac); 922 fc_lport_logo_resp(seq, fp, lport); 923 } 924 925 struct fc_seq *bnx2fc_elsct_send(struct fc_lport *lport, u32 did, 926 struct fc_frame *fp, unsigned int op, 927 void (*resp)(struct fc_seq *, 928 struct fc_frame *, 929 void *), 930 void *arg, u32 timeout) 931 { 932 struct fcoe_port *port = lport_priv(lport); 933 struct bnx2fc_interface *interface = port->priv; 934 struct fcoe_ctlr *fip = bnx2fc_to_ctlr(interface); 935 struct fc_frame_header *fh = fc_frame_header_get(fp); 936 937 switch (op) { 938 case ELS_FLOGI: 939 case ELS_FDISC: 940 return fc_elsct_send(lport, did, fp, op, bnx2fc_flogi_resp, 941 fip, timeout); 942 case ELS_LOGO: 943 /* only hook onto fabric logouts, not port logouts */ 944 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI) 945 break; 946 return fc_elsct_send(lport, did, fp, op, bnx2fc_logo_resp, 947 fip, timeout); 948 } 949 return fc_elsct_send(lport, did, fp, op, resp, arg, timeout); 950 } 951