[SCSI] lpfc 8.2.3 : FC Discovery Fixes
[linux-2.6.git] / drivers / scsi / lpfc / lpfc_init.c
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
5  * EMULEX and SLI are trademarks of Emulex.                        *
6  * www.emulex.com                                                  *
7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
8  *                                                                 *
9  * This program is free software; you can redistribute it and/or   *
10  * modify it under the terms of version 2 of the GNU General       *
11  * Public License as published by the Free Software Foundation.    *
12  * This program is distributed in the hope that it will be useful. *
13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
18  * more details, a copy of which can be found in the file COPYING  *
19  * included with this package.                                     *
20  *******************************************************************/
21
22 #include <linux/blkdev.h>
23 #include <linux/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
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi_transport_fc.h>
36
37 #include "lpfc_hw.h"
38 #include "lpfc_sli.h"
39 #include "lpfc_disc.h"
40 #include "lpfc_scsi.h"
41 #include "lpfc.h"
42 #include "lpfc_logmsg.h"
43 #include "lpfc_crtn.h"
44 #include "lpfc_vport.h"
45 #include "lpfc_version.h"
46
47 static int lpfc_parse_vpd(struct lpfc_hba *, uint8_t *, int);
48 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
49 static int lpfc_post_rcv_buf(struct lpfc_hba *);
50
51 static struct scsi_transport_template *lpfc_transport_template = NULL;
52 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
53 static DEFINE_IDR(lpfc_hba_index);
54
55 /************************************************************************/
56 /*                                                                      */
57 /*    lpfc_config_port_prep                                             */
58 /*    This routine will do LPFC initialization prior to the             */
59 /*    CONFIG_PORT mailbox command. This will be initialized             */
60 /*    as a SLI layer callback routine.                                  */
61 /*    This routine returns 0 on success or -ERESTART if it wants        */
62 /*    the SLI layer to reset the HBA and try again. Any                 */
63 /*    other return value indicates an error.                            */
64 /*                                                                      */
65 /************************************************************************/
66 int
67 lpfc_config_port_prep(struct lpfc_hba *phba)
68 {
69         lpfc_vpd_t *vp = &phba->vpd;
70         int i = 0, rc;
71         LPFC_MBOXQ_t *pmb;
72         MAILBOX_t *mb;
73         char *lpfc_vpd_data = NULL;
74         uint16_t offset = 0;
75         static char licensed[56] =
76                     "key unlock for use with gnu public licensed code only\0";
77         static int init_key = 1;
78
79         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
80         if (!pmb) {
81                 phba->link_state = LPFC_HBA_ERROR;
82                 return -ENOMEM;
83         }
84
85         mb = &pmb->mb;
86         phba->link_state = LPFC_INIT_MBX_CMDS;
87
88         if (lpfc_is_LC_HBA(phba->pcidev->device)) {
89                 if (init_key) {
90                         uint32_t *ptext = (uint32_t *) licensed;
91
92                         for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
93                                 *ptext = cpu_to_be32(*ptext);
94                         init_key = 0;
95                 }
96
97                 lpfc_read_nv(phba, pmb);
98                 memset((char*)mb->un.varRDnvp.rsvd3, 0,
99                         sizeof (mb->un.varRDnvp.rsvd3));
100                 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
101                          sizeof (licensed));
102
103                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
104
105                 if (rc != MBX_SUCCESS) {
106                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
107                                         "0324 Config Port initialization "
108                                         "error, mbxCmd x%x READ_NVPARM, "
109                                         "mbxStatus x%x\n",
110                                         mb->mbxCommand, mb->mbxStatus);
111                         mempool_free(pmb, phba->mbox_mem_pool);
112                         return -ERESTART;
113                 }
114                 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
115                        sizeof(phba->wwnn));
116                 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
117                        sizeof(phba->wwpn));
118         }
119
120         phba->sli3_options = 0x0;
121
122         /* Setup and issue mailbox READ REV command */
123         lpfc_read_rev(phba, pmb);
124         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
125         if (rc != MBX_SUCCESS) {
126                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
127                                 "0439 Adapter failed to init, mbxCmd x%x "
128                                 "READ_REV, mbxStatus x%x\n",
129                                 mb->mbxCommand, mb->mbxStatus);
130                 mempool_free( pmb, phba->mbox_mem_pool);
131                 return -ERESTART;
132         }
133
134
135         /*
136          * The value of rr must be 1 since the driver set the cv field to 1.
137          * This setting requires the FW to set all revision fields.
138          */
139         if (mb->un.varRdRev.rr == 0) {
140                 vp->rev.rBit = 0;
141                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
142                                 "0440 Adapter failed to init, READ_REV has "
143                                 "missing revision information.\n");
144                 mempool_free(pmb, phba->mbox_mem_pool);
145                 return -ERESTART;
146         }
147
148         if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp)
149                 return -EINVAL;
150
151         /* Save information as VPD data */
152         vp->rev.rBit = 1;
153         memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
154         vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
155         memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
156         vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
157         memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
158         vp->rev.biuRev = mb->un.varRdRev.biuRev;
159         vp->rev.smRev = mb->un.varRdRev.smRev;
160         vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
161         vp->rev.endecRev = mb->un.varRdRev.endecRev;
162         vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
163         vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
164         vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
165         vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
166         vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
167         vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
168
169         /* If the sli feature level is less then 9, we must
170          * tear down all RPIs and VPIs on link down if NPIV
171          * is enabled.
172          */
173         if (vp->rev.feaLevelHigh < 9)
174                 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
175
176         if (lpfc_is_LC_HBA(phba->pcidev->device))
177                 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
178                                                 sizeof (phba->RandomData));
179
180         /* Get adapter VPD information */
181         pmb->context2 = kmalloc(DMP_RSP_SIZE, GFP_KERNEL);
182         if (!pmb->context2)
183                 goto out_free_mbox;
184         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
185         if (!lpfc_vpd_data)
186                 goto out_free_context2;
187
188         do {
189                 lpfc_dump_mem(phba, pmb, offset);
190                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
191
192                 if (rc != MBX_SUCCESS) {
193                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
194                                         "0441 VPD not present on adapter, "
195                                         "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
196                                         mb->mbxCommand, mb->mbxStatus);
197                         mb->un.varDmp.word_cnt = 0;
198                 }
199                 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
200                         mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
201                 lpfc_sli_pcimem_bcopy(pmb->context2, lpfc_vpd_data + offset,
202                                       mb->un.varDmp.word_cnt);
203                 offset += mb->un.varDmp.word_cnt;
204         } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
205         lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
206
207         kfree(lpfc_vpd_data);
208 out_free_context2:
209         kfree(pmb->context2);
210 out_free_mbox:
211         mempool_free(pmb, phba->mbox_mem_pool);
212         return 0;
213 }
214
215 /* Completion handler for config async event mailbox command. */
216 static void
217 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
218 {
219         if (pmboxq->mb.mbxStatus == MBX_SUCCESS)
220                 phba->temp_sensor_support = 1;
221         else
222                 phba->temp_sensor_support = 0;
223         mempool_free(pmboxq, phba->mbox_mem_pool);
224         return;
225 }
226
227 /************************************************************************/
228 /*                                                                      */
229 /*    lpfc_config_port_post                                             */
230 /*    This routine will do LPFC initialization after the                */
231 /*    CONFIG_PORT mailbox command. This will be initialized             */
232 /*    as a SLI layer callback routine.                                  */
233 /*    This routine returns 0 on success. Any other return value         */
234 /*    indicates an error.                                               */
235 /*                                                                      */
236 /************************************************************************/
237 int
238 lpfc_config_port_post(struct lpfc_hba *phba)
239 {
240         struct lpfc_vport *vport = phba->pport;
241         LPFC_MBOXQ_t *pmb;
242         MAILBOX_t *mb;
243         struct lpfc_dmabuf *mp;
244         struct lpfc_sli *psli = &phba->sli;
245         uint32_t status, timeout;
246         int i, j;
247         int rc;
248
249         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
250         if (!pmb) {
251                 phba->link_state = LPFC_HBA_ERROR;
252                 return -ENOMEM;
253         }
254         mb = &pmb->mb;
255
256         /* Get login parameters for NID.  */
257         lpfc_read_sparam(phba, pmb, 0);
258         pmb->vport = vport;
259         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
260                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
261                                 "0448 Adapter failed init, mbxCmd x%x "
262                                 "READ_SPARM mbxStatus x%x\n",
263                                 mb->mbxCommand, mb->mbxStatus);
264                 phba->link_state = LPFC_HBA_ERROR;
265                 mp = (struct lpfc_dmabuf *) pmb->context1;
266                 mempool_free( pmb, phba->mbox_mem_pool);
267                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
268                 kfree(mp);
269                 return -EIO;
270         }
271
272         mp = (struct lpfc_dmabuf *) pmb->context1;
273
274         memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
275         lpfc_mbuf_free(phba, mp->virt, mp->phys);
276         kfree(mp);
277         pmb->context1 = NULL;
278
279         if (phba->cfg_soft_wwnn)
280                 u64_to_wwn(phba->cfg_soft_wwnn,
281                            vport->fc_sparam.nodeName.u.wwn);
282         if (phba->cfg_soft_wwpn)
283                 u64_to_wwn(phba->cfg_soft_wwpn,
284                            vport->fc_sparam.portName.u.wwn);
285         memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
286                sizeof (struct lpfc_name));
287         memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
288                sizeof (struct lpfc_name));
289         /* If no serial number in VPD data, use low 6 bytes of WWNN */
290         /* This should be consolidated into parse_vpd ? - mr */
291         if (phba->SerialNumber[0] == 0) {
292                 uint8_t *outptr;
293
294                 outptr = &vport->fc_nodename.u.s.IEEE[0];
295                 for (i = 0; i < 12; i++) {
296                         status = *outptr++;
297                         j = ((status & 0xf0) >> 4);
298                         if (j <= 9)
299                                 phba->SerialNumber[i] =
300                                     (char)((uint8_t) 0x30 + (uint8_t) j);
301                         else
302                                 phba->SerialNumber[i] =
303                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
304                         i++;
305                         j = (status & 0xf);
306                         if (j <= 9)
307                                 phba->SerialNumber[i] =
308                                     (char)((uint8_t) 0x30 + (uint8_t) j);
309                         else
310                                 phba->SerialNumber[i] =
311                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
312                 }
313         }
314
315         lpfc_read_config(phba, pmb);
316         pmb->vport = vport;
317         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
318                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
319                                 "0453 Adapter failed to init, mbxCmd x%x "
320                                 "READ_CONFIG, mbxStatus x%x\n",
321                                 mb->mbxCommand, mb->mbxStatus);
322                 phba->link_state = LPFC_HBA_ERROR;
323                 mempool_free( pmb, phba->mbox_mem_pool);
324                 return -EIO;
325         }
326
327         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
328         if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1))
329                 phba->cfg_hba_queue_depth =
330                         mb->un.varRdConfig.max_xri + 1;
331
332         phba->lmt = mb->un.varRdConfig.lmt;
333
334         /* Get the default values for Model Name and Description */
335         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
336
337         if ((phba->cfg_link_speed > LINK_SPEED_10G)
338             || ((phba->cfg_link_speed == LINK_SPEED_1G)
339                 && !(phba->lmt & LMT_1Gb))
340             || ((phba->cfg_link_speed == LINK_SPEED_2G)
341                 && !(phba->lmt & LMT_2Gb))
342             || ((phba->cfg_link_speed == LINK_SPEED_4G)
343                 && !(phba->lmt & LMT_4Gb))
344             || ((phba->cfg_link_speed == LINK_SPEED_8G)
345                 && !(phba->lmt & LMT_8Gb))
346             || ((phba->cfg_link_speed == LINK_SPEED_10G)
347                 && !(phba->lmt & LMT_10Gb))) {
348                 /* Reset link speed to auto */
349                 lpfc_printf_log(phba, KERN_WARNING, LOG_LINK_EVENT,
350                         "1302 Invalid speed for this board: "
351                         "Reset link speed to auto: x%x\n",
352                         phba->cfg_link_speed);
353                         phba->cfg_link_speed = LINK_SPEED_AUTO;
354         }
355
356         phba->link_state = LPFC_LINK_DOWN;
357
358         /* Only process IOCBs on ELS ring till hba_state is READY */
359         if (psli->ring[psli->extra_ring].cmdringaddr)
360                 psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT;
361         if (psli->ring[psli->fcp_ring].cmdringaddr)
362                 psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT;
363         if (psli->ring[psli->next_ring].cmdringaddr)
364                 psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT;
365
366         /* Post receive buffers for desired rings */
367         if (phba->sli_rev != 3)
368                 lpfc_post_rcv_buf(phba);
369
370         /* Enable appropriate host interrupts */
371         spin_lock_irq(&phba->hbalock);
372         status = readl(phba->HCregaddr);
373         status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
374         if (psli->num_rings > 0)
375                 status |= HC_R0INT_ENA;
376         if (psli->num_rings > 1)
377                 status |= HC_R1INT_ENA;
378         if (psli->num_rings > 2)
379                 status |= HC_R2INT_ENA;
380         if (psli->num_rings > 3)
381                 status |= HC_R3INT_ENA;
382
383         if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
384             (phba->cfg_poll & DISABLE_FCP_RING_INT))
385                 status &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
386
387         writel(status, phba->HCregaddr);
388         readl(phba->HCregaddr); /* flush */
389         spin_unlock_irq(&phba->hbalock);
390
391         /*
392          * Setup the ring 0 (els)  timeout handler
393          */
394         timeout = phba->fc_ratov << 1;
395         mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
396         mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
397         phba->hb_outstanding = 0;
398         phba->last_completion_time = jiffies;
399
400         lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
401         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
402         pmb->vport = vport;
403         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
404         lpfc_set_loopback_flag(phba);
405         if (rc != MBX_SUCCESS) {
406                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
407                                 "0454 Adapter failed to init, mbxCmd x%x "
408                                 "INIT_LINK, mbxStatus x%x\n",
409                                 mb->mbxCommand, mb->mbxStatus);
410
411                 /* Clear all interrupt enable conditions */
412                 writel(0, phba->HCregaddr);
413                 readl(phba->HCregaddr); /* flush */
414                 /* Clear all pending interrupts */
415                 writel(0xffffffff, phba->HAregaddr);
416                 readl(phba->HAregaddr); /* flush */
417
418                 phba->link_state = LPFC_HBA_ERROR;
419                 if (rc != MBX_BUSY)
420                         mempool_free(pmb, phba->mbox_mem_pool);
421                 return -EIO;
422         }
423         /* MBOX buffer will be freed in mbox compl */
424         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
425         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
426         pmb->mbox_cmpl = lpfc_config_async_cmpl;
427         pmb->vport = phba->pport;
428         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
429
430         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
431                 lpfc_printf_log(phba,
432                                 KERN_ERR,
433                                 LOG_INIT,
434                                 "0456 Adapter failed to issue "
435                                 "ASYNCEVT_ENABLE mbox status x%x \n.",
436                                 rc);
437                 mempool_free(pmb, phba->mbox_mem_pool);
438         }
439         return (0);
440 }
441
442 /************************************************************************/
443 /*                                                                      */
444 /*    lpfc_hba_down_prep                                                */
445 /*    This routine will do LPFC uninitialization before the             */
446 /*    HBA is reset when bringing down the SLI Layer. This will be       */
447 /*    initialized as a SLI layer callback routine.                      */
448 /*    This routine returns 0 on success. Any other return value         */
449 /*    indicates an error.                                               */
450 /*                                                                      */
451 /************************************************************************/
452 int
453 lpfc_hba_down_prep(struct lpfc_hba *phba)
454 {
455         /* Disable interrupts */
456         writel(0, phba->HCregaddr);
457         readl(phba->HCregaddr); /* flush */
458
459         lpfc_cleanup_discovery_resources(phba->pport);
460         return 0;
461 }
462
463 /************************************************************************/
464 /*                                                                      */
465 /*    lpfc_hba_down_post                                                */
466 /*    This routine will do uninitialization after the HBA is reset      */
467 /*    when bringing down the SLI Layer.                                 */
468 /*    This routine returns 0 on success. Any other return value         */
469 /*    indicates an error.                                               */
470 /*                                                                      */
471 /************************************************************************/
472 int
473 lpfc_hba_down_post(struct lpfc_hba *phba)
474 {
475         struct lpfc_sli *psli = &phba->sli;
476         struct lpfc_sli_ring *pring;
477         struct lpfc_dmabuf *mp, *next_mp;
478         int i;
479
480         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
481                 lpfc_sli_hbqbuf_free_all(phba);
482         else {
483                 /* Cleanup preposted buffers on the ELS ring */
484                 pring = &psli->ring[LPFC_ELS_RING];
485                 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
486                         list_del(&mp->list);
487                         pring->postbufq_cnt--;
488                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
489                         kfree(mp);
490                 }
491         }
492
493         for (i = 0; i < psli->num_rings; i++) {
494                 pring = &psli->ring[i];
495                 lpfc_sli_abort_iocb_ring(phba, pring);
496         }
497
498         return 0;
499 }
500
501 /* HBA heart beat timeout handler */
502 void
503 lpfc_hb_timeout(unsigned long ptr)
504 {
505         struct lpfc_hba *phba;
506         unsigned long iflag;
507
508         phba = (struct lpfc_hba *)ptr;
509         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
510         if (!(phba->pport->work_port_events & WORKER_HB_TMO))
511                 phba->pport->work_port_events |= WORKER_HB_TMO;
512         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
513
514         if (phba->work_wait)
515                 wake_up(phba->work_wait);
516         return;
517 }
518
519 static void
520 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
521 {
522         unsigned long drvr_flag;
523
524         spin_lock_irqsave(&phba->hbalock, drvr_flag);
525         phba->hb_outstanding = 0;
526         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
527
528         mempool_free(pmboxq, phba->mbox_mem_pool);
529         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
530                 !(phba->link_state == LPFC_HBA_ERROR) &&
531                 !(phba->pport->load_flag & FC_UNLOADING))
532                 mod_timer(&phba->hb_tmofunc,
533                         jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
534         return;
535 }
536
537 void
538 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
539 {
540         LPFC_MBOXQ_t *pmboxq;
541         int retval;
542         struct lpfc_sli *psli = &phba->sli;
543
544         if ((phba->link_state == LPFC_HBA_ERROR) ||
545                 (phba->pport->load_flag & FC_UNLOADING) ||
546                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
547                 return;
548
549         spin_lock_irq(&phba->pport->work_port_lock);
550         /* If the timer is already canceled do nothing */
551         if (!(phba->pport->work_port_events & WORKER_HB_TMO)) {
552                 spin_unlock_irq(&phba->pport->work_port_lock);
553                 return;
554         }
555
556         if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ,
557                 jiffies)) {
558                 spin_unlock_irq(&phba->pport->work_port_lock);
559                 if (!phba->hb_outstanding)
560                         mod_timer(&phba->hb_tmofunc,
561                                 jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
562                 else
563                         mod_timer(&phba->hb_tmofunc,
564                                 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
565                 return;
566         }
567         spin_unlock_irq(&phba->pport->work_port_lock);
568
569         /* If there is no heart beat outstanding, issue a heartbeat command */
570         if (!phba->hb_outstanding) {
571                 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
572                 if (!pmboxq) {
573                         mod_timer(&phba->hb_tmofunc,
574                                 jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
575                         return;
576                 }
577
578                 lpfc_heart_beat(phba, pmboxq);
579                 pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
580                 pmboxq->vport = phba->pport;
581                 retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
582
583                 if (retval != MBX_BUSY && retval != MBX_SUCCESS) {
584                         mempool_free(pmboxq, phba->mbox_mem_pool);
585                         mod_timer(&phba->hb_tmofunc,
586                                 jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
587                         return;
588                 }
589                 mod_timer(&phba->hb_tmofunc,
590                         jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
591                 phba->hb_outstanding = 1;
592                 return;
593         } else {
594                 /*
595                  * If heart beat timeout called with hb_outstanding set we
596                  * need to take the HBA offline.
597                  */
598                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
599                                 "0459 Adapter heartbeat failure, taking "
600                                 "this port offline.\n");
601
602                 spin_lock_irq(&phba->hbalock);
603                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
604                 spin_unlock_irq(&phba->hbalock);
605
606                 lpfc_offline_prep(phba);
607                 lpfc_offline(phba);
608                 lpfc_unblock_mgmt_io(phba);
609                 phba->link_state = LPFC_HBA_ERROR;
610                 lpfc_hba_down_post(phba);
611         }
612 }
613
614 /************************************************************************/
615 /*                                                                      */
616 /*    lpfc_handle_eratt                                                 */
617 /*    This routine will handle processing a Host Attention              */
618 /*    Error Status event. This will be initialized                      */
619 /*    as a SLI layer callback routine.                                  */
620 /*                                                                      */
621 /************************************************************************/
622 void
623 lpfc_handle_eratt(struct lpfc_hba *phba)
624 {
625         struct lpfc_vport *vport = phba->pport;
626         struct lpfc_sli   *psli = &phba->sli;
627         struct lpfc_sli_ring  *pring;
628         struct lpfc_vport **vports;
629         uint32_t event_data;
630         unsigned long temperature;
631         struct temp_event temp_event_data;
632         struct Scsi_Host  *shost;
633         int i;
634
635         /* If the pci channel is offline, ignore possible errors,
636          * since we cannot communicate with the pci card anyway. */
637         if (pci_channel_offline(phba->pcidev))
638                 return;
639
640         if (phba->work_hs & HS_FFER6 ||
641             phba->work_hs & HS_FFER5) {
642                 /* Re-establishing Link */
643                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
644                                 "1301 Re-establishing Link "
645                                 "Data: x%x x%x x%x\n",
646                                 phba->work_hs,
647                                 phba->work_status[0], phba->work_status[1]);
648                 vports = lpfc_create_vport_work_array(phba);
649                 if (vports != NULL)
650                         for(i = 0;
651                             i < LPFC_MAX_VPORTS && vports[i] != NULL;
652                             i++){
653                                 shost = lpfc_shost_from_vport(vports[i]);
654                                 spin_lock_irq(shost->host_lock);
655                                 vports[i]->fc_flag |= FC_ESTABLISH_LINK;
656                                 spin_unlock_irq(shost->host_lock);
657                         }
658                 lpfc_destroy_vport_work_array(vports);
659                 spin_lock_irq(&phba->hbalock);
660                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
661                 spin_unlock_irq(&phba->hbalock);
662
663                 /*
664                 * Firmware stops when it triggled erratt with HS_FFER6.
665                 * That could cause the I/Os dropped by the firmware.
666                 * Error iocb (I/O) on txcmplq and let the SCSI layer
667                 * retry it after re-establishing link.
668                 */
669                 pring = &psli->ring[psli->fcp_ring];
670                 lpfc_sli_abort_iocb_ring(phba, pring);
671
672
673                 /*
674                  * There was a firmware error.  Take the hba offline and then
675                  * attempt to restart it.
676                  */
677                 lpfc_offline_prep(phba);
678                 lpfc_offline(phba);
679                 lpfc_sli_brdrestart(phba);
680                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
681                         mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
682                         lpfc_unblock_mgmt_io(phba);
683                         return;
684                 }
685                 lpfc_unblock_mgmt_io(phba);
686         } else if (phba->work_hs & HS_CRIT_TEMP) {
687                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
688                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
689                 temp_event_data.event_code = LPFC_CRIT_TEMP;
690                 temp_event_data.data = (uint32_t)temperature;
691
692                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
693                                 "0459 Adapter maximum temperature exceeded "
694                                 "(%ld), taking this port offline "
695                                 "Data: x%x x%x x%x\n",
696                                 temperature, phba->work_hs,
697                                 phba->work_status[0], phba->work_status[1]);
698
699                 shost = lpfc_shost_from_vport(phba->pport);
700                 fc_host_post_vendor_event(shost, fc_get_event_number(),
701                                           sizeof(temp_event_data),
702                                           (char *) &temp_event_data,
703                                           SCSI_NL_VID_TYPE_PCI
704                                           | PCI_VENDOR_ID_EMULEX);
705
706                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
707                 lpfc_offline_prep(phba);
708                 lpfc_offline(phba);
709                 lpfc_unblock_mgmt_io(phba);
710                 phba->link_state = LPFC_HBA_ERROR;
711                 lpfc_hba_down_post(phba);
712
713         } else {
714                 /* The if clause above forces this code path when the status
715                  * failure is a value other than FFER6.  Do not call the offline
716                  *  twice. This is the adapter hardware error path.
717                  */
718                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
719                                 "0457 Adapter Hardware Error "
720                                 "Data: x%x x%x x%x\n",
721                                 phba->work_hs,
722                                 phba->work_status[0], phba->work_status[1]);
723
724                 event_data = FC_REG_DUMP_EVENT;
725                 shost = lpfc_shost_from_vport(vport);
726                 fc_host_post_vendor_event(shost, fc_get_event_number(),
727                                 sizeof(event_data), (char *) &event_data,
728                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
729
730                 spin_lock_irq(&phba->hbalock);
731                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
732                 spin_unlock_irq(&phba->hbalock);
733                 lpfc_offline_prep(phba);
734                 lpfc_offline(phba);
735                 lpfc_unblock_mgmt_io(phba);
736                 phba->link_state = LPFC_HBA_ERROR;
737                 lpfc_hba_down_post(phba);
738         }
739 }
740
741 /************************************************************************/
742 /*                                                                      */
743 /*    lpfc_handle_latt                                                  */
744 /*    This routine will handle processing a Host Attention              */
745 /*    Link Status event. This will be initialized                       */
746 /*    as a SLI layer callback routine.                                  */
747 /*                                                                      */
748 /************************************************************************/
749 void
750 lpfc_handle_latt(struct lpfc_hba *phba)
751 {
752         struct lpfc_vport *vport = phba->pport;
753         struct lpfc_sli   *psli = &phba->sli;
754         LPFC_MBOXQ_t *pmb;
755         volatile uint32_t control;
756         struct lpfc_dmabuf *mp;
757         int rc = -ENOMEM;
758
759         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
760         if (!pmb)
761                 goto lpfc_handle_latt_err_exit;
762
763         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
764         if (!mp)
765                 goto lpfc_handle_latt_free_pmb;
766
767         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
768         if (!mp->virt)
769                 goto lpfc_handle_latt_free_mp;
770
771         rc = -EIO;
772
773         /* Cleanup any outstanding ELS commands */
774         lpfc_els_flush_all_cmd(phba);
775
776         psli->slistat.link_event++;
777         lpfc_read_la(phba, pmb, mp);
778         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
779         pmb->vport = vport;
780         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
781         if (rc == MBX_NOT_FINISHED)
782                 goto lpfc_handle_latt_free_mbuf;
783
784         /* Clear Link Attention in HA REG */
785         spin_lock_irq(&phba->hbalock);
786         writel(HA_LATT, phba->HAregaddr);
787         readl(phba->HAregaddr); /* flush */
788         spin_unlock_irq(&phba->hbalock);
789
790         return;
791
792 lpfc_handle_latt_free_mbuf:
793         lpfc_mbuf_free(phba, mp->virt, mp->phys);
794 lpfc_handle_latt_free_mp:
795         kfree(mp);
796 lpfc_handle_latt_free_pmb:
797         mempool_free(pmb, phba->mbox_mem_pool);
798 lpfc_handle_latt_err_exit:
799         /* Enable Link attention interrupts */
800         spin_lock_irq(&phba->hbalock);
801         psli->sli_flag |= LPFC_PROCESS_LA;
802         control = readl(phba->HCregaddr);
803         control |= HC_LAINT_ENA;
804         writel(control, phba->HCregaddr);
805         readl(phba->HCregaddr); /* flush */
806
807         /* Clear Link Attention in HA REG */
808         writel(HA_LATT, phba->HAregaddr);
809         readl(phba->HAregaddr); /* flush */
810         spin_unlock_irq(&phba->hbalock);
811         lpfc_linkdown(phba);
812         phba->link_state = LPFC_HBA_ERROR;
813
814         /* The other case is an error from issue_mbox */
815         if (rc == -ENOMEM)
816                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
817                                 "0300 READ_LA: no buffers\n");
818
819         return;
820 }
821
822 /************************************************************************/
823 /*                                                                      */
824 /*   lpfc_parse_vpd                                                     */
825 /*   This routine will parse the VPD data                               */
826 /*                                                                      */
827 /************************************************************************/
828 static int
829 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
830 {
831         uint8_t lenlo, lenhi;
832         int Length;
833         int i, j;
834         int finished = 0;
835         int index = 0;
836
837         if (!vpd)
838                 return 0;
839
840         /* Vital Product */
841         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
842                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
843                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
844                         (uint32_t) vpd[3]);
845         while (!finished && (index < (len - 4))) {
846                 switch (vpd[index]) {
847                 case 0x82:
848                 case 0x91:
849                         index += 1;
850                         lenlo = vpd[index];
851                         index += 1;
852                         lenhi = vpd[index];
853                         index += 1;
854                         i = ((((unsigned short)lenhi) << 8) + lenlo);
855                         index += i;
856                         break;
857                 case 0x90:
858                         index += 1;
859                         lenlo = vpd[index];
860                         index += 1;
861                         lenhi = vpd[index];
862                         index += 1;
863                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
864                         if (Length > len - index)
865                                 Length = len - index;
866                         while (Length > 0) {
867                         /* Look for Serial Number */
868                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
869                                 index += 2;
870                                 i = vpd[index];
871                                 index += 1;
872                                 j = 0;
873                                 Length -= (3+i);
874                                 while(i--) {
875                                         phba->SerialNumber[j++] = vpd[index++];
876                                         if (j == 31)
877                                                 break;
878                                 }
879                                 phba->SerialNumber[j] = 0;
880                                 continue;
881                         }
882                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
883                                 phba->vpd_flag |= VPD_MODEL_DESC;
884                                 index += 2;
885                                 i = vpd[index];
886                                 index += 1;
887                                 j = 0;
888                                 Length -= (3+i);
889                                 while(i--) {
890                                         phba->ModelDesc[j++] = vpd[index++];
891                                         if (j == 255)
892                                                 break;
893                                 }
894                                 phba->ModelDesc[j] = 0;
895                                 continue;
896                         }
897                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
898                                 phba->vpd_flag |= VPD_MODEL_NAME;
899                                 index += 2;
900                                 i = vpd[index];
901                                 index += 1;
902                                 j = 0;
903                                 Length -= (3+i);
904                                 while(i--) {
905                                         phba->ModelName[j++] = vpd[index++];
906                                         if (j == 79)
907                                                 break;
908                                 }
909                                 phba->ModelName[j] = 0;
910                                 continue;
911                         }
912                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
913                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
914                                 index += 2;
915                                 i = vpd[index];
916                                 index += 1;
917                                 j = 0;
918                                 Length -= (3+i);
919                                 while(i--) {
920                                         phba->ProgramType[j++] = vpd[index++];
921                                         if (j == 255)
922                                                 break;
923                                 }
924                                 phba->ProgramType[j] = 0;
925                                 continue;
926                         }
927                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
928                                 phba->vpd_flag |= VPD_PORT;
929                                 index += 2;
930                                 i = vpd[index];
931                                 index += 1;
932                                 j = 0;
933                                 Length -= (3+i);
934                                 while(i--) {
935                                 phba->Port[j++] = vpd[index++];
936                                 if (j == 19)
937                                         break;
938                                 }
939                                 phba->Port[j] = 0;
940                                 continue;
941                         }
942                         else {
943                                 index += 2;
944                                 i = vpd[index];
945                                 index += 1;
946                                 index += i;
947                                 Length -= (3 + i);
948                         }
949                 }
950                 finished = 0;
951                 break;
952                 case 0x78:
953                         finished = 1;
954                         break;
955                 default:
956                         index ++;
957                         break;
958                 }
959         }
960
961         return(1);
962 }
963
964 static void
965 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
966 {
967         lpfc_vpd_t *vp;
968         uint16_t dev_id = phba->pcidev->device;
969         int max_speed;
970         struct {
971                 char * name;
972                 int    max_speed;
973                 char * bus;
974         } m = {"<Unknown>", 0, ""};
975
976         if (mdp && mdp[0] != '\0'
977                 && descp && descp[0] != '\0')
978                 return;
979
980         if (phba->lmt & LMT_10Gb)
981                 max_speed = 10;
982         else if (phba->lmt & LMT_8Gb)
983                 max_speed = 8;
984         else if (phba->lmt & LMT_4Gb)
985                 max_speed = 4;
986         else if (phba->lmt & LMT_2Gb)
987                 max_speed = 2;
988         else
989                 max_speed = 1;
990
991         vp = &phba->vpd;
992
993         switch (dev_id) {
994         case PCI_DEVICE_ID_FIREFLY:
995                 m = (typeof(m)){"LP6000", max_speed, "PCI"};
996                 break;
997         case PCI_DEVICE_ID_SUPERFLY:
998                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
999                         m = (typeof(m)){"LP7000", max_speed,  "PCI"};
1000                 else
1001                         m = (typeof(m)){"LP7000E", max_speed, "PCI"};
1002                 break;
1003         case PCI_DEVICE_ID_DRAGONFLY:
1004                 m = (typeof(m)){"LP8000", max_speed, "PCI"};
1005                 break;
1006         case PCI_DEVICE_ID_CENTAUR:
1007                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
1008                         m = (typeof(m)){"LP9002", max_speed, "PCI"};
1009                 else
1010                         m = (typeof(m)){"LP9000", max_speed, "PCI"};
1011                 break;
1012         case PCI_DEVICE_ID_RFLY:
1013                 m = (typeof(m)){"LP952", max_speed, "PCI"};
1014                 break;
1015         case PCI_DEVICE_ID_PEGASUS:
1016                 m = (typeof(m)){"LP9802", max_speed, "PCI-X"};
1017                 break;
1018         case PCI_DEVICE_ID_THOR:
1019                 m = (typeof(m)){"LP10000", max_speed, "PCI-X"};
1020                 break;
1021         case PCI_DEVICE_ID_VIPER:
1022                 m = (typeof(m)){"LPX1000", max_speed,  "PCI-X"};
1023                 break;
1024         case PCI_DEVICE_ID_PFLY:
1025                 m = (typeof(m)){"LP982", max_speed, "PCI-X"};
1026                 break;
1027         case PCI_DEVICE_ID_TFLY:
1028                 m = (typeof(m)){"LP1050", max_speed, "PCI-X"};
1029                 break;
1030         case PCI_DEVICE_ID_HELIOS:
1031                 m = (typeof(m)){"LP11000", max_speed, "PCI-X2"};
1032                 break;
1033         case PCI_DEVICE_ID_HELIOS_SCSP:
1034                 m = (typeof(m)){"LP11000-SP", max_speed, "PCI-X2"};
1035                 break;
1036         case PCI_DEVICE_ID_HELIOS_DCSP:
1037                 m = (typeof(m)){"LP11002-SP", max_speed, "PCI-X2"};
1038                 break;
1039         case PCI_DEVICE_ID_NEPTUNE:
1040                 m = (typeof(m)){"LPe1000", max_speed, "PCIe"};
1041                 break;
1042         case PCI_DEVICE_ID_NEPTUNE_SCSP:
1043                 m = (typeof(m)){"LPe1000-SP", max_speed, "PCIe"};
1044                 break;
1045         case PCI_DEVICE_ID_NEPTUNE_DCSP:
1046                 m = (typeof(m)){"LPe1002-SP", max_speed, "PCIe"};
1047                 break;
1048         case PCI_DEVICE_ID_BMID:
1049                 m = (typeof(m)){"LP1150", max_speed, "PCI-X2"};
1050                 break;
1051         case PCI_DEVICE_ID_BSMB:
1052                 m = (typeof(m)){"LP111", max_speed, "PCI-X2"};
1053                 break;
1054         case PCI_DEVICE_ID_ZEPHYR:
1055                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1056                 break;
1057         case PCI_DEVICE_ID_ZEPHYR_SCSP:
1058                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1059                 break;
1060         case PCI_DEVICE_ID_ZEPHYR_DCSP:
1061                 m = (typeof(m)){"LPe11002-SP", max_speed, "PCIe"};
1062                 break;
1063         case PCI_DEVICE_ID_ZMID:
1064                 m = (typeof(m)){"LPe1150", max_speed, "PCIe"};
1065                 break;
1066         case PCI_DEVICE_ID_ZSMB:
1067                 m = (typeof(m)){"LPe111", max_speed, "PCIe"};
1068                 break;
1069         case PCI_DEVICE_ID_LP101:
1070                 m = (typeof(m)){"LP101", max_speed, "PCI-X"};
1071                 break;
1072         case PCI_DEVICE_ID_LP10000S:
1073                 m = (typeof(m)){"LP10000-S", max_speed, "PCI"};
1074                 break;
1075         case PCI_DEVICE_ID_LP11000S:
1076                 m = (typeof(m)){"LP11000-S", max_speed,
1077                         "PCI-X2"};
1078                 break;
1079         case PCI_DEVICE_ID_LPE11000S:
1080                 m = (typeof(m)){"LPe11000-S", max_speed,
1081                         "PCIe"};
1082                 break;
1083         case PCI_DEVICE_ID_SAT:
1084                 m = (typeof(m)){"LPe12000", max_speed, "PCIe"};
1085                 break;
1086         case PCI_DEVICE_ID_SAT_MID:
1087                 m = (typeof(m)){"LPe1250", max_speed, "PCIe"};
1088                 break;
1089         case PCI_DEVICE_ID_SAT_SMB:
1090                 m = (typeof(m)){"LPe121", max_speed, "PCIe"};
1091                 break;
1092         case PCI_DEVICE_ID_SAT_DCSP:
1093                 m = (typeof(m)){"LPe12002-SP", max_speed, "PCIe"};
1094                 break;
1095         case PCI_DEVICE_ID_SAT_SCSP:
1096                 m = (typeof(m)){"LPe12000-SP", max_speed, "PCIe"};
1097                 break;
1098         case PCI_DEVICE_ID_SAT_S:
1099                 m = (typeof(m)){"LPe12000-S", max_speed, "PCIe"};
1100                 break;
1101         default:
1102                 m = (typeof(m)){ NULL };
1103                 break;
1104         }
1105
1106         if (mdp && mdp[0] == '\0')
1107                 snprintf(mdp, 79,"%s", m.name);
1108         if (descp && descp[0] == '\0')
1109                 snprintf(descp, 255,
1110                          "Emulex %s %dGb %s Fibre Channel Adapter",
1111                          m.name, m.max_speed, m.bus);
1112 }
1113
1114 /**************************************************/
1115 /*   lpfc_post_buffer                             */
1116 /*                                                */
1117 /*   This routine will post count buffers to the  */
1118 /*   ring with the QUE_RING_BUF_CN command. This  */
1119 /*   allows 3 buffers / command to be posted.     */
1120 /*   Returns the number of buffers NOT posted.    */
1121 /**************************************************/
1122 int
1123 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt,
1124                  int type)
1125 {
1126         IOCB_t *icmd;
1127         struct lpfc_iocbq *iocb;
1128         struct lpfc_dmabuf *mp1, *mp2;
1129
1130         cnt += pring->missbufcnt;
1131
1132         /* While there are buffers to post */
1133         while (cnt > 0) {
1134                 /* Allocate buffer for  command iocb */
1135                 iocb = lpfc_sli_get_iocbq(phba);
1136                 if (iocb == NULL) {
1137                         pring->missbufcnt = cnt;
1138                         return cnt;
1139                 }
1140                 icmd = &iocb->iocb;
1141
1142                 /* 2 buffers can be posted per command */
1143                 /* Allocate buffer to post */
1144                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1145                 if (mp1)
1146                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
1147                 if (!mp1 || !mp1->virt) {
1148                         kfree(mp1);
1149                         lpfc_sli_release_iocbq(phba, iocb);
1150                         pring->missbufcnt = cnt;
1151                         return cnt;
1152                 }
1153
1154                 INIT_LIST_HEAD(&mp1->list);
1155                 /* Allocate buffer to post */
1156                 if (cnt > 1) {
1157                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1158                         if (mp2)
1159                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
1160                                                             &mp2->phys);
1161                         if (!mp2 || !mp2->virt) {
1162                                 kfree(mp2);
1163                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1164                                 kfree(mp1);
1165                                 lpfc_sli_release_iocbq(phba, iocb);
1166                                 pring->missbufcnt = cnt;
1167                                 return cnt;
1168                         }
1169
1170                         INIT_LIST_HEAD(&mp2->list);
1171                 } else {
1172                         mp2 = NULL;
1173                 }
1174
1175                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
1176                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
1177                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
1178                 icmd->ulpBdeCount = 1;
1179                 cnt--;
1180                 if (mp2) {
1181                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
1182                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
1183                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
1184                         cnt--;
1185                         icmd->ulpBdeCount = 2;
1186                 }
1187
1188                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1189                 icmd->ulpLe = 1;
1190
1191                 if (lpfc_sli_issue_iocb(phba, pring, iocb, 0) == IOCB_ERROR) {
1192                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1193                         kfree(mp1);
1194                         cnt++;
1195                         if (mp2) {
1196                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1197                                 kfree(mp2);
1198                                 cnt++;
1199                         }
1200                         lpfc_sli_release_iocbq(phba, iocb);
1201                         pring->missbufcnt = cnt;
1202                         return cnt;
1203                 }
1204                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1205                 if (mp2)
1206                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1207         }
1208         pring->missbufcnt = 0;
1209         return 0;
1210 }
1211
1212 /************************************************************************/
1213 /*                                                                      */
1214 /*   lpfc_post_rcv_buf                                                  */
1215 /*   This routine post initial rcv buffers to the configured rings      */
1216 /*                                                                      */
1217 /************************************************************************/
1218 static int
1219 lpfc_post_rcv_buf(struct lpfc_hba *phba)
1220 {
1221         struct lpfc_sli *psli = &phba->sli;
1222
1223         /* Ring 0, ELS / CT buffers */
1224         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0, 1);
1225         /* Ring 2 - FCP no buffers needed */
1226
1227         return 0;
1228 }
1229
1230 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
1231
1232 /************************************************************************/
1233 /*                                                                      */
1234 /*   lpfc_sha_init                                                      */
1235 /*                                                                      */
1236 /************************************************************************/
1237 static void
1238 lpfc_sha_init(uint32_t * HashResultPointer)
1239 {
1240         HashResultPointer[0] = 0x67452301;
1241         HashResultPointer[1] = 0xEFCDAB89;
1242         HashResultPointer[2] = 0x98BADCFE;
1243         HashResultPointer[3] = 0x10325476;
1244         HashResultPointer[4] = 0xC3D2E1F0;
1245 }
1246
1247 /************************************************************************/
1248 /*                                                                      */
1249 /*   lpfc_sha_iterate                                                   */
1250 /*                                                                      */
1251 /************************************************************************/
1252 static void
1253 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
1254 {
1255         int t;
1256         uint32_t TEMP;
1257         uint32_t A, B, C, D, E;
1258         t = 16;
1259         do {
1260                 HashWorkingPointer[t] =
1261                     S(1,
1262                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
1263                                                                      8] ^
1264                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
1265         } while (++t <= 79);
1266         t = 0;
1267         A = HashResultPointer[0];
1268         B = HashResultPointer[1];
1269         C = HashResultPointer[2];
1270         D = HashResultPointer[3];
1271         E = HashResultPointer[4];
1272
1273         do {
1274                 if (t < 20) {
1275                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
1276                 } else if (t < 40) {
1277                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
1278                 } else if (t < 60) {
1279                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
1280                 } else {
1281                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
1282                 }
1283                 TEMP += S(5, A) + E + HashWorkingPointer[t];
1284                 E = D;
1285                 D = C;
1286                 C = S(30, B);
1287                 B = A;
1288                 A = TEMP;
1289         } while (++t <= 79);
1290
1291         HashResultPointer[0] += A;
1292         HashResultPointer[1] += B;
1293         HashResultPointer[2] += C;
1294         HashResultPointer[3] += D;
1295         HashResultPointer[4] += E;
1296
1297 }
1298
1299 /************************************************************************/
1300 /*                                                                      */
1301 /*   lpfc_challenge_key                                                 */
1302 /*                                                                      */
1303 /************************************************************************/
1304 static void
1305 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
1306 {
1307         *HashWorking = (*RandomChallenge ^ *HashWorking);
1308 }
1309
1310 /************************************************************************/
1311 /*                                                                      */
1312 /*   lpfc_hba_init                                                      */
1313 /*                                                                      */
1314 /************************************************************************/
1315 void
1316 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
1317 {
1318         int t;
1319         uint32_t *HashWorking;
1320         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
1321
1322         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
1323         if (!HashWorking)
1324                 return;
1325
1326         HashWorking[0] = HashWorking[78] = *pwwnn++;
1327         HashWorking[1] = HashWorking[79] = *pwwnn;
1328
1329         for (t = 0; t < 7; t++)
1330                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
1331
1332         lpfc_sha_init(hbainit);
1333         lpfc_sha_iterate(hbainit, HashWorking);
1334         kfree(HashWorking);
1335 }
1336
1337 void
1338 lpfc_cleanup(struct lpfc_vport *vport)
1339 {
1340         struct lpfc_hba   *phba = vport->phba;
1341         struct lpfc_nodelist *ndlp, *next_ndlp;
1342
1343         if (phba->link_state > LPFC_LINK_DOWN)
1344                 lpfc_port_link_failure(vport);
1345
1346         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1347                 if (ndlp->nlp_type & NLP_FABRIC)
1348                         lpfc_disc_state_machine(vport, ndlp, NULL,
1349                                         NLP_EVT_DEVICE_RECOVERY);
1350                 lpfc_disc_state_machine(vport, ndlp, NULL,
1351                                              NLP_EVT_DEVICE_RM);
1352         }
1353
1354         /* At this point, ALL ndlp's should be gone */
1355         while (!list_empty(&vport->fc_nodes)) {
1356
1357                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
1358                         nlp_listp) {
1359                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1360                                 "0233 Nodelist x%x not free: %d\n",
1361                                 ndlp->nlp_DID,
1362                                 atomic_read(&ndlp->kref.refcount));
1363                         lpfc_drop_node(vport, ndlp);
1364                 }
1365         }
1366         return;
1367 }
1368
1369 static void
1370 lpfc_establish_link_tmo(unsigned long ptr)
1371 {
1372         struct lpfc_hba   *phba = (struct lpfc_hba *) ptr;
1373         struct lpfc_vport **vports;
1374         unsigned long iflag;
1375         int i;
1376
1377         /* Re-establishing Link, timer expired */
1378         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1379                         "1300 Re-establishing Link, timer expired "
1380                         "Data: x%x x%x\n",
1381                         phba->pport->fc_flag, phba->pport->port_state);
1382         vports = lpfc_create_vport_work_array(phba);
1383         if (vports != NULL)
1384                 for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
1385                         struct Scsi_Host *shost;
1386                         shost = lpfc_shost_from_vport(vports[i]);
1387                         spin_lock_irqsave(shost->host_lock, iflag);
1388                         vports[i]->fc_flag &= ~FC_ESTABLISH_LINK;
1389                         spin_unlock_irqrestore(shost->host_lock, iflag);
1390                 }
1391         lpfc_destroy_vport_work_array(vports);
1392 }
1393
1394 void
1395 lpfc_stop_vport_timers(struct lpfc_vport *vport)
1396 {
1397         del_timer_sync(&vport->els_tmofunc);
1398         del_timer_sync(&vport->fc_fdmitmo);
1399         lpfc_can_disctmo(vport);
1400         return;
1401 }
1402
1403 static void
1404 lpfc_stop_phba_timers(struct lpfc_hba *phba)
1405 {
1406         del_timer_sync(&phba->fcp_poll_timer);
1407         del_timer_sync(&phba->fc_estabtmo);
1408         lpfc_stop_vport_timers(phba->pport);
1409         del_timer_sync(&phba->sli.mbox_tmo);
1410         del_timer_sync(&phba->fabric_block_timer);
1411         phba->hb_outstanding = 0;
1412         del_timer_sync(&phba->hb_tmofunc);
1413         return;
1414 }
1415
1416 int
1417 lpfc_online(struct lpfc_hba *phba)
1418 {
1419         struct lpfc_vport *vport = phba->pport;
1420         struct lpfc_vport **vports;
1421         int i;
1422
1423         if (!phba)
1424                 return 0;
1425
1426         if (!(vport->fc_flag & FC_OFFLINE_MODE))
1427                 return 0;
1428
1429         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1430                         "0458 Bring Adapter online\n");
1431
1432         lpfc_block_mgmt_io(phba);
1433
1434         if (!lpfc_sli_queue_setup(phba)) {
1435                 lpfc_unblock_mgmt_io(phba);
1436                 return 1;
1437         }
1438
1439         if (lpfc_sli_hba_setup(phba)) { /* Initialize the HBA */
1440                 lpfc_unblock_mgmt_io(phba);
1441                 return 1;
1442         }
1443
1444         vports = lpfc_create_vport_work_array(phba);
1445         if (vports != NULL)
1446                 for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
1447                         struct Scsi_Host *shost;
1448                         shost = lpfc_shost_from_vport(vports[i]);
1449                         spin_lock_irq(shost->host_lock);
1450                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
1451                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
1452                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1453                         spin_unlock_irq(shost->host_lock);
1454                 }
1455                 lpfc_destroy_vport_work_array(vports);
1456
1457         lpfc_unblock_mgmt_io(phba);
1458         return 0;
1459 }
1460
1461 void
1462 lpfc_block_mgmt_io(struct lpfc_hba * phba)
1463 {
1464         unsigned long iflag;
1465
1466         spin_lock_irqsave(&phba->hbalock, iflag);
1467         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
1468         spin_unlock_irqrestore(&phba->hbalock, iflag);
1469 }
1470
1471 void
1472 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
1473 {
1474         unsigned long iflag;
1475
1476         spin_lock_irqsave(&phba->hbalock, iflag);
1477         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
1478         spin_unlock_irqrestore(&phba->hbalock, iflag);
1479 }
1480
1481 void
1482 lpfc_offline_prep(struct lpfc_hba * phba)
1483 {
1484         struct lpfc_vport *vport = phba->pport;
1485         struct lpfc_nodelist  *ndlp, *next_ndlp;
1486         struct lpfc_vport **vports;
1487         int i;
1488
1489         if (vport->fc_flag & FC_OFFLINE_MODE)
1490                 return;
1491
1492         lpfc_block_mgmt_io(phba);
1493
1494         lpfc_linkdown(phba);
1495
1496         /* Issue an unreg_login to all nodes on all vports */
1497         vports = lpfc_create_vport_work_array(phba);
1498         if (vports != NULL) {
1499                 for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
1500                         struct Scsi_Host *shost;
1501
1502                         shost = lpfc_shost_from_vport(vports[i]);
1503                         list_for_each_entry_safe(ndlp, next_ndlp,
1504                                                  &vports[i]->fc_nodes,
1505                                                  nlp_listp) {
1506                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
1507                                         continue;
1508                                 if (ndlp->nlp_type & NLP_FABRIC) {
1509                                         lpfc_disc_state_machine(vports[i], ndlp,
1510                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
1511                                         lpfc_disc_state_machine(vports[i], ndlp,
1512                                                 NULL, NLP_EVT_DEVICE_RM);
1513                                 }
1514                                 spin_lock_irq(shost->host_lock);
1515                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
1516                                 spin_unlock_irq(shost->host_lock);
1517                                 lpfc_unreg_rpi(vports[i], ndlp);
1518                         }
1519                 }
1520         }
1521         lpfc_destroy_vport_work_array(vports);
1522
1523         lpfc_sli_flush_mbox_queue(phba);
1524 }
1525
1526 void
1527 lpfc_offline(struct lpfc_hba *phba)
1528 {
1529         struct Scsi_Host  *shost;
1530         struct lpfc_vport **vports;
1531         int i;
1532
1533         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1534                 return;
1535
1536         /* stop all timers associated with this hba */
1537         lpfc_stop_phba_timers(phba);
1538         vports = lpfc_create_vport_work_array(phba);
1539         if (vports != NULL)
1540                 for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++)
1541                         lpfc_stop_vport_timers(vports[i]);
1542         lpfc_destroy_vport_work_array(vports);
1543         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1544                         "0460 Bring Adapter offline\n");
1545         /* Bring down the SLI Layer and cleanup.  The HBA is offline
1546            now.  */
1547         lpfc_sli_hba_down(phba);
1548         spin_lock_irq(&phba->hbalock);
1549         phba->work_ha = 0;
1550         spin_unlock_irq(&phba->hbalock);
1551         vports = lpfc_create_vport_work_array(phba);
1552         if (vports != NULL)
1553                 for(i = 0; i < LPFC_MAX_VPORTS && vports[i] != NULL; i++) {
1554                         shost = lpfc_shost_from_vport(vports[i]);
1555                         spin_lock_irq(shost->host_lock);
1556                         vports[i]->work_port_events = 0;
1557                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
1558                         spin_unlock_irq(shost->host_lock);
1559                 }
1560         lpfc_destroy_vport_work_array(vports);
1561 }
1562
1563 /******************************************************************************
1564 * Function name: lpfc_scsi_free
1565 *
1566 * Description: Called from lpfc_pci_remove_one free internal driver resources
1567 *
1568 ******************************************************************************/
1569 static int
1570 lpfc_scsi_free(struct lpfc_hba *phba)
1571 {
1572         struct lpfc_scsi_buf *sb, *sb_next;
1573         struct lpfc_iocbq *io, *io_next;
1574
1575         spin_lock_irq(&phba->hbalock);
1576         /* Release all the lpfc_scsi_bufs maintained by this host. */
1577         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
1578                 list_del(&sb->list);
1579                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
1580                               sb->dma_handle);
1581                 kfree(sb);
1582                 phba->total_scsi_bufs--;
1583         }
1584
1585         /* Release all the lpfc_iocbq entries maintained by this host. */
1586         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
1587                 list_del(&io->list);
1588                 kfree(io);
1589                 phba->total_iocbq_bufs--;
1590         }
1591
1592         spin_unlock_irq(&phba->hbalock);
1593
1594         return 0;
1595 }
1596
1597 struct lpfc_vport *
1598 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
1599 {
1600         struct lpfc_vport *vport;
1601         struct Scsi_Host  *shost;
1602         int error = 0;
1603
1604         if (dev != &phba->pcidev->dev)
1605                 shost = scsi_host_alloc(&lpfc_vport_template,
1606                                         sizeof(struct lpfc_vport));
1607         else
1608                 shost = scsi_host_alloc(&lpfc_template,
1609                                         sizeof(struct lpfc_vport));
1610         if (!shost)
1611                 goto out;
1612
1613         vport = (struct lpfc_vport *) shost->hostdata;
1614         vport->phba = phba;
1615
1616         vport->load_flag |= FC_LOADING;
1617         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1618
1619         lpfc_get_vport_cfgparam(vport);
1620         shost->unique_id = instance;
1621         shost->max_id = LPFC_MAX_TARGET;
1622         shost->max_lun = vport->cfg_max_luns;
1623         shost->this_id = -1;
1624         shost->max_cmd_len = 16;
1625         /*
1626          * Set initial can_queue value since 0 is no longer supported and
1627          * scsi_add_host will fail. This will be adjusted later based on the
1628          * max xri value determined in hba setup.
1629          */
1630         shost->can_queue = phba->cfg_hba_queue_depth - 10;
1631         if (dev != &phba->pcidev->dev) {
1632                 shost->transportt = lpfc_vport_transport_template;
1633                 vport->port_type = LPFC_NPIV_PORT;
1634         } else {
1635                 shost->transportt = lpfc_transport_template;
1636                 vport->port_type = LPFC_PHYSICAL_PORT;
1637         }
1638
1639         /* Initialize all internally managed lists. */
1640         INIT_LIST_HEAD(&vport->fc_nodes);
1641         spin_lock_init(&vport->work_port_lock);
1642
1643         init_timer(&vport->fc_disctmo);
1644         vport->fc_disctmo.function = lpfc_disc_timeout;
1645         vport->fc_disctmo.data = (unsigned long)vport;
1646
1647         init_timer(&vport->fc_fdmitmo);
1648         vport->fc_fdmitmo.function = lpfc_fdmi_tmo;
1649         vport->fc_fdmitmo.data = (unsigned long)vport;
1650
1651         init_timer(&vport->els_tmofunc);
1652         vport->els_tmofunc.function = lpfc_els_timeout;
1653         vport->els_tmofunc.data = (unsigned long)vport;
1654
1655         error = scsi_add_host(shost, dev);
1656         if (error)
1657                 goto out_put_shost;
1658
1659         spin_lock_irq(&phba->hbalock);
1660         list_add_tail(&vport->listentry, &phba->port_list);
1661         spin_unlock_irq(&phba->hbalock);
1662         return vport;
1663
1664 out_put_shost:
1665         scsi_host_put(shost);
1666 out:
1667         return NULL;
1668 }
1669
1670 void
1671 destroy_port(struct lpfc_vport *vport)
1672 {
1673         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1674         struct lpfc_hba  *phba = vport->phba;
1675
1676         kfree(vport->vname);
1677
1678         lpfc_debugfs_terminate(vport);
1679         fc_remove_host(shost);
1680         scsi_remove_host(shost);
1681
1682         spin_lock_irq(&phba->hbalock);
1683         list_del_init(&vport->listentry);
1684         spin_unlock_irq(&phba->hbalock);
1685
1686         lpfc_cleanup(vport);
1687         return;
1688 }
1689
1690 int
1691 lpfc_get_instance(void)
1692 {
1693         int instance = 0;
1694
1695         /* Assign an unused number */
1696         if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL))
1697                 return -1;
1698         if (idr_get_new(&lpfc_hba_index, NULL, &instance))
1699                 return -1;
1700         return instance;
1701 }
1702
1703 /*
1704  * Note: there is no scan_start function as adapter initialization
1705  * will have asynchronously kicked off the link initialization.
1706  */
1707
1708 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
1709 {
1710         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1711         struct lpfc_hba   *phba = vport->phba;
1712         int stat = 0;
1713
1714         spin_lock_irq(shost->host_lock);
1715
1716         if (vport->load_flag & FC_UNLOADING) {
1717                 stat = 1;
1718                 goto finished;
1719         }
1720         if (time >= 30 * HZ) {
1721                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1722                                 "0461 Scanning longer than 30 "
1723                                 "seconds.  Continuing initialization\n");
1724                 stat = 1;
1725                 goto finished;
1726         }
1727         if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
1728                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1729                                 "0465 Link down longer than 15 "
1730                                 "seconds.  Continuing initialization\n");
1731                 stat = 1;
1732                 goto finished;
1733         }
1734
1735         if (vport->port_state != LPFC_VPORT_READY)
1736                 goto finished;
1737         if (vport->num_disc_nodes || vport->fc_prli_sent)
1738                 goto finished;
1739         if (vport->fc_map_cnt == 0 && time < 2 * HZ)
1740                 goto finished;
1741         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
1742                 goto finished;
1743
1744         stat = 1;
1745
1746 finished:
1747         spin_unlock_irq(shost->host_lock);
1748         return stat;
1749 }
1750
1751 void lpfc_host_attrib_init(struct Scsi_Host *shost)
1752 {
1753         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1754         struct lpfc_hba   *phba = vport->phba;
1755         /*
1756          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
1757          */
1758
1759         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
1760         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
1761         fc_host_supported_classes(shost) = FC_COS_CLASS3;
1762
1763         memset(fc_host_supported_fc4s(shost), 0,
1764                sizeof(fc_host_supported_fc4s(shost)));
1765         fc_host_supported_fc4s(shost)[2] = 1;
1766         fc_host_supported_fc4s(shost)[7] = 1;
1767
1768         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
1769                                  sizeof fc_host_symbolic_name(shost));
1770
1771         fc_host_supported_speeds(shost) = 0;
1772         if (phba->lmt & LMT_10Gb)
1773                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
1774         if (phba->lmt & LMT_4Gb)
1775                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
1776         if (phba->lmt & LMT_2Gb)
1777                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
1778         if (phba->lmt & LMT_1Gb)
1779                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
1780
1781         fc_host_maxframe_size(shost) =
1782                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
1783                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
1784
1785         /* This value is also unchanging */
1786         memset(fc_host_active_fc4s(shost), 0,
1787                sizeof(fc_host_active_fc4s(shost)));
1788         fc_host_active_fc4s(shost)[2] = 1;
1789         fc_host_active_fc4s(shost)[7] = 1;
1790
1791         fc_host_max_npiv_vports(shost) = phba->max_vpi;
1792         spin_lock_irq(shost->host_lock);
1793         vport->load_flag &= ~FC_LOADING;
1794         spin_unlock_irq(shost->host_lock);
1795 }
1796
1797 static int __devinit
1798 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
1799 {
1800         struct lpfc_vport *vport = NULL;
1801         struct lpfc_hba   *phba;
1802         struct lpfc_sli   *psli;
1803         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
1804         struct Scsi_Host  *shost = NULL;
1805         void *ptr;
1806         unsigned long bar0map_len, bar2map_len;
1807         int error = -ENODEV, retval;
1808         int  i, hbq_count;
1809         uint16_t iotag;
1810
1811         if (pci_enable_device(pdev))
1812                 goto out;
1813         if (pci_request_regions(pdev, LPFC_DRIVER_NAME))
1814                 goto out_disable_device;
1815
1816         phba = kzalloc(sizeof (struct lpfc_hba), GFP_KERNEL);
1817         if (!phba)
1818                 goto out_release_regions;
1819
1820         spin_lock_init(&phba->hbalock);
1821
1822         phba->pcidev = pdev;
1823
1824         /* Assign an unused board number */
1825         if ((phba->brd_no = lpfc_get_instance()) < 0)
1826                 goto out_free_phba;
1827
1828         INIT_LIST_HEAD(&phba->port_list);
1829         /*
1830          * Get all the module params for configuring this host and then
1831          * establish the host.
1832          */
1833         lpfc_get_cfgparam(phba);
1834         phba->max_vpi = LPFC_MAX_VPI;
1835
1836         /* Initialize timers used by driver */
1837         init_timer(&phba->fc_estabtmo);
1838         phba->fc_estabtmo.function = lpfc_establish_link_tmo;
1839         phba->fc_estabtmo.data = (unsigned long)phba;
1840
1841         init_timer(&phba->hb_tmofunc);
1842         phba->hb_tmofunc.function = lpfc_hb_timeout;
1843         phba->hb_tmofunc.data = (unsigned long)phba;
1844
1845         psli = &phba->sli;
1846         init_timer(&psli->mbox_tmo);
1847         psli->mbox_tmo.function = lpfc_mbox_timeout;
1848         psli->mbox_tmo.data = (unsigned long) phba;
1849         init_timer(&phba->fcp_poll_timer);
1850         phba->fcp_poll_timer.function = lpfc_poll_timeout;
1851         phba->fcp_poll_timer.data = (unsigned long) phba;
1852         init_timer(&phba->fabric_block_timer);
1853         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
1854         phba->fabric_block_timer.data = (unsigned long) phba;
1855
1856         pci_set_master(pdev);
1857         pci_try_set_mwi(pdev);
1858
1859         if (pci_set_dma_mask(phba->pcidev, DMA_64BIT_MASK) != 0)
1860                 if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
1861                         goto out_idr_remove;
1862
1863         /*
1864          * Get the bus address of Bar0 and Bar2 and the number of bytes
1865          * required by each mapping.
1866          */
1867         phba->pci_bar0_map = pci_resource_start(phba->pcidev, 0);
1868         bar0map_len        = pci_resource_len(phba->pcidev, 0);
1869
1870         phba->pci_bar2_map = pci_resource_start(phba->pcidev, 2);
1871         bar2map_len        = pci_resource_len(phba->pcidev, 2);
1872
1873         /* Map HBA SLIM to a kernel virtual address. */
1874         phba->slim_memmap_p      = ioremap(phba->pci_bar0_map, bar0map_len);
1875         if (!phba->slim_memmap_p) {
1876                 error = -ENODEV;
1877                 dev_printk(KERN_ERR, &pdev->dev,
1878                            "ioremap failed for SLIM memory.\n");
1879                 goto out_idr_remove;
1880         }
1881
1882         /* Map HBA Control Registers to a kernel virtual address. */
1883         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
1884         if (!phba->ctrl_regs_memmap_p) {
1885                 error = -ENODEV;
1886                 dev_printk(KERN_ERR, &pdev->dev,
1887                            "ioremap failed for HBA control registers.\n");
1888                 goto out_iounmap_slim;
1889         }
1890
1891         /* Allocate memory for SLI-2 structures */
1892         phba->slim2p = dma_alloc_coherent(&phba->pcidev->dev, SLI2_SLIM_SIZE,
1893                                           &phba->slim2p_mapping, GFP_KERNEL);
1894         if (!phba->slim2p)
1895                 goto out_iounmap;
1896
1897         memset(phba->slim2p, 0, SLI2_SLIM_SIZE);
1898
1899         phba->hbqslimp.virt = dma_alloc_coherent(&phba->pcidev->dev,
1900                                                  lpfc_sli_hbq_size(),
1901                                                  &phba->hbqslimp.phys,
1902                                                  GFP_KERNEL);
1903         if (!phba->hbqslimp.virt)
1904                 goto out_free_slim;
1905
1906         hbq_count = lpfc_sli_hbq_count();
1907         ptr = phba->hbqslimp.virt;
1908         for (i = 0; i < hbq_count; ++i) {
1909                 phba->hbqs[i].hbq_virt = ptr;
1910                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
1911                 ptr += (lpfc_hbq_defs[i]->entry_count *
1912                         sizeof(struct lpfc_hbq_entry));
1913         }
1914         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
1915         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer  = lpfc_els_hbq_free;
1916
1917         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
1918
1919         /* Initialize the SLI Layer to run with lpfc HBAs. */
1920         lpfc_sli_setup(phba);
1921         lpfc_sli_queue_setup(phba);
1922
1923         retval = lpfc_mem_alloc(phba);
1924         if (retval) {
1925                 error = retval;
1926                 goto out_free_hbqslimp;
1927         }
1928
1929         /* Initialize and populate the iocb list per host.  */
1930         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
1931         for (i = 0; i < LPFC_IOCB_LIST_CNT; i++) {
1932                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
1933                 if (iocbq_entry == NULL) {
1934                         printk(KERN_ERR "%s: only allocated %d iocbs of "
1935                                 "expected %d count. Unloading driver.\n",
1936                                 __FUNCTION__, i, LPFC_IOCB_LIST_CNT);
1937                         error = -ENOMEM;
1938                         goto out_free_iocbq;
1939                 }
1940
1941                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
1942                 if (iotag == 0) {
1943                         kfree (iocbq_entry);
1944                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
1945                                "Unloading driver.\n",
1946                                 __FUNCTION__);
1947                         error = -ENOMEM;
1948                         goto out_free_iocbq;
1949                 }
1950
1951                 spin_lock_irq(&phba->hbalock);
1952                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
1953                 phba->total_iocbq_bufs++;
1954                 spin_unlock_irq(&phba->hbalock);
1955         }
1956
1957         /* Initialize HBA structure */
1958         phba->fc_edtov = FF_DEF_EDTOV;
1959         phba->fc_ratov = FF_DEF_RATOV;
1960         phba->fc_altov = FF_DEF_ALTOV;
1961         phba->fc_arbtov = FF_DEF_ARBTOV;
1962
1963         INIT_LIST_HEAD(&phba->work_list);
1964         phba->work_ha_mask = (HA_ERATT|HA_MBATT|HA_LATT);
1965         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
1966
1967         /* Startup the kernel thread for this host adapter. */
1968         phba->worker_thread = kthread_run(lpfc_do_work, phba,
1969                                        "lpfc_worker_%d", phba->brd_no);
1970         if (IS_ERR(phba->worker_thread)) {
1971                 error = PTR_ERR(phba->worker_thread);
1972                 goto out_free_iocbq;
1973         }
1974
1975         /* Initialize the list of scsi buffers used by driver for scsi IO. */
1976         spin_lock_init(&phba->scsi_buf_list_lock);
1977         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
1978
1979         /* Initialize list of fabric iocbs */
1980         INIT_LIST_HEAD(&phba->fabric_iocb_list);
1981
1982         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
1983         if (!vport)
1984                 goto out_kthread_stop;
1985
1986         shost = lpfc_shost_from_vport(vport);
1987         phba->pport = vport;
1988         lpfc_debugfs_initialize(vport);
1989
1990         pci_set_drvdata(pdev, shost);
1991
1992         if (phba->cfg_use_msi) {
1993                 retval = pci_enable_msi(phba->pcidev);
1994                 if (!retval)
1995                         phba->using_msi = 1;
1996                 else
1997                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1998                                         "0452 Enable MSI failed, continuing "
1999                                         "with IRQ\n");
2000         }
2001
2002         retval = request_irq(phba->pcidev->irq, lpfc_intr_handler, IRQF_SHARED,
2003                             LPFC_DRIVER_NAME, phba);
2004         if (retval) {
2005                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2006                         "0451 Enable interrupt handler failed\n");
2007                 error = retval;
2008                 goto out_disable_msi;
2009         }
2010
2011         phba->MBslimaddr = phba->slim_memmap_p;
2012         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
2013         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
2014         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
2015         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
2016
2017         if (lpfc_alloc_sysfs_attr(vport)) {
2018                 error = -ENOMEM;
2019                 goto out_free_irq;
2020         }
2021
2022         if (lpfc_sli_hba_setup(phba)) {
2023                 error = -ENODEV;
2024                 goto out_remove_device;
2025         }
2026
2027         /*
2028          * hba setup may have changed the hba_queue_depth so we need to adjust
2029          * the value of can_queue.
2030          */
2031         shost->can_queue = phba->cfg_hba_queue_depth - 10;
2032
2033         lpfc_host_attrib_init(shost);
2034
2035         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2036                 spin_lock_irq(shost->host_lock);
2037                 lpfc_poll_start_timer(phba);
2038                 spin_unlock_irq(shost->host_lock);
2039         }
2040
2041         scsi_scan_host(shost);
2042
2043         return 0;
2044
2045 out_remove_device:
2046         lpfc_free_sysfs_attr(vport);
2047         spin_lock_irq(shost->host_lock);
2048         vport->load_flag |= FC_UNLOADING;
2049         spin_unlock_irq(shost->host_lock);
2050 out_free_irq:
2051         lpfc_stop_phba_timers(phba);
2052         phba->pport->work_port_events = 0;
2053         free_irq(phba->pcidev->irq, phba);
2054 out_disable_msi:
2055         if (phba->using_msi)
2056                 pci_disable_msi(phba->pcidev);
2057         destroy_port(vport);
2058 out_kthread_stop:
2059         kthread_stop(phba->worker_thread);
2060 out_free_iocbq:
2061         list_for_each_entry_safe(iocbq_entry, iocbq_next,
2062                                                 &phba->lpfc_iocb_list, list) {
2063                 kfree(iocbq_entry);
2064                 phba->total_iocbq_bufs--;
2065         }
2066         lpfc_mem_free(phba);
2067 out_free_hbqslimp:
2068         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(), phba->hbqslimp.virt,
2069                           phba->hbqslimp.phys);
2070 out_free_slim:
2071         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE, phba->slim2p,
2072                                                         phba->slim2p_mapping);
2073 out_iounmap:
2074         iounmap(phba->ctrl_regs_memmap_p);
2075 out_iounmap_slim:
2076         iounmap(phba->slim_memmap_p);
2077 out_idr_remove:
2078         idr_remove(&lpfc_hba_index, phba->brd_no);
2079 out_free_phba:
2080         kfree(phba);
2081 out_release_regions:
2082         pci_release_regions(pdev);
2083 out_disable_device:
2084         pci_disable_device(pdev);
2085 out:
2086         pci_set_drvdata(pdev, NULL);
2087         if (shost)
2088                 scsi_host_put(shost);
2089         return error;
2090 }
2091
2092 static void __devexit
2093 lpfc_pci_remove_one(struct pci_dev *pdev)
2094 {
2095         struct Scsi_Host  *shost = pci_get_drvdata(pdev);
2096         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2097         struct lpfc_hba   *phba = vport->phba;
2098         spin_lock_irq(&phba->hbalock);
2099         vport->load_flag |= FC_UNLOADING;
2100         spin_unlock_irq(&phba->hbalock);
2101
2102         kfree(vport->vname);
2103         lpfc_free_sysfs_attr(vport);
2104
2105         fc_remove_host(shost);
2106         scsi_remove_host(shost);
2107         lpfc_cleanup(vport);
2108
2109         /*
2110          * Bring down the SLI Layer. This step disable all interrupts,
2111          * clears the rings, discards all mailbox commands, and resets
2112          * the HBA.
2113          */
2114         lpfc_sli_hba_down(phba);
2115         lpfc_sli_brdrestart(phba);
2116
2117         lpfc_stop_phba_timers(phba);
2118         spin_lock_irq(&phba->hbalock);
2119         list_del_init(&vport->listentry);
2120         spin_unlock_irq(&phba->hbalock);
2121
2122         lpfc_debugfs_terminate(vport);
2123
2124         kthread_stop(phba->worker_thread);
2125
2126         /* Release the irq reservation */
2127         free_irq(phba->pcidev->irq, phba);
2128         if (phba->using_msi)
2129                 pci_disable_msi(phba->pcidev);
2130
2131         pci_set_drvdata(pdev, NULL);
2132         scsi_host_put(shost);
2133
2134         /*
2135          * Call scsi_free before mem_free since scsi bufs are released to their
2136          * corresponding pools here.
2137          */
2138         lpfc_scsi_free(phba);
2139         lpfc_mem_free(phba);
2140
2141         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(), phba->hbqslimp.virt,
2142                           phba->hbqslimp.phys);
2143
2144         /* Free resources associated with SLI2 interface */
2145         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
2146                           phba->slim2p, phba->slim2p_mapping);
2147
2148         /* unmap adapter SLIM and Control Registers */
2149         iounmap(phba->ctrl_regs_memmap_p);
2150         iounmap(phba->slim_memmap_p);
2151
2152         idr_remove(&lpfc_hba_index, phba->brd_no);
2153
2154         kfree(phba);
2155
2156         pci_release_regions(pdev);
2157         pci_disable_device(pdev);
2158 }
2159
2160 /**
2161  * lpfc_io_error_detected - called when PCI error is detected
2162  * @pdev: Pointer to PCI device
2163  * @state: The current pci conneection state
2164  *
2165  * This function is called after a PCI bus error affecting
2166  * this device has been detected.
2167  */
2168 static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev,
2169                                 pci_channel_state_t state)
2170 {
2171         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2172         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2173         struct lpfc_sli *psli = &phba->sli;
2174         struct lpfc_sli_ring  *pring;
2175
2176         if (state == pci_channel_io_perm_failure)
2177                 return PCI_ERS_RESULT_DISCONNECT;
2178
2179         pci_disable_device(pdev);
2180         /*
2181          * There may be I/Os dropped by the firmware.
2182          * Error iocb (I/O) on txcmplq and let the SCSI layer
2183          * retry it after re-establishing link.
2184          */
2185         pring = &psli->ring[psli->fcp_ring];
2186         lpfc_sli_abort_iocb_ring(phba, pring);
2187
2188         /* Release the irq reservation */
2189         free_irq(phba->pcidev->irq, phba);
2190         if (phba->using_msi)
2191                 pci_disable_msi(phba->pcidev);
2192
2193         /* Request a slot reset. */
2194         return PCI_ERS_RESULT_NEED_RESET;
2195 }
2196
2197 /**
2198  * lpfc_io_slot_reset - called after the pci bus has been reset.
2199  * @pdev: Pointer to PCI device
2200  *
2201  * Restart the card from scratch, as if from a cold-boot.
2202  */
2203 static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
2204 {
2205         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2206         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2207         struct lpfc_sli *psli = &phba->sli;
2208         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2209
2210         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
2211         if (pci_enable_device_bars(pdev, bars)) {
2212                 printk(KERN_ERR "lpfc: Cannot re-enable "
2213                         "PCI device after reset.\n");
2214                 return PCI_ERS_RESULT_DISCONNECT;
2215         }
2216
2217         pci_set_master(pdev);
2218
2219         /* Re-establishing Link */
2220         spin_lock_irq(shost->host_lock);
2221         phba->pport->fc_flag |= FC_ESTABLISH_LINK;
2222         spin_unlock_irq(shost->host_lock);
2223
2224         spin_lock_irq(&phba->hbalock);
2225         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2226         spin_unlock_irq(&phba->hbalock);
2227
2228
2229         /* Take device offline; this will perform cleanup */
2230         lpfc_offline(phba);
2231         lpfc_sli_brdrestart(phba);
2232
2233         return PCI_ERS_RESULT_RECOVERED;
2234 }
2235
2236 /**
2237  * lpfc_io_resume - called when traffic can start flowing again.
2238  * @pdev: Pointer to PCI device
2239  *
2240  * This callback is called when the error recovery driver tells us that
2241  * its OK to resume normal operation.
2242  */
2243 static void lpfc_io_resume(struct pci_dev *pdev)
2244 {
2245         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2246         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2247
2248         if (lpfc_online(phba) == 0) {
2249                 mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
2250         }
2251 }
2252
2253 static struct pci_device_id lpfc_id_table[] = {
2254         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
2255                 PCI_ANY_ID, PCI_ANY_ID, },
2256         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY,
2257                 PCI_ANY_ID, PCI_ANY_ID, },
2258         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR,
2259                 PCI_ANY_ID, PCI_ANY_ID, },
2260         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS,
2261                 PCI_ANY_ID, PCI_ANY_ID, },
2262         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR,
2263                 PCI_ANY_ID, PCI_ANY_ID, },
2264         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY,
2265                 PCI_ANY_ID, PCI_ANY_ID, },
2266         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY,
2267                 PCI_ANY_ID, PCI_ANY_ID, },
2268         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY,
2269                 PCI_ANY_ID, PCI_ANY_ID, },
2270         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY,
2271                 PCI_ANY_ID, PCI_ANY_ID, },
2272         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE,
2273                 PCI_ANY_ID, PCI_ANY_ID, },
2274         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP,
2275                 PCI_ANY_ID, PCI_ANY_ID, },
2276         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP,
2277                 PCI_ANY_ID, PCI_ANY_ID, },
2278         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS,
2279                 PCI_ANY_ID, PCI_ANY_ID, },
2280         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP,
2281                 PCI_ANY_ID, PCI_ANY_ID, },
2282         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP,
2283                 PCI_ANY_ID, PCI_ANY_ID, },
2284         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID,
2285                 PCI_ANY_ID, PCI_ANY_ID, },
2286         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB,
2287                 PCI_ANY_ID, PCI_ANY_ID, },
2288         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR,
2289                 PCI_ANY_ID, PCI_ANY_ID, },
2290         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP,
2291                 PCI_ANY_ID, PCI_ANY_ID, },
2292         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP,
2293                 PCI_ANY_ID, PCI_ANY_ID, },
2294         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID,
2295                 PCI_ANY_ID, PCI_ANY_ID, },
2296         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB,
2297                 PCI_ANY_ID, PCI_ANY_ID, },
2298         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY,
2299                 PCI_ANY_ID, PCI_ANY_ID, },
2300         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101,
2301                 PCI_ANY_ID, PCI_ANY_ID, },
2302         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S,
2303                 PCI_ANY_ID, PCI_ANY_ID, },
2304         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S,
2305                 PCI_ANY_ID, PCI_ANY_ID, },
2306         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
2307                 PCI_ANY_ID, PCI_ANY_ID, },
2308         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
2309                 PCI_ANY_ID, PCI_ANY_ID, },
2310         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
2311                 PCI_ANY_ID, PCI_ANY_ID, },
2312         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
2313                 PCI_ANY_ID, PCI_ANY_ID, },
2314         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
2315                 PCI_ANY_ID, PCI_ANY_ID, },
2316         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
2317                 PCI_ANY_ID, PCI_ANY_ID, },
2318         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
2319                 PCI_ANY_ID, PCI_ANY_ID, },
2320         { 0 }
2321 };
2322
2323 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
2324
2325 static struct pci_error_handlers lpfc_err_handler = {
2326         .error_detected = lpfc_io_error_detected,
2327         .slot_reset = lpfc_io_slot_reset,
2328         .resume = lpfc_io_resume,
2329 };
2330
2331 static struct pci_driver lpfc_driver = {
2332         .name           = LPFC_DRIVER_NAME,
2333         .id_table       = lpfc_id_table,
2334         .probe          = lpfc_pci_probe_one,
2335         .remove         = __devexit_p(lpfc_pci_remove_one),
2336         .err_handler    = &lpfc_err_handler,
2337 };
2338
2339 static int __init
2340 lpfc_init(void)
2341 {
2342         int error = 0;
2343
2344         printk(LPFC_MODULE_DESC "\n");
2345         printk(LPFC_COPYRIGHT "\n");
2346
2347         if (lpfc_enable_npiv) {
2348                 lpfc_transport_functions.vport_create = lpfc_vport_create;
2349                 lpfc_transport_functions.vport_delete = lpfc_vport_delete;
2350         }
2351         lpfc_transport_template =
2352                                 fc_attach_transport(&lpfc_transport_functions);
2353         if (lpfc_transport_template == NULL)
2354                 return -ENOMEM;
2355         if (lpfc_enable_npiv) {
2356                 lpfc_vport_transport_template =
2357                         fc_attach_transport(&lpfc_vport_transport_functions);
2358                 if (lpfc_vport_transport_template == NULL) {
2359                         fc_release_transport(lpfc_transport_template);
2360                         return -ENOMEM;
2361                 }
2362         }
2363         error = pci_register_driver(&lpfc_driver);
2364         if (error) {
2365                 fc_release_transport(lpfc_transport_template);
2366                 fc_release_transport(lpfc_vport_transport_template);
2367         }
2368
2369         return error;
2370 }
2371
2372 static void __exit
2373 lpfc_exit(void)
2374 {
2375         pci_unregister_driver(&lpfc_driver);
2376         fc_release_transport(lpfc_transport_template);
2377         if (lpfc_enable_npiv)
2378                 fc_release_transport(lpfc_vport_transport_template);
2379 }
2380
2381 module_init(lpfc_init);
2382 module_exit(lpfc_exit);
2383 MODULE_LICENSE("GPL");
2384 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
2385 MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com");
2386 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);