blob: 07a28700cbe732807aedda97d5940b339726d597 [file] [log] [blame]
James Smart92d7f7b2007-06-17 19:56:38 -05001/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2006 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/delay.h>
24#include <linux/dma-mapping.h>
25#include <linux/idr.h>
26#include <linux/interrupt.h>
27#include <linux/kthread.h>
28#include <linux/pci.h>
29#include <linux/spinlock.h>
30
31#include <scsi/scsi.h>
32#include <scsi/scsi_device.h>
33#include <scsi/scsi_host.h>
34#include <scsi/scsi_transport_fc.h>
35#include "lpfc_hw.h"
36#include "lpfc_sli.h"
37#include "lpfc_disc.h"
38#include "lpfc_scsi.h"
39#include "lpfc.h"
40#include "lpfc_logmsg.h"
41#include "lpfc_crtn.h"
42#include "lpfc_version.h"
43#include "lpfc_vport.h"
44
45inline void lpfc_vport_set_state(struct lpfc_vport *vport,
46 enum fc_vport_state new_state)
47{
48 struct fc_vport *fc_vport = vport->fc_vport;
49
50 if (fc_vport) {
51 /*
52 * When the transport defines fc_vport_set state we will replace
53 * this code with the following line
54 */
55 /* fc_vport_set_state(fc_vport, new_state); */
56 if (new_state != FC_VPORT_INITIALIZING)
57 fc_vport->vport_last_state = fc_vport->vport_state;
58 fc_vport->vport_state = new_state;
59 }
60
61 /* for all the error states we will set the invternal state to FAILED */
62 switch (new_state) {
63 case FC_VPORT_NO_FABRIC_SUPP:
64 case FC_VPORT_NO_FABRIC_RSCS:
65 case FC_VPORT_FABRIC_LOGOUT:
66 case FC_VPORT_FABRIC_REJ_WWN:
67 case FC_VPORT_FAILED:
68 vport->port_state = LPFC_VPORT_FAILED;
69 break;
70 case FC_VPORT_LINKDOWN:
71 vport->port_state = LPFC_VPORT_UNKNOWN;
72 break;
73 default:
74 /* do nothing */
75 break;
76 }
77}
78
79static int
80lpfc_alloc_vpi(struct lpfc_hba *phba)
81{
82 int vpi;
83
84 spin_lock_irq(&phba->hbalock);
James Smart858c9f62007-06-17 19:56:39 -050085 /* Start at bit 1 because vpi zero is reserved for the physical port */
86 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1);
James Smart92d7f7b2007-06-17 19:56:38 -050087 if (vpi > phba->max_vpi)
88 vpi = 0;
89 else
90 set_bit(vpi, phba->vpi_bmask);
91 spin_unlock_irq(&phba->hbalock);
92 return vpi;
93}
94
95static void
96lpfc_free_vpi(struct lpfc_hba *phba, int vpi)
97{
98 spin_lock_irq(&phba->hbalock);
99 clear_bit(vpi, phba->vpi_bmask);
100 spin_unlock_irq(&phba->hbalock);
101}
102
103static int
104lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport)
105{
106 LPFC_MBOXQ_t *pmb;
107 MAILBOX_t *mb;
108 struct lpfc_dmabuf *mp;
109 int rc;
110
111 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
112 if (!pmb) {
113 return -ENOMEM;
114 }
115 mb = &pmb->mb;
116
117 lpfc_read_sparam(phba, pmb, vport->vpi);
118 /*
119 * Grab buffer pointer and clear context1 so we can use
120 * lpfc_sli_issue_box_wait
121 */
122 mp = (struct lpfc_dmabuf *) pmb->context1;
123 pmb->context1 = NULL;
124
125 pmb->vport = vport;
126 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);
127 if (rc != MBX_SUCCESS) {
James Smart98c9ea52007-10-27 13:37:33 -0400128 if (signal_pending(current)) {
129 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
130 "1830 Signal aborted mbxCmd x%x\n",
131 mb->mbxCommand);
132 lpfc_mbuf_free(phba, mp->virt, mp->phys);
133 kfree(mp);
134 if (rc != MBX_TIMEOUT)
135 mempool_free(pmb, phba->mbox_mem_pool);
136 return -EINTR;
137 } else {
138 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
139 "1818 VPort failed init, mbxCmd x%x "
140 "READ_SPARM mbxStatus x%x, rc = x%x\n",
141 mb->mbxCommand, mb->mbxStatus, rc);
142 lpfc_mbuf_free(phba, mp->virt, mp->phys);
143 kfree(mp);
144 if (rc != MBX_TIMEOUT)
145 mempool_free(pmb, phba->mbox_mem_pool);
146 return -EIO;
147 }
James Smart92d7f7b2007-06-17 19:56:38 -0500148 }
149
150 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
151 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
152 sizeof (struct lpfc_name));
153 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
154 sizeof (struct lpfc_name));
155
156 lpfc_mbuf_free(phba, mp->virt, mp->phys);
157 kfree(mp);
158 mempool_free(pmb, phba->mbox_mem_pool);
159
160 return 0;
161}
162
163static int
164lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn,
165 const char *name_type)
166{
167 /* ensure that IEEE format 1 addresses
168 * contain zeros in bits 59-48
169 */
170 if (!((wwn->u.wwn[0] >> 4) == 1 &&
171 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0)))
172 return 1;
173
174 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400175 "1822 Invalid %s: %02x:%02x:%02x:%02x:"
James Smart92d7f7b2007-06-17 19:56:38 -0500176 "%02x:%02x:%02x:%02x\n",
James Smarte8b62012007-08-02 11:10:09 -0400177 name_type,
James Smart92d7f7b2007-06-17 19:56:38 -0500178 wwn->u.wwn[0], wwn->u.wwn[1],
179 wwn->u.wwn[2], wwn->u.wwn[3],
180 wwn->u.wwn[4], wwn->u.wwn[5],
181 wwn->u.wwn[6], wwn->u.wwn[7]);
182 return 0;
183}
184
185static int
186lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport)
187{
188 struct lpfc_vport *vport;
James Smart549e55c2007-08-02 11:09:51 -0400189 unsigned long flags;
James Smart92d7f7b2007-06-17 19:56:38 -0500190
James Smart549e55c2007-08-02 11:09:51 -0400191 spin_lock_irqsave(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500192 list_for_each_entry(vport, &phba->port_list, listentry) {
193 if (vport == new_vport)
194 continue;
195 /* If they match, return not unique */
196 if (memcmp(&vport->fc_sparam.portName,
James Smart549e55c2007-08-02 11:09:51 -0400197 &new_vport->fc_sparam.portName,
198 sizeof(struct lpfc_name)) == 0) {
199 spin_unlock_irqrestore(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500200 return 0;
James Smart549e55c2007-08-02 11:09:51 -0400201 }
James Smart92d7f7b2007-06-17 19:56:38 -0500202 }
James Smart549e55c2007-08-02 11:09:51 -0400203 spin_unlock_irqrestore(&phba->hbalock, flags);
James Smart92d7f7b2007-06-17 19:56:38 -0500204 return 1;
205}
206
207int
208lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
209{
210 struct lpfc_nodelist *ndlp;
James Smart3de2a652007-08-02 11:09:59 -0400211 struct Scsi_Host *shost = fc_vport->shost;
212 struct lpfc_vport *pport = (struct lpfc_vport *) shost->hostdata;
James Smart92d7f7b2007-06-17 19:56:38 -0500213 struct lpfc_hba *phba = pport->phba;
214 struct lpfc_vport *vport = NULL;
215 int instance;
216 int vpi;
217 int rc = VPORT_ERROR;
James Smart98c9ea52007-10-27 13:37:33 -0400218 int status;
James Smart92d7f7b2007-06-17 19:56:38 -0500219
220 if ((phba->sli_rev < 3) ||
221 !(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
222 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400223 "1808 Create VPORT failed: "
James Smart92d7f7b2007-06-17 19:56:38 -0500224 "NPIV is not enabled: SLImode:%d\n",
James Smarte8b62012007-08-02 11:10:09 -0400225 phba->sli_rev);
James Smart92d7f7b2007-06-17 19:56:38 -0500226 rc = VPORT_INVAL;
227 goto error_out;
228 }
229
230 vpi = lpfc_alloc_vpi(phba);
231 if (vpi == 0) {
232 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400233 "1809 Create VPORT failed: "
James Smart92d7f7b2007-06-17 19:56:38 -0500234 "Max VPORTs (%d) exceeded\n",
James Smarte8b62012007-08-02 11:10:09 -0400235 phba->max_vpi);
James Smart92d7f7b2007-06-17 19:56:38 -0500236 rc = VPORT_NORESOURCES;
237 goto error_out;
238 }
239
240
241 /* Assign an unused board number */
242 if ((instance = lpfc_get_instance()) < 0) {
243 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400244 "1810 Create VPORT failed: Cannot get "
245 "instance number\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500246 lpfc_free_vpi(phba, vpi);
247 rc = VPORT_NORESOURCES;
248 goto error_out;
249 }
250
James Smart3de2a652007-08-02 11:09:59 -0400251 vport = lpfc_create_port(phba, instance, &fc_vport->dev);
James Smart92d7f7b2007-06-17 19:56:38 -0500252 if (!vport) {
253 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400254 "1811 Create VPORT failed: vpi x%x\n", vpi);
James Smart92d7f7b2007-06-17 19:56:38 -0500255 lpfc_free_vpi(phba, vpi);
256 rc = VPORT_NORESOURCES;
257 goto error_out;
258 }
259
260 vport->vpi = vpi;
James Smart858c9f62007-06-17 19:56:39 -0500261 lpfc_debugfs_initialize(vport);
262
James Smart98c9ea52007-10-27 13:37:33 -0400263 if ((status = lpfc_vport_sparm(phba, vport))) {
264 if (status == -EINTR) {
265 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
266 "1831 Create VPORT Interrupted.\n");
267 rc = VPORT_ERROR;
268 } else {
269 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
270 "1813 Create VPORT failed. "
271 "Cannot get sparam\n");
272 rc = VPORT_NORESOURCES;
273 }
James Smart92d7f7b2007-06-17 19:56:38 -0500274 lpfc_free_vpi(phba, vpi);
275 destroy_port(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500276 goto error_out;
277 }
278
279 memcpy(vport->fc_portname.u.wwn, vport->fc_sparam.portName.u.wwn, 8);
280 memcpy(vport->fc_nodename.u.wwn, vport->fc_sparam.nodeName.u.wwn, 8);
281
282 if (fc_vport->node_name != 0)
283 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
284 if (fc_vport->port_name != 0)
285 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
286
287 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
288 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
289
290 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
291 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
James Smarte8b62012007-08-02 11:10:09 -0400292 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
293 "1821 Create VPORT failed. "
294 "Invalid WWN format\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500295 lpfc_free_vpi(phba, vpi);
296 destroy_port(vport);
297 rc = VPORT_INVAL;
298 goto error_out;
299 }
300
301 if (!lpfc_unique_wwpn(phba, vport)) {
James Smarte8b62012007-08-02 11:10:09 -0400302 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
303 "1823 Create VPORT failed. "
304 "Duplicate WWN on HBA\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500305 lpfc_free_vpi(phba, vpi);
306 destroy_port(vport);
307 rc = VPORT_INVAL;
308 goto error_out;
309 }
310
311 *(struct lpfc_vport **)fc_vport->dd_data = vport;
312 vport->fc_vport = fc_vport;
313
314 if ((phba->link_state < LPFC_LINK_UP) ||
315 (phba->fc_topology == TOPOLOGY_LOOP)) {
316 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
317 rc = VPORT_OK;
318 goto out;
319 }
320
321 if (disable) {
322 rc = VPORT_OK;
323 goto out;
324 }
325
326 /* Use the Physical nodes Fabric NDLP to determine if the link is
327 * up and ready to FDISC.
328 */
329 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
330 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
James Smart858c9f62007-06-17 19:56:39 -0500331 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
332 lpfc_set_disctmo(vport);
333 lpfc_initial_fdisc(vport);
334 } else {
335 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
James Smarte8b62012007-08-02 11:10:09 -0400336 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
337 "0262 No NPIV Fabric support\n");
James Smart858c9f62007-06-17 19:56:39 -0500338 }
James Smart92d7f7b2007-06-17 19:56:38 -0500339 } else {
340 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
341 }
342 rc = VPORT_OK;
343
344out:
James Smarta58cbd52007-08-02 11:09:43 -0400345 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
346 "1825 Vport Created.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500347 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
348error_out:
349 return rc;
350}
351
James Smart311464e2007-08-02 11:10:37 -0400352static int
James Smart92d7f7b2007-06-17 19:56:38 -0500353disable_vport(struct fc_vport *fc_vport)
354{
355 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
356 struct lpfc_hba *phba = vport->phba;
357 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
358 long timeout;
359
360 ndlp = lpfc_findnode_did(vport, Fabric_DID);
361 if (ndlp && phba->link_state >= LPFC_LINK_UP) {
362 vport->unreg_vpi_cmpl = VPORT_INVAL;
363 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
364 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
365 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
366 timeout = schedule_timeout(timeout);
367 }
368
369 lpfc_sli_host_down(vport);
370
371 /* Mark all nodes for discovery so we can remove them by
372 * calling lpfc_cleanup_rpis(vport, 1)
373 */
374 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
375 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
376 continue;
377 lpfc_disc_state_machine(vport, ndlp, NULL,
378 NLP_EVT_DEVICE_RECOVERY);
379 }
380 lpfc_cleanup_rpis(vport, 1);
381
382 lpfc_stop_vport_timers(vport);
383 lpfc_unreg_all_rpis(vport);
384 lpfc_unreg_default_rpis(vport);
385 /*
386 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
387 * scsi_host_put() to release the vport.
388 */
389 lpfc_mbx_unreg_vpi(vport);
390
391 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
James Smarta58cbd52007-08-02 11:09:43 -0400392 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
393 "1826 Vport Disabled.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500394 return VPORT_OK;
395}
396
James Smart311464e2007-08-02 11:10:37 -0400397static int
James Smart92d7f7b2007-06-17 19:56:38 -0500398enable_vport(struct fc_vport *fc_vport)
399{
400 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
401 struct lpfc_hba *phba = vport->phba;
402 struct lpfc_nodelist *ndlp = NULL;
403
404 if ((phba->link_state < LPFC_LINK_UP) ||
405 (phba->fc_topology == TOPOLOGY_LOOP)) {
406 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
407 return VPORT_OK;
408 }
409
410 vport->load_flag |= FC_LOADING;
411 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
412
413 /* Use the Physical nodes Fabric NDLP to determine if the link is
414 * up and ready to FDISC.
415 */
416 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
417 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
James Smart858c9f62007-06-17 19:56:39 -0500418 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
419 lpfc_set_disctmo(vport);
420 lpfc_initial_fdisc(vport);
421 } else {
422 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
James Smarte8b62012007-08-02 11:10:09 -0400423 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
424 "0264 No NPIV Fabric support\n");
James Smart858c9f62007-06-17 19:56:39 -0500425 }
James Smart92d7f7b2007-06-17 19:56:38 -0500426 } else {
427 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
428 }
James Smarta58cbd52007-08-02 11:09:43 -0400429 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
430 "1827 Vport Enabled.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500431 return VPORT_OK;
432}
433
434int
435lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
436{
437 if (disable)
438 return disable_vport(fc_vport);
439 else
440 return enable_vport(fc_vport);
441}
442
443
444int
445lpfc_vport_delete(struct fc_vport *fc_vport)
446{
447 struct lpfc_nodelist *ndlp = NULL;
James Smart92d7f7b2007-06-17 19:56:38 -0500448 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost;
449 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
450 struct lpfc_hba *phba = vport->phba;
451 long timeout;
James Smart92d7f7b2007-06-17 19:56:38 -0500452
James Smart51ef4c22007-08-02 11:10:31 -0400453 if (vport->port_type == LPFC_PHYSICAL_PORT) {
454 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
455 "1812 vport_delete failed: Cannot delete "
456 "physical host\n");
457 return VPORT_ERROR;
458 }
459 /*
460 * If we are not unloading the driver then prevent the vport_delete
461 * from happening until after this vport's discovery is finished.
462 */
463 if (!(phba->pport->load_flag & FC_UNLOADING)) {
464 int check_count = 0;
465 while (check_count < ((phba->fc_ratov * 3) + 3) &&
466 vport->port_state > LPFC_VPORT_FAILED &&
467 vport->port_state < LPFC_VPORT_READY) {
468 check_count++;
469 msleep(1000);
470 }
471 if (vport->port_state > LPFC_VPORT_FAILED &&
472 vport->port_state < LPFC_VPORT_READY)
473 return -EAGAIN;
474 }
James Smart92d7f7b2007-06-17 19:56:38 -0500475 /*
476 * This is a bit of a mess. We want to ensure the shost doesn't get
477 * torn down until we're done with the embedded lpfc_vport structure.
478 *
479 * Beyond holding a reference for this function, we also need a
480 * reference for outstanding I/O requests we schedule during delete
481 * processing. But once we scsi_remove_host() we can no longer obtain
482 * a reference through scsi_host_get().
483 *
484 * So we take two references here. We release one reference at the
485 * bottom of the function -- after delinking the vport. And we
486 * release the other at the completion of the unreg_vpi that get's
487 * initiated after we've disposed of all other resources associated
488 * with the port.
489 */
490 if (!scsi_host_get(shost) || !scsi_host_get(shost))
491 return VPORT_INVAL;
James Smart51ef4c22007-08-02 11:10:31 -0400492 spin_lock_irq(&phba->hbalock);
James Smart92d7f7b2007-06-17 19:56:38 -0500493 vport->load_flag |= FC_UNLOADING;
James Smart51ef4c22007-08-02 11:10:31 -0400494 spin_unlock_irq(&phba->hbalock);
James Smart92d7f7b2007-06-17 19:56:38 -0500495 kfree(vport->vname);
James Smart858c9f62007-06-17 19:56:39 -0500496 lpfc_debugfs_terminate(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500497 fc_remove_host(lpfc_shost_from_vport(vport));
498 scsi_remove_host(lpfc_shost_from_vport(vport));
499
500 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
501 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
James Smart7ee5d432007-10-27 13:37:17 -0400502 phba->link_state >= LPFC_LINK_UP) {
503 if (vport->cfg_enable_da_id) {
504 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
505 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
506 while (vport->ct_flags && timeout)
507 timeout = schedule_timeout(timeout);
508 else
509 lpfc_printf_log(vport->phba, KERN_WARNING,
510 LOG_VPORT,
511 "1829 CT command failed to "
512 "delete objects on fabric. \n");
513 }
James Smart92d7f7b2007-06-17 19:56:38 -0500514 /* First look for the Fabric ndlp */
515 ndlp = lpfc_findnode_did(vport, Fabric_DID);
516 if (!ndlp) {
517 /* Cannot find existing Fabric ndlp, allocate one */
518 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
519 if (!ndlp)
520 goto skip_logo;
521 lpfc_nlp_init(vport, ndlp, Fabric_DID);
522 } else {
523 lpfc_dequeue_node(vport, ndlp);
524 }
525 vport->unreg_vpi_cmpl = VPORT_INVAL;
526 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
527 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
528 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
529 timeout = schedule_timeout(timeout);
530 }
531
532skip_logo:
James Smart87af33f2007-10-27 13:37:43 -0400533 lpfc_cleanup(vport);
James Smart92d7f7b2007-06-17 19:56:38 -0500534 lpfc_sli_host_down(vport);
535
James Smart92d7f7b2007-06-17 19:56:38 -0500536 lpfc_stop_vport_timers(vport);
537 lpfc_unreg_all_rpis(vport);
James Smart87af33f2007-10-27 13:37:43 -0400538
539 if (!(phba->pport->load_flag & FC_UNLOADING)) {
540 lpfc_unreg_default_rpis(vport);
541 /*
542 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi)
543 * does the scsi_host_put() to release the vport.
544 */
545 lpfc_mbx_unreg_vpi(vport);
546 }
James Smart92d7f7b2007-06-17 19:56:38 -0500547
548 lpfc_free_vpi(phba, vport->vpi);
549 vport->work_port_events = 0;
550 spin_lock_irq(&phba->hbalock);
551 list_del_init(&vport->listentry);
552 spin_unlock_irq(&phba->hbalock);
James Smarta58cbd52007-08-02 11:09:43 -0400553 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
554 "1828 Vport Deleted.\n");
James Smart92d7f7b2007-06-17 19:56:38 -0500555 scsi_host_put(shost);
James Smart51ef4c22007-08-02 11:10:31 -0400556 return VPORT_OK;
James Smart92d7f7b2007-06-17 19:56:38 -0500557}
558
James Smart549e55c2007-08-02 11:09:51 -0400559struct lpfc_vport **
560lpfc_create_vport_work_array(struct lpfc_hba *phba)
561{
562 struct lpfc_vport *port_iterator;
563 struct lpfc_vport **vports;
564 int index = 0;
565 vports = kzalloc(LPFC_MAX_VPORTS * sizeof(struct lpfc_vport *),
566 GFP_KERNEL);
567 if (vports == NULL)
568 return NULL;
569 spin_lock_irq(&phba->hbalock);
570 list_for_each_entry(port_iterator, &phba->port_list, listentry) {
James Smarte8b62012007-08-02 11:10:09 -0400571 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
James Smart51ef4c22007-08-02 11:10:31 -0400572 lpfc_printf_vlog(port_iterator, KERN_WARNING, LOG_VPORT,
James Smarte8b62012007-08-02 11:10:09 -0400573 "1801 Create vport work array FAILED: "
574 "cannot do scsi_host_get\n");
James Smart549e55c2007-08-02 11:09:51 -0400575 continue;
James Smarte8b62012007-08-02 11:10:09 -0400576 }
James Smart549e55c2007-08-02 11:09:51 -0400577 vports[index++] = port_iterator;
578 }
579 spin_unlock_irq(&phba->hbalock);
580 return vports;
581}
582
583void
584lpfc_destroy_vport_work_array(struct lpfc_vport **vports)
585{
586 int i;
587 if (vports == NULL)
588 return;
589 for (i=0; vports[i] != NULL && i < LPFC_MAX_VPORTS; i++)
590 scsi_host_put(lpfc_shost_from_vport(vports[i]));
591 kfree(vports);
592}