1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
4  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
5  */
6 
7 /*
8  * NPORT
9  *
10  * Port object for physical port and NPIV ports.
11  */
12 
13 /*
14  * NPORT REFERENCE COUNTING
15  *
16  * A nport reference should be taken when:
17  * - an nport is allocated
18  * - a vport populates associated nport
19  * - a remote node is allocated
20  * - a unsolicited frame is processed
21  * The reference should be dropped when:
22  * - the unsolicited frame processesing is done
23  * - the remote node is removed
24  * - the vport is removed
25  * - the nport is removed
26  */
27 
28 #include "efc.h"
29 
30 void
31 efc_nport_cb(void *arg, int event, void *data)
32 {
33 	struct efc *efc = arg;
34 	struct efc_nport *nport = data;
35 	unsigned long flags = 0;
36 
37 	efc_log_debug(efc, "nport event: %s\n", efc_sm_event_name(event));
38 
39 	spin_lock_irqsave(&efc->lock, flags);
40 	efc_sm_post_event(&nport->sm, event, NULL);
41 	spin_unlock_irqrestore(&efc->lock, flags);
42 }
43 
44 static struct efc_nport *
45 efc_nport_find_wwn(struct efc_domain *domain, uint64_t wwnn, uint64_t wwpn)
46 {
47 	struct efc_nport *nport = NULL;
48 
49 	/* Find a nport, given the WWNN and WWPN */
50 	list_for_each_entry(nport, &domain->nport_list, list_entry) {
51 		if (nport->wwnn == wwnn && nport->wwpn == wwpn)
52 			return nport;
53 	}
54 	return NULL;
55 }
56 
57 static void
58 _efc_nport_free(struct kref *arg)
59 {
60 	struct efc_nport *nport = container_of(arg, struct efc_nport, ref);
61 
62 	kfree(nport);
63 }
64 
65 struct efc_nport *
66 efc_nport_alloc(struct efc_domain *domain, uint64_t wwpn, uint64_t wwnn,
67 		u32 fc_id, bool enable_ini, bool enable_tgt)
68 {
69 	struct efc_nport *nport;
70 
71 	if (domain->efc->enable_ini)
72 		enable_ini = 0;
73 
74 	/* Return a failure if this nport has already been allocated */
75 	if ((wwpn != 0) || (wwnn != 0)) {
76 		nport = efc_nport_find_wwn(domain, wwnn, wwpn);
77 		if (nport) {
78 			efc_log_err(domain->efc,
79 				    "NPORT %016llX %016llX already allocated\n",
80 				    wwnn, wwpn);
81 			return NULL;
82 		}
83 	}
84 
85 	nport = kzalloc(sizeof(*nport), GFP_ATOMIC);
86 	if (!nport)
87 		return nport;
88 
89 	/* initialize refcount */
90 	kref_init(&nport->ref);
91 	nport->release = _efc_nport_free;
92 
93 	nport->efc = domain->efc;
94 	snprintf(nport->display_name, sizeof(nport->display_name), "------");
95 	nport->domain = domain;
96 	xa_init(&nport->lookup);
97 	nport->instance_index = domain->nport_count++;
98 	nport->sm.app = nport;
99 	nport->enable_ini = enable_ini;
100 	nport->enable_tgt = enable_tgt;
101 	nport->enable_rscn = (nport->enable_ini ||
102 			(nport->enable_tgt && enable_target_rscn(nport->efc)));
103 
104 	/* Copy service parameters from domain */
105 	memcpy(nport->service_params, domain->service_params,
106 	       sizeof(struct fc_els_flogi));
107 
108 	/* Update requested fc_id */
109 	nport->fc_id = fc_id;
110 
111 	/* Update the nport's service parameters for the new wwn's */
112 	nport->wwpn = wwpn;
113 	nport->wwnn = wwnn;
114 	snprintf(nport->wwnn_str, sizeof(nport->wwnn_str), "%016llX",
115 		 (unsigned long long)wwnn);
116 
117 	/*
118 	 * if this is the "first" nport of the domain,
119 	 * then make it the "phys" nport
120 	 */
121 	if (list_empty(&domain->nport_list))
122 		domain->nport = nport;
123 
124 	INIT_LIST_HEAD(&nport->list_entry);
125 	list_add_tail(&nport->list_entry, &domain->nport_list);
126 
127 	kref_get(&domain->ref);
128 
129 	efc_log_debug(domain->efc, "New Nport [%s]\n", nport->display_name);
130 
131 	return nport;
132 }
133 
134 void
135 efc_nport_free(struct efc_nport *nport)
136 {
137 	struct efc_domain *domain;
138 
139 	if (!nport)
140 		return;
141 
142 	domain = nport->domain;
143 	efc_log_debug(domain->efc, "[%s] free nport\n", nport->display_name);
144 	list_del(&nport->list_entry);
145 	/*
146 	 * if this is the physical nport,
147 	 * then clear it out of the domain
148 	 */
149 	if (nport == domain->nport)
150 		domain->nport = NULL;
151 
152 	xa_destroy(&nport->lookup);
153 	xa_erase(&domain->lookup, nport->fc_id);
154 
155 	if (list_empty(&domain->nport_list))
156 		efc_domain_post_event(domain, EFC_EVT_ALL_CHILD_NODES_FREE,
157 				      NULL);
158 
159 	kref_put(&domain->ref, domain->release);
160 	kref_put(&nport->ref, nport->release);
161 }
162 
163 struct efc_nport *
164 efc_nport_find(struct efc_domain *domain, u32 d_id)
165 {
166 	struct efc_nport *nport;
167 
168 	/* Find a nport object, given an FC_ID */
169 	nport = xa_load(&domain->lookup, d_id);
170 	if (!nport || !kref_get_unless_zero(&nport->ref))
171 		return NULL;
172 
173 	return nport;
174 }
175 
176 int
177 efc_nport_attach(struct efc_nport *nport, u32 fc_id)
178 {
179 	int rc;
180 	struct efc_node *node;
181 	struct efc *efc = nport->efc;
182 	unsigned long index;
183 
184 	/* Set our lookup */
185 	rc = xa_err(xa_store(&nport->domain->lookup, fc_id, nport, GFP_ATOMIC));
186 	if (rc) {
187 		efc_log_err(efc, "Sport lookup store failed: %d\n", rc);
188 		return rc;
189 	}
190 
191 	/* Update our display_name */
192 	efc_node_fcid_display(fc_id, nport->display_name,
193 			      sizeof(nport->display_name));
194 
195 	xa_for_each(&nport->lookup, index, node) {
196 		efc_node_update_display_name(node);
197 	}
198 
199 	efc_log_debug(nport->efc, "[%s] attach nport: fc_id x%06x\n",
200 		      nport->display_name, fc_id);
201 
202 	/* Register a nport, given an FC_ID */
203 	rc = efc_cmd_nport_attach(efc, nport, fc_id);
204 	if (rc < 0) {
205 		efc_log_err(nport->efc,
206 			    "efc_hw_port_attach failed: %d\n", rc);
207 		return -EIO;
208 	}
209 	return 0;
210 }
211 
212 static void
213 efc_nport_shutdown(struct efc_nport *nport)
214 {
215 	struct efc *efc = nport->efc;
216 	struct efc_node *node;
217 	unsigned long index;
218 
219 	xa_for_each(&nport->lookup, index, node) {
220 		if (!(node->rnode.fc_id == FC_FID_FLOGI && nport->is_vport)) {
221 			efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
222 			continue;
223 		}
224 
225 		/*
226 		 * If this is a vport, logout of the fabric
227 		 * controller so that it deletes the vport
228 		 * on the switch.
229 		 */
230 		/* if link is down, don't send logo */
231 		if (efc->link_status == EFC_LINK_STATUS_DOWN) {
232 			efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
233 			continue;
234 		}
235 
236 		efc_log_debug(efc, "[%s] nport shutdown vport, send logo\n",
237 			      node->display_name);
238 
239 		if (!efc_send_logo(node)) {
240 			/* sent LOGO, wait for response */
241 			efc_node_transition(node, __efc_d_wait_logo_rsp, NULL);
242 			continue;
243 		}
244 
245 		/*
246 		 * failed to send LOGO,
247 		 * go ahead and cleanup node anyways
248 		 */
249 		node_printf(node, "Failed to send LOGO\n");
250 		efc_node_post_event(node, EFC_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
251 	}
252 }
253 
254 static void
255 efc_vport_link_down(struct efc_nport *nport)
256 {
257 	struct efc *efc = nport->efc;
258 	struct efc_vport *vport;
259 
260 	/* Clear the nport reference in the vport specification */
261 	list_for_each_entry(vport, &efc->vport_list, list_entry) {
262 		if (vport->nport == nport) {
263 			kref_put(&nport->ref, nport->release);
264 			vport->nport = NULL;
265 			break;
266 		}
267 	}
268 }
269 
270 static void
271 __efc_nport_common(const char *funcname, struct efc_sm_ctx *ctx,
272 		   enum efc_sm_event evt, void *arg)
273 {
274 	struct efc_nport *nport = ctx->app;
275 	struct efc_domain *domain = nport->domain;
276 	struct efc *efc = nport->efc;
277 
278 	switch (evt) {
279 	case EFC_EVT_ENTER:
280 	case EFC_EVT_REENTER:
281 	case EFC_EVT_EXIT:
282 	case EFC_EVT_ALL_CHILD_NODES_FREE:
283 		break;
284 	case EFC_EVT_NPORT_ATTACH_OK:
285 			efc_sm_transition(ctx, __efc_nport_attached, NULL);
286 		break;
287 	case EFC_EVT_SHUTDOWN:
288 		/* Flag this nport as shutting down */
289 		nport->shutting_down = true;
290 
291 		if (nport->is_vport)
292 			efc_vport_link_down(nport);
293 
294 		if (xa_empty(&nport->lookup)) {
295 			/* Remove the nport from the domain's lookup table */
296 			xa_erase(&domain->lookup, nport->fc_id);
297 			efc_sm_transition(ctx, __efc_nport_wait_port_free,
298 					  NULL);
299 			if (efc_cmd_nport_free(efc, nport)) {
300 				efc_log_debug(nport->efc,
301 					      "efc_hw_port_free failed\n");
302 				/* Not much we can do, free the nport anyways */
303 				efc_nport_free(nport);
304 			}
305 		} else {
306 			/* sm: node list is not empty / shutdown nodes */
307 			efc_sm_transition(ctx,
308 					  __efc_nport_wait_shutdown, NULL);
309 			efc_nport_shutdown(nport);
310 		}
311 		break;
312 	default:
313 		efc_log_debug(nport->efc, "[%s] %-20s %-20s not handled\n",
314 			      nport->display_name, funcname,
315 			      efc_sm_event_name(evt));
316 	}
317 }
318 
319 void
320 __efc_nport_allocated(struct efc_sm_ctx *ctx,
321 		      enum efc_sm_event evt, void *arg)
322 {
323 	struct efc_nport *nport = ctx->app;
324 	struct efc_domain *domain = nport->domain;
325 
326 	nport_sm_trace(nport);
327 
328 	switch (evt) {
329 	/* the physical nport is attached */
330 	case EFC_EVT_NPORT_ATTACH_OK:
331 		WARN_ON(nport != domain->nport);
332 		efc_sm_transition(ctx, __efc_nport_attached, NULL);
333 		break;
334 
335 	case EFC_EVT_NPORT_ALLOC_OK:
336 		/* ignore */
337 		break;
338 	default:
339 		__efc_nport_common(__func__, ctx, evt, arg);
340 	}
341 }
342 
343 void
344 __efc_nport_vport_init(struct efc_sm_ctx *ctx,
345 		       enum efc_sm_event evt, void *arg)
346 {
347 	struct efc_nport *nport = ctx->app;
348 	struct efc *efc = nport->efc;
349 
350 	nport_sm_trace(nport);
351 
352 	switch (evt) {
353 	case EFC_EVT_ENTER: {
354 		__be64 be_wwpn = cpu_to_be64(nport->wwpn);
355 
356 		if (nport->wwpn == 0)
357 			efc_log_debug(efc, "vport: letting f/w select WWN\n");
358 
359 		if (nport->fc_id != U32_MAX) {
360 			efc_log_debug(efc, "vport: hard coding port id: %x\n",
361 				      nport->fc_id);
362 		}
363 
364 		efc_sm_transition(ctx, __efc_nport_vport_wait_alloc, NULL);
365 		/* If wwpn is zero, then we'll let the f/w assign wwpn*/
366 		if (efc_cmd_nport_alloc(efc, nport, nport->domain,
367 					nport->wwpn == 0 ? NULL :
368 					(uint8_t *)&be_wwpn)) {
369 			efc_log_err(efc, "Can't allocate port\n");
370 			break;
371 		}
372 
373 		break;
374 	}
375 	default:
376 		__efc_nport_common(__func__, ctx, evt, arg);
377 	}
378 }
379 
380 void
381 __efc_nport_vport_wait_alloc(struct efc_sm_ctx *ctx,
382 			     enum efc_sm_event evt, void *arg)
383 {
384 	struct efc_nport *nport = ctx->app;
385 	struct efc *efc = nport->efc;
386 
387 	nport_sm_trace(nport);
388 
389 	switch (evt) {
390 	case EFC_EVT_NPORT_ALLOC_OK: {
391 		struct fc_els_flogi *sp;
392 
393 		sp = (struct fc_els_flogi *)nport->service_params;
394 
395 		if (nport->wwnn == 0) {
396 			nport->wwnn = be64_to_cpu(nport->sli_wwnn);
397 			nport->wwpn = be64_to_cpu(nport->sli_wwpn);
398 			snprintf(nport->wwnn_str, sizeof(nport->wwnn_str),
399 				 "%016llX", nport->wwpn);
400 		}
401 
402 		/* Update the nport's service parameters */
403 		sp->fl_wwpn = cpu_to_be64(nport->wwpn);
404 		sp->fl_wwnn = cpu_to_be64(nport->wwnn);
405 
406 		/*
407 		 * if nport->fc_id is uninitialized,
408 		 * then request that the fabric node use FDISC
409 		 * to find an fc_id.
410 		 * Otherwise we're restoring vports, or we're in
411 		 * fabric emulation mode, so attach the fc_id
412 		 */
413 		if (nport->fc_id == U32_MAX) {
414 			struct efc_node *fabric;
415 
416 			fabric = efc_node_alloc(nport, FC_FID_FLOGI, false,
417 						false);
418 			if (!fabric) {
419 				efc_log_err(efc, "efc_node_alloc() failed\n");
420 				return;
421 			}
422 			efc_node_transition(fabric, __efc_vport_fabric_init,
423 					    NULL);
424 		} else {
425 			snprintf(nport->wwnn_str, sizeof(nport->wwnn_str),
426 				 "%016llX", nport->wwpn);
427 			efc_nport_attach(nport, nport->fc_id);
428 		}
429 		efc_sm_transition(ctx, __efc_nport_vport_allocated, NULL);
430 		break;
431 	}
432 	default:
433 		__efc_nport_common(__func__, ctx, evt, arg);
434 	}
435 }
436 
437 void
438 __efc_nport_vport_allocated(struct efc_sm_ctx *ctx,
439 			    enum efc_sm_event evt, void *arg)
440 {
441 	struct efc_nport *nport = ctx->app;
442 	struct efc *efc = nport->efc;
443 
444 	nport_sm_trace(nport);
445 
446 	/*
447 	 * This state is entered after the nport is allocated;
448 	 * it then waits for a fabric node
449 	 * FDISC to complete, which requests a nport attach.
450 	 * The nport attach complete is handled in this state.
451 	 */
452 	switch (evt) {
453 	case EFC_EVT_NPORT_ATTACH_OK: {
454 		struct efc_node *node;
455 
456 		/* Find our fabric node, and forward this event */
457 		node = efc_node_find(nport, FC_FID_FLOGI);
458 		if (!node) {
459 			efc_log_debug(efc, "can't find node %06x\n", FC_FID_FLOGI);
460 			break;
461 		}
462 		/* sm: / forward nport attach to fabric node */
463 		efc_node_post_event(node, evt, NULL);
464 		efc_sm_transition(ctx, __efc_nport_attached, NULL);
465 		break;
466 	}
467 	default:
468 		__efc_nport_common(__func__, ctx, evt, arg);
469 	}
470 }
471 
472 static void
473 efc_vport_update_spec(struct efc_nport *nport)
474 {
475 	struct efc *efc = nport->efc;
476 	struct efc_vport *vport;
477 	unsigned long flags = 0;
478 
479 	spin_lock_irqsave(&efc->vport_lock, flags);
480 	list_for_each_entry(vport, &efc->vport_list, list_entry) {
481 		if (vport->nport == nport) {
482 			vport->wwnn = nport->wwnn;
483 			vport->wwpn = nport->wwpn;
484 			vport->tgt_data = nport->tgt_data;
485 			vport->ini_data = nport->ini_data;
486 			break;
487 		}
488 	}
489 	spin_unlock_irqrestore(&efc->vport_lock, flags);
490 }
491 
492 void
493 __efc_nport_attached(struct efc_sm_ctx *ctx,
494 		     enum efc_sm_event evt, void *arg)
495 {
496 	struct efc_nport *nport = ctx->app;
497 	struct efc *efc = nport->efc;
498 
499 	nport_sm_trace(nport);
500 
501 	switch (evt) {
502 	case EFC_EVT_ENTER: {
503 		struct efc_node *node;
504 		unsigned long index;
505 
506 		efc_log_debug(efc,
507 			      "[%s] NPORT attached WWPN %016llX WWNN %016llX\n",
508 			      nport->display_name,
509 			      nport->wwpn, nport->wwnn);
510 
511 		xa_for_each(&nport->lookup, index, node)
512 			efc_node_update_display_name(node);
513 
514 		efc->tt.new_nport(efc, nport);
515 
516 		/*
517 		 * Update the vport (if its not the physical nport)
518 		 * parameters
519 		 */
520 		if (nport->is_vport)
521 			efc_vport_update_spec(nport);
522 		break;
523 	}
524 
525 	case EFC_EVT_EXIT:
526 		efc_log_debug(efc,
527 			      "[%s] NPORT deattached WWPN %016llX WWNN %016llX\n",
528 			      nport->display_name,
529 			      nport->wwpn, nport->wwnn);
530 
531 		efc->tt.del_nport(efc, nport);
532 		break;
533 	default:
534 		__efc_nport_common(__func__, ctx, evt, arg);
535 	}
536 }
537 
538 void
539 __efc_nport_wait_shutdown(struct efc_sm_ctx *ctx,
540 			  enum efc_sm_event evt, void *arg)
541 {
542 	struct efc_nport *nport = ctx->app;
543 	struct efc_domain *domain = nport->domain;
544 	struct efc *efc = nport->efc;
545 
546 	nport_sm_trace(nport);
547 
548 	switch (evt) {
549 	case EFC_EVT_NPORT_ALLOC_OK:
550 	case EFC_EVT_NPORT_ALLOC_FAIL:
551 	case EFC_EVT_NPORT_ATTACH_OK:
552 	case EFC_EVT_NPORT_ATTACH_FAIL:
553 		/* ignore these events - just wait for the all free event */
554 		break;
555 
556 	case EFC_EVT_ALL_CHILD_NODES_FREE: {
557 		/*
558 		 * Remove the nport from the domain's
559 		 * sparse vector lookup table
560 		 */
561 		xa_erase(&domain->lookup, nport->fc_id);
562 		efc_sm_transition(ctx, __efc_nport_wait_port_free, NULL);
563 		if (efc_cmd_nport_free(efc, nport)) {
564 			efc_log_err(nport->efc, "efc_hw_port_free failed\n");
565 			/* Not much we can do, free the nport anyways */
566 			efc_nport_free(nport);
567 		}
568 		break;
569 	}
570 	default:
571 		__efc_nport_common(__func__, ctx, evt, arg);
572 	}
573 }
574 
575 void
576 __efc_nport_wait_port_free(struct efc_sm_ctx *ctx,
577 			   enum efc_sm_event evt, void *arg)
578 {
579 	struct efc_nport *nport = ctx->app;
580 
581 	nport_sm_trace(nport);
582 
583 	switch (evt) {
584 	case EFC_EVT_NPORT_ATTACH_OK:
585 		/* Ignore as we are waiting for the free CB */
586 		break;
587 	case EFC_EVT_NPORT_FREE_OK: {
588 		/* All done, free myself */
589 		efc_nport_free(nport);
590 		break;
591 	}
592 	default:
593 		__efc_nport_common(__func__, ctx, evt, arg);
594 	}
595 }
596 
597 static int
598 efc_vport_nport_alloc(struct efc_domain *domain, struct efc_vport *vport)
599 {
600 	struct efc_nport *nport;
601 
602 	lockdep_assert_held(&domain->efc->lock);
603 
604 	nport = efc_nport_alloc(domain, vport->wwpn, vport->wwnn, vport->fc_id,
605 				vport->enable_ini, vport->enable_tgt);
606 	vport->nport = nport;
607 	if (!nport)
608 		return -EIO;
609 
610 	kref_get(&nport->ref);
611 	nport->is_vport = true;
612 	nport->tgt_data = vport->tgt_data;
613 	nport->ini_data = vport->ini_data;
614 
615 	efc_sm_transition(&nport->sm, __efc_nport_vport_init, NULL);
616 
617 	return 0;
618 }
619 
620 int
621 efc_vport_start(struct efc_domain *domain)
622 {
623 	struct efc *efc = domain->efc;
624 	struct efc_vport *vport;
625 	struct efc_vport *next;
626 	int rc = 0;
627 	unsigned long flags = 0;
628 
629 	/* Use the vport spec to find the associated vports and start them */
630 	spin_lock_irqsave(&efc->vport_lock, flags);
631 	list_for_each_entry_safe(vport, next, &efc->vport_list, list_entry) {
632 		if (!vport->nport) {
633 			if (efc_vport_nport_alloc(domain, vport))
634 				rc = -EIO;
635 		}
636 	}
637 	spin_unlock_irqrestore(&efc->vport_lock, flags);
638 
639 	return rc;
640 }
641 
642 int
643 efc_nport_vport_new(struct efc_domain *domain, uint64_t wwpn, uint64_t wwnn,
644 		    u32 fc_id, bool ini, bool tgt, void *tgt_data,
645 		    void *ini_data)
646 {
647 	struct efc *efc = domain->efc;
648 	struct efc_vport *vport;
649 	int rc = 0;
650 	unsigned long flags = 0;
651 
652 	if (ini && domain->efc->enable_ini == 0) {
653 		efc_log_debug(efc, "driver initiator mode not enabled\n");
654 		return -EIO;
655 	}
656 
657 	if (tgt && domain->efc->enable_tgt == 0) {
658 		efc_log_debug(efc, "driver target mode not enabled\n");
659 		return -EIO;
660 	}
661 
662 	/*
663 	 * Create a vport spec if we need to recreate
664 	 * this vport after a link up event
665 	 */
666 	vport = efc_vport_create_spec(domain->efc, wwnn, wwpn, fc_id, ini, tgt,
667 				      tgt_data, ini_data);
668 	if (!vport) {
669 		efc_log_err(efc, "failed to create vport object entry\n");
670 		return -EIO;
671 	}
672 
673 	spin_lock_irqsave(&efc->lock, flags);
674 	rc = efc_vport_nport_alloc(domain, vport);
675 	spin_unlock_irqrestore(&efc->lock, flags);
676 
677 	return rc;
678 }
679 
680 int
681 efc_nport_vport_del(struct efc *efc, struct efc_domain *domain,
682 		    u64 wwpn, uint64_t wwnn)
683 {
684 	struct efc_nport *nport;
685 	struct efc_vport *vport;
686 	struct efc_vport *next;
687 	unsigned long flags = 0;
688 
689 	spin_lock_irqsave(&efc->vport_lock, flags);
690 	/* walk the efc_vport_list and remove from there */
691 	list_for_each_entry_safe(vport, next, &efc->vport_list, list_entry) {
692 		if (vport->wwpn == wwpn && vport->wwnn == wwnn) {
693 			list_del(&vport->list_entry);
694 			kfree(vport);
695 			break;
696 		}
697 	}
698 	spin_unlock_irqrestore(&efc->vport_lock, flags);
699 
700 	if (!domain) {
701 		/* No domain means no nport to look for */
702 		return 0;
703 	}
704 
705 	spin_lock_irqsave(&efc->lock, flags);
706 	list_for_each_entry(nport, &domain->nport_list, list_entry) {
707 		if (nport->wwpn == wwpn && nport->wwnn == wwnn) {
708 			kref_put(&nport->ref, nport->release);
709 			/* Shutdown this NPORT */
710 			efc_sm_post_event(&nport->sm, EFC_EVT_SHUTDOWN, NULL);
711 			break;
712 		}
713 	}
714 
715 	spin_unlock_irqrestore(&efc->lock, flags);
716 	return 0;
717 }
718 
719 void
720 efc_vport_del_all(struct efc *efc)
721 {
722 	struct efc_vport *vport;
723 	struct efc_vport *next;
724 	unsigned long flags = 0;
725 
726 	spin_lock_irqsave(&efc->vport_lock, flags);
727 	list_for_each_entry_safe(vport, next, &efc->vport_list, list_entry) {
728 		list_del(&vport->list_entry);
729 		kfree(vport);
730 	}
731 	spin_unlock_irqrestore(&efc->vport_lock, flags);
732 }
733 
734 struct efc_vport *
735 efc_vport_create_spec(struct efc *efc, uint64_t wwnn, uint64_t wwpn,
736 		      u32 fc_id, bool enable_ini,
737 		      bool enable_tgt, void *tgt_data, void *ini_data)
738 {
739 	struct efc_vport *vport;
740 	unsigned long flags = 0;
741 
742 	/*
743 	 * walk the efc_vport_list and return failure
744 	 * if a valid(vport with non zero WWPN and WWNN) vport entry
745 	 * is already created
746 	 */
747 	spin_lock_irqsave(&efc->vport_lock, flags);
748 	list_for_each_entry(vport, &efc->vport_list, list_entry) {
749 		if ((wwpn && vport->wwpn == wwpn) &&
750 		    (wwnn && vport->wwnn == wwnn)) {
751 			efc_log_err(efc,
752 				    "VPORT %016llX %016llX already allocated\n",
753 				    wwnn, wwpn);
754 			spin_unlock_irqrestore(&efc->vport_lock, flags);
755 			return NULL;
756 		}
757 	}
758 
759 	vport = kzalloc(sizeof(*vport), GFP_ATOMIC);
760 	if (!vport) {
761 		spin_unlock_irqrestore(&efc->vport_lock, flags);
762 		return NULL;
763 	}
764 
765 	vport->wwnn = wwnn;
766 	vport->wwpn = wwpn;
767 	vport->fc_id = fc_id;
768 	vport->enable_tgt = enable_tgt;
769 	vport->enable_ini = enable_ini;
770 	vport->tgt_data = tgt_data;
771 	vport->ini_data = ini_data;
772 
773 	INIT_LIST_HEAD(&vport->list_entry);
774 	list_add_tail(&vport->list_entry, &efc->vport_list);
775 	spin_unlock_irqrestore(&efc->vport_lock, flags);
776 	return vport;
777 }
778