1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2013 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/slab.h> 25 #include <linux/interrupt.h> 26 27 #include <scsi/scsi.h> 28 #include <scsi/scsi_device.h> 29 #include <scsi/scsi_host.h> 30 #include <scsi/scsi_transport_fc.h> 31 32 #include "lpfc_hw4.h" 33 #include "lpfc_hw.h" 34 #include "lpfc_sli.h" 35 #include "lpfc_sli4.h" 36 #include "lpfc_nl.h" 37 #include "lpfc_disc.h" 38 #include "lpfc_scsi.h" 39 #include "lpfc.h" 40 #include "lpfc_logmsg.h" 41 #include "lpfc_crtn.h" 42 #include "lpfc_vport.h" 43 #include "lpfc_debugfs.h" 44 45 46 /* Called to verify a rcv'ed ADISC was intended for us. */ 47 static int 48 lpfc_check_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 49 struct lpfc_name *nn, struct lpfc_name *pn) 50 { 51 /* First, we MUST have a RPI registered */ 52 if (!(ndlp->nlp_flag & NLP_RPI_REGISTERED)) 53 return 0; 54 55 /* Compare the ADISC rsp WWNN / WWPN matches our internal node 56 * table entry for that node. 57 */ 58 if (memcmp(nn, &ndlp->nlp_nodename, sizeof (struct lpfc_name))) 59 return 0; 60 61 if (memcmp(pn, &ndlp->nlp_portname, sizeof (struct lpfc_name))) 62 return 0; 63 64 /* we match, return success */ 65 return 1; 66 } 67 68 int 69 lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 70 struct serv_parm *sp, uint32_t class, int flogi) 71 { 72 volatile struct serv_parm *hsp = &vport->fc_sparam; 73 uint16_t hsp_value, ssp_value = 0; 74 75 /* 76 * The receive data field size and buffer-to-buffer receive data field 77 * size entries are 16 bits but are represented as two 8-bit fields in 78 * the driver data structure to account for rsvd bits and other control 79 * bits. Reconstruct and compare the fields as a 16-bit values before 80 * correcting the byte values. 81 */ 82 if (sp->cls1.classValid) { 83 if (!flogi) { 84 hsp_value = ((hsp->cls1.rcvDataSizeMsb << 8) | 85 hsp->cls1.rcvDataSizeLsb); 86 ssp_value = ((sp->cls1.rcvDataSizeMsb << 8) | 87 sp->cls1.rcvDataSizeLsb); 88 if (!ssp_value) 89 goto bad_service_param; 90 if (ssp_value > hsp_value) { 91 sp->cls1.rcvDataSizeLsb = 92 hsp->cls1.rcvDataSizeLsb; 93 sp->cls1.rcvDataSizeMsb = 94 hsp->cls1.rcvDataSizeMsb; 95 } 96 } 97 } else if (class == CLASS1) 98 goto bad_service_param; 99 if (sp->cls2.classValid) { 100 if (!flogi) { 101 hsp_value = ((hsp->cls2.rcvDataSizeMsb << 8) | 102 hsp->cls2.rcvDataSizeLsb); 103 ssp_value = ((sp->cls2.rcvDataSizeMsb << 8) | 104 sp->cls2.rcvDataSizeLsb); 105 if (!ssp_value) 106 goto bad_service_param; 107 if (ssp_value > hsp_value) { 108 sp->cls2.rcvDataSizeLsb = 109 hsp->cls2.rcvDataSizeLsb; 110 sp->cls2.rcvDataSizeMsb = 111 hsp->cls2.rcvDataSizeMsb; 112 } 113 } 114 } else if (class == CLASS2) 115 goto bad_service_param; 116 if (sp->cls3.classValid) { 117 if (!flogi) { 118 hsp_value = ((hsp->cls3.rcvDataSizeMsb << 8) | 119 hsp->cls3.rcvDataSizeLsb); 120 ssp_value = ((sp->cls3.rcvDataSizeMsb << 8) | 121 sp->cls3.rcvDataSizeLsb); 122 if (!ssp_value) 123 goto bad_service_param; 124 if (ssp_value > hsp_value) { 125 sp->cls3.rcvDataSizeLsb = 126 hsp->cls3.rcvDataSizeLsb; 127 sp->cls3.rcvDataSizeMsb = 128 hsp->cls3.rcvDataSizeMsb; 129 } 130 } 131 } else if (class == CLASS3) 132 goto bad_service_param; 133 134 /* 135 * Preserve the upper four bits of the MSB from the PLOGI response. 136 * These bits contain the Buffer-to-Buffer State Change Number 137 * from the target and need to be passed to the FW. 138 */ 139 hsp_value = (hsp->cmn.bbRcvSizeMsb << 8) | hsp->cmn.bbRcvSizeLsb; 140 ssp_value = (sp->cmn.bbRcvSizeMsb << 8) | sp->cmn.bbRcvSizeLsb; 141 if (ssp_value > hsp_value) { 142 sp->cmn.bbRcvSizeLsb = hsp->cmn.bbRcvSizeLsb; 143 sp->cmn.bbRcvSizeMsb = (sp->cmn.bbRcvSizeMsb & 0xF0) | 144 (hsp->cmn.bbRcvSizeMsb & 0x0F); 145 } 146 147 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name)); 148 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof (struct lpfc_name)); 149 return 1; 150 bad_service_param: 151 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 152 "0207 Device %x " 153 "(%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x) sent " 154 "invalid service parameters. Ignoring device.\n", 155 ndlp->nlp_DID, 156 sp->nodeName.u.wwn[0], sp->nodeName.u.wwn[1], 157 sp->nodeName.u.wwn[2], sp->nodeName.u.wwn[3], 158 sp->nodeName.u.wwn[4], sp->nodeName.u.wwn[5], 159 sp->nodeName.u.wwn[6], sp->nodeName.u.wwn[7]); 160 return 0; 161 } 162 163 static void * 164 lpfc_check_elscmpl_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 165 struct lpfc_iocbq *rspiocb) 166 { 167 struct lpfc_dmabuf *pcmd, *prsp; 168 uint32_t *lp; 169 void *ptr = NULL; 170 IOCB_t *irsp; 171 172 irsp = &rspiocb->iocb; 173 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 174 175 /* For lpfc_els_abort, context2 could be zero'ed to delay 176 * freeing associated memory till after ABTS completes. 177 */ 178 if (pcmd) { 179 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, 180 list); 181 if (prsp) { 182 lp = (uint32_t *) prsp->virt; 183 ptr = (void *)((uint8_t *)lp + sizeof(uint32_t)); 184 } 185 } else { 186 /* Force ulpStatus error since we are returning NULL ptr */ 187 if (!(irsp->ulpStatus)) { 188 irsp->ulpStatus = IOSTAT_LOCAL_REJECT; 189 irsp->un.ulpWord[4] = IOERR_SLI_ABORTED; 190 } 191 ptr = NULL; 192 } 193 return ptr; 194 } 195 196 197 198 /* 199 * Free resources / clean up outstanding I/Os 200 * associated with a LPFC_NODELIST entry. This 201 * routine effectively results in a "software abort". 202 */ 203 int 204 lpfc_els_abort(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 205 { 206 LIST_HEAD(completions); 207 LIST_HEAD(txcmplq_completions); 208 LIST_HEAD(abort_list); 209 struct lpfc_sli *psli = &phba->sli; 210 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING]; 211 struct lpfc_iocbq *iocb, *next_iocb; 212 213 /* Abort outstanding I/O on NPort <nlp_DID> */ 214 lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_DISCOVERY, 215 "2819 Abort outstanding I/O on NPort x%x " 216 "Data: x%x x%x x%x\n", 217 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state, 218 ndlp->nlp_rpi); 219 220 lpfc_fabric_abort_nport(ndlp); 221 222 /* First check the txq */ 223 spin_lock_irq(&phba->hbalock); 224 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) { 225 /* Check to see if iocb matches the nport we are looking for */ 226 if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp)) { 227 /* It matches, so deque and call compl with anp error */ 228 list_move_tail(&iocb->list, &completions); 229 } 230 } 231 232 /* Next check the txcmplq */ 233 list_splice_init(&pring->txcmplq, &txcmplq_completions); 234 spin_unlock_irq(&phba->hbalock); 235 236 list_for_each_entry_safe(iocb, next_iocb, &txcmplq_completions, list) { 237 /* Check to see if iocb matches the nport we are looking for */ 238 if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp)) 239 list_add_tail(&iocb->dlist, &abort_list); 240 } 241 spin_lock_irq(&phba->hbalock); 242 list_splice(&txcmplq_completions, &pring->txcmplq); 243 spin_unlock_irq(&phba->hbalock); 244 245 list_for_each_entry_safe(iocb, next_iocb, &abort_list, dlist) { 246 spin_lock_irq(&phba->hbalock); 247 list_del_init(&iocb->dlist); 248 lpfc_sli_issue_abort_iotag(phba, pring, iocb); 249 spin_unlock_irq(&phba->hbalock); 250 } 251 252 /* Cancel all the IOCBs from the completions list */ 253 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT, 254 IOERR_SLI_ABORTED); 255 256 lpfc_cancel_retry_delay_tmo(phba->pport, ndlp); 257 return 0; 258 } 259 260 static int 261 lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 262 struct lpfc_iocbq *cmdiocb) 263 { 264 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 265 struct lpfc_hba *phba = vport->phba; 266 struct lpfc_dmabuf *pcmd; 267 uint32_t *lp; 268 IOCB_t *icmd; 269 struct serv_parm *sp; 270 LPFC_MBOXQ_t *mbox; 271 struct ls_rjt stat; 272 int rc; 273 274 memset(&stat, 0, sizeof (struct ls_rjt)); 275 if (vport->port_state <= LPFC_FDISC) { 276 /* Before responding to PLOGI, check for pt2pt mode. 277 * If we are pt2pt, with an outstanding FLOGI, abort 278 * the FLOGI and resend it first. 279 */ 280 if (vport->fc_flag & FC_PT2PT) { 281 lpfc_els_abort_flogi(phba); 282 if (!(vport->fc_flag & FC_PT2PT_PLOGI)) { 283 /* If the other side is supposed to initiate 284 * the PLOGI anyway, just ACC it now and 285 * move on with discovery. 286 */ 287 phba->fc_edtov = FF_DEF_EDTOV; 288 phba->fc_ratov = FF_DEF_RATOV; 289 /* Start discovery - this should just do 290 CLEAR_LA */ 291 lpfc_disc_start(vport); 292 } else 293 lpfc_initial_flogi(vport); 294 } else { 295 stat.un.b.lsRjtRsnCode = LSRJT_LOGICAL_BSY; 296 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 297 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, 298 ndlp, NULL); 299 return 0; 300 } 301 } 302 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 303 lp = (uint32_t *) pcmd->virt; 304 sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t)); 305 if (wwn_to_u64(sp->portName.u.wwn) == 0) { 306 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 307 "0140 PLOGI Reject: invalid nname\n"); 308 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 309 stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_PNAME; 310 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, 311 NULL); 312 return 0; 313 } 314 if (wwn_to_u64(sp->nodeName.u.wwn) == 0) { 315 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 316 "0141 PLOGI Reject: invalid pname\n"); 317 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 318 stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_NNAME; 319 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, 320 NULL); 321 return 0; 322 } 323 if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0) == 0)) { 324 /* Reject this request because invalid parameters */ 325 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 326 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS; 327 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, 328 NULL); 329 return 0; 330 } 331 icmd = &cmdiocb->iocb; 332 333 /* PLOGI chkparm OK */ 334 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 335 "0114 PLOGI chkparm OK Data: x%x x%x x%x " 336 "x%x x%x x%x\n", 337 ndlp->nlp_DID, ndlp->nlp_state, ndlp->nlp_flag, 338 ndlp->nlp_rpi, vport->port_state, 339 vport->fc_flag); 340 341 if (vport->cfg_fcp_class == 2 && sp->cls2.classValid) 342 ndlp->nlp_fcp_info |= CLASS2; 343 else 344 ndlp->nlp_fcp_info |= CLASS3; 345 346 ndlp->nlp_class_sup = 0; 347 if (sp->cls1.classValid) 348 ndlp->nlp_class_sup |= FC_COS_CLASS1; 349 if (sp->cls2.classValid) 350 ndlp->nlp_class_sup |= FC_COS_CLASS2; 351 if (sp->cls3.classValid) 352 ndlp->nlp_class_sup |= FC_COS_CLASS3; 353 if (sp->cls4.classValid) 354 ndlp->nlp_class_sup |= FC_COS_CLASS4; 355 ndlp->nlp_maxframe = 356 ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | sp->cmn.bbRcvSizeLsb; 357 358 /* no need to reg_login if we are already in one of these states */ 359 switch (ndlp->nlp_state) { 360 case NLP_STE_NPR_NODE: 361 if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) 362 break; 363 case NLP_STE_REG_LOGIN_ISSUE: 364 case NLP_STE_PRLI_ISSUE: 365 case NLP_STE_UNMAPPED_NODE: 366 case NLP_STE_MAPPED_NODE: 367 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL); 368 return 1; 369 } 370 371 /* Check for Nport to NPort pt2pt protocol */ 372 if ((vport->fc_flag & FC_PT2PT) && 373 !(vport->fc_flag & FC_PT2PT_PLOGI)) { 374 375 /* rcv'ed PLOGI decides what our NPortId will be */ 376 vport->fc_myDID = icmd->un.rcvels.parmRo; 377 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 378 if (mbox == NULL) 379 goto out; 380 lpfc_config_link(phba, mbox); 381 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 382 mbox->vport = vport; 383 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT); 384 if (rc == MBX_NOT_FINISHED) { 385 mempool_free(mbox, phba->mbox_mem_pool); 386 goto out; 387 } 388 /* 389 * For SLI4, the VFI/VPI are registered AFTER the 390 * Nport with the higher WWPN sends us a PLOGI with 391 * our assigned NPortId. 392 */ 393 if (phba->sli_rev == LPFC_SLI_REV4) 394 lpfc_issue_reg_vfi(vport); 395 396 lpfc_can_disctmo(vport); 397 } 398 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 399 if (!mbox) 400 goto out; 401 402 /* Registering an existing RPI behaves differently for SLI3 vs SLI4 */ 403 if (phba->sli_rev == LPFC_SLI_REV4) 404 lpfc_unreg_rpi(vport, ndlp); 405 406 rc = lpfc_reg_rpi(phba, vport->vpi, icmd->un.rcvels.remoteID, 407 (uint8_t *) sp, mbox, ndlp->nlp_rpi); 408 if (rc) { 409 mempool_free(mbox, phba->mbox_mem_pool); 410 goto out; 411 } 412 413 /* ACC PLOGI rsp command needs to execute first, 414 * queue this mbox command to be processed later. 415 */ 416 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login; 417 /* 418 * mbox->context2 = lpfc_nlp_get(ndlp) deferred until mailbox 419 * command issued in lpfc_cmpl_els_acc(). 420 */ 421 mbox->vport = vport; 422 spin_lock_irq(shost->host_lock); 423 ndlp->nlp_flag |= (NLP_ACC_REGLOGIN | NLP_RCV_PLOGI); 424 spin_unlock_irq(shost->host_lock); 425 426 /* 427 * If there is an outstanding PLOGI issued, abort it before 428 * sending ACC rsp for received PLOGI. If pending plogi 429 * is not canceled here, the plogi will be rejected by 430 * remote port and will be retried. On a configuration with 431 * single discovery thread, this will cause a huge delay in 432 * discovery. Also this will cause multiple state machines 433 * running in parallel for this node. 434 */ 435 if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE) { 436 /* software abort outstanding PLOGI */ 437 lpfc_els_abort(phba, ndlp); 438 } 439 440 if ((vport->port_type == LPFC_NPIV_PORT && 441 vport->cfg_restrict_login)) { 442 443 /* In order to preserve RPIs, we want to cleanup 444 * the default RPI the firmware created to rcv 445 * this ELS request. The only way to do this is 446 * to register, then unregister the RPI. 447 */ 448 spin_lock_irq(shost->host_lock); 449 ndlp->nlp_flag |= NLP_RM_DFLT_RPI; 450 spin_unlock_irq(shost->host_lock); 451 stat.un.b.lsRjtRsnCode = LSRJT_INVALID_CMD; 452 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 453 rc = lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, 454 ndlp, mbox); 455 if (rc) 456 mempool_free(mbox, phba->mbox_mem_pool); 457 return 1; 458 } 459 rc = lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, mbox); 460 if (rc) 461 mempool_free(mbox, phba->mbox_mem_pool); 462 return 1; 463 out: 464 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 465 stat.un.b.lsRjtRsnCodeExp = LSEXP_OUT_OF_RESOURCE; 466 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 467 return 0; 468 } 469 470 /** 471 * lpfc_mbx_cmpl_resume_rpi - Resume RPI completion routine 472 * @phba: pointer to lpfc hba data structure. 473 * @mboxq: pointer to mailbox object 474 * 475 * This routine is invoked to issue a completion to a rcv'ed 476 * ADISC or PDISC after the paused RPI has been resumed. 477 **/ 478 static void 479 lpfc_mbx_cmpl_resume_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 480 { 481 struct lpfc_vport *vport; 482 struct lpfc_iocbq *elsiocb; 483 struct lpfc_nodelist *ndlp; 484 uint32_t cmd; 485 486 elsiocb = (struct lpfc_iocbq *)mboxq->context1; 487 ndlp = (struct lpfc_nodelist *) mboxq->context2; 488 vport = mboxq->vport; 489 cmd = elsiocb->drvrTimeout; 490 491 if (cmd == ELS_CMD_ADISC) { 492 lpfc_els_rsp_adisc_acc(vport, elsiocb, ndlp); 493 } else { 494 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, elsiocb, 495 ndlp, NULL); 496 } 497 kfree(elsiocb); 498 mempool_free(mboxq, phba->mbox_mem_pool); 499 } 500 501 static int 502 lpfc_rcv_padisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 503 struct lpfc_iocbq *cmdiocb) 504 { 505 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 506 struct lpfc_iocbq *elsiocb; 507 struct lpfc_dmabuf *pcmd; 508 struct serv_parm *sp; 509 struct lpfc_name *pnn, *ppn; 510 struct ls_rjt stat; 511 ADISC *ap; 512 IOCB_t *icmd; 513 uint32_t *lp; 514 uint32_t cmd; 515 516 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 517 lp = (uint32_t *) pcmd->virt; 518 519 cmd = *lp++; 520 if (cmd == ELS_CMD_ADISC) { 521 ap = (ADISC *) lp; 522 pnn = (struct lpfc_name *) & ap->nodeName; 523 ppn = (struct lpfc_name *) & ap->portName; 524 } else { 525 sp = (struct serv_parm *) lp; 526 pnn = (struct lpfc_name *) & sp->nodeName; 527 ppn = (struct lpfc_name *) & sp->portName; 528 } 529 530 icmd = &cmdiocb->iocb; 531 if (icmd->ulpStatus == 0 && lpfc_check_adisc(vport, ndlp, pnn, ppn)) { 532 533 /* 534 * As soon as we send ACC, the remote NPort can 535 * start sending us data. Thus, for SLI4 we must 536 * resume the RPI before the ACC goes out. 537 */ 538 if (vport->phba->sli_rev == LPFC_SLI_REV4) { 539 elsiocb = kmalloc(sizeof(struct lpfc_iocbq), 540 GFP_KERNEL); 541 if (elsiocb) { 542 543 /* Save info from cmd IOCB used in rsp */ 544 memcpy((uint8_t *)elsiocb, (uint8_t *)cmdiocb, 545 sizeof(struct lpfc_iocbq)); 546 547 /* Save the ELS cmd */ 548 elsiocb->drvrTimeout = cmd; 549 550 lpfc_sli4_resume_rpi(ndlp, 551 lpfc_mbx_cmpl_resume_rpi, elsiocb); 552 goto out; 553 } 554 } 555 556 if (cmd == ELS_CMD_ADISC) { 557 lpfc_els_rsp_adisc_acc(vport, cmdiocb, ndlp); 558 } else { 559 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, 560 ndlp, NULL); 561 } 562 out: 563 /* If we are authenticated, move to the proper state */ 564 if (ndlp->nlp_type & NLP_FCP_TARGET) 565 lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE); 566 else 567 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 568 569 return 1; 570 } 571 /* Reject this request because invalid parameters */ 572 stat.un.b.lsRjtRsvd0 = 0; 573 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 574 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS; 575 stat.un.b.vendorUnique = 0; 576 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 577 578 /* 1 sec timeout */ 579 mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000)); 580 581 spin_lock_irq(shost->host_lock); 582 ndlp->nlp_flag |= NLP_DELAY_TMO; 583 spin_unlock_irq(shost->host_lock); 584 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 585 ndlp->nlp_prev_state = ndlp->nlp_state; 586 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 587 return 0; 588 } 589 590 static int 591 lpfc_rcv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 592 struct lpfc_iocbq *cmdiocb, uint32_t els_cmd) 593 { 594 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 595 struct lpfc_hba *phba = vport->phba; 596 struct lpfc_vport **vports; 597 int i, active_vlink_present = 0 ; 598 599 /* Put ndlp in NPR state with 1 sec timeout for plogi, ACC logo */ 600 /* Only call LOGO ACC for first LOGO, this avoids sending unnecessary 601 * PLOGIs during LOGO storms from a device. 602 */ 603 spin_lock_irq(shost->host_lock); 604 ndlp->nlp_flag |= NLP_LOGO_ACC; 605 spin_unlock_irq(shost->host_lock); 606 if (els_cmd == ELS_CMD_PRLO) 607 lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL); 608 else 609 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL); 610 if (ndlp->nlp_DID == Fabric_DID) { 611 if (vport->port_state <= LPFC_FDISC) 612 goto out; 613 lpfc_linkdown_port(vport); 614 spin_lock_irq(shost->host_lock); 615 vport->fc_flag |= FC_VPORT_LOGO_RCVD; 616 spin_unlock_irq(shost->host_lock); 617 vports = lpfc_create_vport_work_array(phba); 618 if (vports) { 619 for (i = 0; i <= phba->max_vports && vports[i] != NULL; 620 i++) { 621 if ((!(vports[i]->fc_flag & 622 FC_VPORT_LOGO_RCVD)) && 623 (vports[i]->port_state > LPFC_FDISC)) { 624 active_vlink_present = 1; 625 break; 626 } 627 } 628 lpfc_destroy_vport_work_array(phba, vports); 629 } 630 631 if (active_vlink_present) { 632 /* 633 * If there are other active VLinks present, 634 * re-instantiate the Vlink using FDISC. 635 */ 636 mod_timer(&ndlp->nlp_delayfunc, 637 jiffies + msecs_to_jiffies(1000)); 638 spin_lock_irq(shost->host_lock); 639 ndlp->nlp_flag |= NLP_DELAY_TMO; 640 spin_unlock_irq(shost->host_lock); 641 ndlp->nlp_last_elscmd = ELS_CMD_FDISC; 642 vport->port_state = LPFC_FDISC; 643 } else { 644 spin_lock_irq(shost->host_lock); 645 phba->pport->fc_flag &= ~FC_LOGO_RCVD_DID_CHNG; 646 spin_unlock_irq(shost->host_lock); 647 lpfc_retry_pport_discovery(phba); 648 } 649 } else if ((!(ndlp->nlp_type & NLP_FABRIC) && 650 ((ndlp->nlp_type & NLP_FCP_TARGET) || 651 !(ndlp->nlp_type & NLP_FCP_INITIATOR))) || 652 (ndlp->nlp_state == NLP_STE_ADISC_ISSUE)) { 653 /* Only try to re-login if this is NOT a Fabric Node */ 654 mod_timer(&ndlp->nlp_delayfunc, 655 jiffies + msecs_to_jiffies(1000 * 1)); 656 spin_lock_irq(shost->host_lock); 657 ndlp->nlp_flag |= NLP_DELAY_TMO; 658 spin_unlock_irq(shost->host_lock); 659 660 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 661 } 662 out: 663 ndlp->nlp_prev_state = ndlp->nlp_state; 664 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 665 666 spin_lock_irq(shost->host_lock); 667 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 668 spin_unlock_irq(shost->host_lock); 669 /* The driver has to wait until the ACC completes before it continues 670 * processing the LOGO. The action will resume in 671 * lpfc_cmpl_els_logo_acc routine. Since part of processing includes an 672 * unreg_login, the driver waits so the ACC does not get aborted. 673 */ 674 return 0; 675 } 676 677 static void 678 lpfc_rcv_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 679 struct lpfc_iocbq *cmdiocb) 680 { 681 struct lpfc_dmabuf *pcmd; 682 uint32_t *lp; 683 PRLI *npr; 684 struct fc_rport *rport = ndlp->rport; 685 u32 roles; 686 687 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 688 lp = (uint32_t *) pcmd->virt; 689 npr = (PRLI *) ((uint8_t *) lp + sizeof (uint32_t)); 690 691 ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR); 692 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE; 693 ndlp->nlp_flag &= ~NLP_FIRSTBURST; 694 if (npr->prliType == PRLI_FCP_TYPE) { 695 if (npr->initiatorFunc) 696 ndlp->nlp_type |= NLP_FCP_INITIATOR; 697 if (npr->targetFunc) { 698 ndlp->nlp_type |= NLP_FCP_TARGET; 699 if (npr->writeXferRdyDis) 700 ndlp->nlp_flag |= NLP_FIRSTBURST; 701 } 702 if (npr->Retry) 703 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE; 704 } 705 if (rport) { 706 /* We need to update the rport role values */ 707 roles = FC_RPORT_ROLE_UNKNOWN; 708 if (ndlp->nlp_type & NLP_FCP_INITIATOR) 709 roles |= FC_RPORT_ROLE_FCP_INITIATOR; 710 if (ndlp->nlp_type & NLP_FCP_TARGET) 711 roles |= FC_RPORT_ROLE_FCP_TARGET; 712 713 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT, 714 "rport rolechg: role:x%x did:x%x flg:x%x", 715 roles, ndlp->nlp_DID, ndlp->nlp_flag); 716 717 fc_remote_port_rolechg(rport, roles); 718 } 719 } 720 721 static uint32_t 722 lpfc_disc_set_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 723 { 724 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 725 726 if (!(ndlp->nlp_flag & NLP_RPI_REGISTERED)) { 727 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 728 return 0; 729 } 730 731 if (!(vport->fc_flag & FC_PT2PT)) { 732 /* Check config parameter use-adisc or FCP-2 */ 733 if ((vport->cfg_use_adisc && (vport->fc_flag & FC_RSCN_MODE)) || 734 ((ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) && 735 (ndlp->nlp_type & NLP_FCP_TARGET))) { 736 spin_lock_irq(shost->host_lock); 737 ndlp->nlp_flag |= NLP_NPR_ADISC; 738 spin_unlock_irq(shost->host_lock); 739 return 1; 740 } 741 } 742 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 743 lpfc_unreg_rpi(vport, ndlp); 744 return 0; 745 } 746 747 /** 748 * lpfc_release_rpi - Release a RPI by issuing unreg_login mailbox cmd. 749 * @phba : Pointer to lpfc_hba structure. 750 * @vport: Pointer to lpfc_vport structure. 751 * @rpi : rpi to be release. 752 * 753 * This function will send a unreg_login mailbox command to the firmware 754 * to release a rpi. 755 **/ 756 void 757 lpfc_release_rpi(struct lpfc_hba *phba, 758 struct lpfc_vport *vport, 759 uint16_t rpi) 760 { 761 LPFC_MBOXQ_t *pmb; 762 int rc; 763 764 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, 765 GFP_KERNEL); 766 if (!pmb) 767 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 768 "2796 mailbox memory allocation failed \n"); 769 else { 770 lpfc_unreg_login(phba, vport->vpi, rpi, pmb); 771 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 772 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 773 if (rc == MBX_NOT_FINISHED) 774 mempool_free(pmb, phba->mbox_mem_pool); 775 } 776 } 777 778 static uint32_t 779 lpfc_disc_illegal(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 780 void *arg, uint32_t evt) 781 { 782 struct lpfc_hba *phba; 783 LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg; 784 MAILBOX_t *mb; 785 uint16_t rpi; 786 787 phba = vport->phba; 788 /* Release the RPI if reglogin completing */ 789 if (!(phba->pport->load_flag & FC_UNLOADING) && 790 (evt == NLP_EVT_CMPL_REG_LOGIN) && 791 (!pmb->u.mb.mbxStatus)) { 792 mb = &pmb->u.mb; 793 rpi = pmb->u.mb.un.varWords[0]; 794 lpfc_release_rpi(phba, vport, rpi); 795 } 796 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 797 "0271 Illegal State Transition: node x%x " 798 "event x%x, state x%x Data: x%x x%x\n", 799 ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi, 800 ndlp->nlp_flag); 801 return ndlp->nlp_state; 802 } 803 804 static uint32_t 805 lpfc_cmpl_plogi_illegal(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 806 void *arg, uint32_t evt) 807 { 808 /* This transition is only legal if we previously 809 * rcv'ed a PLOGI. Since we don't want 2 discovery threads 810 * working on the same NPortID, do nothing for this thread 811 * to stop it. 812 */ 813 if (!(ndlp->nlp_flag & NLP_RCV_PLOGI)) { 814 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 815 "0272 Illegal State Transition: node x%x " 816 "event x%x, state x%x Data: x%x x%x\n", 817 ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi, 818 ndlp->nlp_flag); 819 } 820 return ndlp->nlp_state; 821 } 822 823 /* Start of Discovery State Machine routines */ 824 825 static uint32_t 826 lpfc_rcv_plogi_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 827 void *arg, uint32_t evt) 828 { 829 struct lpfc_iocbq *cmdiocb; 830 831 cmdiocb = (struct lpfc_iocbq *) arg; 832 833 if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) { 834 return ndlp->nlp_state; 835 } 836 return NLP_STE_FREED_NODE; 837 } 838 839 static uint32_t 840 lpfc_rcv_els_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 841 void *arg, uint32_t evt) 842 { 843 lpfc_issue_els_logo(vport, ndlp, 0); 844 return ndlp->nlp_state; 845 } 846 847 static uint32_t 848 lpfc_rcv_logo_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 849 void *arg, uint32_t evt) 850 { 851 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 852 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 853 854 spin_lock_irq(shost->host_lock); 855 ndlp->nlp_flag |= NLP_LOGO_ACC; 856 spin_unlock_irq(shost->host_lock); 857 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL); 858 859 return ndlp->nlp_state; 860 } 861 862 static uint32_t 863 lpfc_cmpl_logo_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 864 void *arg, uint32_t evt) 865 { 866 return NLP_STE_FREED_NODE; 867 } 868 869 static uint32_t 870 lpfc_device_rm_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 871 void *arg, uint32_t evt) 872 { 873 return NLP_STE_FREED_NODE; 874 } 875 876 static uint32_t 877 lpfc_device_recov_unused_node(struct lpfc_vport *vport, 878 struct lpfc_nodelist *ndlp, 879 void *arg, uint32_t evt) 880 { 881 return ndlp->nlp_state; 882 } 883 884 static uint32_t 885 lpfc_rcv_plogi_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 886 void *arg, uint32_t evt) 887 { 888 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 889 struct lpfc_hba *phba = vport->phba; 890 struct lpfc_iocbq *cmdiocb = arg; 891 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 892 uint32_t *lp = (uint32_t *) pcmd->virt; 893 struct serv_parm *sp = (struct serv_parm *) (lp + 1); 894 struct ls_rjt stat; 895 int port_cmp; 896 897 memset(&stat, 0, sizeof (struct ls_rjt)); 898 899 /* For a PLOGI, we only accept if our portname is less 900 * than the remote portname. 901 */ 902 phba->fc_stat.elsLogiCol++; 903 port_cmp = memcmp(&vport->fc_portname, &sp->portName, 904 sizeof(struct lpfc_name)); 905 906 if (port_cmp >= 0) { 907 /* Reject this request because the remote node will accept 908 ours */ 909 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 910 stat.un.b.lsRjtRsnCodeExp = LSEXP_CMD_IN_PROGRESS; 911 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, 912 NULL); 913 } else { 914 if (lpfc_rcv_plogi(vport, ndlp, cmdiocb) && 915 (ndlp->nlp_flag & NLP_NPR_2B_DISC) && 916 (vport->num_disc_nodes)) { 917 spin_lock_irq(shost->host_lock); 918 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 919 spin_unlock_irq(shost->host_lock); 920 /* Check if there are more PLOGIs to be sent */ 921 lpfc_more_plogi(vport); 922 if (vport->num_disc_nodes == 0) { 923 spin_lock_irq(shost->host_lock); 924 vport->fc_flag &= ~FC_NDISC_ACTIVE; 925 spin_unlock_irq(shost->host_lock); 926 lpfc_can_disctmo(vport); 927 lpfc_end_rscn(vport); 928 } 929 } 930 } /* If our portname was less */ 931 932 return ndlp->nlp_state; 933 } 934 935 static uint32_t 936 lpfc_rcv_prli_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 937 void *arg, uint32_t evt) 938 { 939 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 940 struct ls_rjt stat; 941 942 memset(&stat, 0, sizeof (struct ls_rjt)); 943 stat.un.b.lsRjtRsnCode = LSRJT_LOGICAL_BSY; 944 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 945 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 946 return ndlp->nlp_state; 947 } 948 949 static uint32_t 950 lpfc_rcv_logo_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 951 void *arg, uint32_t evt) 952 { 953 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 954 955 /* software abort outstanding PLOGI */ 956 lpfc_els_abort(vport->phba, ndlp); 957 958 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 959 return ndlp->nlp_state; 960 } 961 962 static uint32_t 963 lpfc_rcv_els_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 964 void *arg, uint32_t evt) 965 { 966 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 967 struct lpfc_hba *phba = vport->phba; 968 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 969 970 /* software abort outstanding PLOGI */ 971 lpfc_els_abort(phba, ndlp); 972 973 if (evt == NLP_EVT_RCV_LOGO) { 974 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL); 975 } else { 976 lpfc_issue_els_logo(vport, ndlp, 0); 977 } 978 979 /* Put ndlp in npr state set plogi timer for 1 sec */ 980 mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000 * 1)); 981 spin_lock_irq(shost->host_lock); 982 ndlp->nlp_flag |= NLP_DELAY_TMO; 983 spin_unlock_irq(shost->host_lock); 984 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 985 ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE; 986 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 987 988 return ndlp->nlp_state; 989 } 990 991 static uint32_t 992 lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport *vport, 993 struct lpfc_nodelist *ndlp, 994 void *arg, 995 uint32_t evt) 996 { 997 struct lpfc_hba *phba = vport->phba; 998 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 999 struct lpfc_iocbq *cmdiocb, *rspiocb; 1000 struct lpfc_dmabuf *pcmd, *prsp, *mp; 1001 uint32_t *lp; 1002 IOCB_t *irsp; 1003 struct serv_parm *sp; 1004 LPFC_MBOXQ_t *mbox; 1005 1006 cmdiocb = (struct lpfc_iocbq *) arg; 1007 rspiocb = cmdiocb->context_un.rsp_iocb; 1008 1009 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) { 1010 /* Recovery from PLOGI collision logic */ 1011 return ndlp->nlp_state; 1012 } 1013 1014 irsp = &rspiocb->iocb; 1015 1016 if (irsp->ulpStatus) 1017 goto out; 1018 1019 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 1020 1021 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list); 1022 1023 lp = (uint32_t *) prsp->virt; 1024 sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t)); 1025 1026 /* Some switches have FDMI servers returning 0 for WWN */ 1027 if ((ndlp->nlp_DID != FDMI_DID) && 1028 (wwn_to_u64(sp->portName.u.wwn) == 0 || 1029 wwn_to_u64(sp->nodeName.u.wwn) == 0)) { 1030 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1031 "0142 PLOGI RSP: Invalid WWN.\n"); 1032 goto out; 1033 } 1034 if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0)) 1035 goto out; 1036 /* PLOGI chkparm OK */ 1037 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, 1038 "0121 PLOGI chkparm OK Data: x%x x%x x%x x%x\n", 1039 ndlp->nlp_DID, ndlp->nlp_state, 1040 ndlp->nlp_flag, ndlp->nlp_rpi); 1041 if (vport->cfg_fcp_class == 2 && (sp->cls2.classValid)) 1042 ndlp->nlp_fcp_info |= CLASS2; 1043 else 1044 ndlp->nlp_fcp_info |= CLASS3; 1045 1046 ndlp->nlp_class_sup = 0; 1047 if (sp->cls1.classValid) 1048 ndlp->nlp_class_sup |= FC_COS_CLASS1; 1049 if (sp->cls2.classValid) 1050 ndlp->nlp_class_sup |= FC_COS_CLASS2; 1051 if (sp->cls3.classValid) 1052 ndlp->nlp_class_sup |= FC_COS_CLASS3; 1053 if (sp->cls4.classValid) 1054 ndlp->nlp_class_sup |= FC_COS_CLASS4; 1055 ndlp->nlp_maxframe = 1056 ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | sp->cmn.bbRcvSizeLsb; 1057 1058 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1059 if (!mbox) { 1060 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1061 "0133 PLOGI: no memory for reg_login " 1062 "Data: x%x x%x x%x x%x\n", 1063 ndlp->nlp_DID, ndlp->nlp_state, 1064 ndlp->nlp_flag, ndlp->nlp_rpi); 1065 goto out; 1066 } 1067 1068 lpfc_unreg_rpi(vport, ndlp); 1069 1070 if (lpfc_reg_rpi(phba, vport->vpi, irsp->un.elsreq64.remoteID, 1071 (uint8_t *) sp, mbox, ndlp->nlp_rpi) == 0) { 1072 switch (ndlp->nlp_DID) { 1073 case NameServer_DID: 1074 mbox->mbox_cmpl = lpfc_mbx_cmpl_ns_reg_login; 1075 break; 1076 case FDMI_DID: 1077 mbox->mbox_cmpl = lpfc_mbx_cmpl_fdmi_reg_login; 1078 break; 1079 default: 1080 ndlp->nlp_flag |= NLP_REG_LOGIN_SEND; 1081 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login; 1082 } 1083 mbox->context2 = lpfc_nlp_get(ndlp); 1084 mbox->vport = vport; 1085 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT) 1086 != MBX_NOT_FINISHED) { 1087 lpfc_nlp_set_state(vport, ndlp, 1088 NLP_STE_REG_LOGIN_ISSUE); 1089 return ndlp->nlp_state; 1090 } 1091 if (ndlp->nlp_flag & NLP_REG_LOGIN_SEND) 1092 ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND; 1093 /* decrement node reference count to the failed mbox 1094 * command 1095 */ 1096 lpfc_nlp_put(ndlp); 1097 mp = (struct lpfc_dmabuf *) mbox->context1; 1098 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1099 kfree(mp); 1100 mempool_free(mbox, phba->mbox_mem_pool); 1101 1102 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1103 "0134 PLOGI: cannot issue reg_login " 1104 "Data: x%x x%x x%x x%x\n", 1105 ndlp->nlp_DID, ndlp->nlp_state, 1106 ndlp->nlp_flag, ndlp->nlp_rpi); 1107 } else { 1108 mempool_free(mbox, phba->mbox_mem_pool); 1109 1110 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1111 "0135 PLOGI: cannot format reg_login " 1112 "Data: x%x x%x x%x x%x\n", 1113 ndlp->nlp_DID, ndlp->nlp_state, 1114 ndlp->nlp_flag, ndlp->nlp_rpi); 1115 } 1116 1117 1118 out: 1119 if (ndlp->nlp_DID == NameServer_DID) { 1120 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1121 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1122 "0261 Cannot Register NameServer login\n"); 1123 } 1124 1125 /* 1126 ** In case the node reference counter does not go to zero, ensure that 1127 ** the stale state for the node is not processed. 1128 */ 1129 1130 ndlp->nlp_prev_state = ndlp->nlp_state; 1131 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1132 spin_lock_irq(shost->host_lock); 1133 ndlp->nlp_flag |= NLP_DEFER_RM; 1134 spin_unlock_irq(shost->host_lock); 1135 return NLP_STE_FREED_NODE; 1136 } 1137 1138 static uint32_t 1139 lpfc_cmpl_logo_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1140 void *arg, uint32_t evt) 1141 { 1142 return ndlp->nlp_state; 1143 } 1144 1145 static uint32_t 1146 lpfc_cmpl_reglogin_plogi_issue(struct lpfc_vport *vport, 1147 struct lpfc_nodelist *ndlp, void *arg, uint32_t evt) 1148 { 1149 struct lpfc_hba *phba; 1150 LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg; 1151 MAILBOX_t *mb = &pmb->u.mb; 1152 uint16_t rpi; 1153 1154 phba = vport->phba; 1155 /* Release the RPI */ 1156 if (!(phba->pport->load_flag & FC_UNLOADING) && 1157 !mb->mbxStatus) { 1158 rpi = pmb->u.mb.un.varWords[0]; 1159 lpfc_release_rpi(phba, vport, rpi); 1160 } 1161 return ndlp->nlp_state; 1162 } 1163 1164 static uint32_t 1165 lpfc_device_rm_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1166 void *arg, uint32_t evt) 1167 { 1168 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1169 1170 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1171 spin_lock_irq(shost->host_lock); 1172 ndlp->nlp_flag |= NLP_NODEV_REMOVE; 1173 spin_unlock_irq(shost->host_lock); 1174 return ndlp->nlp_state; 1175 } else { 1176 /* software abort outstanding PLOGI */ 1177 lpfc_els_abort(vport->phba, ndlp); 1178 1179 lpfc_drop_node(vport, ndlp); 1180 return NLP_STE_FREED_NODE; 1181 } 1182 } 1183 1184 static uint32_t 1185 lpfc_device_recov_plogi_issue(struct lpfc_vport *vport, 1186 struct lpfc_nodelist *ndlp, 1187 void *arg, 1188 uint32_t evt) 1189 { 1190 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1191 struct lpfc_hba *phba = vport->phba; 1192 1193 /* Don't do anything that will mess up processing of the 1194 * previous RSCN. 1195 */ 1196 if (vport->fc_flag & FC_RSCN_DEFERRED) 1197 return ndlp->nlp_state; 1198 1199 /* software abort outstanding PLOGI */ 1200 lpfc_els_abort(phba, ndlp); 1201 1202 ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE; 1203 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1204 spin_lock_irq(shost->host_lock); 1205 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1206 spin_unlock_irq(shost->host_lock); 1207 1208 return ndlp->nlp_state; 1209 } 1210 1211 static uint32_t 1212 lpfc_rcv_plogi_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1213 void *arg, uint32_t evt) 1214 { 1215 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1216 struct lpfc_hba *phba = vport->phba; 1217 struct lpfc_iocbq *cmdiocb; 1218 1219 /* software abort outstanding ADISC */ 1220 lpfc_els_abort(phba, ndlp); 1221 1222 cmdiocb = (struct lpfc_iocbq *) arg; 1223 1224 if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) { 1225 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1226 spin_lock_irq(shost->host_lock); 1227 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 1228 spin_unlock_irq(shost->host_lock); 1229 if (vport->num_disc_nodes) 1230 lpfc_more_adisc(vport); 1231 } 1232 return ndlp->nlp_state; 1233 } 1234 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1235 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0); 1236 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE); 1237 1238 return ndlp->nlp_state; 1239 } 1240 1241 static uint32_t 1242 lpfc_rcv_prli_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1243 void *arg, uint32_t evt) 1244 { 1245 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1246 1247 lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp); 1248 return ndlp->nlp_state; 1249 } 1250 1251 static uint32_t 1252 lpfc_rcv_logo_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1253 void *arg, uint32_t evt) 1254 { 1255 struct lpfc_hba *phba = vport->phba; 1256 struct lpfc_iocbq *cmdiocb; 1257 1258 cmdiocb = (struct lpfc_iocbq *) arg; 1259 1260 /* software abort outstanding ADISC */ 1261 lpfc_els_abort(phba, ndlp); 1262 1263 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 1264 return ndlp->nlp_state; 1265 } 1266 1267 static uint32_t 1268 lpfc_rcv_padisc_adisc_issue(struct lpfc_vport *vport, 1269 struct lpfc_nodelist *ndlp, 1270 void *arg, uint32_t evt) 1271 { 1272 struct lpfc_iocbq *cmdiocb; 1273 1274 cmdiocb = (struct lpfc_iocbq *) arg; 1275 1276 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 1277 return ndlp->nlp_state; 1278 } 1279 1280 static uint32_t 1281 lpfc_rcv_prlo_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1282 void *arg, uint32_t evt) 1283 { 1284 struct lpfc_iocbq *cmdiocb; 1285 1286 cmdiocb = (struct lpfc_iocbq *) arg; 1287 1288 /* Treat like rcv logo */ 1289 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_PRLO); 1290 return ndlp->nlp_state; 1291 } 1292 1293 static uint32_t 1294 lpfc_cmpl_adisc_adisc_issue(struct lpfc_vport *vport, 1295 struct lpfc_nodelist *ndlp, 1296 void *arg, uint32_t evt) 1297 { 1298 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1299 struct lpfc_hba *phba = vport->phba; 1300 struct lpfc_iocbq *cmdiocb, *rspiocb; 1301 IOCB_t *irsp; 1302 ADISC *ap; 1303 int rc; 1304 1305 cmdiocb = (struct lpfc_iocbq *) arg; 1306 rspiocb = cmdiocb->context_un.rsp_iocb; 1307 1308 ap = (ADISC *)lpfc_check_elscmpl_iocb(phba, cmdiocb, rspiocb); 1309 irsp = &rspiocb->iocb; 1310 1311 if ((irsp->ulpStatus) || 1312 (!lpfc_check_adisc(vport, ndlp, &ap->nodeName, &ap->portName))) { 1313 /* 1 sec timeout */ 1314 mod_timer(&ndlp->nlp_delayfunc, 1315 jiffies + msecs_to_jiffies(1000)); 1316 spin_lock_irq(shost->host_lock); 1317 ndlp->nlp_flag |= NLP_DELAY_TMO; 1318 spin_unlock_irq(shost->host_lock); 1319 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 1320 1321 memset(&ndlp->nlp_nodename, 0, sizeof(struct lpfc_name)); 1322 memset(&ndlp->nlp_portname, 0, sizeof(struct lpfc_name)); 1323 1324 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1325 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1326 lpfc_unreg_rpi(vport, ndlp); 1327 return ndlp->nlp_state; 1328 } 1329 1330 if (phba->sli_rev == LPFC_SLI_REV4) { 1331 rc = lpfc_sli4_resume_rpi(ndlp, NULL, NULL); 1332 if (rc) { 1333 /* Stay in state and retry. */ 1334 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1335 return ndlp->nlp_state; 1336 } 1337 } 1338 1339 if (ndlp->nlp_type & NLP_FCP_TARGET) { 1340 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1341 lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE); 1342 } else { 1343 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1344 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1345 } 1346 1347 return ndlp->nlp_state; 1348 } 1349 1350 static uint32_t 1351 lpfc_device_rm_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1352 void *arg, uint32_t evt) 1353 { 1354 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1355 1356 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1357 spin_lock_irq(shost->host_lock); 1358 ndlp->nlp_flag |= NLP_NODEV_REMOVE; 1359 spin_unlock_irq(shost->host_lock); 1360 return ndlp->nlp_state; 1361 } else { 1362 /* software abort outstanding ADISC */ 1363 lpfc_els_abort(vport->phba, ndlp); 1364 1365 lpfc_drop_node(vport, ndlp); 1366 return NLP_STE_FREED_NODE; 1367 } 1368 } 1369 1370 static uint32_t 1371 lpfc_device_recov_adisc_issue(struct lpfc_vport *vport, 1372 struct lpfc_nodelist *ndlp, 1373 void *arg, 1374 uint32_t evt) 1375 { 1376 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1377 struct lpfc_hba *phba = vport->phba; 1378 1379 /* Don't do anything that will mess up processing of the 1380 * previous RSCN. 1381 */ 1382 if (vport->fc_flag & FC_RSCN_DEFERRED) 1383 return ndlp->nlp_state; 1384 1385 /* software abort outstanding ADISC */ 1386 lpfc_els_abort(phba, ndlp); 1387 1388 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE; 1389 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1390 spin_lock_irq(shost->host_lock); 1391 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1392 spin_unlock_irq(shost->host_lock); 1393 lpfc_disc_set_adisc(vport, ndlp); 1394 return ndlp->nlp_state; 1395 } 1396 1397 static uint32_t 1398 lpfc_rcv_plogi_reglogin_issue(struct lpfc_vport *vport, 1399 struct lpfc_nodelist *ndlp, 1400 void *arg, 1401 uint32_t evt) 1402 { 1403 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1404 1405 lpfc_rcv_plogi(vport, ndlp, cmdiocb); 1406 return ndlp->nlp_state; 1407 } 1408 1409 static uint32_t 1410 lpfc_rcv_prli_reglogin_issue(struct lpfc_vport *vport, 1411 struct lpfc_nodelist *ndlp, 1412 void *arg, 1413 uint32_t evt) 1414 { 1415 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1416 1417 lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp); 1418 return ndlp->nlp_state; 1419 } 1420 1421 static uint32_t 1422 lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport, 1423 struct lpfc_nodelist *ndlp, 1424 void *arg, 1425 uint32_t evt) 1426 { 1427 struct lpfc_hba *phba = vport->phba; 1428 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1429 LPFC_MBOXQ_t *mb; 1430 LPFC_MBOXQ_t *nextmb; 1431 struct lpfc_dmabuf *mp; 1432 1433 cmdiocb = (struct lpfc_iocbq *) arg; 1434 1435 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */ 1436 if ((mb = phba->sli.mbox_active)) { 1437 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) && 1438 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1439 lpfc_nlp_put(ndlp); 1440 mb->context2 = NULL; 1441 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 1442 } 1443 } 1444 1445 spin_lock_irq(&phba->hbalock); 1446 list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) { 1447 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) && 1448 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1449 mp = (struct lpfc_dmabuf *) (mb->context1); 1450 if (mp) { 1451 __lpfc_mbuf_free(phba, mp->virt, mp->phys); 1452 kfree(mp); 1453 } 1454 lpfc_nlp_put(ndlp); 1455 list_del(&mb->list); 1456 phba->sli.mboxq_cnt--; 1457 mempool_free(mb, phba->mbox_mem_pool); 1458 } 1459 } 1460 spin_unlock_irq(&phba->hbalock); 1461 1462 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 1463 return ndlp->nlp_state; 1464 } 1465 1466 static uint32_t 1467 lpfc_rcv_padisc_reglogin_issue(struct lpfc_vport *vport, 1468 struct lpfc_nodelist *ndlp, 1469 void *arg, 1470 uint32_t evt) 1471 { 1472 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1473 1474 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 1475 return ndlp->nlp_state; 1476 } 1477 1478 static uint32_t 1479 lpfc_rcv_prlo_reglogin_issue(struct lpfc_vport *vport, 1480 struct lpfc_nodelist *ndlp, 1481 void *arg, 1482 uint32_t evt) 1483 { 1484 struct lpfc_iocbq *cmdiocb; 1485 1486 cmdiocb = (struct lpfc_iocbq *) arg; 1487 lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL); 1488 return ndlp->nlp_state; 1489 } 1490 1491 static uint32_t 1492 lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport, 1493 struct lpfc_nodelist *ndlp, 1494 void *arg, 1495 uint32_t evt) 1496 { 1497 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1498 LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg; 1499 MAILBOX_t *mb = &pmb->u.mb; 1500 uint32_t did = mb->un.varWords[1]; 1501 1502 if (mb->mbxStatus) { 1503 /* RegLogin failed */ 1504 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 1505 "0246 RegLogin failed Data: x%x x%x x%x x%x " 1506 "x%x\n", 1507 did, mb->mbxStatus, vport->port_state, 1508 mb->un.varRegLogin.vpi, 1509 mb->un.varRegLogin.rpi); 1510 /* 1511 * If RegLogin failed due to lack of HBA resources do not 1512 * retry discovery. 1513 */ 1514 if (mb->mbxStatus == MBXERR_RPI_FULL) { 1515 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1516 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1517 return ndlp->nlp_state; 1518 } 1519 1520 /* Put ndlp in npr state set plogi timer for 1 sec */ 1521 mod_timer(&ndlp->nlp_delayfunc, 1522 jiffies + msecs_to_jiffies(1000 * 1)); 1523 spin_lock_irq(shost->host_lock); 1524 ndlp->nlp_flag |= NLP_DELAY_TMO; 1525 spin_unlock_irq(shost->host_lock); 1526 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 1527 1528 lpfc_issue_els_logo(vport, ndlp, 0); 1529 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1530 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1531 return ndlp->nlp_state; 1532 } 1533 1534 /* SLI4 ports have preallocated logical rpis. */ 1535 if (vport->phba->sli_rev < LPFC_SLI_REV4) 1536 ndlp->nlp_rpi = mb->un.varWords[0]; 1537 1538 ndlp->nlp_flag |= NLP_RPI_REGISTERED; 1539 1540 /* Only if we are not a fabric nport do we issue PRLI */ 1541 if (!(ndlp->nlp_type & NLP_FABRIC)) { 1542 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1543 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE); 1544 lpfc_issue_els_prli(vport, ndlp, 0); 1545 } else { 1546 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1547 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1548 } 1549 return ndlp->nlp_state; 1550 } 1551 1552 static uint32_t 1553 lpfc_device_rm_reglogin_issue(struct lpfc_vport *vport, 1554 struct lpfc_nodelist *ndlp, 1555 void *arg, 1556 uint32_t evt) 1557 { 1558 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1559 1560 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1561 spin_lock_irq(shost->host_lock); 1562 ndlp->nlp_flag |= NLP_NODEV_REMOVE; 1563 spin_unlock_irq(shost->host_lock); 1564 return ndlp->nlp_state; 1565 } else { 1566 lpfc_drop_node(vport, ndlp); 1567 return NLP_STE_FREED_NODE; 1568 } 1569 } 1570 1571 static uint32_t 1572 lpfc_device_recov_reglogin_issue(struct lpfc_vport *vport, 1573 struct lpfc_nodelist *ndlp, 1574 void *arg, 1575 uint32_t evt) 1576 { 1577 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1578 1579 /* Don't do anything that will mess up processing of the 1580 * previous RSCN. 1581 */ 1582 if (vport->fc_flag & FC_RSCN_DEFERRED) 1583 return ndlp->nlp_state; 1584 1585 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE; 1586 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1587 spin_lock_irq(shost->host_lock); 1588 ndlp->nlp_flag |= NLP_IGNR_REG_CMPL; 1589 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1590 spin_unlock_irq(shost->host_lock); 1591 lpfc_disc_set_adisc(vport, ndlp); 1592 return ndlp->nlp_state; 1593 } 1594 1595 static uint32_t 1596 lpfc_rcv_plogi_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1597 void *arg, uint32_t evt) 1598 { 1599 struct lpfc_iocbq *cmdiocb; 1600 1601 cmdiocb = (struct lpfc_iocbq *) arg; 1602 1603 lpfc_rcv_plogi(vport, ndlp, cmdiocb); 1604 return ndlp->nlp_state; 1605 } 1606 1607 static uint32_t 1608 lpfc_rcv_prli_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1609 void *arg, uint32_t evt) 1610 { 1611 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1612 1613 lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp); 1614 return ndlp->nlp_state; 1615 } 1616 1617 static uint32_t 1618 lpfc_rcv_logo_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1619 void *arg, uint32_t evt) 1620 { 1621 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1622 1623 /* Software abort outstanding PRLI before sending acc */ 1624 lpfc_els_abort(vport->phba, ndlp); 1625 1626 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 1627 return ndlp->nlp_state; 1628 } 1629 1630 static uint32_t 1631 lpfc_rcv_padisc_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1632 void *arg, uint32_t evt) 1633 { 1634 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1635 1636 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 1637 return ndlp->nlp_state; 1638 } 1639 1640 /* This routine is envoked when we rcv a PRLO request from a nport 1641 * we are logged into. We should send back a PRLO rsp setting the 1642 * appropriate bits. 1643 * NEXT STATE = PRLI_ISSUE 1644 */ 1645 static uint32_t 1646 lpfc_rcv_prlo_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1647 void *arg, uint32_t evt) 1648 { 1649 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1650 1651 lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL); 1652 return ndlp->nlp_state; 1653 } 1654 1655 static uint32_t 1656 lpfc_cmpl_prli_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1657 void *arg, uint32_t evt) 1658 { 1659 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1660 struct lpfc_iocbq *cmdiocb, *rspiocb; 1661 struct lpfc_hba *phba = vport->phba; 1662 IOCB_t *irsp; 1663 PRLI *npr; 1664 1665 cmdiocb = (struct lpfc_iocbq *) arg; 1666 rspiocb = cmdiocb->context_un.rsp_iocb; 1667 npr = (PRLI *)lpfc_check_elscmpl_iocb(phba, cmdiocb, rspiocb); 1668 1669 irsp = &rspiocb->iocb; 1670 if (irsp->ulpStatus) { 1671 if ((vport->port_type == LPFC_NPIV_PORT) && 1672 vport->cfg_restrict_login) { 1673 goto out; 1674 } 1675 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE; 1676 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1677 return ndlp->nlp_state; 1678 } 1679 1680 /* Check out PRLI rsp */ 1681 ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR); 1682 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE; 1683 ndlp->nlp_flag &= ~NLP_FIRSTBURST; 1684 if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) && 1685 (npr->prliType == PRLI_FCP_TYPE)) { 1686 if (npr->initiatorFunc) 1687 ndlp->nlp_type |= NLP_FCP_INITIATOR; 1688 if (npr->targetFunc) { 1689 ndlp->nlp_type |= NLP_FCP_TARGET; 1690 if (npr->writeXferRdyDis) 1691 ndlp->nlp_flag |= NLP_FIRSTBURST; 1692 } 1693 if (npr->Retry) 1694 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE; 1695 } 1696 if (!(ndlp->nlp_type & NLP_FCP_TARGET) && 1697 (vport->port_type == LPFC_NPIV_PORT) && 1698 vport->cfg_restrict_login) { 1699 out: 1700 spin_lock_irq(shost->host_lock); 1701 ndlp->nlp_flag |= NLP_TARGET_REMOVE; 1702 spin_unlock_irq(shost->host_lock); 1703 lpfc_issue_els_logo(vport, ndlp, 0); 1704 1705 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE; 1706 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1707 return ndlp->nlp_state; 1708 } 1709 1710 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE; 1711 if (ndlp->nlp_type & NLP_FCP_TARGET) 1712 lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE); 1713 else 1714 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1715 return ndlp->nlp_state; 1716 } 1717 1718 /*! lpfc_device_rm_prli_issue 1719 * 1720 * \pre 1721 * \post 1722 * \param phba 1723 * \param ndlp 1724 * \param arg 1725 * \param evt 1726 * \return uint32_t 1727 * 1728 * \b Description: 1729 * This routine is envoked when we a request to remove a nport we are in the 1730 * process of PRLIing. We should software abort outstanding prli, unreg 1731 * login, send a logout. We will change node state to UNUSED_NODE, put it 1732 * on plogi list so it can be freed when LOGO completes. 1733 * 1734 */ 1735 1736 static uint32_t 1737 lpfc_device_rm_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1738 void *arg, uint32_t evt) 1739 { 1740 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1741 1742 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1743 spin_lock_irq(shost->host_lock); 1744 ndlp->nlp_flag |= NLP_NODEV_REMOVE; 1745 spin_unlock_irq(shost->host_lock); 1746 return ndlp->nlp_state; 1747 } else { 1748 /* software abort outstanding PLOGI */ 1749 lpfc_els_abort(vport->phba, ndlp); 1750 1751 lpfc_drop_node(vport, ndlp); 1752 return NLP_STE_FREED_NODE; 1753 } 1754 } 1755 1756 1757 /*! lpfc_device_recov_prli_issue 1758 * 1759 * \pre 1760 * \post 1761 * \param phba 1762 * \param ndlp 1763 * \param arg 1764 * \param evt 1765 * \return uint32_t 1766 * 1767 * \b Description: 1768 * The routine is envoked when the state of a device is unknown, like 1769 * during a link down. We should remove the nodelist entry from the 1770 * unmapped list, issue a UNREG_LOGIN, do a software abort of the 1771 * outstanding PRLI command, then free the node entry. 1772 */ 1773 static uint32_t 1774 lpfc_device_recov_prli_issue(struct lpfc_vport *vport, 1775 struct lpfc_nodelist *ndlp, 1776 void *arg, 1777 uint32_t evt) 1778 { 1779 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1780 struct lpfc_hba *phba = vport->phba; 1781 1782 /* Don't do anything that will mess up processing of the 1783 * previous RSCN. 1784 */ 1785 if (vport->fc_flag & FC_RSCN_DEFERRED) 1786 return ndlp->nlp_state; 1787 1788 /* software abort outstanding PRLI */ 1789 lpfc_els_abort(phba, ndlp); 1790 1791 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE; 1792 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1793 spin_lock_irq(shost->host_lock); 1794 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1795 spin_unlock_irq(shost->host_lock); 1796 lpfc_disc_set_adisc(vport, ndlp); 1797 return ndlp->nlp_state; 1798 } 1799 1800 static uint32_t 1801 lpfc_rcv_plogi_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1802 void *arg, uint32_t evt) 1803 { 1804 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg; 1805 struct ls_rjt stat; 1806 1807 memset(&stat, 0, sizeof(struct ls_rjt)); 1808 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 1809 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 1810 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 1811 return ndlp->nlp_state; 1812 } 1813 1814 static uint32_t 1815 lpfc_rcv_prli_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1816 void *arg, uint32_t evt) 1817 { 1818 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg; 1819 struct ls_rjt stat; 1820 1821 memset(&stat, 0, sizeof(struct ls_rjt)); 1822 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 1823 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 1824 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 1825 return ndlp->nlp_state; 1826 } 1827 1828 static uint32_t 1829 lpfc_rcv_logo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1830 void *arg, uint32_t evt) 1831 { 1832 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1833 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg; 1834 1835 spin_lock_irq(shost->host_lock); 1836 ndlp->nlp_flag &= NLP_LOGO_ACC; 1837 spin_unlock_irq(shost->host_lock); 1838 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL); 1839 return ndlp->nlp_state; 1840 } 1841 1842 static uint32_t 1843 lpfc_rcv_padisc_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1844 void *arg, uint32_t evt) 1845 { 1846 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg; 1847 struct ls_rjt stat; 1848 1849 memset(&stat, 0, sizeof(struct ls_rjt)); 1850 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 1851 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 1852 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 1853 return ndlp->nlp_state; 1854 } 1855 1856 static uint32_t 1857 lpfc_rcv_prlo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1858 void *arg, uint32_t evt) 1859 { 1860 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg; 1861 struct ls_rjt stat; 1862 1863 memset(&stat, 0, sizeof(struct ls_rjt)); 1864 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 1865 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 1866 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 1867 return ndlp->nlp_state; 1868 } 1869 1870 static uint32_t 1871 lpfc_cmpl_logo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1872 void *arg, uint32_t evt) 1873 { 1874 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1875 1876 ndlp->nlp_prev_state = NLP_STE_LOGO_ISSUE; 1877 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1878 spin_lock_irq(shost->host_lock); 1879 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1880 spin_unlock_irq(shost->host_lock); 1881 lpfc_disc_set_adisc(vport, ndlp); 1882 return ndlp->nlp_state; 1883 } 1884 1885 static uint32_t 1886 lpfc_device_rm_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1887 void *arg, uint32_t evt) 1888 { 1889 /* 1890 * Take no action. If a LOGO is outstanding, then possibly DevLoss has 1891 * timed out and is calling for Device Remove. In this case, the LOGO 1892 * must be allowed to complete in state LOGO_ISSUE so that the rpi 1893 * and other NLP flags are correctly cleaned up. 1894 */ 1895 return ndlp->nlp_state; 1896 } 1897 1898 static uint32_t 1899 lpfc_device_recov_logo_issue(struct lpfc_vport *vport, 1900 struct lpfc_nodelist *ndlp, 1901 void *arg, uint32_t evt) 1902 { 1903 /* 1904 * Device Recovery events have no meaning for a node with a LOGO 1905 * outstanding. The LOGO has to complete first and handle the 1906 * node from that point. 1907 */ 1908 return ndlp->nlp_state; 1909 } 1910 1911 static uint32_t 1912 lpfc_rcv_plogi_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1913 void *arg, uint32_t evt) 1914 { 1915 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1916 1917 lpfc_rcv_plogi(vport, ndlp, cmdiocb); 1918 return ndlp->nlp_state; 1919 } 1920 1921 static uint32_t 1922 lpfc_rcv_prli_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1923 void *arg, uint32_t evt) 1924 { 1925 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1926 1927 lpfc_rcv_prli(vport, ndlp, cmdiocb); 1928 lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp); 1929 return ndlp->nlp_state; 1930 } 1931 1932 static uint32_t 1933 lpfc_rcv_logo_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1934 void *arg, uint32_t evt) 1935 { 1936 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1937 1938 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 1939 return ndlp->nlp_state; 1940 } 1941 1942 static uint32_t 1943 lpfc_rcv_padisc_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1944 void *arg, uint32_t evt) 1945 { 1946 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1947 1948 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 1949 return ndlp->nlp_state; 1950 } 1951 1952 static uint32_t 1953 lpfc_rcv_prlo_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1954 void *arg, uint32_t evt) 1955 { 1956 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1957 1958 lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL); 1959 return ndlp->nlp_state; 1960 } 1961 1962 static uint32_t 1963 lpfc_device_recov_unmap_node(struct lpfc_vport *vport, 1964 struct lpfc_nodelist *ndlp, 1965 void *arg, 1966 uint32_t evt) 1967 { 1968 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1969 1970 ndlp->nlp_prev_state = NLP_STE_UNMAPPED_NODE; 1971 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 1972 spin_lock_irq(shost->host_lock); 1973 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 1974 spin_unlock_irq(shost->host_lock); 1975 lpfc_disc_set_adisc(vport, ndlp); 1976 1977 return ndlp->nlp_state; 1978 } 1979 1980 static uint32_t 1981 lpfc_rcv_plogi_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1982 void *arg, uint32_t evt) 1983 { 1984 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1985 1986 lpfc_rcv_plogi(vport, ndlp, cmdiocb); 1987 return ndlp->nlp_state; 1988 } 1989 1990 static uint32_t 1991 lpfc_rcv_prli_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1992 void *arg, uint32_t evt) 1993 { 1994 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 1995 1996 lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp); 1997 return ndlp->nlp_state; 1998 } 1999 2000 static uint32_t 2001 lpfc_rcv_logo_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2002 void *arg, uint32_t evt) 2003 { 2004 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2005 2006 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 2007 return ndlp->nlp_state; 2008 } 2009 2010 static uint32_t 2011 lpfc_rcv_padisc_mapped_node(struct lpfc_vport *vport, 2012 struct lpfc_nodelist *ndlp, 2013 void *arg, uint32_t evt) 2014 { 2015 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2016 2017 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 2018 return ndlp->nlp_state; 2019 } 2020 2021 static uint32_t 2022 lpfc_rcv_prlo_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2023 void *arg, uint32_t evt) 2024 { 2025 struct lpfc_hba *phba = vport->phba; 2026 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2027 2028 /* flush the target */ 2029 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring], 2030 ndlp->nlp_sid, 0, LPFC_CTX_TGT); 2031 2032 /* Treat like rcv logo */ 2033 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_PRLO); 2034 return ndlp->nlp_state; 2035 } 2036 2037 static uint32_t 2038 lpfc_device_recov_mapped_node(struct lpfc_vport *vport, 2039 struct lpfc_nodelist *ndlp, 2040 void *arg, 2041 uint32_t evt) 2042 { 2043 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2044 2045 ndlp->nlp_prev_state = NLP_STE_MAPPED_NODE; 2046 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 2047 spin_lock_irq(shost->host_lock); 2048 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 2049 spin_unlock_irq(shost->host_lock); 2050 lpfc_disc_set_adisc(vport, ndlp); 2051 return ndlp->nlp_state; 2052 } 2053 2054 static uint32_t 2055 lpfc_rcv_plogi_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2056 void *arg, uint32_t evt) 2057 { 2058 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2059 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2060 2061 /* Ignore PLOGI if we have an outstanding LOGO */ 2062 if (ndlp->nlp_flag & (NLP_LOGO_SND | NLP_LOGO_ACC)) 2063 return ndlp->nlp_state; 2064 if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) { 2065 lpfc_cancel_retry_delay_tmo(vport, ndlp); 2066 spin_lock_irq(shost->host_lock); 2067 ndlp->nlp_flag &= ~(NLP_NPR_ADISC | NLP_NPR_2B_DISC); 2068 spin_unlock_irq(shost->host_lock); 2069 } else if (!(ndlp->nlp_flag & NLP_NPR_2B_DISC)) { 2070 /* send PLOGI immediately, move to PLOGI issue state */ 2071 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) { 2072 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 2073 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE); 2074 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0); 2075 } 2076 } 2077 return ndlp->nlp_state; 2078 } 2079 2080 static uint32_t 2081 lpfc_rcv_prli_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2082 void *arg, uint32_t evt) 2083 { 2084 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2085 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2086 struct ls_rjt stat; 2087 2088 memset(&stat, 0, sizeof (struct ls_rjt)); 2089 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2090 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 2091 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL); 2092 2093 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) { 2094 if (ndlp->nlp_flag & NLP_NPR_ADISC) { 2095 spin_lock_irq(shost->host_lock); 2096 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2097 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 2098 spin_unlock_irq(shost->host_lock); 2099 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE); 2100 lpfc_issue_els_adisc(vport, ndlp, 0); 2101 } else { 2102 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 2103 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE); 2104 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0); 2105 } 2106 } 2107 return ndlp->nlp_state; 2108 } 2109 2110 static uint32_t 2111 lpfc_rcv_logo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2112 void *arg, uint32_t evt) 2113 { 2114 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2115 2116 lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO); 2117 return ndlp->nlp_state; 2118 } 2119 2120 static uint32_t 2121 lpfc_rcv_padisc_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2122 void *arg, uint32_t evt) 2123 { 2124 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2125 2126 lpfc_rcv_padisc(vport, ndlp, cmdiocb); 2127 /* 2128 * Do not start discovery if discovery is about to start 2129 * or discovery in progress for this node. Starting discovery 2130 * here will affect the counting of discovery threads. 2131 */ 2132 if (!(ndlp->nlp_flag & NLP_DELAY_TMO) && 2133 !(ndlp->nlp_flag & NLP_NPR_2B_DISC)) { 2134 if (ndlp->nlp_flag & NLP_NPR_ADISC) { 2135 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2136 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 2137 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE); 2138 lpfc_issue_els_adisc(vport, ndlp, 0); 2139 } else { 2140 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 2141 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE); 2142 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0); 2143 } 2144 } 2145 return ndlp->nlp_state; 2146 } 2147 2148 static uint32_t 2149 lpfc_rcv_prlo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2150 void *arg, uint32_t evt) 2151 { 2152 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2153 struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg; 2154 2155 spin_lock_irq(shost->host_lock); 2156 ndlp->nlp_flag |= NLP_LOGO_ACC; 2157 spin_unlock_irq(shost->host_lock); 2158 2159 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL); 2160 2161 if ((ndlp->nlp_flag & NLP_DELAY_TMO) == 0) { 2162 mod_timer(&ndlp->nlp_delayfunc, 2163 jiffies + msecs_to_jiffies(1000 * 1)); 2164 spin_lock_irq(shost->host_lock); 2165 ndlp->nlp_flag |= NLP_DELAY_TMO; 2166 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2167 spin_unlock_irq(shost->host_lock); 2168 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI; 2169 } else { 2170 spin_lock_irq(shost->host_lock); 2171 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2172 spin_unlock_irq(shost->host_lock); 2173 } 2174 return ndlp->nlp_state; 2175 } 2176 2177 static uint32_t 2178 lpfc_cmpl_plogi_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2179 void *arg, uint32_t evt) 2180 { 2181 struct lpfc_iocbq *cmdiocb, *rspiocb; 2182 IOCB_t *irsp; 2183 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2184 2185 cmdiocb = (struct lpfc_iocbq *) arg; 2186 rspiocb = cmdiocb->context_un.rsp_iocb; 2187 2188 irsp = &rspiocb->iocb; 2189 if (irsp->ulpStatus) { 2190 spin_lock_irq(shost->host_lock); 2191 ndlp->nlp_flag |= NLP_DEFER_RM; 2192 spin_unlock_irq(shost->host_lock); 2193 return NLP_STE_FREED_NODE; 2194 } 2195 return ndlp->nlp_state; 2196 } 2197 2198 static uint32_t 2199 lpfc_cmpl_prli_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2200 void *arg, uint32_t evt) 2201 { 2202 struct lpfc_iocbq *cmdiocb, *rspiocb; 2203 IOCB_t *irsp; 2204 2205 cmdiocb = (struct lpfc_iocbq *) arg; 2206 rspiocb = cmdiocb->context_un.rsp_iocb; 2207 2208 irsp = &rspiocb->iocb; 2209 if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) { 2210 lpfc_drop_node(vport, ndlp); 2211 return NLP_STE_FREED_NODE; 2212 } 2213 return ndlp->nlp_state; 2214 } 2215 2216 static uint32_t 2217 lpfc_cmpl_logo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2218 void *arg, uint32_t evt) 2219 { 2220 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2221 2222 /* For the fabric port just clear the fc flags. */ 2223 if (ndlp->nlp_DID == Fabric_DID) { 2224 spin_lock_irq(shost->host_lock); 2225 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 2226 spin_unlock_irq(shost->host_lock); 2227 } 2228 lpfc_unreg_rpi(vport, ndlp); 2229 return ndlp->nlp_state; 2230 } 2231 2232 static uint32_t 2233 lpfc_cmpl_adisc_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2234 void *arg, uint32_t evt) 2235 { 2236 struct lpfc_iocbq *cmdiocb, *rspiocb; 2237 IOCB_t *irsp; 2238 2239 cmdiocb = (struct lpfc_iocbq *) arg; 2240 rspiocb = cmdiocb->context_un.rsp_iocb; 2241 2242 irsp = &rspiocb->iocb; 2243 if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) { 2244 lpfc_drop_node(vport, ndlp); 2245 return NLP_STE_FREED_NODE; 2246 } 2247 return ndlp->nlp_state; 2248 } 2249 2250 static uint32_t 2251 lpfc_cmpl_reglogin_npr_node(struct lpfc_vport *vport, 2252 struct lpfc_nodelist *ndlp, 2253 void *arg, uint32_t evt) 2254 { 2255 LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg; 2256 MAILBOX_t *mb = &pmb->u.mb; 2257 2258 if (!mb->mbxStatus) { 2259 /* SLI4 ports have preallocated logical rpis. */ 2260 if (vport->phba->sli_rev < LPFC_SLI_REV4) 2261 ndlp->nlp_rpi = mb->un.varWords[0]; 2262 ndlp->nlp_flag |= NLP_RPI_REGISTERED; 2263 } else { 2264 if (ndlp->nlp_flag & NLP_NODEV_REMOVE) { 2265 lpfc_drop_node(vport, ndlp); 2266 return NLP_STE_FREED_NODE; 2267 } 2268 } 2269 return ndlp->nlp_state; 2270 } 2271 2272 static uint32_t 2273 lpfc_device_rm_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2274 void *arg, uint32_t evt) 2275 { 2276 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2277 2278 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 2279 spin_lock_irq(shost->host_lock); 2280 ndlp->nlp_flag |= NLP_NODEV_REMOVE; 2281 spin_unlock_irq(shost->host_lock); 2282 return ndlp->nlp_state; 2283 } 2284 lpfc_drop_node(vport, ndlp); 2285 return NLP_STE_FREED_NODE; 2286 } 2287 2288 static uint32_t 2289 lpfc_device_recov_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2290 void *arg, uint32_t evt) 2291 { 2292 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2293 2294 /* Don't do anything that will mess up processing of the 2295 * previous RSCN. 2296 */ 2297 if (vport->fc_flag & FC_RSCN_DEFERRED) 2298 return ndlp->nlp_state; 2299 2300 lpfc_cancel_retry_delay_tmo(vport, ndlp); 2301 spin_lock_irq(shost->host_lock); 2302 ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC); 2303 spin_unlock_irq(shost->host_lock); 2304 return ndlp->nlp_state; 2305 } 2306 2307 2308 /* This next section defines the NPort Discovery State Machine */ 2309 2310 /* There are 4 different double linked lists nodelist entries can reside on. 2311 * The plogi list and adisc list are used when Link Up discovery or RSCN 2312 * processing is needed. Each list holds the nodes that we will send PLOGI 2313 * or ADISC on. These lists will keep track of what nodes will be effected 2314 * by an RSCN, or a Link Up (Typically, all nodes are effected on Link Up). 2315 * The unmapped_list will contain all nodes that we have successfully logged 2316 * into at the Fibre Channel level. The mapped_list will contain all nodes 2317 * that are mapped FCP targets. 2318 */ 2319 /* 2320 * The bind list is a list of undiscovered (potentially non-existent) nodes 2321 * that we have saved binding information on. This information is used when 2322 * nodes transition from the unmapped to the mapped list. 2323 */ 2324 /* For UNUSED_NODE state, the node has just been allocated . 2325 * For PLOGI_ISSUE and REG_LOGIN_ISSUE, the node is on 2326 * the PLOGI list. For REG_LOGIN_COMPL, the node is taken off the PLOGI list 2327 * and put on the unmapped list. For ADISC processing, the node is taken off 2328 * the ADISC list and placed on either the mapped or unmapped list (depending 2329 * on its previous state). Once on the unmapped list, a PRLI is issued and the 2330 * state changed to PRLI_ISSUE. When the PRLI completion occurs, the state is 2331 * changed to UNMAPPED_NODE. If the completion indicates a mapped 2332 * node, the node is taken off the unmapped list. The binding list is checked 2333 * for a valid binding, or a binding is automatically assigned. If binding 2334 * assignment is unsuccessful, the node is left on the unmapped list. If 2335 * binding assignment is successful, the associated binding list entry (if 2336 * any) is removed, and the node is placed on the mapped list. 2337 */ 2338 /* 2339 * For a Link Down, all nodes on the ADISC, PLOGI, unmapped or mapped 2340 * lists will receive a DEVICE_RECOVERY event. If the linkdown or devloss timers 2341 * expire, all effected nodes will receive a DEVICE_RM event. 2342 */ 2343 /* 2344 * For a Link Up or RSCN, all nodes will move from the mapped / unmapped lists 2345 * to either the ADISC or PLOGI list. After a Nameserver query or ALPA loopmap 2346 * check, additional nodes may be added or removed (via DEVICE_RM) to / from 2347 * the PLOGI or ADISC lists. Once the PLOGI and ADISC lists are populated, 2348 * we will first process the ADISC list. 32 entries are processed initially and 2349 * ADISC is initited for each one. Completions / Events for each node are 2350 * funnelled thru the state machine. As each node finishes ADISC processing, it 2351 * starts ADISC for any nodes waiting for ADISC processing. If no nodes are 2352 * waiting, and the ADISC list count is identically 0, then we are done. For 2353 * Link Up discovery, since all nodes on the PLOGI list are UNREG_LOGIN'ed, we 2354 * can issue a CLEAR_LA and reenable Link Events. Next we will process the PLOGI 2355 * list. 32 entries are processed initially and PLOGI is initited for each one. 2356 * Completions / Events for each node are funnelled thru the state machine. As 2357 * each node finishes PLOGI processing, it starts PLOGI for any nodes waiting 2358 * for PLOGI processing. If no nodes are waiting, and the PLOGI list count is 2359 * indentically 0, then we are done. We have now completed discovery / RSCN 2360 * handling. Upon completion, ALL nodes should be on either the mapped or 2361 * unmapped lists. 2362 */ 2363 2364 static uint32_t (*lpfc_disc_action[NLP_STE_MAX_STATE * NLP_EVT_MAX_EVENT]) 2365 (struct lpfc_vport *, struct lpfc_nodelist *, void *, uint32_t) = { 2366 /* Action routine Event Current State */ 2367 lpfc_rcv_plogi_unused_node, /* RCV_PLOGI UNUSED_NODE */ 2368 lpfc_rcv_els_unused_node, /* RCV_PRLI */ 2369 lpfc_rcv_logo_unused_node, /* RCV_LOGO */ 2370 lpfc_rcv_els_unused_node, /* RCV_ADISC */ 2371 lpfc_rcv_els_unused_node, /* RCV_PDISC */ 2372 lpfc_rcv_els_unused_node, /* RCV_PRLO */ 2373 lpfc_disc_illegal, /* CMPL_PLOGI */ 2374 lpfc_disc_illegal, /* CMPL_PRLI */ 2375 lpfc_cmpl_logo_unused_node, /* CMPL_LOGO */ 2376 lpfc_disc_illegal, /* CMPL_ADISC */ 2377 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2378 lpfc_device_rm_unused_node, /* DEVICE_RM */ 2379 lpfc_device_recov_unused_node, /* DEVICE_RECOVERY */ 2380 2381 lpfc_rcv_plogi_plogi_issue, /* RCV_PLOGI PLOGI_ISSUE */ 2382 lpfc_rcv_prli_plogi_issue, /* RCV_PRLI */ 2383 lpfc_rcv_logo_plogi_issue, /* RCV_LOGO */ 2384 lpfc_rcv_els_plogi_issue, /* RCV_ADISC */ 2385 lpfc_rcv_els_plogi_issue, /* RCV_PDISC */ 2386 lpfc_rcv_els_plogi_issue, /* RCV_PRLO */ 2387 lpfc_cmpl_plogi_plogi_issue, /* CMPL_PLOGI */ 2388 lpfc_disc_illegal, /* CMPL_PRLI */ 2389 lpfc_cmpl_logo_plogi_issue, /* CMPL_LOGO */ 2390 lpfc_disc_illegal, /* CMPL_ADISC */ 2391 lpfc_cmpl_reglogin_plogi_issue,/* CMPL_REG_LOGIN */ 2392 lpfc_device_rm_plogi_issue, /* DEVICE_RM */ 2393 lpfc_device_recov_plogi_issue, /* DEVICE_RECOVERY */ 2394 2395 lpfc_rcv_plogi_adisc_issue, /* RCV_PLOGI ADISC_ISSUE */ 2396 lpfc_rcv_prli_adisc_issue, /* RCV_PRLI */ 2397 lpfc_rcv_logo_adisc_issue, /* RCV_LOGO */ 2398 lpfc_rcv_padisc_adisc_issue, /* RCV_ADISC */ 2399 lpfc_rcv_padisc_adisc_issue, /* RCV_PDISC */ 2400 lpfc_rcv_prlo_adisc_issue, /* RCV_PRLO */ 2401 lpfc_disc_illegal, /* CMPL_PLOGI */ 2402 lpfc_disc_illegal, /* CMPL_PRLI */ 2403 lpfc_disc_illegal, /* CMPL_LOGO */ 2404 lpfc_cmpl_adisc_adisc_issue, /* CMPL_ADISC */ 2405 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2406 lpfc_device_rm_adisc_issue, /* DEVICE_RM */ 2407 lpfc_device_recov_adisc_issue, /* DEVICE_RECOVERY */ 2408 2409 lpfc_rcv_plogi_reglogin_issue, /* RCV_PLOGI REG_LOGIN_ISSUE */ 2410 lpfc_rcv_prli_reglogin_issue, /* RCV_PLOGI */ 2411 lpfc_rcv_logo_reglogin_issue, /* RCV_LOGO */ 2412 lpfc_rcv_padisc_reglogin_issue, /* RCV_ADISC */ 2413 lpfc_rcv_padisc_reglogin_issue, /* RCV_PDISC */ 2414 lpfc_rcv_prlo_reglogin_issue, /* RCV_PRLO */ 2415 lpfc_cmpl_plogi_illegal, /* CMPL_PLOGI */ 2416 lpfc_disc_illegal, /* CMPL_PRLI */ 2417 lpfc_disc_illegal, /* CMPL_LOGO */ 2418 lpfc_disc_illegal, /* CMPL_ADISC */ 2419 lpfc_cmpl_reglogin_reglogin_issue,/* CMPL_REG_LOGIN */ 2420 lpfc_device_rm_reglogin_issue, /* DEVICE_RM */ 2421 lpfc_device_recov_reglogin_issue,/* DEVICE_RECOVERY */ 2422 2423 lpfc_rcv_plogi_prli_issue, /* RCV_PLOGI PRLI_ISSUE */ 2424 lpfc_rcv_prli_prli_issue, /* RCV_PRLI */ 2425 lpfc_rcv_logo_prli_issue, /* RCV_LOGO */ 2426 lpfc_rcv_padisc_prli_issue, /* RCV_ADISC */ 2427 lpfc_rcv_padisc_prli_issue, /* RCV_PDISC */ 2428 lpfc_rcv_prlo_prli_issue, /* RCV_PRLO */ 2429 lpfc_cmpl_plogi_illegal, /* CMPL_PLOGI */ 2430 lpfc_cmpl_prli_prli_issue, /* CMPL_PRLI */ 2431 lpfc_disc_illegal, /* CMPL_LOGO */ 2432 lpfc_disc_illegal, /* CMPL_ADISC */ 2433 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2434 lpfc_device_rm_prli_issue, /* DEVICE_RM */ 2435 lpfc_device_recov_prli_issue, /* DEVICE_RECOVERY */ 2436 2437 lpfc_rcv_plogi_logo_issue, /* RCV_PLOGI LOGO_ISSUE */ 2438 lpfc_rcv_prli_logo_issue, /* RCV_PRLI */ 2439 lpfc_rcv_logo_logo_issue, /* RCV_LOGO */ 2440 lpfc_rcv_padisc_logo_issue, /* RCV_ADISC */ 2441 lpfc_rcv_padisc_logo_issue, /* RCV_PDISC */ 2442 lpfc_rcv_prlo_logo_issue, /* RCV_PRLO */ 2443 lpfc_cmpl_plogi_illegal, /* CMPL_PLOGI */ 2444 lpfc_disc_illegal, /* CMPL_PRLI */ 2445 lpfc_cmpl_logo_logo_issue, /* CMPL_LOGO */ 2446 lpfc_disc_illegal, /* CMPL_ADISC */ 2447 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2448 lpfc_device_rm_logo_issue, /* DEVICE_RM */ 2449 lpfc_device_recov_logo_issue, /* DEVICE_RECOVERY */ 2450 2451 lpfc_rcv_plogi_unmap_node, /* RCV_PLOGI UNMAPPED_NODE */ 2452 lpfc_rcv_prli_unmap_node, /* RCV_PRLI */ 2453 lpfc_rcv_logo_unmap_node, /* RCV_LOGO */ 2454 lpfc_rcv_padisc_unmap_node, /* RCV_ADISC */ 2455 lpfc_rcv_padisc_unmap_node, /* RCV_PDISC */ 2456 lpfc_rcv_prlo_unmap_node, /* RCV_PRLO */ 2457 lpfc_disc_illegal, /* CMPL_PLOGI */ 2458 lpfc_disc_illegal, /* CMPL_PRLI */ 2459 lpfc_disc_illegal, /* CMPL_LOGO */ 2460 lpfc_disc_illegal, /* CMPL_ADISC */ 2461 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2462 lpfc_disc_illegal, /* DEVICE_RM */ 2463 lpfc_device_recov_unmap_node, /* DEVICE_RECOVERY */ 2464 2465 lpfc_rcv_plogi_mapped_node, /* RCV_PLOGI MAPPED_NODE */ 2466 lpfc_rcv_prli_mapped_node, /* RCV_PRLI */ 2467 lpfc_rcv_logo_mapped_node, /* RCV_LOGO */ 2468 lpfc_rcv_padisc_mapped_node, /* RCV_ADISC */ 2469 lpfc_rcv_padisc_mapped_node, /* RCV_PDISC */ 2470 lpfc_rcv_prlo_mapped_node, /* RCV_PRLO */ 2471 lpfc_disc_illegal, /* CMPL_PLOGI */ 2472 lpfc_disc_illegal, /* CMPL_PRLI */ 2473 lpfc_disc_illegal, /* CMPL_LOGO */ 2474 lpfc_disc_illegal, /* CMPL_ADISC */ 2475 lpfc_disc_illegal, /* CMPL_REG_LOGIN */ 2476 lpfc_disc_illegal, /* DEVICE_RM */ 2477 lpfc_device_recov_mapped_node, /* DEVICE_RECOVERY */ 2478 2479 lpfc_rcv_plogi_npr_node, /* RCV_PLOGI NPR_NODE */ 2480 lpfc_rcv_prli_npr_node, /* RCV_PRLI */ 2481 lpfc_rcv_logo_npr_node, /* RCV_LOGO */ 2482 lpfc_rcv_padisc_npr_node, /* RCV_ADISC */ 2483 lpfc_rcv_padisc_npr_node, /* RCV_PDISC */ 2484 lpfc_rcv_prlo_npr_node, /* RCV_PRLO */ 2485 lpfc_cmpl_plogi_npr_node, /* CMPL_PLOGI */ 2486 lpfc_cmpl_prli_npr_node, /* CMPL_PRLI */ 2487 lpfc_cmpl_logo_npr_node, /* CMPL_LOGO */ 2488 lpfc_cmpl_adisc_npr_node, /* CMPL_ADISC */ 2489 lpfc_cmpl_reglogin_npr_node, /* CMPL_REG_LOGIN */ 2490 lpfc_device_rm_npr_node, /* DEVICE_RM */ 2491 lpfc_device_recov_npr_node, /* DEVICE_RECOVERY */ 2492 }; 2493 2494 int 2495 lpfc_disc_state_machine(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2496 void *arg, uint32_t evt) 2497 { 2498 uint32_t cur_state, rc; 2499 uint32_t(*func) (struct lpfc_vport *, struct lpfc_nodelist *, void *, 2500 uint32_t); 2501 uint32_t got_ndlp = 0; 2502 2503 if (lpfc_nlp_get(ndlp)) 2504 got_ndlp = 1; 2505 2506 cur_state = ndlp->nlp_state; 2507 2508 /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */ 2509 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2510 "0211 DSM in event x%x on NPort x%x in " 2511 "state %d Data: x%x\n", 2512 evt, ndlp->nlp_DID, cur_state, ndlp->nlp_flag); 2513 2514 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM, 2515 "DSM in: evt:%d ste:%d did:x%x", 2516 evt, cur_state, ndlp->nlp_DID); 2517 2518 func = lpfc_disc_action[(cur_state * NLP_EVT_MAX_EVENT) + evt]; 2519 rc = (func) (vport, ndlp, arg, evt); 2520 2521 /* DSM out state <rc> on NPort <nlp_DID> */ 2522 if (got_ndlp) { 2523 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2524 "0212 DSM out state %d on NPort x%x Data: x%x\n", 2525 rc, ndlp->nlp_DID, ndlp->nlp_flag); 2526 2527 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM, 2528 "DSM out: ste:%d did:x%x flg:x%x", 2529 rc, ndlp->nlp_DID, ndlp->nlp_flag); 2530 /* Decrement the ndlp reference count held for this function */ 2531 lpfc_nlp_put(ndlp); 2532 } else { 2533 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2534 "0213 DSM out state %d on NPort free\n", rc); 2535 2536 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM, 2537 "DSM out: ste:%d did:x%x flg:x%x", 2538 rc, 0, 0); 2539 } 2540 2541 return rc; 2542 } 2543