lpfc_init.c revision 98fc5dd952ecfd3abff7c06e7a55a5eab4dd95b7
1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for         *
3 * Fibre Channel Host Bus Adapters.                                *
4 * Copyright (C) 2004-2010 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#include <linux/ctype.h>
31#include <linux/aer.h>
32#include <linux/slab.h>
33
34#include <scsi/scsi.h>
35#include <scsi/scsi_device.h>
36#include <scsi/scsi_host.h>
37#include <scsi/scsi_transport_fc.h>
38
39#include "lpfc_hw4.h"
40#include "lpfc_hw.h"
41#include "lpfc_sli.h"
42#include "lpfc_sli4.h"
43#include "lpfc_nl.h"
44#include "lpfc_disc.h"
45#include "lpfc_scsi.h"
46#include "lpfc.h"
47#include "lpfc_logmsg.h"
48#include "lpfc_crtn.h"
49#include "lpfc_vport.h"
50#include "lpfc_version.h"
51
52char *_dump_buf_data;
53unsigned long _dump_buf_data_order;
54char *_dump_buf_dif;
55unsigned long _dump_buf_dif_order;
56spinlock_t _dump_buf_lock;
57
58static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
59static int lpfc_post_rcv_buf(struct lpfc_hba *);
60static int lpfc_sli4_queue_create(struct lpfc_hba *);
61static void lpfc_sli4_queue_destroy(struct lpfc_hba *);
62static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
63static int lpfc_setup_endian_order(struct lpfc_hba *);
64static int lpfc_sli4_read_config(struct lpfc_hba *);
65static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
66static void lpfc_free_sgl_list(struct lpfc_hba *);
67static int lpfc_init_sgl_list(struct lpfc_hba *);
68static int lpfc_init_active_sgl_array(struct lpfc_hba *);
69static void lpfc_free_active_sgl(struct lpfc_hba *);
70static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
71static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
72static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
73static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
74static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
75
76static struct scsi_transport_template *lpfc_transport_template = NULL;
77static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
78static DEFINE_IDR(lpfc_hba_index);
79
80/**
81 * lpfc_config_port_prep - Perform lpfc initialization prior to config port
82 * @phba: pointer to lpfc hba data structure.
83 *
84 * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
85 * mailbox command. It retrieves the revision information from the HBA and
86 * collects the Vital Product Data (VPD) about the HBA for preparing the
87 * configuration of the HBA.
88 *
89 * Return codes:
90 *   0 - success.
91 *   -ERESTART - requests the SLI layer to reset the HBA and try again.
92 *   Any other value - indicates an error.
93 **/
94int
95lpfc_config_port_prep(struct lpfc_hba *phba)
96{
97	lpfc_vpd_t *vp = &phba->vpd;
98	int i = 0, rc;
99	LPFC_MBOXQ_t *pmb;
100	MAILBOX_t *mb;
101	char *lpfc_vpd_data = NULL;
102	uint16_t offset = 0;
103	static char licensed[56] =
104		    "key unlock for use with gnu public licensed code only\0";
105	static int init_key = 1;
106
107	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
108	if (!pmb) {
109		phba->link_state = LPFC_HBA_ERROR;
110		return -ENOMEM;
111	}
112
113	mb = &pmb->u.mb;
114	phba->link_state = LPFC_INIT_MBX_CMDS;
115
116	if (lpfc_is_LC_HBA(phba->pcidev->device)) {
117		if (init_key) {
118			uint32_t *ptext = (uint32_t *) licensed;
119
120			for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
121				*ptext = cpu_to_be32(*ptext);
122			init_key = 0;
123		}
124
125		lpfc_read_nv(phba, pmb);
126		memset((char*)mb->un.varRDnvp.rsvd3, 0,
127			sizeof (mb->un.varRDnvp.rsvd3));
128		memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
129			 sizeof (licensed));
130
131		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
132
133		if (rc != MBX_SUCCESS) {
134			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
135					"0324 Config Port initialization "
136					"error, mbxCmd x%x READ_NVPARM, "
137					"mbxStatus x%x\n",
138					mb->mbxCommand, mb->mbxStatus);
139			mempool_free(pmb, phba->mbox_mem_pool);
140			return -ERESTART;
141		}
142		memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
143		       sizeof(phba->wwnn));
144		memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
145		       sizeof(phba->wwpn));
146	}
147
148	phba->sli3_options = 0x0;
149
150	/* Setup and issue mailbox READ REV command */
151	lpfc_read_rev(phba, pmb);
152	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
153	if (rc != MBX_SUCCESS) {
154		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
155				"0439 Adapter failed to init, mbxCmd x%x "
156				"READ_REV, mbxStatus x%x\n",
157				mb->mbxCommand, mb->mbxStatus);
158		mempool_free( pmb, phba->mbox_mem_pool);
159		return -ERESTART;
160	}
161
162
163	/*
164	 * The value of rr must be 1 since the driver set the cv field to 1.
165	 * This setting requires the FW to set all revision fields.
166	 */
167	if (mb->un.varRdRev.rr == 0) {
168		vp->rev.rBit = 0;
169		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
170				"0440 Adapter failed to init, READ_REV has "
171				"missing revision information.\n");
172		mempool_free(pmb, phba->mbox_mem_pool);
173		return -ERESTART;
174	}
175
176	if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
177		mempool_free(pmb, phba->mbox_mem_pool);
178		return -EINVAL;
179	}
180
181	/* Save information as VPD data */
182	vp->rev.rBit = 1;
183	memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
184	vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
185	memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
186	vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
187	memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
188	vp->rev.biuRev = mb->un.varRdRev.biuRev;
189	vp->rev.smRev = mb->un.varRdRev.smRev;
190	vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
191	vp->rev.endecRev = mb->un.varRdRev.endecRev;
192	vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
193	vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
194	vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
195	vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
196	vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
197	vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
198
199	/* If the sli feature level is less then 9, we must
200	 * tear down all RPIs and VPIs on link down if NPIV
201	 * is enabled.
202	 */
203	if (vp->rev.feaLevelHigh < 9)
204		phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
205
206	if (lpfc_is_LC_HBA(phba->pcidev->device))
207		memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
208						sizeof (phba->RandomData));
209
210	/* Get adapter VPD information */
211	lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
212	if (!lpfc_vpd_data)
213		goto out_free_mbox;
214
215	do {
216		lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
217		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
218
219		if (rc != MBX_SUCCESS) {
220			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
221					"0441 VPD not present on adapter, "
222					"mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
223					mb->mbxCommand, mb->mbxStatus);
224			mb->un.varDmp.word_cnt = 0;
225		}
226		/* dump mem may return a zero when finished or we got a
227		 * mailbox error, either way we are done.
228		 */
229		if (mb->un.varDmp.word_cnt == 0)
230			break;
231		if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
232			mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
233		lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
234				      lpfc_vpd_data + offset,
235				      mb->un.varDmp.word_cnt);
236		offset += mb->un.varDmp.word_cnt;
237	} while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
238	lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
239
240	kfree(lpfc_vpd_data);
241out_free_mbox:
242	mempool_free(pmb, phba->mbox_mem_pool);
243	return 0;
244}
245
246/**
247 * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
248 * @phba: pointer to lpfc hba data structure.
249 * @pmboxq: pointer to the driver internal queue element for mailbox command.
250 *
251 * This is the completion handler for driver's configuring asynchronous event
252 * mailbox command to the device. If the mailbox command returns successfully,
253 * it will set internal async event support flag to 1; otherwise, it will
254 * set internal async event support flag to 0.
255 **/
256static void
257lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
258{
259	if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS)
260		phba->temp_sensor_support = 1;
261	else
262		phba->temp_sensor_support = 0;
263	mempool_free(pmboxq, phba->mbox_mem_pool);
264	return;
265}
266
267/**
268 * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
269 * @phba: pointer to lpfc hba data structure.
270 * @pmboxq: pointer to the driver internal queue element for mailbox command.
271 *
272 * This is the completion handler for dump mailbox command for getting
273 * wake up parameters. When this command complete, the response contain
274 * Option rom version of the HBA. This function translate the version number
275 * into a human readable string and store it in OptionROMVersion.
276 **/
277static void
278lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
279{
280	struct prog_id *prg;
281	uint32_t prog_id_word;
282	char dist = ' ';
283	/* character array used for decoding dist type. */
284	char dist_char[] = "nabx";
285
286	if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) {
287		mempool_free(pmboxq, phba->mbox_mem_pool);
288		return;
289	}
290
291	prg = (struct prog_id *) &prog_id_word;
292
293	/* word 7 contain option rom version */
294	prog_id_word = pmboxq->u.mb.un.varWords[7];
295
296	/* Decode the Option rom version word to a readable string */
297	if (prg->dist < 4)
298		dist = dist_char[prg->dist];
299
300	if ((prg->dist == 3) && (prg->num == 0))
301		sprintf(phba->OptionROMVersion, "%d.%d%d",
302			prg->ver, prg->rev, prg->lev);
303	else
304		sprintf(phba->OptionROMVersion, "%d.%d%d%c%d",
305			prg->ver, prg->rev, prg->lev,
306			dist, prg->num);
307	mempool_free(pmboxq, phba->mbox_mem_pool);
308	return;
309}
310
311/**
312 * lpfc_config_port_post - Perform lpfc initialization after config port
313 * @phba: pointer to lpfc hba data structure.
314 *
315 * This routine will do LPFC initialization after the CONFIG_PORT mailbox
316 * command call. It performs all internal resource and state setups on the
317 * port: post IOCB buffers, enable appropriate host interrupt attentions,
318 * ELS ring timers, etc.
319 *
320 * Return codes
321 *   0 - success.
322 *   Any other value - error.
323 **/
324int
325lpfc_config_port_post(struct lpfc_hba *phba)
326{
327	struct lpfc_vport *vport = phba->pport;
328	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
329	LPFC_MBOXQ_t *pmb;
330	MAILBOX_t *mb;
331	struct lpfc_dmabuf *mp;
332	struct lpfc_sli *psli = &phba->sli;
333	uint32_t status, timeout;
334	int i, j;
335	int rc;
336
337	spin_lock_irq(&phba->hbalock);
338	/*
339	 * If the Config port completed correctly the HBA is not
340	 * over heated any more.
341	 */
342	if (phba->over_temp_state == HBA_OVER_TEMP)
343		phba->over_temp_state = HBA_NORMAL_TEMP;
344	spin_unlock_irq(&phba->hbalock);
345
346	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
347	if (!pmb) {
348		phba->link_state = LPFC_HBA_ERROR;
349		return -ENOMEM;
350	}
351	mb = &pmb->u.mb;
352
353	/* Get login parameters for NID.  */
354	rc = lpfc_read_sparam(phba, pmb, 0);
355	if (rc) {
356		mempool_free(pmb, phba->mbox_mem_pool);
357		return -ENOMEM;
358	}
359
360	pmb->vport = vport;
361	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
362		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
363				"0448 Adapter failed init, mbxCmd x%x "
364				"READ_SPARM mbxStatus x%x\n",
365				mb->mbxCommand, mb->mbxStatus);
366		phba->link_state = LPFC_HBA_ERROR;
367		mp = (struct lpfc_dmabuf *) pmb->context1;
368		mempool_free(pmb, phba->mbox_mem_pool);
369		lpfc_mbuf_free(phba, mp->virt, mp->phys);
370		kfree(mp);
371		return -EIO;
372	}
373
374	mp = (struct lpfc_dmabuf *) pmb->context1;
375
376	memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
377	lpfc_mbuf_free(phba, mp->virt, mp->phys);
378	kfree(mp);
379	pmb->context1 = NULL;
380
381	if (phba->cfg_soft_wwnn)
382		u64_to_wwn(phba->cfg_soft_wwnn,
383			   vport->fc_sparam.nodeName.u.wwn);
384	if (phba->cfg_soft_wwpn)
385		u64_to_wwn(phba->cfg_soft_wwpn,
386			   vport->fc_sparam.portName.u.wwn);
387	memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
388	       sizeof (struct lpfc_name));
389	memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
390	       sizeof (struct lpfc_name));
391
392	/* Update the fc_host data structures with new wwn. */
393	fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
394	fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
395	fc_host_max_npiv_vports(shost) = phba->max_vpi;
396
397	/* If no serial number in VPD data, use low 6 bytes of WWNN */
398	/* This should be consolidated into parse_vpd ? - mr */
399	if (phba->SerialNumber[0] == 0) {
400		uint8_t *outptr;
401
402		outptr = &vport->fc_nodename.u.s.IEEE[0];
403		for (i = 0; i < 12; i++) {
404			status = *outptr++;
405			j = ((status & 0xf0) >> 4);
406			if (j <= 9)
407				phba->SerialNumber[i] =
408				    (char)((uint8_t) 0x30 + (uint8_t) j);
409			else
410				phba->SerialNumber[i] =
411				    (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
412			i++;
413			j = (status & 0xf);
414			if (j <= 9)
415				phba->SerialNumber[i] =
416				    (char)((uint8_t) 0x30 + (uint8_t) j);
417			else
418				phba->SerialNumber[i] =
419				    (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
420		}
421	}
422
423	lpfc_read_config(phba, pmb);
424	pmb->vport = vport;
425	if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
426		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
427				"0453 Adapter failed to init, mbxCmd x%x "
428				"READ_CONFIG, mbxStatus x%x\n",
429				mb->mbxCommand, mb->mbxStatus);
430		phba->link_state = LPFC_HBA_ERROR;
431		mempool_free( pmb, phba->mbox_mem_pool);
432		return -EIO;
433	}
434
435	/* Check if the port is disabled */
436	lpfc_sli_read_link_ste(phba);
437
438	/* Reset the DFT_HBA_Q_DEPTH to the max xri  */
439	if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1))
440		phba->cfg_hba_queue_depth =
441			(mb->un.varRdConfig.max_xri + 1) -
442					lpfc_sli4_get_els_iocb_cnt(phba);
443
444	phba->lmt = mb->un.varRdConfig.lmt;
445
446	/* Get the default values for Model Name and Description */
447	lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
448
449	if ((phba->cfg_link_speed > LINK_SPEED_10G)
450	    || ((phba->cfg_link_speed == LINK_SPEED_1G)
451		&& !(phba->lmt & LMT_1Gb))
452	    || ((phba->cfg_link_speed == LINK_SPEED_2G)
453		&& !(phba->lmt & LMT_2Gb))
454	    || ((phba->cfg_link_speed == LINK_SPEED_4G)
455		&& !(phba->lmt & LMT_4Gb))
456	    || ((phba->cfg_link_speed == LINK_SPEED_8G)
457		&& !(phba->lmt & LMT_8Gb))
458	    || ((phba->cfg_link_speed == LINK_SPEED_10G)
459		&& !(phba->lmt & LMT_10Gb))) {
460		/* Reset link speed to auto */
461		lpfc_printf_log(phba, KERN_WARNING, LOG_LINK_EVENT,
462			"1302 Invalid speed for this board: "
463			"Reset link speed to auto: x%x\n",
464			phba->cfg_link_speed);
465			phba->cfg_link_speed = LINK_SPEED_AUTO;
466	}
467
468	phba->link_state = LPFC_LINK_DOWN;
469
470	/* Only process IOCBs on ELS ring till hba_state is READY */
471	if (psli->ring[psli->extra_ring].cmdringaddr)
472		psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT;
473	if (psli->ring[psli->fcp_ring].cmdringaddr)
474		psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT;
475	if (psli->ring[psli->next_ring].cmdringaddr)
476		psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT;
477
478	/* Post receive buffers for desired rings */
479	if (phba->sli_rev != 3)
480		lpfc_post_rcv_buf(phba);
481
482	/*
483	 * Configure HBA MSI-X attention conditions to messages if MSI-X mode
484	 */
485	if (phba->intr_type == MSIX) {
486		rc = lpfc_config_msi(phba, pmb);
487		if (rc) {
488			mempool_free(pmb, phba->mbox_mem_pool);
489			return -EIO;
490		}
491		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
492		if (rc != MBX_SUCCESS) {
493			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
494					"0352 Config MSI mailbox command "
495					"failed, mbxCmd x%x, mbxStatus x%x\n",
496					pmb->u.mb.mbxCommand,
497					pmb->u.mb.mbxStatus);
498			mempool_free(pmb, phba->mbox_mem_pool);
499			return -EIO;
500		}
501	}
502
503	spin_lock_irq(&phba->hbalock);
504	/* Initialize ERATT handling flag */
505	phba->hba_flag &= ~HBA_ERATT_HANDLED;
506
507	/* Enable appropriate host interrupts */
508	status = readl(phba->HCregaddr);
509	status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
510	if (psli->num_rings > 0)
511		status |= HC_R0INT_ENA;
512	if (psli->num_rings > 1)
513		status |= HC_R1INT_ENA;
514	if (psli->num_rings > 2)
515		status |= HC_R2INT_ENA;
516	if (psli->num_rings > 3)
517		status |= HC_R3INT_ENA;
518
519	if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
520	    (phba->cfg_poll & DISABLE_FCP_RING_INT))
521		status &= ~(HC_R0INT_ENA);
522
523	writel(status, phba->HCregaddr);
524	readl(phba->HCregaddr); /* flush */
525	spin_unlock_irq(&phba->hbalock);
526
527	/* Set up ring-0 (ELS) timer */
528	timeout = phba->fc_ratov * 2;
529	mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
530	/* Set up heart beat (HB) timer */
531	mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
532	phba->hb_outstanding = 0;
533	phba->last_completion_time = jiffies;
534	/* Set up error attention (ERATT) polling timer */
535	mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
536
537	if (phba->hba_flag & LINK_DISABLED) {
538		lpfc_printf_log(phba,
539			KERN_ERR, LOG_INIT,
540			"2598 Adapter Link is disabled.\n");
541		lpfc_down_link(phba, pmb);
542		pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
543		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
544		if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
545			lpfc_printf_log(phba,
546			KERN_ERR, LOG_INIT,
547			"2599 Adapter failed to issue DOWN_LINK"
548			" mbox command rc 0x%x\n", rc);
549
550			mempool_free(pmb, phba->mbox_mem_pool);
551			return -EIO;
552		}
553	} else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
554		lpfc_init_link(phba, pmb, phba->cfg_topology,
555			phba->cfg_link_speed);
556		pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
557		lpfc_set_loopback_flag(phba);
558		rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
559		if (rc != MBX_SUCCESS) {
560			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
561				"0454 Adapter failed to init, mbxCmd x%x "
562				"INIT_LINK, mbxStatus x%x\n",
563				mb->mbxCommand, mb->mbxStatus);
564
565			/* Clear all interrupt enable conditions */
566			writel(0, phba->HCregaddr);
567			readl(phba->HCregaddr); /* flush */
568			/* Clear all pending interrupts */
569			writel(0xffffffff, phba->HAregaddr);
570			readl(phba->HAregaddr); /* flush */
571
572			phba->link_state = LPFC_HBA_ERROR;
573			if (rc != MBX_BUSY)
574				mempool_free(pmb, phba->mbox_mem_pool);
575			return -EIO;
576		}
577	}
578	/* MBOX buffer will be freed in mbox compl */
579	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
580	if (!pmb) {
581		phba->link_state = LPFC_HBA_ERROR;
582		return -ENOMEM;
583	}
584
585	lpfc_config_async(phba, pmb, LPFC_ELS_RING);
586	pmb->mbox_cmpl = lpfc_config_async_cmpl;
587	pmb->vport = phba->pport;
588	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
589
590	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
591		lpfc_printf_log(phba,
592				KERN_ERR,
593				LOG_INIT,
594				"0456 Adapter failed to issue "
595				"ASYNCEVT_ENABLE mbox status x%x\n",
596				rc);
597		mempool_free(pmb, phba->mbox_mem_pool);
598	}
599
600	/* Get Option rom version */
601	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
602	if (!pmb) {
603		phba->link_state = LPFC_HBA_ERROR;
604		return -ENOMEM;
605	}
606
607	lpfc_dump_wakeup_param(phba, pmb);
608	pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
609	pmb->vport = phba->pport;
610	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
611
612	if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
613		lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "
614				"to get Option ROM version status x%x\n", rc);
615		mempool_free(pmb, phba->mbox_mem_pool);
616	}
617
618	return 0;
619}
620
621/**
622 * lpfc_hba_init_link - Initialize the FC link
623 * @phba: pointer to lpfc hba data structure.
624 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
625 *
626 * This routine will issue the INIT_LINK mailbox command call.
627 * It is available to other drivers through the lpfc_hba data
628 * structure for use as a delayed link up mechanism with the
629 * module parameter lpfc_suppress_link_up.
630 *
631 * Return code
632 *		0 - success
633 *		Any other value - error
634 **/
635int
636lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
637{
638	struct lpfc_vport *vport = phba->pport;
639	LPFC_MBOXQ_t *pmb;
640	MAILBOX_t *mb;
641	int rc;
642
643	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
644	if (!pmb) {
645		phba->link_state = LPFC_HBA_ERROR;
646		return -ENOMEM;
647	}
648	mb = &pmb->u.mb;
649	pmb->vport = vport;
650
651	lpfc_init_link(phba, pmb, phba->cfg_topology,
652		phba->cfg_link_speed);
653	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
654	lpfc_set_loopback_flag(phba);
655	rc = lpfc_sli_issue_mbox(phba, pmb, flag);
656	if (rc != MBX_SUCCESS) {
657		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
658			"0498 Adapter failed to init, mbxCmd x%x "
659			"INIT_LINK, mbxStatus x%x\n",
660			mb->mbxCommand, mb->mbxStatus);
661		/* Clear all interrupt enable conditions */
662		writel(0, phba->HCregaddr);
663		readl(phba->HCregaddr); /* flush */
664		/* Clear all pending interrupts */
665		writel(0xffffffff, phba->HAregaddr);
666		readl(phba->HAregaddr); /* flush */
667		phba->link_state = LPFC_HBA_ERROR;
668		if (rc != MBX_BUSY || flag == MBX_POLL)
669			mempool_free(pmb, phba->mbox_mem_pool);
670		return -EIO;
671	}
672	phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK;
673	if (flag == MBX_POLL)
674		mempool_free(pmb, phba->mbox_mem_pool);
675
676	return 0;
677}
678
679/**
680 * lpfc_hba_down_link - this routine downs the FC link
681 * @phba: pointer to lpfc hba data structure.
682 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
683 *
684 * This routine will issue the DOWN_LINK mailbox command call.
685 * It is available to other drivers through the lpfc_hba data
686 * structure for use to stop the link.
687 *
688 * Return code
689 *		0 - success
690 *		Any other value - error
691 **/
692int
693lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag)
694{
695	LPFC_MBOXQ_t *pmb;
696	int rc;
697
698	pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
699	if (!pmb) {
700		phba->link_state = LPFC_HBA_ERROR;
701		return -ENOMEM;
702	}
703
704	lpfc_printf_log(phba,
705		KERN_ERR, LOG_INIT,
706		"0491 Adapter Link is disabled.\n");
707	lpfc_down_link(phba, pmb);
708	pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
709	rc = lpfc_sli_issue_mbox(phba, pmb, flag);
710	if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
711		lpfc_printf_log(phba,
712		KERN_ERR, LOG_INIT,
713		"2522 Adapter failed to issue DOWN_LINK"
714		" mbox command rc 0x%x\n", rc);
715
716		mempool_free(pmb, phba->mbox_mem_pool);
717		return -EIO;
718	}
719	if (flag == MBX_POLL)
720		mempool_free(pmb, phba->mbox_mem_pool);
721
722	return 0;
723}
724
725/**
726 * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
727 * @phba: pointer to lpfc HBA data structure.
728 *
729 * This routine will do LPFC uninitialization before the HBA is reset when
730 * bringing down the SLI Layer.
731 *
732 * Return codes
733 *   0 - success.
734 *   Any other value - error.
735 **/
736int
737lpfc_hba_down_prep(struct lpfc_hba *phba)
738{
739	struct lpfc_vport **vports;
740	int i;
741
742	if (phba->sli_rev <= LPFC_SLI_REV3) {
743		/* Disable interrupts */
744		writel(0, phba->HCregaddr);
745		readl(phba->HCregaddr); /* flush */
746	}
747
748	if (phba->pport->load_flag & FC_UNLOADING)
749		lpfc_cleanup_discovery_resources(phba->pport);
750	else {
751		vports = lpfc_create_vport_work_array(phba);
752		if (vports != NULL)
753			for (i = 0; i <= phba->max_vports &&
754				vports[i] != NULL; i++)
755				lpfc_cleanup_discovery_resources(vports[i]);
756		lpfc_destroy_vport_work_array(phba, vports);
757	}
758	return 0;
759}
760
761/**
762 * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
763 * @phba: pointer to lpfc HBA data structure.
764 *
765 * This routine will do uninitialization after the HBA is reset when bring
766 * down the SLI Layer.
767 *
768 * Return codes
769 *   0 - success.
770 *   Any other value - error.
771 **/
772static int
773lpfc_hba_down_post_s3(struct lpfc_hba *phba)
774{
775	struct lpfc_sli *psli = &phba->sli;
776	struct lpfc_sli_ring *pring;
777	struct lpfc_dmabuf *mp, *next_mp;
778	LIST_HEAD(completions);
779	int i;
780
781	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
782		lpfc_sli_hbqbuf_free_all(phba);
783	else {
784		/* Cleanup preposted buffers on the ELS ring */
785		pring = &psli->ring[LPFC_ELS_RING];
786		list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
787			list_del(&mp->list);
788			pring->postbufq_cnt--;
789			lpfc_mbuf_free(phba, mp->virt, mp->phys);
790			kfree(mp);
791		}
792	}
793
794	spin_lock_irq(&phba->hbalock);
795	for (i = 0; i < psli->num_rings; i++) {
796		pring = &psli->ring[i];
797
798		/* At this point in time the HBA is either reset or DOA. Either
799		 * way, nothing should be on txcmplq as it will NEVER complete.
800		 */
801		list_splice_init(&pring->txcmplq, &completions);
802		pring->txcmplq_cnt = 0;
803		spin_unlock_irq(&phba->hbalock);
804
805		/* Cancel all the IOCBs from the completions list */
806		lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
807				      IOERR_SLI_ABORTED);
808
809		lpfc_sli_abort_iocb_ring(phba, pring);
810		spin_lock_irq(&phba->hbalock);
811	}
812	spin_unlock_irq(&phba->hbalock);
813
814	return 0;
815}
816/**
817 * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
818 * @phba: pointer to lpfc HBA data structure.
819 *
820 * This routine will do uninitialization after the HBA is reset when bring
821 * down the SLI Layer.
822 *
823 * Return codes
824 *   0 - success.
825 *   Any other value - error.
826 **/
827static int
828lpfc_hba_down_post_s4(struct lpfc_hba *phba)
829{
830	struct lpfc_scsi_buf *psb, *psb_next;
831	LIST_HEAD(aborts);
832	int ret;
833	unsigned long iflag = 0;
834	struct lpfc_sglq *sglq_entry = NULL;
835
836	ret = lpfc_hba_down_post_s3(phba);
837	if (ret)
838		return ret;
839	/* At this point in time the HBA is either reset or DOA. Either
840	 * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
841	 * on the lpfc_sgl_list so that it can either be freed if the
842	 * driver is unloading or reposted if the driver is restarting
843	 * the port.
844	 */
845	spin_lock_irq(&phba->hbalock);  /* required for lpfc_sgl_list and */
846					/* scsl_buf_list */
847	/* abts_sgl_list_lock required because worker thread uses this
848	 * list.
849	 */
850	spin_lock(&phba->sli4_hba.abts_sgl_list_lock);
851	list_for_each_entry(sglq_entry,
852		&phba->sli4_hba.lpfc_abts_els_sgl_list, list)
853		sglq_entry->state = SGL_FREED;
854
855	list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
856			&phba->sli4_hba.lpfc_sgl_list);
857	spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
858	/* abts_scsi_buf_list_lock required because worker thread uses this
859	 * list.
860	 */
861	spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
862	list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list,
863			&aborts);
864	spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
865	spin_unlock_irq(&phba->hbalock);
866
867	list_for_each_entry_safe(psb, psb_next, &aborts, list) {
868		psb->pCmd = NULL;
869		psb->status = IOSTAT_SUCCESS;
870	}
871	spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
872	list_splice(&aborts, &phba->lpfc_scsi_buf_list);
873	spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
874	return 0;
875}
876
877/**
878 * lpfc_hba_down_post - Wrapper func for hba down post routine
879 * @phba: pointer to lpfc HBA data structure.
880 *
881 * This routine wraps the actual SLI3 or SLI4 routine for performing
882 * uninitialization after the HBA is reset when bring down the SLI Layer.
883 *
884 * Return codes
885 *   0 - success.
886 *   Any other value - error.
887 **/
888int
889lpfc_hba_down_post(struct lpfc_hba *phba)
890{
891	return (*phba->lpfc_hba_down_post)(phba);
892}
893
894/**
895 * lpfc_hb_timeout - The HBA-timer timeout handler
896 * @ptr: unsigned long holds the pointer to lpfc hba data structure.
897 *
898 * This is the HBA-timer timeout handler registered to the lpfc driver. When
899 * this timer fires, a HBA timeout event shall be posted to the lpfc driver
900 * work-port-events bitmap and the worker thread is notified. This timeout
901 * event will be used by the worker thread to invoke the actual timeout
902 * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
903 * be performed in the timeout handler and the HBA timeout event bit shall
904 * be cleared by the worker thread after it has taken the event bitmap out.
905 **/
906static void
907lpfc_hb_timeout(unsigned long ptr)
908{
909	struct lpfc_hba *phba;
910	uint32_t tmo_posted;
911	unsigned long iflag;
912
913	phba = (struct lpfc_hba *)ptr;
914
915	/* Check for heart beat timeout conditions */
916	spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
917	tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
918	if (!tmo_posted)
919		phba->pport->work_port_events |= WORKER_HB_TMO;
920	spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
921
922	/* Tell the worker thread there is work to do */
923	if (!tmo_posted)
924		lpfc_worker_wake_up(phba);
925	return;
926}
927
928/**
929 * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
930 * @phba: pointer to lpfc hba data structure.
931 * @pmboxq: pointer to the driver internal queue element for mailbox command.
932 *
933 * This is the callback function to the lpfc heart-beat mailbox command.
934 * If configured, the lpfc driver issues the heart-beat mailbox command to
935 * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
936 * heart-beat mailbox command is issued, the driver shall set up heart-beat
937 * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
938 * heart-beat outstanding state. Once the mailbox command comes back and
939 * no error conditions detected, the heart-beat mailbox command timer is
940 * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
941 * state is cleared for the next heart-beat. If the timer expired with the
942 * heart-beat outstanding state set, the driver will put the HBA offline.
943 **/
944static void
945lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
946{
947	unsigned long drvr_flag;
948
949	spin_lock_irqsave(&phba->hbalock, drvr_flag);
950	phba->hb_outstanding = 0;
951	spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
952
953	/* Check and reset heart-beat timer is necessary */
954	mempool_free(pmboxq, phba->mbox_mem_pool);
955	if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
956		!(phba->link_state == LPFC_HBA_ERROR) &&
957		!(phba->pport->load_flag & FC_UNLOADING))
958		mod_timer(&phba->hb_tmofunc,
959			jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
960	return;
961}
962
963/**
964 * lpfc_hb_timeout_handler - The HBA-timer timeout handler
965 * @phba: pointer to lpfc hba data structure.
966 *
967 * This is the actual HBA-timer timeout handler to be invoked by the worker
968 * thread whenever the HBA timer fired and HBA-timeout event posted. This
969 * handler performs any periodic operations needed for the device. If such
970 * periodic event has already been attended to either in the interrupt handler
971 * or by processing slow-ring or fast-ring events within the HBA-timer
972 * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
973 * the timer for the next timeout period. If lpfc heart-beat mailbox command
974 * is configured and there is no heart-beat mailbox command outstanding, a
975 * heart-beat mailbox is issued and timer set properly. Otherwise, if there
976 * has been a heart-beat mailbox command outstanding, the HBA shall be put
977 * to offline.
978 **/
979void
980lpfc_hb_timeout_handler(struct lpfc_hba *phba)
981{
982	struct lpfc_vport **vports;
983	LPFC_MBOXQ_t *pmboxq;
984	struct lpfc_dmabuf *buf_ptr;
985	int retval, i;
986	struct lpfc_sli *psli = &phba->sli;
987	LIST_HEAD(completions);
988
989	vports = lpfc_create_vport_work_array(phba);
990	if (vports != NULL)
991		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
992			lpfc_rcv_seq_check_edtov(vports[i]);
993	lpfc_destroy_vport_work_array(phba, vports);
994
995	if ((phba->link_state == LPFC_HBA_ERROR) ||
996		(phba->pport->load_flag & FC_UNLOADING) ||
997		(phba->pport->fc_flag & FC_OFFLINE_MODE))
998		return;
999
1000	spin_lock_irq(&phba->pport->work_port_lock);
1001
1002	if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ,
1003		jiffies)) {
1004		spin_unlock_irq(&phba->pport->work_port_lock);
1005		if (!phba->hb_outstanding)
1006			mod_timer(&phba->hb_tmofunc,
1007				jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
1008		else
1009			mod_timer(&phba->hb_tmofunc,
1010				jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
1011		return;
1012	}
1013	spin_unlock_irq(&phba->pport->work_port_lock);
1014
1015	if (phba->elsbuf_cnt &&
1016		(phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
1017		spin_lock_irq(&phba->hbalock);
1018		list_splice_init(&phba->elsbuf, &completions);
1019		phba->elsbuf_cnt = 0;
1020		phba->elsbuf_prev_cnt = 0;
1021		spin_unlock_irq(&phba->hbalock);
1022
1023		while (!list_empty(&completions)) {
1024			list_remove_head(&completions, buf_ptr,
1025				struct lpfc_dmabuf, list);
1026			lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1027			kfree(buf_ptr);
1028		}
1029	}
1030	phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
1031
1032	/* If there is no heart beat outstanding, issue a heartbeat command */
1033	if (phba->cfg_enable_hba_heartbeat) {
1034		if (!phba->hb_outstanding) {
1035			pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
1036			if (!pmboxq) {
1037				mod_timer(&phba->hb_tmofunc,
1038					  jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
1039				return;
1040			}
1041
1042			lpfc_heart_beat(phba, pmboxq);
1043			pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
1044			pmboxq->vport = phba->pport;
1045			retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
1046
1047			if (retval != MBX_BUSY && retval != MBX_SUCCESS) {
1048				mempool_free(pmboxq, phba->mbox_mem_pool);
1049				mod_timer(&phba->hb_tmofunc,
1050					  jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
1051				return;
1052			}
1053			mod_timer(&phba->hb_tmofunc,
1054				  jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
1055			phba->hb_outstanding = 1;
1056			return;
1057		} else {
1058			/*
1059			* If heart beat timeout called with hb_outstanding set
1060			* we need to take the HBA offline.
1061			*/
1062			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1063					"0459 Adapter heartbeat failure, "
1064					"taking this port offline.\n");
1065
1066			spin_lock_irq(&phba->hbalock);
1067			psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1068			spin_unlock_irq(&phba->hbalock);
1069
1070			lpfc_offline_prep(phba);
1071			lpfc_offline(phba);
1072			lpfc_unblock_mgmt_io(phba);
1073			phba->link_state = LPFC_HBA_ERROR;
1074			lpfc_hba_down_post(phba);
1075		}
1076	}
1077}
1078
1079/**
1080 * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1081 * @phba: pointer to lpfc hba data structure.
1082 *
1083 * This routine is called to bring the HBA offline when HBA hardware error
1084 * other than Port Error 6 has been detected.
1085 **/
1086static void
1087lpfc_offline_eratt(struct lpfc_hba *phba)
1088{
1089	struct lpfc_sli   *psli = &phba->sli;
1090
1091	spin_lock_irq(&phba->hbalock);
1092	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1093	spin_unlock_irq(&phba->hbalock);
1094	lpfc_offline_prep(phba);
1095
1096	lpfc_offline(phba);
1097	lpfc_reset_barrier(phba);
1098	spin_lock_irq(&phba->hbalock);
1099	lpfc_sli_brdreset(phba);
1100	spin_unlock_irq(&phba->hbalock);
1101	lpfc_hba_down_post(phba);
1102	lpfc_sli_brdready(phba, HS_MBRDY);
1103	lpfc_unblock_mgmt_io(phba);
1104	phba->link_state = LPFC_HBA_ERROR;
1105	return;
1106}
1107
1108/**
1109 * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1110 * @phba: pointer to lpfc hba data structure.
1111 *
1112 * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1113 * other than Port Error 6 has been detected.
1114 **/
1115static void
1116lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
1117{
1118	lpfc_offline_prep(phba);
1119	lpfc_offline(phba);
1120	lpfc_sli4_brdreset(phba);
1121	lpfc_hba_down_post(phba);
1122	lpfc_sli4_post_status_check(phba);
1123	lpfc_unblock_mgmt_io(phba);
1124	phba->link_state = LPFC_HBA_ERROR;
1125}
1126
1127/**
1128 * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1129 * @phba: pointer to lpfc hba data structure.
1130 *
1131 * This routine is invoked to handle the deferred HBA hardware error
1132 * conditions. This type of error is indicated by HBA by setting ER1
1133 * and another ER bit in the host status register. The driver will
1134 * wait until the ER1 bit clears before handling the error condition.
1135 **/
1136static void
1137lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
1138{
1139	uint32_t old_host_status = phba->work_hs;
1140	struct lpfc_sli_ring  *pring;
1141	struct lpfc_sli *psli = &phba->sli;
1142
1143	/* If the pci channel is offline, ignore possible errors,
1144	 * since we cannot communicate with the pci card anyway.
1145	 */
1146	if (pci_channel_offline(phba->pcidev)) {
1147		spin_lock_irq(&phba->hbalock);
1148		phba->hba_flag &= ~DEFER_ERATT;
1149		spin_unlock_irq(&phba->hbalock);
1150		return;
1151	}
1152
1153	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1154		"0479 Deferred Adapter Hardware Error "
1155		"Data: x%x x%x x%x\n",
1156		phba->work_hs,
1157		phba->work_status[0], phba->work_status[1]);
1158
1159	spin_lock_irq(&phba->hbalock);
1160	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1161	spin_unlock_irq(&phba->hbalock);
1162
1163
1164	/*
1165	 * Firmware stops when it triggred erratt. That could cause the I/Os
1166	 * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1167	 * SCSI layer retry it after re-establishing link.
1168	 */
1169	pring = &psli->ring[psli->fcp_ring];
1170	lpfc_sli_abort_iocb_ring(phba, pring);
1171
1172	/*
1173	 * There was a firmware error. Take the hba offline and then
1174	 * attempt to restart it.
1175	 */
1176	lpfc_offline_prep(phba);
1177	lpfc_offline(phba);
1178
1179	/* Wait for the ER1 bit to clear.*/
1180	while (phba->work_hs & HS_FFER1) {
1181		msleep(100);
1182		phba->work_hs = readl(phba->HSregaddr);
1183		/* If driver is unloading let the worker thread continue */
1184		if (phba->pport->load_flag & FC_UNLOADING) {
1185			phba->work_hs = 0;
1186			break;
1187		}
1188	}
1189
1190	/*
1191	 * This is to ptrotect against a race condition in which
1192	 * first write to the host attention register clear the
1193	 * host status register.
1194	 */
1195	if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
1196		phba->work_hs = old_host_status & ~HS_FFER1;
1197
1198	spin_lock_irq(&phba->hbalock);
1199	phba->hba_flag &= ~DEFER_ERATT;
1200	spin_unlock_irq(&phba->hbalock);
1201	phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
1202	phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
1203}
1204
1205static void
1206lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
1207{
1208	struct lpfc_board_event_header board_event;
1209	struct Scsi_Host *shost;
1210
1211	board_event.event_type = FC_REG_BOARD_EVENT;
1212	board_event.subcategory = LPFC_EVENT_PORTINTERR;
1213	shost = lpfc_shost_from_vport(phba->pport);
1214	fc_host_post_vendor_event(shost, fc_get_event_number(),
1215				  sizeof(board_event),
1216				  (char *) &board_event,
1217				  LPFC_NL_VENDOR_ID);
1218}
1219
1220/**
1221 * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1222 * @phba: pointer to lpfc hba data structure.
1223 *
1224 * This routine is invoked to handle the following HBA hardware error
1225 * conditions:
1226 * 1 - HBA error attention interrupt
1227 * 2 - DMA ring index out of range
1228 * 3 - Mailbox command came back as unknown
1229 **/
1230static void
1231lpfc_handle_eratt_s3(struct lpfc_hba *phba)
1232{
1233	struct lpfc_vport *vport = phba->pport;
1234	struct lpfc_sli   *psli = &phba->sli;
1235	struct lpfc_sli_ring  *pring;
1236	uint32_t event_data;
1237	unsigned long temperature;
1238	struct temp_event temp_event_data;
1239	struct Scsi_Host  *shost;
1240
1241	/* If the pci channel is offline, ignore possible errors,
1242	 * since we cannot communicate with the pci card anyway.
1243	 */
1244	if (pci_channel_offline(phba->pcidev)) {
1245		spin_lock_irq(&phba->hbalock);
1246		phba->hba_flag &= ~DEFER_ERATT;
1247		spin_unlock_irq(&phba->hbalock);
1248		return;
1249	}
1250
1251	/* If resets are disabled then leave the HBA alone and return */
1252	if (!phba->cfg_enable_hba_reset)
1253		return;
1254
1255	/* Send an internal error event to mgmt application */
1256	lpfc_board_errevt_to_mgmt(phba);
1257
1258	if (phba->hba_flag & DEFER_ERATT)
1259		lpfc_handle_deferred_eratt(phba);
1260
1261	if (phba->work_hs & HS_FFER6) {
1262		/* Re-establishing Link */
1263		lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1264				"1301 Re-establishing Link "
1265				"Data: x%x x%x x%x\n",
1266				phba->work_hs,
1267				phba->work_status[0], phba->work_status[1]);
1268
1269		spin_lock_irq(&phba->hbalock);
1270		psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1271		spin_unlock_irq(&phba->hbalock);
1272
1273		/*
1274		* Firmware stops when it triggled erratt with HS_FFER6.
1275		* That could cause the I/Os dropped by the firmware.
1276		* Error iocb (I/O) on txcmplq and let the SCSI layer
1277		* retry it after re-establishing link.
1278		*/
1279		pring = &psli->ring[psli->fcp_ring];
1280		lpfc_sli_abort_iocb_ring(phba, pring);
1281
1282		/*
1283		 * There was a firmware error.  Take the hba offline and then
1284		 * attempt to restart it.
1285		 */
1286		lpfc_offline_prep(phba);
1287		lpfc_offline(phba);
1288		lpfc_sli_brdrestart(phba);
1289		if (lpfc_online(phba) == 0) {	/* Initialize the HBA */
1290			lpfc_unblock_mgmt_io(phba);
1291			return;
1292		}
1293		lpfc_unblock_mgmt_io(phba);
1294	} else if (phba->work_hs & HS_CRIT_TEMP) {
1295		temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
1296		temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1297		temp_event_data.event_code = LPFC_CRIT_TEMP;
1298		temp_event_data.data = (uint32_t)temperature;
1299
1300		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1301				"0406 Adapter maximum temperature exceeded "
1302				"(%ld), taking this port offline "
1303				"Data: x%x x%x x%x\n",
1304				temperature, phba->work_hs,
1305				phba->work_status[0], phba->work_status[1]);
1306
1307		shost = lpfc_shost_from_vport(phba->pport);
1308		fc_host_post_vendor_event(shost, fc_get_event_number(),
1309					  sizeof(temp_event_data),
1310					  (char *) &temp_event_data,
1311					  SCSI_NL_VID_TYPE_PCI
1312					  | PCI_VENDOR_ID_EMULEX);
1313
1314		spin_lock_irq(&phba->hbalock);
1315		phba->over_temp_state = HBA_OVER_TEMP;
1316		spin_unlock_irq(&phba->hbalock);
1317		lpfc_offline_eratt(phba);
1318
1319	} else {
1320		/* The if clause above forces this code path when the status
1321		 * failure is a value other than FFER6. Do not call the offline
1322		 * twice. This is the adapter hardware error path.
1323		 */
1324		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1325				"0457 Adapter Hardware Error "
1326				"Data: x%x x%x x%x\n",
1327				phba->work_hs,
1328				phba->work_status[0], phba->work_status[1]);
1329
1330		event_data = FC_REG_DUMP_EVENT;
1331		shost = lpfc_shost_from_vport(vport);
1332		fc_host_post_vendor_event(shost, fc_get_event_number(),
1333				sizeof(event_data), (char *) &event_data,
1334				SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1335
1336		lpfc_offline_eratt(phba);
1337	}
1338	return;
1339}
1340
1341/**
1342 * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1343 * @phba: pointer to lpfc hba data structure.
1344 *
1345 * This routine is invoked to handle the SLI4 HBA hardware error attention
1346 * conditions.
1347 **/
1348static void
1349lpfc_handle_eratt_s4(struct lpfc_hba *phba)
1350{
1351	struct lpfc_vport *vport = phba->pport;
1352	uint32_t event_data;
1353	struct Scsi_Host *shost;
1354
1355	/* If the pci channel is offline, ignore possible errors, since
1356	 * we cannot communicate with the pci card anyway.
1357	 */
1358	if (pci_channel_offline(phba->pcidev))
1359		return;
1360	/* If resets are disabled then leave the HBA alone and return */
1361	if (!phba->cfg_enable_hba_reset)
1362		return;
1363
1364	/* Send an internal error event to mgmt application */
1365	lpfc_board_errevt_to_mgmt(phba);
1366
1367	/* For now, the actual action for SLI4 device handling is not
1368	 * specified yet, just treated it as adaptor hardware failure
1369	 */
1370	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1371			"0143 SLI4 Adapter Hardware Error Data: x%x x%x\n",
1372			phba->work_status[0], phba->work_status[1]);
1373
1374	event_data = FC_REG_DUMP_EVENT;
1375	shost = lpfc_shost_from_vport(vport);
1376	fc_host_post_vendor_event(shost, fc_get_event_number(),
1377				  sizeof(event_data), (char *) &event_data,
1378				  SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1379
1380	lpfc_sli4_offline_eratt(phba);
1381}
1382
1383/**
1384 * lpfc_handle_eratt - Wrapper func for handling hba error attention
1385 * @phba: pointer to lpfc HBA data structure.
1386 *
1387 * This routine wraps the actual SLI3 or SLI4 hba error attention handling
1388 * routine from the API jump table function pointer from the lpfc_hba struct.
1389 *
1390 * Return codes
1391 *   0 - success.
1392 *   Any other value - error.
1393 **/
1394void
1395lpfc_handle_eratt(struct lpfc_hba *phba)
1396{
1397	(*phba->lpfc_handle_eratt)(phba);
1398}
1399
1400/**
1401 * lpfc_handle_latt - The HBA link event handler
1402 * @phba: pointer to lpfc hba data structure.
1403 *
1404 * This routine is invoked from the worker thread to handle a HBA host
1405 * attention link event.
1406 **/
1407void
1408lpfc_handle_latt(struct lpfc_hba *phba)
1409{
1410	struct lpfc_vport *vport = phba->pport;
1411	struct lpfc_sli   *psli = &phba->sli;
1412	LPFC_MBOXQ_t *pmb;
1413	volatile uint32_t control;
1414	struct lpfc_dmabuf *mp;
1415	int rc = 0;
1416
1417	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1418	if (!pmb) {
1419		rc = 1;
1420		goto lpfc_handle_latt_err_exit;
1421	}
1422
1423	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1424	if (!mp) {
1425		rc = 2;
1426		goto lpfc_handle_latt_free_pmb;
1427	}
1428
1429	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
1430	if (!mp->virt) {
1431		rc = 3;
1432		goto lpfc_handle_latt_free_mp;
1433	}
1434
1435	/* Cleanup any outstanding ELS commands */
1436	lpfc_els_flush_all_cmd(phba);
1437
1438	psli->slistat.link_event++;
1439	lpfc_read_la(phba, pmb, mp);
1440	pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
1441	pmb->vport = vport;
1442	/* Block ELS IOCBs until we have processed this mbox command */
1443	phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
1444	rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
1445	if (rc == MBX_NOT_FINISHED) {
1446		rc = 4;
1447		goto lpfc_handle_latt_free_mbuf;
1448	}
1449
1450	/* Clear Link Attention in HA REG */
1451	spin_lock_irq(&phba->hbalock);
1452	writel(HA_LATT, phba->HAregaddr);
1453	readl(phba->HAregaddr); /* flush */
1454	spin_unlock_irq(&phba->hbalock);
1455
1456	return;
1457
1458lpfc_handle_latt_free_mbuf:
1459	phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
1460	lpfc_mbuf_free(phba, mp->virt, mp->phys);
1461lpfc_handle_latt_free_mp:
1462	kfree(mp);
1463lpfc_handle_latt_free_pmb:
1464	mempool_free(pmb, phba->mbox_mem_pool);
1465lpfc_handle_latt_err_exit:
1466	/* Enable Link attention interrupts */
1467	spin_lock_irq(&phba->hbalock);
1468	psli->sli_flag |= LPFC_PROCESS_LA;
1469	control = readl(phba->HCregaddr);
1470	control |= HC_LAINT_ENA;
1471	writel(control, phba->HCregaddr);
1472	readl(phba->HCregaddr); /* flush */
1473
1474	/* Clear Link Attention in HA REG */
1475	writel(HA_LATT, phba->HAregaddr);
1476	readl(phba->HAregaddr); /* flush */
1477	spin_unlock_irq(&phba->hbalock);
1478	lpfc_linkdown(phba);
1479	phba->link_state = LPFC_HBA_ERROR;
1480
1481	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1482		     "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1483
1484	return;
1485}
1486
1487/**
1488 * lpfc_parse_vpd - Parse VPD (Vital Product Data)
1489 * @phba: pointer to lpfc hba data structure.
1490 * @vpd: pointer to the vital product data.
1491 * @len: length of the vital product data in bytes.
1492 *
1493 * This routine parses the Vital Product Data (VPD). The VPD is treated as
1494 * an array of characters. In this routine, the ModelName, ProgramType, and
1495 * ModelDesc, etc. fields of the phba data structure will be populated.
1496 *
1497 * Return codes
1498 *   0 - pointer to the VPD passed in is NULL
1499 *   1 - success
1500 **/
1501int
1502lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1503{
1504	uint8_t lenlo, lenhi;
1505	int Length;
1506	int i, j;
1507	int finished = 0;
1508	int index = 0;
1509
1510	if (!vpd)
1511		return 0;
1512
1513	/* Vital Product */
1514	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1515			"0455 Vital Product Data: x%x x%x x%x x%x\n",
1516			(uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1517			(uint32_t) vpd[3]);
1518	while (!finished && (index < (len - 4))) {
1519		switch (vpd[index]) {
1520		case 0x82:
1521		case 0x91:
1522			index += 1;
1523			lenlo = vpd[index];
1524			index += 1;
1525			lenhi = vpd[index];
1526			index += 1;
1527			i = ((((unsigned short)lenhi) << 8) + lenlo);
1528			index += i;
1529			break;
1530		case 0x90:
1531			index += 1;
1532			lenlo = vpd[index];
1533			index += 1;
1534			lenhi = vpd[index];
1535			index += 1;
1536			Length = ((((unsigned short)lenhi) << 8) + lenlo);
1537			if (Length > len - index)
1538				Length = len - index;
1539			while (Length > 0) {
1540			/* Look for Serial Number */
1541			if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
1542				index += 2;
1543				i = vpd[index];
1544				index += 1;
1545				j = 0;
1546				Length -= (3+i);
1547				while(i--) {
1548					phba->SerialNumber[j++] = vpd[index++];
1549					if (j == 31)
1550						break;
1551				}
1552				phba->SerialNumber[j] = 0;
1553				continue;
1554			}
1555			else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
1556				phba->vpd_flag |= VPD_MODEL_DESC;
1557				index += 2;
1558				i = vpd[index];
1559				index += 1;
1560				j = 0;
1561				Length -= (3+i);
1562				while(i--) {
1563					phba->ModelDesc[j++] = vpd[index++];
1564					if (j == 255)
1565						break;
1566				}
1567				phba->ModelDesc[j] = 0;
1568				continue;
1569			}
1570			else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
1571				phba->vpd_flag |= VPD_MODEL_NAME;
1572				index += 2;
1573				i = vpd[index];
1574				index += 1;
1575				j = 0;
1576				Length -= (3+i);
1577				while(i--) {
1578					phba->ModelName[j++] = vpd[index++];
1579					if (j == 79)
1580						break;
1581				}
1582				phba->ModelName[j] = 0;
1583				continue;
1584			}
1585			else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
1586				phba->vpd_flag |= VPD_PROGRAM_TYPE;
1587				index += 2;
1588				i = vpd[index];
1589				index += 1;
1590				j = 0;
1591				Length -= (3+i);
1592				while(i--) {
1593					phba->ProgramType[j++] = vpd[index++];
1594					if (j == 255)
1595						break;
1596				}
1597				phba->ProgramType[j] = 0;
1598				continue;
1599			}
1600			else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
1601				phba->vpd_flag |= VPD_PORT;
1602				index += 2;
1603				i = vpd[index];
1604				index += 1;
1605				j = 0;
1606				Length -= (3+i);
1607				while(i--) {
1608				phba->Port[j++] = vpd[index++];
1609				if (j == 19)
1610					break;
1611				}
1612				phba->Port[j] = 0;
1613				continue;
1614			}
1615			else {
1616				index += 2;
1617				i = vpd[index];
1618				index += 1;
1619				index += i;
1620				Length -= (3 + i);
1621			}
1622		}
1623		finished = 0;
1624		break;
1625		case 0x78:
1626			finished = 1;
1627			break;
1628		default:
1629			index ++;
1630			break;
1631		}
1632	}
1633
1634	return(1);
1635}
1636
1637/**
1638 * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
1639 * @phba: pointer to lpfc hba data structure.
1640 * @mdp: pointer to the data structure to hold the derived model name.
1641 * @descp: pointer to the data structure to hold the derived description.
1642 *
1643 * This routine retrieves HBA's description based on its registered PCI device
1644 * ID. The @descp passed into this function points to an array of 256 chars. It
1645 * shall be returned with the model name, maximum speed, and the host bus type.
1646 * The @mdp passed into this function points to an array of 80 chars. When the
1647 * function returns, the @mdp will be filled with the model name.
1648 **/
1649static void
1650lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
1651{
1652	lpfc_vpd_t *vp;
1653	uint16_t dev_id = phba->pcidev->device;
1654	int max_speed;
1655	int GE = 0;
1656	int oneConnect = 0; /* default is not a oneConnect */
1657	struct {
1658		char *name;
1659		char *bus;
1660		char *function;
1661	} m = {"<Unknown>", "", ""};
1662
1663	if (mdp && mdp[0] != '\0'
1664		&& descp && descp[0] != '\0')
1665		return;
1666
1667	if (phba->lmt & LMT_10Gb)
1668		max_speed = 10;
1669	else if (phba->lmt & LMT_8Gb)
1670		max_speed = 8;
1671	else if (phba->lmt & LMT_4Gb)
1672		max_speed = 4;
1673	else if (phba->lmt & LMT_2Gb)
1674		max_speed = 2;
1675	else
1676		max_speed = 1;
1677
1678	vp = &phba->vpd;
1679
1680	switch (dev_id) {
1681	case PCI_DEVICE_ID_FIREFLY:
1682		m = (typeof(m)){"LP6000", "PCI", "Fibre Channel Adapter"};
1683		break;
1684	case PCI_DEVICE_ID_SUPERFLY:
1685		if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
1686			m = (typeof(m)){"LP7000", "PCI",
1687					"Fibre Channel Adapter"};
1688		else
1689			m = (typeof(m)){"LP7000E", "PCI",
1690					"Fibre Channel Adapter"};
1691		break;
1692	case PCI_DEVICE_ID_DRAGONFLY:
1693		m = (typeof(m)){"LP8000", "PCI",
1694				"Fibre Channel Adapter"};
1695		break;
1696	case PCI_DEVICE_ID_CENTAUR:
1697		if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
1698			m = (typeof(m)){"LP9002", "PCI",
1699					"Fibre Channel Adapter"};
1700		else
1701			m = (typeof(m)){"LP9000", "PCI",
1702					"Fibre Channel Adapter"};
1703		break;
1704	case PCI_DEVICE_ID_RFLY:
1705		m = (typeof(m)){"LP952", "PCI",
1706				"Fibre Channel Adapter"};
1707		break;
1708	case PCI_DEVICE_ID_PEGASUS:
1709		m = (typeof(m)){"LP9802", "PCI-X",
1710				"Fibre Channel Adapter"};
1711		break;
1712	case PCI_DEVICE_ID_THOR:
1713		m = (typeof(m)){"LP10000", "PCI-X",
1714				"Fibre Channel Adapter"};
1715		break;
1716	case PCI_DEVICE_ID_VIPER:
1717		m = (typeof(m)){"LPX1000",  "PCI-X",
1718				"Fibre Channel Adapter"};
1719		break;
1720	case PCI_DEVICE_ID_PFLY:
1721		m = (typeof(m)){"LP982", "PCI-X",
1722				"Fibre Channel Adapter"};
1723		break;
1724	case PCI_DEVICE_ID_TFLY:
1725		m = (typeof(m)){"LP1050", "PCI-X",
1726				"Fibre Channel Adapter"};
1727		break;
1728	case PCI_DEVICE_ID_HELIOS:
1729		m = (typeof(m)){"LP11000", "PCI-X2",
1730				"Fibre Channel Adapter"};
1731		break;
1732	case PCI_DEVICE_ID_HELIOS_SCSP:
1733		m = (typeof(m)){"LP11000-SP", "PCI-X2",
1734				"Fibre Channel Adapter"};
1735		break;
1736	case PCI_DEVICE_ID_HELIOS_DCSP:
1737		m = (typeof(m)){"LP11002-SP",  "PCI-X2",
1738				"Fibre Channel Adapter"};
1739		break;
1740	case PCI_DEVICE_ID_NEPTUNE:
1741		m = (typeof(m)){"LPe1000", "PCIe", "Fibre Channel Adapter"};
1742		break;
1743	case PCI_DEVICE_ID_NEPTUNE_SCSP:
1744		m = (typeof(m)){"LPe1000-SP", "PCIe", "Fibre Channel Adapter"};
1745		break;
1746	case PCI_DEVICE_ID_NEPTUNE_DCSP:
1747		m = (typeof(m)){"LPe1002-SP", "PCIe", "Fibre Channel Adapter"};
1748		break;
1749	case PCI_DEVICE_ID_BMID:
1750		m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
1751		break;
1752	case PCI_DEVICE_ID_BSMB:
1753		m = (typeof(m)){"LP111", "PCI-X2", "Fibre Channel Adapter"};
1754		break;
1755	case PCI_DEVICE_ID_ZEPHYR:
1756		m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
1757		break;
1758	case PCI_DEVICE_ID_ZEPHYR_SCSP:
1759		m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
1760		break;
1761	case PCI_DEVICE_ID_ZEPHYR_DCSP:
1762		m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
1763		GE = 1;
1764		break;
1765	case PCI_DEVICE_ID_ZMID:
1766		m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
1767		break;
1768	case PCI_DEVICE_ID_ZSMB:
1769		m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
1770		break;
1771	case PCI_DEVICE_ID_LP101:
1772		m = (typeof(m)){"LP101", "PCI-X", "Fibre Channel Adapter"};
1773		break;
1774	case PCI_DEVICE_ID_LP10000S:
1775		m = (typeof(m)){"LP10000-S", "PCI", "Fibre Channel Adapter"};
1776		break;
1777	case PCI_DEVICE_ID_LP11000S:
1778		m = (typeof(m)){"LP11000-S", "PCI-X2", "Fibre Channel Adapter"};
1779		break;
1780	case PCI_DEVICE_ID_LPE11000S:
1781		m = (typeof(m)){"LPe11000-S", "PCIe", "Fibre Channel Adapter"};
1782		break;
1783	case PCI_DEVICE_ID_SAT:
1784		m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
1785		break;
1786	case PCI_DEVICE_ID_SAT_MID:
1787		m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
1788		break;
1789	case PCI_DEVICE_ID_SAT_SMB:
1790		m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
1791		break;
1792	case PCI_DEVICE_ID_SAT_DCSP:
1793		m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
1794		break;
1795	case PCI_DEVICE_ID_SAT_SCSP:
1796		m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
1797		break;
1798	case PCI_DEVICE_ID_SAT_S:
1799		m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
1800		break;
1801	case PCI_DEVICE_ID_HORNET:
1802		m = (typeof(m)){"LP21000", "PCIe", "FCoE Adapter"};
1803		GE = 1;
1804		break;
1805	case PCI_DEVICE_ID_PROTEUS_VF:
1806		m = (typeof(m)){"LPev12000", "PCIe IOV",
1807				"Fibre Channel Adapter"};
1808		break;
1809	case PCI_DEVICE_ID_PROTEUS_PF:
1810		m = (typeof(m)){"LPev12000", "PCIe IOV",
1811				"Fibre Channel Adapter"};
1812		break;
1813	case PCI_DEVICE_ID_PROTEUS_S:
1814		m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
1815				"Fibre Channel Adapter"};
1816		break;
1817	case PCI_DEVICE_ID_TIGERSHARK:
1818		oneConnect = 1;
1819		m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
1820		break;
1821	case PCI_DEVICE_ID_TOMCAT:
1822		oneConnect = 1;
1823		m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
1824		break;
1825	case PCI_DEVICE_ID_FALCON:
1826		m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
1827				"EmulexSecure Fibre"};
1828		break;
1829	case PCI_DEVICE_ID_BALIUS:
1830		m = (typeof(m)){"LPVe12002", "PCIe Shared I/O",
1831				"Fibre Channel Adapter"};
1832		break;
1833	default:
1834		m = (typeof(m)){"Unknown", "", ""};
1835		break;
1836	}
1837
1838	if (mdp && mdp[0] == '\0')
1839		snprintf(mdp, 79,"%s", m.name);
1840	/* oneConnect hba requires special processing, they are all initiators
1841	 * and we put the port number on the end
1842	 */
1843	if (descp && descp[0] == '\0') {
1844		if (oneConnect)
1845			snprintf(descp, 255,
1846				"Emulex OneConnect %s, %s Initiator, Port %s",
1847				m.name, m.function,
1848				phba->Port);
1849		else
1850			snprintf(descp, 255,
1851				"Emulex %s %d%s %s %s",
1852				m.name, max_speed, (GE) ? "GE" : "Gb",
1853				m.bus, m.function);
1854	}
1855}
1856
1857/**
1858 * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
1859 * @phba: pointer to lpfc hba data structure.
1860 * @pring: pointer to a IOCB ring.
1861 * @cnt: the number of IOCBs to be posted to the IOCB ring.
1862 *
1863 * This routine posts a given number of IOCBs with the associated DMA buffer
1864 * descriptors specified by the cnt argument to the given IOCB ring.
1865 *
1866 * Return codes
1867 *   The number of IOCBs NOT able to be posted to the IOCB ring.
1868 **/
1869int
1870lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
1871{
1872	IOCB_t *icmd;
1873	struct lpfc_iocbq *iocb;
1874	struct lpfc_dmabuf *mp1, *mp2;
1875
1876	cnt += pring->missbufcnt;
1877
1878	/* While there are buffers to post */
1879	while (cnt > 0) {
1880		/* Allocate buffer for  command iocb */
1881		iocb = lpfc_sli_get_iocbq(phba);
1882		if (iocb == NULL) {
1883			pring->missbufcnt = cnt;
1884			return cnt;
1885		}
1886		icmd = &iocb->iocb;
1887
1888		/* 2 buffers can be posted per command */
1889		/* Allocate buffer to post */
1890		mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1891		if (mp1)
1892		    mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
1893		if (!mp1 || !mp1->virt) {
1894			kfree(mp1);
1895			lpfc_sli_release_iocbq(phba, iocb);
1896			pring->missbufcnt = cnt;
1897			return cnt;
1898		}
1899
1900		INIT_LIST_HEAD(&mp1->list);
1901		/* Allocate buffer to post */
1902		if (cnt > 1) {
1903			mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1904			if (mp2)
1905				mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
1906							    &mp2->phys);
1907			if (!mp2 || !mp2->virt) {
1908				kfree(mp2);
1909				lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1910				kfree(mp1);
1911				lpfc_sli_release_iocbq(phba, iocb);
1912				pring->missbufcnt = cnt;
1913				return cnt;
1914			}
1915
1916			INIT_LIST_HEAD(&mp2->list);
1917		} else {
1918			mp2 = NULL;
1919		}
1920
1921		icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
1922		icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
1923		icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
1924		icmd->ulpBdeCount = 1;
1925		cnt--;
1926		if (mp2) {
1927			icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
1928			icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
1929			icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
1930			cnt--;
1931			icmd->ulpBdeCount = 2;
1932		}
1933
1934		icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1935		icmd->ulpLe = 1;
1936
1937		if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
1938		    IOCB_ERROR) {
1939			lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1940			kfree(mp1);
1941			cnt++;
1942			if (mp2) {
1943				lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1944				kfree(mp2);
1945				cnt++;
1946			}
1947			lpfc_sli_release_iocbq(phba, iocb);
1948			pring->missbufcnt = cnt;
1949			return cnt;
1950		}
1951		lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1952		if (mp2)
1953			lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1954	}
1955	pring->missbufcnt = 0;
1956	return 0;
1957}
1958
1959/**
1960 * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
1961 * @phba: pointer to lpfc hba data structure.
1962 *
1963 * This routine posts initial receive IOCB buffers to the ELS ring. The
1964 * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
1965 * set to 64 IOCBs.
1966 *
1967 * Return codes
1968 *   0 - success (currently always success)
1969 **/
1970static int
1971lpfc_post_rcv_buf(struct lpfc_hba *phba)
1972{
1973	struct lpfc_sli *psli = &phba->sli;
1974
1975	/* Ring 0, ELS / CT buffers */
1976	lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0);
1977	/* Ring 2 - FCP no buffers needed */
1978
1979	return 0;
1980}
1981
1982#define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
1983
1984/**
1985 * lpfc_sha_init - Set up initial array of hash table entries
1986 * @HashResultPointer: pointer to an array as hash table.
1987 *
1988 * This routine sets up the initial values to the array of hash table entries
1989 * for the LC HBAs.
1990 **/
1991static void
1992lpfc_sha_init(uint32_t * HashResultPointer)
1993{
1994	HashResultPointer[0] = 0x67452301;
1995	HashResultPointer[1] = 0xEFCDAB89;
1996	HashResultPointer[2] = 0x98BADCFE;
1997	HashResultPointer[3] = 0x10325476;
1998	HashResultPointer[4] = 0xC3D2E1F0;
1999}
2000
2001/**
2002 * lpfc_sha_iterate - Iterate initial hash table with the working hash table
2003 * @HashResultPointer: pointer to an initial/result hash table.
2004 * @HashWorkingPointer: pointer to an working hash table.
2005 *
2006 * This routine iterates an initial hash table pointed by @HashResultPointer
2007 * with the values from the working hash table pointeed by @HashWorkingPointer.
2008 * The results are putting back to the initial hash table, returned through
2009 * the @HashResultPointer as the result hash table.
2010 **/
2011static void
2012lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
2013{
2014	int t;
2015	uint32_t TEMP;
2016	uint32_t A, B, C, D, E;
2017	t = 16;
2018	do {
2019		HashWorkingPointer[t] =
2020		    S(1,
2021		      HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
2022								     8] ^
2023		      HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
2024	} while (++t <= 79);
2025	t = 0;
2026	A = HashResultPointer[0];
2027	B = HashResultPointer[1];
2028	C = HashResultPointer[2];
2029	D = HashResultPointer[3];
2030	E = HashResultPointer[4];
2031
2032	do {
2033		if (t < 20) {
2034			TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
2035		} else if (t < 40) {
2036			TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
2037		} else if (t < 60) {
2038			TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
2039		} else {
2040			TEMP = (B ^ C ^ D) + 0xCA62C1D6;
2041		}
2042		TEMP += S(5, A) + E + HashWorkingPointer[t];
2043		E = D;
2044		D = C;
2045		C = S(30, B);
2046		B = A;
2047		A = TEMP;
2048	} while (++t <= 79);
2049
2050	HashResultPointer[0] += A;
2051	HashResultPointer[1] += B;
2052	HashResultPointer[2] += C;
2053	HashResultPointer[3] += D;
2054	HashResultPointer[4] += E;
2055
2056}
2057
2058/**
2059 * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2060 * @RandomChallenge: pointer to the entry of host challenge random number array.
2061 * @HashWorking: pointer to the entry of the working hash array.
2062 *
2063 * This routine calculates the working hash array referred by @HashWorking
2064 * from the challenge random numbers associated with the host, referred by
2065 * @RandomChallenge. The result is put into the entry of the working hash
2066 * array and returned by reference through @HashWorking.
2067 **/
2068static void
2069lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
2070{
2071	*HashWorking = (*RandomChallenge ^ *HashWorking);
2072}
2073
2074/**
2075 * lpfc_hba_init - Perform special handling for LC HBA initialization
2076 * @phba: pointer to lpfc hba data structure.
2077 * @hbainit: pointer to an array of unsigned 32-bit integers.
2078 *
2079 * This routine performs the special handling for LC HBA initialization.
2080 **/
2081void
2082lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
2083{
2084	int t;
2085	uint32_t *HashWorking;
2086	uint32_t *pwwnn = (uint32_t *) phba->wwnn;
2087
2088	HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
2089	if (!HashWorking)
2090		return;
2091
2092	HashWorking[0] = HashWorking[78] = *pwwnn++;
2093	HashWorking[1] = HashWorking[79] = *pwwnn;
2094
2095	for (t = 0; t < 7; t++)
2096		lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
2097
2098	lpfc_sha_init(hbainit);
2099	lpfc_sha_iterate(hbainit, HashWorking);
2100	kfree(HashWorking);
2101}
2102
2103/**
2104 * lpfc_cleanup - Performs vport cleanups before deleting a vport
2105 * @vport: pointer to a virtual N_Port data structure.
2106 *
2107 * This routine performs the necessary cleanups before deleting the @vport.
2108 * It invokes the discovery state machine to perform necessary state
2109 * transitions and to release the ndlps associated with the @vport. Note,
2110 * the physical port is treated as @vport 0.
2111 **/
2112void
2113lpfc_cleanup(struct lpfc_vport *vport)
2114{
2115	struct lpfc_hba   *phba = vport->phba;
2116	struct lpfc_nodelist *ndlp, *next_ndlp;
2117	int i = 0;
2118
2119	if (phba->link_state > LPFC_LINK_DOWN)
2120		lpfc_port_link_failure(vport);
2121
2122	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2123		if (!NLP_CHK_NODE_ACT(ndlp)) {
2124			ndlp = lpfc_enable_node(vport, ndlp,
2125						NLP_STE_UNUSED_NODE);
2126			if (!ndlp)
2127				continue;
2128			spin_lock_irq(&phba->ndlp_lock);
2129			NLP_SET_FREE_REQ(ndlp);
2130			spin_unlock_irq(&phba->ndlp_lock);
2131			/* Trigger the release of the ndlp memory */
2132			lpfc_nlp_put(ndlp);
2133			continue;
2134		}
2135		spin_lock_irq(&phba->ndlp_lock);
2136		if (NLP_CHK_FREE_REQ(ndlp)) {
2137			/* The ndlp should not be in memory free mode already */
2138			spin_unlock_irq(&phba->ndlp_lock);
2139			continue;
2140		} else
2141			/* Indicate request for freeing ndlp memory */
2142			NLP_SET_FREE_REQ(ndlp);
2143		spin_unlock_irq(&phba->ndlp_lock);
2144
2145		if (vport->port_type != LPFC_PHYSICAL_PORT &&
2146		    ndlp->nlp_DID == Fabric_DID) {
2147			/* Just free up ndlp with Fabric_DID for vports */
2148			lpfc_nlp_put(ndlp);
2149			continue;
2150		}
2151
2152		if (ndlp->nlp_type & NLP_FABRIC)
2153			lpfc_disc_state_machine(vport, ndlp, NULL,
2154					NLP_EVT_DEVICE_RECOVERY);
2155
2156		lpfc_disc_state_machine(vport, ndlp, NULL,
2157					     NLP_EVT_DEVICE_RM);
2158
2159	}
2160
2161	/* At this point, ALL ndlp's should be gone
2162	 * because of the previous NLP_EVT_DEVICE_RM.
2163	 * Lets wait for this to happen, if needed.
2164	 */
2165	while (!list_empty(&vport->fc_nodes)) {
2166		if (i++ > 3000) {
2167			lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2168				"0233 Nodelist not empty\n");
2169			list_for_each_entry_safe(ndlp, next_ndlp,
2170						&vport->fc_nodes, nlp_listp) {
2171				lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2172						LOG_NODE,
2173						"0282 did:x%x ndlp:x%p "
2174						"usgmap:x%x refcnt:%d\n",
2175						ndlp->nlp_DID, (void *)ndlp,
2176						ndlp->nlp_usg_map,
2177						atomic_read(
2178							&ndlp->kref.refcount));
2179			}
2180			break;
2181		}
2182
2183		/* Wait for any activity on ndlps to settle */
2184		msleep(10);
2185	}
2186}
2187
2188/**
2189 * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2190 * @vport: pointer to a virtual N_Port data structure.
2191 *
2192 * This routine stops all the timers associated with a @vport. This function
2193 * is invoked before disabling or deleting a @vport. Note that the physical
2194 * port is treated as @vport 0.
2195 **/
2196void
2197lpfc_stop_vport_timers(struct lpfc_vport *vport)
2198{
2199	del_timer_sync(&vport->els_tmofunc);
2200	del_timer_sync(&vport->fc_fdmitmo);
2201	lpfc_can_disctmo(vport);
2202	return;
2203}
2204
2205/**
2206 * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2207 * @phba: pointer to lpfc hba data structure.
2208 *
2209 * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2210 * caller of this routine should already hold the host lock.
2211 **/
2212void
2213__lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2214{
2215	/* Clear pending FCF rediscovery wait and failover in progress flags */
2216	phba->fcf.fcf_flag &= ~(FCF_REDISC_PEND |
2217				FCF_DEAD_DISC |
2218				FCF_ACVL_DISC);
2219	/* Now, try to stop the timer */
2220	del_timer(&phba->fcf.redisc_wait);
2221}
2222
2223/**
2224 * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2225 * @phba: pointer to lpfc hba data structure.
2226 *
2227 * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2228 * checks whether the FCF rediscovery wait timer is pending with the host
2229 * lock held before proceeding with disabling the timer and clearing the
2230 * wait timer pendig flag.
2231 **/
2232void
2233lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2234{
2235	spin_lock_irq(&phba->hbalock);
2236	if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2237		/* FCF rediscovery timer already fired or stopped */
2238		spin_unlock_irq(&phba->hbalock);
2239		return;
2240	}
2241	__lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2242	spin_unlock_irq(&phba->hbalock);
2243}
2244
2245/**
2246 * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2247 * @phba: pointer to lpfc hba data structure.
2248 *
2249 * This routine stops all the timers associated with a HBA. This function is
2250 * invoked before either putting a HBA offline or unloading the driver.
2251 **/
2252void
2253lpfc_stop_hba_timers(struct lpfc_hba *phba)
2254{
2255	lpfc_stop_vport_timers(phba->pport);
2256	del_timer_sync(&phba->sli.mbox_tmo);
2257	del_timer_sync(&phba->fabric_block_timer);
2258	del_timer_sync(&phba->eratt_poll);
2259	del_timer_sync(&phba->hb_tmofunc);
2260	phba->hb_outstanding = 0;
2261
2262	switch (phba->pci_dev_grp) {
2263	case LPFC_PCI_DEV_LP:
2264		/* Stop any LightPulse device specific driver timers */
2265		del_timer_sync(&phba->fcp_poll_timer);
2266		break;
2267	case LPFC_PCI_DEV_OC:
2268		/* Stop any OneConnect device sepcific driver timers */
2269		lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2270		break;
2271	default:
2272		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2273				"0297 Invalid device group (x%x)\n",
2274				phba->pci_dev_grp);
2275		break;
2276	}
2277	return;
2278}
2279
2280/**
2281 * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2282 * @phba: pointer to lpfc hba data structure.
2283 *
2284 * This routine marks a HBA's management interface as blocked. Once the HBA's
2285 * management interface is marked as blocked, all the user space access to
2286 * the HBA, whether they are from sysfs interface or libdfc interface will
2287 * all be blocked. The HBA is set to block the management interface when the
2288 * driver prepares the HBA interface for online or offline.
2289 **/
2290static void
2291lpfc_block_mgmt_io(struct lpfc_hba * phba)
2292{
2293	unsigned long iflag;
2294	uint8_t actcmd = MBX_HEARTBEAT;
2295	unsigned long timeout;
2296
2297
2298	spin_lock_irqsave(&phba->hbalock, iflag);
2299	phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
2300	if (phba->sli.mbox_active)
2301		actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
2302	spin_unlock_irqrestore(&phba->hbalock, iflag);
2303	/* Determine how long we might wait for the active mailbox
2304	 * command to be gracefully completed by firmware.
2305	 */
2306	timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, actcmd) * 1000) +
2307			jiffies;
2308	/* Wait for the outstnading mailbox command to complete */
2309	while (phba->sli.mbox_active) {
2310		/* Check active mailbox complete status every 2ms */
2311		msleep(2);
2312		if (time_after(jiffies, timeout)) {
2313			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2314				"2813 Mgmt IO is Blocked %x "
2315				"- mbox cmd %x still active\n",
2316				phba->sli.sli_flag, actcmd);
2317			break;
2318		}
2319	}
2320}
2321
2322/**
2323 * lpfc_online - Initialize and bring a HBA online
2324 * @phba: pointer to lpfc hba data structure.
2325 *
2326 * This routine initializes the HBA and brings a HBA online. During this
2327 * process, the management interface is blocked to prevent user space access
2328 * to the HBA interfering with the driver initialization.
2329 *
2330 * Return codes
2331 *   0 - successful
2332 *   1 - failed
2333 **/
2334int
2335lpfc_online(struct lpfc_hba *phba)
2336{
2337	struct lpfc_vport *vport;
2338	struct lpfc_vport **vports;
2339	int i;
2340
2341	if (!phba)
2342		return 0;
2343	vport = phba->pport;
2344
2345	if (!(vport->fc_flag & FC_OFFLINE_MODE))
2346		return 0;
2347
2348	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2349			"0458 Bring Adapter online\n");
2350
2351	lpfc_block_mgmt_io(phba);
2352
2353	if (!lpfc_sli_queue_setup(phba)) {
2354		lpfc_unblock_mgmt_io(phba);
2355		return 1;
2356	}
2357
2358	if (phba->sli_rev == LPFC_SLI_REV4) {
2359		if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */
2360			lpfc_unblock_mgmt_io(phba);
2361			return 1;
2362		}
2363	} else {
2364		if (lpfc_sli_hba_setup(phba)) {	/* Initialize SLI2/SLI3 HBA */
2365			lpfc_unblock_mgmt_io(phba);
2366			return 1;
2367		}
2368	}
2369
2370	vports = lpfc_create_vport_work_array(phba);
2371	if (vports != NULL)
2372		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2373			struct Scsi_Host *shost;
2374			shost = lpfc_shost_from_vport(vports[i]);
2375			spin_lock_irq(shost->host_lock);
2376			vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
2377			if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2378				vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2379			if (phba->sli_rev == LPFC_SLI_REV4)
2380				vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
2381			spin_unlock_irq(shost->host_lock);
2382		}
2383		lpfc_destroy_vport_work_array(phba, vports);
2384
2385	lpfc_unblock_mgmt_io(phba);
2386	return 0;
2387}
2388
2389/**
2390 * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
2391 * @phba: pointer to lpfc hba data structure.
2392 *
2393 * This routine marks a HBA's management interface as not blocked. Once the
2394 * HBA's management interface is marked as not blocked, all the user space
2395 * access to the HBA, whether they are from sysfs interface or libdfc
2396 * interface will be allowed. The HBA is set to block the management interface
2397 * when the driver prepares the HBA interface for online or offline and then
2398 * set to unblock the management interface afterwards.
2399 **/
2400void
2401lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
2402{
2403	unsigned long iflag;
2404
2405	spin_lock_irqsave(&phba->hbalock, iflag);
2406	phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
2407	spin_unlock_irqrestore(&phba->hbalock, iflag);
2408}
2409
2410/**
2411 * lpfc_offline_prep - Prepare a HBA to be brought offline
2412 * @phba: pointer to lpfc hba data structure.
2413 *
2414 * This routine is invoked to prepare a HBA to be brought offline. It performs
2415 * unregistration login to all the nodes on all vports and flushes the mailbox
2416 * queue to make it ready to be brought offline.
2417 **/
2418void
2419lpfc_offline_prep(struct lpfc_hba * phba)
2420{
2421	struct lpfc_vport *vport = phba->pport;
2422	struct lpfc_nodelist  *ndlp, *next_ndlp;
2423	struct lpfc_vport **vports;
2424	struct Scsi_Host *shost;
2425	int i;
2426
2427	if (vport->fc_flag & FC_OFFLINE_MODE)
2428		return;
2429
2430	lpfc_block_mgmt_io(phba);
2431
2432	lpfc_linkdown(phba);
2433
2434	/* Issue an unreg_login to all nodes on all vports */
2435	vports = lpfc_create_vport_work_array(phba);
2436	if (vports != NULL) {
2437		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2438			if (vports[i]->load_flag & FC_UNLOADING)
2439				continue;
2440			shost = lpfc_shost_from_vport(vports[i]);
2441			spin_lock_irq(shost->host_lock);
2442			vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
2443			vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2444			vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
2445			spin_unlock_irq(shost->host_lock);
2446
2447			shost =	lpfc_shost_from_vport(vports[i]);
2448			list_for_each_entry_safe(ndlp, next_ndlp,
2449						 &vports[i]->fc_nodes,
2450						 nlp_listp) {
2451				if (!NLP_CHK_NODE_ACT(ndlp))
2452					continue;
2453				if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
2454					continue;
2455				if (ndlp->nlp_type & NLP_FABRIC) {
2456					lpfc_disc_state_machine(vports[i], ndlp,
2457						NULL, NLP_EVT_DEVICE_RECOVERY);
2458					lpfc_disc_state_machine(vports[i], ndlp,
2459						NULL, NLP_EVT_DEVICE_RM);
2460				}
2461				spin_lock_irq(shost->host_lock);
2462				ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2463				spin_unlock_irq(shost->host_lock);
2464				lpfc_unreg_rpi(vports[i], ndlp);
2465			}
2466		}
2467	}
2468	lpfc_destroy_vport_work_array(phba, vports);
2469
2470	lpfc_sli_mbox_sys_shutdown(phba);
2471}
2472
2473/**
2474 * lpfc_offline - Bring a HBA offline
2475 * @phba: pointer to lpfc hba data structure.
2476 *
2477 * This routine actually brings a HBA offline. It stops all the timers
2478 * associated with the HBA, brings down the SLI layer, and eventually
2479 * marks the HBA as in offline state for the upper layer protocol.
2480 **/
2481void
2482lpfc_offline(struct lpfc_hba *phba)
2483{
2484	struct Scsi_Host  *shost;
2485	struct lpfc_vport **vports;
2486	int i;
2487
2488	if (phba->pport->fc_flag & FC_OFFLINE_MODE)
2489		return;
2490
2491	/* stop port and all timers associated with this hba */
2492	lpfc_stop_port(phba);
2493	vports = lpfc_create_vport_work_array(phba);
2494	if (vports != NULL)
2495		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
2496			lpfc_stop_vport_timers(vports[i]);
2497	lpfc_destroy_vport_work_array(phba, vports);
2498	lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2499			"0460 Bring Adapter offline\n");
2500	/* Bring down the SLI Layer and cleanup.  The HBA is offline
2501	   now.  */
2502	lpfc_sli_hba_down(phba);
2503	spin_lock_irq(&phba->hbalock);
2504	phba->work_ha = 0;
2505	spin_unlock_irq(&phba->hbalock);
2506	vports = lpfc_create_vport_work_array(phba);
2507	if (vports != NULL)
2508		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2509			shost = lpfc_shost_from_vport(vports[i]);
2510			spin_lock_irq(shost->host_lock);
2511			vports[i]->work_port_events = 0;
2512			vports[i]->fc_flag |= FC_OFFLINE_MODE;
2513			spin_unlock_irq(shost->host_lock);
2514		}
2515	lpfc_destroy_vport_work_array(phba, vports);
2516}
2517
2518/**
2519 * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
2520 * @phba: pointer to lpfc hba data structure.
2521 *
2522 * This routine is to free all the SCSI buffers and IOCBs from the driver
2523 * list back to kernel. It is called from lpfc_pci_remove_one to free
2524 * the internal resources before the device is removed from the system.
2525 *
2526 * Return codes
2527 *   0 - successful (for now, it always returns 0)
2528 **/
2529static int
2530lpfc_scsi_free(struct lpfc_hba *phba)
2531{
2532	struct lpfc_scsi_buf *sb, *sb_next;
2533	struct lpfc_iocbq *io, *io_next;
2534
2535	spin_lock_irq(&phba->hbalock);
2536	/* Release all the lpfc_scsi_bufs maintained by this host. */
2537	spin_lock(&phba->scsi_buf_list_lock);
2538	list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
2539		list_del(&sb->list);
2540		pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
2541			      sb->dma_handle);
2542		kfree(sb);
2543		phba->total_scsi_bufs--;
2544	}
2545	spin_unlock(&phba->scsi_buf_list_lock);
2546
2547	/* Release all the lpfc_iocbq entries maintained by this host. */
2548	list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
2549		list_del(&io->list);
2550		kfree(io);
2551		phba->total_iocbq_bufs--;
2552	}
2553	spin_unlock_irq(&phba->hbalock);
2554	return 0;
2555}
2556
2557/**
2558 * lpfc_create_port - Create an FC port
2559 * @phba: pointer to lpfc hba data structure.
2560 * @instance: a unique integer ID to this FC port.
2561 * @dev: pointer to the device data structure.
2562 *
2563 * This routine creates a FC port for the upper layer protocol. The FC port
2564 * can be created on top of either a physical port or a virtual port provided
2565 * by the HBA. This routine also allocates a SCSI host data structure (shost)
2566 * and associates the FC port created before adding the shost into the SCSI
2567 * layer.
2568 *
2569 * Return codes
2570 *   @vport - pointer to the virtual N_Port data structure.
2571 *   NULL - port create failed.
2572 **/
2573struct lpfc_vport *
2574lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
2575{
2576	struct lpfc_vport *vport;
2577	struct Scsi_Host  *shost;
2578	int error = 0;
2579
2580	if (dev != &phba->pcidev->dev)
2581		shost = scsi_host_alloc(&lpfc_vport_template,
2582					sizeof(struct lpfc_vport));
2583	else
2584		shost = scsi_host_alloc(&lpfc_template,
2585					sizeof(struct lpfc_vport));
2586	if (!shost)
2587		goto out;
2588
2589	vport = (struct lpfc_vport *) shost->hostdata;
2590	vport->phba = phba;
2591	vport->load_flag |= FC_LOADING;
2592	vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2593	vport->fc_rscn_flush = 0;
2594
2595	lpfc_get_vport_cfgparam(vport);
2596	shost->unique_id = instance;
2597	shost->max_id = LPFC_MAX_TARGET;
2598	shost->max_lun = vport->cfg_max_luns;
2599	shost->this_id = -1;
2600	shost->max_cmd_len = 16;
2601	if (phba->sli_rev == LPFC_SLI_REV4) {
2602		shost->dma_boundary =
2603			phba->sli4_hba.pc_sli4_params.sge_supp_len-1;
2604		shost->sg_tablesize = phba->cfg_sg_seg_cnt;
2605	}
2606
2607	/*
2608	 * Set initial can_queue value since 0 is no longer supported and
2609	 * scsi_add_host will fail. This will be adjusted later based on the
2610	 * max xri value determined in hba setup.
2611	 */
2612	shost->can_queue = phba->cfg_hba_queue_depth - 10;
2613	if (dev != &phba->pcidev->dev) {
2614		shost->transportt = lpfc_vport_transport_template;
2615		vport->port_type = LPFC_NPIV_PORT;
2616	} else {
2617		shost->transportt = lpfc_transport_template;
2618		vport->port_type = LPFC_PHYSICAL_PORT;
2619	}
2620
2621	/* Initialize all internally managed lists. */
2622	INIT_LIST_HEAD(&vport->fc_nodes);
2623	INIT_LIST_HEAD(&vport->rcv_buffer_list);
2624	spin_lock_init(&vport->work_port_lock);
2625
2626	init_timer(&vport->fc_disctmo);
2627	vport->fc_disctmo.function = lpfc_disc_timeout;
2628	vport->fc_disctmo.data = (unsigned long)vport;
2629
2630	init_timer(&vport->fc_fdmitmo);
2631	vport->fc_fdmitmo.function = lpfc_fdmi_tmo;
2632	vport->fc_fdmitmo.data = (unsigned long)vport;
2633
2634	init_timer(&vport->els_tmofunc);
2635	vport->els_tmofunc.function = lpfc_els_timeout;
2636	vport->els_tmofunc.data = (unsigned long)vport;
2637	error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
2638	if (error)
2639		goto out_put_shost;
2640
2641	spin_lock_irq(&phba->hbalock);
2642	list_add_tail(&vport->listentry, &phba->port_list);
2643	spin_unlock_irq(&phba->hbalock);
2644	return vport;
2645
2646out_put_shost:
2647	scsi_host_put(shost);
2648out:
2649	return NULL;
2650}
2651
2652/**
2653 * destroy_port -  destroy an FC port
2654 * @vport: pointer to an lpfc virtual N_Port data structure.
2655 *
2656 * This routine destroys a FC port from the upper layer protocol. All the
2657 * resources associated with the port are released.
2658 **/
2659void
2660destroy_port(struct lpfc_vport *vport)
2661{
2662	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2663	struct lpfc_hba  *phba = vport->phba;
2664
2665	lpfc_debugfs_terminate(vport);
2666	fc_remove_host(shost);
2667	scsi_remove_host(shost);
2668
2669	spin_lock_irq(&phba->hbalock);
2670	list_del_init(&vport->listentry);
2671	spin_unlock_irq(&phba->hbalock);
2672
2673	lpfc_cleanup(vport);
2674	return;
2675}
2676
2677/**
2678 * lpfc_get_instance - Get a unique integer ID
2679 *
2680 * This routine allocates a unique integer ID from lpfc_hba_index pool. It
2681 * uses the kernel idr facility to perform the task.
2682 *
2683 * Return codes:
2684 *   instance - a unique integer ID allocated as the new instance.
2685 *   -1 - lpfc get instance failed.
2686 **/
2687int
2688lpfc_get_instance(void)
2689{
2690	int instance = 0;
2691
2692	/* Assign an unused number */
2693	if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL))
2694		return -1;
2695	if (idr_get_new(&lpfc_hba_index, NULL, &instance))
2696		return -1;
2697	return instance;
2698}
2699
2700/**
2701 * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
2702 * @shost: pointer to SCSI host data structure.
2703 * @time: elapsed time of the scan in jiffies.
2704 *
2705 * This routine is called by the SCSI layer with a SCSI host to determine
2706 * whether the scan host is finished.
2707 *
2708 * Note: there is no scan_start function as adapter initialization will have
2709 * asynchronously kicked off the link initialization.
2710 *
2711 * Return codes
2712 *   0 - SCSI host scan is not over yet.
2713 *   1 - SCSI host scan is over.
2714 **/
2715int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2716{
2717	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2718	struct lpfc_hba   *phba = vport->phba;
2719	int stat = 0;
2720
2721	spin_lock_irq(shost->host_lock);
2722
2723	if (vport->load_flag & FC_UNLOADING) {
2724		stat = 1;
2725		goto finished;
2726	}
2727	if (time >= 30 * HZ) {
2728		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2729				"0461 Scanning longer than 30 "
2730				"seconds.  Continuing initialization\n");
2731		stat = 1;
2732		goto finished;
2733	}
2734	if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
2735		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2736				"0465 Link down longer than 15 "
2737				"seconds.  Continuing initialization\n");
2738		stat = 1;
2739		goto finished;
2740	}
2741
2742	if (vport->port_state != LPFC_VPORT_READY)
2743		goto finished;
2744	if (vport->num_disc_nodes || vport->fc_prli_sent)
2745		goto finished;
2746	if (vport->fc_map_cnt == 0 && time < 2 * HZ)
2747		goto finished;
2748	if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
2749		goto finished;
2750
2751	stat = 1;
2752
2753finished:
2754	spin_unlock_irq(shost->host_lock);
2755	return stat;
2756}
2757
2758/**
2759 * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
2760 * @shost: pointer to SCSI host data structure.
2761 *
2762 * This routine initializes a given SCSI host attributes on a FC port. The
2763 * SCSI host can be either on top of a physical port or a virtual port.
2764 **/
2765void lpfc_host_attrib_init(struct Scsi_Host *shost)
2766{
2767	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2768	struct lpfc_hba   *phba = vport->phba;
2769	/*
2770	 * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
2771	 */
2772
2773	fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
2774	fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
2775	fc_host_supported_classes(shost) = FC_COS_CLASS3;
2776
2777	memset(fc_host_supported_fc4s(shost), 0,
2778	       sizeof(fc_host_supported_fc4s(shost)));
2779	fc_host_supported_fc4s(shost)[2] = 1;
2780	fc_host_supported_fc4s(shost)[7] = 1;
2781
2782	lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
2783				 sizeof fc_host_symbolic_name(shost));
2784
2785	fc_host_supported_speeds(shost) = 0;
2786	if (phba->lmt & LMT_10Gb)
2787		fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
2788	if (phba->lmt & LMT_8Gb)
2789		fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
2790	if (phba->lmt & LMT_4Gb)
2791		fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
2792	if (phba->lmt & LMT_2Gb)
2793		fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
2794	if (phba->lmt & LMT_1Gb)
2795		fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
2796
2797	fc_host_maxframe_size(shost) =
2798		(((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
2799		(uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
2800
2801	/* This value is also unchanging */
2802	memset(fc_host_active_fc4s(shost), 0,
2803	       sizeof(fc_host_active_fc4s(shost)));
2804	fc_host_active_fc4s(shost)[2] = 1;
2805	fc_host_active_fc4s(shost)[7] = 1;
2806
2807	fc_host_max_npiv_vports(shost) = phba->max_vpi;
2808	spin_lock_irq(shost->host_lock);
2809	vport->load_flag &= ~FC_LOADING;
2810	spin_unlock_irq(shost->host_lock);
2811}
2812
2813/**
2814 * lpfc_stop_port_s3 - Stop SLI3 device port
2815 * @phba: pointer to lpfc hba data structure.
2816 *
2817 * This routine is invoked to stop an SLI3 device port, it stops the device
2818 * from generating interrupts and stops the device driver's timers for the
2819 * device.
2820 **/
2821static void
2822lpfc_stop_port_s3(struct lpfc_hba *phba)
2823{
2824	/* Clear all interrupt enable conditions */
2825	writel(0, phba->HCregaddr);
2826	readl(phba->HCregaddr); /* flush */
2827	/* Clear all pending interrupts */
2828	writel(0xffffffff, phba->HAregaddr);
2829	readl(phba->HAregaddr); /* flush */
2830
2831	/* Reset some HBA SLI setup states */
2832	lpfc_stop_hba_timers(phba);
2833	phba->pport->work_port_events = 0;
2834}
2835
2836/**
2837 * lpfc_stop_port_s4 - Stop SLI4 device port
2838 * @phba: pointer to lpfc hba data structure.
2839 *
2840 * This routine is invoked to stop an SLI4 device port, it stops the device
2841 * from generating interrupts and stops the device driver's timers for the
2842 * device.
2843 **/
2844static void
2845lpfc_stop_port_s4(struct lpfc_hba *phba)
2846{
2847	/* Reset some HBA SLI4 setup states */
2848	lpfc_stop_hba_timers(phba);
2849	phba->pport->work_port_events = 0;
2850	phba->sli4_hba.intr_enable = 0;
2851}
2852
2853/**
2854 * lpfc_stop_port - Wrapper function for stopping hba port
2855 * @phba: Pointer to HBA context object.
2856 *
2857 * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
2858 * the API jump table function pointer from the lpfc_hba struct.
2859 **/
2860void
2861lpfc_stop_port(struct lpfc_hba *phba)
2862{
2863	phba->lpfc_stop_port(phba);
2864}
2865
2866/**
2867 * lpfc_sli4_remove_dflt_fcf - Remove the driver default fcf record from the port.
2868 * @phba: pointer to lpfc hba data structure.
2869 *
2870 * This routine is invoked to remove the driver default fcf record from
2871 * the port.  This routine currently acts on FCF Index 0.
2872 *
2873 **/
2874void
2875lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
2876{
2877	int rc = 0;
2878	LPFC_MBOXQ_t *mboxq;
2879	struct lpfc_mbx_del_fcf_tbl_entry *del_fcf_record;
2880	uint32_t mbox_tmo, req_len;
2881	uint32_t shdr_status, shdr_add_status;
2882
2883	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2884	if (!mboxq) {
2885		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2886			"2020 Failed to allocate mbox for ADD_FCF cmd\n");
2887		return;
2888	}
2889
2890	req_len = sizeof(struct lpfc_mbx_del_fcf_tbl_entry) -
2891		  sizeof(struct lpfc_sli4_cfg_mhdr);
2892	rc = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
2893			      LPFC_MBOX_OPCODE_FCOE_DELETE_FCF,
2894			      req_len, LPFC_SLI4_MBX_EMBED);
2895	/*
2896	 * In phase 1, there is a single FCF index, 0.  In phase2, the driver
2897	 * supports multiple FCF indices.
2898	 */
2899	del_fcf_record = &mboxq->u.mqe.un.del_fcf_entry;
2900	bf_set(lpfc_mbx_del_fcf_tbl_count, del_fcf_record, 1);
2901	bf_set(lpfc_mbx_del_fcf_tbl_index, del_fcf_record,
2902	       phba->fcf.current_rec.fcf_indx);
2903
2904	if (!phba->sli4_hba.intr_enable)
2905		rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
2906	else {
2907		mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
2908		rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
2909	}
2910	/* The IOCTL status is embedded in the mailbox subheader. */
2911	shdr_status = bf_get(lpfc_mbox_hdr_status,
2912			     &del_fcf_record->header.cfg_shdr.response);
2913	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
2914				 &del_fcf_record->header.cfg_shdr.response);
2915	if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
2916		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2917				"2516 DEL FCF of default FCF Index failed "
2918				"mbx status x%x, status x%x add_status x%x\n",
2919				rc, shdr_status, shdr_add_status);
2920	}
2921	if (rc != MBX_TIMEOUT)
2922		mempool_free(mboxq, phba->mbox_mem_pool);
2923}
2924
2925/**
2926 * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
2927 * @phba: Pointer to hba for which this call is being executed.
2928 *
2929 * This routine starts the timer waiting for the FCF rediscovery to complete.
2930 **/
2931void
2932lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
2933{
2934	unsigned long fcf_redisc_wait_tmo =
2935		(jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
2936	/* Start fcf rediscovery wait period timer */
2937	mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
2938	spin_lock_irq(&phba->hbalock);
2939	/* Allow action to new fcf asynchronous event */
2940	phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
2941	/* Mark the FCF rediscovery pending state */
2942	phba->fcf.fcf_flag |= FCF_REDISC_PEND;
2943	spin_unlock_irq(&phba->hbalock);
2944}
2945
2946/**
2947 * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
2948 * @ptr: Map to lpfc_hba data structure pointer.
2949 *
2950 * This routine is invoked when waiting for FCF table rediscover has been
2951 * timed out. If new FCF record(s) has (have) been discovered during the
2952 * wait period, a new FCF event shall be added to the FCOE async event
2953 * list, and then worker thread shall be waked up for processing from the
2954 * worker thread context.
2955 **/
2956void
2957lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
2958{
2959	struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
2960
2961	/* Don't send FCF rediscovery event if timer cancelled */
2962	spin_lock_irq(&phba->hbalock);
2963	if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2964		spin_unlock_irq(&phba->hbalock);
2965		return;
2966	}
2967	/* Clear FCF rediscovery timer pending flag */
2968	phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2969	/* FCF rediscovery event to worker thread */
2970	phba->fcf.fcf_flag |= FCF_REDISC_EVT;
2971	spin_unlock_irq(&phba->hbalock);
2972	lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2973			"2776 FCF rediscover wait timer expired, post "
2974			"a worker thread event for FCF table scan\n");
2975	/* wake up worker thread */
2976	lpfc_worker_wake_up(phba);
2977}
2978
2979/**
2980 * lpfc_sli4_fw_cfg_check - Read the firmware config and verify FCoE support
2981 * @phba: pointer to lpfc hba data structure.
2982 *
2983 * This function uses the QUERY_FW_CFG mailbox command to determine if the
2984 * firmware loaded supports FCoE. A return of zero indicates that the mailbox
2985 * was successful and the firmware supports FCoE. Any other return indicates
2986 * a error. It is assumed that this function will be called before interrupts
2987 * are enabled.
2988 **/
2989static int
2990lpfc_sli4_fw_cfg_check(struct lpfc_hba *phba)
2991{
2992	int rc = 0;
2993	LPFC_MBOXQ_t *mboxq;
2994	struct lpfc_mbx_query_fw_cfg *query_fw_cfg;
2995	uint32_t length;
2996	uint32_t shdr_status, shdr_add_status;
2997
2998	mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2999	if (!mboxq) {
3000		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3001				"2621 Failed to allocate mbox for "
3002				"query firmware config cmd\n");
3003		return -ENOMEM;
3004	}
3005	query_fw_cfg = &mboxq->u.mqe.un.query_fw_cfg;
3006	length = (sizeof(struct lpfc_mbx_query_fw_cfg) -
3007		  sizeof(struct lpfc_sli4_cfg_mhdr));
3008	lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
3009			 LPFC_MBOX_OPCODE_QUERY_FW_CFG,
3010			 length, LPFC_SLI4_MBX_EMBED);
3011	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
3012	/* The IOCTL status is embedded in the mailbox subheader. */
3013	shdr_status = bf_get(lpfc_mbox_hdr_status,
3014			     &query_fw_cfg->header.cfg_shdr.response);
3015	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
3016				 &query_fw_cfg->header.cfg_shdr.response);
3017	if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
3018		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3019				"2622 Query Firmware Config failed "
3020				"mbx status x%x, status x%x add_status x%x\n",
3021				rc, shdr_status, shdr_add_status);
3022		return -EINVAL;
3023	}
3024	if (!bf_get(lpfc_function_mode_fcoe_i, query_fw_cfg)) {
3025		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3026				"2623 FCoE Function not supported by firmware. "
3027				"Function mode = %08x\n",
3028				query_fw_cfg->function_mode);
3029		return -EINVAL;
3030	}
3031	if (rc != MBX_TIMEOUT)
3032		mempool_free(mboxq, phba->mbox_mem_pool);
3033	return 0;
3034}
3035
3036/**
3037 * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
3038 * @phba: pointer to lpfc hba data structure.
3039 * @acqe_link: pointer to the async link completion queue entry.
3040 *
3041 * This routine is to parse the SLI4 link-attention link fault code and
3042 * translate it into the base driver's read link attention mailbox command
3043 * status.
3044 *
3045 * Return: Link-attention status in terms of base driver's coding.
3046 **/
3047static uint16_t
3048lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba,
3049			   struct lpfc_acqe_link *acqe_link)
3050{
3051	uint16_t latt_fault;
3052
3053	switch (bf_get(lpfc_acqe_link_fault, acqe_link)) {
3054	case LPFC_ASYNC_LINK_FAULT_NONE:
3055	case LPFC_ASYNC_LINK_FAULT_LOCAL:
3056	case LPFC_ASYNC_LINK_FAULT_REMOTE:
3057		latt_fault = 0;
3058		break;
3059	default:
3060		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3061				"0398 Invalid link fault code: x%x\n",
3062				bf_get(lpfc_acqe_link_fault, acqe_link));
3063		latt_fault = MBXERR_ERROR;
3064		break;
3065	}
3066	return latt_fault;
3067}
3068
3069/**
3070 * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
3071 * @phba: pointer to lpfc hba data structure.
3072 * @acqe_link: pointer to the async link completion queue entry.
3073 *
3074 * This routine is to parse the SLI4 link attention type and translate it
3075 * into the base driver's link attention type coding.
3076 *
3077 * Return: Link attention type in terms of base driver's coding.
3078 **/
3079static uint8_t
3080lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
3081			  struct lpfc_acqe_link *acqe_link)
3082{
3083	uint8_t att_type;
3084
3085	switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
3086	case LPFC_ASYNC_LINK_STATUS_DOWN:
3087	case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
3088		att_type = AT_LINK_DOWN;
3089		break;
3090	case LPFC_ASYNC_LINK_STATUS_UP:
3091		/* Ignore physical link up events - wait for logical link up */
3092		att_type = AT_RESERVED;
3093		break;
3094	case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
3095		att_type = AT_LINK_UP;
3096		break;
3097	default:
3098		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3099				"0399 Invalid link attention type: x%x\n",
3100				bf_get(lpfc_acqe_link_status, acqe_link));
3101		att_type = AT_RESERVED;
3102		break;
3103	}
3104	return att_type;
3105}
3106
3107/**
3108 * lpfc_sli4_parse_latt_link_speed - Parse sli4 link-attention link speed
3109 * @phba: pointer to lpfc hba data structure.
3110 * @acqe_link: pointer to the async link completion queue entry.
3111 *
3112 * This routine is to parse the SLI4 link-attention link speed and translate
3113 * it into the base driver's link-attention link speed coding.
3114 *
3115 * Return: Link-attention link speed in terms of base driver's coding.
3116 **/
3117static uint8_t
3118lpfc_sli4_parse_latt_link_speed(struct lpfc_hba *phba,
3119				struct lpfc_acqe_link *acqe_link)
3120{
3121	uint8_t link_speed;
3122
3123	switch (bf_get(lpfc_acqe_link_speed, acqe_link)) {
3124	case LPFC_ASYNC_LINK_SPEED_ZERO:
3125		link_speed = LA_UNKNW_LINK;
3126		break;
3127	case LPFC_ASYNC_LINK_SPEED_10MBPS:
3128		link_speed = LA_UNKNW_LINK;
3129		break;
3130	case LPFC_ASYNC_LINK_SPEED_100MBPS:
3131		link_speed = LA_UNKNW_LINK;
3132		break;
3133	case LPFC_ASYNC_LINK_SPEED_1GBPS:
3134		link_speed = LA_1GHZ_LINK;
3135		break;
3136	case LPFC_ASYNC_LINK_SPEED_10GBPS:
3137		link_speed = LA_10GHZ_LINK;
3138		break;
3139	default:
3140		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3141				"0483 Invalid link-attention link speed: x%x\n",
3142				bf_get(lpfc_acqe_link_speed, acqe_link));
3143		link_speed = LA_UNKNW_LINK;
3144		break;
3145	}
3146	return link_speed;
3147}
3148
3149/**
3150 * lpfc_sli4_async_link_evt - Process the asynchronous link event
3151 * @phba: pointer to lpfc hba data structure.
3152 * @acqe_link: pointer to the async link completion queue entry.
3153 *
3154 * This routine is to handle the SLI4 asynchronous link event.
3155 **/
3156static void
3157lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
3158			 struct lpfc_acqe_link *acqe_link)
3159{
3160	struct lpfc_dmabuf *mp;
3161	LPFC_MBOXQ_t *pmb;
3162	MAILBOX_t *mb;
3163	READ_LA_VAR *la;
3164	uint8_t att_type;
3165
3166	att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
3167	if (att_type != AT_LINK_DOWN && att_type != AT_LINK_UP)
3168		return;
3169	phba->fcoe_eventtag = acqe_link->event_tag;
3170	pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3171	if (!pmb) {
3172		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3173				"0395 The mboxq allocation failed\n");
3174		return;
3175	}
3176	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
3177	if (!mp) {
3178		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3179				"0396 The lpfc_dmabuf allocation failed\n");
3180		goto out_free_pmb;
3181	}
3182	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3183	if (!mp->virt) {
3184		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3185				"0397 The mbuf allocation failed\n");
3186		goto out_free_dmabuf;
3187	}
3188
3189	/* Cleanup any outstanding ELS commands */
3190	lpfc_els_flush_all_cmd(phba);
3191
3192	/* Block ELS IOCBs until we have done process link event */
3193	phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
3194
3195	/* Update link event statistics */
3196	phba->sli.slistat.link_event++;
3197
3198	/* Create pseudo lpfc_handle_latt mailbox command from link ACQE */
3199	lpfc_read_la(phba, pmb, mp);
3200	pmb->vport = phba->pport;
3201
3202	/* Parse and translate status field */
3203	mb = &pmb->u.mb;
3204	mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
3205
3206	/* Parse and translate link attention fields */
3207	la = (READ_LA_VAR *) &pmb->u.mb.un.varReadLA;
3208	la->eventTag = acqe_link->event_tag;
3209	la->attType = att_type;
3210	la->UlnkSpeed = lpfc_sli4_parse_latt_link_speed(phba, acqe_link);
3211
3212	/* Fake the the following irrelvant fields */
3213	la->topology = TOPOLOGY_PT_PT;
3214	la->granted_AL_PA = 0;
3215	la->il = 0;
3216	la->pb = 0;
3217	la->fa = 0;
3218	la->mm = 0;
3219
3220	/* Keep the link status for extra SLI4 state machine reference */
3221	phba->sli4_hba.link_state.speed =
3222				bf_get(lpfc_acqe_link_speed, acqe_link);
3223	phba->sli4_hba.link_state.duplex =
3224				bf_get(lpfc_acqe_link_duplex, acqe_link);
3225	phba->sli4_hba.link_state.status =
3226				bf_get(lpfc_acqe_link_status, acqe_link);
3227	phba->sli4_hba.link_state.physical =
3228				bf_get(lpfc_acqe_link_physical, acqe_link);
3229	phba->sli4_hba.link_state.fault =
3230				bf_get(lpfc_acqe_link_fault, acqe_link);
3231	phba->sli4_hba.link_state.logical_speed =
3232				bf_get(lpfc_acqe_qos_link_speed, acqe_link);
3233
3234	/* Invoke the lpfc_handle_latt mailbox command callback function */
3235	lpfc_mbx_cmpl_read_la(phba, pmb);
3236
3237	return;
3238
3239out_free_dmabuf:
3240	kfree(mp);
3241out_free_pmb:
3242	mempool_free(pmb, phba->mbox_mem_pool);
3243}
3244
3245/**
3246 * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
3247 * @vport: pointer to vport data structure.
3248 *
3249 * This routine is to perform Clear Virtual Link (CVL) on a vport in
3250 * response to a CVL event.
3251 *
3252 * Return the pointer to the ndlp with the vport if successful, otherwise
3253 * return NULL.
3254 **/
3255static struct lpfc_nodelist *
3256lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
3257{
3258	struct lpfc_nodelist *ndlp;
3259	struct Scsi_Host *shost;
3260	struct lpfc_hba *phba;
3261
3262	if (!vport)
3263		return NULL;
3264	phba = vport->phba;
3265	if (!phba)
3266		return NULL;
3267	ndlp = lpfc_findnode_did(vport, Fabric_DID);
3268	if (!ndlp) {
3269		/* Cannot find existing Fabric ndlp, so allocate a new one */
3270		ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3271		if (!ndlp)
3272			return 0;
3273		lpfc_nlp_init(vport, ndlp, Fabric_DID);
3274		/* Set the node type */
3275		ndlp->nlp_type |= NLP_FABRIC;
3276		/* Put ndlp onto node list */
3277		lpfc_enqueue_node(vport, ndlp);
3278	} else if (!NLP_CHK_NODE_ACT(ndlp)) {
3279		/* re-setup ndlp without removing from node list */
3280		ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
3281		if (!ndlp)
3282			return 0;
3283	}
3284	if (phba->pport->port_state <= LPFC_FLOGI)
3285		return NULL;
3286	/* If virtual link is not yet instantiated ignore CVL */
3287	if (vport->port_state <= LPFC_FDISC)
3288		return NULL;
3289	shost = lpfc_shost_from_vport(vport);
3290	if (!shost)
3291		return NULL;
3292	lpfc_linkdown_port(vport);
3293	lpfc_cleanup_pending_mbox(vport);
3294	spin_lock_irq(shost->host_lock);
3295	vport->fc_flag |= FC_VPORT_CVL_RCVD;
3296	spin_unlock_irq(shost->host_lock);
3297
3298	return ndlp;
3299}
3300
3301/**
3302 * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
3303 * @vport: pointer to lpfc hba data structure.
3304 *
3305 * This routine is to perform Clear Virtual Link (CVL) on all vports in
3306 * response to a FCF dead event.
3307 **/
3308static void
3309lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
3310{
3311	struct lpfc_vport **vports;
3312	int i;
3313
3314	vports = lpfc_create_vport_work_array(phba);
3315	if (vports)
3316		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
3317			lpfc_sli4_perform_vport_cvl(vports[i]);
3318	lpfc_destroy_vport_work_array(phba, vports);
3319}
3320
3321/**
3322 * lpfc_sli4_async_fcoe_evt - Process the asynchronous fcoe event
3323 * @phba: pointer to lpfc hba data structure.
3324 * @acqe_link: pointer to the async fcoe completion queue entry.
3325 *
3326 * This routine is to handle the SLI4 asynchronous fcoe event.
3327 **/
3328static void
3329lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
3330			 struct lpfc_acqe_fcoe *acqe_fcoe)
3331{
3332	uint8_t event_type = bf_get(lpfc_acqe_fcoe_event_type, acqe_fcoe);
3333	int rc;
3334	struct lpfc_vport *vport;
3335	struct lpfc_nodelist *ndlp;
3336	struct Scsi_Host  *shost;
3337	int active_vlink_present;
3338	struct lpfc_vport **vports;
3339	int i;
3340
3341	phba->fc_eventTag = acqe_fcoe->event_tag;
3342	phba->fcoe_eventtag = acqe_fcoe->event_tag;
3343	switch (event_type) {
3344	case LPFC_FCOE_EVENT_TYPE_NEW_FCF:
3345	case LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD:
3346		if (event_type == LPFC_FCOE_EVENT_TYPE_NEW_FCF)
3347			lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
3348					LOG_DISCOVERY,
3349					"2546 New FCF found event: "
3350					"evt_tag:x%x, fcf_index:x%x\n",
3351					acqe_fcoe->event_tag,
3352					acqe_fcoe->index);
3353		else
3354			lpfc_printf_log(phba, KERN_WARNING, LOG_FIP |
3355					LOG_DISCOVERY,
3356					"2788 FCF parameter modified event: "
3357					"evt_tag:x%x, fcf_index:x%x\n",
3358					acqe_fcoe->event_tag,
3359					acqe_fcoe->index);
3360		spin_lock_irq(&phba->hbalock);
3361		if ((phba->fcf.fcf_flag & FCF_SCAN_DONE) ||
3362		    (phba->hba_flag & FCF_DISC_INPROGRESS)) {
3363			/*
3364			 * If the current FCF is in discovered state or
3365			 * FCF discovery is in progress, do nothing.
3366			 */
3367			spin_unlock_irq(&phba->hbalock);
3368			break;
3369		}
3370
3371		if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
3372			/*
3373			 * If fast FCF failover rescan event is pending,
3374			 * do nothing.
3375			 */
3376			spin_unlock_irq(&phba->hbalock);
3377			break;
3378		}
3379		spin_unlock_irq(&phba->hbalock);
3380
3381		if ((phba->fcf.fcf_flag & FCF_DISCOVERY) &&
3382		    !(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
3383			/*
3384			 * During period of FCF discovery, read the FCF
3385			 * table record indexed by the event to update
3386			 * FCF round robin failover eligible FCF bmask.
3387			 */
3388			lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
3389					LOG_DISCOVERY,
3390					"2779 Read new FCF record with "
3391					"fcf_index:x%x for updating FCF "
3392					"round robin failover bmask\n",
3393					acqe_fcoe->index);
3394			rc = lpfc_sli4_read_fcf_rec(phba, acqe_fcoe->index);
3395		}
3396
3397		/* Otherwise, scan the entire FCF table and re-discover SAN */
3398		lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
3399				"2770 Start FCF table scan due to new FCF "
3400				"event: evt_tag:x%x, fcf_index:x%x\n",
3401				acqe_fcoe->event_tag, acqe_fcoe->index);
3402		rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
3403						     LPFC_FCOE_FCF_GET_FIRST);
3404		if (rc)
3405			lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
3406					"2547 Issue FCF scan read FCF mailbox "
3407					"command failed 0x%x\n", rc);
3408		break;
3409
3410	case LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL:
3411		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3412			"2548 FCF Table full count 0x%x tag 0x%x\n",
3413			bf_get(lpfc_acqe_fcoe_fcf_count, acqe_fcoe),
3414			acqe_fcoe->event_tag);
3415		break;
3416
3417	case LPFC_FCOE_EVENT_TYPE_FCF_DEAD:
3418		lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
3419			"2549 FCF disconnected from network index 0x%x"
3420			" tag 0x%x\n", acqe_fcoe->index,
3421			acqe_fcoe->event_tag);
3422		/* If the event is not for currently used fcf do nothing */
3423		if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
3424			break;
3425		/* We request port to rediscover the entire FCF table for
3426		 * a fast recovery from case that the current FCF record
3427		 * is no longer valid if we are not in the middle of FCF
3428		 * failover process already.
3429		 */
3430		spin_lock_irq(&phba->hbalock);
3431		if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
3432			spin_unlock_irq(&phba->hbalock);
3433			/* Update FLOGI FCF failover eligible FCF bmask */
3434			lpfc_sli4_fcf_rr_index_clear(phba, acqe_fcoe->index);
3435			break;
3436		}
3437		/* Mark the fast failover process in progress */
3438		phba->fcf.fcf_flag |= FCF_DEAD_DISC;
3439		spin_unlock_irq(&phba->hbalock);
3440		lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
3441				"2771 Start FCF fast failover process due to "
3442				"FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
3443				"\n", acqe_fcoe->event_tag, acqe_fcoe->index);
3444		rc = lpfc_sli4_redisc_fcf_table(phba);
3445		if (rc) {
3446			lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
3447					LOG_DISCOVERY,
3448					"2772 Issue FCF rediscover mabilbox "
3449					"command failed, fail through to FCF "
3450					"dead event\n");
3451			spin_lock_irq(&phba->hbalock);
3452			phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
3453			spin_unlock_irq(&phba->hbalock);
3454			/*
3455			 * Last resort will fail over by treating this
3456			 * as a link down to FCF registration.
3457			 */
3458			lpfc_sli4_fcf_dead_failthrough(phba);
3459		} else
3460			/* Handling fast FCF failover to a DEAD FCF event
3461			 * is considered equalivant to receiving CVL to all
3462			 * vports.
3463			 */
3464			lpfc_sli4_perform_all_vport_cvl(phba);
3465		break;
3466	case LPFC_FCOE_EVENT_TYPE_CVL:
3467		lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
3468			"2718 Clear Virtual Link Received for VPI 0x%x"
3469			" tag 0x%x\n", acqe_fcoe->index, acqe_fcoe->event_tag);
3470		vport = lpfc_find_vport_by_vpid(phba,
3471				acqe_fcoe->index - phba->vpi_base);
3472		ndlp = lpfc_sli4_perform_vport_cvl(vport);
3473		if (!ndlp)
3474			break;
3475		active_vlink_present = 0;
3476
3477		vports = lpfc_create_vport_work_array(phba);
3478		if (vports) {
3479			for (i = 0; i <= phba->max_vports && vports[i] != NULL;
3480					i++) {
3481				if ((!(vports[i]->fc_flag &
3482					FC_VPORT_CVL_RCVD)) &&
3483					(vports[i]->port_state > LPFC_FDISC)) {
3484					active_vlink_present = 1;
3485					break;
3486				}
3487			}
3488			lpfc_destroy_vport_work_array(phba, vports);
3489		}
3490
3491		if (active_vlink_present) {
3492			/*
3493			 * If there are other active VLinks present,
3494			 * re-instantiate the Vlink using FDISC.
3495			 */
3496			mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
3497			shost = lpfc_shost_from_vport(vport);
3498			spin_lock_irq(shost->host_lock);
3499			ndlp->nlp_flag |= NLP_DELAY_TMO;
3500			spin_unlock_irq(shost->host_lock);
3501			ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
3502			vport->port_state = LPFC_FDISC;
3503		} else {
3504			/*
3505			 * Otherwise, we request port to rediscover
3506			 * the entire FCF table for a fast recovery
3507			 * from possible case that the current FCF
3508			 * is no longer valid if we are not already
3509			 * in the FCF failover process.
3510			 */
3511			spin_lock_irq(&phba->hbalock);
3512			if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
3513				spin_unlock_irq(&phba->hbalock);
3514				break;
3515			}
3516			/* Mark the fast failover process in progress */
3517			phba->fcf.fcf_flag |= FCF_ACVL_DISC;
3518			spin_unlock_irq(&phba->hbalock);
3519			lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
3520					LOG_DISCOVERY,
3521					"2773 Start FCF fast failover due "
3522					"to CVL event: evt_tag:x%x\n",
3523					acqe_fcoe->event_tag);
3524			rc = lpfc_sli4_redisc_fcf_table(phba);
3525			if (rc) {
3526				lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
3527						LOG_DISCOVERY,
3528						"2774 Issue FCF rediscover "
3529						"mabilbox command failed, "
3530						"through to CVL event\n");
3531				spin_lock_irq(&phba->hbalock);
3532				phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
3533				spin_unlock_irq(&phba->hbalock);
3534				/*
3535				 * Last resort will be re-try on the
3536				 * the current registered FCF entry.
3537				 */
3538				lpfc_retry_pport_discovery(phba);
3539			}
3540		}
3541		break;
3542	default:
3543		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3544			"0288 Unknown FCoE event type 0x%x event tag "
3545			"0x%x\n", event_type, acqe_fcoe->event_tag);
3546		break;
3547	}
3548}
3549
3550/**
3551 * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
3552 * @phba: pointer to lpfc hba data structure.
3553 * @acqe_link: pointer to the async dcbx completion queue entry.
3554 *
3555 * This routine is to handle the SLI4 asynchronous dcbx event.
3556 **/
3557static void
3558lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
3559			 struct lpfc_acqe_dcbx *acqe_dcbx)
3560{
3561	phba->fc_eventTag = acqe_dcbx->event_tag;
3562	lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3563			"0290 The SLI4 DCBX asynchronous event is not "
3564			"handled yet\n");
3565}
3566
3567/**
3568 * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
3569 * @phba: pointer to lpfc hba data structure.
3570 * @acqe_link: pointer to the async grp5 completion queue entry.
3571 *
3572 * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
3573 * is an asynchronous notified of a logical link speed change.  The Port
3574 * reports the logical link speed in units of 10Mbps.
3575 **/
3576static void
3577lpfc_sli4_async_grp5_evt(struct lpfc_hba *phba,
3578			 struct lpfc_acqe_grp5 *acqe_grp5)
3579{
3580	uint16_t prev_ll_spd;
3581
3582	phba->fc_eventTag = acqe_grp5->event_tag;
3583	phba->fcoe_eventtag = acqe_grp5->event_tag;
3584	prev_ll_spd = phba->sli4_hba.link_state.logical_speed;
3585	phba->sli4_hba.link_state.logical_speed =
3586		(bf_get(lpfc_acqe_grp5_llink_spd, acqe_grp5));
3587	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3588			"2789 GRP5 Async Event: Updating logical link speed "
3589			"from %dMbps to %dMbps\n", (prev_ll_spd * 10),
3590			(phba->sli4_hba.link_state.logical_speed*10));
3591}
3592
3593/**
3594 * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
3595 * @phba: pointer to lpfc hba data structure.
3596 *
3597 * This routine is invoked by the worker thread to process all the pending
3598 * SLI4 asynchronous events.
3599 **/
3600void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
3601{
3602	struct lpfc_cq_event *cq_event;
3603
3604	/* First, declare the async event has been handled */
3605	spin_lock_irq(&phba->hbalock);
3606	phba->hba_flag &= ~ASYNC_EVENT;
3607	spin_unlock_irq(&phba->hbalock);
3608	/* Now, handle all the async events */
3609	while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) {
3610		/* Get the first event from the head of the event queue */
3611		spin_lock_irq(&phba->hbalock);
3612		list_remove_head(&phba->sli4_hba.sp_asynce_work_queue,
3613				 cq_event, struct lpfc_cq_event, list);
3614		spin_unlock_irq(&phba->hbalock);
3615		/* Process the asynchronous event */
3616		switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) {
3617		case LPFC_TRAILER_CODE_LINK:
3618			lpfc_sli4_async_link_evt(phba,
3619						 &cq_event->cqe.acqe_link);
3620			break;
3621		case LPFC_TRAILER_CODE_FCOE:
3622			lpfc_sli4_async_fcoe_evt(phba,
3623						 &cq_event->cqe.acqe_fcoe);
3624			break;
3625		case LPFC_TRAILER_CODE_DCBX:
3626			lpfc_sli4_async_dcbx_evt(phba,
3627						 &cq_event->cqe.acqe_dcbx);
3628			break;
3629		case LPFC_TRAILER_CODE_GRP5:
3630			lpfc_sli4_async_grp5_evt(phba,
3631						 &cq_event->cqe.acqe_grp5);
3632			break;
3633		default:
3634			lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3635					"1804 Invalid asynchrous event code: "
3636					"x%x\n", bf_get(lpfc_trailer_code,
3637					&cq_event->cqe.mcqe_cmpl));
3638			break;
3639		}
3640		/* Free the completion event processed to the free pool */
3641		lpfc_sli4_cq_event_release(phba, cq_event);
3642	}
3643}
3644
3645/**
3646 * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
3647 * @phba: pointer to lpfc hba data structure.
3648 *
3649 * This routine is invoked by the worker thread to process FCF table
3650 * rediscovery pending completion event.
3651 **/
3652void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
3653{
3654	int rc;
3655
3656	spin_lock_irq(&phba->hbalock);
3657	/* Clear FCF rediscovery timeout event */
3658	phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
3659	/* Clear driver fast failover FCF record flag */
3660	phba->fcf.failover_rec.flag = 0;
3661	/* Set state for FCF fast failover */
3662	phba->fcf.fcf_flag |= FCF_REDISC_FOV;
3663	spin_unlock_irq(&phba->hbalock);
3664
3665	/* Scan FCF table from the first entry to re-discover SAN */
3666	lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
3667			"2777 Start FCF table scan after FCF "
3668			"rediscovery quiescent period over\n");
3669	rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
3670	if (rc)
3671		lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
3672				"2747 Issue FCF scan read FCF mailbox "
3673				"command failed 0x%x\n", rc);
3674}
3675
3676/**
3677 * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
3678 * @phba: pointer to lpfc hba data structure.
3679 * @dev_grp: The HBA PCI-Device group number.
3680 *
3681 * This routine is invoked to set up the per HBA PCI-Device group function
3682 * API jump table entries.
3683 *
3684 * Return: 0 if success, otherwise -ENODEV
3685 **/
3686int
3687lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
3688{
3689	int rc;
3690
3691	/* Set up lpfc PCI-device group */
3692	phba->pci_dev_grp = dev_grp;
3693
3694	/* The LPFC_PCI_DEV_OC uses SLI4 */
3695	if (dev_grp == LPFC_PCI_DEV_OC)
3696		phba->sli_rev = LPFC_SLI_REV4;
3697
3698	/* Set up device INIT API function jump table */
3699	rc = lpfc_init_api_table_setup(phba, dev_grp);
3700	if (rc)
3701		return -ENODEV;
3702	/* Set up SCSI API function jump table */
3703	rc = lpfc_scsi_api_table_setup(phba, dev_grp);
3704	if (rc)
3705		return -ENODEV;
3706	/* Set up SLI API function jump table */
3707	rc = lpfc_sli_api_table_setup(phba, dev_grp);
3708	if (rc)
3709		return -ENODEV;
3710	/* Set up MBOX API function jump table */
3711	rc = lpfc_mbox_api_table_setup(phba, dev_grp);
3712	if (rc)
3713		return -ENODEV;
3714
3715	return 0;
3716}
3717
3718/**
3719 * lpfc_log_intr_mode - Log the active interrupt mode
3720 * @phba: pointer to lpfc hba data structure.
3721 * @intr_mode: active interrupt mode adopted.
3722 *
3723 * This routine it invoked to log the currently used active interrupt mode
3724 * to the device.
3725 **/
3726static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
3727{
3728	switch (intr_mode) {
3729	case 0:
3730		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3731				"0470 Enable INTx interrupt mode.\n");
3732		break;
3733	case 1:
3734		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3735				"0481 Enabled MSI interrupt mode.\n");
3736		break;
3737	case 2:
3738		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3739				"0480 Enabled MSI-X interrupt mode.\n");
3740		break;
3741	default:
3742		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3743				"0482 Illegal interrupt mode.\n");
3744		break;
3745	}
3746	return;
3747}
3748
3749/**
3750 * lpfc_enable_pci_dev - Enable a generic PCI device.
3751 * @phba: pointer to lpfc hba data structure.
3752 *
3753 * This routine is invoked to enable the PCI device that is common to all
3754 * PCI devices.
3755 *
3756 * Return codes
3757 * 	0 - successful
3758 * 	other values - error
3759 **/
3760static int
3761lpfc_enable_pci_dev(struct lpfc_hba *phba)
3762{
3763	struct pci_dev *pdev;
3764	int bars;
3765
3766	/* Obtain PCI device reference */
3767	if (!phba->pcidev)
3768		goto out_error;
3769	else
3770		pdev = phba->pcidev;
3771	/* Select PCI BARs */
3772	bars = pci_select_bars(pdev, IORESOURCE_MEM);
3773	/* Enable PCI device */
3774	if (pci_enable_device_mem(pdev))
3775		goto out_error;
3776	/* Request PCI resource for the device */
3777	if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
3778		goto out_disable_device;
3779	/* Set up device as PCI master and save state for EEH */
3780	pci_set_master(pdev);
3781	pci_try_set_mwi(pdev);
3782	pci_save_state(pdev);
3783
3784	return 0;
3785
3786out_disable_device:
3787	pci_disable_device(pdev);
3788out_error:
3789	return -ENODEV;
3790}
3791
3792/**
3793 * lpfc_disable_pci_dev - Disable a generic PCI device.
3794 * @phba: pointer to lpfc hba data structure.
3795 *
3796 * This routine is invoked to disable the PCI device that is common to all
3797 * PCI devices.
3798 **/
3799static void
3800lpfc_disable_pci_dev(struct lpfc_hba *phba)
3801{
3802	struct pci_dev *pdev;
3803	int bars;
3804
3805	/* Obtain PCI device reference */
3806	if (!phba->pcidev)
3807		return;
3808	else
3809		pdev = phba->pcidev;
3810	/* Select PCI BARs */
3811	bars = pci_select_bars(pdev, IORESOURCE_MEM);
3812	/* Release PCI resource and disable PCI device */
3813	pci_release_selected_regions(pdev, bars);
3814	pci_disable_device(pdev);
3815	/* Null out PCI private reference to driver */
3816	pci_set_drvdata(pdev, NULL);
3817
3818	return;
3819}
3820
3821/**
3822 * lpfc_reset_hba - Reset a hba
3823 * @phba: pointer to lpfc hba data structure.
3824 *
3825 * This routine is invoked to reset a hba device. It brings the HBA
3826 * offline, performs a board restart, and then brings the board back
3827 * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
3828 * on outstanding mailbox commands.
3829 **/
3830void
3831lpfc_reset_hba(struct lpfc_hba *phba)
3832{
3833	/* If resets are disabled then set error state and return. */
3834	if (!phba->cfg_enable_hba_reset) {
3835		phba->link_state = LPFC_HBA_ERROR;
3836		return;
3837	}
3838	lpfc_offline_prep(phba);
3839	lpfc_offline(phba);
3840	lpfc_sli_brdrestart(phba);
3841	lpfc_online(phba);
3842	lpfc_unblock_mgmt_io(phba);
3843}
3844
3845/**
3846 * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev.
3847 * @phba: pointer to lpfc hba data structure.
3848 *
3849 * This routine is invoked to set up the driver internal resources specific to
3850 * support the SLI-3 HBA device it attached to.
3851 *
3852 * Return codes
3853 * 	0 - successful
3854 * 	other values - error
3855 **/
3856static int
3857lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
3858{
3859	struct lpfc_sli *psli;
3860
3861	/*
3862	 * Initialize timers used by driver
3863	 */
3864
3865	/* Heartbeat timer */
3866	init_timer(&phba->hb_tmofunc);
3867	phba->hb_tmofunc.function = lpfc_hb_timeout;
3868	phba->hb_tmofunc.data = (unsigned long)phba;
3869
3870	psli = &phba->sli;
3871	/* MBOX heartbeat timer */
3872	init_timer(&psli->mbox_tmo);
3873	psli->mbox_tmo.function = lpfc_mbox_timeout;
3874	psli->mbox_tmo.data = (unsigned long) phba;
3875	/* FCP polling mode timer */
3876	init_timer(&phba->fcp_poll_timer);
3877	phba->fcp_poll_timer.function = lpfc_poll_timeout;
3878	phba->fcp_poll_timer.data = (unsigned long) phba;
3879	/* Fabric block timer */
3880	init_timer(&phba->fabric_block_timer);
3881	phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
3882	phba->fabric_block_timer.data = (unsigned long) phba;
3883	/* EA polling mode timer */
3884	init_timer(&phba->eratt_poll);
3885	phba->eratt_poll.function = lpfc_poll_eratt;
3886	phba->eratt_poll.data = (unsigned long) phba;
3887
3888	/* Host attention work mask setup */
3889	phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
3890	phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
3891
3892	/* Get all the module params for configuring this host */
3893	lpfc_get_cfgparam(phba);
3894	if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) {
3895		phba->menlo_flag |= HBA_MENLO_SUPPORT;
3896		/* check for menlo minimum sg count */
3897		if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT)
3898			phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT;
3899	}
3900
3901	/*
3902	 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
3903	 * used to create the sg_dma_buf_pool must be dynamically calculated.
3904	 * 2 segments are added since the IOCB needs a command and response bde.
3905	 */
3906	phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
3907		sizeof(struct fcp_rsp) +
3908			((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
3909
3910	if (phba->cfg_enable_bg) {
3911		phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT;
3912		phba->cfg_sg_dma_buf_size +=
3913			phba->cfg_prot_sg_seg_cnt * sizeof(struct ulp_bde64);
3914	}
3915
3916	/* Also reinitialize the host templates with new values. */
3917	lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
3918	lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
3919
3920	phba->max_vpi = LPFC_MAX_VPI;
3921	/* This will be set to correct value after config_port mbox */
3922	phba->max_vports = 0;
3923
3924	/*
3925	 * Initialize the SLI Layer to run with lpfc HBAs.
3926	 */
3927	lpfc_sli_setup(phba);
3928	lpfc_sli_queue_setup(phba);
3929
3930	/* Allocate device driver memory */
3931	if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
3932		return -ENOMEM;
3933
3934	return 0;
3935}
3936
3937/**
3938 * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
3939 * @phba: pointer to lpfc hba data structure.
3940 *
3941 * This routine is invoked to unset the driver internal resources set up
3942 * specific for supporting the SLI-3 HBA device it attached to.
3943 **/
3944static void
3945lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
3946{
3947	/* Free device driver memory allocated */
3948	lpfc_mem_free_all(phba);
3949
3950	return;
3951}
3952
3953/**
3954 * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
3955 * @phba: pointer to lpfc hba data structure.
3956 *
3957 * This routine is invoked to set up the driver internal resources specific to
3958 * support the SLI-4 HBA device it attached to.
3959 *
3960 * Return codes
3961 * 	0 - successful
3962 * 	other values - error
3963 **/
3964static int
3965lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
3966{
3967	struct lpfc_sli *psli;
3968	LPFC_MBOXQ_t *mboxq;
3969	int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
3970	uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
3971	struct lpfc_mqe *mqe;
3972	int longs;
3973
3974	/* Before proceed, wait for POST done and device ready */
3975	rc = lpfc_sli4_post_status_check(phba);
3976	if (rc)
3977		return -ENODEV;
3978
3979	/*
3980	 * Initialize timers used by driver
3981	 */
3982
3983	/* Heartbeat timer */
3984	init_timer(&phba->hb_tmofunc);
3985	phba->hb_tmofunc.function = lpfc_hb_timeout;
3986	phba->hb_tmofunc.data = (unsigned long)phba;
3987
3988	psli = &phba->sli;
3989	/* MBOX heartbeat timer */
3990	init_timer(&psli->mbox_tmo);
3991	psli->mbox_tmo.function = lpfc_mbox_timeout;
3992	psli->mbox_tmo.data = (unsigned long) phba;
3993	/* Fabric block timer */
3994	init_timer(&phba->fabric_block_timer);
3995	phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
3996	phba->fabric_block_timer.data = (unsigned long) phba;
3997	/* EA polling mode timer */
3998	init_timer(&phba->eratt_poll);
3999	phba->eratt_poll.function = lpfc_poll_eratt;
4000	phba->eratt_poll.data = (unsigned long) phba;
4001	/* FCF rediscover timer */
4002	init_timer(&phba->fcf.redisc_wait);
4003	phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo;
4004	phba->fcf.redisc_wait.data = (unsigned long)phba;
4005
4006	/*
4007	 * We need to do a READ_CONFIG mailbox command here before
4008	 * calling lpfc_get_cfgparam. For VFs this will report the
4009	 * MAX_XRI, MAX_VPI, MAX_RPI, MAX_IOCB, and MAX_VFI settings.
4010	 * All of the resources allocated
4011	 * for this Port are tied to these values.
4012	 */
4013	/* Get all the module params for configuring this host */
4014	lpfc_get_cfgparam(phba);
4015	phba->max_vpi = LPFC_MAX_VPI;
4016	/* This will be set to correct value after the read_config mbox */
4017	phba->max_vports = 0;
4018
4019	/* Program the default value of vlan_id and fc_map */
4020	phba->valid_vlan = 0;
4021	phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
4022	phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
4023	phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
4024
4025	/*
4026	 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
4027	 * used to create the sg_dma_buf_pool must be dynamically calculated.
4028	 * 2 segments are added since the IOCB needs a command and response bde.
4029	 * To insure that the scsi sgl does not cross a 4k page boundary only
4030	 * sgl sizes of must be a power of 2.
4031	 */
4032	buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
4033		    ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge)));
4034	/* Feature Level 1 hardware is limited to 2 pages */
4035	if ((bf_get(lpfc_sli_intf_featurelevel1, &phba->sli4_hba.sli_intf) ==
4036	     LPFC_SLI_INTF_FEATURELEVEL1_1))
4037		max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
4038	else
4039		max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
4040	for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
4041	     dma_buf_size < max_buf_size && buf_size > dma_buf_size;
4042	     dma_buf_size = dma_buf_size << 1)
4043		;
4044	if (dma_buf_size == max_buf_size)
4045		phba->cfg_sg_seg_cnt = (dma_buf_size -
4046			sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) -
4047			(2 * sizeof(struct sli4_sge))) /
4048				sizeof(struct sli4_sge);
4049	phba->cfg_sg_dma_buf_size = dma_buf_size;
4050
4051	/* Initialize buffer queue management fields */
4052	hbq_count = lpfc_sli_hbq_count();
4053	for (i = 0; i < hbq_count; ++i)
4054		INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
4055	INIT_LIST_HEAD(&phba->rb_pend_list);
4056	phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc;
4057	phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free;
4058
4059	/*
4060	 * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
4061	 */
4062	/* Initialize the Abort scsi buffer list used by driver */
4063	spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock);
4064	INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
4065	/* This abort list used by worker thread */
4066	spin_lock_init(&phba->sli4_hba.abts_sgl_list_lock);
4067
4068	/*
4069	 * Initialize dirver internal slow-path work queues
4070	 */
4071
4072	/* Driver internel slow-path CQ Event pool */
4073	INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
4074	/* Response IOCB work queue list */
4075	INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
4076	/* Asynchronous event CQ Event work queue list */
4077	INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
4078	/* Fast-path XRI aborted CQ Event work queue list */
4079	INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
4080	/* Slow-path XRI aborted CQ Event work queue list */
4081	INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue);
4082	/* Receive queue CQ Event work queue list */
4083	INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
4084
4085	/* Initialize the driver internal SLI layer lists. */
4086	lpfc_sli_setup(phba);
4087	lpfc_sli_queue_setup(phba);
4088
4089	/* Allocate device driver memory */
4090	rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ);
4091	if (rc)
4092		return -ENOMEM;
4093
4094	/* Create the bootstrap mailbox command */
4095	rc = lpfc_create_bootstrap_mbox(phba);
4096	if (unlikely(rc))
4097		goto out_free_mem;
4098
4099	/* Set up the host's endian order with the device. */
4100	rc = lpfc_setup_endian_order(phba);
4101	if (unlikely(rc))
4102		goto out_free_bsmbx;
4103
4104	rc = lpfc_sli4_fw_cfg_check(phba);
4105	if (unlikely(rc))
4106		goto out_free_bsmbx;
4107
4108	/* Set up the hba's configuration parameters. */
4109	rc = lpfc_sli4_read_config(phba);
4110	if (unlikely(rc))
4111		goto out_free_bsmbx;
4112
4113	/* Perform a function reset */
4114	rc = lpfc_pci_function_reset(phba);
4115	if (unlikely(rc))
4116		goto out_free_bsmbx;
4117
4118	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
4119						       GFP_KERNEL);
4120	if (!mboxq) {
4121		rc = -ENOMEM;
4122		goto out_free_bsmbx;
4123	}
4124
4125	/* Get the Supported Pages. It is always available. */
4126	lpfc_supported_pages(mboxq);
4127	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
4128	if (unlikely(rc)) {
4129		rc = -EIO;
4130		mempool_free(mboxq, phba->mbox_mem_pool);
4131		goto out_free_bsmbx;
4132	}
4133
4134	mqe = &mboxq->u.mqe;
4135	memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
4136	       LPFC_MAX_SUPPORTED_PAGES);
4137	for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
4138		switch (pn_page[i]) {
4139		case LPFC_SLI4_PARAMETERS:
4140			phba->sli4_hba.pc_sli4_params.supported = 1;
4141			break;
4142		default:
4143			break;
4144		}
4145	}
4146
4147	/* Read the port's SLI4 Parameters capabilities if supported. */
4148	if (phba->sli4_hba.pc_sli4_params.supported)
4149		rc = lpfc_pc_sli4_params_get(phba, mboxq);
4150	mempool_free(mboxq, phba->mbox_mem_pool);
4151	if (rc) {
4152		rc = -EIO;
4153		goto out_free_bsmbx;
4154	}
4155	/* Create all the SLI4 queues */
4156	rc = lpfc_sli4_queue_create(phba);
4157	if (rc)
4158		goto out_free_bsmbx;
4159
4160	/* Create driver internal CQE event pool */
4161	rc = lpfc_sli4_cq_event_pool_create(phba);
4162	if (rc)
4163		goto out_destroy_queue;
4164
4165	/* Initialize and populate the iocb list per host */
4166	rc = lpfc_init_sgl_list(phba);
4167	if (rc) {
4168		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4169				"1400 Failed to initialize sgl list.\n");
4170		goto out_destroy_cq_event_pool;
4171	}
4172	rc = lpfc_init_active_sgl_array(phba);
4173	if (rc) {
4174		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4175				"1430 Failed to initialize sgl list.\n");
4176		goto out_free_sgl_list;
4177	}
4178
4179	rc = lpfc_sli4_init_rpi_hdrs(phba);
4180	if (rc) {
4181		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4182				"1432 Failed to initialize rpi headers.\n");
4183		goto out_free_active_sgl;
4184	}
4185
4186	/* Allocate eligible FCF bmask memory for FCF round robin failover */
4187	longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;
4188	phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long),
4189					 GFP_KERNEL);
4190	if (!phba->fcf.fcf_rr_bmask) {
4191		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4192				"2759 Failed allocate memory for FCF round "
4193				"robin failover bmask\n");
4194		goto out_remove_rpi_hdrs;
4195	}
4196
4197	phba->sli4_hba.fcp_eq_hdl = kzalloc((sizeof(struct lpfc_fcp_eq_hdl) *
4198				    phba->cfg_fcp_eq_count), GFP_KERNEL);
4199	if (!phba->sli4_hba.fcp_eq_hdl) {
4200		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4201				"2572 Failed allocate memory for fast-path "
4202				"per-EQ handle array\n");
4203		goto out_free_fcf_rr_bmask;
4204	}
4205
4206	phba->sli4_hba.msix_entries = kzalloc((sizeof(struct msix_entry) *
4207				      phba->sli4_hba.cfg_eqn), GFP_KERNEL);
4208	if (!phba->sli4_hba.msix_entries) {
4209		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4210				"2573 Failed allocate memory for msi-x "
4211				"interrupt vector entries\n");
4212		goto out_free_fcp_eq_hdl;
4213	}
4214
4215	return rc;
4216
4217out_free_fcp_eq_hdl:
4218	kfree(phba->sli4_hba.fcp_eq_hdl);
4219out_free_fcf_rr_bmask:
4220	kfree(phba->fcf.fcf_rr_bmask);
4221out_remove_rpi_hdrs:
4222	lpfc_sli4_remove_rpi_hdrs(phba);
4223out_free_active_sgl:
4224	lpfc_free_active_sgl(phba);
4225out_free_sgl_list:
4226	lpfc_free_sgl_list(phba);
4227out_destroy_cq_event_pool:
4228	lpfc_sli4_cq_event_pool_destroy(phba);
4229out_destroy_queue:
4230	lpfc_sli4_queue_destroy(phba);
4231out_free_bsmbx:
4232	lpfc_destroy_bootstrap_mbox(phba);
4233out_free_mem:
4234	lpfc_mem_free(phba);
4235	return rc;
4236}
4237
4238/**
4239 * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
4240 * @phba: pointer to lpfc hba data structure.
4241 *
4242 * This routine is invoked to unset the driver internal resources set up
4243 * specific for supporting the SLI-4 HBA device it attached to.
4244 **/
4245static void
4246lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
4247{
4248	struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
4249
4250	/* unregister default FCFI from the HBA */
4251	lpfc_sli4_fcfi_unreg(phba, phba->fcf.fcfi);
4252
4253	/* Free the default FCR table */
4254	lpfc_sli_remove_dflt_fcf(phba);
4255
4256	/* Free memory allocated for msi-x interrupt vector entries */
4257	kfree(phba->sli4_hba.msix_entries);
4258
4259	/* Free memory allocated for fast-path work queue handles */
4260	kfree(phba->sli4_hba.fcp_eq_hdl);
4261
4262	/* Free the allocated rpi headers. */
4263	lpfc_sli4_remove_rpi_hdrs(phba);
4264	lpfc_sli4_remove_rpis(phba);
4265
4266	/* Free eligible FCF index bmask */
4267	kfree(phba->fcf.fcf_rr_bmask);
4268
4269	/* Free the ELS sgl list */
4270	lpfc_free_active_sgl(phba);
4271	lpfc_free_sgl_list(phba);
4272
4273	/* Free the SCSI sgl management array */
4274	kfree(phba->sli4_hba.lpfc_scsi_psb_array);
4275
4276	/* Free the SLI4 queues */
4277	lpfc_sli4_queue_destroy(phba);
4278
4279	/* Free the completion queue EQ event pool */
4280	lpfc_sli4_cq_event_release_all(phba);
4281	lpfc_sli4_cq_event_pool_destroy(phba);
4282
4283	/* Reset SLI4 HBA FCoE function */
4284	lpfc_pci_function_reset(phba);
4285
4286	/* Free the bsmbx region. */
4287	lpfc_destroy_bootstrap_mbox(phba);
4288
4289	/* Free the SLI Layer memory with SLI4 HBAs */
4290	lpfc_mem_free_all(phba);
4291
4292	/* Free the current connect table */
4293	list_for_each_entry_safe(conn_entry, next_conn_entry,
4294		&phba->fcf_conn_rec_list, list) {
4295		list_del_init(&conn_entry->list);
4296		kfree(conn_entry);
4297	}
4298
4299	return;
4300}
4301
4302/**
4303 * lpfc_init_api_table_setup - Set up init api fucntion jump table
4304 * @phba: The hba struct for which this call is being executed.
4305 * @dev_grp: The HBA PCI-Device group number.
4306 *
4307 * This routine sets up the device INIT interface API function jump table
4308 * in @phba struct.
4309 *
4310 * Returns: 0 - success, -ENODEV - failure.
4311 **/
4312int
4313lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4314{
4315	phba->lpfc_hba_init_link = lpfc_hba_init_link;
4316	phba->lpfc_hba_down_link = lpfc_hba_down_link;
4317	switch (dev_grp) {
4318	case LPFC_PCI_DEV_LP:
4319		phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
4320		phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
4321		phba->lpfc_stop_port = lpfc_stop_port_s3;
4322		break;
4323	case LPFC_PCI_DEV_OC:
4324		phba->lpfc_hba_down_post = lpfc_hba_down_post_s4;
4325		phba->lpfc_handle_eratt = lpfc_handle_eratt_s4;
4326		phba->lpfc_stop_port = lpfc_stop_port_s4;
4327		break;
4328	default:
4329		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4330				"1431 Invalid HBA PCI-device group: 0x%x\n",
4331				dev_grp);
4332		return -ENODEV;
4333		break;
4334	}
4335	return 0;
4336}
4337
4338/**
4339 * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
4340 * @phba: pointer to lpfc hba data structure.
4341 *
4342 * This routine is invoked to set up the driver internal resources before the
4343 * device specific resource setup to support the HBA device it attached to.
4344 *
4345 * Return codes
4346 *	0 - successful
4347 *	other values - error
4348 **/
4349static int
4350lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
4351{
4352	/*
4353	 * Driver resources common to all SLI revisions
4354	 */
4355	atomic_set(&phba->fast_event_count, 0);
4356	spin_lock_init(&phba->hbalock);
4357
4358	/* Initialize ndlp management spinlock */
4359	spin_lock_init(&phba->ndlp_lock);
4360
4361	INIT_LIST_HEAD(&phba->port_list);
4362	INIT_LIST_HEAD(&phba->work_list);
4363	init_waitqueue_head(&phba->wait_4_mlo_m_q);
4364
4365	/* Initialize the wait queue head for the kernel thread */
4366	init_waitqueue_head(&phba->work_waitq);
4367
4368	/* Initialize the scsi buffer list used by driver for scsi IO */
4369	spin_lock_init(&phba->scsi_buf_list_lock);
4370	INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
4371
4372	/* Initialize the fabric iocb list */
4373	INIT_LIST_HEAD(&phba->fabric_iocb_list);
4374
4375	/* Initialize list to save ELS buffers */
4376	INIT_LIST_HEAD(&phba->elsbuf);
4377
4378	/* Initialize FCF connection rec list */
4379	INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
4380
4381	return 0;
4382}
4383
4384/**
4385 * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
4386 * @phba: pointer to lpfc hba data structure.
4387 *
4388 * This routine is invoked to set up the driver internal resources after the
4389 * device specific resource setup to support the HBA device it attached to.
4390 *
4391 * Return codes
4392 * 	0 - successful
4393 * 	other values - error
4394 **/
4395static int
4396lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
4397{
4398	int error;
4399
4400	/* Startup the kernel thread for this host adapter. */
4401	phba->worker_thread = kthread_run(lpfc_do_work, phba,
4402					  "lpfc_worker_%d", phba->brd_no);
4403	if (IS_ERR(phba->worker_thread)) {
4404		error = PTR_ERR(phba->worker_thread);
4405		return error;
4406	}
4407
4408	return 0;
4409}
4410
4411/**
4412 * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
4413 * @phba: pointer to lpfc hba data structure.
4414 *
4415 * This routine is invoked to unset the driver internal resources set up after
4416 * the device specific resource setup for supporting the HBA device it
4417 * attached to.
4418 **/
4419static void
4420lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
4421{
4422	/* Stop kernel worker thread */
4423	kthread_stop(phba->worker_thread);
4424}
4425
4426/**
4427 * lpfc_free_iocb_list - Free iocb list.
4428 * @phba: pointer to lpfc hba data structure.
4429 *
4430 * This routine is invoked to free the driver's IOCB list and memory.
4431 **/
4432static void
4433lpfc_free_iocb_list(struct lpfc_hba *phba)
4434{
4435	struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
4436
4437	spin_lock_irq(&phba->hbalock);
4438	list_for_each_entry_safe(iocbq_entry, iocbq_next,
4439				 &phba->lpfc_iocb_list, list) {
4440		list_del(&iocbq_entry->list);
4441		kfree(iocbq_entry);
4442		phba->total_iocbq_bufs--;
4443	}
4444	spin_unlock_irq(&phba->hbalock);
4445
4446	return;
4447}
4448
4449/**
4450 * lpfc_init_iocb_list - Allocate and initialize iocb list.
4451 * @phba: pointer to lpfc hba data structure.
4452 *
4453 * This routine is invoked to allocate and initizlize the driver's IOCB
4454 * list and set up the IOCB tag array accordingly.
4455 *
4456 * Return codes
4457 *	0 - successful
4458 *	other values - error
4459 **/
4460static int
4461lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
4462{
4463	struct lpfc_iocbq *iocbq_entry = NULL;
4464	uint16_t iotag;
4465	int i;
4466
4467	/* Initialize and populate the iocb list per host.  */
4468	INIT_LIST_HEAD(&phba->lpfc_iocb_list);
4469	for (i = 0; i < iocb_count; i++) {
4470		iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
4471		if (iocbq_entry == NULL) {
4472			printk(KERN_ERR "%s: only allocated %d iocbs of "
4473				"expected %d count. Unloading driver.\n",
4474				__func__, i, LPFC_IOCB_LIST_CNT);
4475			goto out_free_iocbq;
4476		}
4477
4478		iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
4479		if (iotag == 0) {
4480			kfree(iocbq_entry);
4481			printk(KERN_ERR "%s: failed to allocate IOTAG. "
4482				"Unloading driver.\n", __func__);
4483			goto out_free_iocbq;
4484		}
4485		iocbq_entry->sli4_xritag = NO_XRI;
4486
4487		spin_lock_irq(&phba->hbalock);
4488		list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
4489		phba->total_iocbq_bufs++;
4490		spin_unlock_irq(&phba->hbalock);
4491	}
4492
4493	return 0;
4494
4495out_free_iocbq:
4496	lpfc_free_iocb_list(phba);
4497
4498	return -ENOMEM;
4499}
4500
4501/**
4502 * lpfc_free_sgl_list - Free sgl list.
4503 * @phba: pointer to lpfc hba data structure.
4504 *
4505 * This routine is invoked to free the driver's sgl list and memory.
4506 **/
4507static void
4508lpfc_free_sgl_list(struct lpfc_hba *phba)
4509{
4510	struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
4511	LIST_HEAD(sglq_list);
4512	int rc = 0;
4513
4514	spin_lock_irq(&phba->hbalock);
4515	list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &sglq_list);
4516	spin_unlock_irq(&phba->hbalock);
4517
4518	list_for_each_entry_safe(sglq_entry, sglq_next,
4519				 &sglq_list, list) {
4520		list_del(&sglq_entry->list);
4521		lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
4522		kfree(sglq_entry);
4523		phba->sli4_hba.total_sglq_bufs--;
4524	}
4525	rc = lpfc_sli4_remove_all_sgl_pages(phba);
4526	if (rc) {
4527		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4528			"2005 Unable to deregister pages from HBA: %x\n", rc);
4529	}
4530	kfree(phba->sli4_hba.lpfc_els_sgl_array);
4531}
4532
4533/**
4534 * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
4535 * @phba: pointer to lpfc hba data structure.
4536 *
4537 * This routine is invoked to allocate the driver's active sgl memory.
4538 * This array will hold the sglq_entry's for active IOs.
4539 **/
4540static int
4541lpfc_init_active_sgl_array(struct lpfc_hba *phba)
4542{
4543	int size;
4544	size = sizeof(struct lpfc_sglq *);
4545	size *= phba->sli4_hba.max_cfg_param.max_xri;
4546
4547	phba->sli4_hba.lpfc_sglq_active_list =
4548		kzalloc(size, GFP_KERNEL);
4549	if (!phba->sli4_hba.lpfc_sglq_active_list)
4550		return -ENOMEM;
4551	return 0;
4552}
4553
4554/**
4555 * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
4556 * @phba: pointer to lpfc hba data structure.
4557 *
4558 * This routine is invoked to walk through the array of active sglq entries
4559 * and free all of the resources.
4560 * This is just a place holder for now.
4561 **/
4562static void
4563lpfc_free_active_sgl(struct lpfc_hba *phba)
4564{
4565	kfree(phba->sli4_hba.lpfc_sglq_active_list);
4566}
4567
4568/**
4569 * lpfc_init_sgl_list - Allocate and initialize sgl list.
4570 * @phba: pointer to lpfc hba data structure.
4571 *
4572 * This routine is invoked to allocate and initizlize the driver's sgl
4573 * list and set up the sgl xritag tag array accordingly.
4574 *
4575 * Return codes
4576 *	0 - successful
4577 *	other values - error
4578 **/
4579static int
4580lpfc_init_sgl_list(struct lpfc_hba *phba)
4581{
4582	struct lpfc_sglq *sglq_entry = NULL;
4583	int i;
4584	int els_xri_cnt;
4585
4586	els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
4587	lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4588				"2400 lpfc_init_sgl_list els %d.\n",
4589				els_xri_cnt);
4590	/* Initialize and populate the sglq list per host/VF. */
4591	INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list);
4592	INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
4593
4594	/* Sanity check on XRI management */
4595	if (phba->sli4_hba.max_cfg_param.max_xri <= els_xri_cnt) {
4596		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4597				"2562 No room left for SCSI XRI allocation: "
4598				"max_xri=%d, els_xri=%d\n",
4599				phba->sli4_hba.max_cfg_param.max_xri,
4600				els_xri_cnt);
4601		return -ENOMEM;
4602	}
4603
4604	/* Allocate memory for the ELS XRI management array */
4605	phba->sli4_hba.lpfc_els_sgl_array =
4606			kzalloc((sizeof(struct lpfc_sglq *) * els_xri_cnt),
4607			GFP_KERNEL);
4608
4609	if (!phba->sli4_hba.lpfc_els_sgl_array) {
4610		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4611				"2401 Failed to allocate memory for ELS "
4612				"XRI management array of size %d.\n",
4613				els_xri_cnt);
4614		return -ENOMEM;
4615	}
4616
4617	/* Keep the SCSI XRI into the XRI management array */
4618	phba->sli4_hba.scsi_xri_max =
4619			phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
4620	phba->sli4_hba.scsi_xri_cnt = 0;
4621
4622	phba->sli4_hba.lpfc_scsi_psb_array =
4623			kzalloc((sizeof(struct lpfc_scsi_buf *) *
4624			phba->sli4_hba.scsi_xri_max), GFP_KERNEL);
4625
4626	if (!phba->sli4_hba.lpfc_scsi_psb_array) {
4627		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4628				"2563 Failed to allocate memory for SCSI "
4629				"XRI management array of size %d.\n",
4630				phba->sli4_hba.scsi_xri_max);
4631		kfree(phba->sli4_hba.lpfc_els_sgl_array);
4632		return -ENOMEM;
4633	}
4634
4635	for (i = 0; i < els_xri_cnt; i++) {
4636		sglq_entry = kzalloc(sizeof(struct lpfc_sglq), GFP_KERNEL);
4637		if (sglq_entry == NULL) {
4638			printk(KERN_ERR "%s: only allocated %d sgls of "
4639				"expected %d count. Unloading driver.\n",
4640				__func__, i, els_xri_cnt);
4641			goto out_free_mem;
4642		}
4643
4644		sglq_entry->sli4_xritag = lpfc_sli4_next_xritag(phba);
4645		if (sglq_entry->sli4_xritag == NO_XRI) {
4646			kfree(sglq_entry);
4647			printk(KERN_ERR "%s: failed to allocate XRI.\n"
4648				"Unloading driver.\n", __func__);
4649			goto out_free_mem;
4650		}
4651		sglq_entry->buff_type = GEN_BUFF_TYPE;
4652		sglq_entry->virt = lpfc_mbuf_alloc(phba, 0, &sglq_entry->phys);
4653		if (sglq_entry->virt == NULL) {
4654			kfree(sglq_entry);
4655			printk(KERN_ERR "%s: failed to allocate mbuf.\n"
4656				"Unloading driver.\n", __func__);
4657			goto out_free_mem;
4658		}
4659		sglq_entry->sgl = sglq_entry->virt;
4660		memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
4661
4662		/* The list order is used by later block SGL registraton */
4663		spin_lock_irq(&phba->hbalock);
4664		sglq_entry->state = SGL_FREED;
4665		list_add_tail(&sglq_entry->list, &phba->sli4_hba.lpfc_sgl_list);
4666		phba->sli4_hba.lpfc_els_sgl_array[i] = sglq_entry;
4667		phba->sli4_hba.total_sglq_bufs++;
4668		spin_unlock_irq(&phba->hbalock);
4669	}
4670	return 0;
4671
4672out_free_mem:
4673	kfree(phba->sli4_hba.lpfc_scsi_psb_array);
4674	lpfc_free_sgl_list(phba);
4675	return -ENOMEM;
4676}
4677
4678/**
4679 * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
4680 * @phba: pointer to lpfc hba data structure.
4681 *
4682 * This routine is invoked to post rpi header templates to the
4683 * HBA consistent with the SLI-4 interface spec.  This routine
4684 * posts a PAGE_SIZE memory region to the port to hold up to
4685 * PAGE_SIZE modulo 64 rpi context headers.
4686 * No locks are held here because this is an initialization routine
4687 * called only from probe or lpfc_online when interrupts are not
4688 * enabled and the driver is reinitializing the device.
4689 *
4690 * Return codes
4691 * 	0 - successful
4692 * 	ENOMEM - No availble memory
4693 *      EIO - The mailbox failed to complete successfully.
4694 **/
4695int
4696lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
4697{
4698	int rc = 0;
4699	int longs;
4700	uint16_t rpi_count;
4701	struct lpfc_rpi_hdr *rpi_hdr;
4702
4703	INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
4704
4705	/*
4706	 * Provision an rpi bitmask range for discovery. The total count
4707	 * is the difference between max and base + 1.
4708	 */
4709	rpi_count = phba->sli4_hba.max_cfg_param.rpi_base +
4710		    phba->sli4_hba.max_cfg_param.max_rpi - 1;
4711
4712	longs = ((rpi_count) + BITS_PER_LONG - 1) / BITS_PER_LONG;
4713	phba->sli4_hba.rpi_bmask = kzalloc(longs * sizeof(unsigned long),
4714					   GFP_KERNEL);
4715	if (!phba->sli4_hba.rpi_bmask)
4716		return -ENOMEM;
4717
4718	rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
4719	if (!rpi_hdr) {
4720		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
4721				"0391 Error during rpi post operation\n");
4722		lpfc_sli4_remove_rpis(phba);
4723		rc = -ENODEV;
4724	}
4725
4726	return rc;
4727}
4728
4729/**
4730 * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
4731 * @phba: pointer to lpfc hba data structure.
4732 *
4733 * This routine is invoked to allocate a single 4KB memory region to
4734 * support rpis and stores them in the phba.  This single region
4735 * provides support for up to 64 rpis.  The region is used globally
4736 * by the device.
4737 *
4738 * Returns:
4739 *   A valid rpi hdr on success.
4740 *   A NULL pointer on any failure.
4741 **/
4742struct lpfc_rpi_hdr *
4743lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
4744{
4745	uint16_t rpi_limit, curr_rpi_range;
4746	struct lpfc_dmabuf *dmabuf;
4747	struct lpfc_rpi_hdr *rpi_hdr;
4748
4749	rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
4750		    phba->sli4_hba.max_cfg_param.max_rpi - 1;
4751
4752	spin_lock_irq(&phba->hbalock);
4753	curr_rpi_range = phba->sli4_hba.next_rpi;
4754	spin_unlock_irq(&phba->hbalock);
4755
4756	/*
4757	 * The port has a limited number of rpis. The increment here
4758	 * is LPFC_RPI_HDR_COUNT - 1 to account for the starting value
4759	 * and to allow the full max_rpi range per port.
4760	 */
4761	if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
4762		return NULL;
4763
4764	/*
4765	 * First allocate the protocol header region for the port.  The
4766	 * port expects a 4KB DMA-mapped memory region that is 4K aligned.
4767	 */
4768	dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4769	if (!dmabuf)
4770		return NULL;
4771
4772	dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
4773					  LPFC_HDR_TEMPLATE_SIZE,
4774					  &dmabuf->phys,
4775					  GFP_KERNEL);
4776	if (!dmabuf->virt) {
4777		rpi_hdr = NULL;
4778		goto err_free_dmabuf;
4779	}
4780
4781	memset(dmabuf->virt, 0, LPFC_HDR_TEMPLATE_SIZE);
4782	if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) {
4783		rpi_hdr = NULL;
4784		goto err_free_coherent;
4785	}
4786
4787	/* Save the rpi header data for cleanup later. */
4788	rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL);
4789	if (!rpi_hdr)
4790		goto err_free_coherent;
4791
4792	rpi_hdr->dmabuf = dmabuf;
4793	rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
4794	rpi_hdr->page_count = 1;
4795	spin_lock_irq(&phba->hbalock);
4796	rpi_hdr->start_rpi = phba->sli4_hba.next_rpi;
4797	list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
4798
4799	/*
4800	 * The next_rpi stores the next module-64 rpi value to post
4801	 * in any subsequent rpi memory region postings.
4802	 */
4803	phba->sli4_hba.next_rpi += LPFC_RPI_HDR_COUNT;
4804	spin_unlock_irq(&phba->hbalock);
4805	return rpi_hdr;
4806
4807 err_free_coherent:
4808	dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE,
4809			  dmabuf->virt, dmabuf->phys);
4810 err_free_dmabuf:
4811	kfree(dmabuf);
4812	return NULL;
4813}
4814
4815/**
4816 * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
4817 * @phba: pointer to lpfc hba data structure.
4818 *
4819 * This routine is invoked to remove all memory resources allocated
4820 * to support rpis. This routine presumes the caller has released all
4821 * rpis consumed by fabric or port logins and is prepared to have
4822 * the header pages removed.
4823 **/
4824void
4825lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
4826{
4827	struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
4828
4829	list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
4830				 &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
4831		list_del(&rpi_hdr->list);
4832		dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len,
4833				  rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys);
4834		kfree(rpi_hdr->dmabuf);
4835		kfree(rpi_hdr);
4836	}
4837
4838	phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
4839	memset(phba->sli4_hba.rpi_bmask, 0, sizeof(*phba->sli4_hba.rpi_bmask));
4840}
4841
4842/**
4843 * lpfc_hba_alloc - Allocate driver hba data structure for a device.
4844 * @pdev: pointer to pci device data structure.
4845 *
4846 * This routine is invoked to allocate the driver hba data structure for an
4847 * HBA device. If the allocation is successful, the phba reference to the
4848 * PCI device data structure is set.
4849 *
4850 * Return codes
4851 *      pointer to @phba - successful
4852 *      NULL - error
4853 **/
4854static struct lpfc_hba *
4855lpfc_hba_alloc(struct pci_dev *pdev)
4856{
4857	struct lpfc_hba *phba;
4858
4859	/* Allocate memory for HBA structure */
4860	phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
4861	if (!phba) {
4862		dev_err(&pdev->dev, "failed to allocate hba struct\n");
4863		return NULL;
4864	}
4865
4866	/* Set reference to PCI device in HBA structure */
4867	phba->pcidev = pdev;
4868
4869	/* Assign an unused board number */
4870	phba->brd_no = lpfc_get_instance();
4871	if (phba->brd_no < 0) {
4872		kfree(phba);
4873		return NULL;
4874	}
4875
4876	spin_lock_init(&phba->ct_ev_lock);
4877	INIT_LIST_HEAD(&phba->ct_ev_waiters);
4878
4879	return phba;
4880}
4881
4882/**
4883 * lpfc_hba_free - Free driver hba data structure with a device.
4884 * @phba: pointer to lpfc hba data structure.
4885 *
4886 * This routine is invoked to free the driver hba data structure with an
4887 * HBA device.
4888 **/
4889static void
4890lpfc_hba_free(struct lpfc_hba *phba)
4891{
4892	/* Release the driver assigned board number */
4893	idr_remove(&lpfc_hba_index, phba->brd_no);
4894
4895	kfree(phba);
4896	return;
4897}
4898
4899/**
4900 * lpfc_create_shost - Create hba physical port with associated scsi host.
4901 * @phba: pointer to lpfc hba data structure.
4902 *
4903 * This routine is invoked to create HBA physical port and associate a SCSI
4904 * host with it.
4905 *
4906 * Return codes
4907 *      0 - successful
4908 *      other values - error
4909 **/
4910static int
4911lpfc_create_shost(struct lpfc_hba *phba)
4912{
4913	struct lpfc_vport *vport;
4914	struct Scsi_Host  *shost;
4915
4916	/* Initialize HBA FC structure */
4917	phba->fc_edtov = FF_DEF_EDTOV;
4918	phba->fc_ratov = FF_DEF_RATOV;
4919	phba->fc_altov = FF_DEF_ALTOV;
4920	phba->fc_arbtov = FF_DEF_ARBTOV;
4921
4922	vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
4923	if (!vport)
4924		return -ENODEV;
4925
4926	shost = lpfc_shost_from_vport(vport);
4927	phba->pport = vport;
4928	lpfc_debugfs_initialize(vport);
4929	/* Put reference to SCSI host to driver's device private data */
4930	pci_set_drvdata(phba->pcidev, shost);
4931
4932	return 0;
4933}
4934
4935/**
4936 * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
4937 * @phba: pointer to lpfc hba data structure.
4938 *
4939 * This routine is invoked to destroy HBA physical port and the associated
4940 * SCSI host.
4941 **/
4942static void
4943lpfc_destroy_shost(struct lpfc_hba *phba)
4944{
4945	struct lpfc_vport *vport = phba->pport;
4946
4947	/* Destroy physical port that associated with the SCSI host */
4948	destroy_port(vport);
4949
4950	return;
4951}
4952
4953/**
4954 * lpfc_setup_bg - Setup Block guard structures and debug areas.
4955 * @phba: pointer to lpfc hba data structure.
4956 * @shost: the shost to be used to detect Block guard settings.
4957 *
4958 * This routine sets up the local Block guard protocol settings for @shost.
4959 * This routine also allocates memory for debugging bg buffers.
4960 **/
4961static void
4962lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
4963{
4964	int pagecnt = 10;
4965	if (lpfc_prot_mask && lpfc_prot_guard) {
4966		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4967				"1478 Registering BlockGuard with the "
4968				"SCSI layer\n");
4969		scsi_host_set_prot(shost, lpfc_prot_mask);
4970		scsi_host_set_guard(shost, lpfc_prot_guard);
4971	}
4972	if (!_dump_buf_data) {
4973		while (pagecnt) {
4974			spin_lock_init(&_dump_buf_lock);
4975			_dump_buf_data =
4976				(char *) __get_free_pages(GFP_KERNEL, pagecnt);
4977			if (_dump_buf_data) {
4978				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4979					"9043 BLKGRD: allocated %d pages for "
4980				       "_dump_buf_data at 0x%p\n",
4981				       (1 << pagecnt), _dump_buf_data);
4982				_dump_buf_data_order = pagecnt;
4983				memset(_dump_buf_data, 0,
4984				       ((1 << PAGE_SHIFT) << pagecnt));
4985				break;
4986			} else
4987				--pagecnt;
4988		}
4989		if (!_dump_buf_data_order)
4990			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4991				"9044 BLKGRD: ERROR unable to allocate "
4992			       "memory for hexdump\n");
4993	} else
4994		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4995			"9045 BLKGRD: already allocated _dump_buf_data=0x%p"
4996		       "\n", _dump_buf_data);
4997	if (!_dump_buf_dif) {
4998		while (pagecnt) {
4999			_dump_buf_dif =
5000				(char *) __get_free_pages(GFP_KERNEL, pagecnt);
5001			if (_dump_buf_dif) {
5002				lpfc_printf_log(phba, KERN_ERR, LOG_BG,
5003					"9046 BLKGRD: allocated %d pages for "
5004				       "_dump_buf_dif at 0x%p\n",
5005				       (1 << pagecnt), _dump_buf_dif);
5006				_dump_buf_dif_order = pagecnt;
5007				memset(_dump_buf_dif, 0,
5008				       ((1 << PAGE_SHIFT) << pagecnt));
5009				break;
5010			} else
5011				--pagecnt;
5012		}
5013		if (!_dump_buf_dif_order)
5014			lpfc_printf_log(phba, KERN_ERR, LOG_BG,
5015			"9047 BLKGRD: ERROR unable to allocate "
5016			       "memory for hexdump\n");
5017	} else
5018		lpfc_printf_log(phba, KERN_ERR, LOG_BG,
5019			"9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
5020		       _dump_buf_dif);
5021}
5022
5023/**
5024 * lpfc_post_init_setup - Perform necessary device post initialization setup.
5025 * @phba: pointer to lpfc hba data structure.
5026 *
5027 * This routine is invoked to perform all the necessary post initialization
5028 * setup for the device.
5029 **/
5030static void
5031lpfc_post_init_setup(struct lpfc_hba *phba)
5032{
5033	struct Scsi_Host  *shost;
5034	struct lpfc_adapter_event_header adapter_event;
5035
5036	/* Get the default values for Model Name and Description */
5037	lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
5038
5039	/*
5040	 * hba setup may have changed the hba_queue_depth so we need to
5041	 * adjust the value of can_queue.
5042	 */
5043	shost = pci_get_drvdata(phba->pcidev);
5044	shost->can_queue = phba->cfg_hba_queue_depth - 10;
5045	if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
5046		lpfc_setup_bg(phba, shost);
5047
5048	lpfc_host_attrib_init(shost);
5049
5050	if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
5051		spin_lock_irq(shost->host_lock);
5052		lpfc_poll_start_timer(phba);
5053		spin_unlock_irq(shost->host_lock);
5054	}
5055
5056	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5057			"0428 Perform SCSI scan\n");
5058	/* Send board arrival event to upper layer */
5059	adapter_event.event_type = FC_REG_ADAPTER_EVENT;
5060	adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
5061	fc_host_post_vendor_event(shost, fc_get_event_number(),
5062				  sizeof(adapter_event),
5063				  (char *) &adapter_event,
5064				  LPFC_NL_VENDOR_ID);
5065	return;
5066}
5067
5068/**
5069 * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
5070 * @phba: pointer to lpfc hba data structure.
5071 *
5072 * This routine is invoked to set up the PCI device memory space for device
5073 * with SLI-3 interface spec.
5074 *
5075 * Return codes
5076 * 	0 - successful
5077 * 	other values - error
5078 **/
5079static int
5080lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
5081{
5082	struct pci_dev *pdev;
5083	unsigned long bar0map_len, bar2map_len;
5084	int i, hbq_count;
5085	void *ptr;
5086	int error = -ENODEV;
5087
5088	/* Obtain PCI device reference */
5089	if (!phba->pcidev)
5090		return error;
5091	else
5092		pdev = phba->pcidev;
5093
5094	/* Set the device DMA mask size */
5095	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
5096	 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
5097		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
5098		 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
5099			return error;
5100		}
5101	}
5102
5103	/* Get the bus address of Bar0 and Bar2 and the number of bytes
5104	 * required by each mapping.
5105	 */
5106	phba->pci_bar0_map = pci_resource_start(pdev, 0);
5107	bar0map_len = pci_resource_len(pdev, 0);
5108
5109	phba->pci_bar2_map = pci_resource_start(pdev, 2);
5110	bar2map_len = pci_resource_len(pdev, 2);
5111
5112	/* Map HBA SLIM to a kernel virtual address. */
5113	phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
5114	if (!phba->slim_memmap_p) {
5115		dev_printk(KERN_ERR, &pdev->dev,
5116			   "ioremap failed for SLIM memory.\n");
5117		goto out;
5118	}
5119
5120	/* Map HBA Control Registers to a kernel virtual address. */
5121	phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
5122	if (!phba->ctrl_regs_memmap_p) {
5123		dev_printk(KERN_ERR, &pdev->dev,
5124			   "ioremap failed for HBA control registers.\n");
5125		goto out_iounmap_slim;
5126	}
5127
5128	/* Allocate memory for SLI-2 structures */
5129	phba->slim2p.virt = dma_alloc_coherent(&pdev->dev,
5130					       SLI2_SLIM_SIZE,
5131					       &phba->slim2p.phys,
5132					       GFP_KERNEL);
5133	if (!phba->slim2p.virt)
5134		goto out_iounmap;
5135
5136	memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE);
5137	phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
5138	phba->mbox_ext = (phba->slim2p.virt +
5139		offsetof(struct lpfc_sli2_slim, mbx_ext_words));
5140	phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
5141	phba->IOCBs = (phba->slim2p.virt +
5142		       offsetof(struct lpfc_sli2_slim, IOCBs));
5143
5144	phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
5145						 lpfc_sli_hbq_size(),
5146						 &phba->hbqslimp.phys,
5147						 GFP_KERNEL);
5148	if (!phba->hbqslimp.virt)
5149		goto out_free_slim;
5150
5151	hbq_count = lpfc_sli_hbq_count();
5152	ptr = phba->hbqslimp.virt;
5153	for (i = 0; i < hbq_count; ++i) {
5154		phba->hbqs[i].hbq_virt = ptr;
5155		INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
5156		ptr += (lpfc_hbq_defs[i]->entry_count *
5157			sizeof(struct lpfc_hbq_entry));
5158	}
5159	phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
5160	phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
5161
5162	memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
5163
5164	INIT_LIST_HEAD(&phba->rb_pend_list);
5165
5166	phba->MBslimaddr = phba->slim_memmap_p;
5167	phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
5168	phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
5169	phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
5170	phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
5171
5172	return 0;
5173
5174out_free_slim:
5175	dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
5176			  phba->slim2p.virt, phba->slim2p.phys);
5177out_iounmap:
5178	iounmap(phba->ctrl_regs_memmap_p);
5179out_iounmap_slim:
5180	iounmap(phba->slim_memmap_p);
5181out:
5182	return error;
5183}
5184
5185/**
5186 * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
5187 * @phba: pointer to lpfc hba data structure.
5188 *
5189 * This routine is invoked to unset the PCI device memory space for device
5190 * with SLI-3 interface spec.
5191 **/
5192static void
5193lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
5194{
5195	struct pci_dev *pdev;
5196
5197	/* Obtain PCI device reference */
5198	if (!phba->pcidev)
5199		return;
5200	else
5201		pdev = phba->pcidev;
5202
5203	/* Free coherent DMA memory allocated */
5204	dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
5205			  phba->hbqslimp.virt, phba->hbqslimp.phys);
5206	dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
5207			  phba->slim2p.virt, phba->slim2p.phys);
5208
5209	/* I/O memory unmap */
5210	iounmap(phba->ctrl_regs_memmap_p);
5211	iounmap(phba->slim_memmap_p);
5212
5213	return;
5214}
5215
5216/**
5217 * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
5218 * @phba: pointer to lpfc hba data structure.
5219 *
5220 * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
5221 * done and check status.
5222 *
5223 * Return 0 if successful, otherwise -ENODEV.
5224 **/
5225int
5226lpfc_sli4_post_status_check(struct lpfc_hba *phba)
5227{
5228	struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg;
5229	int i, port_error = -ENODEV;
5230
5231	if (!phba->sli4_hba.STAregaddr)
5232		return -ENODEV;
5233
5234	/* Wait up to 30 seconds for the SLI Port POST done and ready */
5235	for (i = 0; i < 3000; i++) {
5236		sta_reg.word0 = readl(phba->sli4_hba.STAregaddr);
5237		/* Encounter fatal POST error, break out */
5238		if (bf_get(lpfc_hst_state_perr, &sta_reg)) {
5239			port_error = -ENODEV;
5240			break;
5241		}
5242		if (LPFC_POST_STAGE_ARMFW_READY ==
5243		    bf_get(lpfc_hst_state_port_status, &sta_reg)) {
5244			port_error = 0;
5245			break;
5246		}
5247		msleep(10);
5248	}
5249
5250	if (port_error)
5251		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5252			"1408 Failure HBA POST Status: sta_reg=0x%x, "
5253			"perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, xrom=x%x, "
5254			"dl=x%x, pstatus=x%x\n", sta_reg.word0,
5255			bf_get(lpfc_hst_state_perr, &sta_reg),
5256			bf_get(lpfc_hst_state_sfi, &sta_reg),
5257			bf_get(lpfc_hst_state_nip, &sta_reg),
5258			bf_get(lpfc_hst_state_ipc, &sta_reg),
5259			bf_get(lpfc_hst_state_xrom, &sta_reg),
5260			bf_get(lpfc_hst_state_dl, &sta_reg),
5261			bf_get(lpfc_hst_state_port_status, &sta_reg));
5262
5263	/* Log device information */
5264	phba->sli4_hba.sli_intf.word0 = readl(phba->sli4_hba.SLIINTFregaddr);
5265	if (bf_get(lpfc_sli_intf_valid,
5266		   &phba->sli4_hba.sli_intf) == LPFC_SLI_INTF_VALID) {
5267		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5268				"2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
5269				"FeatureL1=0x%x, FeatureL2=0x%x\n",
5270				bf_get(lpfc_sli_intf_sli_family,
5271				       &phba->sli4_hba.sli_intf),
5272				bf_get(lpfc_sli_intf_slirev,
5273				       &phba->sli4_hba.sli_intf),
5274				bf_get(lpfc_sli_intf_featurelevel1,
5275				       &phba->sli4_hba.sli_intf),
5276				bf_get(lpfc_sli_intf_featurelevel2,
5277				       &phba->sli4_hba.sli_intf));
5278	}
5279	phba->sli4_hba.ue_mask_lo = readl(phba->sli4_hba.UEMASKLOregaddr);
5280	phba->sli4_hba.ue_mask_hi = readl(phba->sli4_hba.UEMASKHIregaddr);
5281	/* With uncoverable error, log the error message and return error */
5282	uerrlo_reg.word0 = readl(phba->sli4_hba.UERRLOregaddr);
5283	uerrhi_reg.word0 = readl(phba->sli4_hba.UERRHIregaddr);
5284	if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
5285	    (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
5286		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5287				"1422 HBA Unrecoverable error: "
5288				"uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
5289				"ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
5290				uerrlo_reg.word0, uerrhi_reg.word0,
5291				phba->sli4_hba.ue_mask_lo,
5292				phba->sli4_hba.ue_mask_hi);
5293		return -ENODEV;
5294	}
5295
5296	return port_error;
5297}
5298
5299/**
5300 * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
5301 * @phba: pointer to lpfc hba data structure.
5302 *
5303 * This routine is invoked to set up SLI4 BAR0 PCI config space register
5304 * memory map.
5305 **/
5306static void
5307lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
5308{
5309	phba->sli4_hba.UERRLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
5310					LPFC_UERR_STATUS_LO;
5311	phba->sli4_hba.UERRHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
5312					LPFC_UERR_STATUS_HI;
5313	phba->sli4_hba.UEMASKLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
5314					LPFC_UE_MASK_LO;
5315	phba->sli4_hba.UEMASKHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
5316					LPFC_UE_MASK_HI;
5317	phba->sli4_hba.SLIINTFregaddr = phba->sli4_hba.conf_regs_memmap_p +
5318					LPFC_SLI_INTF;
5319}
5320
5321/**
5322 * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
5323 * @phba: pointer to lpfc hba data structure.
5324 *
5325 * This routine is invoked to set up SLI4 BAR1 control status register (CSR)
5326 * memory map.
5327 **/
5328static void
5329lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
5330{
5331
5332	phba->sli4_hba.STAregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5333				    LPFC_HST_STATE;
5334	phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5335				    LPFC_HST_ISR0;
5336	phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5337				    LPFC_HST_IMR0;
5338	phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5339				     LPFC_HST_ISCR0;
5340	return;
5341}
5342
5343/**
5344 * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
5345 * @phba: pointer to lpfc hba data structure.
5346 * @vf: virtual function number
5347 *
5348 * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
5349 * based on the given viftual function number, @vf.
5350 *
5351 * Return 0 if successful, otherwise -ENODEV.
5352 **/
5353static int
5354lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
5355{
5356	if (vf > LPFC_VIR_FUNC_MAX)
5357		return -ENODEV;
5358
5359	phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5360				vf * LPFC_VFR_PAGE_SIZE + LPFC_RQ_DOORBELL);
5361	phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5362				vf * LPFC_VFR_PAGE_SIZE + LPFC_WQ_DOORBELL);
5363	phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5364				vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL);
5365	phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5366				vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL);
5367	phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5368				vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX);
5369	return 0;
5370}
5371
5372/**
5373 * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
5374 * @phba: pointer to lpfc hba data structure.
5375 *
5376 * This routine is invoked to create the bootstrap mailbox
5377 * region consistent with the SLI-4 interface spec.  This
5378 * routine allocates all memory necessary to communicate
5379 * mailbox commands to the port and sets up all alignment
5380 * needs.  No locks are expected to be held when calling
5381 * this routine.
5382 *
5383 * Return codes
5384 * 	0 - successful
5385 * 	ENOMEM - could not allocated memory.
5386 **/
5387static int
5388lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
5389{
5390	uint32_t bmbx_size;
5391	struct lpfc_dmabuf *dmabuf;
5392	struct dma_address *dma_address;
5393	uint32_t pa_addr;
5394	uint64_t phys_addr;
5395
5396	dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
5397	if (!dmabuf)
5398		return -ENOMEM;
5399
5400	/*
5401	 * The bootstrap mailbox region is comprised of 2 parts
5402	 * plus an alignment restriction of 16 bytes.
5403	 */
5404	bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
5405	dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
5406					  bmbx_size,
5407					  &dmabuf->phys,
5408					  GFP_KERNEL);
5409	if (!dmabuf->virt) {
5410		kfree(dmabuf);
5411		return -ENOMEM;
5412	}
5413	memset(dmabuf->virt, 0, bmbx_size);
5414
5415	/*
5416	 * Initialize the bootstrap mailbox pointers now so that the register
5417	 * operations are simple later.  The mailbox dma address is required
5418	 * to be 16-byte aligned.  Also align the virtual memory as each
5419	 * maibox is copied into the bmbx mailbox region before issuing the
5420	 * command to the port.
5421	 */
5422	phba->sli4_hba.bmbx.dmabuf = dmabuf;
5423	phba->sli4_hba.bmbx.bmbx_size = bmbx_size;
5424
5425	phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt,
5426					      LPFC_ALIGN_16_BYTE);
5427	phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys,
5428					      LPFC_ALIGN_16_BYTE);
5429
5430	/*
5431	 * Set the high and low physical addresses now.  The SLI4 alignment
5432	 * requirement is 16 bytes and the mailbox is posted to the port
5433	 * as two 30-bit addresses.  The other data is a bit marking whether
5434	 * the 30-bit address is the high or low address.
5435	 * Upcast bmbx aphys to 64bits so shift instruction compiles
5436	 * clean on 32 bit machines.
5437	 */
5438	dma_address = &phba->sli4_hba.bmbx.dma_address;
5439	phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys;
5440	pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff);
5441	dma_address->addr_hi = (uint32_t) ((pa_addr << 2) |
5442					   LPFC_BMBX_BIT1_ADDR_HI);
5443
5444	pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff);
5445	dma_address->addr_lo = (uint32_t) ((pa_addr << 2) |
5446					   LPFC_BMBX_BIT1_ADDR_LO);
5447	return 0;
5448}
5449
5450/**
5451 * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
5452 * @phba: pointer to lpfc hba data structure.
5453 *
5454 * This routine is invoked to teardown the bootstrap mailbox
5455 * region and release all host resources. This routine requires
5456 * the caller to ensure all mailbox commands recovered, no
5457 * additional mailbox comands are sent, and interrupts are disabled
5458 * before calling this routine.
5459 *
5460 **/
5461static void
5462lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
5463{
5464	dma_free_coherent(&phba->pcidev->dev,
5465			  phba->sli4_hba.bmbx.bmbx_size,
5466			  phba->sli4_hba.bmbx.dmabuf->virt,
5467			  phba->sli4_hba.bmbx.dmabuf->phys);
5468
5469	kfree(phba->sli4_hba.bmbx.dmabuf);
5470	memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx));
5471}
5472
5473/**
5474 * lpfc_sli4_read_config - Get the config parameters.
5475 * @phba: pointer to lpfc hba data structure.
5476 *
5477 * This routine is invoked to read the configuration parameters from the HBA.
5478 * The configuration parameters are used to set the base and maximum values
5479 * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
5480 * allocation for the port.
5481 *
5482 * Return codes
5483 * 	0 - successful
5484 * 	ENOMEM - No availble memory
5485 *      EIO - The mailbox failed to complete successfully.
5486 **/
5487static int
5488lpfc_sli4_read_config(struct lpfc_hba *phba)
5489{
5490	LPFC_MBOXQ_t *pmb;
5491	struct lpfc_mbx_read_config *rd_config;
5492	uint32_t rc = 0;
5493
5494	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5495	if (!pmb) {
5496		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5497				"2011 Unable to allocate memory for issuing "
5498				"SLI_CONFIG_SPECIAL mailbox command\n");
5499		return -ENOMEM;
5500	}
5501
5502	lpfc_read_config(phba, pmb);
5503
5504	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
5505	if (rc != MBX_SUCCESS) {
5506		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5507			"2012 Mailbox failed , mbxCmd x%x "
5508			"READ_CONFIG, mbxStatus x%x\n",
5509			bf_get(lpfc_mqe_command, &pmb->u.mqe),
5510			bf_get(lpfc_mqe_status, &pmb->u.mqe));
5511		rc = -EIO;
5512	} else {
5513		rd_config = &pmb->u.mqe.un.rd_config;
5514		phba->sli4_hba.max_cfg_param.max_xri =
5515			bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
5516		phba->sli4_hba.max_cfg_param.xri_base =
5517			bf_get(lpfc_mbx_rd_conf_xri_base, rd_config);
5518		phba->sli4_hba.max_cfg_param.max_vpi =
5519			bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config);
5520		phba->sli4_hba.max_cfg_param.vpi_base =
5521			bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config);
5522		phba->sli4_hba.max_cfg_param.max_rpi =
5523			bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
5524		phba->sli4_hba.max_cfg_param.rpi_base =
5525			bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config);
5526		phba->sli4_hba.max_cfg_param.max_vfi =
5527			bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config);
5528		phba->sli4_hba.max_cfg_param.vfi_base =
5529			bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
5530		phba->sli4_hba.max_cfg_param.max_fcfi =
5531			bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
5532		phba->sli4_hba.max_cfg_param.fcfi_base =
5533			bf_get(lpfc_mbx_rd_conf_fcfi_base, rd_config);
5534		phba->sli4_hba.max_cfg_param.max_eq =
5535			bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
5536		phba->sli4_hba.max_cfg_param.max_rq =
5537			bf_get(lpfc_mbx_rd_conf_rq_count, rd_config);
5538		phba->sli4_hba.max_cfg_param.max_wq =
5539			bf_get(lpfc_mbx_rd_conf_wq_count, rd_config);
5540		phba->sli4_hba.max_cfg_param.max_cq =
5541			bf_get(lpfc_mbx_rd_conf_cq_count, rd_config);
5542		phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config);
5543		phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base;
5544		phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
5545		phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
5546		phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
5547		phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
5548				(phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
5549		phba->max_vports = phba->max_vpi;
5550		lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5551				"2003 cfg params XRI(B:%d M:%d), "
5552				"VPI(B:%d M:%d) "
5553				"VFI(B:%d M:%d) "
5554				"RPI(B:%d M:%d) "
5555				"FCFI(B:%d M:%d)\n",
5556				phba->sli4_hba.max_cfg_param.xri_base,
5557				phba->sli4_hba.max_cfg_param.max_xri,
5558				phba->sli4_hba.max_cfg_param.vpi_base,
5559				phba->sli4_hba.max_cfg_param.max_vpi,
5560				phba->sli4_hba.max_cfg_param.vfi_base,
5561				phba->sli4_hba.max_cfg_param.max_vfi,
5562				phba->sli4_hba.max_cfg_param.rpi_base,
5563				phba->sli4_hba.max_cfg_param.max_rpi,
5564				phba->sli4_hba.max_cfg_param.fcfi_base,
5565				phba->sli4_hba.max_cfg_param.max_fcfi);
5566	}
5567	mempool_free(pmb, phba->mbox_mem_pool);
5568
5569	/* Reset the DFT_HBA_Q_DEPTH to the max xri  */
5570	if (phba->cfg_hba_queue_depth >
5571		(phba->sli4_hba.max_cfg_param.max_xri -
5572			lpfc_sli4_get_els_iocb_cnt(phba)))
5573		phba->cfg_hba_queue_depth =
5574			phba->sli4_hba.max_cfg_param.max_xri -
5575				lpfc_sli4_get_els_iocb_cnt(phba);
5576	return rc;
5577}
5578
5579/**
5580 * lpfc_dev_endian_order_setup - Notify the port of the host's endian order.
5581 * @phba: pointer to lpfc hba data structure.
5582 *
5583 * This routine is invoked to setup the host-side endian order to the
5584 * HBA consistent with the SLI-4 interface spec.
5585 *
5586 * Return codes
5587 * 	0 - successful
5588 * 	ENOMEM - No availble memory
5589 *      EIO - The mailbox failed to complete successfully.
5590 **/
5591static int
5592lpfc_setup_endian_order(struct lpfc_hba *phba)
5593{
5594	LPFC_MBOXQ_t *mboxq;
5595	uint32_t rc = 0;
5596	uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
5597				      HOST_ENDIAN_HIGH_WORD1};
5598
5599	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5600	if (!mboxq) {
5601		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5602				"0492 Unable to allocate memory for issuing "
5603				"SLI_CONFIG_SPECIAL mailbox command\n");
5604		return -ENOMEM;
5605	}
5606
5607	/*
5608	 * The SLI4_CONFIG_SPECIAL mailbox command requires the first two
5609	 * words to contain special data values and no other data.
5610	 */
5611	memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
5612	memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
5613	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5614	if (rc != MBX_SUCCESS) {
5615		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5616				"0493 SLI_CONFIG_SPECIAL mailbox failed with "
5617				"status x%x\n",
5618				rc);
5619		rc = -EIO;
5620	}
5621
5622	mempool_free(mboxq, phba->mbox_mem_pool);
5623	return rc;
5624}
5625
5626/**
5627 * lpfc_sli4_queue_create - Create all the SLI4 queues
5628 * @phba: pointer to lpfc hba data structure.
5629 *
5630 * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
5631 * operation. For each SLI4 queue type, the parameters such as queue entry
5632 * count (queue depth) shall be taken from the module parameter. For now,
5633 * we just use some constant number as place holder.
5634 *
5635 * Return codes
5636 *      0 - successful
5637 *      ENOMEM - No availble memory
5638 *      EIO - The mailbox failed to complete successfully.
5639 **/
5640static int
5641lpfc_sli4_queue_create(struct lpfc_hba *phba)
5642{
5643	struct lpfc_queue *qdesc;
5644	int fcp_eqidx, fcp_cqidx, fcp_wqidx;
5645	int cfg_fcp_wq_count;
5646	int cfg_fcp_eq_count;
5647
5648	/*
5649	 * Sanity check for confiugred queue parameters against the run-time
5650	 * device parameters
5651	 */
5652
5653	/* Sanity check on FCP fast-path WQ parameters */
5654	cfg_fcp_wq_count = phba->cfg_fcp_wq_count;
5655	if (cfg_fcp_wq_count >
5656	    (phba->sli4_hba.max_cfg_param.max_wq - LPFC_SP_WQN_DEF)) {
5657		cfg_fcp_wq_count = phba->sli4_hba.max_cfg_param.max_wq -
5658				   LPFC_SP_WQN_DEF;
5659		if (cfg_fcp_wq_count < LPFC_FP_WQN_MIN) {
5660			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5661					"2581 Not enough WQs (%d) from "
5662					"the pci function for supporting "
5663					"FCP WQs (%d)\n",
5664					phba->sli4_hba.max_cfg_param.max_wq,
5665					phba->cfg_fcp_wq_count);
5666			goto out_error;
5667		}
5668		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5669				"2582 Not enough WQs (%d) from the pci "
5670				"function for supporting the requested "
5671				"FCP WQs (%d), the actual FCP WQs can "
5672				"be supported: %d\n",
5673				phba->sli4_hba.max_cfg_param.max_wq,
5674				phba->cfg_fcp_wq_count, cfg_fcp_wq_count);
5675	}
5676	/* The actual number of FCP work queues adopted */
5677	phba->cfg_fcp_wq_count = cfg_fcp_wq_count;
5678
5679	/* Sanity check on FCP fast-path EQ parameters */
5680	cfg_fcp_eq_count = phba->cfg_fcp_eq_count;
5681	if (cfg_fcp_eq_count >
5682	    (phba->sli4_hba.max_cfg_param.max_eq - LPFC_SP_EQN_DEF)) {
5683		cfg_fcp_eq_count = phba->sli4_hba.max_cfg_param.max_eq -
5684				   LPFC_SP_EQN_DEF;
5685		if (cfg_fcp_eq_count < LPFC_FP_EQN_MIN) {
5686			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5687					"2574 Not enough EQs (%d) from the "
5688					"pci function for supporting FCP "
5689					"EQs (%d)\n",
5690					phba->sli4_hba.max_cfg_param.max_eq,
5691					phba->cfg_fcp_eq_count);
5692			goto out_error;
5693		}
5694		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5695				"2575 Not enough EQs (%d) from the pci "
5696				"function for supporting the requested "
5697				"FCP EQs (%d), the actual FCP EQs can "
5698				"be supported: %d\n",
5699				phba->sli4_hba.max_cfg_param.max_eq,
5700				phba->cfg_fcp_eq_count, cfg_fcp_eq_count);
5701	}
5702	/* It does not make sense to have more EQs than WQs */
5703	if (cfg_fcp_eq_count > phba->cfg_fcp_wq_count) {
5704		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5705				"2593 The FCP EQ count(%d) cannot be greater "
5706				"than the FCP WQ count(%d), limiting the "
5707				"FCP EQ count to %d\n", cfg_fcp_eq_count,
5708				phba->cfg_fcp_wq_count,
5709				phba->cfg_fcp_wq_count);
5710		cfg_fcp_eq_count = phba->cfg_fcp_wq_count;
5711	}
5712	/* The actual number of FCP event queues adopted */
5713	phba->cfg_fcp_eq_count = cfg_fcp_eq_count;
5714	/* The overall number of event queues used */
5715	phba->sli4_hba.cfg_eqn = phba->cfg_fcp_eq_count + LPFC_SP_EQN_DEF;
5716
5717	/*
5718	 * Create Event Queues (EQs)
5719	 */
5720
5721	/* Get EQ depth from module parameter, fake the default for now */
5722	phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
5723	phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
5724
5725	/* Create slow path event queue */
5726	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
5727				      phba->sli4_hba.eq_ecount);
5728	if (!qdesc) {
5729		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5730				"0496 Failed allocate slow-path EQ\n");
5731		goto out_error;
5732	}
5733	phba->sli4_hba.sp_eq = qdesc;
5734
5735	/* Create fast-path FCP Event Queue(s) */
5736	phba->sli4_hba.fp_eq = kzalloc((sizeof(struct lpfc_queue *) *
5737			       phba->cfg_fcp_eq_count), GFP_KERNEL);
5738	if (!phba->sli4_hba.fp_eq) {
5739		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5740				"2576 Failed allocate memory for fast-path "
5741				"EQ record array\n");
5742		goto out_free_sp_eq;
5743	}
5744	for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) {
5745		qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
5746					      phba->sli4_hba.eq_ecount);
5747		if (!qdesc) {
5748			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5749					"0497 Failed allocate fast-path EQ\n");
5750			goto out_free_fp_eq;
5751		}
5752		phba->sli4_hba.fp_eq[fcp_eqidx] = qdesc;
5753	}
5754
5755	/*
5756	 * Create Complete Queues (CQs)
5757	 */
5758
5759	/* Get CQ depth from module parameter, fake the default for now */
5760	phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
5761	phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
5762
5763	/* Create slow-path Mailbox Command Complete Queue */
5764	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5765				      phba->sli4_hba.cq_ecount);
5766	if (!qdesc) {
5767		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5768				"0500 Failed allocate slow-path mailbox CQ\n");
5769		goto out_free_fp_eq;
5770	}
5771	phba->sli4_hba.mbx_cq = qdesc;
5772
5773	/* Create slow-path ELS Complete Queue */
5774	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5775				      phba->sli4_hba.cq_ecount);
5776	if (!qdesc) {
5777		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5778				"0501 Failed allocate slow-path ELS CQ\n");
5779		goto out_free_mbx_cq;
5780	}
5781	phba->sli4_hba.els_cq = qdesc;
5782
5783
5784	/* Create fast-path FCP Completion Queue(s), one-to-one with EQs */
5785	phba->sli4_hba.fcp_cq = kzalloc((sizeof(struct lpfc_queue *) *
5786				phba->cfg_fcp_eq_count), GFP_KERNEL);
5787	if (!phba->sli4_hba.fcp_cq) {
5788		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5789				"2577 Failed allocate memory for fast-path "
5790				"CQ record array\n");
5791		goto out_free_els_cq;
5792	}
5793	for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
5794		qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5795					      phba->sli4_hba.cq_ecount);
5796		if (!qdesc) {
5797			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5798					"0499 Failed allocate fast-path FCP "
5799					"CQ (%d)\n", fcp_cqidx);
5800			goto out_free_fcp_cq;
5801		}
5802		phba->sli4_hba.fcp_cq[fcp_cqidx] = qdesc;
5803	}
5804
5805	/* Create Mailbox Command Queue */
5806	phba->sli4_hba.mq_esize = LPFC_MQE_SIZE;
5807	phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT;
5808
5809	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize,
5810				      phba->sli4_hba.mq_ecount);
5811	if (!qdesc) {
5812		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5813				"0505 Failed allocate slow-path MQ\n");
5814		goto out_free_fcp_cq;
5815	}
5816	phba->sli4_hba.mbx_wq = qdesc;
5817
5818	/*
5819	 * Create all the Work Queues (WQs)
5820	 */
5821	phba->sli4_hba.wq_esize = LPFC_WQE_SIZE;
5822	phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT;
5823
5824	/* Create slow-path ELS Work Queue */
5825	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
5826				      phba->sli4_hba.wq_ecount);
5827	if (!qdesc) {
5828		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5829				"0504 Failed allocate slow-path ELS WQ\n");
5830		goto out_free_mbx_wq;
5831	}
5832	phba->sli4_hba.els_wq = qdesc;
5833
5834	/* Create fast-path FCP Work Queue(s) */
5835	phba->sli4_hba.fcp_wq = kzalloc((sizeof(struct lpfc_queue *) *
5836				phba->cfg_fcp_wq_count), GFP_KERNEL);
5837	if (!phba->sli4_hba.fcp_wq) {
5838		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5839				"2578 Failed allocate memory for fast-path "
5840				"WQ record array\n");
5841		goto out_free_els_wq;
5842	}
5843	for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) {
5844		qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
5845					      phba->sli4_hba.wq_ecount);
5846		if (!qdesc) {
5847			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5848					"0503 Failed allocate fast-path FCP "
5849					"WQ (%d)\n", fcp_wqidx);
5850			goto out_free_fcp_wq;
5851		}
5852		phba->sli4_hba.fcp_wq[fcp_wqidx] = qdesc;
5853	}
5854
5855	/*
5856	 * Create Receive Queue (RQ)
5857	 */
5858	phba->sli4_hba.rq_esize = LPFC_RQE_SIZE;
5859	phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT;
5860
5861	/* Create Receive Queue for header */
5862	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
5863				      phba->sli4_hba.rq_ecount);
5864	if (!qdesc) {
5865		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5866				"0506 Failed allocate receive HRQ\n");
5867		goto out_free_fcp_wq;
5868	}
5869	phba->sli4_hba.hdr_rq = qdesc;
5870
5871	/* Create Receive Queue for data */
5872	qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
5873				      phba->sli4_hba.rq_ecount);
5874	if (!qdesc) {
5875		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5876				"0507 Failed allocate receive DRQ\n");
5877		goto out_free_hdr_rq;
5878	}
5879	phba->sli4_hba.dat_rq = qdesc;
5880
5881	return 0;
5882
5883out_free_hdr_rq:
5884	lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq);
5885	phba->sli4_hba.hdr_rq = NULL;
5886out_free_fcp_wq:
5887	for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--) {
5888		lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_wqidx]);
5889		phba->sli4_hba.fcp_wq[fcp_wqidx] = NULL;
5890	}
5891	kfree(phba->sli4_hba.fcp_wq);
5892out_free_els_wq:
5893	lpfc_sli4_queue_free(phba->sli4_hba.els_wq);
5894	phba->sli4_hba.els_wq = NULL;
5895out_free_mbx_wq:
5896	lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq);
5897	phba->sli4_hba.mbx_wq = NULL;
5898out_free_fcp_cq:
5899	for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--) {
5900		lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_cqidx]);
5901		phba->sli4_hba.fcp_cq[fcp_cqidx] = NULL;
5902	}
5903	kfree(phba->sli4_hba.fcp_cq);
5904out_free_els_cq:
5905	lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
5906	phba->sli4_hba.els_cq = NULL;
5907out_free_mbx_cq:
5908	lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq);
5909	phba->sli4_hba.mbx_cq = NULL;
5910out_free_fp_eq:
5911	for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--) {
5912		lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_eqidx]);
5913		phba->sli4_hba.fp_eq[fcp_eqidx] = NULL;
5914	}
5915	kfree(phba->sli4_hba.fp_eq);
5916out_free_sp_eq:
5917	lpfc_sli4_queue_free(phba->sli4_hba.sp_eq);
5918	phba->sli4_hba.sp_eq = NULL;
5919out_error:
5920	return -ENOMEM;
5921}
5922
5923/**
5924 * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
5925 * @phba: pointer to lpfc hba data structure.
5926 *
5927 * This routine is invoked to release all the SLI4 queues with the FCoE HBA
5928 * operation.
5929 *
5930 * Return codes
5931 *      0 - successful
5932 *      ENOMEM - No availble memory
5933 *      EIO - The mailbox failed to complete successfully.
5934 **/
5935static void
5936lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
5937{
5938	int fcp_qidx;
5939
5940	/* Release mailbox command work queue */
5941	lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq);
5942	phba->sli4_hba.mbx_wq = NULL;
5943
5944	/* Release ELS work queue */
5945	lpfc_sli4_queue_free(phba->sli4_hba.els_wq);
5946	phba->sli4_hba.els_wq = NULL;
5947
5948	/* Release FCP work queue */
5949	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++)
5950		lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_qidx]);
5951	kfree(phba->sli4_hba.fcp_wq);
5952	phba->sli4_hba.fcp_wq = NULL;
5953
5954	/* Release unsolicited receive queue */
5955	lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq);
5956	phba->sli4_hba.hdr_rq = NULL;
5957	lpfc_sli4_queue_free(phba->sli4_hba.dat_rq);
5958	phba->sli4_hba.dat_rq = NULL;
5959
5960	/* Release ELS complete queue */
5961	lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
5962	phba->sli4_hba.els_cq = NULL;
5963
5964	/* Release mailbox command complete queue */
5965	lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq);
5966	phba->sli4_hba.mbx_cq = NULL;
5967
5968	/* Release FCP response complete queue */
5969	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5970		lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_qidx]);
5971	kfree(phba->sli4_hba.fcp_cq);
5972	phba->sli4_hba.fcp_cq = NULL;
5973
5974	/* Release fast-path event queue */
5975	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5976		lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_qidx]);
5977	kfree(phba->sli4_hba.fp_eq);
5978	phba->sli4_hba.fp_eq = NULL;
5979
5980	/* Release slow-path event queue */
5981	lpfc_sli4_queue_free(phba->sli4_hba.sp_eq);
5982	phba->sli4_hba.sp_eq = NULL;
5983
5984	return;
5985}
5986
5987/**
5988 * lpfc_sli4_queue_setup - Set up all the SLI4 queues
5989 * @phba: pointer to lpfc hba data structure.
5990 *
5991 * This routine is invoked to set up all the SLI4 queues for the FCoE HBA
5992 * operation.
5993 *
5994 * Return codes
5995 *      0 - successful
5996 *      ENOMEM - No availble memory
5997 *      EIO - The mailbox failed to complete successfully.
5998 **/
5999int
6000lpfc_sli4_queue_setup(struct lpfc_hba *phba)
6001{
6002	int rc = -ENOMEM;
6003	int fcp_eqidx, fcp_cqidx, fcp_wqidx;
6004	int fcp_cq_index = 0;
6005
6006	/*
6007	 * Set up Event Queues (EQs)
6008	 */
6009
6010	/* Set up slow-path event queue */
6011	if (!phba->sli4_hba.sp_eq) {
6012		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6013				"0520 Slow-path EQ not allocated\n");
6014		goto out_error;
6015	}
6016	rc = lpfc_eq_create(phba, phba->sli4_hba.sp_eq,
6017			    LPFC_SP_DEF_IMAX);
6018	if (rc) {
6019		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6020				"0521 Failed setup of slow-path EQ: "
6021				"rc = 0x%x\n", rc);
6022		goto out_error;
6023	}
6024	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6025			"2583 Slow-path EQ setup: queue-id=%d\n",
6026			phba->sli4_hba.sp_eq->queue_id);
6027
6028	/* Set up fast-path event queue */
6029	for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) {
6030		if (!phba->sli4_hba.fp_eq[fcp_eqidx]) {
6031			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6032					"0522 Fast-path EQ (%d) not "
6033					"allocated\n", fcp_eqidx);
6034			goto out_destroy_fp_eq;
6035		}
6036		rc = lpfc_eq_create(phba, phba->sli4_hba.fp_eq[fcp_eqidx],
6037				    phba->cfg_fcp_imax);
6038		if (rc) {
6039			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6040					"0523 Failed setup of fast-path EQ "
6041					"(%d), rc = 0x%x\n", fcp_eqidx, rc);
6042			goto out_destroy_fp_eq;
6043		}
6044		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6045				"2584 Fast-path EQ setup: "
6046				"queue[%d]-id=%d\n", fcp_eqidx,
6047				phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id);
6048	}
6049
6050	/*
6051	 * Set up Complete Queues (CQs)
6052	 */
6053
6054	/* Set up slow-path MBOX Complete Queue as the first CQ */
6055	if (!phba->sli4_hba.mbx_cq) {
6056		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6057				"0528 Mailbox CQ not allocated\n");
6058		goto out_destroy_fp_eq;
6059	}
6060	rc = lpfc_cq_create(phba, phba->sli4_hba.mbx_cq, phba->sli4_hba.sp_eq,
6061			    LPFC_MCQ, LPFC_MBOX);
6062	if (rc) {
6063		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6064				"0529 Failed setup of slow-path mailbox CQ: "
6065				"rc = 0x%x\n", rc);
6066		goto out_destroy_fp_eq;
6067	}
6068	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6069			"2585 MBX CQ setup: cq-id=%d, parent eq-id=%d\n",
6070			phba->sli4_hba.mbx_cq->queue_id,
6071			phba->sli4_hba.sp_eq->queue_id);
6072
6073	/* Set up slow-path ELS Complete Queue */
6074	if (!phba->sli4_hba.els_cq) {
6075		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6076				"0530 ELS CQ not allocated\n");
6077		goto out_destroy_mbx_cq;
6078	}
6079	rc = lpfc_cq_create(phba, phba->sli4_hba.els_cq, phba->sli4_hba.sp_eq,
6080			    LPFC_WCQ, LPFC_ELS);
6081	if (rc) {
6082		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6083				"0531 Failed setup of slow-path ELS CQ: "
6084				"rc = 0x%x\n", rc);
6085		goto out_destroy_mbx_cq;
6086	}
6087	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6088			"2586 ELS CQ setup: cq-id=%d, parent eq-id=%d\n",
6089			phba->sli4_hba.els_cq->queue_id,
6090			phba->sli4_hba.sp_eq->queue_id);
6091
6092	/* Set up fast-path FCP Response Complete Queue */
6093	for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
6094		if (!phba->sli4_hba.fcp_cq[fcp_cqidx]) {
6095			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6096					"0526 Fast-path FCP CQ (%d) not "
6097					"allocated\n", fcp_cqidx);
6098			goto out_destroy_fcp_cq;
6099		}
6100		rc = lpfc_cq_create(phba, phba->sli4_hba.fcp_cq[fcp_cqidx],
6101				    phba->sli4_hba.fp_eq[fcp_cqidx],
6102				    LPFC_WCQ, LPFC_FCP);
6103		if (rc) {
6104			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6105					"0527 Failed setup of fast-path FCP "
6106					"CQ (%d), rc = 0x%x\n", fcp_cqidx, rc);
6107			goto out_destroy_fcp_cq;
6108		}
6109		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6110				"2588 FCP CQ setup: cq[%d]-id=%d, "
6111				"parent eq[%d]-id=%d\n",
6112				fcp_cqidx,
6113				phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id,
6114				fcp_cqidx,
6115				phba->sli4_hba.fp_eq[fcp_cqidx]->queue_id);
6116	}
6117
6118	/*
6119	 * Set up all the Work Queues (WQs)
6120	 */
6121
6122	/* Set up Mailbox Command Queue */
6123	if (!phba->sli4_hba.mbx_wq) {
6124		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6125				"0538 Slow-path MQ not allocated\n");
6126		goto out_destroy_fcp_cq;
6127	}
6128	rc = lpfc_mq_create(phba, phba->sli4_hba.mbx_wq,
6129			    phba->sli4_hba.mbx_cq, LPFC_MBOX);
6130	if (rc) {
6131		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6132				"0539 Failed setup of slow-path MQ: "
6133				"rc = 0x%x\n", rc);
6134		goto out_destroy_fcp_cq;
6135	}
6136	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6137			"2589 MBX MQ setup: wq-id=%d, parent cq-id=%d\n",
6138			phba->sli4_hba.mbx_wq->queue_id,
6139			phba->sli4_hba.mbx_cq->queue_id);
6140
6141	/* Set up slow-path ELS Work Queue */
6142	if (!phba->sli4_hba.els_wq) {
6143		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6144				"0536 Slow-path ELS WQ not allocated\n");
6145		goto out_destroy_mbx_wq;
6146	}
6147	rc = lpfc_wq_create(phba, phba->sli4_hba.els_wq,
6148			    phba->sli4_hba.els_cq, LPFC_ELS);
6149	if (rc) {
6150		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6151				"0537 Failed setup of slow-path ELS WQ: "
6152				"rc = 0x%x\n", rc);
6153		goto out_destroy_mbx_wq;
6154	}
6155	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6156			"2590 ELS WQ setup: wq-id=%d, parent cq-id=%d\n",
6157			phba->sli4_hba.els_wq->queue_id,
6158			phba->sli4_hba.els_cq->queue_id);
6159
6160	/* Set up fast-path FCP Work Queue */
6161	for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) {
6162		if (!phba->sli4_hba.fcp_wq[fcp_wqidx]) {
6163			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6164					"0534 Fast-path FCP WQ (%d) not "
6165					"allocated\n", fcp_wqidx);
6166			goto out_destroy_fcp_wq;
6167		}
6168		rc = lpfc_wq_create(phba, phba->sli4_hba.fcp_wq[fcp_wqidx],
6169				    phba->sli4_hba.fcp_cq[fcp_cq_index],
6170				    LPFC_FCP);
6171		if (rc) {
6172			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6173					"0535 Failed setup of fast-path FCP "
6174					"WQ (%d), rc = 0x%x\n", fcp_wqidx, rc);
6175			goto out_destroy_fcp_wq;
6176		}
6177		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6178				"2591 FCP WQ setup: wq[%d]-id=%d, "
6179				"parent cq[%d]-id=%d\n",
6180				fcp_wqidx,
6181				phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
6182				fcp_cq_index,
6183				phba->sli4_hba.fcp_cq[fcp_cq_index]->queue_id);
6184		/* Round robin FCP Work Queue's Completion Queue assignment */
6185		fcp_cq_index = ((fcp_cq_index + 1) % phba->cfg_fcp_eq_count);
6186	}
6187
6188	/*
6189	 * Create Receive Queue (RQ)
6190	 */
6191	if (!phba->sli4_hba.hdr_rq || !phba->sli4_hba.dat_rq) {
6192		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6193				"0540 Receive Queue not allocated\n");
6194		goto out_destroy_fcp_wq;
6195	}
6196	rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
6197			    phba->sli4_hba.els_cq, LPFC_USOL);
6198	if (rc) {
6199		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6200				"0541 Failed setup of Receive Queue: "
6201				"rc = 0x%x\n", rc);
6202		goto out_destroy_fcp_wq;
6203	}
6204	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6205			"2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d "
6206			"parent cq-id=%d\n",
6207			phba->sli4_hba.hdr_rq->queue_id,
6208			phba->sli4_hba.dat_rq->queue_id,
6209			phba->sli4_hba.els_cq->queue_id);
6210	return 0;
6211
6212out_destroy_fcp_wq:
6213	for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--)
6214		lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_wqidx]);
6215	lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
6216out_destroy_mbx_wq:
6217	lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
6218out_destroy_fcp_cq:
6219	for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--)
6220		lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_cqidx]);
6221	lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
6222out_destroy_mbx_cq:
6223	lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
6224out_destroy_fp_eq:
6225	for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--)
6226		lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_eqidx]);
6227	lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq);
6228out_error:
6229	return rc;
6230}
6231
6232/**
6233 * lpfc_sli4_queue_unset - Unset all the SLI4 queues
6234 * @phba: pointer to lpfc hba data structure.
6235 *
6236 * This routine is invoked to unset all the SLI4 queues with the FCoE HBA
6237 * operation.
6238 *
6239 * Return codes
6240 *      0 - successful
6241 *      ENOMEM - No availble memory
6242 *      EIO - The mailbox failed to complete successfully.
6243 **/
6244void
6245lpfc_sli4_queue_unset(struct lpfc_hba *phba)
6246{
6247	int fcp_qidx;
6248
6249	/* Unset mailbox command work queue */
6250	lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
6251	/* Unset ELS work queue */
6252	lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
6253	/* Unset unsolicited receive queue */
6254	lpfc_rq_destroy(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq);
6255	/* Unset FCP work queue */
6256	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++)
6257		lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_qidx]);
6258	/* Unset mailbox command complete queue */
6259	lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
6260	/* Unset ELS complete queue */
6261	lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
6262	/* Unset FCP response complete queue */
6263	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
6264		lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_qidx]);
6265	/* Unset fast-path event queue */
6266	for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
6267		lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_qidx]);
6268	/* Unset slow-path event queue */
6269	lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq);
6270}
6271
6272/**
6273 * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool
6274 * @phba: pointer to lpfc hba data structure.
6275 *
6276 * This routine is invoked to allocate and set up a pool of completion queue
6277 * events. The body of the completion queue event is a completion queue entry
6278 * CQE. For now, this pool is used for the interrupt service routine to queue
6279 * the following HBA completion queue events for the worker thread to process:
6280 *   - Mailbox asynchronous events
6281 *   - Receive queue completion unsolicited events
6282 * Later, this can be used for all the slow-path events.
6283 *
6284 * Return codes
6285 *      0 - successful
6286 *      -ENOMEM - No availble memory
6287 **/
6288static int
6289lpfc_sli4_cq_event_pool_create(struct lpfc_hba *phba)
6290{
6291	struct lpfc_cq_event *cq_event;
6292	int i;
6293
6294	for (i = 0; i < (4 * phba->sli4_hba.cq_ecount); i++) {
6295		cq_event = kmalloc(sizeof(struct lpfc_cq_event), GFP_KERNEL);
6296		if (!cq_event)
6297			goto out_pool_create_fail;
6298		list_add_tail(&cq_event->list,
6299			      &phba->sli4_hba.sp_cqe_event_pool);
6300	}
6301	return 0;
6302
6303out_pool_create_fail:
6304	lpfc_sli4_cq_event_pool_destroy(phba);
6305	return -ENOMEM;
6306}
6307
6308/**
6309 * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool
6310 * @phba: pointer to lpfc hba data structure.
6311 *
6312 * This routine is invoked to free the pool of completion queue events at
6313 * driver unload time. Note that, it is the responsibility of the driver
6314 * cleanup routine to free all the outstanding completion-queue events
6315 * allocated from this pool back into the pool before invoking this routine
6316 * to destroy the pool.
6317 **/
6318static void
6319lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *phba)
6320{
6321	struct lpfc_cq_event *cq_event, *next_cq_event;
6322
6323	list_for_each_entry_safe(cq_event, next_cq_event,
6324				 &phba->sli4_hba.sp_cqe_event_pool, list) {
6325		list_del(&cq_event->list);
6326		kfree(cq_event);
6327	}
6328}
6329
6330/**
6331 * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
6332 * @phba: pointer to lpfc hba data structure.
6333 *
6334 * This routine is the lock free version of the API invoked to allocate a
6335 * completion-queue event from the free pool.
6336 *
6337 * Return: Pointer to the newly allocated completion-queue event if successful
6338 *         NULL otherwise.
6339 **/
6340struct lpfc_cq_event *
6341__lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
6342{
6343	struct lpfc_cq_event *cq_event = NULL;
6344
6345	list_remove_head(&phba->sli4_hba.sp_cqe_event_pool, cq_event,
6346			 struct lpfc_cq_event, list);
6347	return cq_event;
6348}
6349
6350/**
6351 * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
6352 * @phba: pointer to lpfc hba data structure.
6353 *
6354 * This routine is the lock version of the API invoked to allocate a
6355 * completion-queue event from the free pool.
6356 *
6357 * Return: Pointer to the newly allocated completion-queue event if successful
6358 *         NULL otherwise.
6359 **/
6360struct lpfc_cq_event *
6361lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
6362{
6363	struct lpfc_cq_event *cq_event;
6364	unsigned long iflags;
6365
6366	spin_lock_irqsave(&phba->hbalock, iflags);
6367	cq_event = __lpfc_sli4_cq_event_alloc(phba);
6368	spin_unlock_irqrestore(&phba->hbalock, iflags);
6369	return cq_event;
6370}
6371
6372/**
6373 * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
6374 * @phba: pointer to lpfc hba data structure.
6375 * @cq_event: pointer to the completion queue event to be freed.
6376 *
6377 * This routine is the lock free version of the API invoked to release a
6378 * completion-queue event back into the free pool.
6379 **/
6380void
6381__lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
6382			     struct lpfc_cq_event *cq_event)
6383{
6384	list_add_tail(&cq_event->list, &phba->sli4_hba.sp_cqe_event_pool);
6385}
6386
6387/**
6388 * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
6389 * @phba: pointer to lpfc hba data structure.
6390 * @cq_event: pointer to the completion queue event to be freed.
6391 *
6392 * This routine is the lock version of the API invoked to release a
6393 * completion-queue event back into the free pool.
6394 **/
6395void
6396lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
6397			   struct lpfc_cq_event *cq_event)
6398{
6399	unsigned long iflags;
6400	spin_lock_irqsave(&phba->hbalock, iflags);
6401	__lpfc_sli4_cq_event_release(phba, cq_event);
6402	spin_unlock_irqrestore(&phba->hbalock, iflags);
6403}
6404
6405/**
6406 * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool
6407 * @phba: pointer to lpfc hba data structure.
6408 *
6409 * This routine is to free all the pending completion-queue events to the
6410 * back into the free pool for device reset.
6411 **/
6412static void
6413lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba)
6414{
6415	LIST_HEAD(cqelist);
6416	struct lpfc_cq_event *cqe;
6417	unsigned long iflags;
6418
6419	/* Retrieve all the pending WCQEs from pending WCQE lists */
6420	spin_lock_irqsave(&phba->hbalock, iflags);
6421	/* Pending FCP XRI abort events */
6422	list_splice_init(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue,
6423			 &cqelist);
6424	/* Pending ELS XRI abort events */
6425	list_splice_init(&phba->sli4_hba.sp_els_xri_aborted_work_queue,
6426			 &cqelist);
6427	/* Pending asynnc events */
6428	list_splice_init(&phba->sli4_hba.sp_asynce_work_queue,
6429			 &cqelist);
6430	spin_unlock_irqrestore(&phba->hbalock, iflags);
6431
6432	while (!list_empty(&cqelist)) {
6433		list_remove_head(&cqelist, cqe, struct lpfc_cq_event, list);
6434		lpfc_sli4_cq_event_release(phba, cqe);
6435	}
6436}
6437
6438/**
6439 * lpfc_pci_function_reset - Reset pci function.
6440 * @phba: pointer to lpfc hba data structure.
6441 *
6442 * This routine is invoked to request a PCI function reset. It will destroys
6443 * all resources assigned to the PCI function which originates this request.
6444 *
6445 * Return codes
6446 *      0 - successful
6447 *      ENOMEM - No availble memory
6448 *      EIO - The mailbox failed to complete successfully.
6449 **/
6450int
6451lpfc_pci_function_reset(struct lpfc_hba *phba)
6452{
6453	LPFC_MBOXQ_t *mboxq;
6454	uint32_t rc = 0;
6455	uint32_t shdr_status, shdr_add_status;
6456	union lpfc_sli4_cfg_shdr *shdr;
6457
6458	mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6459	if (!mboxq) {
6460		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6461				"0494 Unable to allocate memory for issuing "
6462				"SLI_FUNCTION_RESET mailbox command\n");
6463		return -ENOMEM;
6464	}
6465
6466	/* Set up PCI function reset SLI4_CONFIG mailbox-ioctl command */
6467	lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
6468			 LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
6469			 LPFC_SLI4_MBX_EMBED);
6470	rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6471	shdr = (union lpfc_sli4_cfg_shdr *)
6472		&mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
6473	shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
6474	shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
6475	if (rc != MBX_TIMEOUT)
6476		mempool_free(mboxq, phba->mbox_mem_pool);
6477	if (shdr_status || shdr_add_status || rc) {
6478		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6479				"0495 SLI_FUNCTION_RESET mailbox failed with "
6480				"status x%x add_status x%x, mbx status x%x\n",
6481				shdr_status, shdr_add_status, rc);
6482		rc = -ENXIO;
6483	}
6484	return rc;
6485}
6486
6487/**
6488 * lpfc_sli4_send_nop_mbox_cmds - Send sli-4 nop mailbox commands
6489 * @phba: pointer to lpfc hba data structure.
6490 * @cnt: number of nop mailbox commands to send.
6491 *
6492 * This routine is invoked to send a number @cnt of NOP mailbox command and
6493 * wait for each command to complete.
6494 *
6495 * Return: the number of NOP mailbox command completed.
6496 **/
6497static int
6498lpfc_sli4_send_nop_mbox_cmds(struct lpfc_hba *phba, uint32_t cnt)
6499{
6500	LPFC_MBOXQ_t *mboxq;
6501	int length, cmdsent;
6502	uint32_t mbox_tmo;
6503	uint32_t rc = 0;
6504	uint32_t shdr_status, shdr_add_status;
6505	union lpfc_sli4_cfg_shdr *shdr;
6506
6507	if (cnt == 0) {
6508		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6509				"2518 Requested to send 0 NOP mailbox cmd\n");
6510		return cnt;
6511	}
6512
6513	mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6514	if (!mboxq) {
6515		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6516				"2519 Unable to allocate memory for issuing "
6517				"NOP mailbox command\n");
6518		return 0;
6519	}
6520
6521	/* Set up NOP SLI4_CONFIG mailbox-ioctl command */
6522	length = (sizeof(struct lpfc_mbx_nop) -
6523		  sizeof(struct lpfc_sli4_cfg_mhdr));
6524	lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
6525			 LPFC_MBOX_OPCODE_NOP, length, LPFC_SLI4_MBX_EMBED);
6526
6527	mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
6528	for (cmdsent = 0; cmdsent < cnt; cmdsent++) {
6529		if (!phba->sli4_hba.intr_enable)
6530			rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6531		else
6532			rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
6533		if (rc == MBX_TIMEOUT)
6534			break;
6535		/* Check return status */
6536		shdr = (union lpfc_sli4_cfg_shdr *)
6537			&mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
6538		shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
6539		shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
6540					 &shdr->response);
6541		if (shdr_status || shdr_add_status || rc) {
6542			lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6543					"2520 NOP mailbox command failed "
6544					"status x%x add_status x%x mbx "
6545					"status x%x\n", shdr_status,
6546					shdr_add_status, rc);
6547			break;
6548		}
6549	}
6550
6551	if (rc != MBX_TIMEOUT)
6552		mempool_free(mboxq, phba->mbox_mem_pool);
6553
6554	return cmdsent;
6555}
6556
6557/**
6558 * lpfc_sli4_fcfi_unreg - Unregister fcfi to device
6559 * @phba: pointer to lpfc hba data structure.
6560 * @fcfi: fcf index.
6561 *
6562 * This routine is invoked to unregister a FCFI from device.
6563 **/
6564void
6565lpfc_sli4_fcfi_unreg(struct lpfc_hba *phba, uint16_t fcfi)
6566{
6567	LPFC_MBOXQ_t *mbox;
6568	uint32_t mbox_tmo;
6569	int rc;
6570	unsigned long flags;
6571
6572	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6573
6574	if (!mbox)
6575		return;
6576
6577	lpfc_unreg_fcfi(mbox, fcfi);
6578
6579	if (!phba->sli4_hba.intr_enable)
6580		rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
6581	else {
6582		mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
6583		rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
6584	}
6585	if (rc != MBX_TIMEOUT)
6586		mempool_free(mbox, phba->mbox_mem_pool);
6587	if (rc != MBX_SUCCESS)
6588		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6589				"2517 Unregister FCFI command failed "
6590				"status %d, mbxStatus x%x\n", rc,
6591				bf_get(lpfc_mqe_status, &mbox->u.mqe));
6592	else {
6593		spin_lock_irqsave(&phba->hbalock, flags);
6594		/* Mark the FCFI is no longer registered */
6595		phba->fcf.fcf_flag &=
6596			~(FCF_AVAILABLE | FCF_REGISTERED | FCF_SCAN_DONE);
6597		spin_unlock_irqrestore(&phba->hbalock, flags);
6598	}
6599}
6600
6601/**
6602 * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space.
6603 * @phba: pointer to lpfc hba data structure.
6604 *
6605 * This routine is invoked to set up the PCI device memory space for device
6606 * with SLI-4 interface spec.
6607 *
6608 * Return codes
6609 * 	0 - successful
6610 * 	other values - error
6611 **/
6612static int
6613lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
6614{
6615	struct pci_dev *pdev;
6616	unsigned long bar0map_len, bar1map_len, bar2map_len;
6617	int error = -ENODEV;
6618
6619	/* Obtain PCI device reference */
6620	if (!phba->pcidev)
6621		return error;
6622	else
6623		pdev = phba->pcidev;
6624
6625	/* Set the device DMA mask size */
6626	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
6627	 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
6628		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
6629		 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
6630			return error;
6631		}
6632	}
6633
6634	/* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the
6635	 * number of bytes required by each mapping. They are actually
6636	 * mapping to the PCI BAR regions 0 or 1, 2, and 4 by the SLI4 device.
6637	 */
6638	if (pci_resource_start(pdev, 0)) {
6639		phba->pci_bar0_map = pci_resource_start(pdev, 0);
6640		bar0map_len = pci_resource_len(pdev, 0);
6641	} else {
6642		phba->pci_bar0_map = pci_resource_start(pdev, 1);
6643		bar0map_len = pci_resource_len(pdev, 1);
6644	}
6645	phba->pci_bar1_map = pci_resource_start(pdev, 2);
6646	bar1map_len = pci_resource_len(pdev, 2);
6647
6648	phba->pci_bar2_map = pci_resource_start(pdev, 4);
6649	bar2map_len = pci_resource_len(pdev, 4);
6650
6651	/* Map SLI4 PCI Config Space Register base to a kernel virtual addr */
6652	phba->sli4_hba.conf_regs_memmap_p =
6653				ioremap(phba->pci_bar0_map, bar0map_len);
6654	if (!phba->sli4_hba.conf_regs_memmap_p) {
6655		dev_printk(KERN_ERR, &pdev->dev,
6656			   "ioremap failed for SLI4 PCI config registers.\n");
6657		goto out;
6658	}
6659
6660	/* Map SLI4 HBA Control Register base to a kernel virtual address. */
6661	phba->sli4_hba.ctrl_regs_memmap_p =
6662				ioremap(phba->pci_bar1_map, bar1map_len);
6663	if (!phba->sli4_hba.ctrl_regs_memmap_p) {
6664		dev_printk(KERN_ERR, &pdev->dev,
6665			   "ioremap failed for SLI4 HBA control registers.\n");
6666		goto out_iounmap_conf;
6667	}
6668
6669	/* Map SLI4 HBA Doorbell Register base to a kernel virtual address. */
6670	phba->sli4_hba.drbl_regs_memmap_p =
6671				ioremap(phba->pci_bar2_map, bar2map_len);
6672	if (!phba->sli4_hba.drbl_regs_memmap_p) {
6673		dev_printk(KERN_ERR, &pdev->dev,
6674			   "ioremap failed for SLI4 HBA doorbell registers.\n");
6675		goto out_iounmap_ctrl;
6676	}
6677
6678	/* Set up BAR0 PCI config space register memory map */
6679	lpfc_sli4_bar0_register_memmap(phba);
6680
6681	/* Set up BAR1 register memory map */
6682	lpfc_sli4_bar1_register_memmap(phba);
6683
6684	/* Set up BAR2 register memory map */
6685	error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
6686	if (error)
6687		goto out_iounmap_all;
6688
6689	return 0;
6690
6691out_iounmap_all:
6692	iounmap(phba->sli4_hba.drbl_regs_memmap_p);
6693out_iounmap_ctrl:
6694	iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
6695out_iounmap_conf:
6696	iounmap(phba->sli4_hba.conf_regs_memmap_p);
6697out:
6698	return error;
6699}
6700
6701/**
6702 * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space.
6703 * @phba: pointer to lpfc hba data structure.
6704 *
6705 * This routine is invoked to unset the PCI device memory space for device
6706 * with SLI-4 interface spec.
6707 **/
6708static void
6709lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba)
6710{
6711	struct pci_dev *pdev;
6712
6713	/* Obtain PCI device reference */
6714	if (!phba->pcidev)
6715		return;
6716	else
6717		pdev = phba->pcidev;
6718
6719	/* Free coherent DMA memory allocated */
6720
6721	/* Unmap I/O memory space */
6722	iounmap(phba->sli4_hba.drbl_regs_memmap_p);
6723	iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
6724	iounmap(phba->sli4_hba.conf_regs_memmap_p);
6725
6726	return;
6727}
6728
6729/**
6730 * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
6731 * @phba: pointer to lpfc hba data structure.
6732 *
6733 * This routine is invoked to enable the MSI-X interrupt vectors to device
6734 * with SLI-3 interface specs. The kernel function pci_enable_msix() is
6735 * called to enable the MSI-X vectors. Note that pci_enable_msix(), once
6736 * invoked, enables either all or nothing, depending on the current
6737 * availability of PCI vector resources. The device driver is responsible
6738 * for calling the individual request_irq() to register each MSI-X vector
6739 * with a interrupt handler, which is done in this function. Note that
6740 * later when device is unloading, the driver should always call free_irq()
6741 * on all MSI-X vectors it has done request_irq() on before calling
6742 * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device
6743 * will be left with MSI-X enabled and leaks its vectors.
6744 *
6745 * Return codes
6746 *   0 - successful
6747 *   other values - error
6748 **/
6749static int
6750lpfc_sli_enable_msix(struct lpfc_hba *phba)
6751{
6752	int rc, i;
6753	LPFC_MBOXQ_t *pmb;
6754
6755	/* Set up MSI-X multi-message vectors */
6756	for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6757		phba->msix_entries[i].entry = i;
6758
6759	/* Configure MSI-X capability structure */
6760	rc = pci_enable_msix(phba->pcidev, phba->msix_entries,
6761				ARRAY_SIZE(phba->msix_entries));
6762	if (rc) {
6763		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6764				"0420 PCI enable MSI-X failed (%d)\n", rc);
6765		goto msi_fail_out;
6766	}
6767	for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6768		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6769				"0477 MSI-X entry[%d]: vector=x%x "
6770				"message=%d\n", i,
6771				phba->msix_entries[i].vector,
6772				phba->msix_entries[i].entry);
6773	/*
6774	 * Assign MSI-X vectors to interrupt handlers
6775	 */
6776
6777	/* vector-0 is associated to slow-path handler */
6778	rc = request_irq(phba->msix_entries[0].vector,
6779			 &lpfc_sli_sp_intr_handler, IRQF_SHARED,
6780			 LPFC_SP_DRIVER_HANDLER_NAME, phba);
6781	if (rc) {
6782		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6783				"0421 MSI-X slow-path request_irq failed "
6784				"(%d)\n", rc);
6785		goto msi_fail_out;
6786	}
6787
6788	/* vector-1 is associated to fast-path handler */
6789	rc = request_irq(phba->msix_entries[1].vector,
6790			 &lpfc_sli_fp_intr_handler, IRQF_SHARED,
6791			 LPFC_FP_DRIVER_HANDLER_NAME, phba);
6792
6793	if (rc) {
6794		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6795				"0429 MSI-X fast-path request_irq failed "
6796				"(%d)\n", rc);
6797		goto irq_fail_out;
6798	}
6799
6800	/*
6801	 * Configure HBA MSI-X attention conditions to messages
6802	 */
6803	pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6804
6805	if (!pmb) {
6806		rc = -ENOMEM;
6807		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6808				"0474 Unable to allocate memory for issuing "
6809				"MBOX_CONFIG_MSI command\n");
6810		goto mem_fail_out;
6811	}
6812	rc = lpfc_config_msi(phba, pmb);
6813	if (rc)
6814		goto mbx_fail_out;
6815	rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
6816	if (rc != MBX_SUCCESS) {
6817		lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
6818				"0351 Config MSI mailbox command failed, "
6819				"mbxCmd x%x, mbxStatus x%x\n",
6820				pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus);
6821		goto mbx_fail_out;
6822	}
6823
6824	/* Free memory allocated for mailbox command */
6825	mempool_free(pmb, phba->mbox_mem_pool);
6826	return rc;
6827
6828mbx_fail_out:
6829	/* Free memory allocated for mailbox command */
6830	mempool_free(pmb, phba->mbox_mem_pool);
6831
6832mem_fail_out:
6833	/* free the irq already requested */
6834	free_irq(phba->msix_entries[1].vector, phba);
6835
6836irq_fail_out:
6837	/* free the irq already requested */
6838	free_irq(phba->msix_entries[0].vector, phba);
6839
6840msi_fail_out:
6841	/* Unconfigure MSI-X capability structure */
6842	pci_disable_msix(phba->pcidev);
6843	return rc;
6844}
6845
6846/**
6847 * lpfc_sli_disable_msix - Disable MSI-X interrupt mode on SLI-3 device.
6848 * @phba: pointer to lpfc hba data structure.
6849 *
6850 * This routine is invoked to release the MSI-X vectors and then disable the
6851 * MSI-X interrupt mode to device with SLI-3 interface spec.
6852 **/
6853static void
6854lpfc_sli_disable_msix(struct lpfc_hba *phba)
6855{
6856	int i;
6857
6858	/* Free up MSI-X multi-message vectors */
6859	for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6860		free_irq(phba->msix_entries[i].vector, phba);
6861	/* Disable MSI-X */
6862	pci_disable_msix(phba->pcidev);
6863
6864	return;
6865}
6866
6867/**
6868 * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
6869 * @phba: pointer to lpfc hba data structure.
6870 *
6871 * This routine is invoked to enable the MSI interrupt mode to device with
6872 * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
6873 * enable the MSI vector. The device driver is responsible for calling the
6874 * request_irq() to register MSI vector with a interrupt the handler, which
6875 * is done in this function.
6876 *
6877 * Return codes
6878 * 	0 - successful
6879 * 	other values - error
6880 */
6881static int
6882lpfc_sli_enable_msi(struct lpfc_hba *phba)
6883{
6884	int rc;
6885
6886	rc = pci_enable_msi(phba->pcidev);
6887	if (!rc)
6888		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6889				"0462 PCI enable MSI mode success.\n");
6890	else {
6891		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6892				"0471 PCI enable MSI mode failed (%d)\n", rc);
6893		return rc;
6894	}
6895
6896	rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
6897			 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6898	if (rc) {
6899		pci_disable_msi(phba->pcidev);
6900		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6901				"0478 MSI request_irq failed (%d)\n", rc);
6902	}
6903	return rc;
6904}
6905
6906/**
6907 * lpfc_sli_disable_msi - Disable MSI interrupt mode to SLI-3 device.
6908 * @phba: pointer to lpfc hba data structure.
6909 *
6910 * This routine is invoked to disable the MSI interrupt mode to device with
6911 * SLI-3 interface spec. The driver calls free_irq() on MSI vector it has
6912 * done request_irq() on before calling pci_disable_msi(). Failure to do so
6913 * results in a BUG_ON() and a device will be left with MSI enabled and leaks
6914 * its vector.
6915 */
6916static void
6917lpfc_sli_disable_msi(struct lpfc_hba *phba)
6918{
6919	free_irq(phba->pcidev->irq, phba);
6920	pci_disable_msi(phba->pcidev);
6921	return;
6922}
6923
6924/**
6925 * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
6926 * @phba: pointer to lpfc hba data structure.
6927 *
6928 * This routine is invoked to enable device interrupt and associate driver's
6929 * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
6930 * spec. Depends on the interrupt mode configured to the driver, the driver
6931 * will try to fallback from the configured interrupt mode to an interrupt
6932 * mode which is supported by the platform, kernel, and device in the order
6933 * of:
6934 * MSI-X -> MSI -> IRQ.
6935 *
6936 * Return codes
6937 *   0 - successful
6938 *   other values - error
6939 **/
6940static uint32_t
6941lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
6942{
6943	uint32_t intr_mode = LPFC_INTR_ERROR;
6944	int retval;
6945
6946	if (cfg_mode == 2) {
6947		/* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
6948		retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3);
6949		if (!retval) {
6950			/* Now, try to enable MSI-X interrupt mode */
6951			retval = lpfc_sli_enable_msix(phba);
6952			if (!retval) {
6953				/* Indicate initialization to MSI-X mode */
6954				phba->intr_type = MSIX;
6955				intr_mode = 2;
6956			}
6957		}
6958	}
6959
6960	/* Fallback to MSI if MSI-X initialization failed */
6961	if (cfg_mode >= 1 && phba->intr_type == NONE) {
6962		retval = lpfc_sli_enable_msi(phba);
6963		if (!retval) {
6964			/* Indicate initialization to MSI mode */
6965			phba->intr_type = MSI;
6966			intr_mode = 1;
6967		}
6968	}
6969
6970	/* Fallback to INTx if both MSI-X/MSI initalization failed */
6971	if (phba->intr_type == NONE) {
6972		retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
6973				     IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6974		if (!retval) {
6975			/* Indicate initialization to INTx mode */
6976			phba->intr_type = INTx;
6977			intr_mode = 0;
6978		}
6979	}
6980	return intr_mode;
6981}
6982
6983/**
6984 * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
6985 * @phba: pointer to lpfc hba data structure.
6986 *
6987 * This routine is invoked to disable device interrupt and disassociate the
6988 * driver's interrupt handler(s) from interrupt vector(s) to device with
6989 * SLI-3 interface spec. Depending on the interrupt mode, the driver will
6990 * release the interrupt vector(s) for the message signaled interrupt.
6991 **/
6992static void
6993lpfc_sli_disable_intr(struct lpfc_hba *phba)
6994{
6995	/* Disable the currently initialized interrupt mode */
6996	if (phba->intr_type == MSIX)
6997		lpfc_sli_disable_msix(phba);
6998	else if (phba->intr_type == MSI)
6999		lpfc_sli_disable_msi(phba);
7000	else if (phba->intr_type == INTx)
7001		free_irq(phba->pcidev->irq, phba);
7002
7003	/* Reset interrupt management states */
7004	phba->intr_type = NONE;
7005	phba->sli.slistat.sli_intr = 0;
7006
7007	return;
7008}
7009
7010/**
7011 * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
7012 * @phba: pointer to lpfc hba data structure.
7013 *
7014 * This routine is invoked to enable the MSI-X interrupt vectors to device
7015 * with SLI-4 interface spec. The kernel function pci_enable_msix() is called
7016 * to enable the MSI-X vectors. Note that pci_enable_msix(), once invoked,
7017 * enables either all or nothing, depending on the current availability of
7018 * PCI vector resources. The device driver is responsible for calling the
7019 * individual request_irq() to register each MSI-X vector with a interrupt
7020 * handler, which is done in this function. Note that later when device is
7021 * unloading, the driver should always call free_irq() on all MSI-X vectors
7022 * it has done request_irq() on before calling pci_disable_msix(). Failure
7023 * to do so results in a BUG_ON() and a device will be left with MSI-X
7024 * enabled and leaks its vectors.
7025 *
7026 * Return codes
7027 * 0 - successful
7028 * other values - error
7029 **/
7030static int
7031lpfc_sli4_enable_msix(struct lpfc_hba *phba)
7032{
7033	int rc, index;
7034
7035	/* Set up MSI-X multi-message vectors */
7036	for (index = 0; index < phba->sli4_hba.cfg_eqn; index++)
7037		phba->sli4_hba.msix_entries[index].entry = index;
7038
7039	/* Configure MSI-X capability structure */
7040	rc = pci_enable_msix(phba->pcidev, phba->sli4_hba.msix_entries,
7041			     phba->sli4_hba.cfg_eqn);
7042	if (rc) {
7043		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7044				"0484 PCI enable MSI-X failed (%d)\n", rc);
7045		goto msi_fail_out;
7046	}
7047	/* Log MSI-X vector assignment */
7048	for (index = 0; index < phba->sli4_hba.cfg_eqn; index++)
7049		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7050				"0489 MSI-X entry[%d]: vector=x%x "
7051				"message=%d\n", index,
7052				phba->sli4_hba.msix_entries[index].vector,
7053				phba->sli4_hba.msix_entries[index].entry);
7054	/*
7055	 * Assign MSI-X vectors to interrupt handlers
7056	 */
7057
7058	/* The first vector must associated to slow-path handler for MQ */
7059	rc = request_irq(phba->sli4_hba.msix_entries[0].vector,
7060			 &lpfc_sli4_sp_intr_handler, IRQF_SHARED,
7061			 LPFC_SP_DRIVER_HANDLER_NAME, phba);
7062	if (rc) {
7063		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
7064				"0485 MSI-X slow-path request_irq failed "
7065				"(%d)\n", rc);
7066		goto msi_fail_out;
7067	}
7068
7069	/* The rest of the vector(s) are associated to fast-path handler(s) */
7070	for (index = 1; index < phba->sli4_hba.cfg_eqn; index++) {
7071		phba->sli4_hba.fcp_eq_hdl[index - 1].idx = index - 1;
7072		phba->sli4_hba.fcp_eq_hdl[index - 1].phba = phba;
7073		rc = request_irq(phba->sli4_hba.msix_entries[index].vector,
7074				 &lpfc_sli4_fp_intr_handler, IRQF_SHARED,
7075				 LPFC_FP_DRIVER_HANDLER_NAME,
7076				 &phba->sli4_hba.fcp_eq_hdl[index - 1]);
7077		if (rc) {
7078			lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
7079					"0486 MSI-X fast-path (%d) "
7080					"request_irq failed (%d)\n", index, rc);
7081			goto cfg_fail_out;
7082		}
7083	}
7084
7085	return rc;
7086
7087cfg_fail_out:
7088	/* free the irq already requested */
7089	for (--index; index >= 1; index--)
7090		free_irq(phba->sli4_hba.msix_entries[index - 1].vector,
7091			 &phba->sli4_hba.fcp_eq_hdl[index - 1]);
7092
7093	/* free the irq already requested */
7094	free_irq(phba->sli4_hba.msix_entries[0].vector, phba);
7095
7096msi_fail_out:
7097	/* Unconfigure MSI-X capability structure */
7098	pci_disable_msix(phba->pcidev);
7099	return rc;
7100}
7101
7102/**
7103 * lpfc_sli4_disable_msix - Disable MSI-X interrupt mode to SLI-4 device
7104 * @phba: pointer to lpfc hba data structure.
7105 *
7106 * This routine is invoked to release the MSI-X vectors and then disable the
7107 * MSI-X interrupt mode to device with SLI-4 interface spec.
7108 **/
7109static void
7110lpfc_sli4_disable_msix(struct lpfc_hba *phba)
7111{
7112	int index;
7113
7114	/* Free up MSI-X multi-message vectors */
7115	free_irq(phba->sli4_hba.msix_entries[0].vector, phba);
7116
7117	for (index = 1; index < phba->sli4_hba.cfg_eqn; index++)
7118		free_irq(phba->sli4_hba.msix_entries[index].vector,
7119			 &phba->sli4_hba.fcp_eq_hdl[index - 1]);
7120	/* Disable MSI-X */
7121	pci_disable_msix(phba->pcidev);
7122
7123	return;
7124}
7125
7126/**
7127 * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device
7128 * @phba: pointer to lpfc hba data structure.
7129 *
7130 * This routine is invoked to enable the MSI interrupt mode to device with
7131 * SLI-4 interface spec. The kernel function pci_enable_msi() is called
7132 * to enable the MSI vector. The device driver is responsible for calling
7133 * the request_irq() to register MSI vector with a interrupt the handler,
7134 * which is done in this function.
7135 *
7136 * Return codes
7137 * 	0 - successful
7138 * 	other values - error
7139 **/
7140static int
7141lpfc_sli4_enable_msi(struct lpfc_hba *phba)
7142{
7143	int rc, index;
7144
7145	rc = pci_enable_msi(phba->pcidev);
7146	if (!rc)
7147		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7148				"0487 PCI enable MSI mode success.\n");
7149	else {
7150		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7151				"0488 PCI enable MSI mode failed (%d)\n", rc);
7152		return rc;
7153	}
7154
7155	rc = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
7156			 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
7157	if (rc) {
7158		pci_disable_msi(phba->pcidev);
7159		lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
7160				"0490 MSI request_irq failed (%d)\n", rc);
7161	}
7162
7163	for (index = 0; index < phba->cfg_fcp_eq_count; index++) {
7164		phba->sli4_hba.fcp_eq_hdl[index].idx = index;
7165		phba->sli4_hba.fcp_eq_hdl[index].phba = phba;
7166	}
7167
7168	return rc;
7169}
7170
7171/**
7172 * lpfc_sli4_disable_msi - Disable MSI interrupt mode to SLI-4 device
7173 * @phba: pointer to lpfc hba data structure.
7174 *
7175 * This routine is invoked to disable the MSI interrupt mode to device with
7176 * SLI-4 interface spec. The driver calls free_irq() on MSI vector it has
7177 * done request_irq() on before calling pci_disable_msi(). Failure to do so
7178 * results in a BUG_ON() and a device will be left with MSI enabled and leaks
7179 * its vector.
7180 **/
7181static void
7182lpfc_sli4_disable_msi(struct lpfc_hba *phba)
7183{
7184	free_irq(phba->pcidev->irq, phba);
7185	pci_disable_msi(phba->pcidev);
7186	return;
7187}
7188
7189/**
7190 * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
7191 * @phba: pointer to lpfc hba data structure.
7192 *
7193 * This routine is invoked to enable device interrupt and associate driver's
7194 * interrupt handler(s) to interrupt vector(s) to device with SLI-4
7195 * interface spec. Depends on the interrupt mode configured to the driver,
7196 * the driver will try to fallback from the configured interrupt mode to an
7197 * interrupt mode which is supported by the platform, kernel, and device in
7198 * the order of:
7199 * MSI-X -> MSI -> IRQ.
7200 *
7201 * Return codes
7202 * 	0 - successful
7203 * 	other values - error
7204 **/
7205static uint32_t
7206lpfc_sli4_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
7207{
7208	uint32_t intr_mode = LPFC_INTR_ERROR;
7209	int retval, index;
7210
7211	if (cfg_mode == 2) {
7212		/* Preparation before conf_msi mbox cmd */
7213		retval = 0;
7214		if (!retval) {
7215			/* Now, try to enable MSI-X interrupt mode */
7216			retval = lpfc_sli4_enable_msix(phba);
7217			if (!retval) {
7218				/* Indicate initialization to MSI-X mode */
7219				phba->intr_type = MSIX;
7220				intr_mode = 2;
7221			}
7222		}
7223	}
7224
7225	/* Fallback to MSI if MSI-X initialization failed */
7226	if (cfg_mode >= 1 && phba->intr_type == NONE) {
7227		retval = lpfc_sli4_enable_msi(phba);
7228		if (!retval) {
7229			/* Indicate initialization to MSI mode */
7230			phba->intr_type = MSI;
7231			intr_mode = 1;
7232		}
7233	}
7234
7235	/* Fallback to INTx if both MSI-X/MSI initalization failed */
7236	if (phba->intr_type == NONE) {
7237		retval = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
7238				     IRQF_SHARED, LPFC_DRIVER_NAME, phba);
7239		if (!retval) {
7240			/* Indicate initialization to INTx mode */
7241			phba->intr_type = INTx;
7242			intr_mode = 0;
7243			for (index = 0; index < phba->cfg_fcp_eq_count;
7244			     index++) {
7245				phba->sli4_hba.fcp_eq_hdl[index].idx = index;
7246				phba->sli4_hba.fcp_eq_hdl[index].phba = phba;
7247			}
7248		}
7249	}
7250	return intr_mode;
7251}
7252
7253/**
7254 * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device
7255 * @phba: pointer to lpfc hba data structure.
7256 *
7257 * This routine is invoked to disable device interrupt and disassociate
7258 * the driver's interrupt handler(s) from interrupt vector(s) to device
7259 * with SLI-4 interface spec. Depending on the interrupt mode, the driver
7260 * will release the interrupt vector(s) for the message signaled interrupt.
7261 **/
7262static void
7263lpfc_sli4_disable_intr(struct lpfc_hba *phba)
7264{
7265	/* Disable the currently initialized interrupt mode */
7266	if (phba->intr_type == MSIX)
7267		lpfc_sli4_disable_msix(phba);
7268	else if (phba->intr_type == MSI)
7269		lpfc_sli4_disable_msi(phba);
7270	else if (phba->intr_type == INTx)
7271		free_irq(phba->pcidev->irq, phba);
7272
7273	/* Reset interrupt management states */
7274	phba->intr_type = NONE;
7275	phba->sli.slistat.sli_intr = 0;
7276
7277	return;
7278}
7279
7280/**
7281 * lpfc_unset_hba - Unset SLI3 hba device initialization
7282 * @phba: pointer to lpfc hba data structure.
7283 *
7284 * This routine is invoked to unset the HBA device initialization steps to
7285 * a device with SLI-3 interface spec.
7286 **/
7287static void
7288lpfc_unset_hba(struct lpfc_hba *phba)
7289{
7290	struct lpfc_vport *vport = phba->pport;
7291	struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
7292
7293	spin_lock_irq(shost->host_lock);
7294	vport->load_flag |= FC_UNLOADING;
7295	spin_unlock_irq(shost->host_lock);
7296
7297	lpfc_stop_hba_timers(phba);
7298
7299	phba->pport->work_port_events = 0;
7300
7301	lpfc_sli_hba_down(phba);
7302
7303	lpfc_sli_brdrestart(phba);
7304
7305	lpfc_sli_disable_intr(phba);
7306
7307	return;
7308}
7309
7310/**
7311 * lpfc_sli4_unset_hba - Unset SLI4 hba device initialization.
7312 * @phba: pointer to lpfc hba data structure.
7313 *
7314 * This routine is invoked to unset the HBA device initialization steps to
7315 * a device with SLI-4 interface spec.
7316 **/
7317static void
7318lpfc_sli4_unset_hba(struct lpfc_hba *phba)
7319{
7320	struct lpfc_vport *vport = phba->pport;
7321	struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
7322
7323	spin_lock_irq(shost->host_lock);
7324	vport->load_flag |= FC_UNLOADING;
7325	spin_unlock_irq(shost->host_lock);
7326
7327	phba->pport->work_port_events = 0;
7328
7329	lpfc_sli4_hba_down(phba);
7330
7331	lpfc_sli4_disable_intr(phba);
7332
7333	return;
7334}
7335
7336/**
7337 * lpfc_sli4_hba_unset - Unset the fcoe hba
7338 * @phba: Pointer to HBA context object.
7339 *
7340 * This function is called in the SLI4 code path to reset the HBA's FCoE
7341 * function. The caller is not required to hold any lock. This routine
7342 * issues PCI function reset mailbox command to reset the FCoE function.
7343 * At the end of the function, it calls lpfc_hba_down_post function to
7344 * free any pending commands.
7345 **/
7346static void
7347lpfc_sli4_hba_unset(struct lpfc_hba *phba)
7348{
7349	int wait_cnt = 0;
7350	LPFC_MBOXQ_t *mboxq;
7351
7352	lpfc_stop_hba_timers(phba);
7353	phba->sli4_hba.intr_enable = 0;
7354
7355	/*
7356	 * Gracefully wait out the potential current outstanding asynchronous
7357	 * mailbox command.
7358	 */
7359
7360	/* First, block any pending async mailbox command from posted */
7361	spin_lock_irq(&phba->hbalock);
7362	phba->sli.sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
7363	spin_unlock_irq(&phba->hbalock);
7364	/* Now, trying to wait it out if we can */
7365	while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7366		msleep(10);
7367		if (++wait_cnt > LPFC_ACTIVE_MBOX_WAIT_CNT)
7368			break;
7369	}
7370	/* Forcefully release the outstanding mailbox command if timed out */
7371	if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7372		spin_lock_irq(&phba->hbalock);
7373		mboxq = phba->sli.mbox_active;
7374		mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED;
7375		__lpfc_mbox_cmpl_put(phba, mboxq);
7376		phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7377		phba->sli.mbox_active = NULL;
7378		spin_unlock_irq(&phba->hbalock);
7379	}
7380
7381	/* Tear down the queues in the HBA */
7382	lpfc_sli4_queue_unset(phba);
7383
7384	/* Disable PCI subsystem interrupt */
7385	lpfc_sli4_disable_intr(phba);
7386
7387	/* Stop kthread signal shall trigger work_done one more time */
7388	kthread_stop(phba->worker_thread);
7389
7390	/* Stop the SLI4 device port */
7391	phba->pport->work_port_events = 0;
7392}
7393
7394 /**
7395 * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
7396 * @phba: Pointer to HBA context object.
7397 * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
7398 *
7399 * This function is called in the SLI4 code path to read the port's
7400 * sli4 capabilities.
7401 *
7402 * This function may be be called from any context that can block-wait
7403 * for the completion.  The expectation is that this routine is called
7404 * typically from probe_one or from the online routine.
7405 **/
7406int
7407lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
7408{
7409	int rc;
7410	struct lpfc_mqe *mqe;
7411	struct lpfc_pc_sli4_params *sli4_params;
7412	uint32_t mbox_tmo;
7413
7414	rc = 0;
7415	mqe = &mboxq->u.mqe;
7416
7417	/* Read the port's SLI4 Parameters port capabilities */
7418	lpfc_sli4_params(mboxq);
7419	if (!phba->sli4_hba.intr_enable)
7420		rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
7421	else {
7422		mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_PORT_CAPABILITIES);
7423		rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
7424	}
7425
7426	if (unlikely(rc))
7427		return 1;
7428
7429	sli4_params = &phba->sli4_hba.pc_sli4_params;
7430	sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
7431	sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
7432	sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
7433	sli4_params->featurelevel_1 = bf_get(featurelevel_1,
7434					     &mqe->un.sli4_params);
7435	sli4_params->featurelevel_2 = bf_get(featurelevel_2,
7436					     &mqe->un.sli4_params);
7437	sli4_params->proto_types = mqe->un.sli4_params.word3;
7438	sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
7439	sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
7440	sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
7441	sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
7442	sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
7443	sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
7444	sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
7445	sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
7446	sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
7447	sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
7448	sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
7449	sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
7450	sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
7451	sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
7452	sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
7453	sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
7454	sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
7455	sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
7456	sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
7457	sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
7458	return rc;
7459}
7460
7461/**
7462 * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
7463 * @pdev: pointer to PCI device
7464 * @pid: pointer to PCI device identifier
7465 *
7466 * This routine is to be called to attach a device with SLI-3 interface spec
7467 * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
7468 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
7469 * information of the device and driver to see if the driver state that it can
7470 * support this kind of device. If the match is successful, the driver core
7471 * invokes this routine. If this routine determines it can claim the HBA, it
7472 * does all the initialization that it needs to do to handle the HBA properly.
7473 *
7474 * Return code
7475 * 	0 - driver can claim the device
7476 * 	negative value - driver can not claim the device
7477 **/
7478static int __devinit
7479lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
7480{
7481	struct lpfc_hba   *phba;
7482	struct lpfc_vport *vport = NULL;
7483	struct Scsi_Host  *shost = NULL;
7484	int error;
7485	uint32_t cfg_mode, intr_mode;
7486
7487	/* Allocate memory for HBA structure */
7488	phba = lpfc_hba_alloc(pdev);
7489	if (!phba)
7490		return -ENOMEM;
7491
7492	/* Perform generic PCI device enabling operation */
7493	error = lpfc_enable_pci_dev(phba);
7494	if (error) {
7495		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7496				"1401 Failed to enable pci device.\n");
7497		goto out_free_phba;
7498	}
7499
7500	/* Set up SLI API function jump table for PCI-device group-0 HBAs */
7501	error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP);
7502	if (error)
7503		goto out_disable_pci_dev;
7504
7505	/* Set up SLI-3 specific device PCI memory space */
7506	error = lpfc_sli_pci_mem_setup(phba);
7507	if (error) {
7508		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7509				"1402 Failed to set up pci memory space.\n");
7510		goto out_disable_pci_dev;
7511	}
7512
7513	/* Set up phase-1 common device driver resources */
7514	error = lpfc_setup_driver_resource_phase1(phba);
7515	if (error) {
7516		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7517				"1403 Failed to set up driver resource.\n");
7518		goto out_unset_pci_mem_s3;
7519	}
7520
7521	/* Set up SLI-3 specific device driver resources */
7522	error = lpfc_sli_driver_resource_setup(phba);
7523	if (error) {
7524		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7525				"1404 Failed to set up driver resource.\n");
7526		goto out_unset_pci_mem_s3;
7527	}
7528
7529	/* Initialize and populate the iocb list per host */
7530	error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT);
7531	if (error) {
7532		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7533				"1405 Failed to initialize iocb list.\n");
7534		goto out_unset_driver_resource_s3;
7535	}
7536
7537	/* Set up common device driver resources */
7538	error = lpfc_setup_driver_resource_phase2(phba);
7539	if (error) {
7540		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7541				"1406 Failed to set up driver resource.\n");
7542		goto out_free_iocb_list;
7543	}
7544
7545	/* Create SCSI host to the physical port */
7546	error = lpfc_create_shost(phba);
7547	if (error) {
7548		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7549				"1407 Failed to create scsi host.\n");
7550		goto out_unset_driver_resource;
7551	}
7552
7553	/* Configure sysfs attributes */
7554	vport = phba->pport;
7555	error = lpfc_alloc_sysfs_attr(vport);
7556	if (error) {
7557		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7558				"1476 Failed to allocate sysfs attr\n");
7559		goto out_destroy_shost;
7560	}
7561
7562	shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
7563	/* Now, trying to enable interrupt and bring up the device */
7564	cfg_mode = phba->cfg_use_msi;
7565	while (true) {
7566		/* Put device to a known state before enabling interrupt */
7567		lpfc_stop_port(phba);
7568		/* Configure and enable interrupt */
7569		intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
7570		if (intr_mode == LPFC_INTR_ERROR) {
7571			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7572					"0431 Failed to enable interrupt.\n");
7573			error = -ENODEV;
7574			goto out_free_sysfs_attr;
7575		}
7576		/* SLI-3 HBA setup */
7577		if (lpfc_sli_hba_setup(phba)) {
7578			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7579					"1477 Failed to set up hba\n");
7580			error = -ENODEV;
7581			goto out_remove_device;
7582		}
7583
7584		/* Wait 50ms for the interrupts of previous mailbox commands */
7585		msleep(50);
7586		/* Check active interrupts on message signaled interrupts */
7587		if (intr_mode == 0 ||
7588		    phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) {
7589			/* Log the current active interrupt mode */
7590			phba->intr_mode = intr_mode;
7591			lpfc_log_intr_mode(phba, intr_mode);
7592			break;
7593		} else {
7594			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7595					"0447 Configure interrupt mode (%d) "
7596					"failed active interrupt test.\n",
7597					intr_mode);
7598			/* Disable the current interrupt mode */
7599			lpfc_sli_disable_intr(phba);
7600			/* Try next level of interrupt mode */
7601			cfg_mode = --intr_mode;
7602		}
7603	}
7604
7605	/* Perform post initialization setup */
7606	lpfc_post_init_setup(phba);
7607
7608	/* Check if there are static vports to be created. */
7609	lpfc_create_static_vport(phba);
7610
7611	return 0;
7612
7613out_remove_device:
7614	lpfc_unset_hba(phba);
7615out_free_sysfs_attr:
7616	lpfc_free_sysfs_attr(vport);
7617out_destroy_shost:
7618	lpfc_destroy_shost(phba);
7619out_unset_driver_resource:
7620	lpfc_unset_driver_resource_phase2(phba);
7621out_free_iocb_list:
7622	lpfc_free_iocb_list(phba);
7623out_unset_driver_resource_s3:
7624	lpfc_sli_driver_resource_unset(phba);
7625out_unset_pci_mem_s3:
7626	lpfc_sli_pci_mem_unset(phba);
7627out_disable_pci_dev:
7628	lpfc_disable_pci_dev(phba);
7629	if (shost)
7630		scsi_host_put(shost);
7631out_free_phba:
7632	lpfc_hba_free(phba);
7633	return error;
7634}
7635
7636/**
7637 * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
7638 * @pdev: pointer to PCI device
7639 *
7640 * This routine is to be called to disattach a device with SLI-3 interface
7641 * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
7642 * removed from PCI bus, it performs all the necessary cleanup for the HBA
7643 * device to be removed from the PCI subsystem properly.
7644 **/
7645static void __devexit
7646lpfc_pci_remove_one_s3(struct pci_dev *pdev)
7647{
7648	struct Scsi_Host  *shost = pci_get_drvdata(pdev);
7649	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
7650	struct lpfc_vport **vports;
7651	struct lpfc_hba   *phba = vport->phba;
7652	int i;
7653	int bars = pci_select_bars(pdev, IORESOURCE_MEM);
7654
7655	spin_lock_irq(&phba->hbalock);
7656	vport->load_flag |= FC_UNLOADING;
7657	spin_unlock_irq(&phba->hbalock);
7658
7659	lpfc_free_sysfs_attr(vport);
7660
7661	/* Release all the vports against this physical port */
7662	vports = lpfc_create_vport_work_array(phba);
7663	if (vports != NULL)
7664		for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
7665			fc_vport_terminate(vports[i]->fc_vport);
7666	lpfc_destroy_vport_work_array(phba, vports);
7667
7668	/* Remove FC host and then SCSI host with the physical port */
7669	fc_remove_host(shost);
7670	scsi_remove_host(shost);
7671	lpfc_cleanup(vport);
7672
7673	/*
7674	 * Bring down the SLI Layer. This step disable all interrupts,
7675	 * clears the rings, discards all mailbox commands, and resets
7676	 * the HBA.
7677	 */
7678
7679	/* HBA interrupt will be diabled after this call */
7680	lpfc_sli_hba_down(phba);
7681	/* Stop kthread signal shall trigger work_done one more time */
7682	kthread_stop(phba->worker_thread);
7683	/* Final cleanup of txcmplq and reset the HBA */
7684	lpfc_sli_brdrestart(phba);
7685
7686	lpfc_stop_hba_timers(phba);
7687	spin_lock_irq(&phba->hbalock);
7688	list_del_init(&vport->listentry);
7689	spin_unlock_irq(&phba->hbalock);
7690
7691	lpfc_debugfs_terminate(vport);
7692
7693	/* Disable interrupt */
7694	lpfc_sli_disable_intr(phba);
7695
7696	pci_set_drvdata(pdev, NULL);
7697	scsi_host_put(shost);
7698
7699	/*
7700	 * Call scsi_free before mem_free since scsi bufs are released to their
7701	 * corresponding pools here.
7702	 */
7703	lpfc_scsi_free(phba);
7704	lpfc_mem_free_all(phba);
7705
7706	dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
7707			  phba->hbqslimp.virt, phba->hbqslimp.phys);
7708
7709	/* Free resources associated with SLI2 interface */
7710	dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7711			  phba->slim2p.virt, phba->slim2p.phys);
7712
7713	/* unmap adapter SLIM and Control Registers */
7714	iounmap(phba->ctrl_regs_memmap_p);
7715	iounmap(phba->slim_memmap_p);
7716
7717	lpfc_hba_free(phba);
7718
7719	pci_release_selected_regions(pdev, bars);
7720	pci_disable_device(pdev);
7721}
7722
7723/**
7724 * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
7725 * @pdev: pointer to PCI device
7726 * @msg: power management message
7727 *
7728 * This routine is to be called from the kernel's PCI subsystem to support
7729 * system Power Management (PM) to device with SLI-3 interface spec. When
7730 * PM invokes this method, it quiesces the device by stopping the driver's
7731 * worker thread for the device, turning off device's interrupt and DMA,
7732 * and bring the device offline. Note that as the driver implements the
7733 * minimum PM requirements to a power-aware driver's PM support for the
7734 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
7735 * to the suspend() method call will be treated as SUSPEND and the driver will
7736 * fully reinitialize its device during resume() method call, the driver will
7737 * set device to PCI_D3hot state in PCI config space instead of setting it
7738 * according to the @msg provided by the PM.
7739 *
7740 * Return code
7741 * 	0 - driver suspended the device
7742 * 	Error otherwise
7743 **/
7744static int
7745lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
7746{
7747	struct Scsi_Host *shost = pci_get_drvdata(pdev);
7748	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7749
7750	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7751			"0473 PCI device Power Management suspend.\n");
7752
7753	/* Bring down the device */
7754	lpfc_offline_prep(phba);
7755	lpfc_offline(phba);
7756	kthread_stop(phba->worker_thread);
7757
7758	/* Disable interrupt from device */
7759	lpfc_sli_disable_intr(phba);
7760
7761	/* Save device state to PCI config space */
7762	pci_save_state(pdev);
7763	pci_set_power_state(pdev, PCI_D3hot);
7764
7765	return 0;
7766}
7767
7768/**
7769 * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
7770 * @pdev: pointer to PCI device
7771 *
7772 * This routine is to be called from the kernel's PCI subsystem to support
7773 * system Power Management (PM) to device with SLI-3 interface spec. When PM
7774 * invokes this method, it restores the device's PCI config space state and
7775 * fully reinitializes the device and brings it online. Note that as the
7776 * driver implements the minimum PM requirements to a power-aware driver's
7777 * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
7778 * FREEZE) to the suspend() method call will be treated as SUSPEND and the
7779 * driver will fully reinitialize its device during resume() method call,
7780 * the device will be set to PCI_D0 directly in PCI config space before
7781 * restoring the state.
7782 *
7783 * Return code
7784 * 	0 - driver suspended the device
7785 * 	Error otherwise
7786 **/
7787static int
7788lpfc_pci_resume_one_s3(struct pci_dev *pdev)
7789{
7790	struct Scsi_Host *shost = pci_get_drvdata(pdev);
7791	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7792	uint32_t intr_mode;
7793	int error;
7794
7795	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7796			"0452 PCI device Power Management resume.\n");
7797
7798	/* Restore device state from PCI config space */
7799	pci_set_power_state(pdev, PCI_D0);
7800	pci_restore_state(pdev);
7801
7802	/*
7803	 * As the new kernel behavior of pci_restore_state() API call clears
7804	 * device saved_state flag, need to save the restored state again.
7805	 */
7806	pci_save_state(pdev);
7807
7808	if (pdev->is_busmaster)
7809		pci_set_master(pdev);
7810
7811	/* Startup the kernel thread for this host adapter. */
7812	phba->worker_thread = kthread_run(lpfc_do_work, phba,
7813					"lpfc_worker_%d", phba->brd_no);
7814	if (IS_ERR(phba->worker_thread)) {
7815		error = PTR_ERR(phba->worker_thread);
7816		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7817				"0434 PM resume failed to start worker "
7818				"thread: error=x%x.\n", error);
7819		return error;
7820	}
7821
7822	/* Configure and enable interrupt */
7823	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
7824	if (intr_mode == LPFC_INTR_ERROR) {
7825		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7826				"0430 PM resume Failed to enable interrupt\n");
7827		return -EIO;
7828	} else
7829		phba->intr_mode = intr_mode;
7830
7831	/* Restart HBA and bring it online */
7832	lpfc_sli_brdrestart(phba);
7833	lpfc_online(phba);
7834
7835	/* Log the current active interrupt mode */
7836	lpfc_log_intr_mode(phba, phba->intr_mode);
7837
7838	return 0;
7839}
7840
7841/**
7842 * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
7843 * @phba: pointer to lpfc hba data structure.
7844 *
7845 * This routine is called to prepare the SLI3 device for PCI slot recover. It
7846 * aborts all the outstanding SCSI I/Os to the pci device.
7847 **/
7848static void
7849lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
7850{
7851	struct lpfc_sli *psli = &phba->sli;
7852	struct lpfc_sli_ring  *pring;
7853
7854	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7855			"2723 PCI channel I/O abort preparing for recovery\n");
7856
7857	/*
7858	 * There may be errored I/Os through HBA, abort all I/Os on txcmplq
7859	 * and let the SCSI mid-layer to retry them to recover.
7860	 */
7861	pring = &psli->ring[psli->fcp_ring];
7862	lpfc_sli_abort_iocb_ring(phba, pring);
7863}
7864
7865/**
7866 * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
7867 * @phba: pointer to lpfc hba data structure.
7868 *
7869 * This routine is called to prepare the SLI3 device for PCI slot reset. It
7870 * disables the device interrupt and pci device, and aborts the internal FCP
7871 * pending I/Os.
7872 **/
7873static void
7874lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
7875{
7876	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7877			"2710 PCI channel disable preparing for reset\n");
7878
7879	/* Block all SCSI devices' I/Os on the host */
7880	lpfc_scsi_dev_block(phba);
7881
7882	/* stop all timers */
7883	lpfc_stop_hba_timers(phba);
7884
7885	/* Disable interrupt and pci device */
7886	lpfc_sli_disable_intr(phba);
7887	pci_disable_device(phba->pcidev);
7888	/* Flush all driver's outstanding SCSI I/Os as we are to reset */
7889	lpfc_sli_flush_fcp_rings(phba);
7890}
7891
7892/**
7893 * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
7894 * @phba: pointer to lpfc hba data structure.
7895 *
7896 * This routine is called to prepare the SLI3 device for PCI slot permanently
7897 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
7898 * pending I/Os.
7899 **/
7900static void
7901lpfc_prep_dev_for_perm_failure(struct lpfc_hba *phba)
7902{
7903	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7904			"2711 PCI channel permanent disable for failure\n");
7905	/* Block all SCSI devices' I/Os on the host */
7906	lpfc_scsi_dev_block(phba);
7907
7908	/* stop all timers */
7909	lpfc_stop_hba_timers(phba);
7910
7911	/* Clean up all driver's outstanding SCSI I/Os */
7912	lpfc_sli_flush_fcp_rings(phba);
7913}
7914
7915/**
7916 * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
7917 * @pdev: pointer to PCI device.
7918 * @state: the current PCI connection state.
7919 *
7920 * This routine is called from the PCI subsystem for I/O error handling to
7921 * device with SLI-3 interface spec. This function is called by the PCI
7922 * subsystem after a PCI bus error affecting this device has been detected.
7923 * When this function is invoked, it will need to stop all the I/Os and
7924 * interrupt(s) to the device. Once that is done, it will return
7925 * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
7926 * as desired.
7927 *
7928 * Return codes
7929 * 	PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
7930 * 	PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
7931 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
7932 **/
7933static pci_ers_result_t
7934lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
7935{
7936	struct Scsi_Host *shost = pci_get_drvdata(pdev);
7937	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7938
7939	switch (state) {
7940	case pci_channel_io_normal:
7941		/* Non-fatal error, prepare for recovery */
7942		lpfc_sli_prep_dev_for_recover(phba);
7943		return PCI_ERS_RESULT_CAN_RECOVER;
7944	case pci_channel_io_frozen:
7945		/* Fatal error, prepare for slot reset */
7946		lpfc_sli_prep_dev_for_reset(phba);
7947		return PCI_ERS_RESULT_NEED_RESET;
7948	case pci_channel_io_perm_failure:
7949		/* Permanent failure, prepare for device down */
7950		lpfc_prep_dev_for_perm_failure(phba);
7951		return PCI_ERS_RESULT_DISCONNECT;
7952	default:
7953		/* Unknown state, prepare and request slot reset */
7954		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7955				"0472 Unknown PCI error state: x%x\n", state);
7956		lpfc_sli_prep_dev_for_reset(phba);
7957		return PCI_ERS_RESULT_NEED_RESET;
7958	}
7959}
7960
7961/**
7962 * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
7963 * @pdev: pointer to PCI device.
7964 *
7965 * This routine is called from the PCI subsystem for error handling to
7966 * device with SLI-3 interface spec. This is called after PCI bus has been
7967 * reset to restart the PCI card from scratch, as if from a cold-boot.
7968 * During the PCI subsystem error recovery, after driver returns
7969 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
7970 * recovery and then call this routine before calling the .resume method
7971 * to recover the device. This function will initialize the HBA device,
7972 * enable the interrupt, but it will just put the HBA to offline state
7973 * without passing any I/O traffic.
7974 *
7975 * Return codes
7976 * 	PCI_ERS_RESULT_RECOVERED - the device has been recovered
7977 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
7978 */
7979static pci_ers_result_t
7980lpfc_io_slot_reset_s3(struct pci_dev *pdev)
7981{
7982	struct Scsi_Host *shost = pci_get_drvdata(pdev);
7983	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7984	struct lpfc_sli *psli = &phba->sli;
7985	uint32_t intr_mode;
7986
7987	dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
7988	if (pci_enable_device_mem(pdev)) {
7989		printk(KERN_ERR "lpfc: Cannot re-enable "
7990			"PCI device after reset.\n");
7991		return PCI_ERS_RESULT_DISCONNECT;
7992	}
7993
7994	pci_restore_state(pdev);
7995
7996	/*
7997	 * As the new kernel behavior of pci_restore_state() API call clears
7998	 * device saved_state flag, need to save the restored state again.
7999	 */
8000	pci_save_state(pdev);
8001
8002	if (pdev->is_busmaster)
8003		pci_set_master(pdev);
8004
8005	spin_lock_irq(&phba->hbalock);
8006	psli->sli_flag &= ~LPFC_SLI_ACTIVE;
8007	spin_unlock_irq(&phba->hbalock);
8008
8009	/* Configure and enable interrupt */
8010	intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
8011	if (intr_mode == LPFC_INTR_ERROR) {
8012		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8013				"0427 Cannot re-enable interrupt after "
8014				"slot reset.\n");
8015		return PCI_ERS_RESULT_DISCONNECT;
8016	} else
8017		phba->intr_mode = intr_mode;
8018
8019	/* Take device offline; this will perform cleanup */
8020	lpfc_offline(phba);
8021	lpfc_sli_brdrestart(phba);
8022
8023	/* Log the current active interrupt mode */
8024	lpfc_log_intr_mode(phba, phba->intr_mode);
8025
8026	return PCI_ERS_RESULT_RECOVERED;
8027}
8028
8029/**
8030 * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
8031 * @pdev: pointer to PCI device
8032 *
8033 * This routine is called from the PCI subsystem for error handling to device
8034 * with SLI-3 interface spec. It is called when kernel error recovery tells
8035 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
8036 * error recovery. After this call, traffic can start to flow from this device
8037 * again.
8038 */
8039static void
8040lpfc_io_resume_s3(struct pci_dev *pdev)
8041{
8042	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8043	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8044
8045	/* Bring device online, it will be no-op for non-fatal error resume */
8046	lpfc_online(phba);
8047
8048	/* Clean up Advanced Error Reporting (AER) if needed */
8049	if (phba->hba_flag & HBA_AER_ENABLED)
8050		pci_cleanup_aer_uncorrect_error_status(pdev);
8051}
8052
8053/**
8054 * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve
8055 * @phba: pointer to lpfc hba data structure.
8056 *
8057 * returns the number of ELS/CT IOCBs to reserve
8058 **/
8059int
8060lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
8061{
8062	int max_xri = phba->sli4_hba.max_cfg_param.max_xri;
8063
8064	if (phba->sli_rev == LPFC_SLI_REV4) {
8065		if (max_xri <= 100)
8066			return 10;
8067		else if (max_xri <= 256)
8068			return 25;
8069		else if (max_xri <= 512)
8070			return 50;
8071		else if (max_xri <= 1024)
8072			return 100;
8073		else
8074			return 150;
8075	} else
8076		return 0;
8077}
8078
8079/**
8080 * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
8081 * @pdev: pointer to PCI device
8082 * @pid: pointer to PCI device identifier
8083 *
8084 * This routine is called from the kernel's PCI subsystem to device with
8085 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
8086 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
8087 * information of the device and driver to see if the driver state that it
8088 * can support this kind of device. If the match is successful, the driver
8089 * core invokes this routine. If this routine determines it can claim the HBA,
8090 * it does all the initialization that it needs to do to handle the HBA
8091 * properly.
8092 *
8093 * Return code
8094 * 	0 - driver can claim the device
8095 * 	negative value - driver can not claim the device
8096 **/
8097static int __devinit
8098lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
8099{
8100	struct lpfc_hba   *phba;
8101	struct lpfc_vport *vport = NULL;
8102	struct Scsi_Host  *shost = NULL;
8103	int error;
8104	uint32_t cfg_mode, intr_mode;
8105	int mcnt;
8106
8107	/* Allocate memory for HBA structure */
8108	phba = lpfc_hba_alloc(pdev);
8109	if (!phba)
8110		return -ENOMEM;
8111
8112	/* Perform generic PCI device enabling operation */
8113	error = lpfc_enable_pci_dev(phba);
8114	if (error) {
8115		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8116				"1409 Failed to enable pci device.\n");
8117		goto out_free_phba;
8118	}
8119
8120	/* Set up SLI API function jump table for PCI-device group-1 HBAs */
8121	error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_OC);
8122	if (error)
8123		goto out_disable_pci_dev;
8124
8125	/* Set up SLI-4 specific device PCI memory space */
8126	error = lpfc_sli4_pci_mem_setup(phba);
8127	if (error) {
8128		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8129				"1410 Failed to set up pci memory space.\n");
8130		goto out_disable_pci_dev;
8131	}
8132
8133	/* Set up phase-1 common device driver resources */
8134	error = lpfc_setup_driver_resource_phase1(phba);
8135	if (error) {
8136		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8137				"1411 Failed to set up driver resource.\n");
8138		goto out_unset_pci_mem_s4;
8139	}
8140
8141	/* Set up SLI-4 Specific device driver resources */
8142	error = lpfc_sli4_driver_resource_setup(phba);
8143	if (error) {
8144		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8145				"1412 Failed to set up driver resource.\n");
8146		goto out_unset_pci_mem_s4;
8147	}
8148
8149	/* Initialize and populate the iocb list per host */
8150	error = lpfc_init_iocb_list(phba,
8151			phba->sli4_hba.max_cfg_param.max_xri);
8152	if (error) {
8153		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8154				"1413 Failed to initialize iocb list.\n");
8155		goto out_unset_driver_resource_s4;
8156	}
8157
8158	/* Set up common device driver resources */
8159	error = lpfc_setup_driver_resource_phase2(phba);
8160	if (error) {
8161		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8162				"1414 Failed to set up driver resource.\n");
8163		goto out_free_iocb_list;
8164	}
8165
8166	/* Create SCSI host to the physical port */
8167	error = lpfc_create_shost(phba);
8168	if (error) {
8169		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8170				"1415 Failed to create scsi host.\n");
8171		goto out_unset_driver_resource;
8172	}
8173
8174	/* Configure sysfs attributes */
8175	vport = phba->pport;
8176	error = lpfc_alloc_sysfs_attr(vport);
8177	if (error) {
8178		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8179				"1416 Failed to allocate sysfs attr\n");
8180		goto out_destroy_shost;
8181	}
8182
8183	shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
8184	/* Now, trying to enable interrupt and bring up the device */
8185	cfg_mode = phba->cfg_use_msi;
8186	while (true) {
8187		/* Put device to a known state before enabling interrupt */
8188		lpfc_stop_port(phba);
8189		/* Configure and enable interrupt */
8190		intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);
8191		if (intr_mode == LPFC_INTR_ERROR) {
8192			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8193					"0426 Failed to enable interrupt.\n");
8194			error = -ENODEV;
8195			goto out_free_sysfs_attr;
8196		}
8197		/* Default to single FCP EQ for non-MSI-X */
8198		if (phba->intr_type != MSIX)
8199			phba->cfg_fcp_eq_count = 1;
8200		/* Set up SLI-4 HBA */
8201		if (lpfc_sli4_hba_setup(phba)) {
8202			lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8203					"1421 Failed to set up hba\n");
8204			error = -ENODEV;
8205			goto out_disable_intr;
8206		}
8207
8208		/* Send NOP mbx cmds for non-INTx mode active interrupt test */
8209		if (intr_mode != 0)
8210			mcnt = lpfc_sli4_send_nop_mbox_cmds(phba,
8211							    LPFC_ACT_INTR_CNT);
8212
8213		/* Check active interrupts received only for MSI/MSI-X */
8214		if (intr_mode == 0 ||
8215		    phba->sli.slistat.sli_intr >= LPFC_ACT_INTR_CNT) {
8216			/* Log the current active interrupt mode */
8217			phba->intr_mode = intr_mode;
8218			lpfc_log_intr_mode(phba, intr_mode);
8219			break;
8220		}
8221		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8222				"0451 Configure interrupt mode (%d) "
8223				"failed active interrupt test.\n",
8224				intr_mode);
8225		/* Unset the preivous SLI-4 HBA setup */
8226		lpfc_sli4_unset_hba(phba);
8227		/* Try next level of interrupt mode */
8228		cfg_mode = --intr_mode;
8229	}
8230
8231	/* Perform post initialization setup */
8232	lpfc_post_init_setup(phba);
8233
8234	/* Check if there are static vports to be created. */
8235	lpfc_create_static_vport(phba);
8236
8237	return 0;
8238
8239out_disable_intr:
8240	lpfc_sli4_disable_intr(phba);
8241out_free_sysfs_attr:
8242	lpfc_free_sysfs_attr(vport);
8243out_destroy_shost:
8244	lpfc_destroy_shost(phba);
8245out_unset_driver_resource:
8246	lpfc_unset_driver_resource_phase2(phba);
8247out_free_iocb_list:
8248	lpfc_free_iocb_list(phba);
8249out_unset_driver_resource_s4:
8250	lpfc_sli4_driver_resource_unset(phba);
8251out_unset_pci_mem_s4:
8252	lpfc_sli4_pci_mem_unset(phba);
8253out_disable_pci_dev:
8254	lpfc_disable_pci_dev(phba);
8255	if (shost)
8256		scsi_host_put(shost);
8257out_free_phba:
8258	lpfc_hba_free(phba);
8259	return error;
8260}
8261
8262/**
8263 * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem
8264 * @pdev: pointer to PCI device
8265 *
8266 * This routine is called from the kernel's PCI subsystem to device with
8267 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
8268 * removed from PCI bus, it performs all the necessary cleanup for the HBA
8269 * device to be removed from the PCI subsystem properly.
8270 **/
8271static void __devexit
8272lpfc_pci_remove_one_s4(struct pci_dev *pdev)
8273{
8274	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8275	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
8276	struct lpfc_vport **vports;
8277	struct lpfc_hba *phba = vport->phba;
8278	int i;
8279
8280	/* Mark the device unloading flag */
8281	spin_lock_irq(&phba->hbalock);
8282	vport->load_flag |= FC_UNLOADING;
8283	spin_unlock_irq(&phba->hbalock);
8284
8285	/* Free the HBA sysfs attributes */
8286	lpfc_free_sysfs_attr(vport);
8287
8288	/* Release all the vports against this physical port */
8289	vports = lpfc_create_vport_work_array(phba);
8290	if (vports != NULL)
8291		for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
8292			fc_vport_terminate(vports[i]->fc_vport);
8293	lpfc_destroy_vport_work_array(phba, vports);
8294
8295	/* Remove FC host and then SCSI host with the physical port */
8296	fc_remove_host(shost);
8297	scsi_remove_host(shost);
8298
8299	/* Perform cleanup on the physical port */
8300	lpfc_cleanup(vport);
8301
8302	/*
8303	 * Bring down the SLI Layer. This step disables all interrupts,
8304	 * clears the rings, discards all mailbox commands, and resets
8305	 * the HBA FCoE function.
8306	 */
8307	lpfc_debugfs_terminate(vport);
8308	lpfc_sli4_hba_unset(phba);
8309
8310	spin_lock_irq(&phba->hbalock);
8311	list_del_init(&vport->listentry);
8312	spin_unlock_irq(&phba->hbalock);
8313
8314	/* Call scsi_free before lpfc_sli4_driver_resource_unset since scsi
8315	 * buffers are released to their corresponding pools here.
8316	 */
8317	lpfc_scsi_free(phba);
8318	lpfc_sli4_driver_resource_unset(phba);
8319
8320	/* Unmap adapter Control and Doorbell registers */
8321	lpfc_sli4_pci_mem_unset(phba);
8322
8323	/* Release PCI resources and disable device's PCI function */
8324	scsi_host_put(shost);
8325	lpfc_disable_pci_dev(phba);
8326
8327	/* Finally, free the driver's device data structure */
8328	lpfc_hba_free(phba);
8329
8330	return;
8331}
8332
8333/**
8334 * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt
8335 * @pdev: pointer to PCI device
8336 * @msg: power management message
8337 *
8338 * This routine is called from the kernel's PCI subsystem to support system
8339 * Power Management (PM) to device with SLI-4 interface spec. When PM invokes
8340 * this method, it quiesces the device by stopping the driver's worker
8341 * thread for the device, turning off device's interrupt and DMA, and bring
8342 * the device offline. Note that as the driver implements the minimum PM
8343 * requirements to a power-aware driver's PM support for suspend/resume -- all
8344 * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
8345 * method call will be treated as SUSPEND and the driver will fully
8346 * reinitialize its device during resume() method call, the driver will set
8347 * device to PCI_D3hot state in PCI config space instead of setting it
8348 * according to the @msg provided by the PM.
8349 *
8350 * Return code
8351 * 	0 - driver suspended the device
8352 * 	Error otherwise
8353 **/
8354static int
8355lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg)
8356{
8357	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8358	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8359
8360	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8361			"0298 PCI device Power Management suspend.\n");
8362
8363	/* Bring down the device */
8364	lpfc_offline_prep(phba);
8365	lpfc_offline(phba);
8366	kthread_stop(phba->worker_thread);
8367
8368	/* Disable interrupt from device */
8369	lpfc_sli4_disable_intr(phba);
8370
8371	/* Save device state to PCI config space */
8372	pci_save_state(pdev);
8373	pci_set_power_state(pdev, PCI_D3hot);
8374
8375	return 0;
8376}
8377
8378/**
8379 * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt
8380 * @pdev: pointer to PCI device
8381 *
8382 * This routine is called from the kernel's PCI subsystem to support system
8383 * Power Management (PM) to device with SLI-4 interface spac. When PM invokes
8384 * this method, it restores the device's PCI config space state and fully
8385 * reinitializes the device and brings it online. Note that as the driver
8386 * implements the minimum PM requirements to a power-aware driver's PM for
8387 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
8388 * to the suspend() method call will be treated as SUSPEND and the driver
8389 * will fully reinitialize its device during resume() method call, the device
8390 * will be set to PCI_D0 directly in PCI config space before restoring the
8391 * state.
8392 *
8393 * Return code
8394 * 	0 - driver suspended the device
8395 * 	Error otherwise
8396 **/
8397static int
8398lpfc_pci_resume_one_s4(struct pci_dev *pdev)
8399{
8400	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8401	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8402	uint32_t intr_mode;
8403	int error;
8404
8405	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8406			"0292 PCI device Power Management resume.\n");
8407
8408	/* Restore device state from PCI config space */
8409	pci_set_power_state(pdev, PCI_D0);
8410	pci_restore_state(pdev);
8411
8412	/*
8413	 * As the new kernel behavior of pci_restore_state() API call clears
8414	 * device saved_state flag, need to save the restored state again.
8415	 */
8416	pci_save_state(pdev);
8417
8418	if (pdev->is_busmaster)
8419		pci_set_master(pdev);
8420
8421	 /* Startup the kernel thread for this host adapter. */
8422	phba->worker_thread = kthread_run(lpfc_do_work, phba,
8423					"lpfc_worker_%d", phba->brd_no);
8424	if (IS_ERR(phba->worker_thread)) {
8425		error = PTR_ERR(phba->worker_thread);
8426		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8427				"0293 PM resume failed to start worker "
8428				"thread: error=x%x.\n", error);
8429		return error;
8430	}
8431
8432	/* Configure and enable interrupt */
8433	intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
8434	if (intr_mode == LPFC_INTR_ERROR) {
8435		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8436				"0294 PM resume Failed to enable interrupt\n");
8437		return -EIO;
8438	} else
8439		phba->intr_mode = intr_mode;
8440
8441	/* Restart HBA and bring it online */
8442	lpfc_sli_brdrestart(phba);
8443	lpfc_online(phba);
8444
8445	/* Log the current active interrupt mode */
8446	lpfc_log_intr_mode(phba, phba->intr_mode);
8447
8448	return 0;
8449}
8450
8451/**
8452 * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device
8453 * @pdev: pointer to PCI device.
8454 * @state: the current PCI connection state.
8455 *
8456 * This routine is called from the PCI subsystem for error handling to device
8457 * with SLI-4 interface spec. This function is called by the PCI subsystem
8458 * after a PCI bus error affecting this device has been detected. When this
8459 * function is invoked, it will need to stop all the I/Os and interrupt(s)
8460 * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET
8461 * for the PCI subsystem to perform proper recovery as desired.
8462 *
8463 * Return codes
8464 * 	PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
8465 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8466 **/
8467static pci_ers_result_t
8468lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state)
8469{
8470	return PCI_ERS_RESULT_NEED_RESET;
8471}
8472
8473/**
8474 * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch
8475 * @pdev: pointer to PCI device.
8476 *
8477 * This routine is called from the PCI subsystem for error handling to device
8478 * with SLI-4 interface spec. It is called after PCI bus has been reset to
8479 * restart the PCI card from scratch, as if from a cold-boot. During the
8480 * PCI subsystem error recovery, after the driver returns
8481 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
8482 * recovery and then call this routine before calling the .resume method to
8483 * recover the device. This function will initialize the HBA device, enable
8484 * the interrupt, but it will just put the HBA to offline state without
8485 * passing any I/O traffic.
8486 *
8487 * Return codes
8488 * 	PCI_ERS_RESULT_RECOVERED - the device has been recovered
8489 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8490 */
8491static pci_ers_result_t
8492lpfc_io_slot_reset_s4(struct pci_dev *pdev)
8493{
8494	return PCI_ERS_RESULT_RECOVERED;
8495}
8496
8497/**
8498 * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device
8499 * @pdev: pointer to PCI device
8500 *
8501 * This routine is called from the PCI subsystem for error handling to device
8502 * with SLI-4 interface spec. It is called when kernel error recovery tells
8503 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
8504 * error recovery. After this call, traffic can start to flow from this device
8505 * again.
8506 **/
8507static void
8508lpfc_io_resume_s4(struct pci_dev *pdev)
8509{
8510	return;
8511}
8512
8513/**
8514 * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
8515 * @pdev: pointer to PCI device
8516 * @pid: pointer to PCI device identifier
8517 *
8518 * This routine is to be registered to the kernel's PCI subsystem. When an
8519 * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
8520 * at PCI device-specific information of the device and driver to see if the
8521 * driver state that it can support this kind of device. If the match is
8522 * successful, the driver core invokes this routine. This routine dispatches
8523 * the action to the proper SLI-3 or SLI-4 device probing routine, which will
8524 * do all the initialization that it needs to do to handle the HBA device
8525 * properly.
8526 *
8527 * Return code
8528 * 	0 - driver can claim the device
8529 * 	negative value - driver can not claim the device
8530 **/
8531static int __devinit
8532lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
8533{
8534	int rc;
8535	struct lpfc_sli_intf intf;
8536
8537	if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
8538		return -ENODEV;
8539
8540	if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
8541	    (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
8542		rc = lpfc_pci_probe_one_s4(pdev, pid);
8543	else
8544		rc = lpfc_pci_probe_one_s3(pdev, pid);
8545
8546	return rc;
8547}
8548
8549/**
8550 * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
8551 * @pdev: pointer to PCI device
8552 *
8553 * This routine is to be registered to the kernel's PCI subsystem. When an
8554 * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
8555 * This routine dispatches the action to the proper SLI-3 or SLI-4 device
8556 * remove routine, which will perform all the necessary cleanup for the
8557 * device to be removed from the PCI subsystem properly.
8558 **/
8559static void __devexit
8560lpfc_pci_remove_one(struct pci_dev *pdev)
8561{
8562	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8563	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8564
8565	switch (phba->pci_dev_grp) {
8566	case LPFC_PCI_DEV_LP:
8567		lpfc_pci_remove_one_s3(pdev);
8568		break;
8569	case LPFC_PCI_DEV_OC:
8570		lpfc_pci_remove_one_s4(pdev);
8571		break;
8572	default:
8573		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8574				"1424 Invalid PCI device group: 0x%x\n",
8575				phba->pci_dev_grp);
8576		break;
8577	}
8578	return;
8579}
8580
8581/**
8582 * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
8583 * @pdev: pointer to PCI device
8584 * @msg: power management message
8585 *
8586 * This routine is to be registered to the kernel's PCI subsystem to support
8587 * system Power Management (PM). When PM invokes this method, it dispatches
8588 * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
8589 * suspend the device.
8590 *
8591 * Return code
8592 * 	0 - driver suspended the device
8593 * 	Error otherwise
8594 **/
8595static int
8596lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
8597{
8598	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8599	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8600	int rc = -ENODEV;
8601
8602	switch (phba->pci_dev_grp) {
8603	case LPFC_PCI_DEV_LP:
8604		rc = lpfc_pci_suspend_one_s3(pdev, msg);
8605		break;
8606	case LPFC_PCI_DEV_OC:
8607		rc = lpfc_pci_suspend_one_s4(pdev, msg);
8608		break;
8609	default:
8610		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8611				"1425 Invalid PCI device group: 0x%x\n",
8612				phba->pci_dev_grp);
8613		break;
8614	}
8615	return rc;
8616}
8617
8618/**
8619 * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
8620 * @pdev: pointer to PCI device
8621 *
8622 * This routine is to be registered to the kernel's PCI subsystem to support
8623 * system Power Management (PM). When PM invokes this method, it dispatches
8624 * the action to the proper SLI-3 or SLI-4 device resume routine, which will
8625 * resume the device.
8626 *
8627 * Return code
8628 * 	0 - driver suspended the device
8629 * 	Error otherwise
8630 **/
8631static int
8632lpfc_pci_resume_one(struct pci_dev *pdev)
8633{
8634	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8635	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8636	int rc = -ENODEV;
8637
8638	switch (phba->pci_dev_grp) {
8639	case LPFC_PCI_DEV_LP:
8640		rc = lpfc_pci_resume_one_s3(pdev);
8641		break;
8642	case LPFC_PCI_DEV_OC:
8643		rc = lpfc_pci_resume_one_s4(pdev);
8644		break;
8645	default:
8646		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8647				"1426 Invalid PCI device group: 0x%x\n",
8648				phba->pci_dev_grp);
8649		break;
8650	}
8651	return rc;
8652}
8653
8654/**
8655 * lpfc_io_error_detected - lpfc method for handling PCI I/O error
8656 * @pdev: pointer to PCI device.
8657 * @state: the current PCI connection state.
8658 *
8659 * This routine is registered to the PCI subsystem for error handling. This
8660 * function is called by the PCI subsystem after a PCI bus error affecting
8661 * this device has been detected. When this routine is invoked, it dispatches
8662 * the action to the proper SLI-3 or SLI-4 device error detected handling
8663 * routine, which will perform the proper error detected operation.
8664 *
8665 * Return codes
8666 * 	PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
8667 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8668 **/
8669static pci_ers_result_t
8670lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
8671{
8672	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8673	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8674	pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
8675
8676	switch (phba->pci_dev_grp) {
8677	case LPFC_PCI_DEV_LP:
8678		rc = lpfc_io_error_detected_s3(pdev, state);
8679		break;
8680	case LPFC_PCI_DEV_OC:
8681		rc = lpfc_io_error_detected_s4(pdev, state);
8682		break;
8683	default:
8684		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8685				"1427 Invalid PCI device group: 0x%x\n",
8686				phba->pci_dev_grp);
8687		break;
8688	}
8689	return rc;
8690}
8691
8692/**
8693 * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
8694 * @pdev: pointer to PCI device.
8695 *
8696 * This routine is registered to the PCI subsystem for error handling. This
8697 * function is called after PCI bus has been reset to restart the PCI card
8698 * from scratch, as if from a cold-boot. When this routine is invoked, it
8699 * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
8700 * routine, which will perform the proper device reset.
8701 *
8702 * Return codes
8703 * 	PCI_ERS_RESULT_RECOVERED - the device has been recovered
8704 * 	PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8705 **/
8706static pci_ers_result_t
8707lpfc_io_slot_reset(struct pci_dev *pdev)
8708{
8709	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8710	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8711	pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
8712
8713	switch (phba->pci_dev_grp) {
8714	case LPFC_PCI_DEV_LP:
8715		rc = lpfc_io_slot_reset_s3(pdev);
8716		break;
8717	case LPFC_PCI_DEV_OC:
8718		rc = lpfc_io_slot_reset_s4(pdev);
8719		break;
8720	default:
8721		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8722				"1428 Invalid PCI device group: 0x%x\n",
8723				phba->pci_dev_grp);
8724		break;
8725	}
8726	return rc;
8727}
8728
8729/**
8730 * lpfc_io_resume - lpfc method for resuming PCI I/O operation
8731 * @pdev: pointer to PCI device
8732 *
8733 * This routine is registered to the PCI subsystem for error handling. It
8734 * is called when kernel error recovery tells the lpfc driver that it is
8735 * OK to resume normal PCI operation after PCI bus error recovery. When
8736 * this routine is invoked, it dispatches the action to the proper SLI-3
8737 * or SLI-4 device io_resume routine, which will resume the device operation.
8738 **/
8739static void
8740lpfc_io_resume(struct pci_dev *pdev)
8741{
8742	struct Scsi_Host *shost = pci_get_drvdata(pdev);
8743	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8744
8745	switch (phba->pci_dev_grp) {
8746	case LPFC_PCI_DEV_LP:
8747		lpfc_io_resume_s3(pdev);
8748		break;
8749	case LPFC_PCI_DEV_OC:
8750		lpfc_io_resume_s4(pdev);
8751		break;
8752	default:
8753		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8754				"1429 Invalid PCI device group: 0x%x\n",
8755				phba->pci_dev_grp);
8756		break;
8757	}
8758	return;
8759}
8760
8761static struct pci_device_id lpfc_id_table[] = {
8762	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
8763		PCI_ANY_ID, PCI_ANY_ID, },
8764	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY,
8765		PCI_ANY_ID, PCI_ANY_ID, },
8766	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR,
8767		PCI_ANY_ID, PCI_ANY_ID, },
8768	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS,
8769		PCI_ANY_ID, PCI_ANY_ID, },
8770	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR,
8771		PCI_ANY_ID, PCI_ANY_ID, },
8772	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY,
8773		PCI_ANY_ID, PCI_ANY_ID, },
8774	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY,
8775		PCI_ANY_ID, PCI_ANY_ID, },
8776	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY,
8777		PCI_ANY_ID, PCI_ANY_ID, },
8778	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY,
8779		PCI_ANY_ID, PCI_ANY_ID, },
8780	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE,
8781		PCI_ANY_ID, PCI_ANY_ID, },
8782	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP,
8783		PCI_ANY_ID, PCI_ANY_ID, },
8784	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP,
8785		PCI_ANY_ID, PCI_ANY_ID, },
8786	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS,
8787		PCI_ANY_ID, PCI_ANY_ID, },
8788	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP,
8789		PCI_ANY_ID, PCI_ANY_ID, },
8790	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP,
8791		PCI_ANY_ID, PCI_ANY_ID, },
8792	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID,
8793		PCI_ANY_ID, PCI_ANY_ID, },
8794	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB,
8795		PCI_ANY_ID, PCI_ANY_ID, },
8796	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR,
8797		PCI_ANY_ID, PCI_ANY_ID, },
8798	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HORNET,
8799		PCI_ANY_ID, PCI_ANY_ID, },
8800	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP,
8801		PCI_ANY_ID, PCI_ANY_ID, },
8802	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP,
8803		PCI_ANY_ID, PCI_ANY_ID, },
8804	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID,
8805		PCI_ANY_ID, PCI_ANY_ID, },
8806	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB,
8807		PCI_ANY_ID, PCI_ANY_ID, },
8808	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY,
8809		PCI_ANY_ID, PCI_ANY_ID, },
8810	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101,
8811		PCI_ANY_ID, PCI_ANY_ID, },
8812	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S,
8813		PCI_ANY_ID, PCI_ANY_ID, },
8814	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S,
8815		PCI_ANY_ID, PCI_ANY_ID, },
8816	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
8817		PCI_ANY_ID, PCI_ANY_ID, },
8818	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
8819		PCI_ANY_ID, PCI_ANY_ID, },
8820	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
8821		PCI_ANY_ID, PCI_ANY_ID, },
8822	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
8823		PCI_ANY_ID, PCI_ANY_ID, },
8824	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
8825		PCI_ANY_ID, PCI_ANY_ID, },
8826	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
8827		PCI_ANY_ID, PCI_ANY_ID, },
8828	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
8829		PCI_ANY_ID, PCI_ANY_ID, },
8830	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_VF,
8831		PCI_ANY_ID, PCI_ANY_ID, },
8832	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_PF,
8833		PCI_ANY_ID, PCI_ANY_ID, },
8834	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S,
8835		PCI_ANY_ID, PCI_ANY_ID, },
8836	{PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK,
8837		PCI_ANY_ID, PCI_ANY_ID, },
8838	{PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TOMCAT,
8839		PCI_ANY_ID, PCI_ANY_ID, },
8840	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FALCON,
8841		PCI_ANY_ID, PCI_ANY_ID, },
8842	{PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BALIUS,
8843		PCI_ANY_ID, PCI_ANY_ID, },
8844	{ 0 }
8845};
8846
8847MODULE_DEVICE_TABLE(pci, lpfc_id_table);
8848
8849static struct pci_error_handlers lpfc_err_handler = {
8850	.error_detected = lpfc_io_error_detected,
8851	.slot_reset = lpfc_io_slot_reset,
8852	.resume = lpfc_io_resume,
8853};
8854
8855static struct pci_driver lpfc_driver = {
8856	.name		= LPFC_DRIVER_NAME,
8857	.id_table	= lpfc_id_table,
8858	.probe		= lpfc_pci_probe_one,
8859	.remove		= __devexit_p(lpfc_pci_remove_one),
8860	.suspend        = lpfc_pci_suspend_one,
8861	.resume		= lpfc_pci_resume_one,
8862	.err_handler    = &lpfc_err_handler,
8863};
8864
8865/**
8866 * lpfc_init - lpfc module initialization routine
8867 *
8868 * This routine is to be invoked when the lpfc module is loaded into the
8869 * kernel. The special kernel macro module_init() is used to indicate the
8870 * role of this routine to the kernel as lpfc module entry point.
8871 *
8872 * Return codes
8873 *   0 - successful
8874 *   -ENOMEM - FC attach transport failed
8875 *   all others - failed
8876 */
8877static int __init
8878lpfc_init(void)
8879{
8880	int error = 0;
8881
8882	printk(LPFC_MODULE_DESC "\n");
8883	printk(LPFC_COPYRIGHT "\n");
8884
8885	if (lpfc_enable_npiv) {
8886		lpfc_transport_functions.vport_create = lpfc_vport_create;
8887		lpfc_transport_functions.vport_delete = lpfc_vport_delete;
8888	}
8889	lpfc_transport_template =
8890				fc_attach_transport(&lpfc_transport_functions);
8891	if (lpfc_transport_template == NULL)
8892		return -ENOMEM;
8893	if (lpfc_enable_npiv) {
8894		lpfc_vport_transport_template =
8895			fc_attach_transport(&lpfc_vport_transport_functions);
8896		if (lpfc_vport_transport_template == NULL) {
8897			fc_release_transport(lpfc_transport_template);
8898			return -ENOMEM;
8899		}
8900	}
8901	error = pci_register_driver(&lpfc_driver);
8902	if (error) {
8903		fc_release_transport(lpfc_transport_template);
8904		if (lpfc_enable_npiv)
8905			fc_release_transport(lpfc_vport_transport_template);
8906	}
8907
8908	return error;
8909}
8910
8911/**
8912 * lpfc_exit - lpfc module removal routine
8913 *
8914 * This routine is invoked when the lpfc module is removed from the kernel.
8915 * The special kernel macro module_exit() is used to indicate the role of
8916 * this routine to the kernel as lpfc module exit point.
8917 */
8918static void __exit
8919lpfc_exit(void)
8920{
8921	pci_unregister_driver(&lpfc_driver);
8922	fc_release_transport(lpfc_transport_template);
8923	if (lpfc_enable_npiv)
8924		fc_release_transport(lpfc_vport_transport_template);
8925	if (_dump_buf_data) {
8926		printk(KERN_ERR	"9062 BLKGRD: freeing %lu pages for "
8927				"_dump_buf_data at 0x%p\n",
8928				(1L << _dump_buf_data_order), _dump_buf_data);
8929		free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
8930	}
8931
8932	if (_dump_buf_dif) {
8933		printk(KERN_ERR	"9049 BLKGRD: freeing %lu pages for "
8934				"_dump_buf_dif at 0x%p\n",
8935				(1L << _dump_buf_dif_order), _dump_buf_dif);
8936		free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
8937	}
8938}
8939
8940module_init(lpfc_init);
8941module_exit(lpfc_exit);
8942MODULE_LICENSE("GPL");
8943MODULE_DESCRIPTION(LPFC_MODULE_DESC);
8944MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com");
8945MODULE_VERSION("0:" LPFC_DRIVER_VERSION);
8946