aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/lpfc/lpfc_els.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/lpfc/lpfc_els.c')
-rw-r--r--drivers/scsi/lpfc/lpfc_els.c1431
1 files changed, 716 insertions, 715 deletions
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 638b3cd677bd..0af33bead302 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -41,23 +41,20 @@ static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
41static int lpfc_max_els_tries = 3; 41static int lpfc_max_els_tries = 3;
42 42
43static int 43static int
44lpfc_els_chk_latt(struct lpfc_hba * phba) 44lpfc_els_chk_latt(struct lpfc_vport *vport)
45{ 45{
46 struct lpfc_sli *psli; 46 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
47 struct lpfc_hba *phba = vport->phba;
47 LPFC_MBOXQ_t *mbox; 48 LPFC_MBOXQ_t *mbox;
48 uint32_t ha_copy; 49 uint32_t ha_copy;
49 int rc; 50 int rc;
50 51
51 psli = &phba->sli; 52 if (vport->port_state >= LPFC_VPORT_READY ||
52 53 phba->link_state == LPFC_LINK_DOWN)
53 if ((phba->hba_state >= LPFC_HBA_READY) ||
54 (phba->hba_state == LPFC_LINK_DOWN))
55 return 0; 54 return 0;
56 55
57 /* Read the HBA Host Attention Register */ 56 /* Read the HBA Host Attention Register */
58 spin_lock_irq(phba->host->host_lock);
59 ha_copy = readl(phba->HAregaddr); 57 ha_copy = readl(phba->HAregaddr);
60 spin_unlock_irq(phba->host->host_lock);
61 58
62 if (!(ha_copy & HA_LATT)) 59 if (!(ha_copy & HA_LATT))
63 return 0; 60 return 0;
@@ -66,7 +63,7 @@ lpfc_els_chk_latt(struct lpfc_hba * phba)
66 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY, 63 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
67 "%d:0237 Pending Link Event during " 64 "%d:0237 Pending Link Event during "
68 "Discovery: State x%x\n", 65 "Discovery: State x%x\n",
69 phba->brd_no, phba->hba_state); 66 phba->brd_no, phba->pport->port_state);
70 67
71 /* CLEAR_LA should re-enable link attention events and 68 /* CLEAR_LA should re-enable link attention events and
72 * we should then imediately take a LATT event. The 69 * we should then imediately take a LATT event. The
@@ -74,20 +71,23 @@ lpfc_els_chk_latt(struct lpfc_hba * phba)
74 * will cleanup any left over in-progress discovery 71 * will cleanup any left over in-progress discovery
75 * events. 72 * events.
76 */ 73 */
77 spin_lock_irq(phba->host->host_lock); 74 spin_lock_irq(shost->host_lock);
78 phba->fc_flag |= FC_ABORT_DISCOVERY; 75 vport->fc_flag |= FC_ABORT_DISCOVERY;
79 spin_unlock_irq(phba->host->host_lock); 76 spin_unlock_irq(shost->host_lock);
80 77
81 if (phba->hba_state != LPFC_CLEAR_LA) { 78 if (phba->link_state != LPFC_CLEAR_LA) {
82 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 79 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
83 phba->hba_state = LPFC_CLEAR_LA; 80 phba->link_state = LPFC_CLEAR_LA;
84 lpfc_clear_la(phba, mbox); 81 lpfc_clear_la(phba, mbox);
85 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 82 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
86 rc = lpfc_sli_issue_mbox (phba, mbox, 83 mbox->vport = vport;
87 (MBX_NOWAIT | MBX_STOP_IOCB)); 84 printk(KERN_ERR "%s (%d): do clear_la\n",
85 __FUNCTION__, __LINE__);
86 rc = lpfc_sli_issue_mbox(phba, mbox,
87 (MBX_NOWAIT | MBX_STOP_IOCB));
88 if (rc == MBX_NOT_FINISHED) { 88 if (rc == MBX_NOT_FINISHED) {
89 mempool_free(mbox, phba->mbox_mem_pool); 89 mempool_free(mbox, phba->mbox_mem_pool);
90 phba->hba_state = LPFC_HBA_ERROR; 90 phba->link_state = LPFC_HBA_ERROR;
91 } 91 }
92 } 92 }
93 } 93 }
@@ -97,25 +97,23 @@ lpfc_els_chk_latt(struct lpfc_hba * phba)
97} 97}
98 98
99static struct lpfc_iocbq * 99static struct lpfc_iocbq *
100lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp, 100lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
101 uint16_t cmdSize, uint8_t retry, struct lpfc_nodelist * ndlp, 101 uint16_t cmdSize, uint8_t retry,
102 uint32_t did, uint32_t elscmd) 102 struct lpfc_nodelist *ndlp, uint32_t did,
103 uint32_t elscmd)
103{ 104{
104 struct lpfc_sli_ring *pring; 105 struct lpfc_hba *phba = vport->phba;
105 struct lpfc_iocbq *elsiocb; 106 struct lpfc_iocbq *elsiocb;
106 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist; 107 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
107 struct ulp_bde64 *bpl; 108 struct ulp_bde64 *bpl;
108 IOCB_t *icmd; 109 IOCB_t *icmd;
109 110
110 pring = &phba->sli.ring[LPFC_ELS_RING];
111 111
112 if (phba->hba_state < LPFC_LINK_UP) 112 if (!lpfc_is_link_up(phba))
113 return NULL; 113 return NULL;
114 114
115 /* Allocate buffer for command iocb */ 115 /* Allocate buffer for command iocb */
116 spin_lock_irq(phba->host->host_lock);
117 elsiocb = lpfc_sli_get_iocbq(phba); 116 elsiocb = lpfc_sli_get_iocbq(phba);
118 spin_unlock_irq(phba->host->host_lock);
119 117
120 if (elsiocb == NULL) 118 if (elsiocb == NULL)
121 return NULL; 119 return NULL;
@@ -128,9 +126,7 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
128 MEM_PRI, &(pcmd->phys))) == 0)) { 126 MEM_PRI, &(pcmd->phys))) == 0)) {
129 kfree(pcmd); 127 kfree(pcmd);
130 128
131 spin_lock_irq(phba->host->host_lock);
132 lpfc_sli_release_iocbq(phba, elsiocb); 129 lpfc_sli_release_iocbq(phba, elsiocb);
133 spin_unlock_irq(phba->host->host_lock);
134 return NULL; 130 return NULL;
135 } 131 }
136 132
@@ -146,9 +142,7 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
146 kfree(prsp); 142 kfree(prsp);
147 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys); 143 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
148 kfree(pcmd); 144 kfree(pcmd);
149 spin_lock_irq(phba->host->host_lock);
150 lpfc_sli_release_iocbq(phba, elsiocb); 145 lpfc_sli_release_iocbq(phba, elsiocb);
151 spin_unlock_irq(phba->host->host_lock);
152 return NULL; 146 return NULL;
153 } 147 }
154 INIT_LIST_HEAD(&prsp->list); 148 INIT_LIST_HEAD(&prsp->list);
@@ -162,9 +156,7 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
162 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI, 156 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
163 &pbuflist->phys); 157 &pbuflist->phys);
164 if (pbuflist == 0 || pbuflist->virt == 0) { 158 if (pbuflist == 0 || pbuflist->virt == 0) {
165 spin_lock_irq(phba->host->host_lock);
166 lpfc_sli_release_iocbq(phba, elsiocb); 159 lpfc_sli_release_iocbq(phba, elsiocb);
167 spin_unlock_irq(phba->host->host_lock);
168 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys); 160 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
169 lpfc_mbuf_free(phba, prsp->virt, prsp->phys); 161 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
170 kfree(pcmd); 162 kfree(pcmd);
@@ -178,9 +170,9 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
178 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys); 170 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
179 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys); 171 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
180 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL; 172 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
173 icmd->un.elsreq64.remoteID = did; /* DID */
181 if (expectRsp) { 174 if (expectRsp) {
182 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64)); 175 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
183 icmd->un.elsreq64.remoteID = did; /* DID */
184 icmd->ulpCommand = CMD_ELS_REQUEST64_CR; 176 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
185 icmd->ulpTimeout = phba->fc_ratov * 2; 177 icmd->ulpTimeout = phba->fc_ratov * 2;
186 } else { 178 } else {
@@ -213,6 +205,7 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
213 elsiocb->context2 = pcmd; 205 elsiocb->context2 = pcmd;
214 elsiocb->context3 = pbuflist; 206 elsiocb->context3 = pbuflist;
215 elsiocb->retry = retry; 207 elsiocb->retry = retry;
208 elsiocb->vport = vport;
216 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT; 209 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
217 210
218 if (prsp) { 211 if (prsp) {
@@ -223,9 +216,9 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
223 /* Xmit ELS command <elsCmd> to remote NPORT <did> */ 216 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
224 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 217 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
225 "%d:0116 Xmit ELS command x%x to remote " 218 "%d:0116 Xmit ELS command x%x to remote "
226 "NPORT x%x I/O tag: x%x, HBA state: x%x\n", 219 "NPORT x%x I/O tag: x%x, port state: x%x\n",
227 phba->brd_no, elscmd, 220 phba->brd_no, elscmd, did,
228 did, elsiocb->iotag, phba->hba_state); 221 elsiocb->iotag, vport->port_state);
229 } else { 222 } else {
230 /* Xmit ELS response <elsCmd> to remote NPORT <did> */ 223 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
231 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 224 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
@@ -240,16 +233,18 @@ lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
240 233
241 234
242static int 235static int
243lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, 236lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
244 struct serv_parm *sp, IOCB_t *irsp) 237 struct serv_parm *sp, IOCB_t *irsp)
245{ 238{
239 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
240 struct lpfc_hba *phba = vport->phba;
246 LPFC_MBOXQ_t *mbox; 241 LPFC_MBOXQ_t *mbox;
247 struct lpfc_dmabuf *mp; 242 struct lpfc_dmabuf *mp;
248 int rc; 243 int rc;
249 244
250 spin_lock_irq(phba->host->host_lock); 245 spin_lock_irq(shost->host_lock);
251 phba->fc_flag |= FC_FABRIC; 246 vport->fc_flag |= FC_FABRIC;
252 spin_unlock_irq(phba->host->host_lock); 247 spin_unlock_irq(shost->host_lock);
253 248
254 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov); 249 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
255 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */ 250 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
@@ -258,18 +253,18 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
258 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000; 253 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
259 254
260 if (phba->fc_topology == TOPOLOGY_LOOP) { 255 if (phba->fc_topology == TOPOLOGY_LOOP) {
261 spin_lock_irq(phba->host->host_lock); 256 spin_lock_irq(shost->host_lock);
262 phba->fc_flag |= FC_PUBLIC_LOOP; 257 vport->fc_flag |= FC_PUBLIC_LOOP;
263 spin_unlock_irq(phba->host->host_lock); 258 spin_unlock_irq(shost->host_lock);
264 } else { 259 } else {
265 /* 260 /*
266 * If we are a N-port connected to a Fabric, fixup sparam's so 261 * If we are a N-port connected to a Fabric, fixup sparam's so
267 * logins to devices on remote loops work. 262 * logins to devices on remote loops work.
268 */ 263 */
269 phba->fc_sparam.cmn.altBbCredit = 1; 264 vport->fc_sparam.cmn.altBbCredit = 1;
270 } 265 }
271 266
272 phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID; 267 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
273 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name)); 268 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
274 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name)); 269 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
275 ndlp->nlp_class_sup = 0; 270 ndlp->nlp_class_sup = 0;
@@ -285,11 +280,13 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
285 sp->cmn.bbRcvSizeLsb; 280 sp->cmn.bbRcvSizeLsb;
286 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm)); 281 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
287 282
283 ndlp->nlp_sid = irsp->un.ulpWord[4] & Mask_DID;
284
288 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 285 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
289 if (!mbox) 286 if (!mbox)
290 goto fail; 287 goto fail;
291 288
292 phba->hba_state = LPFC_FABRIC_CFG_LINK; 289 vport->port_state = LPFC_FABRIC_CFG_LINK;
293 lpfc_config_link(phba, mbox); 290 lpfc_config_link(phba, mbox);
294 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 291 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
295 292
@@ -300,11 +297,12 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
300 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 297 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
301 if (!mbox) 298 if (!mbox)
302 goto fail; 299 goto fail;
303 300 rc = lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0);
304 if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0)) 301 if (rc)
305 goto fail_free_mbox; 302 goto fail_free_mbox;
306 303
307 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login; 304 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
305 mbox->vport = vport;
308 mbox->context2 = lpfc_nlp_get(ndlp); 306 mbox->context2 = lpfc_nlp_get(ndlp);
309 307
310 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB); 308 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
@@ -328,25 +326,27 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
328 * We FLOGIed into an NPort, initiate pt2pt protocol 326 * We FLOGIed into an NPort, initiate pt2pt protocol
329 */ 327 */
330static int 328static int
331lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp, 329lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
332 struct serv_parm *sp) 330 struct serv_parm *sp)
333{ 331{
332 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
333 struct lpfc_hba *phba = vport->phba;
334 LPFC_MBOXQ_t *mbox; 334 LPFC_MBOXQ_t *mbox;
335 int rc; 335 int rc;
336 336
337 spin_lock_irq(phba->host->host_lock); 337 spin_lock_irq(shost->host_lock);
338 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 338 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
339 spin_unlock_irq(phba->host->host_lock); 339 spin_unlock_irq(shost->host_lock);
340 340
341 phba->fc_edtov = FF_DEF_EDTOV; 341 phba->fc_edtov = FF_DEF_EDTOV;
342 phba->fc_ratov = FF_DEF_RATOV; 342 phba->fc_ratov = FF_DEF_RATOV;
343 rc = memcmp(&phba->fc_portname, &sp->portName, 343 rc = memcmp(&vport->fc_portname, &sp->portName,
344 sizeof(struct lpfc_name)); 344 sizeof(struct lpfc_name));
345 if (rc >= 0) { 345 if (rc >= 0) {
346 /* This side will initiate the PLOGI */ 346 /* This side will initiate the PLOGI */
347 spin_lock_irq(phba->host->host_lock); 347 spin_lock_irq(shost->host_lock);
348 phba->fc_flag |= FC_PT2PT_PLOGI; 348 vport->fc_flag |= FC_PT2PT_PLOGI;
349 spin_unlock_irq(phba->host->host_lock); 349 spin_unlock_irq(shost->host_lock);
350 350
351 /* 351 /*
352 * N_Port ID cannot be 0, set our to LocalID the other 352 * N_Port ID cannot be 0, set our to LocalID the other
@@ -355,7 +355,7 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
355 355
356 /* not equal */ 356 /* not equal */
357 if (rc) 357 if (rc)
358 phba->fc_myDID = PT2PT_LocalID; 358 vport->fc_myDID = PT2PT_LocalID;
359 359
360 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 360 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
361 if (!mbox) 361 if (!mbox)
@@ -372,7 +372,7 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
372 } 372 }
373 lpfc_nlp_put(ndlp); 373 lpfc_nlp_put(ndlp);
374 374
375 ndlp = lpfc_findnode_did(phba, PT2PT_RemoteID); 375 ndlp = lpfc_findnode_did(vport, PT2PT_RemoteID);
376 if (!ndlp) { 376 if (!ndlp) {
377 /* 377 /*
378 * Cannot find existing Fabric ndlp, so allocate a 378 * Cannot find existing Fabric ndlp, so allocate a
@@ -382,26 +382,28 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
382 if (!ndlp) 382 if (!ndlp)
383 goto fail; 383 goto fail;
384 384
385 lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID); 385 lpfc_nlp_init(vport, ndlp, PT2PT_RemoteID);
386 } 386 }
387 387
388 memcpy(&ndlp->nlp_portname, &sp->portName, 388 memcpy(&ndlp->nlp_portname, &sp->portName,
389 sizeof(struct lpfc_name)); 389 sizeof(struct lpfc_name));
390 memcpy(&ndlp->nlp_nodename, &sp->nodeName, 390 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
391 sizeof(struct lpfc_name)); 391 sizeof(struct lpfc_name));
392 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE); 392 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
393 spin_lock_irq(shost->host_lock);
393 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 394 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
395 spin_unlock_irq(shost->host_lock);
394 } else { 396 } else {
395 /* This side will wait for the PLOGI */ 397 /* This side will wait for the PLOGI */
396 lpfc_nlp_put(ndlp); 398 lpfc_nlp_put(ndlp);
397 } 399 }
398 400
399 spin_lock_irq(phba->host->host_lock); 401 spin_lock_irq(shost->host_lock);
400 phba->fc_flag |= FC_PT2PT; 402 vport->fc_flag |= FC_PT2PT;
401 spin_unlock_irq(phba->host->host_lock); 403 spin_unlock_irq(shost->host_lock);
402 404
403 /* Start discovery - this should just do CLEAR_LA */ 405 /* Start discovery - this should just do CLEAR_LA */
404 lpfc_disc_start(phba); 406 lpfc_disc_start(vport);
405 return 0; 407 return 0;
406 fail: 408 fail:
407 return -ENXIO; 409 return -ENXIO;
@@ -411,6 +413,8 @@ static void
411lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 413lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
412 struct lpfc_iocbq *rspiocb) 414 struct lpfc_iocbq *rspiocb)
413{ 415{
416 struct lpfc_vport *vport = cmdiocb->vport;
417 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
414 IOCB_t *irsp = &rspiocb->iocb; 418 IOCB_t *irsp = &rspiocb->iocb;
415 struct lpfc_nodelist *ndlp = cmdiocb->context1; 419 struct lpfc_nodelist *ndlp = cmdiocb->context1;
416 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp; 420 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
@@ -418,21 +422,20 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
418 int rc; 422 int rc;
419 423
420 /* Check to see if link went down during discovery */ 424 /* Check to see if link went down during discovery */
421 if (lpfc_els_chk_latt(phba)) { 425 if (lpfc_els_chk_latt(vport)) {
422 lpfc_nlp_put(ndlp); 426 lpfc_nlp_put(ndlp);
423 goto out; 427 goto out;
424 } 428 }
425 429
426 if (irsp->ulpStatus) { 430 if (irsp->ulpStatus) {
427 /* Check for retry */ 431 /* Check for retry */
428 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 432 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
429 /* ELS command is being retried */
430 goto out; 433 goto out;
431 } 434
432 /* FLOGI failed, so there is no fabric */ 435 /* FLOGI failed, so there is no fabric */
433 spin_lock_irq(phba->host->host_lock); 436 spin_lock_irq(shost->host_lock);
434 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 437 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
435 spin_unlock_irq(phba->host->host_lock); 438 spin_unlock_irq(shost->host_lock);
436 439
437 /* If private loop, then allow max outstanding els to be 440 /* If private loop, then allow max outstanding els to be
438 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no 441 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
@@ -469,15 +472,15 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
469 irsp->un.ulpWord[4], sp->cmn.e_d_tov, 472 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
470 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution); 473 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
471 474
472 if (phba->hba_state == LPFC_FLOGI) { 475 if (vport->port_state == LPFC_FLOGI) {
473 /* 476 /*
474 * If Common Service Parameters indicate Nport 477 * If Common Service Parameters indicate Nport
475 * we are point to point, if Fport we are Fabric. 478 * we are point to point, if Fport we are Fabric.
476 */ 479 */
477 if (sp->cmn.fPort) 480 if (sp->cmn.fPort)
478 rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp); 481 rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
479 else 482 else
480 rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp); 483 rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
481 484
482 if (!rc) 485 if (!rc)
483 goto out; 486 goto out;
@@ -490,10 +493,10 @@ flogifail:
490 (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED && 493 (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
491 irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) { 494 irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) {
492 /* FLOGI failed, so just use loop map to make discovery list */ 495 /* FLOGI failed, so just use loop map to make discovery list */
493 lpfc_disc_list_loopmap(phba); 496 lpfc_disc_list_loopmap(vport);
494 497
495 /* Start discovery */ 498 /* Start discovery */
496 lpfc_disc_start(phba); 499 lpfc_disc_start(vport);
497 } 500 }
498 501
499out: 502out:
@@ -501,9 +504,10 @@ out:
501} 504}
502 505
503static int 506static int
504lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 507lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
505 uint8_t retry) 508 uint8_t retry)
506{ 509{
510 struct lpfc_hba *phba = vport->phba;
507 struct serv_parm *sp; 511 struct serv_parm *sp;
508 IOCB_t *icmd; 512 IOCB_t *icmd;
509 struct lpfc_iocbq *elsiocb; 513 struct lpfc_iocbq *elsiocb;
@@ -516,8 +520,8 @@ lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
516 pring = &phba->sli.ring[LPFC_ELS_RING]; 520 pring = &phba->sli.ring[LPFC_ELS_RING];
517 521
518 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm)); 522 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
519 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp, 523 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
520 ndlp->nlp_DID, ELS_CMD_FLOGI); 524 ndlp->nlp_DID, ELS_CMD_FLOGI);
521 if (!elsiocb) 525 if (!elsiocb)
522 return 1; 526 return 1;
523 527
@@ -527,7 +531,7 @@ lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
527 /* For FLOGI request, remainder of payload is service parameters */ 531 /* For FLOGI request, remainder of payload is service parameters */
528 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI; 532 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
529 pcmd += sizeof (uint32_t); 533 pcmd += sizeof (uint32_t);
530 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 534 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
531 sp = (struct serv_parm *) pcmd; 535 sp = (struct serv_parm *) pcmd;
532 536
533 /* Setup CSPs accordingly for Fabric */ 537 /* Setup CSPs accordingly for Fabric */
@@ -543,14 +547,12 @@ lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
543 547
544 tmo = phba->fc_ratov; 548 tmo = phba->fc_ratov;
545 phba->fc_ratov = LPFC_DISC_FLOGI_TMO; 549 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
546 lpfc_set_disctmo(phba); 550 lpfc_set_disctmo(vport);
547 phba->fc_ratov = tmo; 551 phba->fc_ratov = tmo;
548 552
549 phba->fc_stat.elsXmitFLOGI++; 553 phba->fc_stat.elsXmitFLOGI++;
550 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi; 554 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
551 spin_lock_irq(phba->host->host_lock);
552 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 555 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
553 spin_unlock_irq(phba->host->host_lock);
554 if (rc == IOCB_ERROR) { 556 if (rc == IOCB_ERROR) {
555 lpfc_els_free_iocb(phba, elsiocb); 557 lpfc_els_free_iocb(phba, elsiocb);
556 return 1; 558 return 1;
@@ -559,7 +561,7 @@ lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
559} 561}
560 562
561int 563int
562lpfc_els_abort_flogi(struct lpfc_hba * phba) 564lpfc_els_abort_flogi(struct lpfc_hba *phba)
563{ 565{
564 struct lpfc_sli_ring *pring; 566 struct lpfc_sli_ring *pring;
565 struct lpfc_iocbq *iocb, *next_iocb; 567 struct lpfc_iocbq *iocb, *next_iocb;
@@ -577,62 +579,65 @@ lpfc_els_abort_flogi(struct lpfc_hba * phba)
577 * Check the txcmplq for an iocb that matches the nport the driver is 579 * Check the txcmplq for an iocb that matches the nport the driver is
578 * searching for. 580 * searching for.
579 */ 581 */
580 spin_lock_irq(phba->host->host_lock); 582 spin_lock_irq(&phba->hbalock);
581 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) { 583 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
582 icmd = &iocb->iocb; 584 icmd = &iocb->iocb;
583 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) { 585 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
586 icmd->un.elsreq64.bdl.ulpIoTag32) {
584 ndlp = (struct lpfc_nodelist *)(iocb->context1); 587 ndlp = (struct lpfc_nodelist *)(iocb->context1);
585 if (ndlp && (ndlp->nlp_DID == Fabric_DID)) 588 if (ndlp && (ndlp->nlp_DID == Fabric_DID))
586 lpfc_sli_issue_abort_iotag(phba, pring, iocb); 589 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
587 } 590 }
588 } 591 }
589 spin_unlock_irq(phba->host->host_lock); 592 spin_unlock_irq(&phba->hbalock);
590 593
591 return 0; 594 return 0;
592} 595}
593 596
594int 597int
595lpfc_initial_flogi(struct lpfc_hba *phba) 598lpfc_initial_flogi(struct lpfc_vport *vport)
596{ 599{
600 struct lpfc_hba *phba = vport->phba;
597 struct lpfc_nodelist *ndlp; 601 struct lpfc_nodelist *ndlp;
598 602
599 /* First look for the Fabric ndlp */ 603 /* First look for the Fabric ndlp */
600 ndlp = lpfc_findnode_did(phba, Fabric_DID); 604 ndlp = lpfc_findnode_did(vport, Fabric_DID);
601 if (!ndlp) { 605 if (!ndlp) {
602 /* Cannot find existing Fabric ndlp, so allocate a new one */ 606 /* Cannot find existing Fabric ndlp, so allocate a new one */
603 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 607 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
604 if (!ndlp) 608 if (!ndlp)
605 return 0; 609 return 0;
606 lpfc_nlp_init(phba, ndlp, Fabric_DID); 610 lpfc_nlp_init(vport, ndlp, Fabric_DID);
607 } else { 611 } else {
608 lpfc_dequeue_node(phba, ndlp); 612 lpfc_dequeue_node(vport, ndlp);
609 } 613 }
610 if (lpfc_issue_els_flogi(phba, ndlp, 0)) { 614 if (lpfc_issue_els_flogi(vport, ndlp, 0)) {
611 lpfc_nlp_put(ndlp); 615 lpfc_nlp_put(ndlp);
612 } 616 }
613 return 1; 617 return 1;
614} 618}
615 619
616static void 620static void
617lpfc_more_plogi(struct lpfc_hba * phba) 621lpfc_more_plogi(struct lpfc_vport *vport)
618{ 622{
619 int sentplogi; 623 int sentplogi;
624 struct lpfc_hba *phba = vport->phba;
620 625
621 if (phba->num_disc_nodes) 626 if (vport->num_disc_nodes)
622 phba->num_disc_nodes--; 627 vport->num_disc_nodes--;
623 628
624 /* Continue discovery with <num_disc_nodes> PLOGIs to go */ 629 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
625 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 630 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
626 "%d:0232 Continue discovery with %d PLOGIs to go " 631 "%d:0232 Continue discovery with %d PLOGIs to go "
627 "Data: x%x x%x x%x\n", 632 "Data: x%x x%x x%x\n",
628 phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt, 633 phba->brd_no, vport->num_disc_nodes,
629 phba->fc_flag, phba->hba_state); 634 vport->fc_plogi_cnt, vport->fc_flag, vport->port_state);
630 635
631 /* Check to see if there are more PLOGIs to be sent */ 636 /* Check to see if there are more PLOGIs to be sent */
632 if (phba->fc_flag & FC_NLP_MORE) { 637 if (vport->fc_flag & FC_NLP_MORE)
633 /* go thru NPR list and issue any remaining ELS PLOGIs */ 638 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
634 sentplogi = lpfc_els_disc_plogi(phba); 639 sentplogi = lpfc_els_disc_plogi(vport);
635 } 640
636 return; 641 return;
637} 642}
638 643
@@ -640,6 +645,7 @@ static struct lpfc_nodelist *
640lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp, 645lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp,
641 struct lpfc_nodelist *ndlp) 646 struct lpfc_nodelist *ndlp)
642{ 647{
648 struct lpfc_vport *vport = ndlp->vport;
643 struct lpfc_nodelist *new_ndlp; 649 struct lpfc_nodelist *new_ndlp;
644 uint32_t *lp; 650 uint32_t *lp;
645 struct serv_parm *sp; 651 struct serv_parm *sp;
@@ -659,43 +665,45 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp,
659 /* Now we find out if the NPort we are logging into, matches the WWPN 665 /* Now we find out if the NPort we are logging into, matches the WWPN
660 * we have for that ndlp. If not, we have some work to do. 666 * we have for that ndlp. If not, we have some work to do.
661 */ 667 */
662 new_ndlp = lpfc_findnode_wwpn(phba, &sp->portName); 668 new_ndlp = lpfc_findnode_wwpn(vport, &sp->portName);
663 669
664 if (new_ndlp == ndlp) 670 if (new_ndlp == ndlp)
665 return ndlp; 671 return ndlp;
666 672
667 if (!new_ndlp) { 673 if (!new_ndlp) {
668 rc = 674 rc = memcmp(&ndlp->nlp_portname, name,
669 memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)); 675 sizeof(struct lpfc_name));
670 if (!rc) 676 if (!rc)
671 return ndlp; 677 return ndlp;
672 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC); 678 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
673 if (!new_ndlp) 679 if (!new_ndlp)
674 return ndlp; 680 return ndlp;
675 681
676 lpfc_nlp_init(phba, new_ndlp, ndlp->nlp_DID); 682 lpfc_nlp_init(vport, new_ndlp, ndlp->nlp_DID);
677 } 683 }
678 684
679 lpfc_unreg_rpi(phba, new_ndlp); 685 lpfc_unreg_rpi(vport, new_ndlp);
680 new_ndlp->nlp_DID = ndlp->nlp_DID; 686 new_ndlp->nlp_DID = ndlp->nlp_DID;
681 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state; 687 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
682 lpfc_nlp_set_state(phba, new_ndlp, ndlp->nlp_state); 688 lpfc_nlp_set_state(vport, new_ndlp, ndlp->nlp_state);
683 689
684 /* Move this back to NPR list */ 690 /* Move this back to NPR state */
685 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0) 691 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
686 lpfc_drop_node(phba, ndlp); 692 lpfc_drop_node(vport, ndlp);
687 else { 693 else {
688 lpfc_unreg_rpi(phba, ndlp); 694 lpfc_unreg_rpi(vport, ndlp);
689 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */ 695 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
690 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE); 696 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
691 } 697 }
692 return new_ndlp; 698 return new_ndlp;
693} 699}
694 700
695static void 701static void
696lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 702lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
697 struct lpfc_iocbq * rspiocb) 703 struct lpfc_iocbq *rspiocb)
698{ 704{
705 struct lpfc_vport *vport = cmdiocb->vport;
706 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
699 IOCB_t *irsp; 707 IOCB_t *irsp;
700 struct lpfc_nodelist *ndlp; 708 struct lpfc_nodelist *ndlp;
701 struct lpfc_dmabuf *prsp; 709 struct lpfc_dmabuf *prsp;
@@ -705,17 +713,17 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
705 cmdiocb->context_un.rsp_iocb = rspiocb; 713 cmdiocb->context_un.rsp_iocb = rspiocb;
706 714
707 irsp = &rspiocb->iocb; 715 irsp = &rspiocb->iocb;
708 ndlp = lpfc_findnode_did(phba, irsp->un.elsreq64.remoteID); 716 ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
709 if (!ndlp) 717 if (!ndlp)
710 goto out; 718 goto out;
711 719
712 /* Since ndlp can be freed in the disc state machine, note if this node 720 /* Since ndlp can be freed in the disc state machine, note if this node
713 * is being used during discovery. 721 * is being used during discovery.
714 */ 722 */
723 spin_lock_irq(shost->host_lock);
715 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 724 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
716 spin_lock_irq(phba->host->host_lock);
717 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 725 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
718 spin_unlock_irq(phba->host->host_lock); 726 spin_unlock_irq(shost->host_lock);
719 rc = 0; 727 rc = 0;
720 728
721 /* PLOGI completes to NPort <nlp_DID> */ 729 /* PLOGI completes to NPort <nlp_DID> */
@@ -724,13 +732,13 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
724 "Data: x%x x%x x%x x%x x%x\n", 732 "Data: x%x x%x x%x x%x x%x\n",
725 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 733 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
726 irsp->un.ulpWord[4], irsp->ulpTimeout, disc, 734 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
727 phba->num_disc_nodes); 735 vport->num_disc_nodes);
728 736
729 /* Check to see if link went down during discovery */ 737 /* Check to see if link went down during discovery */
730 if (lpfc_els_chk_latt(phba)) { 738 if (lpfc_els_chk_latt(vport)) {
731 spin_lock_irq(phba->host->host_lock); 739 spin_lock_irq(shost->host_lock);
732 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 740 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
733 spin_unlock_irq(phba->host->host_lock); 741 spin_unlock_irq(shost->host_lock);
734 goto out; 742 goto out;
735 } 743 }
736 744
@@ -743,9 +751,9 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
743 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 751 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
744 /* ELS command is being retried */ 752 /* ELS command is being retried */
745 if (disc) { 753 if (disc) {
746 spin_lock_irq(phba->host->host_lock); 754 spin_lock_irq(shost->host_lock);
747 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 755 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
748 spin_unlock_irq(phba->host->host_lock); 756 spin_unlock_irq(shost->host_lock);
749 } 757 }
750 goto out; 758 goto out;
751 } 759 }
@@ -758,7 +766,7 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
758 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 766 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
759 rc = NLP_STE_FREED_NODE; 767 rc = NLP_STE_FREED_NODE;
760 } else { 768 } else {
761 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb, 769 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
762 NLP_EVT_CMPL_PLOGI); 770 NLP_EVT_CMPL_PLOGI);
763 } 771 }
764 } else { 772 } else {
@@ -767,32 +775,32 @@ lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
767 cmdiocb->context2)->list.next, 775 cmdiocb->context2)->list.next,
768 struct lpfc_dmabuf, list); 776 struct lpfc_dmabuf, list);
769 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp); 777 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
770 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb, 778 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
771 NLP_EVT_CMPL_PLOGI); 779 NLP_EVT_CMPL_PLOGI);
772 } 780 }
773 781
774 if (disc && phba->num_disc_nodes) { 782 if (disc && vport->num_disc_nodes) {
775 /* Check to see if there are more PLOGIs to be sent */ 783 /* Check to see if there are more PLOGIs to be sent */
776 lpfc_more_plogi(phba); 784 lpfc_more_plogi(vport);
777 785
778 if (phba->num_disc_nodes == 0) { 786 if (vport->num_disc_nodes == 0) {
779 spin_lock_irq(phba->host->host_lock); 787 spin_lock_irq(shost->host_lock);
780 phba->fc_flag &= ~FC_NDISC_ACTIVE; 788 vport->fc_flag &= ~FC_NDISC_ACTIVE;
781 spin_unlock_irq(phba->host->host_lock); 789 spin_unlock_irq(shost->host_lock);
782 790
783 lpfc_can_disctmo(phba); 791 lpfc_can_disctmo(vport);
784 if (phba->fc_flag & FC_RSCN_MODE) { 792 if (vport->fc_flag & FC_RSCN_MODE) {
785 /* 793 /*
786 * Check to see if more RSCNs came in while 794 * Check to see if more RSCNs came in while
787 * we were processing this one. 795 * we were processing this one.
788 */ 796 */
789 if ((phba->fc_rscn_id_cnt == 0) && 797 if ((vport->fc_rscn_id_cnt == 0) &&
790 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 798 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
791 spin_lock_irq(phba->host->host_lock); 799 spin_lock_irq(shost->host_lock);
792 phba->fc_flag &= ~FC_RSCN_MODE; 800 vport->fc_flag &= ~FC_RSCN_MODE;
793 spin_unlock_irq(phba->host->host_lock); 801 spin_unlock_irq(shost->host_lock);
794 } else { 802 } else {
795 lpfc_els_handle_rscn(phba); 803 lpfc_els_handle_rscn(vport);
796 } 804 }
797 } 805 }
798 } 806 }
@@ -804,8 +812,9 @@ out:
804} 812}
805 813
806int 814int
807lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry) 815lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
808{ 816{
817 struct lpfc_hba *phba = vport->phba;
809 struct serv_parm *sp; 818 struct serv_parm *sp;
810 IOCB_t *icmd; 819 IOCB_t *icmd;
811 struct lpfc_iocbq *elsiocb; 820 struct lpfc_iocbq *elsiocb;
@@ -818,8 +827,8 @@ lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
818 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 827 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
819 828
820 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm)); 829 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
821 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, NULL, did, 830 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, NULL, did,
822 ELS_CMD_PLOGI); 831 ELS_CMD_PLOGI);
823 if (!elsiocb) 832 if (!elsiocb)
824 return 1; 833 return 1;
825 834
@@ -829,7 +838,7 @@ lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
829 /* For PLOGI request, remainder of payload is service parameters */ 838 /* For PLOGI request, remainder of payload is service parameters */
830 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI; 839 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
831 pcmd += sizeof (uint32_t); 840 pcmd += sizeof (uint32_t);
832 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 841 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
833 sp = (struct serv_parm *) pcmd; 842 sp = (struct serv_parm *) pcmd;
834 843
835 if (sp->cmn.fcphLow < FC_PH_4_3) 844 if (sp->cmn.fcphLow < FC_PH_4_3)
@@ -840,20 +849,19 @@ lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
840 849
841 phba->fc_stat.elsXmitPLOGI++; 850 phba->fc_stat.elsXmitPLOGI++;
842 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi; 851 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
843 spin_lock_irq(phba->host->host_lock);
844 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 852 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
845 spin_unlock_irq(phba->host->host_lock);
846 lpfc_els_free_iocb(phba, elsiocb); 853 lpfc_els_free_iocb(phba, elsiocb);
847 return 1; 854 return 1;
848 } 855 }
849 spin_unlock_irq(phba->host->host_lock);
850 return 0; 856 return 0;
851} 857}
852 858
853static void 859static void
854lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 860lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
855 struct lpfc_iocbq * rspiocb) 861 struct lpfc_iocbq *rspiocb)
856{ 862{
863 struct lpfc_vport *vport = cmdiocb->vport;
864 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
857 IOCB_t *irsp; 865 IOCB_t *irsp;
858 struct lpfc_sli *psli; 866 struct lpfc_sli *psli;
859 struct lpfc_nodelist *ndlp; 867 struct lpfc_nodelist *ndlp;
@@ -864,9 +872,9 @@ lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
864 872
865 irsp = &(rspiocb->iocb); 873 irsp = &(rspiocb->iocb);
866 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 874 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
867 spin_lock_irq(phba->host->host_lock); 875 spin_lock_irq(shost->host_lock);
868 ndlp->nlp_flag &= ~NLP_PRLI_SND; 876 ndlp->nlp_flag &= ~NLP_PRLI_SND;
869 spin_unlock_irq(phba->host->host_lock); 877 spin_unlock_irq(shost->host_lock);
870 878
871 /* PRLI completes to NPort <nlp_DID> */ 879 /* PRLI completes to NPort <nlp_DID> */
872 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 880 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
@@ -874,11 +882,11 @@ lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
874 "Data: x%x x%x x%x x%x\n", 882 "Data: x%x x%x x%x x%x\n",
875 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 883 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
876 irsp->un.ulpWord[4], irsp->ulpTimeout, 884 irsp->un.ulpWord[4], irsp->ulpTimeout,
877 phba->num_disc_nodes); 885 vport->num_disc_nodes);
878 886
879 phba->fc_prli_sent--; 887 vport->fc_prli_sent--;
880 /* Check to see if link went down during discovery */ 888 /* Check to see if link went down during discovery */
881 if (lpfc_els_chk_latt(phba)) 889 if (lpfc_els_chk_latt(vport))
882 goto out; 890 goto out;
883 891
884 if (irsp->ulpStatus) { 892 if (irsp->ulpStatus) {
@@ -895,12 +903,13 @@ lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
895 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 903 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
896 goto out; 904 goto out;
897 } else { 905 } else {
898 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 906 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
899 NLP_EVT_CMPL_PRLI); 907 NLP_EVT_CMPL_PRLI);
900 } 908 }
901 } else { 909 } else {
902 /* Good status, call state machine */ 910 /* Good status, call state machine */
903 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI); 911 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
912 NLP_EVT_CMPL_PRLI);
904 } 913 }
905 914
906out: 915out:
@@ -909,9 +918,11 @@ out:
909} 918}
910 919
911int 920int
912lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 921lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
913 uint8_t retry) 922 uint8_t retry)
914{ 923{
924 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
925 struct lpfc_hba *phba = vport->phba;
915 PRLI *npr; 926 PRLI *npr;
916 IOCB_t *icmd; 927 IOCB_t *icmd;
917 struct lpfc_iocbq *elsiocb; 928 struct lpfc_iocbq *elsiocb;
@@ -924,8 +935,8 @@ lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
924 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 935 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
925 936
926 cmdsize = (sizeof (uint32_t) + sizeof (PRLI)); 937 cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
927 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp, 938 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
928 ndlp->nlp_DID, ELS_CMD_PRLI); 939 ndlp->nlp_DID, ELS_CMD_PRLI);
929 if (!elsiocb) 940 if (!elsiocb)
930 return 1; 941 return 1;
931 942
@@ -957,79 +968,80 @@ lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
957 968
958 phba->fc_stat.elsXmitPRLI++; 969 phba->fc_stat.elsXmitPRLI++;
959 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli; 970 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
960 spin_lock_irq(phba->host->host_lock); 971 spin_lock_irq(shost->host_lock);
961 ndlp->nlp_flag |= NLP_PRLI_SND; 972 ndlp->nlp_flag |= NLP_PRLI_SND;
973 spin_unlock_irq(shost->host_lock);
962 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 974 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
975 spin_lock_irq(shost->host_lock);
963 ndlp->nlp_flag &= ~NLP_PRLI_SND; 976 ndlp->nlp_flag &= ~NLP_PRLI_SND;
964 spin_unlock_irq(phba->host->host_lock); 977 spin_unlock_irq(shost->host_lock);
965 lpfc_els_free_iocb(phba, elsiocb); 978 lpfc_els_free_iocb(phba, elsiocb);
966 return 1; 979 return 1;
967 } 980 }
968 spin_unlock_irq(phba->host->host_lock); 981 vport->fc_prli_sent++;
969 phba->fc_prli_sent++;
970 return 0; 982 return 0;
971} 983}
972 984
973static void 985static void
974lpfc_more_adisc(struct lpfc_hba * phba) 986lpfc_more_adisc(struct lpfc_vport *vport)
975{ 987{
976 int sentadisc; 988 int sentadisc;
989 struct lpfc_hba *phba = vport->phba;
977 990
978 if (phba->num_disc_nodes) 991 if (vport->num_disc_nodes)
979 phba->num_disc_nodes--; 992 vport->num_disc_nodes--;
980 993
981 /* Continue discovery with <num_disc_nodes> ADISCs to go */ 994 /* Continue discovery with <num_disc_nodes> ADISCs to go */
982 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 995 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
983 "%d:0210 Continue discovery with %d ADISCs to go " 996 "%d:0210 Continue discovery with %d ADISCs to go "
984 "Data: x%x x%x x%x\n", 997 "Data: x%x x%x x%x\n",
985 phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt, 998 phba->brd_no, vport->num_disc_nodes,
986 phba->fc_flag, phba->hba_state); 999 vport->fc_adisc_cnt, vport->fc_flag, vport->port_state);
987 1000
988 /* Check to see if there are more ADISCs to be sent */ 1001 /* Check to see if there are more ADISCs to be sent */
989 if (phba->fc_flag & FC_NLP_MORE) { 1002 if (vport->fc_flag & FC_NLP_MORE) {
990 lpfc_set_disctmo(phba); 1003 lpfc_set_disctmo(vport);
991 1004 /* go thru NPR nodes and issue any remaining ELS ADISCs */
992 /* go thru NPR list and issue any remaining ELS ADISCs */ 1005 sentadisc = lpfc_els_disc_adisc(vport);
993 sentadisc = lpfc_els_disc_adisc(phba);
994 } 1006 }
995 return; 1007 return;
996} 1008}
997 1009
998static void 1010static void
999lpfc_rscn_disc(struct lpfc_hba * phba) 1011lpfc_rscn_disc(struct lpfc_vport *vport)
1000{ 1012{
1013 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1014
1001 /* RSCN discovery */ 1015 /* RSCN discovery */
1002 /* go thru NPR list and issue ELS PLOGIs */ 1016 /* go thru NPR nodes and issue ELS PLOGIs */
1003 if (phba->fc_npr_cnt) { 1017 if (vport->fc_npr_cnt)
1004 if (lpfc_els_disc_plogi(phba)) 1018 if (lpfc_els_disc_plogi(vport))
1005 return; 1019 return;
1006 } 1020
1007 if (phba->fc_flag & FC_RSCN_MODE) { 1021 if (vport->fc_flag & FC_RSCN_MODE) {
1008 /* Check to see if more RSCNs came in while we were 1022 /* Check to see if more RSCNs came in while we were
1009 * processing this one. 1023 * processing this one.
1010 */ 1024 */
1011 if ((phba->fc_rscn_id_cnt == 0) && 1025 if ((vport->fc_rscn_id_cnt == 0) &&
1012 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 1026 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
1013 spin_lock_irq(phba->host->host_lock); 1027 spin_lock_irq(shost->host_lock);
1014 phba->fc_flag &= ~FC_RSCN_MODE; 1028 vport->fc_flag &= ~FC_RSCN_MODE;
1015 spin_unlock_irq(phba->host->host_lock); 1029 spin_unlock_irq(shost->host_lock);
1016 } else { 1030 } else {
1017 lpfc_els_handle_rscn(phba); 1031 lpfc_els_handle_rscn(vport);
1018 } 1032 }
1019 } 1033 }
1020} 1034}
1021 1035
1022static void 1036static void
1023lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1037lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1024 struct lpfc_iocbq * rspiocb) 1038 struct lpfc_iocbq *rspiocb)
1025{ 1039{
1040 struct lpfc_vport *vport = cmdiocb->vport;
1041 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1026 IOCB_t *irsp; 1042 IOCB_t *irsp;
1027 struct lpfc_sli *psli;
1028 struct lpfc_nodelist *ndlp; 1043 struct lpfc_nodelist *ndlp;
1029 LPFC_MBOXQ_t *mbox; 1044 int disc;
1030 int disc, rc;
1031
1032 psli = &phba->sli;
1033 1045
1034 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1046 /* we pass cmdiocb to state machine which needs rspiocb as well */
1035 cmdiocb->context_un.rsp_iocb = rspiocb; 1047 cmdiocb->context_un.rsp_iocb = rspiocb;
@@ -1040,10 +1052,10 @@ lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1040 /* Since ndlp can be freed in the disc state machine, note if this node 1052 /* Since ndlp can be freed in the disc state machine, note if this node
1041 * is being used during discovery. 1053 * is being used during discovery.
1042 */ 1054 */
1055 spin_lock_irq(shost->host_lock);
1043 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC); 1056 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1044 spin_lock_irq(phba->host->host_lock);
1045 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC); 1057 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
1046 spin_unlock_irq(phba->host->host_lock); 1058 spin_unlock_irq(shost->host_lock);
1047 1059
1048 /* ADISC completes to NPort <nlp_DID> */ 1060 /* ADISC completes to NPort <nlp_DID> */
1049 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1061 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
@@ -1051,13 +1063,13 @@ lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1051 "Data: x%x x%x x%x x%x x%x\n", 1063 "Data: x%x x%x x%x x%x x%x\n",
1052 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 1064 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1053 irsp->un.ulpWord[4], irsp->ulpTimeout, disc, 1065 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
1054 phba->num_disc_nodes); 1066 vport->num_disc_nodes);
1055 1067
1056 /* Check to see if link went down during discovery */ 1068 /* Check to see if link went down during discovery */
1057 if (lpfc_els_chk_latt(phba)) { 1069 if (lpfc_els_chk_latt(vport)) {
1058 spin_lock_irq(phba->host->host_lock); 1070 spin_lock_irq(shost->host_lock);
1059 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1071 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1060 spin_unlock_irq(phba->host->host_lock); 1072 spin_unlock_irq(shost->host_lock);
1061 goto out; 1073 goto out;
1062 } 1074 }
1063 1075
@@ -1066,10 +1078,10 @@ lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1066 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 1078 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1067 /* ELS command is being retried */ 1079 /* ELS command is being retried */
1068 if (disc) { 1080 if (disc) {
1069 spin_lock_irq(phba->host->host_lock); 1081 spin_lock_irq(shost->host_lock);
1070 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1082 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1071 spin_unlock_irq(phba->host->host_lock); 1083 spin_unlock_irq(shost->host_lock);
1072 lpfc_set_disctmo(phba); 1084 lpfc_set_disctmo(vport);
1073 } 1085 }
1074 goto out; 1086 goto out;
1075 } 1087 }
@@ -1079,54 +1091,30 @@ lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1079 ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) && 1091 ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
1080 (irsp->un.ulpWord[4] != IOERR_LINK_DOWN) && 1092 (irsp->un.ulpWord[4] != IOERR_LINK_DOWN) &&
1081 (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) { 1093 (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) {
1082 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1094 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1083 NLP_EVT_CMPL_ADISC); 1095 NLP_EVT_CMPL_ADISC);
1084 } 1096 }
1085 } else { 1097 } else {
1086 /* Good status, call state machine */ 1098 /* Good status, call state machine */
1087 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1099 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1088 NLP_EVT_CMPL_ADISC); 1100 NLP_EVT_CMPL_ADISC);
1089 } 1101 }
1090 1102
1091 if (disc && phba->num_disc_nodes) { 1103 if (disc && vport->num_disc_nodes) {
1092 /* Check to see if there are more ADISCs to be sent */ 1104 /* Check to see if there are more ADISCs to be sent */
1093 lpfc_more_adisc(phba); 1105 lpfc_more_adisc(vport);
1094 1106
1095 /* Check to see if we are done with ADISC authentication */ 1107 /* Check to see if we are done with ADISC authentication */
1096 if (phba->num_disc_nodes == 0) { 1108 if (vport->num_disc_nodes == 0) {
1097 lpfc_can_disctmo(phba); 1109 lpfc_can_disctmo(vport);
1098 /* If we get here, there is nothing left to wait for */ 1110 /* If we get here, there is nothing left to wait for */
1099 if ((phba->hba_state < LPFC_HBA_READY) && 1111 if (vport->port_state < LPFC_VPORT_READY &&
1100 (phba->hba_state != LPFC_CLEAR_LA)) { 1112 phba->link_state != LPFC_CLEAR_LA) {
1101 /* Link up discovery */ 1113 if (vport->port_type == LPFC_PHYSICAL_PORT) {
1102 if ((mbox = mempool_alloc(phba->mbox_mem_pool, 1114 lpfc_issue_clear_la(phba, vport);
1103 GFP_KERNEL))) {
1104 phba->hba_state = LPFC_CLEAR_LA;
1105 lpfc_clear_la(phba, mbox);
1106 mbox->mbox_cmpl =
1107 lpfc_mbx_cmpl_clear_la;
1108 rc = lpfc_sli_issue_mbox
1109 (phba, mbox,
1110 (MBX_NOWAIT | MBX_STOP_IOCB));
1111 if (rc == MBX_NOT_FINISHED) {
1112 mempool_free(mbox,
1113 phba->mbox_mem_pool);
1114 lpfc_disc_flush_list(phba);
1115 psli->ring[(psli->extra_ring)].
1116 flag &=
1117 ~LPFC_STOP_IOCB_EVENT;
1118 psli->ring[(psli->fcp_ring)].
1119 flag &=
1120 ~LPFC_STOP_IOCB_EVENT;
1121 psli->ring[(psli->next_ring)].
1122 flag &=
1123 ~LPFC_STOP_IOCB_EVENT;
1124 phba->hba_state =
1125 LPFC_HBA_READY;
1126 }
1127 } 1115 }
1128 } else { 1116 } else {
1129 lpfc_rscn_disc(phba); 1117 lpfc_rscn_disc(vport);
1130 } 1118 }
1131 } 1119 }
1132 } 1120 }
@@ -1136,23 +1124,22 @@ out:
1136} 1124}
1137 1125
1138int 1126int
1139lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 1127lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1140 uint8_t retry) 1128 uint8_t retry)
1141{ 1129{
1130 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1131 struct lpfc_hba *phba = vport->phba;
1142 ADISC *ap; 1132 ADISC *ap;
1143 IOCB_t *icmd; 1133 IOCB_t *icmd;
1144 struct lpfc_iocbq *elsiocb; 1134 struct lpfc_iocbq *elsiocb;
1145 struct lpfc_sli_ring *pring; 1135 struct lpfc_sli *psli = &phba->sli;
1146 struct lpfc_sli *psli; 1136 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
1147 uint8_t *pcmd; 1137 uint8_t *pcmd;
1148 uint16_t cmdsize; 1138 uint16_t cmdsize;
1149 1139
1150 psli = &phba->sli;
1151 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1152
1153 cmdsize = (sizeof (uint32_t) + sizeof (ADISC)); 1140 cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
1154 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp, 1141 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1155 ndlp->nlp_DID, ELS_CMD_ADISC); 1142 ndlp->nlp_DID, ELS_CMD_ADISC);
1156 if (!elsiocb) 1143 if (!elsiocb)
1157 return 1; 1144 return 1;
1158 1145
@@ -1166,41 +1153,43 @@ lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1166 /* Fill in ADISC payload */ 1153 /* Fill in ADISC payload */
1167 ap = (ADISC *) pcmd; 1154 ap = (ADISC *) pcmd;
1168 ap->hardAL_PA = phba->fc_pref_ALPA; 1155 ap->hardAL_PA = phba->fc_pref_ALPA;
1169 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 1156 memcpy(&ap->portName, &vport->fc_portname, sizeof (struct lpfc_name));
1170 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 1157 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
1171 ap->DID = be32_to_cpu(phba->fc_myDID); 1158 ap->DID = be32_to_cpu(vport->fc_myDID);
1172 1159
1173 phba->fc_stat.elsXmitADISC++; 1160 phba->fc_stat.elsXmitADISC++;
1174 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc; 1161 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1175 spin_lock_irq(phba->host->host_lock); 1162 spin_lock_irq(shost->host_lock);
1176 ndlp->nlp_flag |= NLP_ADISC_SND; 1163 ndlp->nlp_flag |= NLP_ADISC_SND;
1164 spin_unlock_irq(shost->host_lock);
1177 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1165 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1166 spin_lock_irq(shost->host_lock);
1178 ndlp->nlp_flag &= ~NLP_ADISC_SND; 1167 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1179 spin_unlock_irq(phba->host->host_lock); 1168 spin_unlock_irq(shost->host_lock);
1180 lpfc_els_free_iocb(phba, elsiocb); 1169 lpfc_els_free_iocb(phba, elsiocb);
1181 return 1; 1170 return 1;
1182 } 1171 }
1183 spin_unlock_irq(phba->host->host_lock);
1184 return 0; 1172 return 0;
1185} 1173}
1186 1174
1187static void 1175static void
1188lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1176lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1189 struct lpfc_iocbq * rspiocb) 1177 struct lpfc_iocbq *rspiocb)
1190{ 1178{
1179 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1180 struct lpfc_vport *vport = ndlp->vport;
1181 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1191 IOCB_t *irsp; 1182 IOCB_t *irsp;
1192 struct lpfc_sli *psli; 1183 struct lpfc_sli *psli;
1193 struct lpfc_nodelist *ndlp;
1194 1184
1195 psli = &phba->sli; 1185 psli = &phba->sli;
1196 /* we pass cmdiocb to state machine which needs rspiocb as well */ 1186 /* we pass cmdiocb to state machine which needs rspiocb as well */
1197 cmdiocb->context_un.rsp_iocb = rspiocb; 1187 cmdiocb->context_un.rsp_iocb = rspiocb;
1198 1188
1199 irsp = &(rspiocb->iocb); 1189 irsp = &(rspiocb->iocb);
1200 ndlp = (struct lpfc_nodelist *) cmdiocb->context1; 1190 spin_lock_irq(shost->host_lock);
1201 spin_lock_irq(phba->host->host_lock);
1202 ndlp->nlp_flag &= ~NLP_LOGO_SND; 1191 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1203 spin_unlock_irq(phba->host->host_lock); 1192 spin_unlock_irq(shost->host_lock);
1204 1193
1205 /* LOGO completes to NPort <nlp_DID> */ 1194 /* LOGO completes to NPort <nlp_DID> */
1206 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1195 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
@@ -1208,18 +1197,17 @@ lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1208 "Data: x%x x%x x%x x%x\n", 1197 "Data: x%x x%x x%x x%x\n",
1209 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus, 1198 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1210 irsp->un.ulpWord[4], irsp->ulpTimeout, 1199 irsp->un.ulpWord[4], irsp->ulpTimeout,
1211 phba->num_disc_nodes); 1200 vport->num_disc_nodes);
1212 1201
1213 /* Check to see if link went down during discovery */ 1202 /* Check to see if link went down during discovery */
1214 if (lpfc_els_chk_latt(phba)) 1203 if (lpfc_els_chk_latt(vport))
1215 goto out; 1204 goto out;
1216 1205
1217 if (irsp->ulpStatus) { 1206 if (irsp->ulpStatus) {
1218 /* Check for retry */ 1207 /* Check for retry */
1219 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) { 1208 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
1220 /* ELS command is being retried */ 1209 /* ELS command is being retried */
1221 goto out; 1210 goto out;
1222 }
1223 /* LOGO failed */ 1211 /* LOGO failed */
1224 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */ 1212 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1225 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) && 1213 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
@@ -1228,14 +1216,15 @@ lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1228 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) { 1216 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1229 goto out; 1217 goto out;
1230 } else { 1218 } else {
1231 lpfc_disc_state_machine(phba, ndlp, cmdiocb, 1219 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1232 NLP_EVT_CMPL_LOGO); 1220 NLP_EVT_CMPL_LOGO);
1233 } 1221 }
1234 } else { 1222 } else {
1235 /* Good status, call state machine. 1223 /* Good status, call state machine.
1236 * This will unregister the rpi if needed. 1224 * This will unregister the rpi if needed.
1237 */ 1225 */
1238 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO); 1226 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1227 NLP_EVT_CMPL_LOGO);
1239 } 1228 }
1240 1229
1241out: 1230out:
@@ -1244,9 +1233,11 @@ out:
1244} 1233}
1245 1234
1246int 1235int
1247lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 1236lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1248 uint8_t retry) 1237 uint8_t retry)
1249{ 1238{
1239 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1240 struct lpfc_hba *phba = vport->phba;
1250 IOCB_t *icmd; 1241 IOCB_t *icmd;
1251 struct lpfc_iocbq *elsiocb; 1242 struct lpfc_iocbq *elsiocb;
1252 struct lpfc_sli_ring *pring; 1243 struct lpfc_sli_ring *pring;
@@ -1258,8 +1249,8 @@ lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1258 pring = &psli->ring[LPFC_ELS_RING]; 1249 pring = &psli->ring[LPFC_ELS_RING];
1259 1250
1260 cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name); 1251 cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name);
1261 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp, 1252 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1262 ndlp->nlp_DID, ELS_CMD_LOGO); 1253 ndlp->nlp_DID, ELS_CMD_LOGO);
1263 if (!elsiocb) 1254 if (!elsiocb)
1264 return 1; 1255 return 1;
1265 1256
@@ -1269,28 +1260,30 @@ lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1269 pcmd += sizeof (uint32_t); 1260 pcmd += sizeof (uint32_t);
1270 1261
1271 /* Fill in LOGO payload */ 1262 /* Fill in LOGO payload */
1272 *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID); 1263 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
1273 pcmd += sizeof (uint32_t); 1264 pcmd += sizeof (uint32_t);
1274 memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name)); 1265 memcpy(pcmd, &vport->fc_portname, sizeof (struct lpfc_name));
1275 1266
1276 phba->fc_stat.elsXmitLOGO++; 1267 phba->fc_stat.elsXmitLOGO++;
1277 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo; 1268 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1278 spin_lock_irq(phba->host->host_lock); 1269 spin_lock_irq(shost->host_lock);
1279 ndlp->nlp_flag |= NLP_LOGO_SND; 1270 ndlp->nlp_flag |= NLP_LOGO_SND;
1271 spin_unlock_irq(shost->host_lock);
1280 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1272 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1273 spin_lock_irq(shost->host_lock);
1281 ndlp->nlp_flag &= ~NLP_LOGO_SND; 1274 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1282 spin_unlock_irq(phba->host->host_lock); 1275 spin_unlock_irq(shost->host_lock);
1283 lpfc_els_free_iocb(phba, elsiocb); 1276 lpfc_els_free_iocb(phba, elsiocb);
1284 return 1; 1277 return 1;
1285 } 1278 }
1286 spin_unlock_irq(phba->host->host_lock);
1287 return 0; 1279 return 0;
1288} 1280}
1289 1281
1290static void 1282static void
1291lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1283lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1292 struct lpfc_iocbq * rspiocb) 1284 struct lpfc_iocbq *rspiocb)
1293{ 1285{
1286 struct lpfc_vport *vport = cmdiocb->vport;
1294 IOCB_t *irsp; 1287 IOCB_t *irsp;
1295 1288
1296 irsp = &rspiocb->iocb; 1289 irsp = &rspiocb->iocb;
@@ -1305,14 +1298,15 @@ lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1305 irsp->un.ulpWord[4], irsp->ulpTimeout); 1298 irsp->un.ulpWord[4], irsp->ulpTimeout);
1306 1299
1307 /* Check to see if link went down during discovery */ 1300 /* Check to see if link went down during discovery */
1308 lpfc_els_chk_latt(phba); 1301 lpfc_els_chk_latt(vport);
1309 lpfc_els_free_iocb(phba, cmdiocb); 1302 lpfc_els_free_iocb(phba, cmdiocb);
1310 return; 1303 return;
1311} 1304}
1312 1305
1313int 1306int
1314lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry) 1307lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1315{ 1308{
1309 struct lpfc_hba *phba = vport->phba;
1316 IOCB_t *icmd; 1310 IOCB_t *icmd;
1317 struct lpfc_iocbq *elsiocb; 1311 struct lpfc_iocbq *elsiocb;
1318 struct lpfc_sli_ring *pring; 1312 struct lpfc_sli_ring *pring;
@@ -1328,10 +1322,11 @@ lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1328 if (!ndlp) 1322 if (!ndlp)
1329 return 1; 1323 return 1;
1330 1324
1331 lpfc_nlp_init(phba, ndlp, nportid); 1325 lpfc_nlp_init(vport, ndlp, nportid);
1326
1327 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1328 ndlp->nlp_DID, ELS_CMD_SCR);
1332 1329
1333 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1334 ndlp->nlp_DID, ELS_CMD_SCR);
1335 if (!elsiocb) { 1330 if (!elsiocb) {
1336 lpfc_nlp_put(ndlp); 1331 lpfc_nlp_put(ndlp);
1337 return 1; 1332 return 1;
@@ -1349,21 +1344,19 @@ lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1349 1344
1350 phba->fc_stat.elsXmitSCR++; 1345 phba->fc_stat.elsXmitSCR++;
1351 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 1346 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1352 spin_lock_irq(phba->host->host_lock);
1353 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1347 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1354 spin_unlock_irq(phba->host->host_lock);
1355 lpfc_nlp_put(ndlp); 1348 lpfc_nlp_put(ndlp);
1356 lpfc_els_free_iocb(phba, elsiocb); 1349 lpfc_els_free_iocb(phba, elsiocb);
1357 return 1; 1350 return 1;
1358 } 1351 }
1359 spin_unlock_irq(phba->host->host_lock);
1360 lpfc_nlp_put(ndlp); 1352 lpfc_nlp_put(ndlp);
1361 return 0; 1353 return 0;
1362} 1354}
1363 1355
1364static int 1356static int
1365lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry) 1357lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1366{ 1358{
1359 struct lpfc_hba *phba = vport->phba;
1367 IOCB_t *icmd; 1360 IOCB_t *icmd;
1368 struct lpfc_iocbq *elsiocb; 1361 struct lpfc_iocbq *elsiocb;
1369 struct lpfc_sli_ring *pring; 1362 struct lpfc_sli_ring *pring;
@@ -1381,10 +1374,11 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1381 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 1374 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1382 if (!ndlp) 1375 if (!ndlp)
1383 return 1; 1376 return 1;
1384 lpfc_nlp_init(phba, ndlp, nportid);
1385 1377
1386 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp, 1378 lpfc_nlp_init(vport, ndlp, nportid);
1387 ndlp->nlp_DID, ELS_CMD_RNID); 1379
1380 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1381 ndlp->nlp_DID, ELS_CMD_RNID);
1388 if (!elsiocb) { 1382 if (!elsiocb) {
1389 lpfc_nlp_put(ndlp); 1383 lpfc_nlp_put(ndlp);
1390 return 1; 1384 return 1;
@@ -1401,13 +1395,14 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1401 memset(fp, 0, sizeof (FARP)); 1395 memset(fp, 0, sizeof (FARP));
1402 lp = (uint32_t *) pcmd; 1396 lp = (uint32_t *) pcmd;
1403 *lp++ = be32_to_cpu(nportid); 1397 *lp++ = be32_to_cpu(nportid);
1404 *lp++ = be32_to_cpu(phba->fc_myDID); 1398 *lp++ = be32_to_cpu(vport->fc_myDID);
1405 fp->Rflags = 0; 1399 fp->Rflags = 0;
1406 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE); 1400 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1407 1401
1408 memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name)); 1402 memcpy(&fp->RportName, &vport->fc_portname, sizeof (struct lpfc_name));
1409 memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 1403 memcpy(&fp->RnodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
1410 if ((ondlp = lpfc_findnode_did(phba, nportid))) { 1404 ondlp = lpfc_findnode_did(vport, nportid);
1405 if (ondlp) {
1411 memcpy(&fp->OportName, &ondlp->nlp_portname, 1406 memcpy(&fp->OportName, &ondlp->nlp_portname,
1412 sizeof (struct lpfc_name)); 1407 sizeof (struct lpfc_name));
1413 memcpy(&fp->OnodeName, &ondlp->nlp_nodename, 1408 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
@@ -1416,22 +1411,23 @@ lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1416 1411
1417 phba->fc_stat.elsXmitFARPR++; 1412 phba->fc_stat.elsXmitFARPR++;
1418 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd; 1413 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1419 spin_lock_irq(phba->host->host_lock);
1420 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) { 1414 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1421 spin_unlock_irq(phba->host->host_lock);
1422 lpfc_nlp_put(ndlp); 1415 lpfc_nlp_put(ndlp);
1423 lpfc_els_free_iocb(phba, elsiocb); 1416 lpfc_els_free_iocb(phba, elsiocb);
1424 return 1; 1417 return 1;
1425 } 1418 }
1426 spin_unlock_irq(phba->host->host_lock);
1427 lpfc_nlp_put(ndlp); 1419 lpfc_nlp_put(ndlp);
1428 return 0; 1420 return 0;
1429} 1421}
1430 1422
1431void 1423void
1432lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp) 1424lpfc_cancel_retry_delay_tmo(struct lpfc_vport *vport, struct lpfc_nodelist *nlp)
1433{ 1425{
1426 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1427
1428 spin_lock_irq(shost->host_lock);
1434 nlp->nlp_flag &= ~NLP_DELAY_TMO; 1429 nlp->nlp_flag &= ~NLP_DELAY_TMO;
1430 spin_unlock_irq(shost->host_lock);
1435 del_timer_sync(&nlp->nlp_delayfunc); 1431 del_timer_sync(&nlp->nlp_delayfunc);
1436 nlp->nlp_last_elscmd = 0; 1432 nlp->nlp_last_elscmd = 0;
1437 1433
@@ -1439,28 +1435,36 @@ lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
1439 list_del_init(&nlp->els_retry_evt.evt_listp); 1435 list_del_init(&nlp->els_retry_evt.evt_listp);
1440 1436
1441 if (nlp->nlp_flag & NLP_NPR_2B_DISC) { 1437 if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
1438 spin_lock_irq(shost->host_lock);
1442 nlp->nlp_flag &= ~NLP_NPR_2B_DISC; 1439 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1443 if (phba->num_disc_nodes) { 1440 spin_unlock_irq(shost->host_lock);
1441 if (vport->num_disc_nodes) {
1444 /* Check to see if there are more 1442 /* Check to see if there are more
1445 * PLOGIs to be sent 1443 * PLOGIs to be sent
1446 */ 1444 */
1447 lpfc_more_plogi(phba); 1445 lpfc_more_plogi(vport);
1448 1446
1449 if (phba->num_disc_nodes == 0) { 1447 if (vport->num_disc_nodes == 0) {
1450 phba->fc_flag &= ~FC_NDISC_ACTIVE; 1448 spin_lock_irq(shost->host_lock);
1451 lpfc_can_disctmo(phba); 1449 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1452 if (phba->fc_flag & FC_RSCN_MODE) { 1450 spin_unlock_irq(shost->host_lock);
1451 lpfc_can_disctmo(vport);
1452 if (vport->fc_flag & FC_RSCN_MODE) {
1453 /* 1453 /*
1454 * Check to see if more RSCNs 1454 * Check to see if more RSCNs
1455 * came in while we were 1455 * came in while we were
1456 * processing this one. 1456 * processing this one.
1457 */ 1457 */
1458 if((phba->fc_rscn_id_cnt==0) && 1458 if (!vport->fc_rscn_id_cnt &&
1459 !(phba->fc_flag & FC_RSCN_DISCOVERY)) { 1459 !(vport->fc_flag &
1460 phba->fc_flag &= ~FC_RSCN_MODE; 1460 FC_RSCN_DISCOVERY)) {
1461 spin_lock_irq(shost->host_lock);
1462 vport->fc_flag &= ~FC_RSCN_MODE;
1463 spin_unlock_irq(
1464 shost->host_lock);
1461 } 1465 }
1462 else { 1466 else {
1463 lpfc_els_handle_rscn(phba); 1467 lpfc_els_handle_rscn(vport);
1464 } 1468 }
1465 } 1469 }
1466 } 1470 }
@@ -1472,18 +1476,20 @@ lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
1472void 1476void
1473lpfc_els_retry_delay(unsigned long ptr) 1477lpfc_els_retry_delay(unsigned long ptr)
1474{ 1478{
1475 struct lpfc_nodelist *ndlp; 1479 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
1476 struct lpfc_hba *phba; 1480 struct lpfc_vport *vport = ndlp->vport;
1481 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1482 struct lpfc_hba *phba = vport->phba;
1477 unsigned long iflag; 1483 unsigned long iflag;
1478 struct lpfc_work_evt *evtp; 1484 struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;
1479 1485
1480 ndlp = (struct lpfc_nodelist *)ptr; 1486 ndlp = (struct lpfc_nodelist *) ptr;
1481 phba = ndlp->nlp_phba; 1487 phba = ndlp->vport->phba;
1482 evtp = &ndlp->els_retry_evt; 1488 evtp = &ndlp->els_retry_evt;
1483 1489
1484 spin_lock_irqsave(phba->host->host_lock, iflag); 1490 spin_lock_irqsave(shost->host_lock, iflag);
1485 if (!list_empty(&evtp->evt_listp)) { 1491 if (!list_empty(&evtp->evt_listp)) {
1486 spin_unlock_irqrestore(phba->host->host_lock, iflag); 1492 spin_unlock_irqrestore(shost->host_lock, iflag);
1487 return; 1493 return;
1488 } 1494 }
1489 1495
@@ -1493,31 +1499,29 @@ lpfc_els_retry_delay(unsigned long ptr)
1493 if (phba->work_wait) 1499 if (phba->work_wait)
1494 wake_up(phba->work_wait); 1500 wake_up(phba->work_wait);
1495 1501
1496 spin_unlock_irqrestore(phba->host->host_lock, iflag); 1502 spin_unlock_irqrestore(shost->host_lock, iflag);
1497 return; 1503 return;
1498} 1504}
1499 1505
1500void 1506void
1501lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp) 1507lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1502{ 1508{
1503 struct lpfc_hba *phba; 1509 struct lpfc_vport *vport = ndlp->vport;
1504 uint32_t cmd; 1510 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1505 uint32_t did; 1511 uint32_t cmd, did, retry;
1506 uint8_t retry;
1507 1512
1508 phba = ndlp->nlp_phba; 1513 spin_lock_irq(shost->host_lock);
1509 spin_lock_irq(phba->host->host_lock);
1510 did = ndlp->nlp_DID; 1514 did = ndlp->nlp_DID;
1511 cmd = ndlp->nlp_last_elscmd; 1515 cmd = ndlp->nlp_last_elscmd;
1512 ndlp->nlp_last_elscmd = 0; 1516 ndlp->nlp_last_elscmd = 0;
1513 1517
1514 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) { 1518 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1515 spin_unlock_irq(phba->host->host_lock); 1519 spin_unlock_irq(shost->host_lock);
1516 return; 1520 return;
1517 } 1521 }
1518 1522
1519 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 1523 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1520 spin_unlock_irq(phba->host->host_lock); 1524 spin_unlock_irq(shost->host_lock);
1521 /* 1525 /*
1522 * If a discovery event readded nlp_delayfunc after timer 1526 * If a discovery event readded nlp_delayfunc after timer
1523 * firing and before processing the timer, cancel the 1527 * firing and before processing the timer, cancel the
@@ -1528,30 +1532,30 @@ lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1528 1532
1529 switch (cmd) { 1533 switch (cmd) {
1530 case ELS_CMD_FLOGI: 1534 case ELS_CMD_FLOGI:
1531 lpfc_issue_els_flogi(phba, ndlp, retry); 1535 lpfc_issue_els_flogi(vport, ndlp, retry);
1532 break; 1536 break;
1533 case ELS_CMD_PLOGI: 1537 case ELS_CMD_PLOGI:
1534 if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) { 1538 if (!lpfc_issue_els_plogi(vport, ndlp->nlp_DID, retry)) {
1535 ndlp->nlp_prev_state = ndlp->nlp_state; 1539 ndlp->nlp_prev_state = ndlp->nlp_state;
1536 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE); 1540 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
1537 } 1541 }
1538 break; 1542 break;
1539 case ELS_CMD_ADISC: 1543 case ELS_CMD_ADISC:
1540 if (!lpfc_issue_els_adisc(phba, ndlp, retry)) { 1544 if (!lpfc_issue_els_adisc(vport, ndlp, retry)) {
1541 ndlp->nlp_prev_state = ndlp->nlp_state; 1545 ndlp->nlp_prev_state = ndlp->nlp_state;
1542 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE); 1546 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1543 } 1547 }
1544 break; 1548 break;
1545 case ELS_CMD_PRLI: 1549 case ELS_CMD_PRLI:
1546 if (!lpfc_issue_els_prli(phba, ndlp, retry)) { 1550 if (!lpfc_issue_els_prli(vport, ndlp, retry)) {
1547 ndlp->nlp_prev_state = ndlp->nlp_state; 1551 ndlp->nlp_prev_state = ndlp->nlp_state;
1548 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE); 1552 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1549 } 1553 }
1550 break; 1554 break;
1551 case ELS_CMD_LOGO: 1555 case ELS_CMD_LOGO:
1552 if (!lpfc_issue_els_logo(phba, ndlp, retry)) { 1556 if (!lpfc_issue_els_logo(vport, ndlp, retry)) {
1553 ndlp->nlp_prev_state = ndlp->nlp_state; 1557 ndlp->nlp_prev_state = ndlp->nlp_state;
1554 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE); 1558 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1555 } 1559 }
1556 break; 1560 break;
1557 } 1561 }
@@ -1559,26 +1563,20 @@ lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1559} 1563}
1560 1564
1561static int 1565static int
1562lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1566lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1563 struct lpfc_iocbq * rspiocb) 1567 struct lpfc_iocbq *rspiocb)
1564{ 1568{
1565 IOCB_t *irsp; 1569 struct lpfc_vport *vport = cmdiocb->vport;
1566 struct lpfc_dmabuf *pcmd; 1570 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1567 struct lpfc_nodelist *ndlp; 1571 IOCB_t *irsp = &rspiocb->iocb;
1572 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1573 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1568 uint32_t *elscmd; 1574 uint32_t *elscmd;
1569 struct ls_rjt stat; 1575 struct ls_rjt stat;
1570 int retry, maxretry; 1576 int retry = 0, maxretry = lpfc_max_els_tries, delay = 0;
1571 int delay; 1577 uint32_t cmd = 0;
1572 uint32_t cmd;
1573 uint32_t did; 1578 uint32_t did;
1574 1579
1575 retry = 0;
1576 delay = 0;
1577 maxretry = lpfc_max_els_tries;
1578 irsp = &rspiocb->iocb;
1579 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1580 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1581 cmd = 0;
1582 1580
1583 /* Note: context2 may be 0 for internal driver abort 1581 /* Note: context2 may be 0 for internal driver abort
1584 * of delays ELS command. 1582 * of delays ELS command.
@@ -1594,7 +1592,7 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1594 else { 1592 else {
1595 /* We should only hit this case for retrying PLOGI */ 1593 /* We should only hit this case for retrying PLOGI */
1596 did = irsp->un.elsreq64.remoteID; 1594 did = irsp->un.elsreq64.remoteID;
1597 ndlp = lpfc_findnode_did(phba, did); 1595 ndlp = lpfc_findnode_did(vport, did);
1598 if (!ndlp && (cmd != ELS_CMD_PLOGI)) 1596 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1599 return 1; 1597 return 1;
1600 } 1598 }
@@ -1607,11 +1605,8 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1607 case IOSTAT_LOCAL_REJECT: 1605 case IOSTAT_LOCAL_REJECT:
1608 switch ((irsp->un.ulpWord[4] & 0xff)) { 1606 switch ((irsp->un.ulpWord[4] & 0xff)) {
1609 case IOERR_LOOP_OPEN_FAILURE: 1607 case IOERR_LOOP_OPEN_FAILURE:
1610 if (cmd == ELS_CMD_PLOGI) { 1608 if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
1611 if (cmdiocb->retry == 0) {
1612 delay = 1; 1609 delay = 1;
1613 }
1614 }
1615 retry = 1; 1610 retry = 1;
1616 break; 1611 break;
1617 1612
@@ -1620,9 +1615,8 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1620 break; 1615 break;
1621 1616
1622 case IOERR_NO_RESOURCES: 1617 case IOERR_NO_RESOURCES:
1623 if (cmd == ELS_CMD_PLOGI) { 1618 if (cmd == ELS_CMD_PLOGI)
1624 delay = 1; 1619 delay = 1;
1625 }
1626 retry = 1; 1620 retry = 1;
1627 break; 1621 break;
1628 1622
@@ -1706,10 +1700,9 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1706 1700
1707 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) { 1701 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
1708 /* If discovery / RSCN timer is running, reset it */ 1702 /* If discovery / RSCN timer is running, reset it */
1709 if (timer_pending(&phba->fc_disctmo) || 1703 if (timer_pending(&vport->fc_disctmo) ||
1710 (phba->fc_flag & FC_RSCN_MODE)) { 1704 (vport->fc_flag & FC_RSCN_MODE))
1711 lpfc_set_disctmo(phba); 1705 lpfc_set_disctmo(vport);
1712 }
1713 } 1706 }
1714 1707
1715 phba->fc_stat.elsXmitRetry++; 1708 phba->fc_stat.elsXmitRetry++;
@@ -1718,40 +1711,42 @@ lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1718 ndlp->nlp_retry = cmdiocb->retry; 1711 ndlp->nlp_retry = cmdiocb->retry;
1719 1712
1720 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ); 1713 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
1714 spin_lock_irq(shost->host_lock);
1721 ndlp->nlp_flag |= NLP_DELAY_TMO; 1715 ndlp->nlp_flag |= NLP_DELAY_TMO;
1716 spin_unlock_irq(shost->host_lock);
1722 1717
1723 ndlp->nlp_prev_state = ndlp->nlp_state; 1718 ndlp->nlp_prev_state = ndlp->nlp_state;
1724 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE); 1719 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1725 ndlp->nlp_last_elscmd = cmd; 1720 ndlp->nlp_last_elscmd = cmd;
1726 1721
1727 return 1; 1722 return 1;
1728 } 1723 }
1729 switch (cmd) { 1724 switch (cmd) {
1730 case ELS_CMD_FLOGI: 1725 case ELS_CMD_FLOGI:
1731 lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry); 1726 lpfc_issue_els_flogi(vport, ndlp, cmdiocb->retry);
1732 return 1; 1727 return 1;
1733 case ELS_CMD_PLOGI: 1728 case ELS_CMD_PLOGI:
1734 if (ndlp) { 1729 if (ndlp) {
1735 ndlp->nlp_prev_state = ndlp->nlp_state; 1730 ndlp->nlp_prev_state = ndlp->nlp_state;
1736 lpfc_nlp_set_state(phba, ndlp, 1731 lpfc_nlp_set_state(vport, ndlp,
1737 NLP_STE_PLOGI_ISSUE); 1732 NLP_STE_PLOGI_ISSUE);
1738 } 1733 }
1739 lpfc_issue_els_plogi(phba, did, cmdiocb->retry); 1734 lpfc_issue_els_plogi(vport, did, cmdiocb->retry);
1740 return 1; 1735 return 1;
1741 case ELS_CMD_ADISC: 1736 case ELS_CMD_ADISC:
1742 ndlp->nlp_prev_state = ndlp->nlp_state; 1737 ndlp->nlp_prev_state = ndlp->nlp_state;
1743 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE); 1738 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1744 lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry); 1739 lpfc_issue_els_adisc(vport, ndlp, cmdiocb->retry);
1745 return 1; 1740 return 1;
1746 case ELS_CMD_PRLI: 1741 case ELS_CMD_PRLI:
1747 ndlp->nlp_prev_state = ndlp->nlp_state; 1742 ndlp->nlp_prev_state = ndlp->nlp_state;
1748 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE); 1743 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1749 lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry); 1744 lpfc_issue_els_prli(vport, ndlp, cmdiocb->retry);
1750 return 1; 1745 return 1;
1751 case ELS_CMD_LOGO: 1746 case ELS_CMD_LOGO:
1752 ndlp->nlp_prev_state = ndlp->nlp_state; 1747 ndlp->nlp_prev_state = ndlp->nlp_state;
1753 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE); 1748 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1754 lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry); 1749 lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
1755 return 1; 1750 return 1;
1756 } 1751 }
1757 } 1752 }
@@ -1795,19 +1790,16 @@ lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
1795 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 1790 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1796 kfree(buf_ptr); 1791 kfree(buf_ptr);
1797 } 1792 }
1798 spin_lock_irq(phba->host->host_lock);
1799 lpfc_sli_release_iocbq(phba, elsiocb); 1793 lpfc_sli_release_iocbq(phba, elsiocb);
1800 spin_unlock_irq(phba->host->host_lock);
1801 return 0; 1794 return 0;
1802} 1795}
1803 1796
1804static void 1797static void
1805lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 1798lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1806 struct lpfc_iocbq * rspiocb) 1799 struct lpfc_iocbq *rspiocb)
1807{ 1800{
1808 struct lpfc_nodelist *ndlp; 1801 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1809 1802 struct lpfc_vport *vport = cmdiocb->vport;
1810 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1811 1803
1812 /* ACC to LOGO completes to NPort <nlp_DID> */ 1804 /* ACC to LOGO completes to NPort <nlp_DID> */
1813 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 1805 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
@@ -1818,10 +1810,10 @@ lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1818 1810
1819 switch (ndlp->nlp_state) { 1811 switch (ndlp->nlp_state) {
1820 case NLP_STE_UNUSED_NODE: /* node is just allocated */ 1812 case NLP_STE_UNUSED_NODE: /* node is just allocated */
1821 lpfc_drop_node(phba, ndlp); 1813 lpfc_drop_node(vport, ndlp);
1822 break; 1814 break;
1823 case NLP_STE_NPR_NODE: /* NPort Recovery mode */ 1815 case NLP_STE_NPR_NODE: /* NPort Recovery mode */
1824 lpfc_unreg_rpi(phba, ndlp); 1816 lpfc_unreg_rpi(vport, ndlp);
1825 break; 1817 break;
1826 default: 1818 default:
1827 break; 1819 break;
@@ -1834,20 +1826,20 @@ static void
1834lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 1826lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1835 struct lpfc_iocbq *rspiocb) 1827 struct lpfc_iocbq *rspiocb)
1836{ 1828{
1829 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1830 struct lpfc_vport *vport = ndlp ? ndlp->vport : NULL;
1831 struct Scsi_Host *shost = vport ? lpfc_shost_from_vport(vport) : NULL;
1837 IOCB_t *irsp; 1832 IOCB_t *irsp;
1838 struct lpfc_nodelist *ndlp;
1839 LPFC_MBOXQ_t *mbox = NULL; 1833 LPFC_MBOXQ_t *mbox = NULL;
1840 struct lpfc_dmabuf *mp; 1834 struct lpfc_dmabuf *mp = NULL;
1841 1835
1842 irsp = &rspiocb->iocb; 1836 irsp = &rspiocb->iocb;
1843 1837
1844 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1845 if (cmdiocb->context_un.mbox) 1838 if (cmdiocb->context_un.mbox)
1846 mbox = cmdiocb->context_un.mbox; 1839 mbox = cmdiocb->context_un.mbox;
1847 1840
1848
1849 /* Check to see if link went down during discovery */ 1841 /* Check to see if link went down during discovery */
1850 if (lpfc_els_chk_latt(phba) || !ndlp) { 1842 if (!ndlp || lpfc_els_chk_latt(vport)) {
1851 if (mbox) { 1843 if (mbox) {
1852 mp = (struct lpfc_dmabuf *) mbox->context1; 1844 mp = (struct lpfc_dmabuf *) mbox->context1;
1853 if (mp) { 1845 if (mp) {
@@ -1866,17 +1858,19 @@ lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1866 phba->brd_no, 1858 phba->brd_no,
1867 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus, 1859 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
1868 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout, 1860 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
1869 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state, 1861 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
1870 ndlp->nlp_rpi); 1862 ndlp->nlp_rpi);
1871 1863
1872 if (mbox) { 1864 if (mbox) {
1873 if ((rspiocb->iocb.ulpStatus == 0) 1865 if ((rspiocb->iocb.ulpStatus == 0)
1874 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) { 1866 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
1875 lpfc_unreg_rpi(phba, ndlp); 1867 lpfc_unreg_rpi(vport, ndlp);
1876 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login; 1868 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
1877 mbox->context2 = lpfc_nlp_get(ndlp); 1869 mbox->context2 = lpfc_nlp_get(ndlp);
1870 mbox->vport = vport;
1878 ndlp->nlp_prev_state = ndlp->nlp_state; 1871 ndlp->nlp_prev_state = ndlp->nlp_state;
1879 lpfc_nlp_set_state(phba, ndlp, NLP_STE_REG_LOGIN_ISSUE); 1872 lpfc_nlp_set_state(vport, ndlp,
1873 NLP_STE_REG_LOGIN_ISSUE);
1880 if (lpfc_sli_issue_mbox(phba, mbox, 1874 if (lpfc_sli_issue_mbox(phba, mbox,
1881 (MBX_NOWAIT | MBX_STOP_IOCB)) 1875 (MBX_NOWAIT | MBX_STOP_IOCB))
1882 != MBX_NOT_FINISHED) { 1876 != MBX_NOT_FINISHED) {
@@ -1892,7 +1886,7 @@ lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1892 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) || 1886 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1893 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) { 1887 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
1894 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) { 1888 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
1895 lpfc_drop_node(phba, ndlp); 1889 lpfc_drop_node(vport, ndlp);
1896 ndlp = NULL; 1890 ndlp = NULL;
1897 } 1891 }
1898 } 1892 }
@@ -1906,19 +1900,21 @@ lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1906 } 1900 }
1907out: 1901out:
1908 if (ndlp) { 1902 if (ndlp) {
1909 spin_lock_irq(phba->host->host_lock); 1903 spin_lock_irq(shost->host_lock);
1910 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN; 1904 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
1911 spin_unlock_irq(phba->host->host_lock); 1905 spin_unlock_irq(shost->host_lock);
1912 } 1906 }
1913 lpfc_els_free_iocb(phba, cmdiocb); 1907 lpfc_els_free_iocb(phba, cmdiocb);
1914 return; 1908 return;
1915} 1909}
1916 1910
1917int 1911int
1918lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag, 1912lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
1919 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp, 1913 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
1920 LPFC_MBOXQ_t * mbox, uint8_t newnode) 1914 LPFC_MBOXQ_t *mbox, uint8_t newnode)
1921{ 1915{
1916 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1917 struct lpfc_hba *phba = vport->phba;
1922 IOCB_t *icmd; 1918 IOCB_t *icmd;
1923 IOCB_t *oldcmd; 1919 IOCB_t *oldcmd;
1924 struct lpfc_iocbq *elsiocb; 1920 struct lpfc_iocbq *elsiocb;
@@ -1936,12 +1932,15 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1936 switch (flag) { 1932 switch (flag) {
1937 case ELS_CMD_ACC: 1933 case ELS_CMD_ACC:
1938 cmdsize = sizeof (uint32_t); 1934 cmdsize = sizeof (uint32_t);
1939 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1935 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
1940 ndlp, ndlp->nlp_DID, ELS_CMD_ACC); 1936 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1941 if (!elsiocb) { 1937 if (!elsiocb) {
1938 spin_lock_irq(shost->host_lock);
1942 ndlp->nlp_flag &= ~NLP_LOGO_ACC; 1939 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
1940 spin_unlock_irq(shost->host_lock);
1943 return 1; 1941 return 1;
1944 } 1942 }
1943
1945 icmd = &elsiocb->iocb; 1944 icmd = &elsiocb->iocb;
1946 icmd->ulpContext = oldcmd->ulpContext; /* Xri */ 1945 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1947 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt); 1946 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
@@ -1950,8 +1949,8 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1950 break; 1949 break;
1951 case ELS_CMD_PLOGI: 1950 case ELS_CMD_PLOGI:
1952 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t)); 1951 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
1953 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1952 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
1954 ndlp, ndlp->nlp_DID, ELS_CMD_ACC); 1953 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1955 if (!elsiocb) 1954 if (!elsiocb)
1956 return 1; 1955 return 1;
1957 1956
@@ -1964,11 +1963,11 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1964 1963
1965 *((uint32_t *) (pcmd)) = ELS_CMD_ACC; 1964 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1966 pcmd += sizeof (uint32_t); 1965 pcmd += sizeof (uint32_t);
1967 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm)); 1966 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
1968 break; 1967 break;
1969 case ELS_CMD_PRLO: 1968 case ELS_CMD_PRLO:
1970 cmdsize = sizeof (uint32_t) + sizeof (PRLO); 1969 cmdsize = sizeof (uint32_t) + sizeof (PRLO);
1971 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 1970 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
1972 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO); 1971 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
1973 if (!elsiocb) 1972 if (!elsiocb)
1974 return 1; 1973 return 1;
@@ -2001,18 +2000,16 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
2001 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi); 2000 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2002 2001
2003 if (ndlp->nlp_flag & NLP_LOGO_ACC) { 2002 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2004 spin_lock_irq(phba->host->host_lock); 2003 spin_lock_irq(shost->host_lock);
2005 ndlp->nlp_flag &= ~NLP_LOGO_ACC; 2004 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2006 spin_unlock_irq(phba->host->host_lock); 2005 spin_unlock_irq(shost->host_lock);
2007 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc; 2006 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2008 } else { 2007 } else {
2009 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2008 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2010 } 2009 }
2011 2010
2012 phba->fc_stat.elsXmitACC++; 2011 phba->fc_stat.elsXmitACC++;
2013 spin_lock_irq(phba->host->host_lock);
2014 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2012 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2015 spin_unlock_irq(phba->host->host_lock);
2016 if (rc == IOCB_ERROR) { 2013 if (rc == IOCB_ERROR) {
2017 lpfc_els_free_iocb(phba, elsiocb); 2014 lpfc_els_free_iocb(phba, elsiocb);
2018 return 1; 2015 return 1;
@@ -2021,9 +2018,10 @@ lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
2021} 2018}
2022 2019
2023int 2020int
2024lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError, 2021lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
2025 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 2022 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
2026{ 2023{
2024 struct lpfc_hba *phba = vport->phba;
2027 IOCB_t *icmd; 2025 IOCB_t *icmd;
2028 IOCB_t *oldcmd; 2026 IOCB_t *oldcmd;
2029 struct lpfc_iocbq *elsiocb; 2027 struct lpfc_iocbq *elsiocb;
@@ -2037,8 +2035,8 @@ lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2037 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 2035 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2038 2036
2039 cmdsize = 2 * sizeof (uint32_t); 2037 cmdsize = 2 * sizeof (uint32_t);
2040 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 2038 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2041 ndlp, ndlp->nlp_DID, ELS_CMD_LS_RJT); 2039 ndlp->nlp_DID, ELS_CMD_LS_RJT);
2042 if (!elsiocb) 2040 if (!elsiocb)
2043 return 1; 2041 return 1;
2044 2042
@@ -2061,9 +2059,7 @@ lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2061 2059
2062 phba->fc_stat.elsXmitLSRJT++; 2060 phba->fc_stat.elsXmitLSRJT++;
2063 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2061 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2064 spin_lock_irq(phba->host->host_lock);
2065 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2062 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2066 spin_unlock_irq(phba->host->host_lock);
2067 if (rc == IOCB_ERROR) { 2063 if (rc == IOCB_ERROR) {
2068 lpfc_els_free_iocb(phba, elsiocb); 2064 lpfc_els_free_iocb(phba, elsiocb);
2069 return 1; 2065 return 1;
@@ -2072,25 +2068,22 @@ lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2072} 2068}
2073 2069
2074int 2070int
2075lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba, 2071lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2076 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 2072 struct lpfc_nodelist *ndlp)
2077{ 2073{
2074 struct lpfc_hba *phba = vport->phba;
2075 struct lpfc_sli *psli = &phba->sli;
2076 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2078 ADISC *ap; 2077 ADISC *ap;
2079 IOCB_t *icmd; 2078 IOCB_t *icmd, *oldcmd;
2080 IOCB_t *oldcmd;
2081 struct lpfc_iocbq *elsiocb; 2079 struct lpfc_iocbq *elsiocb;
2082 struct lpfc_sli_ring *pring;
2083 struct lpfc_sli *psli;
2084 uint8_t *pcmd; 2080 uint8_t *pcmd;
2085 uint16_t cmdsize; 2081 uint16_t cmdsize;
2086 int rc; 2082 int rc;
2087 2083
2088 psli = &phba->sli;
2089 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2090
2091 cmdsize = sizeof (uint32_t) + sizeof (ADISC); 2084 cmdsize = sizeof (uint32_t) + sizeof (ADISC);
2092 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 2085 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2093 ndlp, ndlp->nlp_DID, ELS_CMD_ACC); 2086 ndlp->nlp_DID, ELS_CMD_ACC);
2094 if (!elsiocb) 2087 if (!elsiocb)
2095 return 1; 2088 return 1;
2096 2089
@@ -2113,15 +2106,13 @@ lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
2113 2106
2114 ap = (ADISC *) (pcmd); 2107 ap = (ADISC *) (pcmd);
2115 ap->hardAL_PA = phba->fc_pref_ALPA; 2108 ap->hardAL_PA = phba->fc_pref_ALPA;
2116 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 2109 memcpy(&ap->portName, &vport->fc_portname, sizeof (struct lpfc_name));
2117 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 2110 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
2118 ap->DID = be32_to_cpu(phba->fc_myDID); 2111 ap->DID = be32_to_cpu(vport->fc_myDID);
2119 2112
2120 phba->fc_stat.elsXmitACC++; 2113 phba->fc_stat.elsXmitACC++;
2121 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2114 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2122 spin_lock_irq(phba->host->host_lock);
2123 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2115 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2124 spin_unlock_irq(phba->host->host_lock);
2125 if (rc == IOCB_ERROR) { 2116 if (rc == IOCB_ERROR) {
2126 lpfc_els_free_iocb(phba, elsiocb); 2117 lpfc_els_free_iocb(phba, elsiocb);
2127 return 1; 2118 return 1;
@@ -2130,9 +2121,10 @@ lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
2130} 2121}
2131 2122
2132int 2123int
2133lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb, 2124lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2134 struct lpfc_nodelist *ndlp) 2125 struct lpfc_nodelist *ndlp)
2135{ 2126{
2127 struct lpfc_hba *phba = vport->phba;
2136 PRLI *npr; 2128 PRLI *npr;
2137 lpfc_vpd_t *vpd; 2129 lpfc_vpd_t *vpd;
2138 IOCB_t *icmd; 2130 IOCB_t *icmd;
@@ -2148,8 +2140,10 @@ lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb,
2148 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 2140 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2149 2141
2150 cmdsize = sizeof (uint32_t) + sizeof (PRLI); 2142 cmdsize = sizeof (uint32_t) + sizeof (PRLI);
2151 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, ndlp, 2143 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2152 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK))); 2144 ndlp->nlp_DID,
2145 (ELS_CMD_ACC |
2146 (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
2153 if (!elsiocb) 2147 if (!elsiocb)
2154 return 1; 2148 return 1;
2155 2149
@@ -2196,9 +2190,7 @@ lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb,
2196 phba->fc_stat.elsXmitACC++; 2190 phba->fc_stat.elsXmitACC++;
2197 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc; 2191 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2198 2192
2199 spin_lock_irq(phba->host->host_lock);
2200 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2193 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2201 spin_unlock_irq(phba->host->host_lock);
2202 if (rc == IOCB_ERROR) { 2194 if (rc == IOCB_ERROR) {
2203 lpfc_els_free_iocb(phba, elsiocb); 2195 lpfc_els_free_iocb(phba, elsiocb);
2204 return 1; 2196 return 1;
@@ -2207,12 +2199,12 @@ lpfc_els_rsp_prli_acc(struct lpfc_hba *phba, struct lpfc_iocbq *oldiocb,
2207} 2199}
2208 2200
2209static int 2201static int
2210lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format, 2202lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
2211 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp) 2203 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
2212{ 2204{
2205 struct lpfc_hba *phba = vport->phba;
2213 RNID *rn; 2206 RNID *rn;
2214 IOCB_t *icmd; 2207 IOCB_t *icmd, *oldcmd;
2215 IOCB_t *oldcmd;
2216 struct lpfc_iocbq *elsiocb; 2208 struct lpfc_iocbq *elsiocb;
2217 struct lpfc_sli_ring *pring; 2209 struct lpfc_sli_ring *pring;
2218 struct lpfc_sli *psli; 2210 struct lpfc_sli *psli;
@@ -2228,8 +2220,8 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2228 if (format) 2220 if (format)
2229 cmdsize += sizeof (RNID_TOP_DISC); 2221 cmdsize += sizeof (RNID_TOP_DISC);
2230 2222
2231 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, 2223 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2232 ndlp, ndlp->nlp_DID, ELS_CMD_ACC); 2224 ndlp->nlp_DID, ELS_CMD_ACC);
2233 if (!elsiocb) 2225 if (!elsiocb)
2234 return 1; 2226 return 1;
2235 2227
@@ -2253,8 +2245,8 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2253 rn = (RNID *) (pcmd); 2245 rn = (RNID *) (pcmd);
2254 rn->Format = format; 2246 rn->Format = format;
2255 rn->CommonLen = (2 * sizeof (struct lpfc_name)); 2247 rn->CommonLen = (2 * sizeof (struct lpfc_name));
2256 memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name)); 2248 memcpy(&rn->portName, &vport->fc_portname, sizeof (struct lpfc_name));
2257 memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name)); 2249 memcpy(&rn->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
2258 switch (format) { 2250 switch (format) {
2259 case 0: 2251 case 0:
2260 rn->SpecificLen = 0; 2252 rn->SpecificLen = 0;
@@ -2262,7 +2254,7 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2262 case RNID_TOPOLOGY_DISC: 2254 case RNID_TOPOLOGY_DISC:
2263 rn->SpecificLen = sizeof (RNID_TOP_DISC); 2255 rn->SpecificLen = sizeof (RNID_TOP_DISC);
2264 memcpy(&rn->un.topologyDisc.portName, 2256 memcpy(&rn->un.topologyDisc.portName,
2265 &phba->fc_portname, sizeof (struct lpfc_name)); 2257 &vport->fc_portname, sizeof (struct lpfc_name));
2266 rn->un.topologyDisc.unitType = RNID_HBA; 2258 rn->un.topologyDisc.unitType = RNID_HBA;
2267 rn->un.topologyDisc.physPort = 0; 2259 rn->un.topologyDisc.physPort = 0;
2268 rn->un.topologyDisc.attachedNodes = 0; 2260 rn->un.topologyDisc.attachedNodes = 0;
@@ -2279,9 +2271,7 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2279 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl, 2271 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2280 * it could be freed */ 2272 * it could be freed */
2281 2273
2282 spin_lock_irq(phba->host->host_lock);
2283 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0); 2274 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2284 spin_unlock_irq(phba->host->host_lock);
2285 if (rc == IOCB_ERROR) { 2275 if (rc == IOCB_ERROR) {
2286 lpfc_els_free_iocb(phba, elsiocb); 2276 lpfc_els_free_iocb(phba, elsiocb);
2287 return 1; 2277 return 1;
@@ -2290,120 +2280,122 @@ lpfc_els_rsp_rnid_acc(struct lpfc_hba *phba, uint8_t format,
2290} 2280}
2291 2281
2292int 2282int
2293lpfc_els_disc_adisc(struct lpfc_hba *phba) 2283lpfc_els_disc_adisc(struct lpfc_vport *vport)
2294{ 2284{
2295 int sentadisc; 2285 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2296 struct lpfc_nodelist *ndlp, *next_ndlp; 2286 struct lpfc_nodelist *ndlp, *next_ndlp;
2287 int sentadisc = 0;
2297 2288
2298 sentadisc = 0;
2299 /* go thru NPR nodes and issue any remaining ELS ADISCs */ 2289 /* go thru NPR nodes and issue any remaining ELS ADISCs */
2300 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) { 2290 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2301 if (ndlp->nlp_state == NLP_STE_NPR_NODE && 2291 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2302 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 && 2292 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2303 (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) { 2293 (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
2304 spin_lock_irq(phba->host->host_lock); 2294 spin_lock_irq(shost->host_lock);
2305 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2295 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2306 spin_unlock_irq(phba->host->host_lock); 2296 spin_unlock_irq(shost->host_lock);
2307 ndlp->nlp_prev_state = ndlp->nlp_state; 2297 ndlp->nlp_prev_state = ndlp->nlp_state;
2308 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE); 2298 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2309 lpfc_issue_els_adisc(phba, ndlp, 0); 2299 lpfc_issue_els_adisc(vport, ndlp, 0);
2310 sentadisc++; 2300 sentadisc++;
2311 phba->num_disc_nodes++; 2301 vport->num_disc_nodes++;
2312 if (phba->num_disc_nodes >= 2302 if (vport->num_disc_nodes >=
2313 phba->cfg_discovery_threads) { 2303 vport->phba->cfg_discovery_threads) {
2314 spin_lock_irq(phba->host->host_lock); 2304 spin_lock_irq(shost->host_lock);
2315 phba->fc_flag |= FC_NLP_MORE; 2305 vport->fc_flag |= FC_NLP_MORE;
2316 spin_unlock_irq(phba->host->host_lock); 2306 spin_unlock_irq(shost->host_lock);
2317 break; 2307 break;
2318 } 2308 }
2319 } 2309 }
2320 } 2310 }
2321 if (sentadisc == 0) { 2311 if (sentadisc == 0) {
2322 spin_lock_irq(phba->host->host_lock); 2312 spin_lock_irq(shost->host_lock);
2323 phba->fc_flag &= ~FC_NLP_MORE; 2313 vport->fc_flag &= ~FC_NLP_MORE;
2324 spin_unlock_irq(phba->host->host_lock); 2314 spin_unlock_irq(shost->host_lock);
2325 } 2315 }
2326 return sentadisc; 2316 return sentadisc;
2327} 2317}
2328 2318
2329int 2319int
2330lpfc_els_disc_plogi(struct lpfc_hba * phba) 2320lpfc_els_disc_plogi(struct lpfc_vport *vport)
2331{ 2321{
2332 int sentplogi; 2322 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2333 struct lpfc_nodelist *ndlp, *next_ndlp; 2323 struct lpfc_nodelist *ndlp, *next_ndlp;
2324 int sentplogi = 0;
2334 2325
2335 sentplogi = 0; 2326 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
2336 /* go thru NPR list and issue any remaining ELS PLOGIs */ 2327 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2337 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp) {
2338 if (ndlp->nlp_state == NLP_STE_NPR_NODE && 2328 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2339 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 && 2329 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2340 (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 && 2330 (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
2341 (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) { 2331 (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
2342 ndlp->nlp_prev_state = ndlp->nlp_state; 2332 ndlp->nlp_prev_state = ndlp->nlp_state;
2343 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE); 2333 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2344 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0); 2334 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2345 sentplogi++; 2335 sentplogi++;
2346 phba->num_disc_nodes++; 2336 vport->num_disc_nodes++;
2347 if (phba->num_disc_nodes >= 2337 if (vport->num_disc_nodes >=
2348 phba->cfg_discovery_threads) { 2338 vport->phba->cfg_discovery_threads) {
2349 spin_lock_irq(phba->host->host_lock); 2339 spin_lock_irq(shost->host_lock);
2350 phba->fc_flag |= FC_NLP_MORE; 2340 vport->fc_flag |= FC_NLP_MORE;
2351 spin_unlock_irq(phba->host->host_lock); 2341 spin_unlock_irq(shost->host_lock);
2352 break; 2342 break;
2353 } 2343 }
2354 } 2344 }
2355 } 2345 }
2356 if (sentplogi == 0) { 2346 if (sentplogi == 0) {
2357 spin_lock_irq(phba->host->host_lock); 2347 spin_lock_irq(shost->host_lock);
2358 phba->fc_flag &= ~FC_NLP_MORE; 2348 vport->fc_flag &= ~FC_NLP_MORE;
2359 spin_unlock_irq(phba->host->host_lock); 2349 spin_unlock_irq(shost->host_lock);
2360 } 2350 }
2361 return sentplogi; 2351 return sentplogi;
2362} 2352}
2363 2353
2364int 2354int
2365lpfc_els_flush_rscn(struct lpfc_hba * phba) 2355lpfc_els_flush_rscn(struct lpfc_vport *vport)
2366{ 2356{
2357 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2358 struct lpfc_hba *phba = vport->phba;
2367 struct lpfc_dmabuf *mp; 2359 struct lpfc_dmabuf *mp;
2368 int i; 2360 int i;
2369 2361
2370 for (i = 0; i < phba->fc_rscn_id_cnt; i++) { 2362 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2371 mp = phba->fc_rscn_id_list[i]; 2363 mp = vport->fc_rscn_id_list[i];
2372 lpfc_mbuf_free(phba, mp->virt, mp->phys); 2364 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2373 kfree(mp); 2365 kfree(mp);
2374 phba->fc_rscn_id_list[i] = NULL; 2366 vport->fc_rscn_id_list[i] = NULL;
2375 } 2367 }
2376 phba->fc_rscn_id_cnt = 0; 2368 spin_lock_irq(shost->host_lock);
2377 spin_lock_irq(phba->host->host_lock); 2369 vport->fc_rscn_id_cnt = 0;
2378 phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY); 2370 vport->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2379 spin_unlock_irq(phba->host->host_lock); 2371 spin_unlock_irq(shost->host_lock);
2380 lpfc_can_disctmo(phba); 2372 lpfc_can_disctmo(vport);
2381 return 0; 2373 return 0;
2382} 2374}
2383 2375
2384int 2376int
2385lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did) 2377lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
2386{ 2378{
2387 D_ID ns_did; 2379 D_ID ns_did;
2388 D_ID rscn_did; 2380 D_ID rscn_did;
2389 struct lpfc_dmabuf *mp; 2381 struct lpfc_dmabuf *mp;
2390 uint32_t *lp; 2382 uint32_t *lp;
2391 uint32_t payload_len, cmd, i, match; 2383 uint32_t payload_len, cmd, i, match;
2384 struct lpfc_hba *phba = vport->phba;
2392 2385
2393 ns_did.un.word = did; 2386 ns_did.un.word = did;
2394 match = 0; 2387 match = 0;
2395 2388
2396 /* Never match fabric nodes for RSCNs */ 2389 /* Never match fabric nodes for RSCNs */
2397 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) 2390 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2398 return(0); 2391 return 0;
2399 2392
2400 /* If we are doing a FULL RSCN rediscovery, match everything */ 2393 /* If we are doing a FULL RSCN rediscovery, match everything */
2401 if (phba->fc_flag & FC_RSCN_DISCOVERY) { 2394 if (vport->fc_flag & FC_RSCN_DISCOVERY)
2402 return did; 2395 return did;
2403 }
2404 2396
2405 for (i = 0; i < phba->fc_rscn_id_cnt; i++) { 2397 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2406 mp = phba->fc_rscn_id_list[i]; 2398 mp = vport->fc_rscn_id_list[i];
2407 lp = (uint32_t *) mp->virt; 2399 lp = (uint32_t *) mp->virt;
2408 cmd = *lp++; 2400 cmd = *lp++;
2409 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */ 2401 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
@@ -2414,44 +2406,38 @@ lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
2414 payload_len -= sizeof (uint32_t); 2406 payload_len -= sizeof (uint32_t);
2415 switch (rscn_did.un.b.resv) { 2407 switch (rscn_did.un.b.resv) {
2416 case 0: /* Single N_Port ID effected */ 2408 case 0: /* Single N_Port ID effected */
2417 if (ns_did.un.word == rscn_did.un.word) { 2409 if (ns_did.un.word == rscn_did.un.word)
2418 match = did; 2410 match = did;
2419 }
2420 break; 2411 break;
2421 case 1: /* Whole N_Port Area effected */ 2412 case 1: /* Whole N_Port Area effected */
2422 if ((ns_did.un.b.domain == rscn_did.un.b.domain) 2413 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2423 && (ns_did.un.b.area == rscn_did.un.b.area)) 2414 && (ns_did.un.b.area == rscn_did.un.b.area))
2424 {
2425 match = did; 2415 match = did;
2426 }
2427 break; 2416 break;
2428 case 2: /* Whole N_Port Domain effected */ 2417 case 2: /* Whole N_Port Domain effected */
2429 if (ns_did.un.b.domain == rscn_did.un.b.domain) 2418 if (ns_did.un.b.domain == rscn_did.un.b.domain)
2430 {
2431 match = did; 2419 match = did;
2432 }
2433 break; 2420 break;
2434 case 3: /* Whole Fabric effected */ 2421 case 3: /* Whole Fabric effected */
2435 match = did; 2422 match = did;
2436 break; 2423 break;
2437 default: 2424 default:
2438 /* Unknown Identifier in RSCN list */ 2425 /* Unknown Identifier in RSCN node */
2439 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2426 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2440 "%d:0217 Unknown Identifier in " 2427 "%d:0217 Unknown Identifier in "
2441 "RSCN payload Data: x%x\n", 2428 "RSCN payload Data: x%x\n",
2442 phba->brd_no, rscn_did.un.word); 2429 phba->brd_no, rscn_did.un.word);
2443 break; 2430 break;
2444 } 2431 }
2445 if (match) { 2432 if (match)
2446 break; 2433 break;
2447 } 2434 }
2448 } 2435 }
2449 }
2450 return match; 2436 return match;
2451} 2437}
2452 2438
2453static int 2439static int
2454lpfc_rscn_recovery_check(struct lpfc_hba *phba) 2440lpfc_rscn_recovery_check(struct lpfc_vport *vport)
2455{ 2441{
2456 struct lpfc_nodelist *ndlp = NULL; 2442 struct lpfc_nodelist *ndlp = NULL;
2457 2443
@@ -2459,12 +2445,12 @@ lpfc_rscn_recovery_check(struct lpfc_hba *phba)
2459 * them to NPR state. 2445 * them to NPR state.
2460 */ 2446 */
2461 2447
2462 list_for_each_entry(ndlp, &phba->fc_nodes, nlp_listp) { 2448 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2463 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE || 2449 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE ||
2464 lpfc_rscn_payload_check(phba, ndlp->nlp_DID) == 0) 2450 lpfc_rscn_payload_check(vport, ndlp->nlp_DID) == 0)
2465 continue; 2451 continue;
2466 2452
2467 lpfc_disc_state_machine(phba, ndlp, NULL, 2453 lpfc_disc_state_machine(vport, ndlp, NULL,
2468 NLP_EVT_DEVICE_RECOVERY); 2454 NLP_EVT_DEVICE_RECOVERY);
2469 2455
2470 /* 2456 /*
@@ -2472,17 +2458,18 @@ lpfc_rscn_recovery_check(struct lpfc_hba *phba)
2472 * recovery event. 2458 * recovery event.
2473 */ 2459 */
2474 if (ndlp->nlp_flag & NLP_DELAY_TMO) 2460 if (ndlp->nlp_flag & NLP_DELAY_TMO)
2475 lpfc_cancel_retry_delay_tmo(phba, ndlp); 2461 lpfc_cancel_retry_delay_tmo(vport, ndlp);
2476 } 2462 }
2477 2463
2478 return 0; 2464 return 0;
2479} 2465}
2480 2466
2481static int 2467static int
2482lpfc_els_rcv_rscn(struct lpfc_hba * phba, 2468lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2483 struct lpfc_iocbq * cmdiocb, 2469 struct lpfc_nodelist *ndlp, uint8_t newnode)
2484 struct lpfc_nodelist * ndlp, uint8_t newnode)
2485{ 2470{
2471 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2472 struct lpfc_hba *phba = vport->phba;
2486 struct lpfc_dmabuf *pcmd; 2473 struct lpfc_dmabuf *pcmd;
2487 uint32_t *lp; 2474 uint32_t *lp;
2488 IOCB_t *icmd; 2475 IOCB_t *icmd;
@@ -2503,18 +2490,18 @@ lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2503 KERN_INFO, 2490 KERN_INFO,
2504 LOG_DISCOVERY, 2491 LOG_DISCOVERY,
2505 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n", 2492 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2506 phba->brd_no, 2493 phba->brd_no, vport->fc_flag, payload_len, *lp,
2507 phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt); 2494 vport->fc_rscn_id_cnt);
2508 2495
2509 for (i = 0; i < payload_len/sizeof(uint32_t); i++) 2496 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2510 fc_host_post_event(phba->host, fc_get_event_number(), 2497 fc_host_post_event(shost, fc_get_event_number(),
2511 FCH_EVT_RSCN, lp[i]); 2498 FCH_EVT_RSCN, lp[i]);
2512 2499
2513 /* If we are about to begin discovery, just ACC the RSCN. 2500 /* If we are about to begin discovery, just ACC the RSCN.
2514 * Discovery processing will satisfy it. 2501 * Discovery processing will satisfy it.
2515 */ 2502 */
2516 if (phba->hba_state <= LPFC_NS_QRY) { 2503 if (vport->port_state <= LPFC_NS_QRY) {
2517 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 2504 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2518 newnode); 2505 newnode);
2519 return 0; 2506 return 0;
2520 } 2507 }
@@ -2522,13 +2509,13 @@ lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2522 /* If we are already processing an RSCN, save the received 2509 /* If we are already processing an RSCN, save the received
2523 * RSCN payload buffer, cmdiocb->context2 to process later. 2510 * RSCN payload buffer, cmdiocb->context2 to process later.
2524 */ 2511 */
2525 if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) { 2512 if (vport->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2526 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) && 2513 if ((vport->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2527 !(phba->fc_flag & FC_RSCN_DISCOVERY)) { 2514 !(vport->fc_flag & FC_RSCN_DISCOVERY)) {
2528 spin_lock_irq(phba->host->host_lock); 2515 spin_lock_irq(shost->host_lock);
2529 phba->fc_flag |= FC_RSCN_MODE; 2516 vport->fc_flag |= FC_RSCN_MODE;
2530 spin_unlock_irq(phba->host->host_lock); 2517 spin_unlock_irq(shost->host_lock);
2531 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd; 2518 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
2532 2519
2533 /* If we zero, cmdiocb->context2, the calling 2520 /* If we zero, cmdiocb->context2, the calling
2534 * routine will not try to free it. 2521 * routine will not try to free it.
@@ -2539,54 +2526,59 @@ lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2539 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 2526 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2540 "%d:0235 Deferred RSCN " 2527 "%d:0235 Deferred RSCN "
2541 "Data: x%x x%x x%x\n", 2528 "Data: x%x x%x x%x\n",
2542 phba->brd_no, phba->fc_rscn_id_cnt, 2529 phba->brd_no, vport->fc_rscn_id_cnt,
2543 phba->fc_flag, phba->hba_state); 2530 vport->fc_flag,
2531 vport->port_state);
2544 } else { 2532 } else {
2545 spin_lock_irq(phba->host->host_lock); 2533 spin_lock_irq(shost->host_lock);
2546 phba->fc_flag |= FC_RSCN_DISCOVERY; 2534 vport->fc_flag |= FC_RSCN_DISCOVERY;
2547 spin_unlock_irq(phba->host->host_lock); 2535 spin_unlock_irq(shost->host_lock);
2548 /* ReDiscovery RSCN */ 2536 /* ReDiscovery RSCN */
2549 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 2537 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2550 "%d:0234 ReDiscovery RSCN " 2538 "%d:0234 ReDiscovery RSCN "
2551 "Data: x%x x%x x%x\n", 2539 "Data: x%x x%x x%x\n",
2552 phba->brd_no, phba->fc_rscn_id_cnt, 2540 phba->brd_no, vport->fc_rscn_id_cnt,
2553 phba->fc_flag, phba->hba_state); 2541 vport->fc_flag,
2542 vport->port_state);
2554 } 2543 }
2555 /* Send back ACC */ 2544 /* Send back ACC */
2556 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 2545 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2557 newnode); 2546 newnode);
2558 2547
2559 /* send RECOVERY event for ALL nodes that match RSCN payload */ 2548 /* send RECOVERY event for ALL nodes that match RSCN payload */
2560 lpfc_rscn_recovery_check(phba); 2549 lpfc_rscn_recovery_check(vport);
2561 return 0; 2550 return 0;
2562 } 2551 }
2563 2552
2564 phba->fc_flag |= FC_RSCN_MODE; 2553 spin_lock_irq(shost->host_lock);
2565 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd; 2554 vport->fc_flag |= FC_RSCN_MODE;
2555 spin_unlock_irq(shost->host_lock);
2556 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
2566 /* 2557 /*
2567 * If we zero, cmdiocb->context2, the calling routine will 2558 * If we zero, cmdiocb->context2, the calling routine will
2568 * not try to free it. 2559 * not try to free it.
2569 */ 2560 */
2570 cmdiocb->context2 = NULL; 2561 cmdiocb->context2 = NULL;
2571 2562
2572 lpfc_set_disctmo(phba); 2563 lpfc_set_disctmo(vport);
2573 2564
2574 /* Send back ACC */ 2565 /* Send back ACC */
2575 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode); 2566 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
2576 2567
2577 /* send RECOVERY event for ALL nodes that match RSCN payload */ 2568 /* send RECOVERY event for ALL nodes that match RSCN payload */
2578 lpfc_rscn_recovery_check(phba); 2569 lpfc_rscn_recovery_check(vport);
2579 2570
2580 return lpfc_els_handle_rscn(phba); 2571 return lpfc_els_handle_rscn(vport);
2581} 2572}
2582 2573
2583int 2574int
2584lpfc_els_handle_rscn(struct lpfc_hba * phba) 2575lpfc_els_handle_rscn(struct lpfc_vport *vport)
2585{ 2576{
2586 struct lpfc_nodelist *ndlp; 2577 struct lpfc_nodelist *ndlp;
2578 struct lpfc_hba *phba = vport->phba;
2587 2579
2588 /* Start timer for RSCN processing */ 2580 /* Start timer for RSCN processing */
2589 lpfc_set_disctmo(phba); 2581 lpfc_set_disctmo(vport);
2590 2582
2591 /* RSCN processed */ 2583 /* RSCN processed */
2592 lpfc_printf_log(phba, 2584 lpfc_printf_log(phba,
@@ -2594,53 +2586,53 @@ lpfc_els_handle_rscn(struct lpfc_hba * phba)
2594 LOG_DISCOVERY, 2586 LOG_DISCOVERY,
2595 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n", 2587 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2596 phba->brd_no, 2588 phba->brd_no,
2597 phba->fc_flag, 0, phba->fc_rscn_id_cnt, 2589 vport->fc_flag, 0, vport->fc_rscn_id_cnt,
2598 phba->hba_state); 2590 vport->port_state);
2599 2591
2600 /* To process RSCN, first compare RSCN data with NameServer */ 2592 /* To process RSCN, first compare RSCN data with NameServer */
2601 phba->fc_ns_retry = 0; 2593 vport->fc_ns_retry = 0;
2602 ndlp = lpfc_findnode_did(phba, NameServer_DID); 2594 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2603 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) { 2595 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
2604 /* Good ndlp, issue CT Request to NameServer */ 2596 /* Good ndlp, issue CT Request to NameServer */
2605 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) { 2597 if (lpfc_ns_cmd(vport, ndlp, SLI_CTNS_GID_FT) == 0)
2606 /* Wait for NameServer query cmpl before we can 2598 /* Wait for NameServer query cmpl before we can
2607 continue */ 2599 continue */
2608 return 1; 2600 return 1;
2609 }
2610 } else { 2601 } else {
2611 /* If login to NameServer does not exist, issue one */ 2602 /* If login to NameServer does not exist, issue one */
2612 /* Good status, issue PLOGI to NameServer */ 2603 /* Good status, issue PLOGI to NameServer */
2613 ndlp = lpfc_findnode_did(phba, NameServer_DID); 2604 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2614 if (ndlp) { 2605 if (ndlp)
2615 /* Wait for NameServer login cmpl before we can 2606 /* Wait for NameServer login cmpl before we can
2616 continue */ 2607 continue */
2617 return 1; 2608 return 1;
2618 } 2609
2619 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 2610 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2620 if (!ndlp) { 2611 if (!ndlp) {
2621 lpfc_els_flush_rscn(phba); 2612 lpfc_els_flush_rscn(vport);
2622 return 0; 2613 return 0;
2623 } else { 2614 } else {
2624 lpfc_nlp_init(phba, ndlp, NameServer_DID); 2615 lpfc_nlp_init(vport, ndlp, NameServer_DID);
2625 ndlp->nlp_type |= NLP_FABRIC; 2616 ndlp->nlp_type |= NLP_FABRIC;
2626 ndlp->nlp_prev_state = ndlp->nlp_state; 2617 ndlp->nlp_prev_state = ndlp->nlp_state;
2627 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE); 2618 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2628 lpfc_issue_els_plogi(phba, NameServer_DID, 0); 2619 lpfc_issue_els_plogi(vport, NameServer_DID, 0);
2629 /* Wait for NameServer login cmpl before we can 2620 /* Wait for NameServer login cmpl before we can
2630 continue */ 2621 continue */
2631 return 1; 2622 return 1;
2632 } 2623 }
2633 } 2624 }
2634 2625
2635 lpfc_els_flush_rscn(phba); 2626 lpfc_els_flush_rscn(vport);
2636 return 0; 2627 return 0;
2637} 2628}
2638 2629
2639static int 2630static int
2640lpfc_els_rcv_flogi(struct lpfc_hba * phba, 2631lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2641 struct lpfc_iocbq * cmdiocb, 2632 struct lpfc_nodelist *ndlp, uint8_t newnode)
2642 struct lpfc_nodelist * ndlp, uint8_t newnode)
2643{ 2633{
2634 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2635 struct lpfc_hba *phba = vport->phba;
2644 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2636 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2645 uint32_t *lp = (uint32_t *) pcmd->virt; 2637 uint32_t *lp = (uint32_t *) pcmd->virt;
2646 IOCB_t *icmd = &cmdiocb->iocb; 2638 IOCB_t *icmd = &cmdiocb->iocb;
@@ -2655,7 +2647,7 @@ lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2655 2647
2656 /* FLOGI received */ 2648 /* FLOGI received */
2657 2649
2658 lpfc_set_disctmo(phba); 2650 lpfc_set_disctmo(vport);
2659 2651
2660 if (phba->fc_topology == TOPOLOGY_LOOP) { 2652 if (phba->fc_topology == TOPOLOGY_LOOP) {
2661 /* We should never receive a FLOGI in loop mode, ignore it */ 2653 /* We should never receive a FLOGI in loop mode, ignore it */
@@ -2672,19 +2664,19 @@ lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2672 2664
2673 did = Fabric_DID; 2665 did = Fabric_DID;
2674 2666
2675 if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) { 2667 if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
2676 /* For a FLOGI we accept, then if our portname is greater 2668 /* For a FLOGI we accept, then if our portname is greater
2677 * then the remote portname we initiate Nport login. 2669 * then the remote portname we initiate Nport login.
2678 */ 2670 */
2679 2671
2680 rc = memcmp(&phba->fc_portname, &sp->portName, 2672 rc = memcmp(&vport->fc_portname, &sp->portName,
2681 sizeof (struct lpfc_name)); 2673 sizeof (struct lpfc_name));
2682 2674
2683 if (!rc) { 2675 if (!rc) {
2684 if ((mbox = mempool_alloc(phba->mbox_mem_pool, 2676 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2685 GFP_KERNEL)) == 0) { 2677 if (!mbox)
2686 return 1; 2678 return 1;
2687 } 2679
2688 lpfc_linkdown(phba); 2680 lpfc_linkdown(phba);
2689 lpfc_init_link(phba, mbox, 2681 lpfc_init_link(phba, mbox,
2690 phba->cfg_topology, 2682 phba->cfg_topology,
@@ -2699,31 +2691,33 @@ lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2699 } 2691 }
2700 return 1; 2692 return 1;
2701 } else if (rc > 0) { /* greater than */ 2693 } else if (rc > 0) { /* greater than */
2702 spin_lock_irq(phba->host->host_lock); 2694 spin_lock_irq(shost->host_lock);
2703 phba->fc_flag |= FC_PT2PT_PLOGI; 2695 vport->fc_flag |= FC_PT2PT_PLOGI;
2704 spin_unlock_irq(phba->host->host_lock); 2696 spin_unlock_irq(shost->host_lock);
2705 } 2697 }
2706 phba->fc_flag |= FC_PT2PT; 2698 spin_lock_irq(shost->host_lock);
2707 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 2699 vport->fc_flag |= FC_PT2PT;
2700 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2701 spin_unlock_irq(shost->host_lock);
2708 } else { 2702 } else {
2709 /* Reject this request because invalid parameters */ 2703 /* Reject this request because invalid parameters */
2710 stat.un.b.lsRjtRsvd0 = 0; 2704 stat.un.b.lsRjtRsvd0 = 0;
2711 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2705 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2712 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS; 2706 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
2713 stat.un.b.vendorUnique = 0; 2707 stat.un.b.vendorUnique = 0;
2714 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2708 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2715 return 1; 2709 return 1;
2716 } 2710 }
2717 2711
2718 /* Send back ACC */ 2712 /* Send back ACC */
2719 lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode); 2713 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
2720 2714
2721 return 0; 2715 return 0;
2722} 2716}
2723 2717
2724static int 2718static int
2725lpfc_els_rcv_rnid(struct lpfc_hba * phba, 2719lpfc_els_rcv_rnid(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2726 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 2720 struct lpfc_nodelist *ndlp)
2727{ 2721{
2728 struct lpfc_dmabuf *pcmd; 2722 struct lpfc_dmabuf *pcmd;
2729 uint32_t *lp; 2723 uint32_t *lp;
@@ -2746,7 +2740,7 @@ lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2746 case 0: 2740 case 0:
2747 case RNID_TOPOLOGY_DISC: 2741 case RNID_TOPOLOGY_DISC:
2748 /* Send back ACC */ 2742 /* Send back ACC */
2749 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp); 2743 lpfc_els_rsp_rnid_acc(vport, rn->Format, cmdiocb, ndlp);
2750 break; 2744 break;
2751 default: 2745 default:
2752 /* Reject this request because format not supported */ 2746 /* Reject this request because format not supported */
@@ -2754,14 +2748,14 @@ lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2754 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2748 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2755 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2749 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2756 stat.un.b.vendorUnique = 0; 2750 stat.un.b.vendorUnique = 0;
2757 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2751 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2758 } 2752 }
2759 return 0; 2753 return 0;
2760} 2754}
2761 2755
2762static int 2756static int
2763lpfc_els_rcv_lirr(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb, 2757lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2764 struct lpfc_nodelist *ndlp) 2758 struct lpfc_nodelist *ndlp)
2765{ 2759{
2766 struct ls_rjt stat; 2760 struct ls_rjt stat;
2767 2761
@@ -2770,15 +2764,15 @@ lpfc_els_rcv_lirr(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2770 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2764 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2771 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2765 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2772 stat.un.b.vendorUnique = 0; 2766 stat.un.b.vendorUnique = 0;
2773 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2767 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2774 return 0; 2768 return 0;
2775} 2769}
2776 2770
2777static void 2771static void
2778lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 2772lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2779{ 2773{
2780 struct lpfc_sli *psli; 2774 struct lpfc_sli *psli = &phba->sli;
2781 struct lpfc_sli_ring *pring; 2775 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2782 MAILBOX_t *mb; 2776 MAILBOX_t *mb;
2783 IOCB_t *icmd; 2777 IOCB_t *icmd;
2784 RPS_RSP *rps_rsp; 2778 RPS_RSP *rps_rsp;
@@ -2788,8 +2782,6 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2788 uint16_t xri, status; 2782 uint16_t xri, status;
2789 uint32_t cmdsize; 2783 uint32_t cmdsize;
2790 2784
2791 psli = &phba->sli;
2792 pring = &psli->ring[LPFC_ELS_RING];
2793 mb = &pmb->mb; 2785 mb = &pmb->mb;
2794 2786
2795 ndlp = (struct lpfc_nodelist *) pmb->context2; 2787 ndlp = (struct lpfc_nodelist *) pmb->context2;
@@ -2804,8 +2796,9 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2804 2796
2805 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t); 2797 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
2806 mempool_free(pmb, phba->mbox_mem_pool); 2798 mempool_free(pmb, phba->mbox_mem_pool);
2807 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp, 2799 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
2808 ndlp->nlp_DID, ELS_CMD_ACC); 2800 lpfc_max_els_tries, ndlp,
2801 ndlp->nlp_DID, ELS_CMD_ACC);
2809 lpfc_nlp_put(ndlp); 2802 lpfc_nlp_put(ndlp);
2810 if (!elsiocb) 2803 if (!elsiocb)
2811 return; 2804 return;
@@ -2822,7 +2815,7 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2822 status = 0x10; 2815 status = 0x10;
2823 else 2816 else
2824 status = 0x8; 2817 status = 0x8;
2825 if (phba->fc_flag & FC_FABRIC) 2818 if (phba->pport->fc_flag & FC_FABRIC)
2826 status |= 0x4; 2819 status |= 0x4;
2827 2820
2828 rps_rsp->rsvd1 = 0; 2821 rps_rsp->rsvd1 = 0;
@@ -2852,9 +2845,10 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2852} 2845}
2853 2846
2854static int 2847static int
2855lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 2848lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2856 struct lpfc_nodelist * ndlp) 2849 struct lpfc_nodelist *ndlp)
2857{ 2850{
2851 struct lpfc_hba *phba = vport->phba;
2858 uint32_t *lp; 2852 uint32_t *lp;
2859 uint8_t flag; 2853 uint8_t flag;
2860 LPFC_MBOXQ_t *mbox; 2854 LPFC_MBOXQ_t *mbox;
@@ -2868,7 +2862,7 @@ lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2868 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2862 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2869 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2863 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2870 stat.un.b.vendorUnique = 0; 2864 stat.un.b.vendorUnique = 0;
2871 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2865 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2872 } 2866 }
2873 2867
2874 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2868 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
@@ -2878,19 +2872,21 @@ lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2878 2872
2879 if ((flag == 0) || 2873 if ((flag == 0) ||
2880 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) || 2874 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
2881 ((flag == 2) && (memcmp(&rps->un.portName, &phba->fc_portname, 2875 ((flag == 2) && (memcmp(&rps->un.portName, &vport->fc_portname,
2882 sizeof (struct lpfc_name)) == 0))) { 2876 sizeof (struct lpfc_name)) == 0))) {
2883 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC))) { 2877
2878 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
2879 if (mbox) {
2884 lpfc_read_lnk_stat(phba, mbox); 2880 lpfc_read_lnk_stat(phba, mbox);
2885 mbox->context1 = 2881 mbox->context1 =
2886 (void *)((unsigned long)cmdiocb->iocb.ulpContext); 2882 (void *)((unsigned long)cmdiocb->iocb.ulpContext);
2887 mbox->context2 = lpfc_nlp_get(ndlp); 2883 mbox->context2 = lpfc_nlp_get(ndlp);
2888 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc; 2884 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
2889 if (lpfc_sli_issue_mbox (phba, mbox, 2885 if (lpfc_sli_issue_mbox (phba, mbox,
2890 (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED) { 2886 (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED)
2891 /* Mbox completion will send ELS Response */ 2887 /* Mbox completion will send ELS Response */
2892 return 0; 2888 return 0;
2893 } 2889
2894 lpfc_nlp_put(ndlp); 2890 lpfc_nlp_put(ndlp);
2895 mempool_free(mbox, phba->mbox_mem_pool); 2891 mempool_free(mbox, phba->mbox_mem_pool);
2896 } 2892 }
@@ -2899,27 +2895,25 @@ lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2899 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2895 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2900 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2896 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2901 stat.un.b.vendorUnique = 0; 2897 stat.un.b.vendorUnique = 0;
2902 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2898 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2903 return 0; 2899 return 0;
2904} 2900}
2905 2901
2906static int 2902static int
2907lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize, 2903lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
2908 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp) 2904 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
2909{ 2905{
2910 IOCB_t *icmd; 2906 struct lpfc_hba *phba = vport->phba;
2911 IOCB_t *oldcmd; 2907 IOCB_t *icmd, *oldcmd;
2912 RPL_RSP rpl_rsp; 2908 RPL_RSP rpl_rsp;
2913 struct lpfc_iocbq *elsiocb; 2909 struct lpfc_iocbq *elsiocb;
2914 struct lpfc_sli_ring *pring; 2910 struct lpfc_sli *psli = &phba->sli;
2915 struct lpfc_sli *psli; 2911 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2916 uint8_t *pcmd; 2912 uint8_t *pcmd;
2917 2913
2918 psli = &phba->sli; 2914 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2919 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */ 2915 ndlp->nlp_DID, ELS_CMD_ACC);
2920 2916
2921 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2922 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2923 if (!elsiocb) 2917 if (!elsiocb)
2924 return 1; 2918 return 1;
2925 2919
@@ -2937,8 +2931,8 @@ lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
2937 rpl_rsp.listLen = be32_to_cpu(1); 2931 rpl_rsp.listLen = be32_to_cpu(1);
2938 rpl_rsp.index = 0; 2932 rpl_rsp.index = 0;
2939 rpl_rsp.port_num_blk.portNum = 0; 2933 rpl_rsp.port_num_blk.portNum = 0;
2940 rpl_rsp.port_num_blk.portID = be32_to_cpu(phba->fc_myDID); 2934 rpl_rsp.port_num_blk.portID = be32_to_cpu(vport->fc_myDID);
2941 memcpy(&rpl_rsp.port_num_blk.portName, &phba->fc_portname, 2935 memcpy(&rpl_rsp.port_num_blk.portName, &vport->fc_portname,
2942 sizeof(struct lpfc_name)); 2936 sizeof(struct lpfc_name));
2943 2937
2944 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t)); 2938 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
@@ -2963,8 +2957,8 @@ lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
2963} 2957}
2964 2958
2965static int 2959static int
2966lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 2960lpfc_els_rcv_rpl(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2967 struct lpfc_nodelist * ndlp) 2961 struct lpfc_nodelist *ndlp)
2968{ 2962{
2969 struct lpfc_dmabuf *pcmd; 2963 struct lpfc_dmabuf *pcmd;
2970 uint32_t *lp; 2964 uint32_t *lp;
@@ -2979,7 +2973,7 @@ lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2979 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 2973 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2980 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA; 2974 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2981 stat.un.b.vendorUnique = 0; 2975 stat.un.b.vendorUnique = 0;
2982 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp); 2976 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
2983 } 2977 }
2984 2978
2985 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2; 2979 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
@@ -2996,15 +2990,16 @@ lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2996 } else { 2990 } else {
2997 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t); 2991 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
2998 } 2992 }
2999 lpfc_els_rsp_rpl_acc(phba, cmdsize, cmdiocb, ndlp); 2993 lpfc_els_rsp_rpl_acc(vport, cmdsize, cmdiocb, ndlp);
3000 2994
3001 return 0; 2995 return 0;
3002} 2996}
3003 2997
3004static int 2998static int
3005lpfc_els_rcv_farp(struct lpfc_hba * phba, 2999lpfc_els_rcv_farp(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3006 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 3000 struct lpfc_nodelist *ndlp)
3007{ 3001{
3002 struct lpfc_hba *phba = vport->phba;
3008 struct lpfc_dmabuf *pcmd; 3003 struct lpfc_dmabuf *pcmd;
3009 uint32_t *lp; 3004 uint32_t *lp;
3010 IOCB_t *icmd; 3005 IOCB_t *icmd;
@@ -3034,14 +3029,14 @@ lpfc_els_rcv_farp(struct lpfc_hba * phba,
3034 cnt = 0; 3029 cnt = 0;
3035 /* If this FARP command is searching for my portname */ 3030 /* If this FARP command is searching for my portname */
3036 if (fp->Mflags & FARP_MATCH_PORT) { 3031 if (fp->Mflags & FARP_MATCH_PORT) {
3037 if (memcmp(&fp->RportName, &phba->fc_portname, 3032 if (memcmp(&fp->RportName, &vport->fc_portname,
3038 sizeof (struct lpfc_name)) == 0) 3033 sizeof (struct lpfc_name)) == 0)
3039 cnt = 1; 3034 cnt = 1;
3040 } 3035 }
3041 3036
3042 /* If this FARP command is searching for my nodename */ 3037 /* If this FARP command is searching for my nodename */
3043 if (fp->Mflags & FARP_MATCH_NODE) { 3038 if (fp->Mflags & FARP_MATCH_NODE) {
3044 if (memcmp(&fp->RnodeName, &phba->fc_nodename, 3039 if (memcmp(&fp->RnodeName, &vport->fc_nodename,
3045 sizeof (struct lpfc_name)) == 0) 3040 sizeof (struct lpfc_name)) == 0)
3046 cnt = 1; 3041 cnt = 1;
3047 } 3042 }
@@ -3052,28 +3047,28 @@ lpfc_els_rcv_farp(struct lpfc_hba * phba,
3052 /* Log back into the node before sending the FARP. */ 3047 /* Log back into the node before sending the FARP. */
3053 if (fp->Rflags & FARP_REQUEST_PLOGI) { 3048 if (fp->Rflags & FARP_REQUEST_PLOGI) {
3054 ndlp->nlp_prev_state = ndlp->nlp_state; 3049 ndlp->nlp_prev_state = ndlp->nlp_state;
3055 lpfc_nlp_set_state(phba, ndlp, 3050 lpfc_nlp_set_state(vport, ndlp,
3056 NLP_STE_PLOGI_ISSUE); 3051 NLP_STE_PLOGI_ISSUE);
3057 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0); 3052 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
3058 } 3053 }
3059 3054
3060 /* Send a FARP response to that node */ 3055 /* Send a FARP response to that node */
3061 if (fp->Rflags & FARP_REQUEST_FARPR) { 3056 if (fp->Rflags & FARP_REQUEST_FARPR)
3062 lpfc_issue_els_farpr(phba, did, 0); 3057 lpfc_issue_els_farpr(vport, did, 0);
3063 }
3064 } 3058 }
3065 } 3059 }
3066 return 0; 3060 return 0;
3067} 3061}
3068 3062
3069static int 3063static int
3070lpfc_els_rcv_farpr(struct lpfc_hba * phba, 3064lpfc_els_rcv_farpr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3071 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp) 3065 struct lpfc_nodelist *ndlp)
3072{ 3066{
3073 struct lpfc_dmabuf *pcmd; 3067 struct lpfc_dmabuf *pcmd;
3074 uint32_t *lp; 3068 uint32_t *lp;
3075 IOCB_t *icmd; 3069 IOCB_t *icmd;
3076 uint32_t cmd, did; 3070 uint32_t cmd, did;
3071 struct lpfc_hba *phba = vport->phba;
3077 3072
3078 icmd = &cmdiocb->iocb; 3073 icmd = &cmdiocb->iocb;
3079 did = icmd->un.elsreq64.remoteID; 3074 did = icmd->un.elsreq64.remoteID;
@@ -3089,14 +3084,14 @@ lpfc_els_rcv_farpr(struct lpfc_hba * phba,
3089 phba->brd_no, did); 3084 phba->brd_no, did);
3090 3085
3091 /* ACCEPT the Farp resp request */ 3086 /* ACCEPT the Farp resp request */
3092 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0); 3087 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
3093 3088
3094 return 0; 3089 return 0;
3095} 3090}
3096 3091
3097static int 3092static int
3098lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb, 3093lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3099 struct lpfc_nodelist * fan_ndlp) 3094 struct lpfc_nodelist *fan_ndlp)
3100{ 3095{
3101 struct lpfc_dmabuf *pcmd; 3096 struct lpfc_dmabuf *pcmd;
3102 uint32_t *lp; 3097 uint32_t *lp;
@@ -3104,6 +3099,7 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3104 uint32_t cmd, did; 3099 uint32_t cmd, did;
3105 FAN *fp; 3100 FAN *fp;
3106 struct lpfc_nodelist *ndlp, *next_ndlp; 3101 struct lpfc_nodelist *ndlp, *next_ndlp;
3102 struct lpfc_hba *phba = vport->phba;
3107 3103
3108 /* FAN received */ 3104 /* FAN received */
3109 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n", 3105 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
@@ -3119,7 +3115,7 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3119 3115
3120 /* FAN received; Fan does not have a reply sequence */ 3116 /* FAN received; Fan does not have a reply sequence */
3121 3117
3122 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) { 3118 if (phba->pport->port_state == LPFC_LOCAL_CFG_LINK) {
3123 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName, 3119 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3124 sizeof(struct lpfc_name)) != 0) || 3120 sizeof(struct lpfc_name)) != 0) ||
3125 (memcmp(&phba->fc_fabparam.portName, &fp->FportName, 3121 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
@@ -3130,7 +3126,7 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3130 */ 3126 */
3131 3127
3132 list_for_each_entry_safe(ndlp, next_ndlp, 3128 list_for_each_entry_safe(ndlp, next_ndlp,
3133 &phba->fc_nodes, nlp_listp) { 3129 &vport->fc_nodes, nlp_listp) {
3134 if (ndlp->nlp_state != NLP_STE_NPR_NODE) 3130 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3135 continue; 3131 continue;
3136 if (ndlp->nlp_type & NLP_FABRIC) { 3132 if (ndlp->nlp_type & NLP_FABRIC) {
@@ -3138,24 +3134,24 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3138 * Clean up old Fabric, Nameserver and 3134 * Clean up old Fabric, Nameserver and
3139 * other NLP_FABRIC logins 3135 * other NLP_FABRIC logins
3140 */ 3136 */
3141 lpfc_drop_node(phba, ndlp); 3137 lpfc_drop_node(vport, ndlp);
3142 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) { 3138 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
3143 /* Fail outstanding I/O now since this 3139 /* Fail outstanding I/O now since this
3144 * device is marked for PLOGI 3140 * device is marked for PLOGI
3145 */ 3141 */
3146 lpfc_unreg_rpi(phba, ndlp); 3142 lpfc_unreg_rpi(vport, ndlp);
3147 } 3143 }
3148 } 3144 }
3149 3145
3150 phba->hba_state = LPFC_FLOGI; 3146 vport->port_state = LPFC_FLOGI;
3151 lpfc_set_disctmo(phba); 3147 lpfc_set_disctmo(vport);
3152 lpfc_initial_flogi(phba); 3148 lpfc_initial_flogi(vport);
3153 return 0; 3149 return 0;
3154 } 3150 }
3155 /* Discovery not needed, 3151 /* Discovery not needed,
3156 * move the nodes to their original state. 3152 * move the nodes to their original state.
3157 */ 3153 */
3158 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, 3154 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
3159 nlp_listp) { 3155 nlp_listp) {
3160 if (ndlp->nlp_state != NLP_STE_NPR_NODE) 3156 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3161 continue; 3157 continue;
@@ -3163,13 +3159,13 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3163 switch (ndlp->nlp_prev_state) { 3159 switch (ndlp->nlp_prev_state) {
3164 case NLP_STE_UNMAPPED_NODE: 3160 case NLP_STE_UNMAPPED_NODE:
3165 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 3161 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3166 lpfc_nlp_set_state(phba, ndlp, 3162 lpfc_nlp_set_state(vport, ndlp,
3167 NLP_STE_UNMAPPED_NODE); 3163 NLP_STE_UNMAPPED_NODE);
3168 break; 3164 break;
3169 3165
3170 case NLP_STE_MAPPED_NODE: 3166 case NLP_STE_MAPPED_NODE:
3171 ndlp->nlp_prev_state = NLP_STE_NPR_NODE; 3167 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3172 lpfc_nlp_set_state(phba, ndlp, 3168 lpfc_nlp_set_state(vport, ndlp,
3173 NLP_STE_MAPPED_NODE); 3169 NLP_STE_MAPPED_NODE);
3174 break; 3170 break;
3175 3171
@@ -3179,7 +3175,7 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3179 } 3175 }
3180 3176
3181 /* Start discovery - this should just do CLEAR_LA */ 3177 /* Start discovery - this should just do CLEAR_LA */
3182 lpfc_disc_start(phba); 3178 lpfc_disc_start(vport);
3183 } 3179 }
3184 return 0; 3180 return 0;
3185} 3181}
@@ -3187,42 +3183,37 @@ lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3187void 3183void
3188lpfc_els_timeout(unsigned long ptr) 3184lpfc_els_timeout(unsigned long ptr)
3189{ 3185{
3190 struct lpfc_hba *phba; 3186 struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
3187 struct lpfc_hba *phba = vport->phba;
3191 unsigned long iflag; 3188 unsigned long iflag;
3192 3189
3193 phba = (struct lpfc_hba *)ptr; 3190 spin_lock_irqsave(&vport->work_port_lock, iflag);
3194 if (phba == 0) 3191 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3195 return; 3192 vport->work_port_events |= WORKER_ELS_TMO;
3196 spin_lock_irqsave(phba->host->host_lock, iflag);
3197 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3198 phba->work_hba_events |= WORKER_ELS_TMO;
3199 if (phba->work_wait) 3193 if (phba->work_wait)
3200 wake_up(phba->work_wait); 3194 wake_up(phba->work_wait);
3201 } 3195 }
3202 spin_unlock_irqrestore(phba->host->host_lock, iflag); 3196 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3203 return; 3197 return;
3204} 3198}
3205 3199
3206void 3200void
3207lpfc_els_timeout_handler(struct lpfc_hba *phba) 3201lpfc_els_timeout_handler(struct lpfc_vport *vport)
3208{ 3202{
3203 struct lpfc_hba *phba = vport->phba;
3209 struct lpfc_sli_ring *pring; 3204 struct lpfc_sli_ring *pring;
3210 struct lpfc_iocbq *tmp_iocb, *piocb; 3205 struct lpfc_iocbq *tmp_iocb, *piocb;
3211 IOCB_t *cmd = NULL; 3206 IOCB_t *cmd = NULL;
3212 struct lpfc_dmabuf *pcmd; 3207 struct lpfc_dmabuf *pcmd;
3213 uint32_t *elscmd; 3208 uint32_t els_command = 0;
3214 uint32_t els_command=0;
3215 uint32_t timeout; 3209 uint32_t timeout;
3216 uint32_t remote_ID; 3210 uint32_t remote_ID = 0xffffffff;
3217 3211
3218 if (phba == 0)
3219 return;
3220 spin_lock_irq(phba->host->host_lock);
3221 /* If the timer is already canceled do nothing */ 3212 /* If the timer is already canceled do nothing */
3222 if (!(phba->work_hba_events & WORKER_ELS_TMO)) { 3213 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3223 spin_unlock_irq(phba->host->host_lock);
3224 return; 3214 return;
3225 } 3215 }
3216 spin_lock_irq(&phba->hbalock);
3226 timeout = (uint32_t)(phba->fc_ratov << 1); 3217 timeout = (uint32_t)(phba->fc_ratov << 1);
3227 3218
3228 pring = &phba->sli.ring[LPFC_ELS_RING]; 3219 pring = &phba->sli.ring[LPFC_ELS_RING];
@@ -3230,16 +3221,17 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
3230 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) { 3221 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3231 cmd = &piocb->iocb; 3222 cmd = &piocb->iocb;
3232 3223
3233 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) || 3224 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) != 0 ||
3234 (piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN) || 3225 piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
3235 (piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)) { 3226 piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
3236 continue; 3227 continue;
3237 } 3228
3229 if (piocb->vport != vport)
3230 continue;
3231
3238 pcmd = (struct lpfc_dmabuf *) piocb->context2; 3232 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3239 if (pcmd) { 3233 if (pcmd)
3240 elscmd = (uint32_t *) (pcmd->virt); 3234 els_command = *(uint32_t *) (pcmd->virt);
3241 els_command = *elscmd;
3242 }
3243 3235
3244 if ((els_command == ELS_CMD_FARP) 3236 if ((els_command == ELS_CMD_FARP)
3245 || (els_command == ELS_CMD_FARPR)) { 3237 || (els_command == ELS_CMD_FARPR)) {
@@ -3255,12 +3247,14 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
3255 continue; 3247 continue;
3256 } 3248 }
3257 3249
3258 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) { 3250 remote_ID = 0xffffffff;
3259 struct lpfc_nodelist *ndlp; 3251 if (cmd->ulpCommand != CMD_GEN_REQUEST64_CR)
3260 ndlp = __lpfc_findnode_rpi(phba, cmd->ulpContext);
3261 remote_ID = ndlp->nlp_DID;
3262 } else {
3263 remote_ID = cmd->un.elsreq64.remoteID; 3252 remote_ID = cmd->un.elsreq64.remoteID;
3253 else {
3254 struct lpfc_nodelist *ndlp;
3255 ndlp = __lpfc_findnode_rpi(vport, cmd->ulpContext);
3256 if (ndlp)
3257 remote_ID = ndlp->nlp_DID;
3264 } 3258 }
3265 3259
3266 lpfc_printf_log(phba, 3260 lpfc_printf_log(phba,
@@ -3272,21 +3266,22 @@ lpfc_els_timeout_handler(struct lpfc_hba *phba)
3272 3266
3273 lpfc_sli_issue_abort_iotag(phba, pring, piocb); 3267 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3274 } 3268 }
3275 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt) 3269 spin_unlock_irq(&phba->hbalock);
3276 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
3277 3270
3278 spin_unlock_irq(phba->host->host_lock); 3271 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3272 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
3279} 3273}
3280 3274
3281void 3275void
3282lpfc_els_flush_cmd(struct lpfc_hba *phba) 3276lpfc_els_flush_cmd(struct lpfc_vport *vport)
3283{ 3277{
3284 LIST_HEAD(completions); 3278 LIST_HEAD(completions);
3279 struct lpfc_hba *phba = vport->phba;
3285 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING]; 3280 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3286 struct lpfc_iocbq *tmp_iocb, *piocb; 3281 struct lpfc_iocbq *tmp_iocb, *piocb;
3287 IOCB_t *cmd = NULL; 3282 IOCB_t *cmd = NULL;
3288 3283
3289 spin_lock_irq(phba->host->host_lock); 3284 spin_lock_irq(&phba->hbalock);
3290 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) { 3285 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3291 cmd = &piocb->iocb; 3286 cmd = &piocb->iocb;
3292 3287
@@ -3301,61 +3296,63 @@ lpfc_els_flush_cmd(struct lpfc_hba *phba)
3301 cmd->ulpCommand == CMD_ABORT_XRI_CN) 3296 cmd->ulpCommand == CMD_ABORT_XRI_CN)
3302 continue; 3297 continue;
3303 3298
3299 if (piocb->vport != vport)
3300 continue;
3301
3304 list_move_tail(&piocb->list, &completions); 3302 list_move_tail(&piocb->list, &completions);
3305 pring->txq_cnt--; 3303 pring->txq_cnt--;
3306
3307 } 3304 }
3308 3305
3309 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) { 3306 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3310 cmd = &piocb->iocb;
3311
3312 if (piocb->iocb_flag & LPFC_IO_LIBDFC) { 3307 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3313 continue; 3308 continue;
3314 } 3309 }
3315 3310
3311 if (piocb->vport != vport)
3312 continue;
3313
3316 lpfc_sli_issue_abort_iotag(phba, pring, piocb); 3314 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3317 } 3315 }
3318 spin_unlock_irq(phba->host->host_lock); 3316 spin_unlock_irq(&phba->hbalock);
3319 3317
3320 while(!list_empty(&completions)) { 3318 while (!list_empty(&completions)) {
3321 piocb = list_get_first(&completions, struct lpfc_iocbq, list); 3319 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3322 cmd = &piocb->iocb; 3320 cmd = &piocb->iocb;
3323 list_del(&piocb->list); 3321 list_del(&piocb->list);
3324 3322
3325 if (piocb->iocb_cmpl) { 3323 if (!piocb->iocb_cmpl)
3324 lpfc_sli_release_iocbq(phba, piocb);
3325 else {
3326 cmd->ulpStatus = IOSTAT_LOCAL_REJECT; 3326 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3327 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 3327 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3328 (piocb->iocb_cmpl) (phba, piocb, piocb); 3328 (piocb->iocb_cmpl) (phba, piocb, piocb);
3329 } else 3329 }
3330 lpfc_sli_release_iocbq(phba, piocb);
3331 } 3330 }
3332 3331
3333 return; 3332 return;
3334} 3333}
3335 3334
3336void 3335void
3337lpfc_els_unsol_event(struct lpfc_hba * phba, 3336lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3338 struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb) 3337 struct lpfc_iocbq *elsiocb)
3339{ 3338{
3340 struct lpfc_sli *psli; 3339 struct lpfc_sli *psli;
3341 struct lpfc_nodelist *ndlp; 3340 struct lpfc_nodelist *ndlp;
3342 struct lpfc_dmabuf *mp; 3341 struct lpfc_dmabuf *mp = NULL;
3343 uint32_t *lp; 3342 uint32_t *lp;
3344 IOCB_t *icmd; 3343 IOCB_t *icmd;
3345 struct ls_rjt stat; 3344 struct ls_rjt stat;
3346 uint32_t cmd; 3345 uint32_t cmd, did, newnode, rjt_err = 0;
3347 uint32_t did;
3348 uint32_t newnode;
3349 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */ 3346 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */
3350 uint32_t rjt_err = 0; 3347 struct lpfc_vport *vport = NULL;
3351 3348
3352 psli = &phba->sli; 3349 psli = &phba->sli;
3353 icmd = &elsiocb->iocb; 3350 icmd = &elsiocb->iocb;
3354 3351
3355 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) && 3352 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3356 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) { 3353 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
3357 /* Not enough posted buffers; Try posting more buffers */
3358 phba->fc_stat.NoRcvBuf++; 3354 phba->fc_stat.NoRcvBuf++;
3355 /* Not enough posted buffers; Try posting more buffers */
3359 lpfc_post_buffer(phba, pring, 0, 1); 3356 lpfc_post_buffer(phba, pring, 0, 1);
3360 return; 3357 return;
3361 } 3358 }
@@ -3366,17 +3363,17 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3366 if (icmd->ulpBdeCount == 0) 3363 if (icmd->ulpBdeCount == 0)
3367 return; 3364 return;
3368 3365
3369 /* type of ELS cmd is first 32bit word in packet */ 3366 /* type of ELS cmd is first 32bit word in packet */
3370 mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un. 3367 mp = lpfc_sli_ringpostbuf_get(phba, pring,
3371 cont64[0]. 3368 getPaddr(icmd->un.cont64[0].addrHigh,
3372 addrHigh, 3369 icmd->un.cont64[0].addrLow));
3373 icmd->un.
3374 cont64[0].addrLow));
3375 if (mp == 0) { 3370 if (mp == 0) {
3376 drop_cmd = 1; 3371 drop_cmd = 1;
3377 goto dropit; 3372 goto dropit;
3378 } 3373 }
3379 3374
3375 vport = phba->pport;
3376
3380 newnode = 0; 3377 newnode = 0;
3381 lp = (uint32_t *) mp->virt; 3378 lp = (uint32_t *) mp->virt;
3382 cmd = *lp++; 3379 cmd = *lp++;
@@ -3390,7 +3387,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3390 } 3387 }
3391 3388
3392 /* Check to see if link went down during discovery */ 3389 /* Check to see if link went down during discovery */
3393 if (lpfc_els_chk_latt(phba)) { 3390 if (lpfc_els_chk_latt(vport)) {
3394 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3391 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3395 kfree(mp); 3392 kfree(mp);
3396 drop_cmd = 1; 3393 drop_cmd = 1;
@@ -3398,7 +3395,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3398 } 3395 }
3399 3396
3400 did = icmd->un.rcvels.remoteID; 3397 did = icmd->un.rcvels.remoteID;
3401 ndlp = lpfc_findnode_did(phba, did); 3398 ndlp = lpfc_findnode_did(vport, did);
3402 if (!ndlp) { 3399 if (!ndlp) {
3403 /* Cannot find existing Fabric ndlp, so allocate a new one */ 3400 /* Cannot find existing Fabric ndlp, so allocate a new one */
3404 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 3401 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
@@ -3409,12 +3406,12 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3409 goto dropit; 3406 goto dropit;
3410 } 3407 }
3411 3408
3412 lpfc_nlp_init(phba, ndlp, did); 3409 lpfc_nlp_init(vport, ndlp, did);
3413 newnode = 1; 3410 newnode = 1;
3414 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) { 3411 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3415 ndlp->nlp_type |= NLP_FABRIC; 3412 ndlp->nlp_type |= NLP_FABRIC;
3416 } 3413 }
3417 lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE); 3414 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
3418 } 3415 }
3419 3416
3420 phba->fc_stat.elsRcvFrame++; 3417 phba->fc_stat.elsRcvFrame++;
@@ -3422,6 +3419,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3422 lpfc_nlp_put(elsiocb->context1); 3419 lpfc_nlp_put(elsiocb->context1);
3423 elsiocb->context1 = lpfc_nlp_get(ndlp); 3420 elsiocb->context1 = lpfc_nlp_get(ndlp);
3424 elsiocb->context2 = mp; 3421 elsiocb->context2 = mp;
3422 elsiocb->vport = vport;
3425 3423
3426 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) { 3424 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3427 cmd &= ELS_CMD_MASK; 3425 cmd &= ELS_CMD_MASK;
@@ -3429,105 +3427,109 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3429 /* ELS command <elsCmd> received from NPORT <did> */ 3427 /* ELS command <elsCmd> received from NPORT <did> */
3430 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, 3428 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3431 "%d:0112 ELS command x%x received from NPORT x%x " 3429 "%d:0112 ELS command x%x received from NPORT x%x "
3432 "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state); 3430 "Data: x%x\n", phba->brd_no, cmd, did,
3431 vport->port_state);
3433 3432
3434 switch (cmd) { 3433 switch (cmd) {
3435 case ELS_CMD_PLOGI: 3434 case ELS_CMD_PLOGI:
3436 phba->fc_stat.elsRcvPLOGI++; 3435 phba->fc_stat.elsRcvPLOGI++;
3437 if (phba->hba_state < LPFC_DISC_AUTH) { 3436 if (vport->port_state < LPFC_DISC_AUTH) {
3438 rjt_err = 1; 3437 rjt_err = 1;
3439 break; 3438 break;
3440 } 3439 }
3441 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp); 3440 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
3442 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI); 3441 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3442 NLP_EVT_RCV_PLOGI);
3443 break; 3443 break;
3444 case ELS_CMD_FLOGI: 3444 case ELS_CMD_FLOGI:
3445 phba->fc_stat.elsRcvFLOGI++; 3445 phba->fc_stat.elsRcvFLOGI++;
3446 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode); 3446 lpfc_els_rcv_flogi(vport, elsiocb, ndlp, newnode);
3447 if (newnode) 3447 if (newnode)
3448 lpfc_drop_node(phba, ndlp); 3448 lpfc_drop_node(vport, ndlp);
3449 break; 3449 break;
3450 case ELS_CMD_LOGO: 3450 case ELS_CMD_LOGO:
3451 phba->fc_stat.elsRcvLOGO++; 3451 phba->fc_stat.elsRcvLOGO++;
3452 if (phba->hba_state < LPFC_DISC_AUTH) { 3452 if (vport->port_state < LPFC_DISC_AUTH) {
3453 rjt_err = 1; 3453 rjt_err = 1;
3454 break; 3454 break;
3455 } 3455 }
3456 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO); 3456 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3457 break; 3457 break;
3458 case ELS_CMD_PRLO: 3458 case ELS_CMD_PRLO:
3459 phba->fc_stat.elsRcvPRLO++; 3459 phba->fc_stat.elsRcvPRLO++;
3460 if (phba->hba_state < LPFC_DISC_AUTH) { 3460 if (vport->port_state < LPFC_DISC_AUTH) {
3461 rjt_err = 1; 3461 rjt_err = 1;
3462 break; 3462 break;
3463 } 3463 }
3464 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO); 3464 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3465 break; 3465 break;
3466 case ELS_CMD_RSCN: 3466 case ELS_CMD_RSCN:
3467 phba->fc_stat.elsRcvRSCN++; 3467 phba->fc_stat.elsRcvRSCN++;
3468 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode); 3468 lpfc_els_rcv_rscn(vport, elsiocb, ndlp, newnode);
3469 if (newnode) 3469 if (newnode)
3470 lpfc_drop_node(phba, ndlp); 3470 lpfc_drop_node(vport, ndlp);
3471 break; 3471 break;
3472 case ELS_CMD_ADISC: 3472 case ELS_CMD_ADISC:
3473 phba->fc_stat.elsRcvADISC++; 3473 phba->fc_stat.elsRcvADISC++;
3474 if (phba->hba_state < LPFC_DISC_AUTH) { 3474 if (vport->port_state < LPFC_DISC_AUTH) {
3475 rjt_err = 1; 3475 rjt_err = 1;
3476 break; 3476 break;
3477 } 3477 }
3478 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC); 3478 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3479 NLP_EVT_RCV_ADISC);
3479 break; 3480 break;
3480 case ELS_CMD_PDISC: 3481 case ELS_CMD_PDISC:
3481 phba->fc_stat.elsRcvPDISC++; 3482 phba->fc_stat.elsRcvPDISC++;
3482 if (phba->hba_state < LPFC_DISC_AUTH) { 3483 if (vport->port_state < LPFC_DISC_AUTH) {
3483 rjt_err = 1; 3484 rjt_err = 1;
3484 break; 3485 break;
3485 } 3486 }
3486 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC); 3487 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3488 NLP_EVT_RCV_PDISC);
3487 break; 3489 break;
3488 case ELS_CMD_FARPR: 3490 case ELS_CMD_FARPR:
3489 phba->fc_stat.elsRcvFARPR++; 3491 phba->fc_stat.elsRcvFARPR++;
3490 lpfc_els_rcv_farpr(phba, elsiocb, ndlp); 3492 lpfc_els_rcv_farpr(vport, elsiocb, ndlp);
3491 break; 3493 break;
3492 case ELS_CMD_FARP: 3494 case ELS_CMD_FARP:
3493 phba->fc_stat.elsRcvFARP++; 3495 phba->fc_stat.elsRcvFARP++;
3494 lpfc_els_rcv_farp(phba, elsiocb, ndlp); 3496 lpfc_els_rcv_farp(vport, elsiocb, ndlp);
3495 break; 3497 break;
3496 case ELS_CMD_FAN: 3498 case ELS_CMD_FAN:
3497 phba->fc_stat.elsRcvFAN++; 3499 phba->fc_stat.elsRcvFAN++;
3498 lpfc_els_rcv_fan(phba, elsiocb, ndlp); 3500 lpfc_els_rcv_fan(vport, elsiocb, ndlp);
3499 break; 3501 break;
3500 case ELS_CMD_PRLI: 3502 case ELS_CMD_PRLI:
3501 phba->fc_stat.elsRcvPRLI++; 3503 phba->fc_stat.elsRcvPRLI++;
3502 if (phba->hba_state < LPFC_DISC_AUTH) { 3504 if (vport->port_state < LPFC_DISC_AUTH) {
3503 rjt_err = 1; 3505 rjt_err = 1;
3504 break; 3506 break;
3505 } 3507 }
3506 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI); 3508 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3507 break; 3509 break;
3508 case ELS_CMD_LIRR: 3510 case ELS_CMD_LIRR:
3509 phba->fc_stat.elsRcvLIRR++; 3511 phba->fc_stat.elsRcvLIRR++;
3510 lpfc_els_rcv_lirr(phba, elsiocb, ndlp); 3512 lpfc_els_rcv_lirr(vport, elsiocb, ndlp);
3511 if (newnode) 3513 if (newnode)
3512 lpfc_drop_node(phba, ndlp); 3514 lpfc_drop_node(vport, ndlp);
3513 break; 3515 break;
3514 case ELS_CMD_RPS: 3516 case ELS_CMD_RPS:
3515 phba->fc_stat.elsRcvRPS++; 3517 phba->fc_stat.elsRcvRPS++;
3516 lpfc_els_rcv_rps(phba, elsiocb, ndlp); 3518 lpfc_els_rcv_rps(vport, elsiocb, ndlp);
3517 if (newnode) 3519 if (newnode)
3518 lpfc_drop_node(phba, ndlp); 3520 lpfc_drop_node(vport, ndlp);
3519 break; 3521 break;
3520 case ELS_CMD_RPL: 3522 case ELS_CMD_RPL:
3521 phba->fc_stat.elsRcvRPL++; 3523 phba->fc_stat.elsRcvRPL++;
3522 lpfc_els_rcv_rpl(phba, elsiocb, ndlp); 3524 lpfc_els_rcv_rpl(vport, elsiocb, ndlp);
3523 if (newnode) 3525 if (newnode)
3524 lpfc_drop_node(phba, ndlp); 3526 lpfc_drop_node(vport, ndlp);
3525 break; 3527 break;
3526 case ELS_CMD_RNID: 3528 case ELS_CMD_RNID:
3527 phba->fc_stat.elsRcvRNID++; 3529 phba->fc_stat.elsRcvRNID++;
3528 lpfc_els_rcv_rnid(phba, elsiocb, ndlp); 3530 lpfc_els_rcv_rnid(vport, elsiocb, ndlp);
3529 if (newnode) 3531 if (newnode)
3530 lpfc_drop_node(phba, ndlp); 3532 lpfc_drop_node(vport, ndlp);
3531 break; 3533 break;
3532 default: 3534 default:
3533 /* Unsupported ELS command, reject */ 3535 /* Unsupported ELS command, reject */
@@ -3538,7 +3540,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3538 "%d:0115 Unknown ELS command x%x received from " 3540 "%d:0115 Unknown ELS command x%x received from "
3539 "NPORT x%x\n", phba->brd_no, cmd, did); 3541 "NPORT x%x\n", phba->brd_no, cmd, did);
3540 if (newnode) 3542 if (newnode)
3541 lpfc_drop_node(phba, ndlp); 3543 lpfc_drop_node(vport, ndlp);
3542 break; 3544 break;
3543 } 3545 }
3544 3546
@@ -3548,7 +3550,7 @@ lpfc_els_unsol_event(struct lpfc_hba * phba,
3548 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC; 3550 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3549 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE; 3551 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
3550 stat.un.b.vendorUnique = 0; 3552 stat.un.b.vendorUnique = 0;
3551 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp); 3553 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, elsiocb, ndlp);
3552 } 3554 }
3553 3555
3554 lpfc_nlp_put(elsiocb->context1); 3556 lpfc_nlp_put(elsiocb->context1);
@@ -3567,5 +3569,4 @@ dropit:
3567 icmd->ulpTimeout); 3569 icmd->ulpTimeout);
3568 phba->fc_stat.elsRcvDrop++; 3570 phba->fc_stat.elsRcvDrop++;
3569 } 3571 }
3570 return;
3571} 3572}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-23 19:26:10 -0500