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