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