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