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