1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2005 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * Portions Copyright (C) 2004-2005 Christoph Hellwig * 8 * * 9 * This program is free software; you can redistribute it and/or * 10 * modify it under the terms of version 2 of the GNU General * 11 * Public License as published by the Free Software Foundation. * 12 * This program is distributed in the hope that it will be useful. * 13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 17 * TO BE LEGALLY INVALID. See the GNU General Public License for * 18 * more details, a copy of which can be found in the file COPYING * 19 * included with this package. * 20 *******************************************************************/ 21 22 #include <linux/blkdev.h> 23 #include <linux/pci.h> 24 #include <linux/interrupt.h> 25 26 #include <scsi/scsi.h> 27 #include <scsi/scsi_device.h> 28 #include <scsi/scsi_host.h> 29 #include <scsi/scsi_transport_fc.h> 30 31 #include "lpfc_hw.h" 32 #include "lpfc_sli.h" 33 #include "lpfc_disc.h" 34 #include "lpfc_scsi.h" 35 #include "lpfc.h" 36 #include "lpfc_logmsg.h" 37 #include "lpfc_crtn.h" 38 39 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *, 40 struct lpfc_iocbq *); 41 static int lpfc_max_els_tries = 3; 42 43 static int 44 lpfc_els_chk_latt(struct lpfc_hba * phba) 45 { 46 struct lpfc_sli *psli; 47 LPFC_MBOXQ_t *mbox; 48 uint32_t ha_copy; 49 int rc; 50 51 psli = &phba->sli; 52 53 if ((phba->hba_state >= LPFC_HBA_READY) || 54 (phba->hba_state == LPFC_LINK_DOWN)) 55 return 0; 56 57 /* Read the HBA Host Attention Register */ 58 spin_lock_irq(phba->host->host_lock); 59 ha_copy = readl(phba->HAregaddr); 60 spin_unlock_irq(phba->host->host_lock); 61 62 if (!(ha_copy & HA_LATT)) 63 return 0; 64 65 /* Pending Link Event during Discovery */ 66 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY, 67 "%d:0237 Pending Link Event during " 68 "Discovery: State x%x\n", 69 phba->brd_no, phba->hba_state); 70 71 /* CLEAR_LA should re-enable link attention events and 72 * we should then imediately take a LATT event. The 73 * LATT processing should call lpfc_linkdown() which 74 * will cleanup any left over in-progress discovery 75 * events. 76 */ 77 spin_lock_irq(phba->host->host_lock); 78 phba->fc_flag |= FC_ABORT_DISCOVERY; 79 spin_unlock_irq(phba->host->host_lock); 80 81 if (phba->hba_state != LPFC_CLEAR_LA) { 82 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 83 phba->hba_state = LPFC_CLEAR_LA; 84 lpfc_clear_la(phba, mbox); 85 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 86 rc = lpfc_sli_issue_mbox (phba, mbox, 87 (MBX_NOWAIT | MBX_STOP_IOCB)); 88 if (rc == MBX_NOT_FINISHED) { 89 mempool_free(mbox, phba->mbox_mem_pool); 90 phba->hba_state = LPFC_HBA_ERROR; 91 } 92 } 93 } 94 95 return (1); 96 97 } 98 99 static struct lpfc_iocbq * 100 lpfc_prep_els_iocb(struct lpfc_hba * phba, 101 uint8_t expectRsp, 102 uint16_t cmdSize, 103 uint8_t retry, struct lpfc_nodelist * ndlp, uint32_t elscmd) 104 { 105 struct lpfc_sli_ring *pring; 106 struct lpfc_iocbq *elsiocb; 107 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist; 108 struct ulp_bde64 *bpl; 109 IOCB_t *icmd; 110 111 pring = &phba->sli.ring[LPFC_ELS_RING]; 112 113 if (phba->hba_state < LPFC_LINK_UP) 114 return NULL; 115 116 /* Allocate buffer for command iocb */ 117 spin_lock_irq(phba->host->host_lock); 118 elsiocb = lpfc_sli_get_iocbq(phba); 119 spin_unlock_irq(phba->host->host_lock); 120 121 if (elsiocb == NULL) 122 return NULL; 123 icmd = &elsiocb->iocb; 124 125 /* fill in BDEs for command */ 126 /* Allocate buffer for command payload */ 127 if (((pcmd = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL)) == 0) || 128 ((pcmd->virt = lpfc_mbuf_alloc(phba, 129 MEM_PRI, &(pcmd->phys))) == 0)) { 130 kfree(pcmd); 131 132 spin_lock_irq(phba->host->host_lock); 133 lpfc_sli_release_iocbq(phba, elsiocb); 134 spin_unlock_irq(phba->host->host_lock); 135 return NULL; 136 } 137 138 INIT_LIST_HEAD(&pcmd->list); 139 140 /* Allocate buffer for response payload */ 141 if (expectRsp) { 142 prsp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 143 if (prsp) 144 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, 145 &prsp->phys); 146 if (prsp == 0 || prsp->virt == 0) { 147 kfree(prsp); 148 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys); 149 kfree(pcmd); 150 spin_lock_irq(phba->host->host_lock); 151 lpfc_sli_release_iocbq(phba, elsiocb); 152 spin_unlock_irq(phba->host->host_lock); 153 return NULL; 154 } 155 INIT_LIST_HEAD(&prsp->list); 156 } else { 157 prsp = NULL; 158 } 159 160 /* Allocate buffer for Buffer ptr list */ 161 pbuflist = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 162 if (pbuflist) 163 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI, 164 &pbuflist->phys); 165 if (pbuflist == 0 || pbuflist->virt == 0) { 166 spin_lock_irq(phba->host->host_lock); 167 lpfc_sli_release_iocbq(phba, elsiocb); 168 spin_unlock_irq(phba->host->host_lock); 169 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys); 170 lpfc_mbuf_free(phba, prsp->virt, prsp->phys); 171 kfree(pcmd); 172 kfree(prsp); 173 kfree(pbuflist); 174 return NULL; 175 } 176 177 INIT_LIST_HEAD(&pbuflist->list); 178 179 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys); 180 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys); 181 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL; 182 if (expectRsp) { 183 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64)); 184 icmd->un.elsreq64.remoteID = ndlp->nlp_DID; /* DID */ 185 icmd->ulpCommand = CMD_ELS_REQUEST64_CR; 186 } else { 187 icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64); 188 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX; 189 } 190 191 icmd->ulpBdeCount = 1; 192 icmd->ulpLe = 1; 193 icmd->ulpClass = CLASS3; 194 195 bpl = (struct ulp_bde64 *) pbuflist->virt; 196 bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys)); 197 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys)); 198 bpl->tus.f.bdeSize = cmdSize; 199 bpl->tus.f.bdeFlags = 0; 200 bpl->tus.w = le32_to_cpu(bpl->tus.w); 201 202 if (expectRsp) { 203 bpl++; 204 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys)); 205 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys)); 206 bpl->tus.f.bdeSize = FCELSSIZE; 207 bpl->tus.f.bdeFlags = BUFF_USE_RCV; 208 bpl->tus.w = le32_to_cpu(bpl->tus.w); 209 } 210 211 /* Save for completion so we can release these resources */ 212 elsiocb->context1 = (uint8_t *) ndlp; 213 elsiocb->context2 = (uint8_t *) pcmd; 214 elsiocb->context3 = (uint8_t *) pbuflist; 215 elsiocb->retry = retry; 216 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT; 217 218 if (prsp) { 219 list_add(&prsp->list, &pcmd->list); 220 } 221 222 if (expectRsp) { 223 /* Xmit ELS command <elsCmd> to remote NPORT <did> */ 224 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 225 "%d:0116 Xmit ELS command x%x to remote " 226 "NPORT x%x Data: x%x x%x\n", 227 phba->brd_no, elscmd, 228 ndlp->nlp_DID, icmd->ulpIoTag, phba->hba_state); 229 } else { 230 /* Xmit ELS response <elsCmd> to remote NPORT <did> */ 231 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 232 "%d:0117 Xmit ELS response x%x to remote " 233 "NPORT x%x Data: x%x x%x\n", 234 phba->brd_no, elscmd, 235 ndlp->nlp_DID, icmd->ulpIoTag, cmdSize); 236 } 237 238 return (elsiocb); 239 } 240 241 242 static int 243 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, 244 struct serv_parm *sp, IOCB_t *irsp) 245 { 246 LPFC_MBOXQ_t *mbox; 247 int rc; 248 249 spin_lock_irq(phba->host->host_lock); 250 phba->fc_flag |= FC_FABRIC; 251 spin_unlock_irq(phba->host->host_lock); 252 253 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov); 254 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */ 255 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000; 256 257 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000; 258 259 if (phba->fc_topology == TOPOLOGY_LOOP) { 260 spin_lock_irq(phba->host->host_lock); 261 phba->fc_flag |= FC_PUBLIC_LOOP; 262 spin_unlock_irq(phba->host->host_lock); 263 } else { 264 /* 265 * If we are a N-port connected to a Fabric, fixup sparam's so 266 * logins to devices on remote loops work. 267 */ 268 phba->fc_sparam.cmn.altBbCredit = 1; 269 } 270 271 phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID; 272 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name)); 273 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name)); 274 ndlp->nlp_class_sup = 0; 275 if (sp->cls1.classValid) 276 ndlp->nlp_class_sup |= FC_COS_CLASS1; 277 if (sp->cls2.classValid) 278 ndlp->nlp_class_sup |= FC_COS_CLASS2; 279 if (sp->cls3.classValid) 280 ndlp->nlp_class_sup |= FC_COS_CLASS3; 281 if (sp->cls4.classValid) 282 ndlp->nlp_class_sup |= FC_COS_CLASS4; 283 ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | 284 sp->cmn.bbRcvSizeLsb; 285 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm)); 286 287 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 288 if (!mbox) 289 goto fail; 290 291 phba->hba_state = LPFC_FABRIC_CFG_LINK; 292 lpfc_config_link(phba, mbox); 293 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 294 295 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB); 296 if (rc == MBX_NOT_FINISHED) 297 goto fail_free_mbox; 298 299 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 300 if (!mbox) 301 goto fail; 302 303 if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0)) 304 goto fail_free_mbox; 305 306 /* 307 * set_slim mailbox command needs to execute first, 308 * queue this command to be processed later. 309 */ 310 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login; 311 mbox->context2 = ndlp; 312 313 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB); 314 if (rc == MBX_NOT_FINISHED) 315 goto fail_free_mbox; 316 317 return 0; 318 319 fail_free_mbox: 320 mempool_free(mbox, phba->mbox_mem_pool); 321 fail: 322 return -ENXIO; 323 } 324 325 /* 326 * We FLOGIed into an NPort, initiate pt2pt protocol 327 */ 328 static int 329 lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, 330 struct serv_parm *sp) 331 { 332 LPFC_MBOXQ_t *mbox; 333 int rc; 334 335 spin_lock_irq(phba->host->host_lock); 336 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 337 spin_unlock_irq(phba->host->host_lock); 338 339 phba->fc_edtov = FF_DEF_EDTOV; 340 phba->fc_ratov = FF_DEF_RATOV; 341 rc = memcmp(&phba->fc_portname, &sp->portName, 342 sizeof(struct lpfc_name)); 343 if (rc >= 0) { 344 /* This side will initiate the PLOGI */ 345 spin_lock_irq(phba->host->host_lock); 346 phba->fc_flag |= FC_PT2PT_PLOGI; 347 spin_unlock_irq(phba->host->host_lock); 348 349 /* 350 * N_Port ID cannot be 0, set our to LocalID the other 351 * side will be RemoteID. 352 */ 353 354 /* not equal */ 355 if (rc) 356 phba->fc_myDID = PT2PT_LocalID; 357 358 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 359 if (!mbox) 360 goto fail; 361 362 lpfc_config_link(phba, mbox); 363 364 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 365 rc = lpfc_sli_issue_mbox(phba, mbox, 366 MBX_NOWAIT | MBX_STOP_IOCB); 367 if (rc == MBX_NOT_FINISHED) { 368 mempool_free(mbox, phba->mbox_mem_pool); 369 goto fail; 370 } 371 mempool_free(ndlp, phba->nlp_mem_pool); 372 373 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, PT2PT_RemoteID); 374 if (!ndlp) { 375 /* 376 * Cannot find existing Fabric ndlp, so allocate a 377 * new one 378 */ 379 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 380 if (!ndlp) 381 goto fail; 382 383 lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID); 384 } 385 386 memcpy(&ndlp->nlp_portname, &sp->portName, 387 sizeof(struct lpfc_name)); 388 memcpy(&ndlp->nlp_nodename, &sp->nodeName, 389 sizeof(struct lpfc_name)); 390 ndlp->nlp_state = NLP_STE_NPR_NODE; 391 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 392 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 393 } else { 394 /* This side will wait for the PLOGI */ 395 mempool_free( ndlp, phba->nlp_mem_pool); 396 } 397 398 spin_lock_irq(phba->host->host_lock); 399 phba->fc_flag |= FC_PT2PT; 400 spin_unlock_irq(phba->host->host_lock); 401 402 /* Start discovery - this should just do CLEAR_LA */ 403 lpfc_disc_start(phba); 404 return 0; 405 fail: 406 return -ENXIO; 407 } 408 409 static void 410 lpfc_cmpl_els_flogi(struct lpfc_hba * phba, 411 struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb) 412 { 413 IOCB_t *irsp = &rspiocb->iocb; 414 struct lpfc_nodelist *ndlp = cmdiocb->context1; 415 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp; 416 struct serv_parm *sp; 417 int rc; 418 419 /* Check to see if link went down during discovery */ 420 if (lpfc_els_chk_latt(phba)) { 421 lpfc_nlp_remove(phba, ndlp); 422 goto out; 423 } 424 425 if (irsp->ulpStatus) { 426 /* Check for retry */ 427 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 428 /* ELS command is being retried */ 429 goto out; 430 } 431 /* FLOGI failed, so there is no fabric */ 432 spin_lock_irq(phba->host->host_lock); 433 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 434 spin_unlock_irq(phba->host->host_lock); 435 436 /* If private loop, then allow max outstandting els to be 437 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no 438 * alpa map would take too long otherwise. 439 */ 440 if (phba->alpa_map[0] == 0) { 441 phba->cfg_discovery_threads = 442 LPFC_MAX_DISC_THREADS; 443 } 444 445 /* FLOGI failure */ 446 lpfc_printf_log(phba, 447 KERN_INFO, 448 LOG_ELS, 449 "%d:0100 FLOGI failure Data: x%x x%x\n", 450 phba->brd_no, 451 irsp->ulpStatus, irsp->un.ulpWord[4]); 452 goto flogifail; 453 } 454 455 /* 456 * The FLogI succeeded. Sync the data for the CPU before 457 * accessing it. 458 */ 459 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list); 460 461 sp = prsp->virt + sizeof(uint32_t); 462 463 /* FLOGI completes successfully */ 464 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 465 "%d:0101 FLOGI completes sucessfully " 466 "Data: x%x x%x x%x x%x\n", 467 phba->brd_no, 468 irsp->un.ulpWord[4], sp->cmn.e_d_tov, 469 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution); 470 471 if (phba->hba_state == LPFC_FLOGI) { 472 /* 473 * If Common Service Parameters indicate Nport 474 * we are point to point, if Fport we are Fabric. 475 */ 476 if (sp->cmn.fPort) 477 rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp); 478 else 479 rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp); 480 481 if (!rc) 482 goto out; 483 } 484 485 flogifail: 486 lpfc_nlp_remove(phba, ndlp); 487 488 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT || 489 (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED && 490 irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) { 491 /* FLOGI failed, so just use loop map to make discovery list */ 492 lpfc_disc_list_loopmap(phba); 493 494 /* Start discovery */ 495 lpfc_disc_start(phba); 496 } 497 498 out: 499 lpfc_els_free_iocb(phba, cmdiocb); 500 } 501 502 static int 503 lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 504 uint8_t retry) 505 { 506 struct serv_parm *sp; 507 IOCB_t *icmd; 508 struct lpfc_iocbq *elsiocb; 509 struct lpfc_sli_ring *pring; 510 uint8_t *pcmd; 511 uint16_t cmdsize; 512 uint32_t tmo; 513 int rc; 514 515 pring = &phba->sli.ring[LPFC_ELS_RING]; 516 517 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm)); 518 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 519 ndlp, ELS_CMD_FLOGI)) == 0) { 520 return (1); 521 } 522 523 icmd = &elsiocb->iocb; 524 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 525 526 /* For FLOGI request, remainder of payload is service parameters */ 527 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI; 528 pcmd += sizeof (uint32_t); 529 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 530 sp = (struct serv_parm *) pcmd; 531 532 /* Setup CSPs accordingly for Fabric */ 533 sp->cmn.e_d_tov = 0; 534 sp->cmn.w2.r_a_tov = 0; 535 sp->cls1.classValid = 0; 536 sp->cls2.seqDelivery = 1; 537 sp->cls3.seqDelivery = 1; 538 if (sp->cmn.fcphLow < FC_PH3) 539 sp->cmn.fcphLow = FC_PH3; 540 if (sp->cmn.fcphHigh < FC_PH3) 541 sp->cmn.fcphHigh = FC_PH3; 542 543 tmo = phba->fc_ratov; 544 phba->fc_ratov = LPFC_DISC_FLOGI_TMO; 545 lpfc_set_disctmo(phba); 546 phba->fc_ratov = tmo; 547 548 phba->fc_stat.elsXmitFLOGI++; 549 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi; 550 spin_lock_irq(phba->host->host_lock); 551 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 552 spin_unlock_irq(phba->host->host_lock); 553 if (rc == IOCB_ERROR) { 554 lpfc_els_free_iocb(phba, elsiocb); 555 return (1); 556 } 557 return (0); 558 } 559 560 int 561 lpfc_els_abort_flogi(struct lpfc_hba * phba) 562 { 563 struct lpfc_sli_ring *pring; 564 struct lpfc_iocbq *iocb, *next_iocb; 565 struct lpfc_nodelist *ndlp; 566 IOCB_t *icmd; 567 568 /* Abort outstanding I/O on NPort <nlp_DID> */ 569 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 570 "%d:0201 Abort outstanding I/O on NPort x%x\n", 571 phba->brd_no, Fabric_DID); 572 573 pring = &phba->sli.ring[LPFC_ELS_RING]; 574 575 /* 576 * Check the txcmplq for an iocb that matches the nport the driver is 577 * searching for. 578 */ 579 spin_lock_irq(phba->host->host_lock); 580 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) { 581 icmd = &iocb->iocb; 582 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) { 583 ndlp = (struct lpfc_nodelist *)(iocb->context1); 584 if (ndlp && (ndlp->nlp_DID == Fabric_DID)) { 585 list_del(&iocb->list); 586 pring->txcmplq_cnt--; 587 588 if ((icmd->un.elsreq64.bdl.ulpIoTag32)) { 589 lpfc_sli_issue_abort_iotag32 590 (phba, pring, iocb); 591 } 592 if (iocb->iocb_cmpl) { 593 icmd->ulpStatus = IOSTAT_LOCAL_REJECT; 594 icmd->un.ulpWord[4] = 595 IOERR_SLI_ABORTED; 596 spin_unlock_irq(phba->host->host_lock); 597 (iocb->iocb_cmpl) (phba, iocb, iocb); 598 spin_lock_irq(phba->host->host_lock); 599 } else 600 lpfc_sli_release_iocbq(phba, iocb); 601 } 602 } 603 } 604 spin_unlock_irq(phba->host->host_lock); 605 606 return 0; 607 } 608 609 int 610 lpfc_initial_flogi(struct lpfc_hba * phba) 611 { 612 struct lpfc_nodelist *ndlp; 613 614 /* First look for Fabric ndlp on the unmapped list */ 615 616 if ((ndlp = 617 lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, 618 Fabric_DID)) == 0) { 619 /* Cannot find existing Fabric ndlp, so allocate a new one */ 620 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) 621 == 0) { 622 return (0); 623 } 624 lpfc_nlp_init(phba, ndlp, Fabric_DID); 625 } 626 else { 627 phba->fc_unmap_cnt--; 628 list_del(&ndlp->nlp_listp); 629 spin_lock_irq(phba->host->host_lock); 630 ndlp->nlp_flag &= ~NLP_LIST_MASK; 631 spin_unlock_irq(phba->host->host_lock); 632 } 633 if (lpfc_issue_els_flogi(phba, ndlp, 0)) { 634 mempool_free( ndlp, phba->nlp_mem_pool); 635 } 636 return (1); 637 } 638 639 static void 640 lpfc_more_plogi(struct lpfc_hba * phba) 641 { 642 int sentplogi; 643 644 if (phba->num_disc_nodes) 645 phba->num_disc_nodes--; 646 647 /* Continue discovery with <num_disc_nodes> PLOGIs to go */ 648 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 649 "%d:0232 Continue discovery with %d PLOGIs to go " 650 "Data: x%x x%x x%x\n", 651 phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt, 652 phba->fc_flag, phba->hba_state); 653 654 /* Check to see if there are more PLOGIs to be sent */ 655 if (phba->fc_flag & FC_NLP_MORE) { 656 /* go thru NPR list and issue any remaining ELS PLOGIs */ 657 sentplogi = lpfc_els_disc_plogi(phba); 658 } 659 return; 660 } 661 662 static void 663 lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 664 struct lpfc_iocbq * rspiocb) 665 { 666 IOCB_t *irsp; 667 struct lpfc_sli *psli; 668 struct lpfc_nodelist *ndlp; 669 int disc, rc, did, type; 670 671 psli = &phba->sli; 672 673 /* we pass cmdiocb to state machine which needs rspiocb as well */ 674 cmdiocb->context_un.rsp_iocb = rspiocb; 675 676 irsp = &rspiocb->iocb; 677 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 678 spin_lock_irq(phba->host->host_lock); 679 ndlp->nlp_flag &= ~NLP_PLOGI_SND; 680 spin_unlock_irq(phba->host->host_lock); 681 682 /* Since ndlp can be freed in the disc state machine, note if this node 683 * is being used during discovery. 684 */ 685 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 686 rc = 0; 687 688 /* PLOGI completes to NPort <nlp_DID> */ 689 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 690 "%d:0102 PLOGI completes to NPort x%x " 691 "Data: x%x x%x x%x x%x\n", 692 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 693 irsp->un.ulpWord[4], disc, phba->num_disc_nodes); 694 695 /* Check to see if link went down during discovery */ 696 if (lpfc_els_chk_latt(phba)) { 697 spin_lock_irq(phba->host->host_lock); 698 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 699 spin_unlock_irq(phba->host->host_lock); 700 goto out; 701 } 702 703 /* ndlp could be freed in DSM, save these values now */ 704 type = ndlp->nlp_type; 705 did = ndlp->nlp_DID; 706 707 if (irsp->ulpStatus) { 708 /* Check for retry */ 709 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 710 /* ELS command is being retried */ 711 if (disc) { 712 spin_lock_irq(phba->host->host_lock); 713 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 714 spin_unlock_irq(phba->host->host_lock); 715 } 716 goto out; 717 } 718 719 /* PLOGI failed */ 720 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ 721 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 722 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || 723 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || 724 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 725 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 726 } 727 else { 728 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb, 729 NLP_EVT_CMPL_PLOGI); 730 } 731 } else { 732 /* Good status, call state machine */ 733 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb, 734 NLP_EVT_CMPL_PLOGI); 735 } 736 737 if (type & NLP_FABRIC) { 738 /* If we cannot login to Nameserver, kick off discovery now */ 739 if ((did == NameServer_DID) && (rc == NLP_STE_FREED_NODE)) { 740 lpfc_disc_start(phba); 741 } 742 goto out; 743 } 744 745 if (disc && phba->num_disc_nodes) { 746 /* Check to see if there are more PLOGIs to be sent */ 747 lpfc_more_plogi(phba); 748 } 749 750 if (rc != NLP_STE_FREED_NODE) { 751 spin_lock_irq(phba->host->host_lock); 752 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 753 spin_unlock_irq(phba->host->host_lock); 754 } 755 756 if (phba->num_disc_nodes == 0) { 757 if(disc) { 758 spin_lock_irq(phba->host->host_lock); 759 phba->fc_flag &= ~FC_NDISC_ACTIVE; 760 spin_unlock_irq(phba->host->host_lock); 761 } 762 lpfc_can_disctmo(phba); 763 if (phba->fc_flag & FC_RSCN_MODE) { 764 /* Check to see if more RSCNs came in while we were 765 * processing this one. 766 */ 767 if ((phba->fc_rscn_id_cnt == 0) && 768 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 769 spin_lock_irq(phba->host->host_lock); 770 phba->fc_flag &= ~FC_RSCN_MODE; 771 spin_unlock_irq(phba->host->host_lock); 772 } else { 773 lpfc_els_handle_rscn(phba); 774 } 775 } 776 } 777 778 out: 779 lpfc_els_free_iocb(phba, cmdiocb); 780 return; 781 } 782 783 int 784 lpfc_issue_els_plogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 785 uint8_t retry) 786 { 787 struct serv_parm *sp; 788 IOCB_t *icmd; 789 struct lpfc_iocbq *elsiocb; 790 struct lpfc_sli_ring *pring; 791 struct lpfc_sli *psli; 792 uint8_t *pcmd; 793 uint16_t cmdsize; 794 795 psli = &phba->sli; 796 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 797 798 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm)); 799 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 800 ndlp, ELS_CMD_PLOGI)) == 0) { 801 return (1); 802 } 803 804 icmd = &elsiocb->iocb; 805 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 806 807 /* For PLOGI request, remainder of payload is service parameters */ 808 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI; 809 pcmd += sizeof (uint32_t); 810 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 811 sp = (struct serv_parm *) pcmd; 812 813 if (sp->cmn.fcphLow < FC_PH_4_3) 814 sp->cmn.fcphLow = FC_PH_4_3; 815 816 if (sp->cmn.fcphHigh < FC_PH3) 817 sp->cmn.fcphHigh = FC_PH3; 818 819 phba->fc_stat.elsXmitPLOGI++; 820 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi; 821 spin_lock_irq(phba->host->host_lock); 822 ndlp->nlp_flag |= NLP_PLOGI_SND; 823 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 824 ndlp->nlp_flag &= ~NLP_PLOGI_SND; 825 spin_unlock_irq(phba->host->host_lock); 826 lpfc_els_free_iocb(phba, elsiocb); 827 return (1); 828 } 829 spin_unlock_irq(phba->host->host_lock); 830 return (0); 831 } 832 833 static void 834 lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 835 struct lpfc_iocbq * rspiocb) 836 { 837 IOCB_t *irsp; 838 struct lpfc_sli *psli; 839 struct lpfc_nodelist *ndlp; 840 841 psli = &phba->sli; 842 /* we pass cmdiocb to state machine which needs rspiocb as well */ 843 cmdiocb->context_un.rsp_iocb = rspiocb; 844 845 irsp = &(rspiocb->iocb); 846 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 847 spin_lock_irq(phba->host->host_lock); 848 ndlp->nlp_flag &= ~NLP_PRLI_SND; 849 spin_unlock_irq(phba->host->host_lock); 850 851 /* PRLI completes to NPort <nlp_DID> */ 852 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 853 "%d:0103 PRLI completes to NPort x%x " 854 "Data: x%x x%x x%x\n", 855 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 856 irsp->un.ulpWord[4], phba->num_disc_nodes); 857 858 phba->fc_prli_sent--; 859 /* Check to see if link went down during discovery */ 860 if (lpfc_els_chk_latt(phba)) 861 goto out; 862 863 if (irsp->ulpStatus) { 864 /* Check for retry */ 865 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 866 /* ELS command is being retried */ 867 goto out; 868 } 869 /* PRLI failed */ 870 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ 871 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 872 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || 873 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || 874 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 875 goto out; 876 } 877 else { 878 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 879 NLP_EVT_CMPL_PRLI); 880 } 881 } else { 882 /* Good status, call state machine */ 883 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI); 884 } 885 886 out: 887 lpfc_els_free_iocb(phba, cmdiocb); 888 return; 889 } 890 891 int 892 lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 893 uint8_t retry) 894 { 895 PRLI *npr; 896 IOCB_t *icmd; 897 struct lpfc_iocbq *elsiocb; 898 struct lpfc_sli_ring *pring; 899 struct lpfc_sli *psli; 900 uint8_t *pcmd; 901 uint16_t cmdsize; 902 903 psli = &phba->sli; 904 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 905 906 cmdsize = (sizeof (uint32_t) + sizeof (PRLI)); 907 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 908 ndlp, ELS_CMD_PRLI)) == 0) { 909 return (1); 910 } 911 912 icmd = &elsiocb->iocb; 913 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 914 915 /* For PRLI request, remainder of payload is service parameters */ 916 memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t))); 917 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI; 918 pcmd += sizeof (uint32_t); 919 920 /* For PRLI, remainder of payload is PRLI parameter page */ 921 npr = (PRLI *) pcmd; 922 /* 923 * If our firmware version is 3.20 or later, 924 * set the following bits for FC-TAPE support. 925 */ 926 if (phba->vpd.rev.feaLevelHigh >= 0x02) { 927 npr->ConfmComplAllowed = 1; 928 npr->Retry = 1; 929 npr->TaskRetryIdReq = 1; 930 } 931 npr->estabImagePair = 1; 932 npr->readXferRdyDis = 1; 933 934 /* For FCP support */ 935 npr->prliType = PRLI_FCP_TYPE; 936 npr->initiatorFunc = 1; 937 938 phba->fc_stat.elsXmitPRLI++; 939 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli; 940 spin_lock_irq(phba->host->host_lock); 941 ndlp->nlp_flag |= NLP_PRLI_SND; 942 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 943 ndlp->nlp_flag &= ~NLP_PRLI_SND; 944 spin_unlock_irq(phba->host->host_lock); 945 lpfc_els_free_iocb(phba, elsiocb); 946 return (1); 947 } 948 spin_unlock_irq(phba->host->host_lock); 949 phba->fc_prli_sent++; 950 return (0); 951 } 952 953 static void 954 lpfc_more_adisc(struct lpfc_hba * phba) 955 { 956 int sentadisc; 957 958 if (phba->num_disc_nodes) 959 phba->num_disc_nodes--; 960 961 /* Continue discovery with <num_disc_nodes> ADISCs to go */ 962 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 963 "%d:0210 Continue discovery with %d ADISCs to go " 964 "Data: x%x x%x x%x\n", 965 phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt, 966 phba->fc_flag, phba->hba_state); 967 968 /* Check to see if there are more ADISCs to be sent */ 969 if (phba->fc_flag & FC_NLP_MORE) { 970 lpfc_set_disctmo(phba); 971 972 /* go thru NPR list and issue any remaining ELS ADISCs */ 973 sentadisc = lpfc_els_disc_adisc(phba); 974 } 975 return; 976 } 977 978 static void 979 lpfc_rscn_disc(struct lpfc_hba * phba) 980 { 981 /* RSCN discovery */ 982 /* go thru NPR list and issue ELS PLOGIs */ 983 if (phba->fc_npr_cnt) { 984 if (lpfc_els_disc_plogi(phba)) 985 return; 986 } 987 if (phba->fc_flag & FC_RSCN_MODE) { 988 /* Check to see if more RSCNs came in while we were 989 * processing this one. 990 */ 991 if ((phba->fc_rscn_id_cnt == 0) && 992 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 993 spin_lock_irq(phba->host->host_lock); 994 phba->fc_flag &= ~FC_RSCN_MODE; 995 spin_unlock_irq(phba->host->host_lock); 996 } else { 997 lpfc_els_handle_rscn(phba); 998 } 999 } 1000 } 1001 1002 static void 1003 lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1004 struct lpfc_iocbq * rspiocb) 1005 { 1006 IOCB_t *irsp; 1007 struct lpfc_sli *psli; 1008 struct lpfc_nodelist *ndlp; 1009 LPFC_MBOXQ_t *mbox; 1010 int disc, rc; 1011 1012 psli = &phba->sli; 1013 1014 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1015 cmdiocb->context_un.rsp_iocb = rspiocb; 1016 1017 irsp = &(rspiocb->iocb); 1018 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1019 spin_lock_irq(phba->host->host_lock); 1020 ndlp->nlp_flag &= ~NLP_ADISC_SND; 1021 spin_unlock_irq(phba->host->host_lock); 1022 1023 /* Since ndlp can be freed in the disc state machine, note if this node 1024 * is being used during discovery. 1025 */ 1026 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 1027 1028 /* ADISC completes to NPort <nlp_DID> */ 1029 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1030 "%d:0104 ADISC completes to NPort x%x " 1031 "Data: x%x x%x x%x x%x\n", 1032 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 1033 irsp->un.ulpWord[4], disc, phba->num_disc_nodes); 1034 1035 /* Check to see if link went down during discovery */ 1036 if (lpfc_els_chk_latt(phba)) { 1037 spin_lock_irq(phba->host->host_lock); 1038 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1039 spin_unlock_irq(phba->host->host_lock); 1040 goto out; 1041 } 1042 1043 if (irsp->ulpStatus) { 1044 /* Check for retry */ 1045 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 1046 /* ELS command is being retried */ 1047 if (disc) { 1048 spin_lock_irq(phba->host->host_lock); 1049 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1050 spin_unlock_irq(phba->host->host_lock); 1051 lpfc_set_disctmo(phba); 1052 } 1053 goto out; 1054 } 1055 /* ADISC failed */ 1056 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ 1057 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 1058 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || 1059 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || 1060 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 1061 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 1062 } 1063 else { 1064 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1065 NLP_EVT_CMPL_ADISC); 1066 } 1067 } else { 1068 /* Good status, call state machine */ 1069 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1070 NLP_EVT_CMPL_ADISC); 1071 } 1072 1073 if (disc && phba->num_disc_nodes) { 1074 /* Check to see if there are more ADISCs to be sent */ 1075 lpfc_more_adisc(phba); 1076 1077 /* Check to see if we are done with ADISC authentication */ 1078 if (phba->num_disc_nodes == 0) { 1079 lpfc_can_disctmo(phba); 1080 /* If we get here, there is nothing left to wait for */ 1081 if ((phba->hba_state < LPFC_HBA_READY) && 1082 (phba->hba_state != LPFC_CLEAR_LA)) { 1083 /* Link up discovery */ 1084 if ((mbox = mempool_alloc(phba->mbox_mem_pool, 1085 GFP_KERNEL))) { 1086 phba->hba_state = LPFC_CLEAR_LA; 1087 lpfc_clear_la(phba, mbox); 1088 mbox->mbox_cmpl = 1089 lpfc_mbx_cmpl_clear_la; 1090 rc = lpfc_sli_issue_mbox 1091 (phba, mbox, 1092 (MBX_NOWAIT | MBX_STOP_IOCB)); 1093 if (rc == MBX_NOT_FINISHED) { 1094 mempool_free(mbox, 1095 phba->mbox_mem_pool); 1096 lpfc_disc_flush_list(phba); 1097 psli->ring[(psli->ip_ring)]. 1098 flag &= 1099 ~LPFC_STOP_IOCB_EVENT; 1100 psli->ring[(psli->fcp_ring)]. 1101 flag &= 1102 ~LPFC_STOP_IOCB_EVENT; 1103 psli->ring[(psli->next_ring)]. 1104 flag &= 1105 ~LPFC_STOP_IOCB_EVENT; 1106 phba->hba_state = 1107 LPFC_HBA_READY; 1108 } 1109 } 1110 } else { 1111 lpfc_rscn_disc(phba); 1112 } 1113 } 1114 } 1115 spin_lock_irq(phba->host->host_lock); 1116 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 1117 spin_unlock_irq(phba->host->host_lock); 1118 out: 1119 lpfc_els_free_iocb(phba, cmdiocb); 1120 return; 1121 } 1122 1123 int 1124 lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 1125 uint8_t retry) 1126 { 1127 ADISC *ap; 1128 IOCB_t *icmd; 1129 struct lpfc_iocbq *elsiocb; 1130 struct lpfc_sli_ring *pring; 1131 struct lpfc_sli *psli; 1132 uint8_t *pcmd; 1133 uint16_t cmdsize; 1134 1135 psli = &phba->sli; 1136 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1137 1138 cmdsize = (sizeof (uint32_t) + sizeof (ADISC)); 1139 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 1140 ndlp, ELS_CMD_ADISC)) == 0) { 1141 return (1); 1142 } 1143 1144 icmd = &elsiocb->iocb; 1145 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1146 1147 /* For ADISC request, remainder of payload is service parameters */ 1148 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC; 1149 pcmd += sizeof (uint32_t); 1150 1151 /* Fill in ADISC payload */ 1152 ap = (ADISC *) pcmd; 1153 ap->hardAL_PA = phba->fc_pref_ALPA; 1154 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 1155 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 1156 ap->DID = be32_to_cpu(phba->fc_myDID); 1157 1158 phba->fc_stat.elsXmitADISC++; 1159 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc; 1160 spin_lock_irq(phba->host->host_lock); 1161 ndlp->nlp_flag |= NLP_ADISC_SND; 1162 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1163 ndlp->nlp_flag &= ~NLP_ADISC_SND; 1164 spin_unlock_irq(phba->host->host_lock); 1165 lpfc_els_free_iocb(phba, elsiocb); 1166 return (1); 1167 } 1168 spin_unlock_irq(phba->host->host_lock); 1169 return (0); 1170 } 1171 1172 static void 1173 lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1174 struct lpfc_iocbq * rspiocb) 1175 { 1176 IOCB_t *irsp; 1177 struct lpfc_sli *psli; 1178 struct lpfc_nodelist *ndlp; 1179 1180 psli = &phba->sli; 1181 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1182 cmdiocb->context_un.rsp_iocb = rspiocb; 1183 1184 irsp = &(rspiocb->iocb); 1185 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1186 spin_lock_irq(phba->host->host_lock); 1187 ndlp->nlp_flag &= ~NLP_LOGO_SND; 1188 spin_unlock_irq(phba->host->host_lock); 1189 1190 /* LOGO completes to NPort <nlp_DID> */ 1191 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1192 "%d:0105 LOGO completes to NPort x%x " 1193 "Data: x%x x%x x%x\n", 1194 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 1195 irsp->un.ulpWord[4], phba->num_disc_nodes); 1196 1197 /* Check to see if link went down during discovery */ 1198 if (lpfc_els_chk_latt(phba)) 1199 goto out; 1200 1201 if (irsp->ulpStatus) { 1202 /* Check for retry */ 1203 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 1204 /* ELS command is being retried */ 1205 goto out; 1206 } 1207 /* LOGO failed */ 1208 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ 1209 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 1210 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) || 1211 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || 1212 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 1213 goto out; 1214 } 1215 else { 1216 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1217 NLP_EVT_CMPL_LOGO); 1218 } 1219 } else { 1220 /* Good status, call state machine */ 1221 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO); 1222 1223 if (ndlp->nlp_flag & NLP_DELAY_TMO) { 1224 lpfc_unreg_rpi(phba, ndlp); 1225 } 1226 } 1227 1228 out: 1229 lpfc_els_free_iocb(phba, cmdiocb); 1230 return; 1231 } 1232 1233 int 1234 lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 1235 uint8_t retry) 1236 { 1237 IOCB_t *icmd; 1238 struct lpfc_iocbq *elsiocb; 1239 struct lpfc_sli_ring *pring; 1240 struct lpfc_sli *psli; 1241 uint8_t *pcmd; 1242 uint16_t cmdsize; 1243 1244 psli = &phba->sli; 1245 pring = &psli->ring[LPFC_ELS_RING]; 1246 1247 cmdsize = 2 * (sizeof (uint32_t) + sizeof (struct lpfc_name)); 1248 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 1249 ndlp, ELS_CMD_LOGO)) == 0) { 1250 return (1); 1251 } 1252 1253 icmd = &elsiocb->iocb; 1254 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1255 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO; 1256 pcmd += sizeof (uint32_t); 1257 1258 /* Fill in LOGO payload */ 1259 *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID); 1260 pcmd += sizeof (uint32_t); 1261 memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name)); 1262 1263 phba->fc_stat.elsXmitLOGO++; 1264 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo; 1265 spin_lock_irq(phba->host->host_lock); 1266 ndlp->nlp_flag |= NLP_LOGO_SND; 1267 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1268 ndlp->nlp_flag &= ~NLP_LOGO_SND; 1269 spin_unlock_irq(phba->host->host_lock); 1270 lpfc_els_free_iocb(phba, elsiocb); 1271 return (1); 1272 } 1273 spin_unlock_irq(phba->host->host_lock); 1274 return (0); 1275 } 1276 1277 static void 1278 lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1279 struct lpfc_iocbq * rspiocb) 1280 { 1281 IOCB_t *irsp; 1282 1283 irsp = &rspiocb->iocb; 1284 1285 /* ELS cmd tag <ulpIoTag> completes */ 1286 lpfc_printf_log(phba, 1287 KERN_INFO, 1288 LOG_ELS, 1289 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x\n", 1290 phba->brd_no, 1291 irsp->ulpIoTag, irsp->ulpStatus, irsp->un.ulpWord[4]); 1292 1293 /* Check to see if link went down during discovery */ 1294 lpfc_els_chk_latt(phba); 1295 lpfc_els_free_iocb(phba, cmdiocb); 1296 return; 1297 } 1298 1299 int 1300 lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry) 1301 { 1302 IOCB_t *icmd; 1303 struct lpfc_iocbq *elsiocb; 1304 struct lpfc_sli_ring *pring; 1305 struct lpfc_sli *psli; 1306 uint8_t *pcmd; 1307 uint16_t cmdsize; 1308 struct lpfc_nodelist *ndlp; 1309 1310 psli = &phba->sli; 1311 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1312 cmdsize = (sizeof (uint32_t) + sizeof (SCR)); 1313 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) == 0) { 1314 return (1); 1315 } 1316 1317 lpfc_nlp_init(phba, ndlp, nportid); 1318 1319 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 1320 ndlp, ELS_CMD_SCR)) == 0) { 1321 mempool_free( ndlp, phba->nlp_mem_pool); 1322 return (1); 1323 } 1324 1325 icmd = &elsiocb->iocb; 1326 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1327 1328 *((uint32_t *) (pcmd)) = ELS_CMD_SCR; 1329 pcmd += sizeof (uint32_t); 1330 1331 /* For SCR, remainder of payload is SCR parameter page */ 1332 memset(pcmd, 0, sizeof (SCR)); 1333 ((SCR *) pcmd)->Function = SCR_FUNC_FULL; 1334 1335 phba->fc_stat.elsXmitSCR++; 1336 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 1337 spin_lock_irq(phba->host->host_lock); 1338 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1339 spin_unlock_irq(phba->host->host_lock); 1340 mempool_free( ndlp, phba->nlp_mem_pool); 1341 lpfc_els_free_iocb(phba, elsiocb); 1342 return (1); 1343 } 1344 spin_unlock_irq(phba->host->host_lock); 1345 mempool_free( ndlp, phba->nlp_mem_pool); 1346 return (0); 1347 } 1348 1349 static int 1350 lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry) 1351 { 1352 IOCB_t *icmd; 1353 struct lpfc_iocbq *elsiocb; 1354 struct lpfc_sli_ring *pring; 1355 struct lpfc_sli *psli; 1356 FARP *fp; 1357 uint8_t *pcmd; 1358 uint32_t *lp; 1359 uint16_t cmdsize; 1360 struct lpfc_nodelist *ondlp; 1361 struct lpfc_nodelist *ndlp; 1362 1363 psli = &phba->sli; 1364 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1365 cmdsize = (sizeof (uint32_t) + sizeof (FARP)); 1366 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) == 0) { 1367 return (1); 1368 } 1369 lpfc_nlp_init(phba, ndlp, nportid); 1370 1371 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, 1372 ndlp, ELS_CMD_RNID)) == 0) { 1373 mempool_free( ndlp, phba->nlp_mem_pool); 1374 return (1); 1375 } 1376 1377 icmd = &elsiocb->iocb; 1378 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1379 1380 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR; 1381 pcmd += sizeof (uint32_t); 1382 1383 /* Fill in FARPR payload */ 1384 fp = (FARP *) (pcmd); 1385 memset(fp, 0, sizeof (FARP)); 1386 lp = (uint32_t *) pcmd; 1387 *lp++ = be32_to_cpu(nportid); 1388 *lp++ = be32_to_cpu(phba->fc_myDID); 1389 fp->Rflags = 0; 1390 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE); 1391 1392 memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name)); 1393 memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 1394 if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) { 1395 memcpy(&fp->OportName, &ondlp->nlp_portname, 1396 sizeof (struct lpfc_name)); 1397 memcpy(&fp->OnodeName, &ondlp->nlp_nodename, 1398 sizeof (struct lpfc_name)); 1399 } 1400 1401 phba->fc_stat.elsXmitFARPR++; 1402 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 1403 spin_lock_irq(phba->host->host_lock); 1404 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1405 spin_unlock_irq(phba->host->host_lock); 1406 mempool_free( ndlp, phba->nlp_mem_pool); 1407 lpfc_els_free_iocb(phba, elsiocb); 1408 return (1); 1409 } 1410 spin_unlock_irq(phba->host->host_lock); 1411 mempool_free( ndlp, phba->nlp_mem_pool); 1412 return (0); 1413 } 1414 1415 void 1416 lpfc_els_retry_delay(unsigned long ptr) 1417 { 1418 struct lpfc_nodelist *ndlp; 1419 struct lpfc_hba *phba; 1420 unsigned long iflag; 1421 struct lpfc_work_evt *evtp; 1422 1423 ndlp = (struct lpfc_nodelist *)ptr; 1424 phba = ndlp->nlp_phba; 1425 evtp = &ndlp->els_retry_evt; 1426 1427 spin_lock_irqsave(phba->host->host_lock, iflag); 1428 if (!list_empty(&evtp->evt_listp)) { 1429 spin_unlock_irqrestore(phba->host->host_lock, iflag); 1430 return; 1431 } 1432 1433 evtp->evt_arg1 = ndlp; 1434 evtp->evt = LPFC_EVT_ELS_RETRY; 1435 list_add_tail(&evtp->evt_listp, &phba->work_list); 1436 if (phba->work_wait) 1437 wake_up(phba->work_wait); 1438 1439 spin_unlock_irqrestore(phba->host->host_lock, iflag); 1440 return; 1441 } 1442 1443 void 1444 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp) 1445 { 1446 struct lpfc_hba *phba; 1447 uint32_t cmd; 1448 uint32_t did; 1449 uint8_t retry; 1450 1451 phba = ndlp->nlp_phba; 1452 spin_lock_irq(phba->host->host_lock); 1453 did = (uint32_t) (ndlp->nlp_DID); 1454 cmd = (uint32_t) (ndlp->nlp_last_elscmd); 1455 1456 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) { 1457 spin_unlock_irq(phba->host->host_lock); 1458 return; 1459 } 1460 1461 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 1462 spin_unlock_irq(phba->host->host_lock); 1463 retry = ndlp->nlp_retry; 1464 1465 switch (cmd) { 1466 case ELS_CMD_FLOGI: 1467 lpfc_issue_els_flogi(phba, ndlp, retry); 1468 break; 1469 case ELS_CMD_PLOGI: 1470 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 1471 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 1472 lpfc_issue_els_plogi(phba, ndlp, retry); 1473 break; 1474 case ELS_CMD_ADISC: 1475 ndlp->nlp_state = NLP_STE_ADISC_ISSUE; 1476 lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST); 1477 lpfc_issue_els_adisc(phba, ndlp, retry); 1478 break; 1479 case ELS_CMD_PRLI: 1480 ndlp->nlp_state = NLP_STE_PRLI_ISSUE; 1481 lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST); 1482 lpfc_issue_els_prli(phba, ndlp, retry); 1483 break; 1484 case ELS_CMD_LOGO: 1485 ndlp->nlp_state = NLP_STE_NPR_NODE; 1486 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1487 lpfc_issue_els_logo(phba, ndlp, retry); 1488 break; 1489 } 1490 return; 1491 } 1492 1493 static int 1494 lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1495 struct lpfc_iocbq * rspiocb) 1496 { 1497 IOCB_t *irsp; 1498 struct lpfc_dmabuf *pcmd; 1499 struct lpfc_nodelist *ndlp; 1500 uint32_t *elscmd; 1501 struct ls_rjt stat; 1502 int retry, maxretry; 1503 int delay; 1504 uint32_t cmd; 1505 1506 retry = 0; 1507 delay = 0; 1508 maxretry = lpfc_max_els_tries; 1509 irsp = &rspiocb->iocb; 1510 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1511 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 1512 cmd = 0; 1513 /* Note: context2 may be 0 for internal driver abort 1514 * of delays ELS command. 1515 */ 1516 1517 if (pcmd && pcmd->virt) { 1518 elscmd = (uint32_t *) (pcmd->virt); 1519 cmd = *elscmd++; 1520 } 1521 1522 switch (irsp->ulpStatus) { 1523 case IOSTAT_FCP_RSP_ERROR: 1524 case IOSTAT_REMOTE_STOP: 1525 break; 1526 1527 case IOSTAT_LOCAL_REJECT: 1528 switch ((irsp->un.ulpWord[4] & 0xff)) { 1529 case IOERR_LOOP_OPEN_FAILURE: 1530 if (cmd == ELS_CMD_PLOGI) { 1531 if (cmdiocb->retry == 0) { 1532 delay = 1; 1533 } 1534 } 1535 retry = 1; 1536 break; 1537 1538 case IOERR_SEQUENCE_TIMEOUT: 1539 retry = 1; 1540 if ((cmd == ELS_CMD_FLOGI) 1541 && (phba->fc_topology != TOPOLOGY_LOOP)) { 1542 delay = 1; 1543 maxretry = 48; 1544 } 1545 break; 1546 1547 case IOERR_NO_RESOURCES: 1548 if (cmd == ELS_CMD_PLOGI) { 1549 delay = 1; 1550 } 1551 retry = 1; 1552 break; 1553 1554 case IOERR_INVALID_RPI: 1555 retry = 1; 1556 break; 1557 } 1558 break; 1559 1560 case IOSTAT_NPORT_RJT: 1561 case IOSTAT_FABRIC_RJT: 1562 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) { 1563 retry = 1; 1564 break; 1565 } 1566 break; 1567 1568 case IOSTAT_NPORT_BSY: 1569 case IOSTAT_FABRIC_BSY: 1570 retry = 1; 1571 break; 1572 1573 case IOSTAT_LS_RJT: 1574 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]); 1575 /* Added for Vendor specifc support 1576 * Just keep retrying for these Rsn / Exp codes 1577 */ 1578 switch (stat.un.b.lsRjtRsnCode) { 1579 case LSRJT_UNABLE_TPC: 1580 if (stat.un.b.lsRjtRsnCodeExp == 1581 LSEXP_CMD_IN_PROGRESS) { 1582 if (cmd == ELS_CMD_PLOGI) { 1583 delay = 1; 1584 maxretry = 48; 1585 } 1586 retry = 1; 1587 break; 1588 } 1589 if (cmd == ELS_CMD_PLOGI) { 1590 delay = 1; 1591 maxretry = lpfc_max_els_tries + 1; 1592 retry = 1; 1593 break; 1594 } 1595 break; 1596 1597 case LSRJT_LOGICAL_BSY: 1598 if (cmd == ELS_CMD_PLOGI) { 1599 delay = 1; 1600 maxretry = 48; 1601 } 1602 retry = 1; 1603 break; 1604 } 1605 break; 1606 1607 case IOSTAT_INTERMED_RSP: 1608 case IOSTAT_BA_RJT: 1609 break; 1610 1611 default: 1612 break; 1613 } 1614 1615 if (ndlp->nlp_DID == FDMI_DID) { 1616 retry = 1; 1617 } 1618 1619 if ((++cmdiocb->retry) >= maxretry) { 1620 phba->fc_stat.elsRetryExceeded++; 1621 retry = 0; 1622 } 1623 1624 if (retry) { 1625 1626 /* Retry ELS command <elsCmd> to remote NPORT <did> */ 1627 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1628 "%d:0107 Retry ELS command x%x to remote " 1629 "NPORT x%x Data: x%x x%x\n", 1630 phba->brd_no, 1631 cmd, ndlp->nlp_DID, cmdiocb->retry, delay); 1632 1633 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) { 1634 /* If discovery / RSCN timer is running, reset it */ 1635 if (timer_pending(&phba->fc_disctmo) || 1636 (phba->fc_flag & FC_RSCN_MODE)) { 1637 lpfc_set_disctmo(phba); 1638 } 1639 } 1640 1641 phba->fc_stat.elsXmitRetry++; 1642 if (delay) { 1643 phba->fc_stat.elsDelayRetry++; 1644 ndlp->nlp_retry = cmdiocb->retry; 1645 1646 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ); 1647 ndlp->nlp_flag |= NLP_DELAY_TMO; 1648 1649 ndlp->nlp_state = NLP_STE_NPR_NODE; 1650 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1651 ndlp->nlp_last_elscmd = cmd; 1652 1653 return (1); 1654 } 1655 switch (cmd) { 1656 case ELS_CMD_FLOGI: 1657 lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry); 1658 return (1); 1659 case ELS_CMD_PLOGI: 1660 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 1661 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 1662 lpfc_issue_els_plogi(phba, ndlp, cmdiocb->retry); 1663 return (1); 1664 case ELS_CMD_ADISC: 1665 ndlp->nlp_state = NLP_STE_ADISC_ISSUE; 1666 lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST); 1667 lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry); 1668 return (1); 1669 case ELS_CMD_PRLI: 1670 ndlp->nlp_state = NLP_STE_PRLI_ISSUE; 1671 lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST); 1672 lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry); 1673 return (1); 1674 case ELS_CMD_LOGO: 1675 ndlp->nlp_state = NLP_STE_NPR_NODE; 1676 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1677 lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry); 1678 return (1); 1679 } 1680 } 1681 1682 /* No retry ELS command <elsCmd> to remote NPORT <did> */ 1683 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1684 "%d:0108 No retry ELS command x%x to remote NPORT x%x " 1685 "Data: x%x x%x\n", 1686 phba->brd_no, 1687 cmd, ndlp->nlp_DID, cmdiocb->retry, ndlp->nlp_flag); 1688 1689 return (0); 1690 } 1691 1692 int 1693 lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb) 1694 { 1695 struct lpfc_dmabuf *buf_ptr, *buf_ptr1; 1696 1697 /* context2 = cmd, context2->next = rsp, context3 = bpl */ 1698 if (elsiocb->context2) { 1699 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2; 1700 /* Free the response before processing the command. */ 1701 if (!list_empty(&buf_ptr1->list)) { 1702 list_remove_head(&buf_ptr1->list, buf_ptr, 1703 struct lpfc_dmabuf, 1704 list); 1705 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 1706 kfree(buf_ptr); 1707 } 1708 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys); 1709 kfree(buf_ptr1); 1710 } 1711 1712 if (elsiocb->context3) { 1713 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3; 1714 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 1715 kfree(buf_ptr); 1716 } 1717 spin_lock_irq(phba->host->host_lock); 1718 lpfc_sli_release_iocbq(phba, elsiocb); 1719 spin_unlock_irq(phba->host->host_lock); 1720 return 0; 1721 } 1722 1723 static void 1724 lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1725 struct lpfc_iocbq * rspiocb) 1726 { 1727 struct lpfc_nodelist *ndlp; 1728 1729 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1730 1731 /* ACC to LOGO completes to NPort <nlp_DID> */ 1732 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1733 "%d:0109 ACC to LOGO completes to NPort x%x " 1734 "Data: x%x x%x x%x\n", 1735 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag, 1736 ndlp->nlp_state, ndlp->nlp_rpi); 1737 1738 spin_lock_irq(phba->host->host_lock); 1739 ndlp->nlp_flag &= ~NLP_LOGO_ACC; 1740 spin_unlock_irq(phba->host->host_lock); 1741 1742 switch (ndlp->nlp_state) { 1743 case NLP_STE_UNUSED_NODE: /* node is just allocated */ 1744 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 1745 break; 1746 case NLP_STE_NPR_NODE: /* NPort Recovery mode */ 1747 lpfc_unreg_rpi(phba, ndlp); 1748 break; 1749 default: 1750 break; 1751 } 1752 lpfc_els_free_iocb(phba, cmdiocb); 1753 return; 1754 } 1755 1756 static void 1757 lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1758 struct lpfc_iocbq * rspiocb) 1759 { 1760 struct lpfc_nodelist *ndlp; 1761 LPFC_MBOXQ_t *mbox = NULL; 1762 1763 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1764 if (cmdiocb->context_un.mbox) 1765 mbox = cmdiocb->context_un.mbox; 1766 1767 1768 /* Check to see if link went down during discovery */ 1769 if ((lpfc_els_chk_latt(phba)) || !ndlp) { 1770 if (mbox) { 1771 mempool_free( mbox, phba->mbox_mem_pool); 1772 } 1773 goto out; 1774 } 1775 1776 /* ELS response tag <ulpIoTag> completes */ 1777 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1778 "%d:0110 ELS response tag x%x completes " 1779 "Data: x%x x%x x%x x%x x%x x%x\n", 1780 phba->brd_no, 1781 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus, 1782 rspiocb->iocb.un.ulpWord[4], ndlp->nlp_DID, 1783 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 1784 1785 if (mbox) { 1786 if ((rspiocb->iocb.ulpStatus == 0) 1787 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) { 1788 /* set_slim mailbox command needs to execute first, 1789 * queue this command to be processed later. 1790 */ 1791 lpfc_unreg_rpi(phba, ndlp); 1792 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login; 1793 mbox->context2 = ndlp; 1794 ndlp->nlp_state = NLP_STE_REG_LOGIN_ISSUE; 1795 lpfc_nlp_list(phba, ndlp, NLP_REGLOGIN_LIST); 1796 if (lpfc_sli_issue_mbox(phba, mbox, 1797 (MBX_NOWAIT | MBX_STOP_IOCB)) 1798 != MBX_NOT_FINISHED) { 1799 goto out; 1800 } 1801 /* NOTE: we should have messages for unsuccessful 1802 reglogin */ 1803 mempool_free( mbox, phba->mbox_mem_pool); 1804 } else { 1805 mempool_free( mbox, phba->mbox_mem_pool); 1806 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) { 1807 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 1808 } 1809 } 1810 } 1811 out: 1812 if (ndlp) { 1813 spin_lock_irq(phba->host->host_lock); 1814 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN; 1815 spin_unlock_irq(phba->host->host_lock); 1816 } 1817 lpfc_els_free_iocb(phba, cmdiocb); 1818 return; 1819 } 1820 1821 int 1822 lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag, 1823 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp, 1824 LPFC_MBOXQ_t * mbox, uint8_t newnode) 1825 { 1826 IOCB_t *icmd; 1827 IOCB_t *oldcmd; 1828 struct lpfc_iocbq *elsiocb; 1829 struct lpfc_sli_ring *pring; 1830 struct lpfc_sli *psli; 1831 uint8_t *pcmd; 1832 uint16_t cmdsize; 1833 int rc; 1834 1835 psli = &phba->sli; 1836 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1837 oldcmd = &oldiocb->iocb; 1838 1839 switch (flag) { 1840 case ELS_CMD_ACC: 1841 cmdsize = sizeof (uint32_t); 1842 if ((elsiocb = 1843 lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1844 ndlp, ELS_CMD_ACC)) == 0) { 1845 return (1); 1846 } 1847 icmd = &elsiocb->iocb; 1848 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 1849 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1850 *((uint32_t *) (pcmd)) = ELS_CMD_ACC; 1851 pcmd += sizeof (uint32_t); 1852 break; 1853 case ELS_CMD_PLOGI: 1854 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t)); 1855 if ((elsiocb = 1856 lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1857 ndlp, ELS_CMD_ACC)) == 0) { 1858 return (1); 1859 } 1860 icmd = &elsiocb->iocb; 1861 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 1862 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1863 1864 if (mbox) 1865 elsiocb->context_un.mbox = mbox; 1866 1867 *((uint32_t *) (pcmd)) = ELS_CMD_ACC; 1868 pcmd += sizeof (uint32_t); 1869 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 1870 break; 1871 default: 1872 return (1); 1873 } 1874 1875 if (newnode) 1876 elsiocb->context1 = NULL; 1877 1878 /* Xmit ELS ACC response tag <ulpIoTag> */ 1879 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1880 "%d:0128 Xmit ELS ACC response tag x%x " 1881 "Data: x%x x%x x%x x%x x%x\n", 1882 phba->brd_no, 1883 elsiocb->iocb.ulpIoTag, 1884 elsiocb->iocb.ulpContext, ndlp->nlp_DID, 1885 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 1886 1887 if (ndlp->nlp_flag & NLP_LOGO_ACC) { 1888 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc; 1889 } else { 1890 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 1891 } 1892 1893 phba->fc_stat.elsXmitACC++; 1894 spin_lock_irq(phba->host->host_lock); 1895 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 1896 spin_unlock_irq(phba->host->host_lock); 1897 if (rc == IOCB_ERROR) { 1898 lpfc_els_free_iocb(phba, elsiocb); 1899 return (1); 1900 } 1901 return (0); 1902 } 1903 1904 int 1905 lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError, 1906 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 1907 { 1908 IOCB_t *icmd; 1909 IOCB_t *oldcmd; 1910 struct lpfc_iocbq *elsiocb; 1911 struct lpfc_sli_ring *pring; 1912 struct lpfc_sli *psli; 1913 uint8_t *pcmd; 1914 uint16_t cmdsize; 1915 int rc; 1916 1917 psli = &phba->sli; 1918 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1919 1920 cmdsize = 2 * sizeof (uint32_t); 1921 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1922 ndlp, ELS_CMD_LS_RJT)) == 0) { 1923 return (1); 1924 } 1925 1926 icmd = &elsiocb->iocb; 1927 oldcmd = &oldiocb->iocb; 1928 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 1929 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1930 1931 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT; 1932 pcmd += sizeof (uint32_t); 1933 *((uint32_t *) (pcmd)) = rejectError; 1934 1935 /* Xmit ELS RJT <err> response tag <ulpIoTag> */ 1936 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1937 "%d:0129 Xmit ELS RJT x%x response tag x%x " 1938 "Data: x%x x%x x%x x%x x%x\n", 1939 phba->brd_no, 1940 rejectError, elsiocb->iocb.ulpIoTag, 1941 elsiocb->iocb.ulpContext, ndlp->nlp_DID, 1942 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 1943 1944 phba->fc_stat.elsXmitLSRJT++; 1945 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 1946 spin_lock_irq(phba->host->host_lock); 1947 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 1948 spin_unlock_irq(phba->host->host_lock); 1949 if (rc == IOCB_ERROR) { 1950 lpfc_els_free_iocb(phba, elsiocb); 1951 return (1); 1952 } 1953 return (0); 1954 } 1955 1956 int 1957 lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba, 1958 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 1959 { 1960 ADISC *ap; 1961 IOCB_t *icmd; 1962 IOCB_t *oldcmd; 1963 struct lpfc_iocbq *elsiocb; 1964 struct lpfc_sli_ring *pring; 1965 struct lpfc_sli *psli; 1966 uint8_t *pcmd; 1967 uint16_t cmdsize; 1968 int rc; 1969 1970 psli = &phba->sli; 1971 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 1972 1973 cmdsize = sizeof (uint32_t) + sizeof (ADISC); 1974 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1975 ndlp, ELS_CMD_ACC)) == 0) { 1976 return (1); 1977 } 1978 1979 /* Xmit ADISC ACC response tag <ulpIoTag> */ 1980 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1981 "%d:0130 Xmit ADISC ACC response tag x%x " 1982 "Data: x%x x%x x%x x%x x%x\n", 1983 phba->brd_no, 1984 elsiocb->iocb.ulpIoTag, 1985 elsiocb->iocb.ulpContext, ndlp->nlp_DID, 1986 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 1987 1988 icmd = &elsiocb->iocb; 1989 oldcmd = &oldiocb->iocb; 1990 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 1991 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1992 1993 *((uint32_t *) (pcmd)) = ELS_CMD_ACC; 1994 pcmd += sizeof (uint32_t); 1995 1996 ap = (ADISC *) (pcmd); 1997 ap->hardAL_PA = phba->fc_pref_ALPA; 1998 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 1999 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 2000 ap->DID = be32_to_cpu(phba->fc_myDID); 2001 2002 phba->fc_stat.elsXmitACC++; 2003 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2004 spin_lock_irq(phba->host->host_lock); 2005 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2006 spin_unlock_irq(phba->host->host_lock); 2007 if (rc == IOCB_ERROR) { 2008 lpfc_els_free_iocb(phba, elsiocb); 2009 return (1); 2010 } 2011 return (0); 2012 } 2013 2014 int 2015 lpfc_els_rsp_prli_acc(struct lpfc_hba * phba, 2016 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 2017 { 2018 PRLI *npr; 2019 lpfc_vpd_t *vpd; 2020 IOCB_t *icmd; 2021 IOCB_t *oldcmd; 2022 struct lpfc_iocbq *elsiocb; 2023 struct lpfc_sli_ring *pring; 2024 struct lpfc_sli *psli; 2025 uint8_t *pcmd; 2026 uint16_t cmdsize; 2027 int rc; 2028 2029 psli = &phba->sli; 2030 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 2031 2032 cmdsize = sizeof (uint32_t) + sizeof (PRLI); 2033 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 2034 ndlp, 2035 (ELS_CMD_ACC | 2036 (ELS_CMD_PRLI & ~ELS_RSP_MASK)))) == 2037 0) { 2038 return (1); 2039 } 2040 2041 /* Xmit PRLI ACC response tag <ulpIoTag> */ 2042 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 2043 "%d:0131 Xmit PRLI ACC response tag x%x " 2044 "Data: x%x x%x x%x x%x x%x\n", 2045 phba->brd_no, 2046 elsiocb->iocb.ulpIoTag, 2047 elsiocb->iocb.ulpContext, ndlp->nlp_DID, 2048 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 2049 2050 icmd = &elsiocb->iocb; 2051 oldcmd = &oldiocb->iocb; 2052 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 2053 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 2054 2055 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)); 2056 pcmd += sizeof (uint32_t); 2057 2058 /* For PRLI, remainder of payload is PRLI parameter page */ 2059 memset(pcmd, 0, sizeof (PRLI)); 2060 2061 npr = (PRLI *) pcmd; 2062 vpd = &phba->vpd; 2063 /* 2064 * If our firmware version is 3.20 or later, 2065 * set the following bits for FC-TAPE support. 2066 */ 2067 if (vpd->rev.feaLevelHigh >= 0x02) { 2068 npr->ConfmComplAllowed = 1; 2069 npr->Retry = 1; 2070 npr->TaskRetryIdReq = 1; 2071 } 2072 2073 npr->acceptRspCode = PRLI_REQ_EXECUTED; 2074 npr->estabImagePair = 1; 2075 npr->readXferRdyDis = 1; 2076 npr->ConfmComplAllowed = 1; 2077 2078 npr->prliType = PRLI_FCP_TYPE; 2079 npr->initiatorFunc = 1; 2080 2081 phba->fc_stat.elsXmitACC++; 2082 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2083 2084 spin_lock_irq(phba->host->host_lock); 2085 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2086 spin_unlock_irq(phba->host->host_lock); 2087 if (rc == IOCB_ERROR) { 2088 lpfc_els_free_iocb(phba, elsiocb); 2089 return (1); 2090 } 2091 return (0); 2092 } 2093 2094 static int 2095 lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba, 2096 uint8_t format, 2097 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 2098 { 2099 RNID *rn; 2100 IOCB_t *icmd; 2101 IOCB_t *oldcmd; 2102 struct lpfc_iocbq *elsiocb; 2103 struct lpfc_sli_ring *pring; 2104 struct lpfc_sli *psli; 2105 uint8_t *pcmd; 2106 uint16_t cmdsize; 2107 int rc; 2108 2109 psli = &phba->sli; 2110 pring = &psli->ring[LPFC_ELS_RING]; 2111 2112 cmdsize = sizeof (uint32_t) + sizeof (uint32_t) 2113 + (2 * sizeof (struct lpfc_name)); 2114 if (format) 2115 cmdsize += sizeof (RNID_TOP_DISC); 2116 2117 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 2118 ndlp, ELS_CMD_ACC)) == 0) { 2119 return (1); 2120 } 2121 2122 /* Xmit RNID ACC response tag <ulpIoTag> */ 2123 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 2124 "%d:0132 Xmit RNID ACC response tag x%x " 2125 "Data: x%x\n", 2126 phba->brd_no, 2127 elsiocb->iocb.ulpIoTag, 2128 elsiocb->iocb.ulpContext); 2129 2130 icmd = &elsiocb->iocb; 2131 oldcmd = &oldiocb->iocb; 2132 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 2133 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 2134 2135 *((uint32_t *) (pcmd)) = ELS_CMD_ACC; 2136 pcmd += sizeof (uint32_t); 2137 2138 memset(pcmd, 0, sizeof (RNID)); 2139 rn = (RNID *) (pcmd); 2140 rn->Format = format; 2141 rn->CommonLen = (2 * sizeof (struct lpfc_name)); 2142 memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 2143 memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 2144 switch (format) { 2145 case 0: 2146 rn->SpecificLen = 0; 2147 break; 2148 case RNID_TOPOLOGY_DISC: 2149 rn->SpecificLen = sizeof (RNID_TOP_DISC); 2150 memcpy(&rn->un.topologyDisc.portName, 2151 &phba->fc_portname, sizeof (struct lpfc_name)); 2152 rn->un.topologyDisc.unitType = RNID_HBA; 2153 rn->un.topologyDisc.physPort = 0; 2154 rn->un.topologyDisc.attachedNodes = 0; 2155 break; 2156 default: 2157 rn->CommonLen = 0; 2158 rn->SpecificLen = 0; 2159 break; 2160 } 2161 2162 phba->fc_stat.elsXmitACC++; 2163 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2164 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl, 2165 * it could be freed */ 2166 2167 spin_lock_irq(phba->host->host_lock); 2168 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2169 spin_unlock_irq(phba->host->host_lock); 2170 if (rc == IOCB_ERROR) { 2171 lpfc_els_free_iocb(phba, elsiocb); 2172 return (1); 2173 } 2174 return (0); 2175 } 2176 2177 int 2178 lpfc_els_disc_adisc(struct lpfc_hba * phba) 2179 { 2180 int sentadisc; 2181 struct lpfc_nodelist *ndlp, *next_ndlp; 2182 2183 sentadisc = 0; 2184 /* go thru NPR list and issue any remaining ELS ADISCs */ 2185 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 2186 nlp_listp) { 2187 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 2188 if (ndlp->nlp_flag & NLP_NPR_ADISC) { 2189 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2190 ndlp->nlp_state = NLP_STE_ADISC_ISSUE; 2191 lpfc_nlp_list(phba, ndlp, 2192 NLP_ADISC_LIST); 2193 lpfc_issue_els_adisc(phba, ndlp, 0); 2194 sentadisc++; 2195 phba->num_disc_nodes++; 2196 if (phba->num_disc_nodes >= 2197 phba->cfg_discovery_threads) { 2198 spin_lock_irq(phba->host->host_lock); 2199 phba->fc_flag |= FC_NLP_MORE; 2200 spin_unlock_irq(phba->host->host_lock); 2201 break; 2202 } 2203 } 2204 } 2205 } 2206 if (sentadisc == 0) { 2207 spin_lock_irq(phba->host->host_lock); 2208 phba->fc_flag &= ~FC_NLP_MORE; 2209 spin_unlock_irq(phba->host->host_lock); 2210 } 2211 return(sentadisc); 2212 } 2213 2214 int 2215 lpfc_els_disc_plogi(struct lpfc_hba * phba) 2216 { 2217 int sentplogi; 2218 struct lpfc_nodelist *ndlp, *next_ndlp; 2219 2220 sentplogi = 0; 2221 /* go thru NPR list and issue any remaining ELS PLOGIs */ 2222 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 2223 nlp_listp) { 2224 if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) && 2225 (!(ndlp->nlp_flag & NLP_DELAY_TMO))) { 2226 if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) { 2227 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 2228 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 2229 lpfc_issue_els_plogi(phba, ndlp, 0); 2230 sentplogi++; 2231 phba->num_disc_nodes++; 2232 if (phba->num_disc_nodes >= 2233 phba->cfg_discovery_threads) { 2234 spin_lock_irq(phba->host->host_lock); 2235 phba->fc_flag |= FC_NLP_MORE; 2236 spin_unlock_irq(phba->host->host_lock); 2237 break; 2238 } 2239 } 2240 } 2241 } 2242 if (sentplogi == 0) { 2243 spin_lock_irq(phba->host->host_lock); 2244 phba->fc_flag &= ~FC_NLP_MORE; 2245 spin_unlock_irq(phba->host->host_lock); 2246 } 2247 return(sentplogi); 2248 } 2249 2250 int 2251 lpfc_els_flush_rscn(struct lpfc_hba * phba) 2252 { 2253 struct lpfc_dmabuf *mp; 2254 int i; 2255 2256 for (i = 0; i < phba->fc_rscn_id_cnt; i++) { 2257 mp = phba->fc_rscn_id_list[i]; 2258 lpfc_mbuf_free(phba, mp->virt, mp->phys); 2259 kfree(mp); 2260 phba->fc_rscn_id_list[i] = NULL; 2261 } 2262 phba->fc_rscn_id_cnt = 0; 2263 spin_lock_irq(phba->host->host_lock); 2264 phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY); 2265 spin_unlock_irq(phba->host->host_lock); 2266 lpfc_can_disctmo(phba); 2267 return (0); 2268 } 2269 2270 int 2271 lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did) 2272 { 2273 D_ID ns_did; 2274 D_ID rscn_did; 2275 struct lpfc_dmabuf *mp; 2276 uint32_t *lp; 2277 uint32_t payload_len, cmd, i, match; 2278 2279 ns_did.un.word = did; 2280 match = 0; 2281 2282 /* Never match fabric nodes for RSCNs */ 2283 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) 2284 return(0); 2285 2286 /* If we are doing a FULL RSCN rediscovery, match everything */ 2287 if (phba->fc_flag & FC_RSCN_DISCOVERY) { 2288 return (did); 2289 } 2290 2291 for (i = 0; i < phba->fc_rscn_id_cnt; i++) { 2292 mp = phba->fc_rscn_id_list[i]; 2293 lp = (uint32_t *) mp->virt; 2294 cmd = *lp++; 2295 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */ 2296 payload_len -= sizeof (uint32_t); /* take off word 0 */ 2297 while (payload_len) { 2298 rscn_did.un.word = *lp++; 2299 rscn_did.un.word = be32_to_cpu(rscn_did.un.word); 2300 payload_len -= sizeof (uint32_t); 2301 switch (rscn_did.un.b.resv) { 2302 case 0: /* Single N_Port ID effected */ 2303 if (ns_did.un.word == rscn_did.un.word) { 2304 match = did; 2305 } 2306 break; 2307 case 1: /* Whole N_Port Area effected */ 2308 if ((ns_did.un.b.domain == rscn_did.un.b.domain) 2309 && (ns_did.un.b.area == rscn_did.un.b.area)) 2310 { 2311 match = did; 2312 } 2313 break; 2314 case 2: /* Whole N_Port Domain effected */ 2315 if (ns_did.un.b.domain == rscn_did.un.b.domain) 2316 { 2317 match = did; 2318 } 2319 break; 2320 case 3: /* Whole Fabric effected */ 2321 match = did; 2322 break; 2323 default: 2324 /* Unknown Identifier in RSCN list */ 2325 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2326 "%d:0217 Unknown Identifier in " 2327 "RSCN payload Data: x%x\n", 2328 phba->brd_no, rscn_did.un.word); 2329 break; 2330 } 2331 if (match) { 2332 break; 2333 } 2334 } 2335 } 2336 return (match); 2337 } 2338 2339 static int 2340 lpfc_rscn_recovery_check(struct lpfc_hba * phba) 2341 { 2342 struct lpfc_nodelist *ndlp = NULL, *next_ndlp; 2343 struct list_head *listp; 2344 struct list_head *node_list[7]; 2345 int i; 2346 2347 /* Look at all nodes effected by pending RSCNs and move 2348 * them to NPR list. 2349 */ 2350 node_list[0] = &phba->fc_npr_list; /* MUST do this list first */ 2351 node_list[1] = &phba->fc_nlpmap_list; 2352 node_list[2] = &phba->fc_nlpunmap_list; 2353 node_list[3] = &phba->fc_prli_list; 2354 node_list[4] = &phba->fc_reglogin_list; 2355 node_list[5] = &phba->fc_adisc_list; 2356 node_list[6] = &phba->fc_plogi_list; 2357 for (i = 0; i < 7; i++) { 2358 listp = node_list[i]; 2359 if (list_empty(listp)) 2360 continue; 2361 2362 list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) { 2363 if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID))) 2364 continue; 2365 2366 lpfc_disc_state_machine(phba, ndlp, NULL, 2367 NLP_EVT_DEVICE_RECOVERY); 2368 if (ndlp->nlp_flag & NLP_DELAY_TMO) { 2369 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 2370 del_timer_sync(&ndlp->nlp_delayfunc); 2371 if (!list_empty(&ndlp-> 2372 els_retry_evt.evt_listp)) 2373 list_del_init(&ndlp-> 2374 els_retry_evt.evt_listp); 2375 } 2376 } 2377 } 2378 return (0); 2379 } 2380 2381 static int 2382 lpfc_els_rcv_rscn(struct lpfc_hba * phba, 2383 struct lpfc_iocbq * cmdiocb, 2384 struct lpfc_nodelist * ndlp, uint8_t newnode) 2385 { 2386 struct lpfc_dmabuf *pcmd; 2387 uint32_t *lp; 2388 IOCB_t *icmd; 2389 uint32_t payload_len, cmd; 2390 2391 icmd = &cmdiocb->iocb; 2392 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2393 lp = (uint32_t *) pcmd->virt; 2394 2395 cmd = *lp++; 2396 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */ 2397 payload_len -= sizeof (uint32_t); /* take off word 0 */ 2398 cmd &= ELS_CMD_MASK; 2399 2400 /* RSCN received */ 2401 lpfc_printf_log(phba, 2402 KERN_INFO, 2403 LOG_DISCOVERY, 2404 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n", 2405 phba->brd_no, 2406 phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt); 2407 2408 /* If we are about to begin discovery, just ACC the RSCN. 2409 * Discovery processing will satisfy it. 2410 */ 2411 if (phba->hba_state < LPFC_NS_QRY) { 2412 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 2413 newnode); 2414 return (0); 2415 } 2416 2417 /* If we are already processing an RSCN, save the received 2418 * RSCN payload buffer, cmdiocb->context2 to process later. 2419 */ 2420 if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) { 2421 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) && 2422 !(phba->fc_flag & FC_RSCN_DISCOVERY)) { 2423 spin_lock_irq(phba->host->host_lock); 2424 phba->fc_flag |= FC_RSCN_MODE; 2425 spin_unlock_irq(phba->host->host_lock); 2426 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd; 2427 2428 /* If we zero, cmdiocb->context2, the calling 2429 * routine will not try to free it. 2430 */ 2431 cmdiocb->context2 = NULL; 2432 2433 /* Deferred RSCN */ 2434 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 2435 "%d:0235 Deferred RSCN " 2436 "Data: x%x x%x x%x\n", 2437 phba->brd_no, phba->fc_rscn_id_cnt, 2438 phba->fc_flag, phba->hba_state); 2439 } else { 2440 spin_lock_irq(phba->host->host_lock); 2441 phba->fc_flag |= FC_RSCN_DISCOVERY; 2442 spin_unlock_irq(phba->host->host_lock); 2443 /* ReDiscovery RSCN */ 2444 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 2445 "%d:0234 ReDiscovery RSCN " 2446 "Data: x%x x%x x%x\n", 2447 phba->brd_no, phba->fc_rscn_id_cnt, 2448 phba->fc_flag, phba->hba_state); 2449 } 2450 /* Send back ACC */ 2451 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 2452 newnode); 2453 2454 /* send RECOVERY event for ALL nodes that match RSCN payload */ 2455 lpfc_rscn_recovery_check(phba); 2456 return (0); 2457 } 2458 2459 phba->fc_flag |= FC_RSCN_MODE; 2460 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd; 2461 /* 2462 * If we zero, cmdiocb->context2, the calling routine will 2463 * not try to free it. 2464 */ 2465 cmdiocb->context2 = NULL; 2466 2467 lpfc_set_disctmo(phba); 2468 2469 /* Send back ACC */ 2470 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode); 2471 2472 /* send RECOVERY event for ALL nodes that match RSCN payload */ 2473 lpfc_rscn_recovery_check(phba); 2474 2475 return (lpfc_els_handle_rscn(phba)); 2476 } 2477 2478 int 2479 lpfc_els_handle_rscn(struct lpfc_hba * phba) 2480 { 2481 struct lpfc_nodelist *ndlp; 2482 2483 /* Start timer for RSCN processing */ 2484 lpfc_set_disctmo(phba); 2485 2486 /* RSCN processed */ 2487 lpfc_printf_log(phba, 2488 KERN_INFO, 2489 LOG_DISCOVERY, 2490 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n", 2491 phba->brd_no, 2492 phba->fc_flag, 0, phba->fc_rscn_id_cnt, 2493 phba->hba_state); 2494 2495 /* To process RSCN, first compare RSCN data with NameServer */ 2496 phba->fc_ns_retry = 0; 2497 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, 2498 NameServer_DID))) { 2499 /* Good ndlp, issue CT Request to NameServer */ 2500 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) { 2501 /* Wait for NameServer query cmpl before we can 2502 continue */ 2503 return (1); 2504 } 2505 } else { 2506 /* If login to NameServer does not exist, issue one */ 2507 /* Good status, issue PLOGI to NameServer */ 2508 if ((ndlp = 2509 lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID))) { 2510 /* Wait for NameServer login cmpl before we can 2511 continue */ 2512 return (1); 2513 } 2514 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) 2515 == 0) { 2516 lpfc_els_flush_rscn(phba); 2517 return (0); 2518 } else { 2519 lpfc_nlp_init(phba, ndlp, NameServer_DID); 2520 ndlp->nlp_type |= NLP_FABRIC; 2521 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 2522 lpfc_issue_els_plogi(phba, ndlp, 0); 2523 /* Wait for NameServer login cmpl before we can 2524 continue */ 2525 return (1); 2526 } 2527 } 2528 2529 lpfc_els_flush_rscn(phba); 2530 return (0); 2531 } 2532 2533 static int 2534 lpfc_els_rcv_flogi(struct lpfc_hba * phba, 2535 struct lpfc_iocbq * cmdiocb, 2536 struct lpfc_nodelist * ndlp, uint8_t newnode) 2537 { 2538 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2539 uint32_t *lp = (uint32_t *) pcmd->virt; 2540 IOCB_t *icmd = &cmdiocb->iocb; 2541 struct serv_parm *sp; 2542 LPFC_MBOXQ_t *mbox; 2543 struct ls_rjt stat; 2544 uint32_t cmd, did; 2545 int rc; 2546 2547 cmd = *lp++; 2548 sp = (struct serv_parm *) lp; 2549 2550 /* FLOGI received */ 2551 2552 lpfc_set_disctmo(phba); 2553 2554 if (phba->fc_topology == TOPOLOGY_LOOP) { 2555 /* We should never receive a FLOGI in loop mode, ignore it */ 2556 did = icmd->un.elsreq64.remoteID; 2557 2558 /* An FLOGI ELS command <elsCmd> was received from DID <did> in 2559 Loop Mode */ 2560 lpfc_printf_log(phba, KERN_ERR, LOG_ELS, 2561 "%d:0113 An FLOGI ELS command x%x was received " 2562 "from DID x%x in Loop Mode\n", 2563 phba->brd_no, cmd, did); 2564 return (1); 2565 } 2566 2567 did = Fabric_DID; 2568 2569 if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) { 2570 /* For a FLOGI we accept, then if our portname is greater 2571 * then the remote portname we initiate Nport login. 2572 */ 2573 2574 rc = memcmp(&phba->fc_portname, &sp->portName, 2575 sizeof (struct lpfc_name)); 2576 2577 if (!rc) { 2578 if ((mbox = mempool_alloc(phba->mbox_mem_pool, 2579 GFP_KERNEL)) == 0) { 2580 return (1); 2581 } 2582 lpfc_linkdown(phba); 2583 lpfc_init_link(phba, mbox, 2584 phba->cfg_topology, 2585 phba->cfg_link_speed); 2586 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0; 2587 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2588 rc = lpfc_sli_issue_mbox 2589 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB)); 2590 if (rc == MBX_NOT_FINISHED) { 2591 mempool_free( mbox, phba->mbox_mem_pool); 2592 } 2593 return (1); 2594 } 2595 else if (rc > 0) { /* greater than */ 2596 spin_lock_irq(phba->host->host_lock); 2597 phba->fc_flag |= FC_PT2PT_PLOGI; 2598 spin_unlock_irq(phba->host->host_lock); 2599 } 2600 phba->fc_flag |= FC_PT2PT; 2601 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 2602 } else { 2603 /* Reject this request because invalid parameters */ 2604 stat.un.b.lsRjtRsvd0 = 0; 2605 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2606 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS; 2607 stat.un.b.vendorUnique = 0; 2608 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2609 return (1); 2610 } 2611 2612 /* Send back ACC */ 2613 lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode); 2614 2615 return (0); 2616 } 2617 2618 static int 2619 lpfc_els_rcv_rnid(struct lpfc_hba * phba, 2620 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 2621 { 2622 struct lpfc_dmabuf *pcmd; 2623 uint32_t *lp; 2624 IOCB_t *icmd; 2625 RNID *rn; 2626 struct ls_rjt stat; 2627 uint32_t cmd, did; 2628 2629 icmd = &cmdiocb->iocb; 2630 did = icmd->un.elsreq64.remoteID; 2631 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2632 lp = (uint32_t *) pcmd->virt; 2633 2634 cmd = *lp++; 2635 rn = (RNID *) lp; 2636 2637 /* RNID received */ 2638 2639 switch (rn->Format) { 2640 case 0: 2641 case RNID_TOPOLOGY_DISC: 2642 /* Send back ACC */ 2643 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp); 2644 break; 2645 default: 2646 /* Reject this request because format not supported */ 2647 stat.un.b.lsRjtRsvd0 = 0; 2648 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2649 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2650 stat.un.b.vendorUnique = 0; 2651 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2652 } 2653 return (0); 2654 } 2655 2656 static int 2657 lpfc_els_rcv_rrq(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 2658 struct lpfc_nodelist * ndlp) 2659 { 2660 struct lpfc_dmabuf *pcmd; 2661 uint32_t *lp; 2662 IOCB_t *icmd; 2663 struct lpfc_sli_ring *pring; 2664 struct lpfc_sli *psli; 2665 RRQ *rrq; 2666 uint32_t cmd, did; 2667 2668 psli = &phba->sli; 2669 pring = &psli->ring[LPFC_FCP_RING]; 2670 icmd = &cmdiocb->iocb; 2671 did = icmd->un.elsreq64.remoteID; 2672 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2673 lp = (uint32_t *) pcmd->virt; 2674 2675 cmd = *lp++; 2676 rrq = (RRQ *) lp; 2677 2678 /* RRQ received */ 2679 /* Get oxid / rxid from payload and abort it */ 2680 spin_lock_irq(phba->host->host_lock); 2681 if ((rrq->SID == be32_to_cpu(phba->fc_myDID))) { 2682 lpfc_sli_abort_iocb(phba, pring, 0, 0, rrq->Oxid, 2683 LPFC_CTX_CTX); 2684 } else { 2685 lpfc_sli_abort_iocb(phba, pring, 0, 0, rrq->Rxid, 2686 LPFC_CTX_CTX); 2687 } 2688 2689 spin_unlock_irq(phba->host->host_lock); 2690 /* ACCEPT the rrq request */ 2691 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0); 2692 2693 return 0; 2694 } 2695 2696 static int 2697 lpfc_els_rcv_farp(struct lpfc_hba * phba, 2698 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 2699 { 2700 struct lpfc_dmabuf *pcmd; 2701 uint32_t *lp; 2702 IOCB_t *icmd; 2703 FARP *fp; 2704 uint32_t cmd, cnt, did; 2705 2706 icmd = &cmdiocb->iocb; 2707 did = icmd->un.elsreq64.remoteID; 2708 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2709 lp = (uint32_t *) pcmd->virt; 2710 2711 cmd = *lp++; 2712 fp = (FARP *) lp; 2713 2714 /* FARP-REQ received from DID <did> */ 2715 lpfc_printf_log(phba, 2716 KERN_INFO, 2717 LOG_IP, 2718 "%d:0601 FARP-REQ received from DID x%x\n", 2719 phba->brd_no, did); 2720 2721 /* We will only support match on WWPN or WWNN */ 2722 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) { 2723 return (0); 2724 } 2725 2726 cnt = 0; 2727 /* If this FARP command is searching for my portname */ 2728 if (fp->Mflags & FARP_MATCH_PORT) { 2729 if (memcmp(&fp->RportName, &phba->fc_portname, 2730 sizeof (struct lpfc_name)) == 0) 2731 cnt = 1; 2732 } 2733 2734 /* If this FARP command is searching for my nodename */ 2735 if (fp->Mflags & FARP_MATCH_NODE) { 2736 if (memcmp(&fp->RnodeName, &phba->fc_nodename, 2737 sizeof (struct lpfc_name)) == 0) 2738 cnt = 1; 2739 } 2740 2741 if (cnt) { 2742 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) || 2743 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) { 2744 /* Log back into the node before sending the FARP. */ 2745 if (fp->Rflags & FARP_REQUEST_PLOGI) { 2746 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 2747 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 2748 lpfc_issue_els_plogi(phba, ndlp, 0); 2749 } 2750 2751 /* Send a FARP response to that node */ 2752 if (fp->Rflags & FARP_REQUEST_FARPR) { 2753 lpfc_issue_els_farpr(phba, did, 0); 2754 } 2755 } 2756 } 2757 return (0); 2758 } 2759 2760 static int 2761 lpfc_els_rcv_farpr(struct lpfc_hba * phba, 2762 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 2763 { 2764 struct lpfc_dmabuf *pcmd; 2765 uint32_t *lp; 2766 IOCB_t *icmd; 2767 uint32_t cmd, did; 2768 2769 icmd = &cmdiocb->iocb; 2770 did = icmd->un.elsreq64.remoteID; 2771 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2772 lp = (uint32_t *) pcmd->virt; 2773 2774 cmd = *lp++; 2775 /* FARP-RSP received from DID <did> */ 2776 lpfc_printf_log(phba, 2777 KERN_INFO, 2778 LOG_IP, 2779 "%d:0600 FARP-RSP received from DID x%x\n", 2780 phba->brd_no, did); 2781 2782 /* ACCEPT the Farp resp request */ 2783 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0); 2784 2785 return 0; 2786 } 2787 2788 static int 2789 lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 2790 struct lpfc_nodelist * ndlp) 2791 { 2792 struct lpfc_dmabuf *pcmd; 2793 uint32_t *lp; 2794 IOCB_t *icmd; 2795 FAN *fp; 2796 uint32_t cmd, did; 2797 2798 icmd = &cmdiocb->iocb; 2799 did = icmd->un.elsreq64.remoteID; 2800 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2801 lp = (uint32_t *) pcmd->virt; 2802 2803 cmd = *lp++; 2804 fp = (FAN *) lp; 2805 2806 /* FAN received */ 2807 2808 /* ACCEPT the FAN request */ 2809 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0); 2810 2811 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) { 2812 /* The discovery state machine needs to take a different 2813 * action if this node has switched fabrics 2814 */ 2815 if ((memcmp(&fp->FportName, &phba->fc_fabparam.portName, 2816 sizeof (struct lpfc_name)) != 0) 2817 || 2818 (memcmp(&fp->FnodeName, &phba->fc_fabparam.nodeName, 2819 sizeof (struct lpfc_name)) != 0)) { 2820 /* This node has switched fabrics. An FLOGI is required 2821 * after the timeout 2822 */ 2823 return (0); 2824 } 2825 2826 /* Start discovery */ 2827 lpfc_disc_start(phba); 2828 } 2829 2830 return (0); 2831 } 2832 2833 void 2834 lpfc_els_timeout(unsigned long ptr) 2835 { 2836 struct lpfc_hba *phba; 2837 unsigned long iflag; 2838 2839 phba = (struct lpfc_hba *)ptr; 2840 if (phba == 0) 2841 return; 2842 spin_lock_irqsave(phba->host->host_lock, iflag); 2843 if (!(phba->work_hba_events & WORKER_ELS_TMO)) { 2844 phba->work_hba_events |= WORKER_ELS_TMO; 2845 if (phba->work_wait) 2846 wake_up(phba->work_wait); 2847 } 2848 spin_unlock_irqrestore(phba->host->host_lock, iflag); 2849 return; 2850 } 2851 2852 void 2853 lpfc_els_timeout_handler(struct lpfc_hba *phba) 2854 { 2855 struct lpfc_sli_ring *pring; 2856 struct lpfc_iocbq *tmp_iocb, *piocb; 2857 IOCB_t *cmd = NULL; 2858 struct lpfc_dmabuf *pcmd; 2859 struct list_head *dlp; 2860 uint32_t *elscmd; 2861 uint32_t els_command; 2862 uint32_t timeout; 2863 uint32_t remote_ID; 2864 2865 if (phba == 0) 2866 return; 2867 spin_lock_irq(phba->host->host_lock); 2868 /* If the timer is already canceled do nothing */ 2869 if (!(phba->work_hba_events & WORKER_ELS_TMO)) { 2870 spin_unlock_irq(phba->host->host_lock); 2871 return; 2872 } 2873 timeout = (uint32_t)(phba->fc_ratov << 1); 2874 2875 pring = &phba->sli.ring[LPFC_ELS_RING]; 2876 dlp = &pring->txcmplq; 2877 2878 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) { 2879 cmd = &piocb->iocb; 2880 2881 if (piocb->iocb_flag & LPFC_IO_LIBDFC) { 2882 continue; 2883 } 2884 pcmd = (struct lpfc_dmabuf *) piocb->context2; 2885 elscmd = (uint32_t *) (pcmd->virt); 2886 els_command = *elscmd; 2887 2888 if ((els_command == ELS_CMD_FARP) 2889 || (els_command == ELS_CMD_FARPR)) { 2890 continue; 2891 } 2892 2893 if (piocb->drvrTimeout > 0) { 2894 if (piocb->drvrTimeout >= timeout) { 2895 piocb->drvrTimeout -= timeout; 2896 } else { 2897 piocb->drvrTimeout = 0; 2898 } 2899 continue; 2900 } 2901 2902 list_del(&piocb->list); 2903 pring->txcmplq_cnt--; 2904 2905 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) { 2906 struct lpfc_nodelist *ndlp; 2907 2908 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext); 2909 remote_ID = ndlp->nlp_DID; 2910 if (cmd->un.elsreq64.bdl.ulpIoTag32) { 2911 lpfc_sli_issue_abort_iotag32(phba, 2912 pring, piocb); 2913 } 2914 } else { 2915 remote_ID = cmd->un.elsreq64.remoteID; 2916 } 2917 2918 lpfc_printf_log(phba, 2919 KERN_ERR, 2920 LOG_ELS, 2921 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n", 2922 phba->brd_no, els_command, 2923 remote_ID, cmd->ulpCommand, cmd->ulpIoTag); 2924 2925 /* 2926 * The iocb has timed out; abort it. 2927 */ 2928 if (piocb->iocb_cmpl) { 2929 cmd->ulpStatus = IOSTAT_LOCAL_REJECT; 2930 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 2931 spin_unlock_irq(phba->host->host_lock); 2932 (piocb->iocb_cmpl) (phba, piocb, piocb); 2933 spin_lock_irq(phba->host->host_lock); 2934 } else 2935 lpfc_sli_release_iocbq(phba, piocb); 2936 } 2937 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt) { 2938 phba->els_tmofunc.expires = jiffies + HZ * timeout; 2939 add_timer(&phba->els_tmofunc); 2940 } 2941 spin_unlock_irq(phba->host->host_lock); 2942 } 2943 2944 void 2945 lpfc_els_flush_cmd(struct lpfc_hba * phba) 2946 { 2947 struct lpfc_sli_ring *pring; 2948 struct lpfc_iocbq *tmp_iocb, *piocb; 2949 IOCB_t *cmd = NULL; 2950 struct lpfc_dmabuf *pcmd; 2951 uint32_t *elscmd; 2952 uint32_t els_command; 2953 uint32_t remote_ID; 2954 2955 pring = &phba->sli.ring[LPFC_ELS_RING]; 2956 spin_lock_irq(phba->host->host_lock); 2957 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) { 2958 cmd = &piocb->iocb; 2959 2960 if (piocb->iocb_flag & LPFC_IO_LIBDFC) { 2961 continue; 2962 } 2963 2964 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */ 2965 if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) || 2966 (cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) || 2967 (cmd->ulpCommand == CMD_CLOSE_XRI_CN) || 2968 (cmd->ulpCommand == CMD_ABORT_XRI_CN)) { 2969 continue; 2970 } 2971 2972 pcmd = (struct lpfc_dmabuf *) piocb->context2; 2973 elscmd = (uint32_t *) (pcmd->virt); 2974 els_command = *elscmd; 2975 2976 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) { 2977 struct lpfc_nodelist *ndlp; 2978 2979 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext); 2980 remote_ID = ndlp->nlp_DID; 2981 if (phba->hba_state == LPFC_HBA_READY) { 2982 continue; 2983 } 2984 } else { 2985 remote_ID = cmd->un.elsreq64.remoteID; 2986 } 2987 2988 list_del(&piocb->list); 2989 pring->txcmplq_cnt--; 2990 2991 cmd->ulpStatus = IOSTAT_LOCAL_REJECT; 2992 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 2993 2994 if (piocb->iocb_cmpl) { 2995 spin_unlock_irq(phba->host->host_lock); 2996 (piocb->iocb_cmpl) (phba, piocb, piocb); 2997 spin_lock_irq(phba->host->host_lock); 2998 } 2999 else 3000 lpfc_sli_release_iocbq(phba, piocb); 3001 } 3002 3003 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) { 3004 cmd = &piocb->iocb; 3005 3006 if (piocb->iocb_flag & LPFC_IO_LIBDFC) { 3007 continue; 3008 } 3009 pcmd = (struct lpfc_dmabuf *) piocb->context2; 3010 elscmd = (uint32_t *) (pcmd->virt); 3011 els_command = *elscmd; 3012 3013 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) { 3014 struct lpfc_nodelist *ndlp; 3015 3016 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext); 3017 remote_ID = ndlp->nlp_DID; 3018 if (phba->hba_state == LPFC_HBA_READY) { 3019 continue; 3020 } 3021 } else { 3022 remote_ID = cmd->un.elsreq64.remoteID; 3023 } 3024 3025 list_del(&piocb->list); 3026 pring->txcmplq_cnt--; 3027 3028 cmd->ulpStatus = IOSTAT_LOCAL_REJECT; 3029 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 3030 3031 if (piocb->iocb_cmpl) { 3032 spin_unlock_irq(phba->host->host_lock); 3033 (piocb->iocb_cmpl) (phba, piocb, piocb); 3034 spin_lock_irq(phba->host->host_lock); 3035 } 3036 else 3037 lpfc_sli_release_iocbq(phba, piocb); 3038 } 3039 spin_unlock_irq(phba->host->host_lock); 3040 return; 3041 } 3042 3043 void 3044 lpfc_els_unsol_event(struct lpfc_hba * phba, 3045 struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb) 3046 { 3047 struct lpfc_sli *psli; 3048 struct lpfc_nodelist *ndlp; 3049 struct lpfc_dmabuf *mp; 3050 uint32_t *lp; 3051 IOCB_t *icmd; 3052 struct ls_rjt stat; 3053 uint32_t cmd; 3054 uint32_t did; 3055 uint32_t newnode; 3056 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */ 3057 uint32_t rjt_err = 0; 3058 3059 psli = &phba->sli; 3060 icmd = &elsiocb->iocb; 3061 3062 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) && 3063 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) { 3064 /* Not enough posted buffers; Try posting more buffers */ 3065 phba->fc_stat.NoRcvBuf++; 3066 lpfc_post_buffer(phba, pring, 0, 1); 3067 return; 3068 } 3069 3070 /* If there are no BDEs associated with this IOCB, 3071 * there is nothing to do. 3072 */ 3073 if (icmd->ulpBdeCount == 0) 3074 return; 3075 3076 /* type of ELS cmd is first 32bit word in packet */ 3077 mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un. 3078 cont64[0]. 3079 addrHigh, 3080 icmd->un. 3081 cont64[0].addrLow)); 3082 if (mp == 0) { 3083 drop_cmd = 1; 3084 goto dropit; 3085 } 3086 3087 newnode = 0; 3088 lp = (uint32_t *) mp->virt; 3089 cmd = *lp++; 3090 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1); 3091 3092 if (icmd->ulpStatus) { 3093 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3094 kfree(mp); 3095 drop_cmd = 1; 3096 goto dropit; 3097 } 3098 3099 /* Check to see if link went down during discovery */ 3100 if (lpfc_els_chk_latt(phba)) { 3101 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3102 kfree(mp); 3103 drop_cmd = 1; 3104 goto dropit; 3105 } 3106 3107 did = icmd->un.rcvels.remoteID; 3108 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did)) == 0) { 3109 /* Cannot find existing Fabric ndlp, so allocate a new one */ 3110 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) 3111 == 0) { 3112 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3113 kfree(mp); 3114 drop_cmd = 1; 3115 goto dropit; 3116 } 3117 3118 lpfc_nlp_init(phba, ndlp, did); 3119 newnode = 1; 3120 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) { 3121 ndlp->nlp_type |= NLP_FABRIC; 3122 } 3123 } 3124 3125 phba->fc_stat.elsRcvFrame++; 3126 elsiocb->context1 = ndlp; 3127 elsiocb->context2 = mp; 3128 3129 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) { 3130 cmd &= ELS_CMD_MASK; 3131 } 3132 /* ELS command <elsCmd> received from NPORT <did> */ 3133 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 3134 "%d:0112 ELS command x%x received from NPORT x%x " 3135 "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state); 3136 3137 switch (cmd) { 3138 case ELS_CMD_PLOGI: 3139 phba->fc_stat.elsRcvPLOGI++; 3140 if (phba->hba_state < LPFC_DISC_AUTH) { 3141 rjt_err = 1; 3142 break; 3143 } 3144 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI); 3145 break; 3146 case ELS_CMD_FLOGI: 3147 phba->fc_stat.elsRcvFLOGI++; 3148 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode); 3149 if (newnode) { 3150 mempool_free( ndlp, phba->nlp_mem_pool); 3151 } 3152 break; 3153 case ELS_CMD_LOGO: 3154 phba->fc_stat.elsRcvLOGO++; 3155 if (phba->hba_state < LPFC_DISC_AUTH) { 3156 rjt_err = 1; 3157 break; 3158 } 3159 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO); 3160 break; 3161 case ELS_CMD_PRLO: 3162 phba->fc_stat.elsRcvPRLO++; 3163 if (phba->hba_state < LPFC_DISC_AUTH) { 3164 rjt_err = 1; 3165 break; 3166 } 3167 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO); 3168 break; 3169 case ELS_CMD_RSCN: 3170 phba->fc_stat.elsRcvRSCN++; 3171 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode); 3172 if (newnode) { 3173 mempool_free( ndlp, phba->nlp_mem_pool); 3174 } 3175 break; 3176 case ELS_CMD_ADISC: 3177 phba->fc_stat.elsRcvADISC++; 3178 if (phba->hba_state < LPFC_DISC_AUTH) { 3179 rjt_err = 1; 3180 break; 3181 } 3182 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC); 3183 break; 3184 case ELS_CMD_PDISC: 3185 phba->fc_stat.elsRcvPDISC++; 3186 if (phba->hba_state < LPFC_DISC_AUTH) { 3187 rjt_err = 1; 3188 break; 3189 } 3190 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC); 3191 break; 3192 case ELS_CMD_FARPR: 3193 phba->fc_stat.elsRcvFARPR++; 3194 lpfc_els_rcv_farpr(phba, elsiocb, ndlp); 3195 break; 3196 case ELS_CMD_FARP: 3197 phba->fc_stat.elsRcvFARP++; 3198 lpfc_els_rcv_farp(phba, elsiocb, ndlp); 3199 break; 3200 case ELS_CMD_FAN: 3201 phba->fc_stat.elsRcvFAN++; 3202 lpfc_els_rcv_fan(phba, elsiocb, ndlp); 3203 break; 3204 case ELS_CMD_RRQ: 3205 phba->fc_stat.elsRcvRRQ++; 3206 lpfc_els_rcv_rrq(phba, elsiocb, ndlp); 3207 break; 3208 case ELS_CMD_PRLI: 3209 phba->fc_stat.elsRcvPRLI++; 3210 if (phba->hba_state < LPFC_DISC_AUTH) { 3211 rjt_err = 1; 3212 break; 3213 } 3214 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI); 3215 break; 3216 case ELS_CMD_RNID: 3217 phba->fc_stat.elsRcvRNID++; 3218 lpfc_els_rcv_rnid(phba, elsiocb, ndlp); 3219 break; 3220 default: 3221 /* Unsupported ELS command, reject */ 3222 rjt_err = 1; 3223 3224 /* Unknown ELS command <elsCmd> received from NPORT <did> */ 3225 lpfc_printf_log(phba, KERN_ERR, LOG_ELS, 3226 "%d:0115 Unknown ELS command x%x received from " 3227 "NPORT x%x\n", phba->brd_no, cmd, did); 3228 if (newnode) { 3229 mempool_free( ndlp, phba->nlp_mem_pool); 3230 } 3231 break; 3232 } 3233 3234 /* check if need to LS_RJT received ELS cmd */ 3235 if (rjt_err) { 3236 stat.un.b.lsRjtRsvd0 = 0; 3237 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 3238 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 3239 stat.un.b.vendorUnique = 0; 3240 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp); 3241 } 3242 3243 if (elsiocb->context2) { 3244 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3245 kfree(mp); 3246 } 3247 dropit: 3248 /* check if need to drop received ELS cmd */ 3249 if (drop_cmd == 1) { 3250 lpfc_printf_log(phba, KERN_ERR, LOG_ELS, 3251 "%d:0111 Dropping received ELS cmd " 3252 "Data: x%x x%x\n", phba->brd_no, 3253 icmd->ulpStatus, icmd->un.ulpWord[4]); 3254 phba->fc_stat.elsRcvDrop++; 3255 } 3256 return; 3257 } 3258