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