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