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