1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 4 * Copyright (c) 2014- QLogic Corporation. 5 * All rights reserved 6 * www.qlogic.com 7 * 8 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. 9 */ 10 11/* 12 * bfad_im.c Linux driver IM module. 13 */ 14 15#include <linux/export.h> 16 17#include "bfad_drv.h" 18#include "bfad_im.h" 19#include "bfa_fcs.h" 20 21BFA_TRC_FILE(LDRV, IM); 22 23DEFINE_IDR(bfad_im_port_index); 24struct scsi_transport_template *bfad_im_scsi_transport_template; 25struct scsi_transport_template *bfad_im_scsi_vport_transport_template; 26static void bfad_im_itnim_work_handler(struct work_struct *work); 27static int bfad_im_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmnd); 28static int bfad_im_slave_alloc(struct scsi_device *sdev); 29static void bfad_im_fc_rport_add(struct bfad_im_port_s *im_port, 30 struct bfad_itnim_s *itnim); 31 32void 33bfa_cb_ioim_done(void *drv, struct bfad_ioim_s *dio, 34 enum bfi_ioim_status io_status, u8 scsi_status, 35 int sns_len, u8 *sns_info, s32 residue) 36{ 37 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio; 38 struct bfad_s *bfad = drv; 39 struct bfad_itnim_data_s *itnim_data; 40 struct bfad_itnim_s *itnim; 41 u8 host_status = DID_OK; 42 43 switch (io_status) { 44 case BFI_IOIM_STS_OK: 45 bfa_trc(bfad, scsi_status); 46 scsi_set_resid(cmnd, 0); 47 48 if (sns_len > 0) { 49 bfa_trc(bfad, sns_len); 50 if (sns_len > SCSI_SENSE_BUFFERSIZE) 51 sns_len = SCSI_SENSE_BUFFERSIZE; 52 memcpy(cmnd->sense_buffer, sns_info, sns_len); 53 } 54 55 if (residue > 0) { 56 bfa_trc(bfad, residue); 57 scsi_set_resid(cmnd, residue); 58 if (!sns_len && (scsi_status == SAM_STAT_GOOD) && 59 (scsi_bufflen(cmnd) - residue) < 60 cmnd->underflow) { 61 bfa_trc(bfad, 0); 62 host_status = DID_ERROR; 63 } 64 } 65 cmnd->result = host_status << 16 | scsi_status; 66 67 break; 68 69 case BFI_IOIM_STS_TIMEDOUT: 70 cmnd->result = DID_TIME_OUT << 16; 71 break; 72 case BFI_IOIM_STS_PATHTOV: 73 cmnd->result = DID_TRANSPORT_DISRUPTED << 16; 74 break; 75 default: 76 cmnd->result = DID_ERROR << 16; 77 } 78 79 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */ 80 if (cmnd->device->host != NULL) 81 scsi_dma_unmap(cmnd); 82 83 cmnd->host_scribble = NULL; 84 bfa_trc(bfad, cmnd->result); 85 86 itnim_data = cmnd->device->hostdata; 87 if (itnim_data) { 88 itnim = itnim_data->itnim; 89 if (!cmnd->result && itnim && 90 (bfa_lun_queue_depth > cmnd->device->queue_depth)) { 91 /* Queue depth adjustment for good status completion */ 92 bfad_ramp_up_qdepth(itnim, cmnd->device); 93 } else if (cmnd->result == SAM_STAT_TASK_SET_FULL && itnim) { 94 /* qfull handling */ 95 bfad_handle_qfull(itnim, cmnd->device); 96 } 97 } 98 99 cmnd->scsi_done(cmnd); 100} 101 102void 103bfa_cb_ioim_good_comp(void *drv, struct bfad_ioim_s *dio) 104{ 105 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio; 106 struct bfad_itnim_data_s *itnim_data; 107 struct bfad_itnim_s *itnim; 108 109 cmnd->result = DID_OK << 16 | SCSI_STATUS_GOOD; 110 111 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */ 112 if (cmnd->device->host != NULL) 113 scsi_dma_unmap(cmnd); 114 115 cmnd->host_scribble = NULL; 116 117 /* Queue depth adjustment */ 118 if (bfa_lun_queue_depth > cmnd->device->queue_depth) { 119 itnim_data = cmnd->device->hostdata; 120 if (itnim_data) { 121 itnim = itnim_data->itnim; 122 if (itnim) 123 bfad_ramp_up_qdepth(itnim, cmnd->device); 124 } 125 } 126 127 cmnd->scsi_done(cmnd); 128} 129 130void 131bfa_cb_ioim_abort(void *drv, struct bfad_ioim_s *dio) 132{ 133 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio; 134 struct bfad_s *bfad = drv; 135 136 cmnd->result = DID_ERROR << 16; 137 138 /* Unmap DMA, if host is NULL, it means a scsi passthru cmd */ 139 if (cmnd->device->host != NULL) 140 scsi_dma_unmap(cmnd); 141 142 bfa_trc(bfad, cmnd->result); 143 cmnd->host_scribble = NULL; 144} 145 146void 147bfa_cb_tskim_done(void *bfad, struct bfad_tskim_s *dtsk, 148 enum bfi_tskim_status tsk_status) 149{ 150 struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dtsk; 151 wait_queue_head_t *wq; 152 153 cmnd->SCp.Status |= tsk_status << 1; 154 set_bit(IO_DONE_BIT, (unsigned long *)&cmnd->SCp.Status); 155 wq = (wait_queue_head_t *) cmnd->SCp.ptr; 156 cmnd->SCp.ptr = NULL; 157 158 if (wq) 159 wake_up(wq); 160} 161 162/* 163 * Scsi_Host_template SCSI host template 164 */ 165/* 166 * Scsi_Host template entry, returns BFAD PCI info. 167 */ 168static const char * 169bfad_im_info(struct Scsi_Host *shost) 170{ 171 static char bfa_buf[256]; 172 struct bfad_im_port_s *im_port = 173 (struct bfad_im_port_s *) shost->hostdata[0]; 174 struct bfad_s *bfad = im_port->bfad; 175 176 memset(bfa_buf, 0, sizeof(bfa_buf)); 177 snprintf(bfa_buf, sizeof(bfa_buf), 178 "QLogic BR-series FC/FCOE Adapter, hwpath: %s driver: %s", 179 bfad->pci_name, BFAD_DRIVER_VERSION); 180 181 return bfa_buf; 182} 183 184/* 185 * Scsi_Host template entry, aborts the specified SCSI command. 186 * 187 * Returns: SUCCESS or FAILED. 188 */ 189static int 190bfad_im_abort_handler(struct scsi_cmnd *cmnd) 191{ 192 struct Scsi_Host *shost = cmnd->device->host; 193 struct bfad_im_port_s *im_port = 194 (struct bfad_im_port_s *) shost->hostdata[0]; 195 struct bfad_s *bfad = im_port->bfad; 196 struct bfa_ioim_s *hal_io; 197 unsigned long flags; 198 u32 timeout; 199 int rc = FAILED; 200 201 spin_lock_irqsave(&bfad->bfad_lock, flags); 202 hal_io = (struct bfa_ioim_s *) cmnd->host_scribble; 203 if (!hal_io) { 204 /* IO has been completed, return success */ 205 rc = SUCCESS; 206 goto out; 207 } 208 if (hal_io->dio != (struct bfad_ioim_s *) cmnd) { 209 rc = FAILED; 210 goto out; 211 } 212 213 bfa_trc(bfad, hal_io->iotag); 214 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 215 "scsi%d: abort cmnd %p iotag %x\n", 216 im_port->shost->host_no, cmnd, hal_io->iotag); 217 (void) bfa_ioim_abort(hal_io); 218 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 219 220 /* Need to wait until the command get aborted */ 221 timeout = 10; 222 while ((struct bfa_ioim_s *) cmnd->host_scribble == hal_io) { 223 set_current_state(TASK_UNINTERRUPTIBLE); 224 schedule_timeout(timeout); 225 if (timeout < 4 * HZ) 226 timeout *= 2; 227 } 228 229 cmnd->scsi_done(cmnd); 230 bfa_trc(bfad, hal_io->iotag); 231 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 232 "scsi%d: complete abort 0x%p iotag 0x%x\n", 233 im_port->shost->host_no, cmnd, hal_io->iotag); 234 return SUCCESS; 235out: 236 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 237 return rc; 238} 239 240static bfa_status_t 241bfad_im_target_reset_send(struct bfad_s *bfad, struct scsi_cmnd *cmnd, 242 struct bfad_itnim_s *itnim) 243{ 244 struct bfa_tskim_s *tskim; 245 struct bfa_itnim_s *bfa_itnim; 246 bfa_status_t rc = BFA_STATUS_OK; 247 struct scsi_lun scsilun; 248 249 tskim = bfa_tskim_alloc(&bfad->bfa, (struct bfad_tskim_s *) cmnd); 250 if (!tskim) { 251 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 252 "target reset, fail to allocate tskim\n"); 253 rc = BFA_STATUS_FAILED; 254 goto out; 255 } 256 257 /* 258 * Set host_scribble to NULL to avoid aborting a task command if 259 * happens. 260 */ 261 cmnd->host_scribble = NULL; 262 cmnd->SCp.Status = 0; 263 bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim); 264 /* 265 * bfa_itnim can be NULL if the port gets disconnected and the bfa 266 * and fcs layers have cleaned up their nexus with the targets and 267 * the same has not been cleaned up by the shim 268 */ 269 if (bfa_itnim == NULL) { 270 bfa_tskim_free(tskim); 271 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 272 "target reset, bfa_itnim is NULL\n"); 273 rc = BFA_STATUS_FAILED; 274 goto out; 275 } 276 277 memset(&scsilun, 0, sizeof(scsilun)); 278 bfa_tskim_start(tskim, bfa_itnim, scsilun, 279 FCP_TM_TARGET_RESET, BFAD_TARGET_RESET_TMO); 280out: 281 return rc; 282} 283 284/* 285 * Scsi_Host template entry, resets a LUN and abort its all commands. 286 * 287 * Returns: SUCCESS or FAILED. 288 * 289 */ 290static int 291bfad_im_reset_lun_handler(struct scsi_cmnd *cmnd) 292{ 293 struct Scsi_Host *shost = cmnd->device->host; 294 struct bfad_im_port_s *im_port = 295 (struct bfad_im_port_s *) shost->hostdata[0]; 296 struct bfad_itnim_data_s *itnim_data = cmnd->device->hostdata; 297 struct bfad_s *bfad = im_port->bfad; 298 struct bfa_tskim_s *tskim; 299 struct bfad_itnim_s *itnim; 300 struct bfa_itnim_s *bfa_itnim; 301 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 302 int rc = SUCCESS; 303 unsigned long flags; 304 enum bfi_tskim_status task_status; 305 struct scsi_lun scsilun; 306 307 spin_lock_irqsave(&bfad->bfad_lock, flags); 308 itnim = itnim_data->itnim; 309 if (!itnim) { 310 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 311 rc = FAILED; 312 goto out; 313 } 314 315 tskim = bfa_tskim_alloc(&bfad->bfa, (struct bfad_tskim_s *) cmnd); 316 if (!tskim) { 317 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 318 "LUN reset, fail to allocate tskim"); 319 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 320 rc = FAILED; 321 goto out; 322 } 323 324 /* 325 * Set host_scribble to NULL to avoid aborting a task command 326 * if happens. 327 */ 328 cmnd->host_scribble = NULL; 329 cmnd->SCp.ptr = (char *)&wq; 330 cmnd->SCp.Status = 0; 331 bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim->fcs_itnim); 332 /* 333 * bfa_itnim can be NULL if the port gets disconnected and the bfa 334 * and fcs layers have cleaned up their nexus with the targets and 335 * the same has not been cleaned up by the shim 336 */ 337 if (bfa_itnim == NULL) { 338 bfa_tskim_free(tskim); 339 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 340 "lun reset, bfa_itnim is NULL\n"); 341 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 342 rc = FAILED; 343 goto out; 344 } 345 int_to_scsilun(cmnd->device->lun, &scsilun); 346 bfa_tskim_start(tskim, bfa_itnim, scsilun, 347 FCP_TM_LUN_RESET, BFAD_LUN_RESET_TMO); 348 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 349 350 wait_event(wq, test_bit(IO_DONE_BIT, 351 (unsigned long *)&cmnd->SCp.Status)); 352 353 task_status = cmnd->SCp.Status >> 1; 354 if (task_status != BFI_TSKIM_STS_OK) { 355 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 356 "LUN reset failure, status: %d\n", task_status); 357 rc = FAILED; 358 } 359 360out: 361 return rc; 362} 363 364/* 365 * Scsi_Host template entry, resets the target and abort all commands. 366 */ 367static int 368bfad_im_reset_target_handler(struct scsi_cmnd *cmnd) 369{ 370 struct Scsi_Host *shost = cmnd->device->host; 371 struct scsi_target *starget = scsi_target(cmnd->device); 372 struct bfad_im_port_s *im_port = 373 (struct bfad_im_port_s *) shost->hostdata[0]; 374 struct bfad_s *bfad = im_port->bfad; 375 struct bfad_itnim_s *itnim; 376 unsigned long flags; 377 u32 rc, rtn = FAILED; 378 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); 379 enum bfi_tskim_status task_status; 380 381 spin_lock_irqsave(&bfad->bfad_lock, flags); 382 itnim = bfad_get_itnim(im_port, starget->id); 383 if (itnim) { 384 cmnd->SCp.ptr = (char *)&wq; 385 rc = bfad_im_target_reset_send(bfad, cmnd, itnim); 386 if (rc == BFA_STATUS_OK) { 387 /* wait target reset to complete */ 388 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 389 wait_event(wq, test_bit(IO_DONE_BIT, 390 (unsigned long *)&cmnd->SCp.Status)); 391 spin_lock_irqsave(&bfad->bfad_lock, flags); 392 393 task_status = cmnd->SCp.Status >> 1; 394 if (task_status != BFI_TSKIM_STS_OK) 395 BFA_LOG(KERN_ERR, bfad, bfa_log_level, 396 "target reset failure," 397 " status: %d\n", task_status); 398 else 399 rtn = SUCCESS; 400 } 401 } 402 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 403 404 return rtn; 405} 406 407/* 408 * Scsi_Host template entry slave_destroy. 409 */ 410static void 411bfad_im_slave_destroy(struct scsi_device *sdev) 412{ 413 sdev->hostdata = NULL; 414 return; 415} 416 417/* 418 * BFA FCS itnim callbacks 419 */ 420 421/* 422 * BFA FCS itnim alloc callback, after successful PRLI 423 * Context: Interrupt 424 */ 425int 426bfa_fcb_itnim_alloc(struct bfad_s *bfad, struct bfa_fcs_itnim_s **itnim, 427 struct bfad_itnim_s **itnim_drv) 428{ 429 *itnim_drv = kzalloc(sizeof(struct bfad_itnim_s), GFP_ATOMIC); 430 if (*itnim_drv == NULL) 431 return -ENOMEM; 432 433 (*itnim_drv)->im = bfad->im; 434 *itnim = &(*itnim_drv)->fcs_itnim; 435 (*itnim_drv)->state = ITNIM_STATE_NONE; 436 437 /* 438 * Initiaze the itnim_work 439 */ 440 INIT_WORK(&(*itnim_drv)->itnim_work, bfad_im_itnim_work_handler); 441 bfad->bfad_flags |= BFAD_RPORT_ONLINE; 442 return 0; 443} 444 445/* 446 * BFA FCS itnim free callback. 447 * Context: Interrupt. bfad_lock is held 448 */ 449void 450bfa_fcb_itnim_free(struct bfad_s *bfad, struct bfad_itnim_s *itnim_drv) 451{ 452 struct bfad_port_s *port; 453 wwn_t wwpn; 454 u32 fcid; 455 char wwpn_str[32], fcid_str[16]; 456 struct bfad_im_s *im = itnim_drv->im; 457 458 /* online to free state transtion should not happen */ 459 WARN_ON(itnim_drv->state == ITNIM_STATE_ONLINE); 460 461 itnim_drv->queue_work = 1; 462 /* offline request is not yet done, use the same request to free */ 463 if (itnim_drv->state == ITNIM_STATE_OFFLINE_PENDING) 464 itnim_drv->queue_work = 0; 465 466 itnim_drv->state = ITNIM_STATE_FREE; 467 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim); 468 itnim_drv->im_port = port->im_port; 469 wwpn = bfa_fcs_itnim_get_pwwn(&itnim_drv->fcs_itnim); 470 fcid = bfa_fcs_itnim_get_fcid(&itnim_drv->fcs_itnim); 471 wwn2str(wwpn_str, wwpn); 472 fcid2str(fcid_str, fcid); 473 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 474 "ITNIM FREE scsi%d: FCID: %s WWPN: %s\n", 475 port->im_port->shost->host_no, 476 fcid_str, wwpn_str); 477 478 /* ITNIM processing */ 479 if (itnim_drv->queue_work) 480 queue_work(im->drv_workq, &itnim_drv->itnim_work); 481} 482 483/* 484 * BFA FCS itnim online callback. 485 * Context: Interrupt. bfad_lock is held 486 */ 487void 488bfa_fcb_itnim_online(struct bfad_itnim_s *itnim_drv) 489{ 490 struct bfad_port_s *port; 491 struct bfad_im_s *im = itnim_drv->im; 492 493 itnim_drv->bfa_itnim = bfa_fcs_itnim_get_halitn(&itnim_drv->fcs_itnim); 494 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim); 495 itnim_drv->state = ITNIM_STATE_ONLINE; 496 itnim_drv->queue_work = 1; 497 itnim_drv->im_port = port->im_port; 498 499 /* ITNIM processing */ 500 if (itnim_drv->queue_work) 501 queue_work(im->drv_workq, &itnim_drv->itnim_work); 502} 503 504/* 505 * BFA FCS itnim offline callback. 506 * Context: Interrupt. bfad_lock is held 507 */ 508void 509bfa_fcb_itnim_offline(struct bfad_itnim_s *itnim_drv) 510{ 511 struct bfad_port_s *port; 512 struct bfad_s *bfad; 513 struct bfad_im_s *im = itnim_drv->im; 514 515 port = bfa_fcs_itnim_get_drvport(&itnim_drv->fcs_itnim); 516 bfad = port->bfad; 517 if ((bfad->pport.flags & BFAD_PORT_DELETE) || 518 (port->flags & BFAD_PORT_DELETE)) { 519 itnim_drv->state = ITNIM_STATE_OFFLINE; 520 return; 521 } 522 itnim_drv->im_port = port->im_port; 523 itnim_drv->state = ITNIM_STATE_OFFLINE_PENDING; 524 itnim_drv->queue_work = 1; 525 526 /* ITNIM processing */ 527 if (itnim_drv->queue_work) 528 queue_work(im->drv_workq, &itnim_drv->itnim_work); 529} 530 531/* 532 * Allocate a Scsi_Host for a port. 533 */ 534int 535bfad_im_scsi_host_alloc(struct bfad_s *bfad, struct bfad_im_port_s *im_port, 536 struct device *dev) 537{ 538 struct bfad_im_port_pointer *im_portp; 539 int error; 540 541 mutex_lock(&bfad_mutex); 542 error = idr_alloc(&bfad_im_port_index, im_port, 0, 0, GFP_KERNEL); 543 if (error < 0) { 544 mutex_unlock(&bfad_mutex); 545 printk(KERN_WARNING "idr_alloc failure\n"); 546 goto out; 547 } 548 im_port->idr_id = error; 549 mutex_unlock(&bfad_mutex); 550 551 im_port->shost = bfad_scsi_host_alloc(im_port, bfad); 552 if (!im_port->shost) { 553 error = 1; 554 goto out_free_idr; 555 } 556 557 im_portp = shost_priv(im_port->shost); 558 im_portp->p = im_port; 559 im_port->shost->unique_id = im_port->idr_id; 560 im_port->shost->this_id = -1; 561 im_port->shost->max_id = MAX_FCP_TARGET; 562 im_port->shost->max_lun = MAX_FCP_LUN; 563 im_port->shost->max_cmd_len = 16; 564 im_port->shost->can_queue = bfad->cfg_data.ioc_queue_depth; 565 if (im_port->port->pvb_type == BFAD_PORT_PHYS_BASE) 566 im_port->shost->transportt = bfad_im_scsi_transport_template; 567 else 568 im_port->shost->transportt = 569 bfad_im_scsi_vport_transport_template; 570 571 error = scsi_add_host_with_dma(im_port->shost, dev, &bfad->pcidev->dev); 572 if (error) { 573 printk(KERN_WARNING "scsi_add_host failure %d\n", error); 574 goto out_fc_rel; 575 } 576 577 return 0; 578 579out_fc_rel: 580 scsi_host_put(im_port->shost); 581 im_port->shost = NULL; 582out_free_idr: 583 mutex_lock(&bfad_mutex); 584 idr_remove(&bfad_im_port_index, im_port->idr_id); 585 mutex_unlock(&bfad_mutex); 586out: 587 return error; 588} 589 590void 591bfad_im_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port) 592{ 593 bfa_trc(bfad, bfad->inst_no); 594 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "Free scsi%d\n", 595 im_port->shost->host_no); 596 597 fc_remove_host(im_port->shost); 598 599 scsi_remove_host(im_port->shost); 600 scsi_host_put(im_port->shost); 601 602 mutex_lock(&bfad_mutex); 603 idr_remove(&bfad_im_port_index, im_port->idr_id); 604 mutex_unlock(&bfad_mutex); 605} 606 607static void 608bfad_im_port_delete_handler(struct work_struct *work) 609{ 610 struct bfad_im_port_s *im_port = 611 container_of(work, struct bfad_im_port_s, port_delete_work); 612 613 if (im_port->port->pvb_type != BFAD_PORT_PHYS_BASE) { 614 im_port->flags |= BFAD_PORT_DELETE; 615 fc_vport_terminate(im_port->fc_vport); 616 } 617} 618 619bfa_status_t 620bfad_im_port_new(struct bfad_s *bfad, struct bfad_port_s *port) 621{ 622 int rc = BFA_STATUS_OK; 623 struct bfad_im_port_s *im_port; 624 625 im_port = kzalloc(sizeof(struct bfad_im_port_s), GFP_ATOMIC); 626 if (im_port == NULL) { 627 rc = BFA_STATUS_ENOMEM; 628 goto ext; 629 } 630 port->im_port = im_port; 631 im_port->port = port; 632 im_port->bfad = bfad; 633 634 INIT_WORK(&im_port->port_delete_work, bfad_im_port_delete_handler); 635 INIT_LIST_HEAD(&im_port->itnim_mapped_list); 636 INIT_LIST_HEAD(&im_port->binding_list); 637 638ext: 639 return rc; 640} 641 642void 643bfad_im_port_delete(struct bfad_s *bfad, struct bfad_port_s *port) 644{ 645 struct bfad_im_port_s *im_port = port->im_port; 646 647 queue_work(bfad->im->drv_workq, 648 &im_port->port_delete_work); 649} 650 651void 652bfad_im_port_clean(struct bfad_im_port_s *im_port) 653{ 654 struct bfad_fcp_binding *bp, *bp_new; 655 unsigned long flags; 656 struct bfad_s *bfad = im_port->bfad; 657 658 spin_lock_irqsave(&bfad->bfad_lock, flags); 659 list_for_each_entry_safe(bp, bp_new, &im_port->binding_list, 660 list_entry) { 661 list_del(&bp->list_entry); 662 kfree(bp); 663 } 664 665 /* the itnim_mapped_list must be empty at this time */ 666 WARN_ON(!list_empty(&im_port->itnim_mapped_list)); 667 668 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 669} 670 671static void bfad_aen_im_notify_handler(struct work_struct *work) 672{ 673 struct bfad_im_s *im = 674 container_of(work, struct bfad_im_s, aen_im_notify_work); 675 struct bfa_aen_entry_s *aen_entry; 676 struct bfad_s *bfad = im->bfad; 677 struct Scsi_Host *shost = bfad->pport.im_port->shost; 678 void *event_data; 679 unsigned long flags; 680 681 while (!list_empty(&bfad->active_aen_q)) { 682 spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags); 683 bfa_q_deq(&bfad->active_aen_q, &aen_entry); 684 spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags); 685 event_data = (char *)aen_entry + sizeof(struct list_head); 686 fc_host_post_vendor_event(shost, fc_get_event_number(), 687 sizeof(struct bfa_aen_entry_s) - 688 sizeof(struct list_head), 689 (char *)event_data, BFAD_NL_VENDOR_ID); 690 spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags); 691 list_add_tail(&aen_entry->qe, &bfad->free_aen_q); 692 spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags); 693 } 694} 695 696bfa_status_t 697bfad_im_probe(struct bfad_s *bfad) 698{ 699 struct bfad_im_s *im; 700 701 im = kzalloc(sizeof(struct bfad_im_s), GFP_KERNEL); 702 if (im == NULL) 703 return BFA_STATUS_ENOMEM; 704 705 bfad->im = im; 706 im->bfad = bfad; 707 708 if (bfad_thread_workq(bfad) != BFA_STATUS_OK) { 709 kfree(im); 710 return BFA_STATUS_FAILED; 711 } 712 713 INIT_WORK(&im->aen_im_notify_work, bfad_aen_im_notify_handler); 714 return BFA_STATUS_OK; 715} 716 717void 718bfad_im_probe_undo(struct bfad_s *bfad) 719{ 720 if (bfad->im) { 721 bfad_destroy_workq(bfad->im); 722 kfree(bfad->im); 723 bfad->im = NULL; 724 } 725} 726 727struct Scsi_Host * 728bfad_scsi_host_alloc(struct bfad_im_port_s *im_port, struct bfad_s *bfad) 729{ 730 struct scsi_host_template *sht; 731 732 if (im_port->port->pvb_type == BFAD_PORT_PHYS_BASE) 733 sht = &bfad_im_scsi_host_template; 734 else 735 sht = &bfad_im_vport_template; 736 737 if (max_xfer_size != BFAD_MAX_SECTORS >> 1) 738 sht->max_sectors = max_xfer_size << 1; 739 740 sht->sg_tablesize = bfad->cfg_data.io_max_sge; 741 742 return scsi_host_alloc(sht, sizeof(struct bfad_im_port_pointer)); 743} 744 745void 746bfad_scsi_host_free(struct bfad_s *bfad, struct bfad_im_port_s *im_port) 747{ 748 if (!(im_port->flags & BFAD_PORT_DELETE)) 749 flush_workqueue(bfad->im->drv_workq); 750 bfad_im_scsi_host_free(im_port->bfad, im_port); 751 bfad_im_port_clean(im_port); 752 kfree(im_port); 753} 754 755void 756bfad_destroy_workq(struct bfad_im_s *im) 757{ 758 if (im && im->drv_workq) { 759 flush_workqueue(im->drv_workq); 760 destroy_workqueue(im->drv_workq); 761 im->drv_workq = NULL; 762 } 763} 764 765bfa_status_t 766bfad_thread_workq(struct bfad_s *bfad) 767{ 768 struct bfad_im_s *im = bfad->im; 769 770 bfa_trc(bfad, 0); 771 snprintf(im->drv_workq_name, KOBJ_NAME_LEN, "bfad_wq_%d", 772 bfad->inst_no); 773 im->drv_workq = create_singlethread_workqueue(im->drv_workq_name); 774 if (!im->drv_workq) 775 return BFA_STATUS_FAILED; 776 777 return BFA_STATUS_OK; 778} 779 780/* 781 * Scsi_Host template entry. 782 * 783 * Description: 784 * OS entry point to adjust the queue_depths on a per-device basis. 785 * Called once per device during the bus scan. 786 * Return non-zero if fails. 787 */ 788static int 789bfad_im_slave_configure(struct scsi_device *sdev) 790{ 791 scsi_change_queue_depth(sdev, bfa_lun_queue_depth); 792 return 0; 793} 794 795struct scsi_host_template bfad_im_scsi_host_template = { 796 .module = THIS_MODULE, 797 .name = BFAD_DRIVER_NAME, 798 .info = bfad_im_info, 799 .queuecommand = bfad_im_queuecommand, 800 .eh_timed_out = fc_eh_timed_out, 801 .eh_abort_handler = bfad_im_abort_handler, 802 .eh_device_reset_handler = bfad_im_reset_lun_handler, 803 .eh_target_reset_handler = bfad_im_reset_target_handler, 804 805 .slave_alloc = bfad_im_slave_alloc, 806 .slave_configure = bfad_im_slave_configure, 807 .slave_destroy = bfad_im_slave_destroy, 808 809 .this_id = -1, 810 .sg_tablesize = BFAD_IO_MAX_SGE, 811 .cmd_per_lun = 3, 812 .shost_attrs = bfad_im_host_attrs, 813 .max_sectors = BFAD_MAX_SECTORS, 814 .vendor_id = BFA_PCI_VENDOR_ID_BROCADE, 815}; 816 817struct scsi_host_template bfad_im_vport_template = { 818 .module = THIS_MODULE, 819 .name = BFAD_DRIVER_NAME, 820 .info = bfad_im_info, 821 .queuecommand = bfad_im_queuecommand, 822 .eh_timed_out = fc_eh_timed_out, 823 .eh_abort_handler = bfad_im_abort_handler, 824 .eh_device_reset_handler = bfad_im_reset_lun_handler, 825 .eh_target_reset_handler = bfad_im_reset_target_handler, 826 827 .slave_alloc = bfad_im_slave_alloc, 828 .slave_configure = bfad_im_slave_configure, 829 .slave_destroy = bfad_im_slave_destroy, 830 831 .this_id = -1, 832 .sg_tablesize = BFAD_IO_MAX_SGE, 833 .cmd_per_lun = 3, 834 .shost_attrs = bfad_im_vport_attrs, 835 .max_sectors = BFAD_MAX_SECTORS, 836}; 837 838bfa_status_t 839bfad_im_module_init(void) 840{ 841 bfad_im_scsi_transport_template = 842 fc_attach_transport(&bfad_im_fc_function_template); 843 if (!bfad_im_scsi_transport_template) 844 return BFA_STATUS_ENOMEM; 845 846 bfad_im_scsi_vport_transport_template = 847 fc_attach_transport(&bfad_im_vport_fc_function_template); 848 if (!bfad_im_scsi_vport_transport_template) { 849 fc_release_transport(bfad_im_scsi_transport_template); 850 return BFA_STATUS_ENOMEM; 851 } 852 853 return BFA_STATUS_OK; 854} 855 856void 857bfad_im_module_exit(void) 858{ 859 if (bfad_im_scsi_transport_template) 860 fc_release_transport(bfad_im_scsi_transport_template); 861 862 if (bfad_im_scsi_vport_transport_template) 863 fc_release_transport(bfad_im_scsi_vport_transport_template); 864 865 idr_destroy(&bfad_im_port_index); 866} 867 868void 869bfad_ramp_up_qdepth(struct bfad_itnim_s *itnim, struct scsi_device *sdev) 870{ 871 struct scsi_device *tmp_sdev; 872 873 if (((jiffies - itnim->last_ramp_up_time) > 874 BFA_QUEUE_FULL_RAMP_UP_TIME * HZ) && 875 ((jiffies - itnim->last_queue_full_time) > 876 BFA_QUEUE_FULL_RAMP_UP_TIME * HZ)) { 877 shost_for_each_device(tmp_sdev, sdev->host) { 878 if (bfa_lun_queue_depth > tmp_sdev->queue_depth) { 879 if (tmp_sdev->id != sdev->id) 880 continue; 881 scsi_change_queue_depth(tmp_sdev, 882 tmp_sdev->queue_depth + 1); 883 884 itnim->last_ramp_up_time = jiffies; 885 } 886 } 887 } 888} 889 890void 891bfad_handle_qfull(struct bfad_itnim_s *itnim, struct scsi_device *sdev) 892{ 893 struct scsi_device *tmp_sdev; 894 895 itnim->last_queue_full_time = jiffies; 896 897 shost_for_each_device(tmp_sdev, sdev->host) { 898 if (tmp_sdev->id != sdev->id) 899 continue; 900 scsi_track_queue_full(tmp_sdev, tmp_sdev->queue_depth - 1); 901 } 902} 903 904struct bfad_itnim_s * 905bfad_get_itnim(struct bfad_im_port_s *im_port, int id) 906{ 907 struct bfad_itnim_s *itnim = NULL; 908 909 /* Search the mapped list for this target ID */ 910 list_for_each_entry(itnim, &im_port->itnim_mapped_list, list_entry) { 911 if (id == itnim->scsi_tgt_id) 912 return itnim; 913 } 914 915 return NULL; 916} 917 918/* 919 * Function is invoked from the SCSI Host Template slave_alloc() entry point. 920 * Has the logic to query the LUN Mask database to check if this LUN needs to 921 * be made visible to the SCSI mid-layer or not. 922 * 923 * Returns BFA_STATUS_OK if this LUN needs to be added to the OS stack. 924 * Returns -ENXIO to notify SCSI mid-layer to not add this LUN to the OS stack. 925 */ 926static int 927bfad_im_check_if_make_lun_visible(struct scsi_device *sdev, 928 struct fc_rport *rport) 929{ 930 struct bfad_itnim_data_s *itnim_data = 931 (struct bfad_itnim_data_s *) rport->dd_data; 932 struct bfa_s *bfa = itnim_data->itnim->bfa_itnim->bfa; 933 struct bfa_rport_s *bfa_rport = itnim_data->itnim->bfa_itnim->rport; 934 struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(bfa); 935 int i = 0, ret = -ENXIO; 936 937 for (i = 0; i < MAX_LUN_MASK_CFG; i++) { 938 if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE && 939 scsilun_to_int(&lun_list[i].lun) == sdev->lun && 940 lun_list[i].rp_tag == bfa_rport->rport_tag && 941 lun_list[i].lp_tag == (u8)bfa_rport->rport_info.lp_tag) { 942 ret = BFA_STATUS_OK; 943 break; 944 } 945 } 946 return ret; 947} 948 949/* 950 * Scsi_Host template entry slave_alloc 951 */ 952static int 953bfad_im_slave_alloc(struct scsi_device *sdev) 954{ 955 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 956 struct bfad_itnim_data_s *itnim_data; 957 struct bfa_s *bfa; 958 959 if (!rport || fc_remote_port_chkready(rport)) 960 return -ENXIO; 961 962 itnim_data = (struct bfad_itnim_data_s *) rport->dd_data; 963 bfa = itnim_data->itnim->bfa_itnim->bfa; 964 965 if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED) { 966 /* 967 * We should not mask LUN 0 - since this will translate 968 * to no LUN / TARGET for SCSI ml resulting no scan. 969 */ 970 if (sdev->lun == 0) { 971 sdev->sdev_bflags |= BLIST_NOREPORTLUN | 972 BLIST_SPARSELUN; 973 goto done; 974 } 975 976 /* 977 * Query LUN Mask configuration - to expose this LUN 978 * to the SCSI mid-layer or to mask it. 979 */ 980 if (bfad_im_check_if_make_lun_visible(sdev, rport) != 981 BFA_STATUS_OK) 982 return -ENXIO; 983 } 984done: 985 sdev->hostdata = rport->dd_data; 986 987 return 0; 988} 989 990u32 991bfad_im_supported_speeds(struct bfa_s *bfa) 992{ 993 struct bfa_ioc_attr_s *ioc_attr; 994 u32 supported_speed = 0; 995 996 ioc_attr = kzalloc(sizeof(struct bfa_ioc_attr_s), GFP_KERNEL); 997 if (!ioc_attr) 998 return 0; 999 1000 bfa_ioc_get_attr(&bfa->ioc, ioc_attr); 1001 if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_16GBPS) 1002 supported_speed |= FC_PORTSPEED_16GBIT | FC_PORTSPEED_8GBIT | 1003 FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT; 1004 else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_8GBPS) { 1005 if (ioc_attr->adapter_attr.is_mezz) { 1006 supported_speed |= FC_PORTSPEED_8GBIT | 1007 FC_PORTSPEED_4GBIT | 1008 FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT; 1009 } else { 1010 supported_speed |= FC_PORTSPEED_8GBIT | 1011 FC_PORTSPEED_4GBIT | 1012 FC_PORTSPEED_2GBIT; 1013 } 1014 } else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_4GBPS) { 1015 supported_speed |= FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT | 1016 FC_PORTSPEED_1GBIT; 1017 } else if (ioc_attr->adapter_attr.max_speed == BFA_PORT_SPEED_10GBPS) { 1018 supported_speed |= FC_PORTSPEED_10GBIT; 1019 } 1020 kfree(ioc_attr); 1021 return supported_speed; 1022} 1023 1024void 1025bfad_fc_host_init(struct bfad_im_port_s *im_port) 1026{ 1027 struct Scsi_Host *host = im_port->shost; 1028 struct bfad_s *bfad = im_port->bfad; 1029 struct bfad_port_s *port = im_port->port; 1030 char symname[BFA_SYMNAME_MAXLEN]; 1031 struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa); 1032 1033 fc_host_node_name(host) = 1034 cpu_to_be64((bfa_fcs_lport_get_nwwn(port->fcs_port))); 1035 fc_host_port_name(host) = 1036 cpu_to_be64((bfa_fcs_lport_get_pwwn(port->fcs_port))); 1037 fc_host_max_npiv_vports(host) = bfa_lps_get_max_vport(&bfad->bfa); 1038 1039 fc_host_supported_classes(host) = FC_COS_CLASS3; 1040 1041 memset(fc_host_supported_fc4s(host), 0, 1042 sizeof(fc_host_supported_fc4s(host))); 1043 if (supported_fc4s & BFA_LPORT_ROLE_FCP_IM) 1044 /* For FCP type 0x08 */ 1045 fc_host_supported_fc4s(host)[2] = 1; 1046 /* For fibre channel services type 0x20 */ 1047 fc_host_supported_fc4s(host)[7] = 1; 1048 1049 strlcpy(symname, bfad->bfa_fcs.fabric.bport.port_cfg.sym_name.symname, 1050 BFA_SYMNAME_MAXLEN); 1051 sprintf(fc_host_symbolic_name(host), "%s", symname); 1052 1053 fc_host_supported_speeds(host) = bfad_im_supported_speeds(&bfad->bfa); 1054 fc_host_maxframe_size(host) = fcport->cfg.maxfrsize; 1055} 1056 1057static void 1058bfad_im_fc_rport_add(struct bfad_im_port_s *im_port, struct bfad_itnim_s *itnim) 1059{ 1060 struct fc_rport_identifiers rport_ids; 1061 struct fc_rport *fc_rport; 1062 struct bfad_itnim_data_s *itnim_data; 1063 1064 rport_ids.node_name = 1065 cpu_to_be64(bfa_fcs_itnim_get_nwwn(&itnim->fcs_itnim)); 1066 rport_ids.port_name = 1067 cpu_to_be64(bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim)); 1068 rport_ids.port_id = 1069 bfa_hton3b(bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim)); 1070 rport_ids.roles = FC_RPORT_ROLE_UNKNOWN; 1071 1072 itnim->fc_rport = fc_rport = 1073 fc_remote_port_add(im_port->shost, 0, &rport_ids); 1074 1075 if (!fc_rport) 1076 return; 1077 1078 fc_rport->maxframe_size = 1079 bfa_fcs_itnim_get_maxfrsize(&itnim->fcs_itnim); 1080 fc_rport->supported_classes = bfa_fcs_itnim_get_cos(&itnim->fcs_itnim); 1081 1082 itnim_data = fc_rport->dd_data; 1083 itnim_data->itnim = itnim; 1084 1085 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; 1086 1087 if (rport_ids.roles != FC_RPORT_ROLE_UNKNOWN) 1088 fc_remote_port_rolechg(fc_rport, rport_ids.roles); 1089 1090 if ((fc_rport->scsi_target_id != -1) 1091 && (fc_rport->scsi_target_id < MAX_FCP_TARGET)) 1092 itnim->scsi_tgt_id = fc_rport->scsi_target_id; 1093 1094 itnim->channel = fc_rport->channel; 1095 1096 return; 1097} 1098 1099/* 1100 * Work queue handler using FC transport service 1101* Context: kernel 1102 */ 1103static void 1104bfad_im_itnim_work_handler(struct work_struct *work) 1105{ 1106 struct bfad_itnim_s *itnim = container_of(work, struct bfad_itnim_s, 1107 itnim_work); 1108 struct bfad_im_s *im = itnim->im; 1109 struct bfad_s *bfad = im->bfad; 1110 struct bfad_im_port_s *im_port; 1111 unsigned long flags; 1112 struct fc_rport *fc_rport; 1113 wwn_t wwpn; 1114 u32 fcid; 1115 char wwpn_str[32], fcid_str[16]; 1116 1117 spin_lock_irqsave(&bfad->bfad_lock, flags); 1118 im_port = itnim->im_port; 1119 bfa_trc(bfad, itnim->state); 1120 switch (itnim->state) { 1121 case ITNIM_STATE_ONLINE: 1122 if (!itnim->fc_rport) { 1123 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1124 bfad_im_fc_rport_add(im_port, itnim); 1125 spin_lock_irqsave(&bfad->bfad_lock, flags); 1126 wwpn = bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim); 1127 fcid = bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim); 1128 wwn2str(wwpn_str, wwpn); 1129 fcid2str(fcid_str, fcid); 1130 list_add_tail(&itnim->list_entry, 1131 &im_port->itnim_mapped_list); 1132 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 1133 "ITNIM ONLINE Target: %d:0:%d " 1134 "FCID: %s WWPN: %s\n", 1135 im_port->shost->host_no, 1136 itnim->scsi_tgt_id, 1137 fcid_str, wwpn_str); 1138 } else { 1139 printk(KERN_WARNING 1140 "%s: itnim %llx is already in online state\n", 1141 __func__, 1142 bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim)); 1143 } 1144 1145 break; 1146 case ITNIM_STATE_OFFLINE_PENDING: 1147 itnim->state = ITNIM_STATE_OFFLINE; 1148 if (itnim->fc_rport) { 1149 fc_rport = itnim->fc_rport; 1150 ((struct bfad_itnim_data_s *) 1151 fc_rport->dd_data)->itnim = NULL; 1152 itnim->fc_rport = NULL; 1153 if (!(im_port->port->flags & BFAD_PORT_DELETE)) { 1154 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1155 fc_rport->dev_loss_tmo = 1156 bfa_fcpim_path_tov_get(&bfad->bfa) + 1; 1157 fc_remote_port_delete(fc_rport); 1158 spin_lock_irqsave(&bfad->bfad_lock, flags); 1159 } 1160 wwpn = bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim); 1161 fcid = bfa_fcs_itnim_get_fcid(&itnim->fcs_itnim); 1162 wwn2str(wwpn_str, wwpn); 1163 fcid2str(fcid_str, fcid); 1164 list_del(&itnim->list_entry); 1165 BFA_LOG(KERN_INFO, bfad, bfa_log_level, 1166 "ITNIM OFFLINE Target: %d:0:%d " 1167 "FCID: %s WWPN: %s\n", 1168 im_port->shost->host_no, 1169 itnim->scsi_tgt_id, 1170 fcid_str, wwpn_str); 1171 } 1172 break; 1173 case ITNIM_STATE_FREE: 1174 if (itnim->fc_rport) { 1175 fc_rport = itnim->fc_rport; 1176 ((struct bfad_itnim_data_s *) 1177 fc_rport->dd_data)->itnim = NULL; 1178 itnim->fc_rport = NULL; 1179 if (!(im_port->port->flags & BFAD_PORT_DELETE)) { 1180 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1181 fc_rport->dev_loss_tmo = 1182 bfa_fcpim_path_tov_get(&bfad->bfa) + 1; 1183 fc_remote_port_delete(fc_rport); 1184 spin_lock_irqsave(&bfad->bfad_lock, flags); 1185 } 1186 list_del(&itnim->list_entry); 1187 } 1188 1189 kfree(itnim); 1190 break; 1191 default: 1192 WARN_ON(1); 1193 break; 1194 } 1195 1196 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1197} 1198 1199/* 1200 * Scsi_Host template entry, queue a SCSI command to the BFAD. 1201 */ 1202static int 1203bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *)) 1204{ 1205 struct bfad_im_port_s *im_port = 1206 (struct bfad_im_port_s *) cmnd->device->host->hostdata[0]; 1207 struct bfad_s *bfad = im_port->bfad; 1208 struct bfad_itnim_data_s *itnim_data = cmnd->device->hostdata; 1209 struct bfad_itnim_s *itnim; 1210 struct bfa_ioim_s *hal_io; 1211 unsigned long flags; 1212 int rc; 1213 int sg_cnt = 0; 1214 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device)); 1215 1216 rc = fc_remote_port_chkready(rport); 1217 if (rc) { 1218 cmnd->result = rc; 1219 done(cmnd); 1220 return 0; 1221 } 1222 1223 if (bfad->bfad_flags & BFAD_EEH_BUSY) { 1224 if (bfad->bfad_flags & BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE) 1225 cmnd->result = DID_NO_CONNECT << 16; 1226 else 1227 cmnd->result = DID_REQUEUE << 16; 1228 done(cmnd); 1229 return 0; 1230 } 1231 1232 sg_cnt = scsi_dma_map(cmnd); 1233 if (sg_cnt < 0) 1234 return SCSI_MLQUEUE_HOST_BUSY; 1235 1236 cmnd->scsi_done = done; 1237 1238 spin_lock_irqsave(&bfad->bfad_lock, flags); 1239 if (!(bfad->bfad_flags & BFAD_HAL_START_DONE)) { 1240 printk(KERN_WARNING 1241 "bfad%d, queuecommand %p %x failed, BFA stopped\n", 1242 bfad->inst_no, cmnd, cmnd->cmnd[0]); 1243 cmnd->result = DID_NO_CONNECT << 16; 1244 goto out_fail_cmd; 1245 } 1246 1247 1248 itnim = itnim_data->itnim; 1249 if (!itnim) { 1250 cmnd->result = DID_IMM_RETRY << 16; 1251 goto out_fail_cmd; 1252 } 1253 1254 hal_io = bfa_ioim_alloc(&bfad->bfa, (struct bfad_ioim_s *) cmnd, 1255 itnim->bfa_itnim, sg_cnt); 1256 if (!hal_io) { 1257 printk(KERN_WARNING "hal_io failure\n"); 1258 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1259 scsi_dma_unmap(cmnd); 1260 return SCSI_MLQUEUE_HOST_BUSY; 1261 } 1262 1263 cmnd->host_scribble = (char *)hal_io; 1264 bfa_ioim_start(hal_io); 1265 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1266 1267 return 0; 1268 1269out_fail_cmd: 1270 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1271 scsi_dma_unmap(cmnd); 1272 if (done) 1273 done(cmnd); 1274 1275 return 0; 1276} 1277 1278static DEF_SCSI_QCMD(bfad_im_queuecommand) 1279 1280void 1281bfad_rport_online_wait(struct bfad_s *bfad) 1282{ 1283 int i; 1284 int rport_delay = 10; 1285 1286 for (i = 0; !(bfad->bfad_flags & BFAD_PORT_ONLINE) 1287 && i < bfa_linkup_delay; i++) { 1288 set_current_state(TASK_UNINTERRUPTIBLE); 1289 schedule_timeout(HZ); 1290 } 1291 1292 if (bfad->bfad_flags & BFAD_PORT_ONLINE) { 1293 rport_delay = rport_delay < bfa_linkup_delay ? 1294 rport_delay : bfa_linkup_delay; 1295 for (i = 0; !(bfad->bfad_flags & BFAD_RPORT_ONLINE) 1296 && i < rport_delay; i++) { 1297 set_current_state(TASK_UNINTERRUPTIBLE); 1298 schedule_timeout(HZ); 1299 } 1300 1301 if (rport_delay > 0 && (bfad->bfad_flags & BFAD_RPORT_ONLINE)) { 1302 set_current_state(TASK_UNINTERRUPTIBLE); 1303 schedule_timeout(rport_delay * HZ); 1304 } 1305 } 1306} 1307 1308int 1309bfad_get_linkup_delay(struct bfad_s *bfad) 1310{ 1311 u8 nwwns = 0; 1312 wwn_t wwns[BFA_PREBOOT_BOOTLUN_MAX]; 1313 int linkup_delay; 1314 1315 /* 1316 * Querying for the boot target port wwns 1317 * -- read from boot information in flash. 1318 * If nwwns > 0 => boot over SAN and set linkup_delay = 30 1319 * else => local boot machine set linkup_delay = 0 1320 */ 1321 1322 bfa_iocfc_get_bootwwns(&bfad->bfa, &nwwns, wwns); 1323 1324 if (nwwns > 0) 1325 /* If Boot over SAN set linkup_delay = 30sec */ 1326 linkup_delay = 30; 1327 else 1328 /* If local boot; no linkup_delay */ 1329 linkup_delay = 0; 1330 1331 return linkup_delay; 1332} 1333