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