1 /* bnx2fc_io.c: Broadcom NetXtreme II Linux FCoE offload driver. 2 * IO manager and SCSI IO processing. 3 * 4 * Copyright (c) 2008 - 2010 Broadcom Corporation 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation. 9 * 10 * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com) 11 */ 12 13 #include "bnx2fc.h" 14 15 #define RESERVE_FREE_LIST_INDEX num_possible_cpus() 16 17 static int bnx2fc_split_bd(struct bnx2fc_cmd *io_req, u64 addr, int sg_len, 18 int bd_index); 19 static int bnx2fc_map_sg(struct bnx2fc_cmd *io_req); 20 static void bnx2fc_build_bd_list_from_sg(struct bnx2fc_cmd *io_req); 21 static void bnx2fc_unmap_sg_list(struct bnx2fc_cmd *io_req); 22 static void bnx2fc_free_mp_resc(struct bnx2fc_cmd *io_req); 23 static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req, 24 struct fcoe_fcp_rsp_payload *fcp_rsp, 25 u8 num_rq); 26 27 void bnx2fc_cmd_timer_set(struct bnx2fc_cmd *io_req, 28 unsigned int timer_msec) 29 { 30 struct bnx2fc_interface *interface = io_req->port->priv; 31 32 if (queue_delayed_work(interface->timer_work_queue, 33 &io_req->timeout_work, 34 msecs_to_jiffies(timer_msec))) 35 kref_get(&io_req->refcount); 36 } 37 38 static void bnx2fc_cmd_timeout(struct work_struct *work) 39 { 40 struct bnx2fc_cmd *io_req = container_of(work, struct bnx2fc_cmd, 41 timeout_work.work); 42 struct fc_lport *lport; 43 struct fc_rport_priv *rdata; 44 u8 cmd_type = io_req->cmd_type; 45 struct bnx2fc_rport *tgt = io_req->tgt; 46 int logo_issued; 47 int rc; 48 49 BNX2FC_IO_DBG(io_req, "cmd_timeout, cmd_type = %d," 50 "req_flags = %lx\n", cmd_type, io_req->req_flags); 51 52 spin_lock_bh(&tgt->tgt_lock); 53 if (test_and_clear_bit(BNX2FC_FLAG_ISSUE_RRQ, &io_req->req_flags)) { 54 clear_bit(BNX2FC_FLAG_RETIRE_OXID, &io_req->req_flags); 55 /* 56 * ideally we should hold the io_req until RRQ complets, 57 * and release io_req from timeout hold. 58 */ 59 spin_unlock_bh(&tgt->tgt_lock); 60 bnx2fc_send_rrq(io_req); 61 return; 62 } 63 if (test_and_clear_bit(BNX2FC_FLAG_RETIRE_OXID, &io_req->req_flags)) { 64 BNX2FC_IO_DBG(io_req, "IO ready for reuse now\n"); 65 goto done; 66 } 67 68 switch (cmd_type) { 69 case BNX2FC_SCSI_CMD: 70 if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT, 71 &io_req->req_flags)) { 72 /* Handle eh_abort timeout */ 73 BNX2FC_IO_DBG(io_req, "eh_abort timed out\n"); 74 complete(&io_req->tm_done); 75 } else if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, 76 &io_req->req_flags)) { 77 /* Handle internally generated ABTS timeout */ 78 BNX2FC_IO_DBG(io_req, "ABTS timed out refcnt = %d\n", 79 io_req->refcount.refcount.counter); 80 if (!(test_and_set_bit(BNX2FC_FLAG_ABTS_DONE, 81 &io_req->req_flags))) { 82 83 lport = io_req->port->lport; 84 rdata = io_req->tgt->rdata; 85 logo_issued = test_and_set_bit( 86 BNX2FC_FLAG_EXPL_LOGO, 87 &tgt->flags); 88 kref_put(&io_req->refcount, bnx2fc_cmd_release); 89 spin_unlock_bh(&tgt->tgt_lock); 90 91 /* Explicitly logo the target */ 92 if (!logo_issued) { 93 BNX2FC_IO_DBG(io_req, "Explicit " 94 "logo - tgt flags = 0x%lx\n", 95 tgt->flags); 96 97 mutex_lock(&lport->disc.disc_mutex); 98 lport->tt.rport_logoff(rdata); 99 mutex_unlock(&lport->disc.disc_mutex); 100 } 101 return; 102 } 103 } else { 104 /* Hanlde IO timeout */ 105 BNX2FC_IO_DBG(io_req, "IO timed out. issue ABTS\n"); 106 if (test_and_set_bit(BNX2FC_FLAG_IO_COMPL, 107 &io_req->req_flags)) { 108 BNX2FC_IO_DBG(io_req, "IO completed before " 109 " timer expiry\n"); 110 goto done; 111 } 112 113 if (!test_and_set_bit(BNX2FC_FLAG_ISSUE_ABTS, 114 &io_req->req_flags)) { 115 rc = bnx2fc_initiate_abts(io_req); 116 if (rc == SUCCESS) 117 goto done; 118 /* 119 * Explicitly logo the target if 120 * abts initiation fails 121 */ 122 lport = io_req->port->lport; 123 rdata = io_req->tgt->rdata; 124 logo_issued = test_and_set_bit( 125 BNX2FC_FLAG_EXPL_LOGO, 126 &tgt->flags); 127 kref_put(&io_req->refcount, bnx2fc_cmd_release); 128 spin_unlock_bh(&tgt->tgt_lock); 129 130 if (!logo_issued) { 131 BNX2FC_IO_DBG(io_req, "Explicit " 132 "logo - tgt flags = 0x%lx\n", 133 tgt->flags); 134 135 136 mutex_lock(&lport->disc.disc_mutex); 137 lport->tt.rport_logoff(rdata); 138 mutex_unlock(&lport->disc.disc_mutex); 139 } 140 return; 141 } else { 142 BNX2FC_IO_DBG(io_req, "IO already in " 143 "ABTS processing\n"); 144 } 145 } 146 break; 147 case BNX2FC_ELS: 148 149 if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags)) { 150 BNX2FC_IO_DBG(io_req, "ABTS for ELS timed out\n"); 151 152 if (!test_and_set_bit(BNX2FC_FLAG_ABTS_DONE, 153 &io_req->req_flags)) { 154 lport = io_req->port->lport; 155 rdata = io_req->tgt->rdata; 156 logo_issued = test_and_set_bit( 157 BNX2FC_FLAG_EXPL_LOGO, 158 &tgt->flags); 159 kref_put(&io_req->refcount, bnx2fc_cmd_release); 160 spin_unlock_bh(&tgt->tgt_lock); 161 162 /* Explicitly logo the target */ 163 if (!logo_issued) { 164 BNX2FC_IO_DBG(io_req, "Explicitly logo" 165 "(els)\n"); 166 mutex_lock(&lport->disc.disc_mutex); 167 lport->tt.rport_logoff(rdata); 168 mutex_unlock(&lport->disc.disc_mutex); 169 } 170 return; 171 } 172 } else { 173 /* 174 * Handle ELS timeout. 175 * tgt_lock is used to sync compl path and timeout 176 * path. If els compl path is processing this IO, we 177 * have nothing to do here, just release the timer hold 178 */ 179 BNX2FC_IO_DBG(io_req, "ELS timed out\n"); 180 if (test_and_set_bit(BNX2FC_FLAG_ELS_DONE, 181 &io_req->req_flags)) 182 goto done; 183 184 /* Indicate the cb_func that this ELS is timed out */ 185 set_bit(BNX2FC_FLAG_ELS_TIMEOUT, &io_req->req_flags); 186 187 if ((io_req->cb_func) && (io_req->cb_arg)) { 188 io_req->cb_func(io_req->cb_arg); 189 io_req->cb_arg = NULL; 190 } 191 } 192 break; 193 default: 194 printk(KERN_ERR PFX "cmd_timeout: invalid cmd_type %d\n", 195 cmd_type); 196 break; 197 } 198 199 done: 200 /* release the cmd that was held when timer was set */ 201 kref_put(&io_req->refcount, bnx2fc_cmd_release); 202 spin_unlock_bh(&tgt->tgt_lock); 203 } 204 205 static void bnx2fc_scsi_done(struct bnx2fc_cmd *io_req, int err_code) 206 { 207 /* Called with host lock held */ 208 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 209 210 /* 211 * active_cmd_queue may have other command types as well, 212 * and during flush operation, we want to error back only 213 * scsi commands. 214 */ 215 if (io_req->cmd_type != BNX2FC_SCSI_CMD) 216 return; 217 218 BNX2FC_IO_DBG(io_req, "scsi_done. err_code = 0x%x\n", err_code); 219 if (test_bit(BNX2FC_FLAG_CMD_LOST, &io_req->req_flags)) { 220 /* Do not call scsi done for this IO */ 221 return; 222 } 223 224 bnx2fc_unmap_sg_list(io_req); 225 io_req->sc_cmd = NULL; 226 if (!sc_cmd) { 227 printk(KERN_ERR PFX "scsi_done - sc_cmd NULL. " 228 "IO(0x%x) already cleaned up\n", 229 io_req->xid); 230 return; 231 } 232 sc_cmd->result = err_code << 16; 233 234 BNX2FC_IO_DBG(io_req, "sc=%p, result=0x%x, retries=%d, allowed=%d\n", 235 sc_cmd, host_byte(sc_cmd->result), sc_cmd->retries, 236 sc_cmd->allowed); 237 scsi_set_resid(sc_cmd, scsi_bufflen(sc_cmd)); 238 sc_cmd->SCp.ptr = NULL; 239 sc_cmd->scsi_done(sc_cmd); 240 } 241 242 struct bnx2fc_cmd_mgr *bnx2fc_cmd_mgr_alloc(struct bnx2fc_hba *hba, 243 u16 min_xid, u16 max_xid) 244 { 245 struct bnx2fc_cmd_mgr *cmgr; 246 struct io_bdt *bdt_info; 247 struct bnx2fc_cmd *io_req; 248 size_t len; 249 u32 mem_size; 250 u16 xid; 251 int i; 252 int num_ios, num_pri_ios; 253 size_t bd_tbl_sz; 254 int arr_sz = num_possible_cpus() + 1; 255 256 if (max_xid <= min_xid || max_xid == FC_XID_UNKNOWN) { 257 printk(KERN_ERR PFX "cmd_mgr_alloc: Invalid min_xid 0x%x \ 258 and max_xid 0x%x\n", min_xid, max_xid); 259 return NULL; 260 } 261 BNX2FC_MISC_DBG("min xid 0x%x, max xid 0x%x\n", min_xid, max_xid); 262 263 num_ios = max_xid - min_xid + 1; 264 len = (num_ios * (sizeof(struct bnx2fc_cmd *))); 265 len += sizeof(struct bnx2fc_cmd_mgr); 266 267 cmgr = kzalloc(len, GFP_KERNEL); 268 if (!cmgr) { 269 printk(KERN_ERR PFX "failed to alloc cmgr\n"); 270 return NULL; 271 } 272 273 cmgr->free_list = kzalloc(sizeof(*cmgr->free_list) * 274 arr_sz, GFP_KERNEL); 275 if (!cmgr->free_list) { 276 printk(KERN_ERR PFX "failed to alloc free_list\n"); 277 goto mem_err; 278 } 279 280 cmgr->free_list_lock = kzalloc(sizeof(*cmgr->free_list_lock) * 281 arr_sz, GFP_KERNEL); 282 if (!cmgr->free_list_lock) { 283 printk(KERN_ERR PFX "failed to alloc free_list_lock\n"); 284 goto mem_err; 285 } 286 287 cmgr->hba = hba; 288 cmgr->cmds = (struct bnx2fc_cmd **)(cmgr + 1); 289 290 for (i = 0; i < arr_sz; i++) { 291 INIT_LIST_HEAD(&cmgr->free_list[i]); 292 spin_lock_init(&cmgr->free_list_lock[i]); 293 } 294 295 /* 296 * Pre-allocated pool of bnx2fc_cmds. 297 * Last entry in the free list array is the free list 298 * of slow path requests. 299 */ 300 xid = BNX2FC_MIN_XID; 301 num_pri_ios = num_ios - BNX2FC_ELSTM_XIDS; 302 for (i = 0; i < num_ios; i++) { 303 io_req = kzalloc(sizeof(*io_req), GFP_KERNEL); 304 305 if (!io_req) { 306 printk(KERN_ERR PFX "failed to alloc io_req\n"); 307 goto mem_err; 308 } 309 310 INIT_LIST_HEAD(&io_req->link); 311 INIT_DELAYED_WORK(&io_req->timeout_work, bnx2fc_cmd_timeout); 312 313 io_req->xid = xid++; 314 if (i < num_pri_ios) 315 list_add_tail(&io_req->link, 316 &cmgr->free_list[io_req->xid % 317 num_possible_cpus()]); 318 else 319 list_add_tail(&io_req->link, 320 &cmgr->free_list[num_possible_cpus()]); 321 io_req++; 322 } 323 324 /* Allocate pool of io_bdts - one for each bnx2fc_cmd */ 325 mem_size = num_ios * sizeof(struct io_bdt *); 326 cmgr->io_bdt_pool = kmalloc(mem_size, GFP_KERNEL); 327 if (!cmgr->io_bdt_pool) { 328 printk(KERN_ERR PFX "failed to alloc io_bdt_pool\n"); 329 goto mem_err; 330 } 331 332 mem_size = sizeof(struct io_bdt); 333 for (i = 0; i < num_ios; i++) { 334 cmgr->io_bdt_pool[i] = kmalloc(mem_size, GFP_KERNEL); 335 if (!cmgr->io_bdt_pool[i]) { 336 printk(KERN_ERR PFX "failed to alloc " 337 "io_bdt_pool[%d]\n", i); 338 goto mem_err; 339 } 340 } 341 342 /* Allocate an map fcoe_bdt_ctx structures */ 343 bd_tbl_sz = BNX2FC_MAX_BDS_PER_CMD * sizeof(struct fcoe_bd_ctx); 344 for (i = 0; i < num_ios; i++) { 345 bdt_info = cmgr->io_bdt_pool[i]; 346 bdt_info->bd_tbl = dma_alloc_coherent(&hba->pcidev->dev, 347 bd_tbl_sz, 348 &bdt_info->bd_tbl_dma, 349 GFP_KERNEL); 350 if (!bdt_info->bd_tbl) { 351 printk(KERN_ERR PFX "failed to alloc " 352 "bdt_tbl[%d]\n", i); 353 goto mem_err; 354 } 355 } 356 357 return cmgr; 358 359 mem_err: 360 bnx2fc_cmd_mgr_free(cmgr); 361 return NULL; 362 } 363 364 void bnx2fc_cmd_mgr_free(struct bnx2fc_cmd_mgr *cmgr) 365 { 366 struct io_bdt *bdt_info; 367 struct bnx2fc_hba *hba = cmgr->hba; 368 size_t bd_tbl_sz; 369 u16 min_xid = BNX2FC_MIN_XID; 370 u16 max_xid = BNX2FC_MAX_XID; 371 int num_ios; 372 int i; 373 374 num_ios = max_xid - min_xid + 1; 375 376 /* Free fcoe_bdt_ctx structures */ 377 if (!cmgr->io_bdt_pool) 378 goto free_cmd_pool; 379 380 bd_tbl_sz = BNX2FC_MAX_BDS_PER_CMD * sizeof(struct fcoe_bd_ctx); 381 for (i = 0; i < num_ios; i++) { 382 bdt_info = cmgr->io_bdt_pool[i]; 383 if (bdt_info->bd_tbl) { 384 dma_free_coherent(&hba->pcidev->dev, bd_tbl_sz, 385 bdt_info->bd_tbl, 386 bdt_info->bd_tbl_dma); 387 bdt_info->bd_tbl = NULL; 388 } 389 } 390 391 /* Destroy io_bdt pool */ 392 for (i = 0; i < num_ios; i++) { 393 kfree(cmgr->io_bdt_pool[i]); 394 cmgr->io_bdt_pool[i] = NULL; 395 } 396 397 kfree(cmgr->io_bdt_pool); 398 cmgr->io_bdt_pool = NULL; 399 400 free_cmd_pool: 401 kfree(cmgr->free_list_lock); 402 403 /* Destroy cmd pool */ 404 if (!cmgr->free_list) 405 goto free_cmgr; 406 407 for (i = 0; i < num_possible_cpus() + 1; i++) { 408 struct list_head *list; 409 struct list_head *tmp; 410 411 list_for_each_safe(list, tmp, &cmgr->free_list[i]) { 412 struct bnx2fc_cmd *io_req = (struct bnx2fc_cmd *)list; 413 list_del(&io_req->link); 414 kfree(io_req); 415 } 416 } 417 kfree(cmgr->free_list); 418 free_cmgr: 419 /* Free command manager itself */ 420 kfree(cmgr); 421 } 422 423 struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type) 424 { 425 struct fcoe_port *port = tgt->port; 426 struct bnx2fc_interface *interface = port->priv; 427 struct bnx2fc_cmd_mgr *cmd_mgr = interface->hba->cmd_mgr; 428 struct bnx2fc_cmd *io_req; 429 struct list_head *listp; 430 struct io_bdt *bd_tbl; 431 int index = RESERVE_FREE_LIST_INDEX; 432 u32 free_sqes; 433 u32 max_sqes; 434 u16 xid; 435 436 max_sqes = tgt->max_sqes; 437 switch (type) { 438 case BNX2FC_TASK_MGMT_CMD: 439 max_sqes = BNX2FC_TM_MAX_SQES; 440 break; 441 case BNX2FC_ELS: 442 max_sqes = BNX2FC_ELS_MAX_SQES; 443 break; 444 default: 445 break; 446 } 447 448 /* 449 * NOTE: Free list insertions and deletions are protected with 450 * cmgr lock 451 */ 452 spin_lock_bh(&cmd_mgr->free_list_lock[index]); 453 free_sqes = atomic_read(&tgt->free_sqes); 454 if ((list_empty(&(cmd_mgr->free_list[index]))) || 455 (tgt->num_active_ios.counter >= max_sqes) || 456 (free_sqes + max_sqes <= BNX2FC_SQ_WQES_MAX)) { 457 BNX2FC_TGT_DBG(tgt, "No free els_tm cmds available " 458 "ios(%d):sqes(%d)\n", 459 tgt->num_active_ios.counter, tgt->max_sqes); 460 if (list_empty(&(cmd_mgr->free_list[index]))) 461 printk(KERN_ERR PFX "elstm_alloc: list_empty\n"); 462 spin_unlock_bh(&cmd_mgr->free_list_lock[index]); 463 return NULL; 464 } 465 466 listp = (struct list_head *) 467 cmd_mgr->free_list[index].next; 468 list_del_init(listp); 469 io_req = (struct bnx2fc_cmd *) listp; 470 xid = io_req->xid; 471 cmd_mgr->cmds[xid] = io_req; 472 atomic_inc(&tgt->num_active_ios); 473 atomic_dec(&tgt->free_sqes); 474 spin_unlock_bh(&cmd_mgr->free_list_lock[index]); 475 476 INIT_LIST_HEAD(&io_req->link); 477 478 io_req->port = port; 479 io_req->cmd_mgr = cmd_mgr; 480 io_req->req_flags = 0; 481 io_req->cmd_type = type; 482 483 /* Bind io_bdt for this io_req */ 484 /* Have a static link between io_req and io_bdt_pool */ 485 bd_tbl = io_req->bd_tbl = cmd_mgr->io_bdt_pool[xid]; 486 bd_tbl->io_req = io_req; 487 488 /* Hold the io_req against deletion */ 489 kref_init(&io_req->refcount); 490 return io_req; 491 } 492 493 struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt) 494 { 495 struct fcoe_port *port = tgt->port; 496 struct bnx2fc_interface *interface = port->priv; 497 struct bnx2fc_cmd_mgr *cmd_mgr = interface->hba->cmd_mgr; 498 struct bnx2fc_cmd *io_req; 499 struct list_head *listp; 500 struct io_bdt *bd_tbl; 501 u32 free_sqes; 502 u32 max_sqes; 503 u16 xid; 504 int index = get_cpu(); 505 506 max_sqes = BNX2FC_SCSI_MAX_SQES; 507 /* 508 * NOTE: Free list insertions and deletions are protected with 509 * cmgr lock 510 */ 511 spin_lock_bh(&cmd_mgr->free_list_lock[index]); 512 free_sqes = atomic_read(&tgt->free_sqes); 513 if ((list_empty(&cmd_mgr->free_list[index])) || 514 (tgt->num_active_ios.counter >= max_sqes) || 515 (free_sqes + max_sqes <= BNX2FC_SQ_WQES_MAX)) { 516 spin_unlock_bh(&cmd_mgr->free_list_lock[index]); 517 put_cpu(); 518 return NULL; 519 } 520 521 listp = (struct list_head *) 522 cmd_mgr->free_list[index].next; 523 list_del_init(listp); 524 io_req = (struct bnx2fc_cmd *) listp; 525 xid = io_req->xid; 526 cmd_mgr->cmds[xid] = io_req; 527 atomic_inc(&tgt->num_active_ios); 528 atomic_dec(&tgt->free_sqes); 529 spin_unlock_bh(&cmd_mgr->free_list_lock[index]); 530 put_cpu(); 531 532 INIT_LIST_HEAD(&io_req->link); 533 534 io_req->port = port; 535 io_req->cmd_mgr = cmd_mgr; 536 io_req->req_flags = 0; 537 538 /* Bind io_bdt for this io_req */ 539 /* Have a static link between io_req and io_bdt_pool */ 540 bd_tbl = io_req->bd_tbl = cmd_mgr->io_bdt_pool[xid]; 541 bd_tbl->io_req = io_req; 542 543 /* Hold the io_req against deletion */ 544 kref_init(&io_req->refcount); 545 return io_req; 546 } 547 548 void bnx2fc_cmd_release(struct kref *ref) 549 { 550 struct bnx2fc_cmd *io_req = container_of(ref, 551 struct bnx2fc_cmd, refcount); 552 struct bnx2fc_cmd_mgr *cmd_mgr = io_req->cmd_mgr; 553 int index; 554 555 if (io_req->cmd_type == BNX2FC_SCSI_CMD) 556 index = io_req->xid % num_possible_cpus(); 557 else 558 index = RESERVE_FREE_LIST_INDEX; 559 560 561 spin_lock_bh(&cmd_mgr->free_list_lock[index]); 562 if (io_req->cmd_type != BNX2FC_SCSI_CMD) 563 bnx2fc_free_mp_resc(io_req); 564 cmd_mgr->cmds[io_req->xid] = NULL; 565 /* Delete IO from retire queue */ 566 list_del_init(&io_req->link); 567 /* Add it to the free list */ 568 list_add(&io_req->link, 569 &cmd_mgr->free_list[index]); 570 atomic_dec(&io_req->tgt->num_active_ios); 571 spin_unlock_bh(&cmd_mgr->free_list_lock[index]); 572 573 } 574 575 static void bnx2fc_free_mp_resc(struct bnx2fc_cmd *io_req) 576 { 577 struct bnx2fc_mp_req *mp_req = &(io_req->mp_req); 578 struct bnx2fc_interface *interface = io_req->port->priv; 579 struct bnx2fc_hba *hba = interface->hba; 580 size_t sz = sizeof(struct fcoe_bd_ctx); 581 582 /* clear tm flags */ 583 mp_req->tm_flags = 0; 584 if (mp_req->mp_req_bd) { 585 dma_free_coherent(&hba->pcidev->dev, sz, 586 mp_req->mp_req_bd, 587 mp_req->mp_req_bd_dma); 588 mp_req->mp_req_bd = NULL; 589 } 590 if (mp_req->mp_resp_bd) { 591 dma_free_coherent(&hba->pcidev->dev, sz, 592 mp_req->mp_resp_bd, 593 mp_req->mp_resp_bd_dma); 594 mp_req->mp_resp_bd = NULL; 595 } 596 if (mp_req->req_buf) { 597 dma_free_coherent(&hba->pcidev->dev, PAGE_SIZE, 598 mp_req->req_buf, 599 mp_req->req_buf_dma); 600 mp_req->req_buf = NULL; 601 } 602 if (mp_req->resp_buf) { 603 dma_free_coherent(&hba->pcidev->dev, PAGE_SIZE, 604 mp_req->resp_buf, 605 mp_req->resp_buf_dma); 606 mp_req->resp_buf = NULL; 607 } 608 } 609 610 int bnx2fc_init_mp_req(struct bnx2fc_cmd *io_req) 611 { 612 struct bnx2fc_mp_req *mp_req; 613 struct fcoe_bd_ctx *mp_req_bd; 614 struct fcoe_bd_ctx *mp_resp_bd; 615 struct bnx2fc_interface *interface = io_req->port->priv; 616 struct bnx2fc_hba *hba = interface->hba; 617 dma_addr_t addr; 618 size_t sz; 619 620 mp_req = (struct bnx2fc_mp_req *)&(io_req->mp_req); 621 memset(mp_req, 0, sizeof(struct bnx2fc_mp_req)); 622 623 mp_req->req_len = sizeof(struct fcp_cmnd); 624 io_req->data_xfer_len = mp_req->req_len; 625 mp_req->req_buf = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE, 626 &mp_req->req_buf_dma, 627 GFP_ATOMIC); 628 if (!mp_req->req_buf) { 629 printk(KERN_ERR PFX "unable to alloc MP req buffer\n"); 630 bnx2fc_free_mp_resc(io_req); 631 return FAILED; 632 } 633 634 mp_req->resp_buf = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE, 635 &mp_req->resp_buf_dma, 636 GFP_ATOMIC); 637 if (!mp_req->resp_buf) { 638 printk(KERN_ERR PFX "unable to alloc TM resp buffer\n"); 639 bnx2fc_free_mp_resc(io_req); 640 return FAILED; 641 } 642 memset(mp_req->req_buf, 0, PAGE_SIZE); 643 memset(mp_req->resp_buf, 0, PAGE_SIZE); 644 645 /* Allocate and map mp_req_bd and mp_resp_bd */ 646 sz = sizeof(struct fcoe_bd_ctx); 647 mp_req->mp_req_bd = dma_alloc_coherent(&hba->pcidev->dev, sz, 648 &mp_req->mp_req_bd_dma, 649 GFP_ATOMIC); 650 if (!mp_req->mp_req_bd) { 651 printk(KERN_ERR PFX "unable to alloc MP req bd\n"); 652 bnx2fc_free_mp_resc(io_req); 653 return FAILED; 654 } 655 mp_req->mp_resp_bd = dma_alloc_coherent(&hba->pcidev->dev, sz, 656 &mp_req->mp_resp_bd_dma, 657 GFP_ATOMIC); 658 if (!mp_req->mp_req_bd) { 659 printk(KERN_ERR PFX "unable to alloc MP resp bd\n"); 660 bnx2fc_free_mp_resc(io_req); 661 return FAILED; 662 } 663 /* Fill bd table */ 664 addr = mp_req->req_buf_dma; 665 mp_req_bd = mp_req->mp_req_bd; 666 mp_req_bd->buf_addr_lo = (u32)addr & 0xffffffff; 667 mp_req_bd->buf_addr_hi = (u32)((u64)addr >> 32); 668 mp_req_bd->buf_len = PAGE_SIZE; 669 mp_req_bd->flags = 0; 670 671 /* 672 * MP buffer is either a task mgmt command or an ELS. 673 * So the assumption is that it consumes a single bd 674 * entry in the bd table 675 */ 676 mp_resp_bd = mp_req->mp_resp_bd; 677 addr = mp_req->resp_buf_dma; 678 mp_resp_bd->buf_addr_lo = (u32)addr & 0xffffffff; 679 mp_resp_bd->buf_addr_hi = (u32)((u64)addr >> 32); 680 mp_resp_bd->buf_len = PAGE_SIZE; 681 mp_resp_bd->flags = 0; 682 683 return SUCCESS; 684 } 685 686 static int bnx2fc_initiate_tmf(struct scsi_cmnd *sc_cmd, u8 tm_flags) 687 { 688 struct fc_lport *lport; 689 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device)); 690 struct fc_rport_libfc_priv *rp = rport->dd_data; 691 struct fcoe_port *port; 692 struct bnx2fc_interface *interface; 693 struct bnx2fc_rport *tgt; 694 struct bnx2fc_cmd *io_req; 695 struct bnx2fc_mp_req *tm_req; 696 struct fcoe_task_ctx_entry *task; 697 struct fcoe_task_ctx_entry *task_page; 698 struct Scsi_Host *host = sc_cmd->device->host; 699 struct fc_frame_header *fc_hdr; 700 struct fcp_cmnd *fcp_cmnd; 701 int task_idx, index; 702 int rc = SUCCESS; 703 u16 xid; 704 u32 sid, did; 705 unsigned long start = jiffies; 706 707 lport = shost_priv(host); 708 port = lport_priv(lport); 709 interface = port->priv; 710 711 if (rport == NULL) { 712 printk(KERN_ERR PFX "device_reset: rport is NULL\n"); 713 rc = FAILED; 714 goto tmf_err; 715 } 716 717 rc = fc_block_scsi_eh(sc_cmd); 718 if (rc) 719 return rc; 720 721 if (lport->state != LPORT_ST_READY || !(lport->link_up)) { 722 printk(KERN_ERR PFX "device_reset: link is not ready\n"); 723 rc = FAILED; 724 goto tmf_err; 725 } 726 /* rport and tgt are allocated together, so tgt should be non-NULL */ 727 tgt = (struct bnx2fc_rport *)&rp[1]; 728 729 if (!(test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags))) { 730 printk(KERN_ERR PFX "device_reset: tgt not offloaded\n"); 731 rc = FAILED; 732 goto tmf_err; 733 } 734 retry_tmf: 735 io_req = bnx2fc_elstm_alloc(tgt, BNX2FC_TASK_MGMT_CMD); 736 if (!io_req) { 737 if (time_after(jiffies, start + HZ)) { 738 printk(KERN_ERR PFX "tmf: Failed TMF"); 739 rc = FAILED; 740 goto tmf_err; 741 } 742 msleep(20); 743 goto retry_tmf; 744 } 745 /* Initialize rest of io_req fields */ 746 io_req->sc_cmd = sc_cmd; 747 io_req->port = port; 748 io_req->tgt = tgt; 749 750 tm_req = (struct bnx2fc_mp_req *)&(io_req->mp_req); 751 752 rc = bnx2fc_init_mp_req(io_req); 753 if (rc == FAILED) { 754 printk(KERN_ERR PFX "Task mgmt MP request init failed\n"); 755 spin_lock_bh(&tgt->tgt_lock); 756 kref_put(&io_req->refcount, bnx2fc_cmd_release); 757 spin_unlock_bh(&tgt->tgt_lock); 758 goto tmf_err; 759 } 760 761 /* Set TM flags */ 762 io_req->io_req_flags = 0; 763 tm_req->tm_flags = tm_flags; 764 765 /* Fill FCP_CMND */ 766 bnx2fc_build_fcp_cmnd(io_req, (struct fcp_cmnd *)tm_req->req_buf); 767 fcp_cmnd = (struct fcp_cmnd *)tm_req->req_buf; 768 memset(fcp_cmnd->fc_cdb, 0, sc_cmd->cmd_len); 769 fcp_cmnd->fc_dl = 0; 770 771 /* Fill FC header */ 772 fc_hdr = &(tm_req->req_fc_hdr); 773 sid = tgt->sid; 774 did = rport->port_id; 775 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_DD_UNSOL_CMD, did, sid, 776 FC_TYPE_FCP, FC_FC_FIRST_SEQ | FC_FC_END_SEQ | 777 FC_FC_SEQ_INIT, 0); 778 /* Obtain exchange id */ 779 xid = io_req->xid; 780 781 BNX2FC_TGT_DBG(tgt, "Initiate TMF - xid = 0x%x\n", xid); 782 task_idx = xid/BNX2FC_TASKS_PER_PAGE; 783 index = xid % BNX2FC_TASKS_PER_PAGE; 784 785 /* Initialize task context for this IO request */ 786 task_page = (struct fcoe_task_ctx_entry *) 787 interface->hba->task_ctx[task_idx]; 788 task = &(task_page[index]); 789 bnx2fc_init_mp_task(io_req, task); 790 791 sc_cmd->SCp.ptr = (char *)io_req; 792 793 /* Obtain free SQ entry */ 794 spin_lock_bh(&tgt->tgt_lock); 795 bnx2fc_add_2_sq(tgt, xid); 796 797 /* Enqueue the io_req to active_tm_queue */ 798 io_req->on_tmf_queue = 1; 799 list_add_tail(&io_req->link, &tgt->active_tm_queue); 800 801 init_completion(&io_req->tm_done); 802 io_req->wait_for_comp = 1; 803 804 /* Ring doorbell */ 805 bnx2fc_ring_doorbell(tgt); 806 spin_unlock_bh(&tgt->tgt_lock); 807 808 rc = wait_for_completion_timeout(&io_req->tm_done, 809 BNX2FC_TM_TIMEOUT * HZ); 810 spin_lock_bh(&tgt->tgt_lock); 811 812 io_req->wait_for_comp = 0; 813 if (!(test_bit(BNX2FC_FLAG_TM_COMPL, &io_req->req_flags))) 814 set_bit(BNX2FC_FLAG_TM_TIMEOUT, &io_req->req_flags); 815 816 spin_unlock_bh(&tgt->tgt_lock); 817 818 if (!rc) { 819 BNX2FC_TGT_DBG(tgt, "task mgmt command failed...\n"); 820 rc = FAILED; 821 } else { 822 BNX2FC_TGT_DBG(tgt, "task mgmt command success...\n"); 823 rc = SUCCESS; 824 } 825 tmf_err: 826 return rc; 827 } 828 829 int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req) 830 { 831 struct fc_lport *lport; 832 struct bnx2fc_rport *tgt = io_req->tgt; 833 struct fc_rport *rport = tgt->rport; 834 struct fc_rport_priv *rdata = tgt->rdata; 835 struct bnx2fc_interface *interface; 836 struct fcoe_port *port; 837 struct bnx2fc_cmd *abts_io_req; 838 struct fcoe_task_ctx_entry *task; 839 struct fcoe_task_ctx_entry *task_page; 840 struct fc_frame_header *fc_hdr; 841 struct bnx2fc_mp_req *abts_req; 842 int task_idx, index; 843 u32 sid, did; 844 u16 xid; 845 int rc = SUCCESS; 846 u32 r_a_tov = rdata->r_a_tov; 847 848 /* called with tgt_lock held */ 849 BNX2FC_IO_DBG(io_req, "Entered bnx2fc_initiate_abts\n"); 850 851 port = io_req->port; 852 interface = port->priv; 853 lport = port->lport; 854 855 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) { 856 printk(KERN_ERR PFX "initiate_abts: tgt not offloaded\n"); 857 rc = FAILED; 858 goto abts_err; 859 } 860 861 if (rport == NULL) { 862 printk(KERN_ERR PFX "initiate_abts: rport is NULL\n"); 863 rc = FAILED; 864 goto abts_err; 865 } 866 867 if (lport->state != LPORT_ST_READY || !(lport->link_up)) { 868 printk(KERN_ERR PFX "initiate_abts: link is not ready\n"); 869 rc = FAILED; 870 goto abts_err; 871 } 872 873 abts_io_req = bnx2fc_elstm_alloc(tgt, BNX2FC_ABTS); 874 if (!abts_io_req) { 875 printk(KERN_ERR PFX "abts: couldnt allocate cmd\n"); 876 rc = FAILED; 877 goto abts_err; 878 } 879 880 /* Initialize rest of io_req fields */ 881 abts_io_req->sc_cmd = NULL; 882 abts_io_req->port = port; 883 abts_io_req->tgt = tgt; 884 abts_io_req->data_xfer_len = 0; /* No data transfer for ABTS */ 885 886 abts_req = (struct bnx2fc_mp_req *)&(abts_io_req->mp_req); 887 memset(abts_req, 0, sizeof(struct bnx2fc_mp_req)); 888 889 /* Fill FC header */ 890 fc_hdr = &(abts_req->req_fc_hdr); 891 892 /* Obtain oxid and rxid for the original exchange to be aborted */ 893 fc_hdr->fh_ox_id = htons(io_req->xid); 894 fc_hdr->fh_rx_id = htons(io_req->task->rxwr_txrd.var_ctx.rx_id); 895 896 sid = tgt->sid; 897 did = rport->port_id; 898 899 __fc_fill_fc_hdr(fc_hdr, FC_RCTL_BA_ABTS, did, sid, 900 FC_TYPE_BLS, FC_FC_FIRST_SEQ | FC_FC_END_SEQ | 901 FC_FC_SEQ_INIT, 0); 902 903 xid = abts_io_req->xid; 904 BNX2FC_IO_DBG(abts_io_req, "ABTS io_req\n"); 905 task_idx = xid/BNX2FC_TASKS_PER_PAGE; 906 index = xid % BNX2FC_TASKS_PER_PAGE; 907 908 /* Initialize task context for this IO request */ 909 task_page = (struct fcoe_task_ctx_entry *) 910 interface->hba->task_ctx[task_idx]; 911 task = &(task_page[index]); 912 bnx2fc_init_mp_task(abts_io_req, task); 913 914 /* 915 * ABTS task is a temporary task that will be cleaned up 916 * irrespective of ABTS response. We need to start the timer 917 * for the original exchange, as the CQE is posted for the original 918 * IO request. 919 * 920 * Timer for ABTS is started only when it is originated by a 921 * TM request. For the ABTS issued as part of ULP timeout, 922 * scsi-ml maintains the timers. 923 */ 924 925 /* if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags))*/ 926 bnx2fc_cmd_timer_set(io_req, 2 * r_a_tov); 927 928 /* Obtain free SQ entry */ 929 bnx2fc_add_2_sq(tgt, xid); 930 931 /* Ring doorbell */ 932 bnx2fc_ring_doorbell(tgt); 933 934 abts_err: 935 return rc; 936 } 937 938 int bnx2fc_initiate_seq_cleanup(struct bnx2fc_cmd *orig_io_req, u32 offset, 939 enum fc_rctl r_ctl) 940 { 941 struct fc_lport *lport; 942 struct bnx2fc_rport *tgt = orig_io_req->tgt; 943 struct bnx2fc_interface *interface; 944 struct fcoe_port *port; 945 struct bnx2fc_cmd *seq_clnp_req; 946 struct fcoe_task_ctx_entry *task; 947 struct fcoe_task_ctx_entry *task_page; 948 struct bnx2fc_els_cb_arg *cb_arg = NULL; 949 int task_idx, index; 950 u16 xid; 951 int rc = 0; 952 953 BNX2FC_IO_DBG(orig_io_req, "bnx2fc_initiate_seq_cleanup xid = 0x%x\n", 954 orig_io_req->xid); 955 kref_get(&orig_io_req->refcount); 956 957 port = orig_io_req->port; 958 interface = port->priv; 959 lport = port->lport; 960 961 cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC); 962 if (!cb_arg) { 963 printk(KERN_ERR PFX "Unable to alloc cb_arg for seq clnup\n"); 964 rc = -ENOMEM; 965 goto cleanup_err; 966 } 967 968 seq_clnp_req = bnx2fc_elstm_alloc(tgt, BNX2FC_SEQ_CLEANUP); 969 if (!seq_clnp_req) { 970 printk(KERN_ERR PFX "cleanup: couldnt allocate cmd\n"); 971 rc = -ENOMEM; 972 kfree(cb_arg); 973 goto cleanup_err; 974 } 975 /* Initialize rest of io_req fields */ 976 seq_clnp_req->sc_cmd = NULL; 977 seq_clnp_req->port = port; 978 seq_clnp_req->tgt = tgt; 979 seq_clnp_req->data_xfer_len = 0; /* No data transfer for cleanup */ 980 981 xid = seq_clnp_req->xid; 982 983 task_idx = xid/BNX2FC_TASKS_PER_PAGE; 984 index = xid % BNX2FC_TASKS_PER_PAGE; 985 986 /* Initialize task context for this IO request */ 987 task_page = (struct fcoe_task_ctx_entry *) 988 interface->hba->task_ctx[task_idx]; 989 task = &(task_page[index]); 990 cb_arg->aborted_io_req = orig_io_req; 991 cb_arg->io_req = seq_clnp_req; 992 cb_arg->r_ctl = r_ctl; 993 cb_arg->offset = offset; 994 seq_clnp_req->cb_arg = cb_arg; 995 996 printk(KERN_ERR PFX "call init_seq_cleanup_task\n"); 997 bnx2fc_init_seq_cleanup_task(seq_clnp_req, task, orig_io_req, offset); 998 999 /* Obtain free SQ entry */ 1000 bnx2fc_add_2_sq(tgt, xid); 1001 1002 /* Ring doorbell */ 1003 bnx2fc_ring_doorbell(tgt); 1004 cleanup_err: 1005 return rc; 1006 } 1007 1008 int bnx2fc_initiate_cleanup(struct bnx2fc_cmd *io_req) 1009 { 1010 struct fc_lport *lport; 1011 struct bnx2fc_rport *tgt = io_req->tgt; 1012 struct bnx2fc_interface *interface; 1013 struct fcoe_port *port; 1014 struct bnx2fc_cmd *cleanup_io_req; 1015 struct fcoe_task_ctx_entry *task; 1016 struct fcoe_task_ctx_entry *task_page; 1017 int task_idx, index; 1018 u16 xid, orig_xid; 1019 int rc = 0; 1020 1021 /* ASSUMPTION: called with tgt_lock held */ 1022 BNX2FC_IO_DBG(io_req, "Entered bnx2fc_initiate_cleanup\n"); 1023 1024 port = io_req->port; 1025 interface = port->priv; 1026 lport = port->lport; 1027 1028 cleanup_io_req = bnx2fc_elstm_alloc(tgt, BNX2FC_CLEANUP); 1029 if (!cleanup_io_req) { 1030 printk(KERN_ERR PFX "cleanup: couldnt allocate cmd\n"); 1031 rc = -1; 1032 goto cleanup_err; 1033 } 1034 1035 /* Initialize rest of io_req fields */ 1036 cleanup_io_req->sc_cmd = NULL; 1037 cleanup_io_req->port = port; 1038 cleanup_io_req->tgt = tgt; 1039 cleanup_io_req->data_xfer_len = 0; /* No data transfer for cleanup */ 1040 1041 xid = cleanup_io_req->xid; 1042 1043 task_idx = xid/BNX2FC_TASKS_PER_PAGE; 1044 index = xid % BNX2FC_TASKS_PER_PAGE; 1045 1046 /* Initialize task context for this IO request */ 1047 task_page = (struct fcoe_task_ctx_entry *) 1048 interface->hba->task_ctx[task_idx]; 1049 task = &(task_page[index]); 1050 orig_xid = io_req->xid; 1051 1052 BNX2FC_IO_DBG(io_req, "CLEANUP io_req xid = 0x%x\n", xid); 1053 1054 bnx2fc_init_cleanup_task(cleanup_io_req, task, orig_xid); 1055 1056 /* Obtain free SQ entry */ 1057 bnx2fc_add_2_sq(tgt, xid); 1058 1059 /* Ring doorbell */ 1060 bnx2fc_ring_doorbell(tgt); 1061 1062 cleanup_err: 1063 return rc; 1064 } 1065 1066 /** 1067 * bnx2fc_eh_target_reset: Reset a target 1068 * 1069 * @sc_cmd: SCSI command 1070 * 1071 * Set from SCSI host template to send task mgmt command to the target 1072 * and wait for the response 1073 */ 1074 int bnx2fc_eh_target_reset(struct scsi_cmnd *sc_cmd) 1075 { 1076 return bnx2fc_initiate_tmf(sc_cmd, FCP_TMF_TGT_RESET); 1077 } 1078 1079 /** 1080 * bnx2fc_eh_device_reset - Reset a single LUN 1081 * 1082 * @sc_cmd: SCSI command 1083 * 1084 * Set from SCSI host template to send task mgmt command to the target 1085 * and wait for the response 1086 */ 1087 int bnx2fc_eh_device_reset(struct scsi_cmnd *sc_cmd) 1088 { 1089 return bnx2fc_initiate_tmf(sc_cmd, FCP_TMF_LUN_RESET); 1090 } 1091 1092 /** 1093 * bnx2fc_eh_abort - eh_abort_handler api to abort an outstanding 1094 * SCSI command 1095 * 1096 * @sc_cmd: SCSI_ML command pointer 1097 * 1098 * SCSI abort request handler 1099 */ 1100 int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd) 1101 { 1102 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device)); 1103 struct fc_rport_libfc_priv *rp = rport->dd_data; 1104 struct bnx2fc_cmd *io_req; 1105 struct fc_lport *lport; 1106 struct bnx2fc_rport *tgt; 1107 int rc = FAILED; 1108 1109 1110 rc = fc_block_scsi_eh(sc_cmd); 1111 if (rc) 1112 return rc; 1113 1114 lport = shost_priv(sc_cmd->device->host); 1115 if ((lport->state != LPORT_ST_READY) || !(lport->link_up)) { 1116 printk(KERN_ERR PFX "eh_abort: link not ready\n"); 1117 return rc; 1118 } 1119 1120 tgt = (struct bnx2fc_rport *)&rp[1]; 1121 1122 BNX2FC_TGT_DBG(tgt, "Entered bnx2fc_eh_abort\n"); 1123 1124 spin_lock_bh(&tgt->tgt_lock); 1125 io_req = (struct bnx2fc_cmd *)sc_cmd->SCp.ptr; 1126 if (!io_req) { 1127 /* Command might have just completed */ 1128 printk(KERN_ERR PFX "eh_abort: io_req is NULL\n"); 1129 spin_unlock_bh(&tgt->tgt_lock); 1130 return SUCCESS; 1131 } 1132 BNX2FC_IO_DBG(io_req, "eh_abort - refcnt = %d\n", 1133 io_req->refcount.refcount.counter); 1134 1135 /* Hold IO request across abort processing */ 1136 kref_get(&io_req->refcount); 1137 1138 BUG_ON(tgt != io_req->tgt); 1139 1140 /* Remove the io_req from the active_q. */ 1141 /* 1142 * Task Mgmt functions (LUN RESET & TGT RESET) will not 1143 * issue an ABTS on this particular IO req, as the 1144 * io_req is no longer in the active_q. 1145 */ 1146 if (tgt->flush_in_prog) { 1147 printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) " 1148 "flush in progress\n", io_req->xid); 1149 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1150 spin_unlock_bh(&tgt->tgt_lock); 1151 return SUCCESS; 1152 } 1153 1154 if (io_req->on_active_queue == 0) { 1155 printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) " 1156 "not on active_q\n", io_req->xid); 1157 /* 1158 * This condition can happen only due to the FW bug, 1159 * where we do not receive cleanup response from 1160 * the FW. Handle this case gracefully by erroring 1161 * back the IO request to SCSI-ml 1162 */ 1163 bnx2fc_scsi_done(io_req, DID_ABORT); 1164 1165 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1166 spin_unlock_bh(&tgt->tgt_lock); 1167 return SUCCESS; 1168 } 1169 1170 /* 1171 * Only eh_abort processing will remove the IO from 1172 * active_cmd_q before processing the request. this is 1173 * done to avoid race conditions between IOs aborted 1174 * as part of task management completion and eh_abort 1175 * processing 1176 */ 1177 list_del_init(&io_req->link); 1178 io_req->on_active_queue = 0; 1179 /* Move IO req to retire queue */ 1180 list_add_tail(&io_req->link, &tgt->io_retire_queue); 1181 1182 init_completion(&io_req->tm_done); 1183 io_req->wait_for_comp = 1; 1184 1185 if (!test_and_set_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags)) { 1186 /* Cancel the current timer running on this io_req */ 1187 if (cancel_delayed_work(&io_req->timeout_work)) 1188 kref_put(&io_req->refcount, 1189 bnx2fc_cmd_release); /* drop timer hold */ 1190 set_bit(BNX2FC_FLAG_EH_ABORT, &io_req->req_flags); 1191 rc = bnx2fc_initiate_abts(io_req); 1192 } else { 1193 printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) " 1194 "already in abts processing\n", io_req->xid); 1195 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1196 spin_unlock_bh(&tgt->tgt_lock); 1197 return SUCCESS; 1198 } 1199 if (rc == FAILED) { 1200 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1201 spin_unlock_bh(&tgt->tgt_lock); 1202 return rc; 1203 } 1204 spin_unlock_bh(&tgt->tgt_lock); 1205 1206 wait_for_completion(&io_req->tm_done); 1207 1208 spin_lock_bh(&tgt->tgt_lock); 1209 io_req->wait_for_comp = 0; 1210 if (!(test_and_set_bit(BNX2FC_FLAG_ABTS_DONE, 1211 &io_req->req_flags))) { 1212 /* Let the scsi-ml try to recover this command */ 1213 printk(KERN_ERR PFX "abort failed, xid = 0x%x\n", 1214 io_req->xid); 1215 rc = FAILED; 1216 } else { 1217 /* 1218 * We come here even when there was a race condition 1219 * between timeout and abts completion, and abts 1220 * completion happens just in time. 1221 */ 1222 BNX2FC_IO_DBG(io_req, "abort succeeded\n"); 1223 rc = SUCCESS; 1224 bnx2fc_scsi_done(io_req, DID_ABORT); 1225 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1226 } 1227 1228 /* release the reference taken in eh_abort */ 1229 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1230 spin_unlock_bh(&tgt->tgt_lock); 1231 return rc; 1232 } 1233 1234 void bnx2fc_process_seq_cleanup_compl(struct bnx2fc_cmd *seq_clnp_req, 1235 struct fcoe_task_ctx_entry *task, 1236 u8 rx_state) 1237 { 1238 struct bnx2fc_els_cb_arg *cb_arg = seq_clnp_req->cb_arg; 1239 struct bnx2fc_cmd *orig_io_req = cb_arg->aborted_io_req; 1240 u32 offset = cb_arg->offset; 1241 enum fc_rctl r_ctl = cb_arg->r_ctl; 1242 int rc = 0; 1243 struct bnx2fc_rport *tgt = orig_io_req->tgt; 1244 1245 BNX2FC_IO_DBG(orig_io_req, "Entered process_cleanup_compl xid = 0x%x" 1246 "cmd_type = %d\n", 1247 seq_clnp_req->xid, seq_clnp_req->cmd_type); 1248 1249 if (rx_state == FCOE_TASK_RX_STATE_IGNORED_SEQUENCE_CLEANUP) { 1250 printk(KERN_ERR PFX "seq cleanup ignored - xid = 0x%x\n", 1251 seq_clnp_req->xid); 1252 goto free_cb_arg; 1253 } 1254 kref_get(&orig_io_req->refcount); 1255 1256 spin_unlock_bh(&tgt->tgt_lock); 1257 rc = bnx2fc_send_srr(orig_io_req, offset, r_ctl); 1258 spin_lock_bh(&tgt->tgt_lock); 1259 1260 if (rc) 1261 printk(KERN_ERR PFX "clnup_compl: Unable to send SRR" 1262 " IO will abort\n"); 1263 seq_clnp_req->cb_arg = NULL; 1264 kref_put(&orig_io_req->refcount, bnx2fc_cmd_release); 1265 free_cb_arg: 1266 kfree(cb_arg); 1267 return; 1268 } 1269 1270 void bnx2fc_process_cleanup_compl(struct bnx2fc_cmd *io_req, 1271 struct fcoe_task_ctx_entry *task, 1272 u8 num_rq) 1273 { 1274 BNX2FC_IO_DBG(io_req, "Entered process_cleanup_compl " 1275 "refcnt = %d, cmd_type = %d\n", 1276 io_req->refcount.refcount.counter, io_req->cmd_type); 1277 bnx2fc_scsi_done(io_req, DID_ERROR); 1278 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1279 } 1280 1281 void bnx2fc_process_abts_compl(struct bnx2fc_cmd *io_req, 1282 struct fcoe_task_ctx_entry *task, 1283 u8 num_rq) 1284 { 1285 u32 r_ctl; 1286 u32 r_a_tov = FC_DEF_R_A_TOV; 1287 u8 issue_rrq = 0; 1288 struct bnx2fc_rport *tgt = io_req->tgt; 1289 1290 BNX2FC_IO_DBG(io_req, "Entered process_abts_compl xid = 0x%x" 1291 "refcnt = %d, cmd_type = %d\n", 1292 io_req->xid, 1293 io_req->refcount.refcount.counter, io_req->cmd_type); 1294 1295 if (test_and_set_bit(BNX2FC_FLAG_ABTS_DONE, 1296 &io_req->req_flags)) { 1297 BNX2FC_IO_DBG(io_req, "Timer context finished processing" 1298 " this io\n"); 1299 return; 1300 } 1301 1302 /* Do not issue RRQ as this IO is already cleanedup */ 1303 if (test_and_set_bit(BNX2FC_FLAG_IO_CLEANUP, 1304 &io_req->req_flags)) 1305 goto io_compl; 1306 1307 /* 1308 * For ABTS issued due to SCSI eh_abort_handler, timeout 1309 * values are maintained by scsi-ml itself. Cancel timeout 1310 * in case ABTS issued as part of task management function 1311 * or due to FW error. 1312 */ 1313 if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags)) 1314 if (cancel_delayed_work(&io_req->timeout_work)) 1315 kref_put(&io_req->refcount, 1316 bnx2fc_cmd_release); /* drop timer hold */ 1317 1318 r_ctl = (u8)task->rxwr_only.union_ctx.comp_info.abts_rsp.r_ctl; 1319 1320 switch (r_ctl) { 1321 case FC_RCTL_BA_ACC: 1322 /* 1323 * Dont release this cmd yet. It will be relesed 1324 * after we get RRQ response 1325 */ 1326 BNX2FC_IO_DBG(io_req, "ABTS response - ACC Send RRQ\n"); 1327 issue_rrq = 1; 1328 break; 1329 1330 case FC_RCTL_BA_RJT: 1331 BNX2FC_IO_DBG(io_req, "ABTS response - RJT\n"); 1332 break; 1333 default: 1334 printk(KERN_ERR PFX "Unknown ABTS response\n"); 1335 break; 1336 } 1337 1338 if (issue_rrq) { 1339 BNX2FC_IO_DBG(io_req, "Issue RRQ after R_A_TOV\n"); 1340 set_bit(BNX2FC_FLAG_ISSUE_RRQ, &io_req->req_flags); 1341 } 1342 set_bit(BNX2FC_FLAG_RETIRE_OXID, &io_req->req_flags); 1343 bnx2fc_cmd_timer_set(io_req, r_a_tov); 1344 1345 io_compl: 1346 if (io_req->wait_for_comp) { 1347 if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT, 1348 &io_req->req_flags)) 1349 complete(&io_req->tm_done); 1350 } else { 1351 /* 1352 * We end up here when ABTS is issued as 1353 * in asynchronous context, i.e., as part 1354 * of task management completion, or 1355 * when FW error is received or when the 1356 * ABTS is issued when the IO is timed 1357 * out. 1358 */ 1359 1360 if (io_req->on_active_queue) { 1361 list_del_init(&io_req->link); 1362 io_req->on_active_queue = 0; 1363 /* Move IO req to retire queue */ 1364 list_add_tail(&io_req->link, &tgt->io_retire_queue); 1365 } 1366 bnx2fc_scsi_done(io_req, DID_ERROR); 1367 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1368 } 1369 } 1370 1371 static void bnx2fc_lun_reset_cmpl(struct bnx2fc_cmd *io_req) 1372 { 1373 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 1374 struct bnx2fc_rport *tgt = io_req->tgt; 1375 struct list_head *list; 1376 struct list_head *tmp; 1377 struct bnx2fc_cmd *cmd; 1378 int tm_lun = sc_cmd->device->lun; 1379 int rc = 0; 1380 int lun; 1381 1382 /* called with tgt_lock held */ 1383 BNX2FC_IO_DBG(io_req, "Entered bnx2fc_lun_reset_cmpl\n"); 1384 /* 1385 * Walk thru the active_ios queue and ABORT the IO 1386 * that matches with the LUN that was reset 1387 */ 1388 list_for_each_safe(list, tmp, &tgt->active_cmd_queue) { 1389 BNX2FC_TGT_DBG(tgt, "LUN RST cmpl: scan for pending IOs\n"); 1390 cmd = (struct bnx2fc_cmd *)list; 1391 lun = cmd->sc_cmd->device->lun; 1392 if (lun == tm_lun) { 1393 /* Initiate ABTS on this cmd */ 1394 if (!test_and_set_bit(BNX2FC_FLAG_ISSUE_ABTS, 1395 &cmd->req_flags)) { 1396 /* cancel the IO timeout */ 1397 if (cancel_delayed_work(&io_req->timeout_work)) 1398 kref_put(&io_req->refcount, 1399 bnx2fc_cmd_release); 1400 /* timer hold */ 1401 rc = bnx2fc_initiate_abts(cmd); 1402 /* abts shouldn't fail in this context */ 1403 WARN_ON(rc != SUCCESS); 1404 } else 1405 printk(KERN_ERR PFX "lun_rst: abts already in" 1406 " progress for this IO 0x%x\n", 1407 cmd->xid); 1408 } 1409 } 1410 } 1411 1412 static void bnx2fc_tgt_reset_cmpl(struct bnx2fc_cmd *io_req) 1413 { 1414 struct bnx2fc_rport *tgt = io_req->tgt; 1415 struct list_head *list; 1416 struct list_head *tmp; 1417 struct bnx2fc_cmd *cmd; 1418 int rc = 0; 1419 1420 /* called with tgt_lock held */ 1421 BNX2FC_IO_DBG(io_req, "Entered bnx2fc_tgt_reset_cmpl\n"); 1422 /* 1423 * Walk thru the active_ios queue and ABORT the IO 1424 * that matches with the LUN that was reset 1425 */ 1426 list_for_each_safe(list, tmp, &tgt->active_cmd_queue) { 1427 BNX2FC_TGT_DBG(tgt, "TGT RST cmpl: scan for pending IOs\n"); 1428 cmd = (struct bnx2fc_cmd *)list; 1429 /* Initiate ABTS */ 1430 if (!test_and_set_bit(BNX2FC_FLAG_ISSUE_ABTS, 1431 &cmd->req_flags)) { 1432 /* cancel the IO timeout */ 1433 if (cancel_delayed_work(&io_req->timeout_work)) 1434 kref_put(&io_req->refcount, 1435 bnx2fc_cmd_release); /* timer hold */ 1436 rc = bnx2fc_initiate_abts(cmd); 1437 /* abts shouldn't fail in this context */ 1438 WARN_ON(rc != SUCCESS); 1439 1440 } else 1441 printk(KERN_ERR PFX "tgt_rst: abts already in progress" 1442 " for this IO 0x%x\n", cmd->xid); 1443 } 1444 } 1445 1446 void bnx2fc_process_tm_compl(struct bnx2fc_cmd *io_req, 1447 struct fcoe_task_ctx_entry *task, u8 num_rq) 1448 { 1449 struct bnx2fc_mp_req *tm_req; 1450 struct fc_frame_header *fc_hdr; 1451 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 1452 u64 *hdr; 1453 u64 *temp_hdr; 1454 void *rsp_buf; 1455 1456 /* Called with tgt_lock held */ 1457 BNX2FC_IO_DBG(io_req, "Entered process_tm_compl\n"); 1458 1459 if (!(test_bit(BNX2FC_FLAG_TM_TIMEOUT, &io_req->req_flags))) 1460 set_bit(BNX2FC_FLAG_TM_COMPL, &io_req->req_flags); 1461 else { 1462 /* TM has already timed out and we got 1463 * delayed completion. Ignore completion 1464 * processing. 1465 */ 1466 return; 1467 } 1468 1469 tm_req = &(io_req->mp_req); 1470 fc_hdr = &(tm_req->resp_fc_hdr); 1471 hdr = (u64 *)fc_hdr; 1472 temp_hdr = (u64 *) 1473 &task->rxwr_only.union_ctx.comp_info.mp_rsp.fc_hdr; 1474 hdr[0] = cpu_to_be64(temp_hdr[0]); 1475 hdr[1] = cpu_to_be64(temp_hdr[1]); 1476 hdr[2] = cpu_to_be64(temp_hdr[2]); 1477 1478 tm_req->resp_len = 1479 task->rxwr_only.union_ctx.comp_info.mp_rsp.mp_payload_len; 1480 1481 rsp_buf = tm_req->resp_buf; 1482 1483 if (fc_hdr->fh_r_ctl == FC_RCTL_DD_CMD_STATUS) { 1484 bnx2fc_parse_fcp_rsp(io_req, 1485 (struct fcoe_fcp_rsp_payload *) 1486 rsp_buf, num_rq); 1487 if (io_req->fcp_rsp_code == 0) { 1488 /* TM successful */ 1489 if (tm_req->tm_flags & FCP_TMF_LUN_RESET) 1490 bnx2fc_lun_reset_cmpl(io_req); 1491 else if (tm_req->tm_flags & FCP_TMF_TGT_RESET) 1492 bnx2fc_tgt_reset_cmpl(io_req); 1493 } 1494 } else { 1495 printk(KERN_ERR PFX "tmf's fc_hdr r_ctl = 0x%x\n", 1496 fc_hdr->fh_r_ctl); 1497 } 1498 if (!sc_cmd->SCp.ptr) { 1499 printk(KERN_ERR PFX "tm_compl: SCp.ptr is NULL\n"); 1500 return; 1501 } 1502 switch (io_req->fcp_status) { 1503 case FC_GOOD: 1504 if (io_req->cdb_status == 0) { 1505 /* Good IO completion */ 1506 sc_cmd->result = DID_OK << 16; 1507 } else { 1508 /* Transport status is good, SCSI status not good */ 1509 sc_cmd->result = (DID_OK << 16) | io_req->cdb_status; 1510 } 1511 if (io_req->fcp_resid) 1512 scsi_set_resid(sc_cmd, io_req->fcp_resid); 1513 break; 1514 1515 default: 1516 BNX2FC_IO_DBG(io_req, "process_tm_compl: fcp_status = %d\n", 1517 io_req->fcp_status); 1518 break; 1519 } 1520 1521 sc_cmd = io_req->sc_cmd; 1522 io_req->sc_cmd = NULL; 1523 1524 /* check if the io_req exists in tgt's tmf_q */ 1525 if (io_req->on_tmf_queue) { 1526 1527 list_del_init(&io_req->link); 1528 io_req->on_tmf_queue = 0; 1529 } else { 1530 1531 printk(KERN_ERR PFX "Command not on active_cmd_queue!\n"); 1532 return; 1533 } 1534 1535 sc_cmd->SCp.ptr = NULL; 1536 sc_cmd->scsi_done(sc_cmd); 1537 1538 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1539 if (io_req->wait_for_comp) { 1540 BNX2FC_IO_DBG(io_req, "tm_compl - wake up the waiter\n"); 1541 complete(&io_req->tm_done); 1542 } 1543 } 1544 1545 static int bnx2fc_split_bd(struct bnx2fc_cmd *io_req, u64 addr, int sg_len, 1546 int bd_index) 1547 { 1548 struct fcoe_bd_ctx *bd = io_req->bd_tbl->bd_tbl; 1549 int frag_size, sg_frags; 1550 1551 sg_frags = 0; 1552 while (sg_len) { 1553 if (sg_len >= BNX2FC_BD_SPLIT_SZ) 1554 frag_size = BNX2FC_BD_SPLIT_SZ; 1555 else 1556 frag_size = sg_len; 1557 bd[bd_index + sg_frags].buf_addr_lo = addr & 0xffffffff; 1558 bd[bd_index + sg_frags].buf_addr_hi = addr >> 32; 1559 bd[bd_index + sg_frags].buf_len = (u16)frag_size; 1560 bd[bd_index + sg_frags].flags = 0; 1561 1562 addr += (u64) frag_size; 1563 sg_frags++; 1564 sg_len -= frag_size; 1565 } 1566 return sg_frags; 1567 1568 } 1569 1570 static int bnx2fc_map_sg(struct bnx2fc_cmd *io_req) 1571 { 1572 struct scsi_cmnd *sc = io_req->sc_cmd; 1573 struct fcoe_bd_ctx *bd = io_req->bd_tbl->bd_tbl; 1574 struct scatterlist *sg; 1575 int byte_count = 0; 1576 int sg_count = 0; 1577 int bd_count = 0; 1578 int sg_frags; 1579 unsigned int sg_len; 1580 u64 addr; 1581 int i; 1582 1583 sg_count = scsi_dma_map(sc); 1584 scsi_for_each_sg(sc, sg, sg_count, i) { 1585 sg_len = sg_dma_len(sg); 1586 addr = sg_dma_address(sg); 1587 if (sg_len > BNX2FC_MAX_BD_LEN) { 1588 sg_frags = bnx2fc_split_bd(io_req, addr, sg_len, 1589 bd_count); 1590 } else { 1591 1592 sg_frags = 1; 1593 bd[bd_count].buf_addr_lo = addr & 0xffffffff; 1594 bd[bd_count].buf_addr_hi = addr >> 32; 1595 bd[bd_count].buf_len = (u16)sg_len; 1596 bd[bd_count].flags = 0; 1597 } 1598 bd_count += sg_frags; 1599 byte_count += sg_len; 1600 } 1601 if (byte_count != scsi_bufflen(sc)) 1602 printk(KERN_ERR PFX "byte_count = %d != scsi_bufflen = %d, " 1603 "task_id = 0x%x\n", byte_count, scsi_bufflen(sc), 1604 io_req->xid); 1605 return bd_count; 1606 } 1607 1608 static void bnx2fc_build_bd_list_from_sg(struct bnx2fc_cmd *io_req) 1609 { 1610 struct scsi_cmnd *sc = io_req->sc_cmd; 1611 struct fcoe_bd_ctx *bd = io_req->bd_tbl->bd_tbl; 1612 int bd_count; 1613 1614 if (scsi_sg_count(sc)) 1615 bd_count = bnx2fc_map_sg(io_req); 1616 else { 1617 bd_count = 0; 1618 bd[0].buf_addr_lo = bd[0].buf_addr_hi = 0; 1619 bd[0].buf_len = bd[0].flags = 0; 1620 } 1621 io_req->bd_tbl->bd_valid = bd_count; 1622 } 1623 1624 static void bnx2fc_unmap_sg_list(struct bnx2fc_cmd *io_req) 1625 { 1626 struct scsi_cmnd *sc = io_req->sc_cmd; 1627 1628 if (io_req->bd_tbl->bd_valid && sc) { 1629 scsi_dma_unmap(sc); 1630 io_req->bd_tbl->bd_valid = 0; 1631 } 1632 } 1633 1634 void bnx2fc_build_fcp_cmnd(struct bnx2fc_cmd *io_req, 1635 struct fcp_cmnd *fcp_cmnd) 1636 { 1637 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 1638 char tag[2]; 1639 1640 memset(fcp_cmnd, 0, sizeof(struct fcp_cmnd)); 1641 1642 int_to_scsilun(sc_cmd->device->lun, 1643 (struct scsi_lun *) fcp_cmnd->fc_lun); 1644 1645 1646 fcp_cmnd->fc_dl = htonl(io_req->data_xfer_len); 1647 memcpy(fcp_cmnd->fc_cdb, sc_cmd->cmnd, sc_cmd->cmd_len); 1648 1649 fcp_cmnd->fc_cmdref = 0; 1650 fcp_cmnd->fc_pri_ta = 0; 1651 fcp_cmnd->fc_tm_flags = io_req->mp_req.tm_flags; 1652 fcp_cmnd->fc_flags = io_req->io_req_flags; 1653 1654 if (scsi_populate_tag_msg(sc_cmd, tag)) { 1655 switch (tag[0]) { 1656 case HEAD_OF_QUEUE_TAG: 1657 fcp_cmnd->fc_pri_ta = FCP_PTA_HEADQ; 1658 break; 1659 case ORDERED_QUEUE_TAG: 1660 fcp_cmnd->fc_pri_ta = FCP_PTA_ORDERED; 1661 break; 1662 default: 1663 fcp_cmnd->fc_pri_ta = FCP_PTA_SIMPLE; 1664 break; 1665 } 1666 } else { 1667 fcp_cmnd->fc_pri_ta = 0; 1668 } 1669 } 1670 1671 static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req, 1672 struct fcoe_fcp_rsp_payload *fcp_rsp, 1673 u8 num_rq) 1674 { 1675 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 1676 struct bnx2fc_rport *tgt = io_req->tgt; 1677 u8 rsp_flags = fcp_rsp->fcp_flags.flags; 1678 u32 rq_buff_len = 0; 1679 int i; 1680 unsigned char *rq_data; 1681 unsigned char *dummy; 1682 int fcp_sns_len = 0; 1683 int fcp_rsp_len = 0; 1684 1685 io_req->fcp_status = FC_GOOD; 1686 io_req->fcp_resid = fcp_rsp->fcp_resid; 1687 1688 io_req->scsi_comp_flags = rsp_flags; 1689 CMD_SCSI_STATUS(sc_cmd) = io_req->cdb_status = 1690 fcp_rsp->scsi_status_code; 1691 1692 /* Fetch fcp_rsp_info and fcp_sns_info if available */ 1693 if (num_rq) { 1694 1695 /* 1696 * We do not anticipate num_rq >1, as the linux defined 1697 * SCSI_SENSE_BUFFERSIZE is 96 bytes + 8 bytes of FCP_RSP_INFO 1698 * 256 bytes of single rq buffer is good enough to hold this. 1699 */ 1700 1701 if (rsp_flags & 1702 FCOE_FCP_RSP_FLAGS_FCP_RSP_LEN_VALID) { 1703 fcp_rsp_len = rq_buff_len 1704 = fcp_rsp->fcp_rsp_len; 1705 } 1706 1707 if (rsp_flags & 1708 FCOE_FCP_RSP_FLAGS_FCP_SNS_LEN_VALID) { 1709 fcp_sns_len = fcp_rsp->fcp_sns_len; 1710 rq_buff_len += fcp_rsp->fcp_sns_len; 1711 } 1712 1713 io_req->fcp_rsp_len = fcp_rsp_len; 1714 io_req->fcp_sns_len = fcp_sns_len; 1715 1716 if (rq_buff_len > num_rq * BNX2FC_RQ_BUF_SZ) { 1717 /* Invalid sense sense length. */ 1718 printk(KERN_ERR PFX "invalid sns length %d\n", 1719 rq_buff_len); 1720 /* reset rq_buff_len */ 1721 rq_buff_len = num_rq * BNX2FC_RQ_BUF_SZ; 1722 } 1723 1724 rq_data = bnx2fc_get_next_rqe(tgt, 1); 1725 1726 if (num_rq > 1) { 1727 /* We do not need extra sense data */ 1728 for (i = 1; i < num_rq; i++) 1729 dummy = bnx2fc_get_next_rqe(tgt, 1); 1730 } 1731 1732 /* fetch fcp_rsp_code */ 1733 if ((fcp_rsp_len == 4) || (fcp_rsp_len == 8)) { 1734 /* Only for task management function */ 1735 io_req->fcp_rsp_code = rq_data[3]; 1736 printk(KERN_ERR PFX "fcp_rsp_code = %d\n", 1737 io_req->fcp_rsp_code); 1738 } 1739 1740 /* fetch sense data */ 1741 rq_data += fcp_rsp_len; 1742 1743 if (fcp_sns_len > SCSI_SENSE_BUFFERSIZE) { 1744 printk(KERN_ERR PFX "Truncating sense buffer\n"); 1745 fcp_sns_len = SCSI_SENSE_BUFFERSIZE; 1746 } 1747 1748 memset(sc_cmd->sense_buffer, 0, sizeof(sc_cmd->sense_buffer)); 1749 if (fcp_sns_len) 1750 memcpy(sc_cmd->sense_buffer, rq_data, fcp_sns_len); 1751 1752 /* return RQ entries */ 1753 for (i = 0; i < num_rq; i++) 1754 bnx2fc_return_rqe(tgt, 1); 1755 } 1756 } 1757 1758 /** 1759 * bnx2fc_queuecommand - Queuecommand function of the scsi template 1760 * 1761 * @host: The Scsi_Host the command was issued to 1762 * @sc_cmd: struct scsi_cmnd to be executed 1763 * 1764 * This is the IO strategy routine, called by SCSI-ML 1765 **/ 1766 int bnx2fc_queuecommand(struct Scsi_Host *host, 1767 struct scsi_cmnd *sc_cmd) 1768 { 1769 struct fc_lport *lport = shost_priv(host); 1770 struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device)); 1771 struct fc_rport_libfc_priv *rp = rport->dd_data; 1772 struct bnx2fc_rport *tgt; 1773 struct bnx2fc_cmd *io_req; 1774 int rc = 0; 1775 int rval; 1776 1777 rval = fc_remote_port_chkready(rport); 1778 if (rval) { 1779 sc_cmd->result = rval; 1780 sc_cmd->scsi_done(sc_cmd); 1781 return 0; 1782 } 1783 1784 if ((lport->state != LPORT_ST_READY) || !(lport->link_up)) { 1785 rc = SCSI_MLQUEUE_HOST_BUSY; 1786 goto exit_qcmd; 1787 } 1788 1789 /* rport and tgt are allocated together, so tgt should be non-NULL */ 1790 tgt = (struct bnx2fc_rport *)&rp[1]; 1791 1792 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) { 1793 if (test_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags)) { 1794 sc_cmd->result = DID_NO_CONNECT << 16; 1795 sc_cmd->scsi_done(sc_cmd); 1796 return 0; 1797 1798 } 1799 /* 1800 * Session is not offloaded yet. Let SCSI-ml retry 1801 * the command. 1802 */ 1803 rc = SCSI_MLQUEUE_TARGET_BUSY; 1804 goto exit_qcmd; 1805 } 1806 1807 io_req = bnx2fc_cmd_alloc(tgt); 1808 if (!io_req) { 1809 rc = SCSI_MLQUEUE_HOST_BUSY; 1810 goto exit_qcmd; 1811 } 1812 io_req->sc_cmd = sc_cmd; 1813 1814 if (bnx2fc_post_io_req(tgt, io_req)) { 1815 printk(KERN_ERR PFX "Unable to post io_req\n"); 1816 rc = SCSI_MLQUEUE_HOST_BUSY; 1817 goto exit_qcmd; 1818 } 1819 exit_qcmd: 1820 return rc; 1821 } 1822 1823 void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req, 1824 struct fcoe_task_ctx_entry *task, 1825 u8 num_rq) 1826 { 1827 struct fcoe_fcp_rsp_payload *fcp_rsp; 1828 struct bnx2fc_rport *tgt = io_req->tgt; 1829 struct scsi_cmnd *sc_cmd; 1830 struct Scsi_Host *host; 1831 1832 1833 /* scsi_cmd_cmpl is called with tgt lock held */ 1834 1835 if (test_and_set_bit(BNX2FC_FLAG_IO_COMPL, &io_req->req_flags)) { 1836 /* we will not receive ABTS response for this IO */ 1837 BNX2FC_IO_DBG(io_req, "Timer context finished processing " 1838 "this scsi cmd\n"); 1839 } 1840 1841 /* Cancel the timeout_work, as we received IO completion */ 1842 if (cancel_delayed_work(&io_req->timeout_work)) 1843 kref_put(&io_req->refcount, 1844 bnx2fc_cmd_release); /* drop timer hold */ 1845 1846 sc_cmd = io_req->sc_cmd; 1847 if (sc_cmd == NULL) { 1848 printk(KERN_ERR PFX "scsi_cmd_compl - sc_cmd is NULL\n"); 1849 return; 1850 } 1851 1852 /* Fetch fcp_rsp from task context and perform cmd completion */ 1853 fcp_rsp = (struct fcoe_fcp_rsp_payload *) 1854 &(task->rxwr_only.union_ctx.comp_info.fcp_rsp.payload); 1855 1856 /* parse fcp_rsp and obtain sense data from RQ if available */ 1857 bnx2fc_parse_fcp_rsp(io_req, fcp_rsp, num_rq); 1858 1859 host = sc_cmd->device->host; 1860 if (!sc_cmd->SCp.ptr) { 1861 printk(KERN_ERR PFX "SCp.ptr is NULL\n"); 1862 return; 1863 } 1864 1865 if (io_req->on_active_queue) { 1866 list_del_init(&io_req->link); 1867 io_req->on_active_queue = 0; 1868 /* Move IO req to retire queue */ 1869 list_add_tail(&io_req->link, &tgt->io_retire_queue); 1870 } else { 1871 /* This should not happen, but could have been pulled 1872 * by bnx2fc_flush_active_ios(), or during a race 1873 * between command abort and (late) completion. 1874 */ 1875 BNX2FC_IO_DBG(io_req, "xid not on active_cmd_queue\n"); 1876 if (io_req->wait_for_comp) 1877 if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT, 1878 &io_req->req_flags)) 1879 complete(&io_req->tm_done); 1880 } 1881 1882 bnx2fc_unmap_sg_list(io_req); 1883 io_req->sc_cmd = NULL; 1884 1885 switch (io_req->fcp_status) { 1886 case FC_GOOD: 1887 if (io_req->cdb_status == 0) { 1888 /* Good IO completion */ 1889 sc_cmd->result = DID_OK << 16; 1890 } else { 1891 /* Transport status is good, SCSI status not good */ 1892 BNX2FC_IO_DBG(io_req, "scsi_cmpl: cdb_status = %d" 1893 " fcp_resid = 0x%x\n", 1894 io_req->cdb_status, io_req->fcp_resid); 1895 sc_cmd->result = (DID_OK << 16) | io_req->cdb_status; 1896 } 1897 if (io_req->fcp_resid) 1898 scsi_set_resid(sc_cmd, io_req->fcp_resid); 1899 break; 1900 default: 1901 printk(KERN_ERR PFX "scsi_cmd_compl: fcp_status = %d\n", 1902 io_req->fcp_status); 1903 break; 1904 } 1905 sc_cmd->SCp.ptr = NULL; 1906 sc_cmd->scsi_done(sc_cmd); 1907 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1908 } 1909 1910 int bnx2fc_post_io_req(struct bnx2fc_rport *tgt, 1911 struct bnx2fc_cmd *io_req) 1912 { 1913 struct fcoe_task_ctx_entry *task; 1914 struct fcoe_task_ctx_entry *task_page; 1915 struct scsi_cmnd *sc_cmd = io_req->sc_cmd; 1916 struct fcoe_port *port = tgt->port; 1917 struct bnx2fc_interface *interface = port->priv; 1918 struct bnx2fc_hba *hba = interface->hba; 1919 struct fc_lport *lport = port->lport; 1920 struct fcoe_dev_stats *stats; 1921 int task_idx, index; 1922 u16 xid; 1923 1924 /* Initialize rest of io_req fields */ 1925 io_req->cmd_type = BNX2FC_SCSI_CMD; 1926 io_req->port = port; 1927 io_req->tgt = tgt; 1928 io_req->data_xfer_len = scsi_bufflen(sc_cmd); 1929 sc_cmd->SCp.ptr = (char *)io_req; 1930 1931 stats = per_cpu_ptr(lport->dev_stats, get_cpu()); 1932 if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) { 1933 io_req->io_req_flags = BNX2FC_READ; 1934 stats->InputRequests++; 1935 stats->InputBytes += io_req->data_xfer_len; 1936 } else if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) { 1937 io_req->io_req_flags = BNX2FC_WRITE; 1938 stats->OutputRequests++; 1939 stats->OutputBytes += io_req->data_xfer_len; 1940 } else { 1941 io_req->io_req_flags = 0; 1942 stats->ControlRequests++; 1943 } 1944 put_cpu(); 1945 1946 xid = io_req->xid; 1947 1948 /* Build buffer descriptor list for firmware from sg list */ 1949 bnx2fc_build_bd_list_from_sg(io_req); 1950 1951 task_idx = xid / BNX2FC_TASKS_PER_PAGE; 1952 index = xid % BNX2FC_TASKS_PER_PAGE; 1953 1954 /* Initialize task context for this IO request */ 1955 task_page = (struct fcoe_task_ctx_entry *) hba->task_ctx[task_idx]; 1956 task = &(task_page[index]); 1957 bnx2fc_init_task(io_req, task); 1958 1959 spin_lock_bh(&tgt->tgt_lock); 1960 1961 if (tgt->flush_in_prog) { 1962 printk(KERN_ERR PFX "Flush in progress..Host Busy\n"); 1963 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1964 spin_unlock_bh(&tgt->tgt_lock); 1965 return -EAGAIN; 1966 } 1967 1968 if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) { 1969 printk(KERN_ERR PFX "Session not ready...post_io\n"); 1970 kref_put(&io_req->refcount, bnx2fc_cmd_release); 1971 spin_unlock_bh(&tgt->tgt_lock); 1972 return -EAGAIN; 1973 } 1974 1975 /* Time IO req */ 1976 if (tgt->io_timeout) 1977 bnx2fc_cmd_timer_set(io_req, BNX2FC_IO_TIMEOUT); 1978 /* Obtain free SQ entry */ 1979 bnx2fc_add_2_sq(tgt, xid); 1980 1981 /* Enqueue the io_req to active_cmd_queue */ 1982 1983 io_req->on_active_queue = 1; 1984 /* move io_req from pending_queue to active_queue */ 1985 list_add_tail(&io_req->link, &tgt->active_cmd_queue); 1986 1987 /* Ring doorbell */ 1988 bnx2fc_ring_doorbell(tgt); 1989 spin_unlock_bh(&tgt->tgt_lock); 1990 return 0; 1991 } 1992