Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/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-2016 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/module.h>
 28 #include <linux/kthread.h>
 29 #include <linux/pci.h>
 30 #include <linux/spinlock.h>
 31 #include <linux/ctype.h>
 32 #include <linux/aer.h>
 33 #include <linux/slab.h>
 34 #include <linux/firmware.h>
 35 #include <linux/miscdevice.h>
 36 #include <linux/percpu.h>
 37 
 38 #include <scsi/scsi.h>
 39 #include <scsi/scsi_device.h>
 40 #include <scsi/scsi_host.h>
 41 #include <scsi/scsi_transport_fc.h>
 42 
 43 #include "lpfc_hw4.h"
 44 #include "lpfc_hw.h"
 45 #include "lpfc_sli.h"
 46 #include "lpfc_sli4.h"
 47 #include "lpfc_nl.h"
 48 #include "lpfc_disc.h"
 49 #include "lpfc_scsi.h"
 50 #include "lpfc.h"
 51 #include "lpfc_logmsg.h"
 52 #include "lpfc_crtn.h"
 53 #include "lpfc_vport.h"
 54 #include "lpfc_version.h"
 55 
 56 char *_dump_buf_data;
 57 unsigned long _dump_buf_data_order;
 58 char *_dump_buf_dif;
 59 unsigned long _dump_buf_dif_order;
 60 spinlock_t _dump_buf_lock;
 61 
 62 /* Used when mapping IRQ vectors in a driver centric manner */
 63 uint16_t *lpfc_used_cpu;
 64 uint32_t lpfc_present_cpu;
 65 
 66 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
 67 static int lpfc_post_rcv_buf(struct lpfc_hba *);
 68 static int lpfc_sli4_queue_verify(struct lpfc_hba *);
 69 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
 70 static int lpfc_setup_endian_order(struct lpfc_hba *);
 71 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
 72 static void lpfc_free_els_sgl_list(struct lpfc_hba *);
 73 static void lpfc_init_sgl_list(struct lpfc_hba *);
 74 static int lpfc_init_active_sgl_array(struct lpfc_hba *);
 75 static void lpfc_free_active_sgl(struct lpfc_hba *);
 76 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
 77 static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
 78 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
 79 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
 80 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
 81 static void lpfc_sli4_disable_intr(struct lpfc_hba *);
 82 static uint32_t lpfc_sli4_enable_intr(struct lpfc_hba *, uint32_t);
 83 static void lpfc_sli4_oas_verify(struct lpfc_hba *phba);
 84 
 85 static struct scsi_transport_template *lpfc_transport_template = NULL;
 86 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
 87 static DEFINE_IDR(lpfc_hba_index);
 88 
 89 /**
 90  * lpfc_config_port_prep - Perform lpfc initialization prior to config port
 91  * @phba: pointer to lpfc hba data structure.
 92  *
 93  * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
 94  * mailbox command. It retrieves the revision information from the HBA and
 95  * collects the Vital Product Data (VPD) about the HBA for preparing the
 96  * configuration of the HBA.
 97  *
 98  * Return codes:
 99  *   0 - success.
100  *   -ERESTART - requests the SLI layer to reset the HBA and try again.
101  *   Any other value - indicates an error.
102  **/
103 int
104 lpfc_config_port_prep(struct lpfc_hba *phba)
105 {
106         lpfc_vpd_t *vp = &phba->vpd;
107         int i = 0, rc;
108         LPFC_MBOXQ_t *pmb;
109         MAILBOX_t *mb;
110         char *lpfc_vpd_data = NULL;
111         uint16_t offset = 0;
112         static char licensed[56] =
113                     "key unlock for use with gnu public licensed code only\0";
114         static int init_key = 1;
115 
116         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
117         if (!pmb) {
118                 phba->link_state = LPFC_HBA_ERROR;
119                 return -ENOMEM;
120         }
121 
122         mb = &pmb->u.mb;
123         phba->link_state = LPFC_INIT_MBX_CMDS;
124 
125         if (lpfc_is_LC_HBA(phba->pcidev->device)) {
126                 if (init_key) {
127                         uint32_t *ptext = (uint32_t *) licensed;
128 
129                         for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
130                                 *ptext = cpu_to_be32(*ptext);
131                         init_key = 0;
132                 }
133 
134                 lpfc_read_nv(phba, pmb);
135                 memset((char*)mb->un.varRDnvp.rsvd3, 0,
136                         sizeof (mb->un.varRDnvp.rsvd3));
137                 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
138                          sizeof (licensed));
139 
140                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
141 
142                 if (rc != MBX_SUCCESS) {
143                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
144                                         "0324 Config Port initialization "
145                                         "error, mbxCmd x%x READ_NVPARM, "
146                                         "mbxStatus x%x\n",
147                                         mb->mbxCommand, mb->mbxStatus);
148                         mempool_free(pmb, phba->mbox_mem_pool);
149                         return -ERESTART;
150                 }
151                 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
152                        sizeof(phba->wwnn));
153                 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
154                        sizeof(phba->wwpn));
155         }
156 
157         phba->sli3_options = 0x0;
158 
159         /* Setup and issue mailbox READ REV command */
160         lpfc_read_rev(phba, pmb);
161         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
162         if (rc != MBX_SUCCESS) {
163                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
164                                 "0439 Adapter failed to init, mbxCmd x%x "
165                                 "READ_REV, mbxStatus x%x\n",
166                                 mb->mbxCommand, mb->mbxStatus);
167                 mempool_free( pmb, phba->mbox_mem_pool);
168                 return -ERESTART;
169         }
170 
171 
172         /*
173          * The value of rr must be 1 since the driver set the cv field to 1.
174          * This setting requires the FW to set all revision fields.
175          */
176         if (mb->un.varRdRev.rr == 0) {
177                 vp->rev.rBit = 0;
178                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
179                                 "0440 Adapter failed to init, READ_REV has "
180                                 "missing revision information.\n");
181                 mempool_free(pmb, phba->mbox_mem_pool);
182                 return -ERESTART;
183         }
184 
185         if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
186                 mempool_free(pmb, phba->mbox_mem_pool);
187                 return -EINVAL;
188         }
189 
190         /* Save information as VPD data */
191         vp->rev.rBit = 1;
192         memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
193         vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
194         memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
195         vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
196         memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
197         vp->rev.biuRev = mb->un.varRdRev.biuRev;
198         vp->rev.smRev = mb->un.varRdRev.smRev;
199         vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
200         vp->rev.endecRev = mb->un.varRdRev.endecRev;
201         vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
202         vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
203         vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
204         vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
205         vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
206         vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
207 
208         /* If the sli feature level is less then 9, we must
209          * tear down all RPIs and VPIs on link down if NPIV
210          * is enabled.
211          */
212         if (vp->rev.feaLevelHigh < 9)
213                 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
214 
215         if (lpfc_is_LC_HBA(phba->pcidev->device))
216                 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
217                                                 sizeof (phba->RandomData));
218 
219         /* Get adapter VPD information */
220         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
221         if (!lpfc_vpd_data)
222                 goto out_free_mbox;
223         do {
224                 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
225                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
226 
227                 if (rc != MBX_SUCCESS) {
228                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
229                                         "0441 VPD not present on adapter, "
230                                         "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
231                                         mb->mbxCommand, mb->mbxStatus);
232                         mb->un.varDmp.word_cnt = 0;
233                 }
234                 /* dump mem may return a zero when finished or we got a
235                  * mailbox error, either way we are done.
236                  */
237                 if (mb->un.varDmp.word_cnt == 0)
238                         break;
239                 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
240                         mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
241                 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
242                                       lpfc_vpd_data + offset,
243                                       mb->un.varDmp.word_cnt);
244                 offset += mb->un.varDmp.word_cnt;
245         } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
246         lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
247 
248         kfree(lpfc_vpd_data);
249 out_free_mbox:
250         mempool_free(pmb, phba->mbox_mem_pool);
251         return 0;
252 }
253 
254 /**
255  * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
256  * @phba: pointer to lpfc hba data structure.
257  * @pmboxq: pointer to the driver internal queue element for mailbox command.
258  *
259  * This is the completion handler for driver's configuring asynchronous event
260  * mailbox command to the device. If the mailbox command returns successfully,
261  * it will set internal async event support flag to 1; otherwise, it will
262  * set internal async event support flag to 0.
263  **/
264 static void
265 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
266 {
267         if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS)
268                 phba->temp_sensor_support = 1;
269         else
270                 phba->temp_sensor_support = 0;
271         mempool_free(pmboxq, phba->mbox_mem_pool);
272         return;
273 }
274 
275 /**
276  * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
277  * @phba: pointer to lpfc hba data structure.
278  * @pmboxq: pointer to the driver internal queue element for mailbox command.
279  *
280  * This is the completion handler for dump mailbox command for getting
281  * wake up parameters. When this command complete, the response contain
282  * Option rom version of the HBA. This function translate the version number
283  * into a human readable string and store it in OptionROMVersion.
284  **/
285 static void
286 lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
287 {
288         struct prog_id *prg;
289         uint32_t prog_id_word;
290         char dist = ' ';
291         /* character array used for decoding dist type. */
292         char dist_char[] = "nabx";
293 
294         if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) {
295                 mempool_free(pmboxq, phba->mbox_mem_pool);
296                 return;
297         }
298 
299         prg = (struct prog_id *) &prog_id_word;
300 
301         /* word 7 contain option rom version */
302         prog_id_word = pmboxq->u.mb.un.varWords[7];
303 
304         /* Decode the Option rom version word to a readable string */
305         if (prg->dist < 4)
306                 dist = dist_char[prg->dist];
307 
308         if ((prg->dist == 3) && (prg->num == 0))
309                 snprintf(phba->OptionROMVersion, 32, "%d.%d%d",
310                         prg->ver, prg->rev, prg->lev);
311         else
312                 snprintf(phba->OptionROMVersion, 32, "%d.%d%d%c%d",
313                         prg->ver, prg->rev, prg->lev,
314                         dist, prg->num);
315         mempool_free(pmboxq, phba->mbox_mem_pool);
316         return;
317 }
318 
319 /**
320  * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname,
321  *      cfg_soft_wwnn, cfg_soft_wwpn
322  * @vport: pointer to lpfc vport data structure.
323  *
324  *
325  * Return codes
326  *   None.
327  **/
328 void
329 lpfc_update_vport_wwn(struct lpfc_vport *vport)
330 {
331         /* If the soft name exists then update it using the service params */
332         if (vport->phba->cfg_soft_wwnn)
333                 u64_to_wwn(vport->phba->cfg_soft_wwnn,
334                            vport->fc_sparam.nodeName.u.wwn);
335         if (vport->phba->cfg_soft_wwpn)
336                 u64_to_wwn(vport->phba->cfg_soft_wwpn,
337                            vport->fc_sparam.portName.u.wwn);
338 
339         /*
340          * If the name is empty or there exists a soft name
341          * then copy the service params name, otherwise use the fc name
342          */
343         if (vport->fc_nodename.u.wwn[0] == 0 || vport->phba->cfg_soft_wwnn)
344                 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
345                         sizeof(struct lpfc_name));
346         else
347                 memcpy(&vport->fc_sparam.nodeName, &vport->fc_nodename,
348                         sizeof(struct lpfc_name));
349 
350         if (vport->fc_portname.u.wwn[0] == 0 || vport->phba->cfg_soft_wwpn)
351                 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
352                         sizeof(struct lpfc_name));
353         else
354                 memcpy(&vport->fc_sparam.portName, &vport->fc_portname,
355                         sizeof(struct lpfc_name));
356 }
357 
358 /**
359  * lpfc_config_port_post - Perform lpfc initialization after config port
360  * @phba: pointer to lpfc hba data structure.
361  *
362  * This routine will do LPFC initialization after the CONFIG_PORT mailbox
363  * command call. It performs all internal resource and state setups on the
364  * port: post IOCB buffers, enable appropriate host interrupt attentions,
365  * ELS ring timers, etc.
366  *
367  * Return codes
368  *   0 - success.
369  *   Any other value - error.
370  **/
371 int
372 lpfc_config_port_post(struct lpfc_hba *phba)
373 {
374         struct lpfc_vport *vport = phba->pport;
375         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
376         LPFC_MBOXQ_t *pmb;
377         MAILBOX_t *mb;
378         struct lpfc_dmabuf *mp;
379         struct lpfc_sli *psli = &phba->sli;
380         uint32_t status, timeout;
381         int i, j;
382         int rc;
383 
384         spin_lock_irq(&phba->hbalock);
385         /*
386          * If the Config port completed correctly the HBA is not
387          * over heated any more.
388          */
389         if (phba->over_temp_state == HBA_OVER_TEMP)
390                 phba->over_temp_state = HBA_NORMAL_TEMP;
391         spin_unlock_irq(&phba->hbalock);
392 
393         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
394         if (!pmb) {
395                 phba->link_state = LPFC_HBA_ERROR;
396                 return -ENOMEM;
397         }
398         mb = &pmb->u.mb;
399 
400         /* Get login parameters for NID.  */
401         rc = lpfc_read_sparam(phba, pmb, 0);
402         if (rc) {
403                 mempool_free(pmb, phba->mbox_mem_pool);
404                 return -ENOMEM;
405         }
406 
407         pmb->vport = vport;
408         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
409                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
410                                 "0448 Adapter failed init, mbxCmd x%x "
411                                 "READ_SPARM mbxStatus x%x\n",
412                                 mb->mbxCommand, mb->mbxStatus);
413                 phba->link_state = LPFC_HBA_ERROR;
414                 mp = (struct lpfc_dmabuf *) pmb->context1;
415                 mempool_free(pmb, phba->mbox_mem_pool);
416                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
417                 kfree(mp);
418                 return -EIO;
419         }
420 
421         mp = (struct lpfc_dmabuf *) pmb->context1;
422 
423         memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
424         lpfc_mbuf_free(phba, mp->virt, mp->phys);
425         kfree(mp);
426         pmb->context1 = NULL;
427         lpfc_update_vport_wwn(vport);
428 
429         /* Update the fc_host data structures with new wwn. */
430         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
431         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
432         fc_host_max_npiv_vports(shost) = phba->max_vpi;
433 
434         /* If no serial number in VPD data, use low 6 bytes of WWNN */
435         /* This should be consolidated into parse_vpd ? - mr */
436         if (phba->SerialNumber[0] == 0) {
437                 uint8_t *outptr;
438 
439                 outptr = &vport->fc_nodename.u.s.IEEE[0];
440                 for (i = 0; i < 12; i++) {
441                         status = *outptr++;
442                         j = ((status & 0xf0) >> 4);
443                         if (j <= 9)
444                                 phba->SerialNumber[i] =
445                                     (char)((uint8_t) 0x30 + (uint8_t) j);
446                         else
447                                 phba->SerialNumber[i] =
448                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
449                         i++;
450                         j = (status & 0xf);
451                         if (j <= 9)
452                                 phba->SerialNumber[i] =
453                                     (char)((uint8_t) 0x30 + (uint8_t) j);
454                         else
455                                 phba->SerialNumber[i] =
456                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
457                 }
458         }
459 
460         lpfc_read_config(phba, pmb);
461         pmb->vport = vport;
462         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
463                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
464                                 "0453 Adapter failed to init, mbxCmd x%x "
465                                 "READ_CONFIG, mbxStatus x%x\n",
466                                 mb->mbxCommand, mb->mbxStatus);
467                 phba->link_state = LPFC_HBA_ERROR;
468                 mempool_free( pmb, phba->mbox_mem_pool);
469                 return -EIO;
470         }
471 
472         /* Check if the port is disabled */
473         lpfc_sli_read_link_ste(phba);
474 
475         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
476         i = (mb->un.varRdConfig.max_xri + 1);
477         if (phba->cfg_hba_queue_depth > i) {
478                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
479                                 "3359 HBA queue depth changed from %d to %d\n",
480                                 phba->cfg_hba_queue_depth, i);
481                 phba->cfg_hba_queue_depth = i;
482         }
483 
484         /* Reset the DFT_LUN_Q_DEPTH to (max xri >> 3)  */
485         i = (mb->un.varRdConfig.max_xri >> 3);
486         if (phba->pport->cfg_lun_queue_depth > i) {
487                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
488                                 "3360 LUN queue depth changed from %d to %d\n",
489                                 phba->pport->cfg_lun_queue_depth, i);
490                 phba->pport->cfg_lun_queue_depth = i;
491         }
492 
493         phba->lmt = mb->un.varRdConfig.lmt;
494 
495         /* Get the default values for Model Name and Description */
496         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
497 
498         phba->link_state = LPFC_LINK_DOWN;
499 
500         /* Only process IOCBs on ELS ring till hba_state is READY */
501         if (psli->ring[psli->extra_ring].sli.sli3.cmdringaddr)
502                 psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT;
503         if (psli->ring[psli->fcp_ring].sli.sli3.cmdringaddr)
504                 psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT;
505         if (psli->ring[psli->next_ring].sli.sli3.cmdringaddr)
506                 psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT;
507 
508         /* Post receive buffers for desired rings */
509         if (phba->sli_rev != 3)
510                 lpfc_post_rcv_buf(phba);
511 
512         /*
513          * Configure HBA MSI-X attention conditions to messages if MSI-X mode
514          */
515         if (phba->intr_type == MSIX) {
516                 rc = lpfc_config_msi(phba, pmb);
517                 if (rc) {
518                         mempool_free(pmb, phba->mbox_mem_pool);
519                         return -EIO;
520                 }
521                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
522                 if (rc != MBX_SUCCESS) {
523                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
524                                         "0352 Config MSI mailbox command "
525                                         "failed, mbxCmd x%x, mbxStatus x%x\n",
526                                         pmb->u.mb.mbxCommand,
527                                         pmb->u.mb.mbxStatus);
528                         mempool_free(pmb, phba->mbox_mem_pool);
529                         return -EIO;
530                 }
531         }
532 
533         spin_lock_irq(&phba->hbalock);
534         /* Initialize ERATT handling flag */
535         phba->hba_flag &= ~HBA_ERATT_HANDLED;
536 
537         /* Enable appropriate host interrupts */
538         if (lpfc_readl(phba->HCregaddr, &status)) {
539                 spin_unlock_irq(&phba->hbalock);
540                 return -EIO;
541         }
542         status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
543         if (psli->num_rings > 0)
544                 status |= HC_R0INT_ENA;
545         if (psli->num_rings > 1)
546                 status |= HC_R1INT_ENA;
547         if (psli->num_rings > 2)
548                 status |= HC_R2INT_ENA;
549         if (psli->num_rings > 3)
550                 status |= HC_R3INT_ENA;
551 
552         if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
553             (phba->cfg_poll & DISABLE_FCP_RING_INT))
554                 status &= ~(HC_R0INT_ENA);
555 
556         writel(status, phba->HCregaddr);
557         readl(phba->HCregaddr); /* flush */
558         spin_unlock_irq(&phba->hbalock);
559 
560         /* Set up ring-0 (ELS) timer */
561         timeout = phba->fc_ratov * 2;
562         mod_timer(&vport->els_tmofunc,
563                   jiffies + msecs_to_jiffies(1000 * timeout));
564         /* Set up heart beat (HB) timer */
565         mod_timer(&phba->hb_tmofunc,
566                   jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
567         phba->hb_outstanding = 0;
568         phba->last_completion_time = jiffies;
569         /* Set up error attention (ERATT) polling timer */
570         mod_timer(&phba->eratt_poll,
571                   jiffies + msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
572 
573         if (phba->hba_flag & LINK_DISABLED) {
574                 lpfc_printf_log(phba,
575                         KERN_ERR, LOG_INIT,
576                         "2598 Adapter Link is disabled.\n");
577                 lpfc_down_link(phba, pmb);
578                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
579                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
580                 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
581                         lpfc_printf_log(phba,
582                         KERN_ERR, LOG_INIT,
583                         "2599 Adapter failed to issue DOWN_LINK"
584                         " mbox command rc 0x%x\n", rc);
585 
586                         mempool_free(pmb, phba->mbox_mem_pool);
587                         return -EIO;
588                 }
589         } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
590                 mempool_free(pmb, phba->mbox_mem_pool);
591                 rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
592                 if (rc)
593                         return rc;
594         }
595         /* MBOX buffer will be freed in mbox compl */
596         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
597         if (!pmb) {
598                 phba->link_state = LPFC_HBA_ERROR;
599                 return -ENOMEM;
600         }
601 
602         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
603         pmb->mbox_cmpl = lpfc_config_async_cmpl;
604         pmb->vport = phba->pport;
605         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
606 
607         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
608                 lpfc_printf_log(phba,
609                                 KERN_ERR,
610                                 LOG_INIT,
611                                 "0456 Adapter failed to issue "
612                                 "ASYNCEVT_ENABLE mbox status x%x\n",
613                                 rc);
614                 mempool_free(pmb, phba->mbox_mem_pool);
615         }
616 
617         /* Get Option rom version */
618         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
619         if (!pmb) {
620                 phba->link_state = LPFC_HBA_ERROR;
621                 return -ENOMEM;
622         }
623 
624         lpfc_dump_wakeup_param(phba, pmb);
625         pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
626         pmb->vport = phba->pport;
627         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
628 
629         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
630                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "
631                                 "to get Option ROM version status x%x\n", rc);
632                 mempool_free(pmb, phba->mbox_mem_pool);
633         }
634 
635         return 0;
636 }
637 
638 /**
639  * lpfc_hba_init_link - Initialize the FC link
640  * @phba: pointer to lpfc hba data structure.
641  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
642  *
643  * This routine will issue the INIT_LINK mailbox command call.
644  * It is available to other drivers through the lpfc_hba data
645  * structure for use as a delayed link up mechanism with the
646  * module parameter lpfc_suppress_link_up.
647  *
648  * Return code
649  *              0 - success
650  *              Any other value - error
651  **/
652 static int
653 lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
654 {
655         return lpfc_hba_init_link_fc_topology(phba, phba->cfg_topology, flag);
656 }
657 
658 /**
659  * lpfc_hba_init_link_fc_topology - Initialize FC link with desired topology
660  * @phba: pointer to lpfc hba data structure.
661  * @fc_topology: desired fc topology.
662  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
663  *
664  * This routine will issue the INIT_LINK mailbox command call.
665  * It is available to other drivers through the lpfc_hba data
666  * structure for use as a delayed link up mechanism with the
667  * module parameter lpfc_suppress_link_up.
668  *
669  * Return code
670  *              0 - success
671  *              Any other value - error
672  **/
673 int
674 lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology,
675                                uint32_t flag)
676 {
677         struct lpfc_vport *vport = phba->pport;
678         LPFC_MBOXQ_t *pmb;
679         MAILBOX_t *mb;
680         int rc;
681 
682         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
683         if (!pmb) {
684                 phba->link_state = LPFC_HBA_ERROR;
685                 return -ENOMEM;
686         }
687         mb = &pmb->u.mb;
688         pmb->vport = vport;
689 
690         if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_MAX) ||
691             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G) &&
692              !(phba->lmt & LMT_1Gb)) ||
693             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G) &&
694              !(phba->lmt & LMT_2Gb)) ||
695             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G) &&
696              !(phba->lmt & LMT_4Gb)) ||
697             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G) &&
698              !(phba->lmt & LMT_8Gb)) ||
699             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G) &&
700              !(phba->lmt & LMT_10Gb)) ||
701             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G) &&
702              !(phba->lmt & LMT_16Gb)) ||
703             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_32G) &&
704              !(phba->lmt & LMT_32Gb))) {
705                 /* Reset link speed to auto */
706                 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
707                         "1302 Invalid speed for this board:%d "
708                         "Reset link speed to auto.\n",
709                         phba->cfg_link_speed);
710                         phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
711         }
712         lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed);
713         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
714         if (phba->sli_rev < LPFC_SLI_REV4)
715                 lpfc_set_loopback_flag(phba);
716         rc = lpfc_sli_issue_mbox(phba, pmb, flag);
717         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
718                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
719                         "0498 Adapter failed to init, mbxCmd x%x "
720                         "INIT_LINK, mbxStatus x%x\n",
721                         mb->mbxCommand, mb->mbxStatus);
722                 if (phba->sli_rev <= LPFC_SLI_REV3) {
723                         /* Clear all interrupt enable conditions */
724                         writel(0, phba->HCregaddr);
725                         readl(phba->HCregaddr); /* flush */
726                         /* Clear all pending interrupts */
727                         writel(0xffffffff, phba->HAregaddr);
728                         readl(phba->HAregaddr); /* flush */
729                 }
730                 phba->link_state = LPFC_HBA_ERROR;
731                 if (rc != MBX_BUSY || flag == MBX_POLL)
732                         mempool_free(pmb, phba->mbox_mem_pool);
733                 return -EIO;
734         }
735         phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK;
736         if (flag == MBX_POLL)
737                 mempool_free(pmb, phba->mbox_mem_pool);
738 
739         return 0;
740 }
741 
742 /**
743  * lpfc_hba_down_link - this routine downs the FC link
744  * @phba: pointer to lpfc hba data structure.
745  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
746  *
747  * This routine will issue the DOWN_LINK mailbox command call.
748  * It is available to other drivers through the lpfc_hba data
749  * structure for use to stop the link.
750  *
751  * Return code
752  *              0 - success
753  *              Any other value - error
754  **/
755 static int
756 lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag)
757 {
758         LPFC_MBOXQ_t *pmb;
759         int rc;
760 
761         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
762         if (!pmb) {
763                 phba->link_state = LPFC_HBA_ERROR;
764                 return -ENOMEM;
765         }
766 
767         lpfc_printf_log(phba,
768                 KERN_ERR, LOG_INIT,
769                 "0491 Adapter Link is disabled.\n");
770         lpfc_down_link(phba, pmb);
771         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
772         rc = lpfc_sli_issue_mbox(phba, pmb, flag);
773         if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
774                 lpfc_printf_log(phba,
775                 KERN_ERR, LOG_INIT,
776                 "2522 Adapter failed to issue DOWN_LINK"
777                 " mbox command rc 0x%x\n", rc);
778 
779                 mempool_free(pmb, phba->mbox_mem_pool);
780                 return -EIO;
781         }
782         if (flag == MBX_POLL)
783                 mempool_free(pmb, phba->mbox_mem_pool);
784 
785         return 0;
786 }
787 
788 /**
789  * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
790  * @phba: pointer to lpfc HBA data structure.
791  *
792  * This routine will do LPFC uninitialization before the HBA is reset when
793  * bringing down the SLI Layer.
794  *
795  * Return codes
796  *   0 - success.
797  *   Any other value - error.
798  **/
799 int
800 lpfc_hba_down_prep(struct lpfc_hba *phba)
801 {
802         struct lpfc_vport **vports;
803         int i;
804 
805         if (phba->sli_rev <= LPFC_SLI_REV3) {
806                 /* Disable interrupts */
807                 writel(0, phba->HCregaddr);
808                 readl(phba->HCregaddr); /* flush */
809         }
810 
811         if (phba->pport->load_flag & FC_UNLOADING)
812                 lpfc_cleanup_discovery_resources(phba->pport);
813         else {
814                 vports = lpfc_create_vport_work_array(phba);
815                 if (vports != NULL)
816                         for (i = 0; i <= phba->max_vports &&
817                                 vports[i] != NULL; i++)
818                                 lpfc_cleanup_discovery_resources(vports[i]);
819                 lpfc_destroy_vport_work_array(phba, vports);
820         }
821         return 0;
822 }
823 
824 /**
825  * lpfc_sli4_free_sp_events - Cleanup sp_queue_events to free
826  * rspiocb which got deferred
827  *
828  * @phba: pointer to lpfc HBA data structure.
829  *
830  * This routine will cleanup completed slow path events after HBA is reset
831  * when bringing down the SLI Layer.
832  *
833  *
834  * Return codes
835  *   void.
836  **/
837 static void
838 lpfc_sli4_free_sp_events(struct lpfc_hba *phba)
839 {
840         struct lpfc_iocbq *rspiocbq;
841         struct hbq_dmabuf *dmabuf;
842         struct lpfc_cq_event *cq_event;
843 
844         spin_lock_irq(&phba->hbalock);
845         phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
846         spin_unlock_irq(&phba->hbalock);
847 
848         while (!list_empty(&phba->sli4_hba.sp_queue_event)) {
849                 /* Get the response iocb from the head of work queue */
850                 spin_lock_irq(&phba->hbalock);
851                 list_remove_head(&phba->sli4_hba.sp_queue_event,
852                                  cq_event, struct lpfc_cq_event, list);
853                 spin_unlock_irq(&phba->hbalock);
854 
855                 switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {
856                 case CQE_CODE_COMPL_WQE:
857                         rspiocbq = container_of(cq_event, struct lpfc_iocbq,
858                                                  cq_event);
859                         lpfc_sli_release_iocbq(phba, rspiocbq);
860                         break;
861                 case CQE_CODE_RECEIVE:
862                 case CQE_CODE_RECEIVE_V1:
863                         dmabuf = container_of(cq_event, struct hbq_dmabuf,
864                                               cq_event);
865                         lpfc_in_buf_free(phba, &dmabuf->dbuf);
866                 }
867         }
868 }
869 
870 /**
871  * lpfc_hba_free_post_buf - Perform lpfc uninitialization after HBA reset
872  * @phba: pointer to lpfc HBA data structure.
873  *
874  * This routine will cleanup posted ELS buffers after the HBA is reset
875  * when bringing down the SLI Layer.
876  *
877  *
878  * Return codes
879  *   void.
880  **/
881 static void
882 lpfc_hba_free_post_buf(struct lpfc_hba *phba)
883 {
884         struct lpfc_sli *psli = &phba->sli;
885         struct lpfc_sli_ring *pring;
886         struct lpfc_dmabuf *mp, *next_mp;
887         LIST_HEAD(buflist);
888         int count;
889 
890         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
891                 lpfc_sli_hbqbuf_free_all(phba);
892         else {
893                 /* Cleanup preposted buffers on the ELS ring */
894                 pring = &psli->ring[LPFC_ELS_RING];
895                 spin_lock_irq(&phba->hbalock);
896                 list_splice_init(&pring->postbufq, &buflist);
897                 spin_unlock_irq(&phba->hbalock);
898 
899                 count = 0;
900                 list_for_each_entry_safe(mp, next_mp, &buflist, list) {
901                         list_del(&mp->list);
902                         count++;
903                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
904                         kfree(mp);
905                 }
906 
907                 spin_lock_irq(&phba->hbalock);
908                 pring->postbufq_cnt -= count;
909                 spin_unlock_irq(&phba->hbalock);
910         }
911 }
912 
913 /**
914  * lpfc_hba_clean_txcmplq - Perform lpfc uninitialization after HBA reset
915  * @phba: pointer to lpfc HBA data structure.
916  *
917  * This routine will cleanup the txcmplq after the HBA is reset when bringing
918  * down the SLI Layer.
919  *
920  * Return codes
921  *   void
922  **/
923 static void
924 lpfc_hba_clean_txcmplq(struct lpfc_hba *phba)
925 {
926         struct lpfc_sli *psli = &phba->sli;
927         struct lpfc_sli_ring *pring;
928         LIST_HEAD(completions);
929         int i;
930 
931         for (i = 0; i < psli->num_rings; i++) {
932                 pring = &psli->ring[i];
933                 if (phba->sli_rev >= LPFC_SLI_REV4)
934                         spin_lock_irq(&pring->ring_lock);
935                 else
936                         spin_lock_irq(&phba->hbalock);
937                 /* At this point in time the HBA is either reset or DOA. Either
938                  * way, nothing should be on txcmplq as it will NEVER complete.
939                  */
940                 list_splice_init(&pring->txcmplq, &completions);
941                 pring->txcmplq_cnt = 0;
942 
943                 if (phba->sli_rev >= LPFC_SLI_REV4)
944                         spin_unlock_irq(&pring->ring_lock);
945                 else
946                         spin_unlock_irq(&phba->hbalock);
947 
948                 /* Cancel all the IOCBs from the completions list */
949                 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
950                                       IOERR_SLI_ABORTED);
951                 lpfc_sli_abort_iocb_ring(phba, pring);
952         }
953 }
954 
955 /**
956  * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
957         int i;
958  * @phba: pointer to lpfc HBA data structure.
959  *
960  * This routine will do uninitialization after the HBA is reset when bring
961  * down the SLI Layer.
962  *
963  * Return codes
964  *   0 - success.
965  *   Any other value - error.
966  **/
967 static int
968 lpfc_hba_down_post_s3(struct lpfc_hba *phba)
969 {
970         lpfc_hba_free_post_buf(phba);
971         lpfc_hba_clean_txcmplq(phba);
972         return 0;
973 }
974 
975 /**
976  * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
977  * @phba: pointer to lpfc HBA data structure.
978  *
979  * This routine will do uninitialization after the HBA is reset when bring
980  * down the SLI Layer.
981  *
982  * Return codes
983  *   0 - success.
984  *   Any other value - error.
985  **/
986 static int
987 lpfc_hba_down_post_s4(struct lpfc_hba *phba)
988 {
989         struct lpfc_scsi_buf *psb, *psb_next;
990         LIST_HEAD(aborts);
991         unsigned long iflag = 0;
992         struct lpfc_sglq *sglq_entry = NULL;
993         struct lpfc_sli *psli = &phba->sli;
994         struct lpfc_sli_ring *pring;
995 
996         lpfc_hba_free_post_buf(phba);
997         lpfc_hba_clean_txcmplq(phba);
998         pring = &psli->ring[LPFC_ELS_RING];
999 
1000         /* At this point in time the HBA is either reset or DOA. Either
1001          * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
1002          * on the lpfc_sgl_list so that it can either be freed if the
1003          * driver is unloading or reposted if the driver is restarting
1004          * the port.
1005          */
1006         spin_lock_irq(&phba->hbalock);  /* required for lpfc_sgl_list and */
1007                                         /* scsl_buf_list */
1008         /* abts_sgl_list_lock required because worker thread uses this
1009          * list.
1010          */
1011         spin_lock(&phba->sli4_hba.abts_sgl_list_lock);
1012         list_for_each_entry(sglq_entry,
1013                 &phba->sli4_hba.lpfc_abts_els_sgl_list, list)
1014                 sglq_entry->state = SGL_FREED;
1015 
1016         spin_lock(&pring->ring_lock);
1017         list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
1018                         &phba->sli4_hba.lpfc_sgl_list);
1019         spin_unlock(&pring->ring_lock);
1020         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
1021         /* abts_scsi_buf_list_lock required because worker thread uses this
1022          * list.
1023          */
1024         spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1025         list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list,
1026                         &aborts);
1027         spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1028         spin_unlock_irq(&phba->hbalock);
1029 
1030         list_for_each_entry_safe(psb, psb_next, &aborts, list) {
1031                 psb->pCmd = NULL;
1032                 psb->status = IOSTAT_SUCCESS;
1033         }
1034         spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
1035         list_splice(&aborts, &phba->lpfc_scsi_buf_list_put);
1036         spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
1037 
1038         lpfc_sli4_free_sp_events(phba);
1039         return 0;
1040 }
1041 
1042 /**
1043  * lpfc_hba_down_post - Wrapper func for hba down post routine
1044  * @phba: pointer to lpfc HBA data structure.
1045  *
1046  * This routine wraps the actual SLI3 or SLI4 routine for performing
1047  * uninitialization after the HBA is reset when bring down the SLI Layer.
1048  *
1049  * Return codes
1050  *   0 - success.
1051  *   Any other value - error.
1052  **/
1053 int
1054 lpfc_hba_down_post(struct lpfc_hba *phba)
1055 {
1056         return (*phba->lpfc_hba_down_post)(phba);
1057 }
1058 
1059 /**
1060  * lpfc_hb_timeout - The HBA-timer timeout handler
1061  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1062  *
1063  * This is the HBA-timer timeout handler registered to the lpfc driver. When
1064  * this timer fires, a HBA timeout event shall be posted to the lpfc driver
1065  * work-port-events bitmap and the worker thread is notified. This timeout
1066  * event will be used by the worker thread to invoke the actual timeout
1067  * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
1068  * be performed in the timeout handler and the HBA timeout event bit shall
1069  * be cleared by the worker thread after it has taken the event bitmap out.
1070  **/
1071 static void
1072 lpfc_hb_timeout(unsigned long ptr)
1073 {
1074         struct lpfc_hba *phba;
1075         uint32_t tmo_posted;
1076         unsigned long iflag;
1077 
1078         phba = (struct lpfc_hba *)ptr;
1079 
1080         /* Check for heart beat timeout conditions */
1081         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1082         tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
1083         if (!tmo_posted)
1084                 phba->pport->work_port_events |= WORKER_HB_TMO;
1085         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1086 
1087         /* Tell the worker thread there is work to do */
1088         if (!tmo_posted)
1089                 lpfc_worker_wake_up(phba);
1090         return;
1091 }
1092 
1093 /**
1094  * lpfc_rrq_timeout - The RRQ-timer timeout handler
1095  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1096  *
1097  * This is the RRQ-timer timeout handler registered to the lpfc driver. When
1098  * this timer fires, a RRQ timeout event shall be posted to the lpfc driver
1099  * work-port-events bitmap and the worker thread is notified. This timeout
1100  * event will be used by the worker thread to invoke the actual timeout
1101  * handler routine, lpfc_rrq_handler. Any periodical operations will
1102  * be performed in the timeout handler and the RRQ timeout event bit shall
1103  * be cleared by the worker thread after it has taken the event bitmap out.
1104  **/
1105 static void
1106 lpfc_rrq_timeout(unsigned long ptr)
1107 {
1108         struct lpfc_hba *phba;
1109         unsigned long iflag;
1110 
1111         phba = (struct lpfc_hba *)ptr;
1112         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1113         if (!(phba->pport->load_flag & FC_UNLOADING))
1114                 phba->hba_flag |= HBA_RRQ_ACTIVE;
1115         else
1116                 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
1117         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1118 
1119         if (!(phba->pport->load_flag & FC_UNLOADING))
1120                 lpfc_worker_wake_up(phba);
1121 }
1122 
1123 /**
1124  * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
1125  * @phba: pointer to lpfc hba data structure.
1126  * @pmboxq: pointer to the driver internal queue element for mailbox command.
1127  *
1128  * This is the callback function to the lpfc heart-beat mailbox command.
1129  * If configured, the lpfc driver issues the heart-beat mailbox command to
1130  * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
1131  * heart-beat mailbox command is issued, the driver shall set up heart-beat
1132  * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
1133  * heart-beat outstanding state. Once the mailbox command comes back and
1134  * no error conditions detected, the heart-beat mailbox command timer is
1135  * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
1136  * state is cleared for the next heart-beat. If the timer expired with the
1137  * heart-beat outstanding state set, the driver will put the HBA offline.
1138  **/
1139 static void
1140 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
1141 {
1142         unsigned long drvr_flag;
1143 
1144         spin_lock_irqsave(&phba->hbalock, drvr_flag);
1145         phba->hb_outstanding = 0;
1146         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1147 
1148         /* Check and reset heart-beat timer is necessary */
1149         mempool_free(pmboxq, phba->mbox_mem_pool);
1150         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
1151                 !(phba->link_state == LPFC_HBA_ERROR) &&
1152                 !(phba->pport->load_flag & FC_UNLOADING))
1153                 mod_timer(&phba->hb_tmofunc,
1154                           jiffies +
1155                           msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1156         return;
1157 }
1158 
1159 /**
1160  * lpfc_hb_timeout_handler - The HBA-timer timeout handler
1161  * @phba: pointer to lpfc hba data structure.
1162  *
1163  * This is the actual HBA-timer timeout handler to be invoked by the worker
1164  * thread whenever the HBA timer fired and HBA-timeout event posted. This
1165  * handler performs any periodic operations needed for the device. If such
1166  * periodic event has already been attended to either in the interrupt handler
1167  * or by processing slow-ring or fast-ring events within the HBA-timer
1168  * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
1169  * the timer for the next timeout period. If lpfc heart-beat mailbox command
1170  * is configured and there is no heart-beat mailbox command outstanding, a
1171  * heart-beat mailbox is issued and timer set properly. Otherwise, if there
1172  * has been a heart-beat mailbox command outstanding, the HBA shall be put
1173  * to offline.
1174  **/
1175 void
1176 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
1177 {
1178         struct lpfc_vport **vports;
1179         LPFC_MBOXQ_t *pmboxq;
1180         struct lpfc_dmabuf *buf_ptr;
1181         int retval, i;
1182         struct lpfc_sli *psli = &phba->sli;
1183         LIST_HEAD(completions);
1184 
1185         vports = lpfc_create_vport_work_array(phba);
1186         if (vports != NULL)
1187                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
1188                         lpfc_rcv_seq_check_edtov(vports[i]);
1189                         lpfc_fdmi_num_disc_check(vports[i]);
1190                 }
1191         lpfc_destroy_vport_work_array(phba, vports);
1192 
1193         if ((phba->link_state == LPFC_HBA_ERROR) ||
1194                 (phba->pport->load_flag & FC_UNLOADING) ||
1195                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
1196                 return;
1197 
1198         spin_lock_irq(&phba->pport->work_port_lock);
1199 
1200         if (time_after(phba->last_completion_time +
1201                         msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL),
1202                         jiffies)) {
1203                 spin_unlock_irq(&phba->pport->work_port_lock);
1204                 if (!phba->hb_outstanding)
1205                         mod_timer(&phba->hb_tmofunc,
1206                                 jiffies +
1207                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1208                 else
1209                         mod_timer(&phba->hb_tmofunc,
1210                                 jiffies +
1211                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1212                 return;
1213         }
1214         spin_unlock_irq(&phba->pport->work_port_lock);
1215 
1216         if (phba->elsbuf_cnt &&
1217                 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
1218                 spin_lock_irq(&phba->hbalock);
1219                 list_splice_init(&phba->elsbuf, &completions);
1220                 phba->elsbuf_cnt = 0;
1221                 phba->elsbuf_prev_cnt = 0;
1222                 spin_unlock_irq(&phba->hbalock);
1223 
1224                 while (!list_empty(&completions)) {
1225                         list_remove_head(&completions, buf_ptr,
1226                                 struct lpfc_dmabuf, list);
1227                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1228                         kfree(buf_ptr);
1229                 }
1230         }
1231         phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
1232 
1233         /* If there is no heart beat outstanding, issue a heartbeat command */
1234         if (phba->cfg_enable_hba_heartbeat) {
1235                 if (!phba->hb_outstanding) {
1236                         if ((!(psli->sli_flag & LPFC_SLI_MBOX_ACTIVE)) &&
1237                                 (list_empty(&psli->mboxq))) {
1238                                 pmboxq = mempool_alloc(phba->mbox_mem_pool,
1239                                                         GFP_KERNEL);
1240                                 if (!pmboxq) {
1241                                         mod_timer(&phba->hb_tmofunc,
1242                                                  jiffies +
1243                                                  msecs_to_jiffies(1000 *
1244                                                  LPFC_HB_MBOX_INTERVAL));
1245                                         return;
1246                                 }
1247 
1248                                 lpfc_heart_beat(phba, pmboxq);
1249                                 pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
1250                                 pmboxq->vport = phba->pport;
1251                                 retval = lpfc_sli_issue_mbox(phba, pmboxq,
1252                                                 MBX_NOWAIT);
1253 
1254                                 if (retval != MBX_BUSY &&
1255                                         retval != MBX_SUCCESS) {
1256                                         mempool_free(pmboxq,
1257                                                         phba->mbox_mem_pool);
1258                                         mod_timer(&phba->hb_tmofunc,
1259                                                 jiffies +
1260                                                 msecs_to_jiffies(1000 *
1261                                                 LPFC_HB_MBOX_INTERVAL));
1262                                         return;
1263                                 }
1264                                 phba->skipped_hb = 0;
1265                                 phba->hb_outstanding = 1;
1266                         } else if (time_before_eq(phba->last_completion_time,
1267                                         phba->skipped_hb)) {
1268                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1269                                         "2857 Last completion time not "
1270                                         " updated in %d ms\n",
1271                                         jiffies_to_msecs(jiffies
1272                                                  - phba->last_completion_time));
1273                         } else
1274                                 phba->skipped_hb = jiffies;
1275 
1276                         mod_timer(&phba->hb_tmofunc,
1277                                  jiffies +
1278                                  msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1279                         return;
1280                 } else {
1281                         /*
1282                         * If heart beat timeout called with hb_outstanding set
1283                         * we need to give the hb mailbox cmd a chance to
1284                         * complete or TMO.
1285                         */
1286                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1287                                         "0459 Adapter heartbeat still out"
1288                                         "standing:last compl time was %d ms.\n",
1289                                         jiffies_to_msecs(jiffies
1290                                                  - phba->last_completion_time));
1291                         mod_timer(&phba->hb_tmofunc,
1292                                 jiffies +
1293                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1294                 }
1295         } else {
1296                         mod_timer(&phba->hb_tmofunc,
1297                                 jiffies +
1298                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1299         }
1300 }
1301 
1302 /**
1303  * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1304  * @phba: pointer to lpfc hba data structure.
1305  *
1306  * This routine is called to bring the HBA offline when HBA hardware error
1307  * other than Port Error 6 has been detected.
1308  **/
1309 static void
1310 lpfc_offline_eratt(struct lpfc_hba *phba)
1311 {
1312         struct lpfc_sli   *psli = &phba->sli;
1313 
1314         spin_lock_irq(&phba->hbalock);
1315         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1316         spin_unlock_irq(&phba->hbalock);
1317         lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1318 
1319         lpfc_offline(phba);
1320         lpfc_reset_barrier(phba);
1321         spin_lock_irq(&phba->hbalock);
1322         lpfc_sli_brdreset(phba);
1323         spin_unlock_irq(&phba->hbalock);
1324         lpfc_hba_down_post(phba);
1325         lpfc_sli_brdready(phba, HS_MBRDY);
1326         lpfc_unblock_mgmt_io(phba);
1327         phba->link_state = LPFC_HBA_ERROR;
1328         return;
1329 }
1330 
1331 /**
1332  * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1333  * @phba: pointer to lpfc hba data structure.
1334  *
1335  * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1336  * other than Port Error 6 has been detected.
1337  **/
1338 void
1339 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
1340 {
1341         spin_lock_irq(&phba->hbalock);
1342         phba->link_state = LPFC_HBA_ERROR;
1343         spin_unlock_irq(&phba->hbalock);
1344 
1345         lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1346         lpfc_offline(phba);
1347         lpfc_hba_down_post(phba);
1348         lpfc_unblock_mgmt_io(phba);
1349 }
1350 
1351 /**
1352  * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1353  * @phba: pointer to lpfc hba data structure.
1354  *
1355  * This routine is invoked to handle the deferred HBA hardware error
1356  * conditions. This type of error is indicated by HBA by setting ER1
1357  * and another ER bit in the host status register. The driver will
1358  * wait until the ER1 bit clears before handling the error condition.
1359  **/
1360 static void
1361 lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
1362 {
1363         uint32_t old_host_status = phba->work_hs;
1364         struct lpfc_sli *psli = &phba->sli;
1365 
1366         /* If the pci channel is offline, ignore possible errors,
1367          * since we cannot communicate with the pci card anyway.
1368          */
1369         if (pci_channel_offline(phba->pcidev)) {
1370                 spin_lock_irq(&phba->hbalock);
1371                 phba->hba_flag &= ~DEFER_ERATT;
1372                 spin_unlock_irq(&phba->hbalock);
1373                 return;
1374         }
1375 
1376         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1377                 "0479 Deferred Adapter Hardware Error "
1378                 "Data: x%x x%x x%x\n",
1379                 phba->work_hs,
1380                 phba->work_status[0], phba->work_status[1]);
1381 
1382         spin_lock_irq(&phba->hbalock);
1383         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1384         spin_unlock_irq(&phba->hbalock);
1385 
1386 
1387         /*
1388          * Firmware stops when it triggred erratt. That could cause the I/Os
1389          * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1390          * SCSI layer retry it after re-establishing link.
1391          */
1392         lpfc_sli_abort_fcp_rings(phba);
1393 
1394         /*
1395          * There was a firmware error. Take the hba offline and then
1396          * attempt to restart it.
1397          */
1398         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
1399         lpfc_offline(phba);
1400 
1401         /* Wait for the ER1 bit to clear.*/
1402         while (phba->work_hs & HS_FFER1) {
1403                 msleep(100);
1404                 if (lpfc_readl(phba->HSregaddr, &phba->work_hs)) {
1405                         phba->work_hs = UNPLUG_ERR ;
1406                         break;
1407                 }
1408                 /* If driver is unloading let the worker thread continue */
1409                 if (phba->pport->load_flag & FC_UNLOADING) {
1410                         phba->work_hs = 0;
1411                         break;
1412                 }
1413         }
1414 
1415         /*
1416          * This is to ptrotect against a race condition in which
1417          * first write to the host attention register clear the
1418          * host status register.
1419          */
1420         if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
1421                 phba->work_hs = old_host_status & ~HS_FFER1;
1422 
1423         spin_lock_irq(&phba->hbalock);
1424         phba->hba_flag &= ~DEFER_ERATT;
1425         spin_unlock_irq(&phba->hbalock);
1426         phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
1427         phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
1428 }
1429 
1430 static void
1431 lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
1432 {
1433         struct lpfc_board_event_header board_event;
1434         struct Scsi_Host *shost;
1435 
1436         board_event.event_type = FC_REG_BOARD_EVENT;
1437         board_event.subcategory = LPFC_EVENT_PORTINTERR;
1438         shost = lpfc_shost_from_vport(phba->pport);
1439         fc_host_post_vendor_event(shost, fc_get_event_number(),
1440                                   sizeof(board_event),
1441                                   (char *) &board_event,
1442                                   LPFC_NL_VENDOR_ID);
1443 }
1444 
1445 /**
1446  * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1447  * @phba: pointer to lpfc hba data structure.
1448  *
1449  * This routine is invoked to handle the following HBA hardware error
1450  * conditions:
1451  * 1 - HBA error attention interrupt
1452  * 2 - DMA ring index out of range
1453  * 3 - Mailbox command came back as unknown
1454  **/
1455 static void
1456 lpfc_handle_eratt_s3(struct lpfc_hba *phba)
1457 {
1458         struct lpfc_vport *vport = phba->pport;
1459         struct lpfc_sli   *psli = &phba->sli;
1460         uint32_t event_data;
1461         unsigned long temperature;
1462         struct temp_event temp_event_data;
1463         struct Scsi_Host  *shost;
1464 
1465         /* If the pci channel is offline, ignore possible errors,
1466          * since we cannot communicate with the pci card anyway.
1467          */
1468         if (pci_channel_offline(phba->pcidev)) {
1469                 spin_lock_irq(&phba->hbalock);
1470                 phba->hba_flag &= ~DEFER_ERATT;
1471                 spin_unlock_irq(&phba->hbalock);
1472                 return;
1473         }
1474 
1475         /* If resets are disabled then leave the HBA alone and return */
1476         if (!phba->cfg_enable_hba_reset)
1477                 return;
1478 
1479         /* Send an internal error event to mgmt application */
1480         lpfc_board_errevt_to_mgmt(phba);
1481 
1482         if (phba->hba_flag & DEFER_ERATT)
1483                 lpfc_handle_deferred_eratt(phba);
1484 
1485         if ((phba->work_hs & HS_FFER6) || (phba->work_hs & HS_FFER8)) {
1486                 if (phba->work_hs & HS_FFER6)
1487                         /* Re-establishing Link */
1488                         lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1489                                         "1301 Re-establishing Link "
1490                                         "Data: x%x x%x x%x\n",
1491                                         phba->work_hs, phba->work_status[0],
1492                                         phba->work_status[1]);
1493                 if (phba->work_hs & HS_FFER8)
1494                         /* Device Zeroization */
1495                         lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1496                                         "2861 Host Authentication device "
1497                                         "zeroization Data:x%x x%x x%x\n",
1498                                         phba->work_hs, phba->work_status[0],
1499                                         phba->work_status[1]);
1500 
1501                 spin_lock_irq(&phba->hbalock);
1502                 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1503                 spin_unlock_irq(&phba->hbalock);
1504 
1505                 /*
1506                 * Firmware stops when it triggled erratt with HS_FFER6.
1507                 * That could cause the I/Os dropped by the firmware.
1508                 * Error iocb (I/O) on txcmplq and let the SCSI layer
1509                 * retry it after re-establishing link.
1510                 */
1511                 lpfc_sli_abort_fcp_rings(phba);
1512 
1513                 /*
1514                  * There was a firmware error.  Take the hba offline and then
1515                  * attempt to restart it.
1516                  */
1517                 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1518                 lpfc_offline(phba);
1519                 lpfc_sli_brdrestart(phba);
1520                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
1521                         lpfc_unblock_mgmt_io(phba);
1522                         return;
1523                 }
1524                 lpfc_unblock_mgmt_io(phba);
1525         } else if (phba->work_hs & HS_CRIT_TEMP) {
1526                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
1527                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1528                 temp_event_data.event_code = LPFC_CRIT_TEMP;
1529                 temp_event_data.data = (uint32_t)temperature;
1530 
1531                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1532                                 "0406 Adapter maximum temperature exceeded "
1533                                 "(%ld), taking this port offline "
1534                                 "Data: x%x x%x x%x\n",
1535                                 temperature, phba->work_hs,
1536                                 phba->work_status[0], phba->work_status[1]);
1537 
1538                 shost = lpfc_shost_from_vport(phba->pport);
1539                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1540                                           sizeof(temp_event_data),
1541                                           (char *) &temp_event_data,
1542                                           SCSI_NL_VID_TYPE_PCI
1543                                           | PCI_VENDOR_ID_EMULEX);
1544 
1545                 spin_lock_irq(&phba->hbalock);
1546                 phba->over_temp_state = HBA_OVER_TEMP;
1547                 spin_unlock_irq(&phba->hbalock);
1548                 lpfc_offline_eratt(phba);
1549 
1550         } else {
1551                 /* The if clause above forces this code path when the status
1552                  * failure is a value other than FFER6. Do not call the offline
1553                  * twice. This is the adapter hardware error path.
1554                  */
1555                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1556                                 "0457 Adapter Hardware Error "
1557                                 "Data: x%x x%x x%x\n",
1558                                 phba->work_hs,
1559                                 phba->work_status[0], phba->work_status[1]);
1560 
1561                 event_data = FC_REG_DUMP_EVENT;
1562                 shost = lpfc_shost_from_vport(vport);
1563                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1564                                 sizeof(event_data), (char *) &event_data,
1565                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1566 
1567                 lpfc_offline_eratt(phba);
1568         }
1569         return;
1570 }
1571 
1572 /**
1573  * lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
1574  * @phba: pointer to lpfc hba data structure.
1575  * @mbx_action: flag for mailbox shutdown action.
1576  *
1577  * This routine is invoked to perform an SLI4 port PCI function reset in
1578  * response to port status register polling attention. It waits for port
1579  * status register (ERR, RDY, RN) bits before proceeding with function reset.
1580  * During this process, interrupt vectors are freed and later requested
1581  * for handling possible port resource change.
1582  **/
1583 static int
1584 lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action,
1585                             bool en_rn_msg)
1586 {
1587         int rc;
1588         uint32_t intr_mode;
1589 
1590         /*
1591          * On error status condition, driver need to wait for port
1592          * ready before performing reset.
1593          */
1594         rc = lpfc_sli4_pdev_status_reg_wait(phba);
1595         if (!rc) {
1596                 /* need reset: attempt for port recovery */
1597                 if (en_rn_msg)
1598                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1599                                         "2887 Reset Needed: Attempting Port "
1600                                         "Recovery...\n");
1601                 lpfc_offline_prep(phba, mbx_action);
1602                 lpfc_offline(phba);
1603                 /* release interrupt for possible resource change */
1604                 lpfc_sli4_disable_intr(phba);
1605                 lpfc_sli_brdrestart(phba);
1606                 /* request and enable interrupt */
1607                 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
1608                 if (intr_mode == LPFC_INTR_ERROR) {
1609                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1610                                         "3175 Failed to enable interrupt\n");
1611                         return -EIO;
1612                 } else {
1613                         phba->intr_mode = intr_mode;
1614                 }
1615                 rc = lpfc_online(phba);
1616                 if (rc == 0)
1617                         lpfc_unblock_mgmt_io(phba);
1618         }
1619         return rc;
1620 }
1621 
1622 /**
1623  * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1624  * @phba: pointer to lpfc hba data structure.
1625  *
1626  * This routine is invoked to handle the SLI4 HBA hardware error attention
1627  * conditions.
1628  **/
1629 static void
1630 lpfc_handle_eratt_s4(struct lpfc_hba *phba)
1631 {
1632         struct lpfc_vport *vport = phba->pport;
1633         uint32_t event_data;
1634         struct Scsi_Host *shost;
1635         uint32_t if_type;
1636         struct lpfc_register portstat_reg = {0};
1637         uint32_t reg_err1, reg_err2;
1638         uint32_t uerrlo_reg, uemasklo_reg;
1639         uint32_t pci_rd_rc1, pci_rd_rc2;
1640         bool en_rn_msg = true;
1641         struct temp_event temp_event_data;
1642         int rc;
1643 
1644         /* If the pci channel is offline, ignore possible errors, since
1645          * we cannot communicate with the pci card anyway.
1646          */
1647         if (pci_channel_offline(phba->pcidev))
1648                 return;
1649 
1650         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
1651         switch (if_type) {
1652         case LPFC_SLI_INTF_IF_TYPE_0:
1653                 pci_rd_rc1 = lpfc_readl(
1654                                 phba->sli4_hba.u.if_type0.UERRLOregaddr,
1655                                 &uerrlo_reg);
1656                 pci_rd_rc2 = lpfc_readl(
1657                                 phba->sli4_hba.u.if_type0.UEMASKLOregaddr,
1658                                 &uemasklo_reg);
1659                 /* consider PCI bus read error as pci_channel_offline */
1660                 if (pci_rd_rc1 == -EIO && pci_rd_rc2 == -EIO)
1661                         return;
1662                 lpfc_sli4_offline_eratt(phba);
1663                 break;
1664 
1665         case LPFC_SLI_INTF_IF_TYPE_2:
1666                 pci_rd_rc1 = lpfc_readl(
1667                                 phba->sli4_hba.u.if_type2.STATUSregaddr,
1668                                 &portstat_reg.word0);
1669                 /* consider PCI bus read error as pci_channel_offline */
1670                 if (pci_rd_rc1 == -EIO) {
1671                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1672                                 "3151 PCI bus read access failure: x%x\n",
1673                                 readl(phba->sli4_hba.u.if_type2.STATUSregaddr));
1674                         return;
1675                 }
1676                 reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
1677                 reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
1678                 if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {
1679                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1680                                 "2889 Port Overtemperature event, "
1681                                 "taking port offline Data: x%x x%x\n",
1682                                 reg_err1, reg_err2);
1683 
1684                         temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1685                         temp_event_data.event_code = LPFC_CRIT_TEMP;
1686                         temp_event_data.data = 0xFFFFFFFF;
1687 
1688                         shost = lpfc_shost_from_vport(phba->pport);
1689                         fc_host_post_vendor_event(shost, fc_get_event_number(),
1690                                                   sizeof(temp_event_data),
1691                                                   (char *)&temp_event_data,
1692                                                   SCSI_NL_VID_TYPE_PCI
1693                                                   | PCI_VENDOR_ID_EMULEX);
1694 
1695                         spin_lock_irq(&phba->hbalock);
1696                         phba->over_temp_state = HBA_OVER_TEMP;
1697                         spin_unlock_irq(&phba->hbalock);
1698                         lpfc_sli4_offline_eratt(phba);
1699                         return;
1700                 }
1701                 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1702                     reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) {
1703                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1704                                         "3143 Port Down: Firmware Update "
1705                                         "Detected\n");
1706                         en_rn_msg = false;
1707                 } else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1708                          reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1709                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1710                                         "3144 Port Down: Debug Dump\n");
1711                 else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1712                          reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)
1713                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1714                                         "3145 Port Down: Provisioning\n");
1715 
1716                 /* If resets are disabled then leave the HBA alone and return */
1717                 if (!phba->cfg_enable_hba_reset)
1718                         return;
1719 
1720                 /* Check port status register for function reset */
1721                 rc = lpfc_sli4_port_sta_fn_reset(phba, LPFC_MBX_NO_WAIT,
1722                                 en_rn_msg);
1723                 if (rc == 0) {
1724                         /* don't report event on forced debug dump */
1725                         if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1726                             reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1727                                 return;
1728                         else
1729                                 break;
1730                 }
1731                 /* fall through for not able to recover */
1732                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1733                                 "3152 Unrecoverable error, bring the port "
1734                                 "offline\n");
1735                 lpfc_sli4_offline_eratt(phba);
1736                 break;
1737         case LPFC_SLI_INTF_IF_TYPE_1:
1738         default:
1739                 break;
1740         }
1741         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1742                         "3123 Report dump event to upper layer\n");
1743         /* Send an internal error event to mgmt application */
1744         lpfc_board_errevt_to_mgmt(phba);
1745 
1746         event_data = FC_REG_DUMP_EVENT;
1747         shost = lpfc_shost_from_vport(vport);
1748         fc_host_post_vendor_event(shost, fc_get_event_number(),
1749                                   sizeof(event_data), (char *) &event_data,
1750                                   SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1751 }
1752 
1753 /**
1754  * lpfc_handle_eratt - Wrapper func for handling hba error attention
1755  * @phba: pointer to lpfc HBA data structure.
1756  *
1757  * This routine wraps the actual SLI3 or SLI4 hba error attention handling
1758  * routine from the API jump table function pointer from the lpfc_hba struct.
1759  *
1760  * Return codes
1761  *   0 - success.
1762  *   Any other value - error.
1763  **/
1764 void
1765 lpfc_handle_eratt(struct lpfc_hba *phba)
1766 {
1767         (*phba->lpfc_handle_eratt)(phba);
1768 }
1769 
1770 /**
1771  * lpfc_handle_latt - The HBA link event handler
1772  * @phba: pointer to lpfc hba data structure.
1773  *
1774  * This routine is invoked from the worker thread to handle a HBA host
1775  * attention link event.
1776  **/
1777 void
1778 lpfc_handle_latt(struct lpfc_hba *phba)
1779 {
1780         struct lpfc_vport *vport = phba->pport;
1781         struct lpfc_sli   *psli = &phba->sli;
1782         LPFC_MBOXQ_t *pmb;
1783         volatile uint32_t control;
1784         struct lpfc_dmabuf *mp;
1785         int rc = 0;
1786 
1787         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1788         if (!pmb) {
1789                 rc = 1;
1790                 goto lpfc_handle_latt_err_exit;
1791         }
1792 
1793         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1794         if (!mp) {
1795                 rc = 2;
1796                 goto lpfc_handle_latt_free_pmb;
1797         }
1798 
1799         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
1800         if (!mp->virt) {
1801                 rc = 3;
1802                 goto lpfc_handle_latt_free_mp;
1803         }
1804 
1805         /* Cleanup any outstanding ELS commands */
1806         lpfc_els_flush_all_cmd(phba);
1807 
1808         psli->slistat.link_event++;
1809         lpfc_read_topology(phba, pmb, mp);
1810         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
1811         pmb->vport = vport;
1812         /* Block ELS IOCBs until we have processed this mbox command */
1813         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
1814         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
1815         if (rc == MBX_NOT_FINISHED) {
1816                 rc = 4;
1817                 goto lpfc_handle_latt_free_mbuf;
1818         }
1819 
1820         /* Clear Link Attention in HA REG */
1821         spin_lock_irq(&phba->hbalock);
1822         writel(HA_LATT, phba->HAregaddr);
1823         readl(phba->HAregaddr); /* flush */
1824         spin_unlock_irq(&phba->hbalock);
1825 
1826         return;
1827 
1828 lpfc_handle_latt_free_mbuf:
1829         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
1830         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1831 lpfc_handle_latt_free_mp:
1832         kfree(mp);
1833 lpfc_handle_latt_free_pmb:
1834         mempool_free(pmb, phba->mbox_mem_pool);
1835 lpfc_handle_latt_err_exit:
1836         /* Enable Link attention interrupts */
1837         spin_lock_irq(&phba->hbalock);
1838         psli->sli_flag |= LPFC_PROCESS_LA;
1839         control = readl(phba->HCregaddr);
1840         control |= HC_LAINT_ENA;
1841         writel(control, phba->HCregaddr);
1842         readl(phba->HCregaddr); /* flush */
1843 
1844         /* Clear Link Attention in HA REG */
1845         writel(HA_LATT, phba->HAregaddr);
1846         readl(phba->HAregaddr); /* flush */
1847         spin_unlock_irq(&phba->hbalock);
1848         lpfc_linkdown(phba);
1849         phba->link_state = LPFC_HBA_ERROR;
1850 
1851         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1852                      "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1853 
1854         return;
1855 }
1856 
1857 /**
1858  * lpfc_parse_vpd - Parse VPD (Vital Product Data)
1859  * @phba: pointer to lpfc hba data structure.
1860  * @vpd: pointer to the vital product data.
1861  * @len: length of the vital product data in bytes.
1862  *
1863  * This routine parses the Vital Product Data (VPD). The VPD is treated as
1864  * an array of characters. In this routine, the ModelName, ProgramType, and
1865  * ModelDesc, etc. fields of the phba data structure will be populated.
1866  *
1867  * Return codes
1868  *   0 - pointer to the VPD passed in is NULL
1869  *   1 - success
1870  **/
1871 int
1872 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1873 {
1874         uint8_t lenlo, lenhi;
1875         int Length;
1876         int i, j;
1877         int finished = 0;
1878         int index = 0;
1879 
1880         if (!vpd)
1881                 return 0;
1882 
1883         /* Vital Product */
1884         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1885                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
1886                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1887                         (uint32_t) vpd[3]);
1888         while (!finished && (index < (len - 4))) {
1889                 switch (vpd[index]) {
1890                 case 0x82:
1891                 case 0x91:
1892                         index += 1;
1893                         lenlo = vpd[index];
1894                         index += 1;
1895                         lenhi = vpd[index];
1896                         index += 1;
1897                         i = ((((unsigned short)lenhi) << 8) + lenlo);
1898                         index += i;
1899                         break;
1900                 case 0x90:
1901                         index += 1;
1902                         lenlo = vpd[index];
1903                         index += 1;
1904                         lenhi = vpd[index];
1905                         index += 1;
1906                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
1907                         if (Length > len - index)
1908                                 Length = len - index;
1909                         while (Length > 0) {
1910                         /* Look for Serial Number */
1911                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
1912                                 index += 2;
1913                                 i = vpd[index];
1914                                 index += 1;
1915                                 j = 0;
1916                                 Length -= (3+i);
1917                                 while(i--) {
1918                                         phba->SerialNumber[j++] = vpd[index++];
1919                                         if (j == 31)
1920                                                 break;
1921                                 }
1922                                 phba->SerialNumber[j] = 0;
1923                                 continue;
1924                         }
1925                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
1926                                 phba->vpd_flag |= VPD_MODEL_DESC;
1927                                 index += 2;
1928                                 i = vpd[index];
1929                                 index += 1;
1930                                 j = 0;
1931                                 Length -= (3+i);
1932                                 while(i--) {
1933                                         phba->ModelDesc[j++] = vpd[index++];
1934                                         if (j == 255)
1935                                                 break;
1936                                 }
1937                                 phba->ModelDesc[j] = 0;
1938                                 continue;
1939                         }
1940                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
1941                                 phba->vpd_flag |= VPD_MODEL_NAME;
1942                                 index += 2;
1943                                 i = vpd[index];
1944                                 index += 1;
1945                                 j = 0;
1946                                 Length -= (3+i);
1947                                 while(i--) {
1948                                         phba->ModelName[j++] = vpd[index++];
1949                                         if (j == 79)
1950                                                 break;
1951                                 }
1952                                 phba->ModelName[j] = 0;
1953                                 continue;
1954                         }
1955                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
1956                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
1957                                 index += 2;
1958                                 i = vpd[index];
1959                                 index += 1;
1960                                 j = 0;
1961                                 Length -= (3+i);
1962                                 while(i--) {
1963                                         phba->ProgramType[j++] = vpd[index++];
1964                                         if (j == 255)
1965                                                 break;
1966                                 }
1967                                 phba->ProgramType[j] = 0;
1968                                 continue;
1969                         }
1970                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
1971                                 phba->vpd_flag |= VPD_PORT;
1972                                 index += 2;
1973                                 i = vpd[index];
1974                                 index += 1;
1975                                 j = 0;
1976                                 Length -= (3+i);
1977                                 while(i--) {
1978                                         if ((phba->sli_rev == LPFC_SLI_REV4) &&
1979                                             (phba->sli4_hba.pport_name_sta ==
1980                                              LPFC_SLI4_PPNAME_GET)) {
1981                                                 j++;
1982                                                 index++;
1983                                         } else
1984                                                 phba->Port[j++] = vpd[index++];
1985                                         if (j == 19)
1986                                                 break;
1987                                 }
1988                                 if ((phba->sli_rev != LPFC_SLI_REV4) ||
1989                                     (phba->sli4_hba.pport_name_sta ==
1990                                      LPFC_SLI4_PPNAME_NON))
1991                                         phba->Port[j] = 0;
1992                                 continue;
1993                         }
1994                         else {
1995                                 index += 2;
1996                                 i = vpd[index];
1997                                 index += 1;
1998                                 index += i;
1999                                 Length -= (3 + i);
2000                         }
2001                 }
2002                 finished = 0;
2003                 break;
2004                 case 0x78:
2005                         finished = 1;
2006                         break;
2007                 default:
2008                         index ++;
2009                         break;
2010                 }
2011         }
2012 
2013         return(1);
2014 }
2015 
2016 /**
2017  * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
2018  * @phba: pointer to lpfc hba data structure.
2019  * @mdp: pointer to the data structure to hold the derived model name.
2020  * @descp: pointer to the data structure to hold the derived description.
2021  *
2022  * This routine retrieves HBA's description based on its registered PCI device
2023  * ID. The @descp passed into this function points to an array of 256 chars. It
2024  * shall be returned with the model name, maximum speed, and the host bus type.
2025  * The @mdp passed into this function points to an array of 80 chars. When the
2026  * function returns, the @mdp will be filled with the model name.
2027  **/
2028 static void
2029 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
2030 {
2031         lpfc_vpd_t *vp;
2032         uint16_t dev_id = phba->pcidev->device;
2033         int max_speed;
2034         int GE = 0;
2035         int oneConnect = 0; /* default is not a oneConnect */
2036         struct {
2037                 char *name;
2038                 char *bus;
2039                 char *function;
2040         } m = {"<Unknown>", "", ""};
2041 
2042         if (mdp && mdp[0] != '\0'
2043                 && descp && descp[0] != '\0')
2044                 return;
2045 
2046         if (phba->lmt & LMT_32Gb)
2047                 max_speed = 32;
2048         else if (phba->lmt & LMT_16Gb)
2049                 max_speed = 16;
2050         else if (phba->lmt & LMT_10Gb)
2051                 max_speed = 10;
2052         else if (phba->lmt & LMT_8Gb)
2053                 max_speed = 8;
2054         else if (phba->lmt & LMT_4Gb)
2055                 max_speed = 4;
2056         else if (phba->lmt & LMT_2Gb)
2057                 max_speed = 2;
2058         else if (phba->lmt & LMT_1Gb)
2059                 max_speed = 1;
2060         else
2061                 max_speed = 0;
2062 
2063         vp = &phba->vpd;
2064 
2065         switch (dev_id) {
2066         case PCI_DEVICE_ID_FIREFLY:
2067                 m = (typeof(m)){"LP6000", "PCI",
2068                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2069                 break;
2070         case PCI_DEVICE_ID_SUPERFLY:
2071                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
2072                         m = (typeof(m)){"LP7000", "PCI", ""};
2073                 else
2074                         m = (typeof(m)){"LP7000E", "PCI", ""};
2075                 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2076                 break;
2077         case PCI_DEVICE_ID_DRAGONFLY:
2078                 m = (typeof(m)){"LP8000", "PCI",
2079                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2080                 break;
2081         case PCI_DEVICE_ID_CENTAUR:
2082                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
2083                         m = (typeof(m)){"LP9002", "PCI", ""};
2084                 else
2085                         m = (typeof(m)){"LP9000", "PCI", ""};
2086                 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2087                 break;
2088         case PCI_DEVICE_ID_RFLY:
2089                 m = (typeof(m)){"LP952", "PCI",
2090                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2091                 break;
2092         case PCI_DEVICE_ID_PEGASUS:
2093                 m = (typeof(m)){"LP9802", "PCI-X",
2094                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2095                 break;
2096         case PCI_DEVICE_ID_THOR:
2097                 m = (typeof(m)){"LP10000", "PCI-X",
2098                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2099                 break;
2100         case PCI_DEVICE_ID_VIPER:
2101                 m = (typeof(m)){"LPX1000",  "PCI-X",
2102                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2103                 break;
2104         case PCI_DEVICE_ID_PFLY:
2105                 m = (typeof(m)){"LP982", "PCI-X",
2106                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2107                 break;
2108         case PCI_DEVICE_ID_TFLY:
2109                 m = (typeof(m)){"LP1050", "PCI-X",
2110                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2111                 break;
2112         case PCI_DEVICE_ID_HELIOS:
2113                 m = (typeof(m)){"LP11000", "PCI-X2",
2114                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2115                 break;
2116         case PCI_DEVICE_ID_HELIOS_SCSP:
2117                 m = (typeof(m)){"LP11000-SP", "PCI-X2",
2118                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2119                 break;
2120         case PCI_DEVICE_ID_HELIOS_DCSP:
2121                 m = (typeof(m)){"LP11002-SP",  "PCI-X2",
2122                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2123                 break;
2124         case PCI_DEVICE_ID_NEPTUNE:
2125                 m = (typeof(m)){"LPe1000", "PCIe",
2126                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2127                 break;
2128         case PCI_DEVICE_ID_NEPTUNE_SCSP:
2129                 m = (typeof(m)){"LPe1000-SP", "PCIe",
2130                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2131                 break;
2132         case PCI_DEVICE_ID_NEPTUNE_DCSP:
2133                 m = (typeof(m)){"LPe1002-SP", "PCIe",
2134                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2135                 break;
2136         case PCI_DEVICE_ID_BMID:
2137                 m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
2138                 break;
2139         case PCI_DEVICE_ID_BSMB:
2140                 m = (typeof(m)){"LP111", "PCI-X2",
2141                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2142                 break;
2143         case PCI_DEVICE_ID_ZEPHYR:
2144                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2145                 break;
2146         case PCI_DEVICE_ID_ZEPHYR_SCSP:
2147                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2148                 break;
2149         case PCI_DEVICE_ID_ZEPHYR_DCSP:
2150                 m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
2151                 GE = 1;
2152                 break;
2153         case PCI_DEVICE_ID_ZMID:
2154                 m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
2155                 break;
2156         case PCI_DEVICE_ID_ZSMB:
2157                 m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
2158                 break;
2159         case PCI_DEVICE_ID_LP101:
2160                 m = (typeof(m)){"LP101", "PCI-X",
2161                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2162                 break;
2163         case PCI_DEVICE_ID_LP10000S:
2164                 m = (typeof(m)){"LP10000-S", "PCI",
2165                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2166                 break;
2167         case PCI_DEVICE_ID_LP11000S:
2168                 m = (typeof(m)){"LP11000-S", "PCI-X2",
2169                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2170                 break;
2171         case PCI_DEVICE_ID_LPE11000S:
2172                 m = (typeof(m)){"LPe11000-S", "PCIe",
2173                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2174                 break;
2175         case PCI_DEVICE_ID_SAT:
2176                 m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
2177                 break;
2178         case PCI_DEVICE_ID_SAT_MID:
2179                 m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
2180                 break;
2181         case PCI_DEVICE_ID_SAT_SMB:
2182                 m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
2183                 break;
2184         case PCI_DEVICE_ID_SAT_DCSP:
2185                 m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
2186                 break;
2187         case PCI_DEVICE_ID_SAT_SCSP:
2188                 m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
2189                 break;
2190         case PCI_DEVICE_ID_SAT_S:
2191                 m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
2192                 break;
2193         case PCI_DEVICE_ID_HORNET:
2194                 m = (typeof(m)){"LP21000", "PCIe",
2195                                 "Obsolete, Unsupported FCoE Adapter"};
2196                 GE = 1;
2197                 break;
2198         case PCI_DEVICE_ID_PROTEUS_VF:
2199                 m = (typeof(m)){"LPev12000", "PCIe IOV",
2200                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2201                 break;
2202         case PCI_DEVICE_ID_PROTEUS_PF:
2203                 m = (typeof(m)){"LPev12000", "PCIe IOV",
2204                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2205                 break;
2206         case PCI_DEVICE_ID_PROTEUS_S:
2207                 m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
2208                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2209                 break;
2210         case PCI_DEVICE_ID_TIGERSHARK:
2211                 oneConnect = 1;
2212                 m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
2213                 break;
2214         case PCI_DEVICE_ID_TOMCAT:
2215                 oneConnect = 1;
2216                 m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
2217                 break;
2218         case PCI_DEVICE_ID_FALCON:
2219                 m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
2220                                 "EmulexSecure Fibre"};
2221                 break;
2222         case PCI_DEVICE_ID_BALIUS:
2223                 m = (typeof(m)){"LPVe12002", "PCIe Shared I/O",
2224                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2225                 break;
2226         case PCI_DEVICE_ID_LANCER_FC:
2227                 m = (typeof(m)){"LPe16000", "PCIe", "Fibre Channel Adapter"};
2228                 break;
2229         case PCI_DEVICE_ID_LANCER_FC_VF:
2230                 m = (typeof(m)){"LPe16000", "PCIe",
2231                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2232                 break;
2233         case PCI_DEVICE_ID_LANCER_FCOE:
2234                 oneConnect = 1;
2235                 m = (typeof(m)){"OCe15100", "PCIe", "FCoE"};
2236                 break;
2237         case PCI_DEVICE_ID_LANCER_FCOE_VF:
2238                 oneConnect = 1;
2239                 m = (typeof(m)){"OCe15100", "PCIe",
2240                                 "Obsolete, Unsupported FCoE"};
2241                 break;
2242         case PCI_DEVICE_ID_LANCER_G6_FC:
2243                 m = (typeof(m)){"LPe32000", "PCIe", "Fibre Channel Adapter"};
2244                 break;
2245         case PCI_DEVICE_ID_SKYHAWK:
2246         case PCI_DEVICE_ID_SKYHAWK_VF:
2247                 oneConnect = 1;
2248                 m = (typeof(m)){"OCe14000", "PCIe", "FCoE"};
2249                 break;
2250         default:
2251                 m = (typeof(m)){"Unknown", "", ""};
2252                 break;
2253         }
2254 
2255         if (mdp && mdp[0] == '\0')
2256                 snprintf(mdp, 79,"%s", m.name);
2257         /*
2258          * oneConnect hba requires special processing, they are all initiators
2259          * and we put the port number on the end
2260          */
2261         if (descp && descp[0] == '\0') {
2262                 if (oneConnect)
2263                         snprintf(descp, 255,
2264                                 "Emulex OneConnect %s, %s Initiator %s",
2265                                 m.name, m.function,
2266                                 phba->Port);
2267                 else if (max_speed == 0)
2268                         snprintf(descp, 255,
2269                                 "Emulex %s %s %s",
2270                                 m.name, m.bus, m.function);
2271                 else
2272                         snprintf(descp, 255,
2273                                 "Emulex %s %d%s %s %s",
2274                                 m.name, max_speed, (GE) ? "GE" : "Gb",
2275                                 m.bus, m.function);
2276         }
2277 }
2278 
2279 /**
2280  * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
2281  * @phba: pointer to lpfc hba data structure.
2282  * @pring: pointer to a IOCB ring.
2283  * @cnt: the number of IOCBs to be posted to the IOCB ring.
2284  *
2285  * This routine posts a given number of IOCBs with the associated DMA buffer
2286  * descriptors specified by the cnt argument to the given IOCB ring.
2287  *
2288  * Return codes
2289  *   The number of IOCBs NOT able to be posted to the IOCB ring.
2290  **/
2291 int
2292 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
2293 {
2294         IOCB_t *icmd;
2295         struct lpfc_iocbq *iocb;
2296         struct lpfc_dmabuf *mp1, *mp2;
2297 
2298         cnt += pring->missbufcnt;
2299 
2300         /* While there are buffers to post */
2301         while (cnt > 0) {
2302                 /* Allocate buffer for  command iocb */
2303                 iocb = lpfc_sli_get_iocbq(phba);
2304                 if (iocb == NULL) {
2305                         pring->missbufcnt = cnt;
2306                         return cnt;
2307                 }
2308                 icmd = &iocb->iocb;
2309 
2310                 /* 2 buffers can be posted per command */
2311                 /* Allocate buffer to post */
2312                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2313                 if (mp1)
2314                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
2315                 if (!mp1 || !mp1->virt) {
2316                         kfree(mp1);
2317                         lpfc_sli_release_iocbq(phba, iocb);
2318                         pring->missbufcnt = cnt;
2319                         return cnt;
2320                 }
2321 
2322                 INIT_LIST_HEAD(&mp1->list);
2323                 /* Allocate buffer to post */
2324                 if (cnt > 1) {
2325                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2326                         if (mp2)
2327                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
2328                                                             &mp2->phys);
2329                         if (!mp2 || !mp2->virt) {
2330                                 kfree(mp2);
2331                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2332                                 kfree(mp1);
2333                                 lpfc_sli_release_iocbq(phba, iocb);
2334                                 pring->missbufcnt = cnt;
2335                                 return cnt;
2336                         }
2337 
2338                         INIT_LIST_HEAD(&mp2->list);
2339                 } else {
2340                         mp2 = NULL;
2341                 }
2342 
2343                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
2344                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
2345                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
2346                 icmd->ulpBdeCount = 1;
2347                 cnt--;
2348                 if (mp2) {
2349                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
2350                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
2351                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
2352                         cnt--;
2353                         icmd->ulpBdeCount = 2;
2354                 }
2355 
2356                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
2357                 icmd->ulpLe = 1;
2358 
2359                 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
2360                     IOCB_ERROR) {
2361                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2362                         kfree(mp1);
2363                         cnt++;
2364                         if (mp2) {
2365                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
2366                                 kfree(mp2);
2367                                 cnt++;
2368                         }
2369                         lpfc_sli_release_iocbq(phba, iocb);
2370                         pring->missbufcnt = cnt;
2371                         return cnt;
2372                 }
2373                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
2374                 if (mp2)
2375                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
2376         }
2377         pring->missbufcnt = 0;
2378         return 0;
2379 }
2380 
2381 /**
2382  * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
2383  * @phba: pointer to lpfc hba data structure.
2384  *
2385  * This routine posts initial receive IOCB buffers to the ELS ring. The
2386  * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
2387  * set to 64 IOCBs.
2388  *
2389  * Return codes
2390  *   0 - success (currently always success)
2391  **/
2392 static int
2393 lpfc_post_rcv_buf(struct lpfc_hba *phba)
2394 {
2395         struct lpfc_sli *psli = &phba->sli;
2396 
2397         /* Ring 0, ELS / CT buffers */
2398         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0);
2399         /* Ring 2 - FCP no buffers needed */
2400 
2401         return 0;
2402 }
2403 
2404 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
2405 
2406 /**
2407  * lpfc_sha_init - Set up initial array of hash table entries
2408  * @HashResultPointer: pointer to an array as hash table.
2409  *
2410  * This routine sets up the initial values to the array of hash table entries
2411  * for the LC HBAs.
2412  **/
2413 static void
2414 lpfc_sha_init(uint32_t * HashResultPointer)
2415 {
2416         HashResultPointer[0] = 0x67452301;
2417         HashResultPointer[1] = 0xEFCDAB89;
2418         HashResultPointer[2] = 0x98BADCFE;
2419         HashResultPointer[3] = 0x10325476;
2420         HashResultPointer[4] = 0xC3D2E1F0;
2421 }
2422 
2423 /**
2424  * lpfc_sha_iterate - Iterate initial hash table with the working hash table
2425  * @HashResultPointer: pointer to an initial/result hash table.
2426  * @HashWorkingPointer: pointer to an working hash table.
2427  *
2428  * This routine iterates an initial hash table pointed by @HashResultPointer
2429  * with the values from the working hash table pointeed by @HashWorkingPointer.
2430  * The results are putting back to the initial hash table, returned through
2431  * the @HashResultPointer as the result hash table.
2432  **/
2433 static void
2434 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
2435 {
2436         int t;
2437         uint32_t TEMP;
2438         uint32_t A, B, C, D, E;
2439         t = 16;
2440         do {
2441                 HashWorkingPointer[t] =
2442                     S(1,
2443                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
2444                                                                      8] ^
2445                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
2446         } while (++t <= 79);
2447         t = 0;
2448         A = HashResultPointer[0];
2449         B = HashResultPointer[1];
2450         C = HashResultPointer[2];
2451         D = HashResultPointer[3];
2452         E = HashResultPointer[4];
2453 
2454         do {
2455                 if (t < 20) {
2456                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
2457                 } else if (t < 40) {
2458                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
2459                 } else if (t < 60) {
2460                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
2461                 } else {
2462                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
2463                 }
2464                 TEMP += S(5, A) + E + HashWorkingPointer[t];
2465                 E = D;
2466                 D = C;
2467                 C = S(30, B);
2468                 B = A;
2469                 A = TEMP;
2470         } while (++t <= 79);
2471 
2472         HashResultPointer[0] += A;
2473         HashResultPointer[1] += B;
2474         HashResultPointer[2] += C;
2475         HashResultPointer[3] += D;
2476         HashResultPointer[4] += E;
2477 
2478 }
2479 
2480 /**
2481  * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2482  * @RandomChallenge: pointer to the entry of host challenge random number array.
2483  * @HashWorking: pointer to the entry of the working hash array.
2484  *
2485  * This routine calculates the working hash array referred by @HashWorking
2486  * from the challenge random numbers associated with the host, referred by
2487  * @RandomChallenge. The result is put into the entry of the working hash
2488  * array and returned by reference through @HashWorking.
2489  **/
2490 static void
2491 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
2492 {
2493         *HashWorking = (*RandomChallenge ^ *HashWorking);
2494 }
2495 
2496 /**
2497  * lpfc_hba_init - Perform special handling for LC HBA initialization
2498  * @phba: pointer to lpfc hba data structure.
2499  * @hbainit: pointer to an array of unsigned 32-bit integers.
2500  *
2501  * This routine performs the special handling for LC HBA initialization.
2502  **/
2503 void
2504 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
2505 {
2506         int t;
2507         uint32_t *HashWorking;
2508         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
2509 
2510         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
2511         if (!HashWorking)
2512                 return;
2513 
2514         HashWorking[0] = HashWorking[78] = *pwwnn++;
2515         HashWorking[1] = HashWorking[79] = *pwwnn;
2516 
2517         for (t = 0; t < 7; t++)
2518                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
2519 
2520         lpfc_sha_init(hbainit);
2521         lpfc_sha_iterate(hbainit, HashWorking);
2522         kfree(HashWorking);
2523 }
2524 
2525 /**
2526  * lpfc_cleanup - Performs vport cleanups before deleting a vport
2527  * @vport: pointer to a virtual N_Port data structure.
2528  *
2529  * This routine performs the necessary cleanups before deleting the @vport.
2530  * It invokes the discovery state machine to perform necessary state
2531  * transitions and to release the ndlps associated with the @vport. Note,
2532  * the physical port is treated as @vport 0.
2533  **/
2534 void
2535 lpfc_cleanup(struct lpfc_vport *vport)
2536 {
2537         struct lpfc_hba   *phba = vport->phba;
2538         struct lpfc_nodelist *ndlp, *next_ndlp;
2539         int i = 0;
2540 
2541         if (phba->link_state > LPFC_LINK_DOWN)
2542                 lpfc_port_link_failure(vport);
2543 
2544         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2545                 if (!NLP_CHK_NODE_ACT(ndlp)) {
2546                         ndlp = lpfc_enable_node(vport, ndlp,
2547                                                 NLP_STE_UNUSED_NODE);
2548                         if (!ndlp)
2549                                 continue;
2550                         spin_lock_irq(&phba->ndlp_lock);
2551                         NLP_SET_FREE_REQ(ndlp);
2552                         spin_unlock_irq(&phba->ndlp_lock);
2553                         /* Trigger the release of the ndlp memory */
2554                         lpfc_nlp_put(ndlp);
2555                         continue;
2556                 }
2557                 spin_lock_irq(&phba->ndlp_lock);
2558                 if (NLP_CHK_FREE_REQ(ndlp)) {
2559                         /* The ndlp should not be in memory free mode already */
2560                         spin_unlock_irq(&phba->ndlp_lock);
2561                         continue;
2562                 } else
2563                         /* Indicate request for freeing ndlp memory */
2564                         NLP_SET_FREE_REQ(ndlp);
2565                 spin_unlock_irq(&phba->ndlp_lock);
2566 
2567                 if (vport->port_type != LPFC_PHYSICAL_PORT &&
2568                     ndlp->nlp_DID == Fabric_DID) {
2569                         /* Just free up ndlp with Fabric_DID for vports */
2570                         lpfc_nlp_put(ndlp);
2571                         continue;
2572                 }
2573 
2574                 /* take care of nodes in unused state before the state
2575                  * machine taking action.
2576                  */
2577                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) {
2578                         lpfc_nlp_put(ndlp);
2579                         continue;
2580                 }
2581 
2582                 if (ndlp->nlp_type & NLP_FABRIC)
2583                         lpfc_disc_state_machine(vport, ndlp, NULL,
2584                                         NLP_EVT_DEVICE_RECOVERY);
2585 
2586                 lpfc_disc_state_machine(vport, ndlp, NULL,
2587                                              NLP_EVT_DEVICE_RM);
2588         }
2589 
2590         /* At this point, ALL ndlp's should be gone
2591          * because of the previous NLP_EVT_DEVICE_RM.
2592          * Lets wait for this to happen, if needed.
2593          */
2594         while (!list_empty(&vport->fc_nodes)) {
2595                 if (i++ > 3000) {
2596                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2597                                 "0233 Nodelist not empty\n");
2598                         list_for_each_entry_safe(ndlp, next_ndlp,
2599                                                 &vport->fc_nodes, nlp_listp) {
2600                                 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2601                                                 LOG_NODE,
2602                                                 "0282 did:x%x ndlp:x%p "
2603                                                 "usgmap:x%x refcnt:%d\n",
2604                                                 ndlp->nlp_DID, (void *)ndlp,
2605                                                 ndlp->nlp_usg_map,
2606                                                 atomic_read(
2607                                                         &ndlp->kref.refcount));
2608                         }
2609                         break;
2610                 }
2611 
2612                 /* Wait for any activity on ndlps to settle */
2613                 msleep(10);
2614         }
2615         lpfc_cleanup_vports_rrqs(vport, NULL);
2616 }
2617 
2618 /**
2619  * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2620  * @vport: pointer to a virtual N_Port data structure.
2621  *
2622  * This routine stops all the timers associated with a @vport. This function
2623  * is invoked before disabling or deleting a @vport. Note that the physical
2624  * port is treated as @vport 0.
2625  **/
2626 void
2627 lpfc_stop_vport_timers(struct lpfc_vport *vport)
2628 {
2629         del_timer_sync(&vport->els_tmofunc);
2630         del_timer_sync(&vport->delayed_disc_tmo);
2631         lpfc_can_disctmo(vport);
2632         return;
2633 }
2634 
2635 /**
2636  * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2637  * @phba: pointer to lpfc hba data structure.
2638  *
2639  * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2640  * caller of this routine should already hold the host lock.
2641  **/
2642 void
2643 __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2644 {
2645         /* Clear pending FCF rediscovery wait flag */
2646         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2647 
2648         /* Now, try to stop the timer */
2649         del_timer(&phba->fcf.redisc_wait);
2650 }
2651 
2652 /**
2653  * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2654  * @phba: pointer to lpfc hba data structure.
2655  *
2656  * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2657  * checks whether the FCF rediscovery wait timer is pending with the host
2658  * lock held before proceeding with disabling the timer and clearing the
2659  * wait timer pendig flag.
2660  **/
2661 void
2662 lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2663 {
2664         spin_lock_irq(&phba->hbalock);
2665         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2666                 /* FCF rediscovery timer already fired or stopped */
2667                 spin_unlock_irq(&phba->hbalock);
2668                 return;
2669         }
2670         __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2671         /* Clear failover in progress flags */
2672         phba->fcf.fcf_flag &= ~(FCF_DEAD_DISC | FCF_ACVL_DISC);
2673         spin_unlock_irq(&phba->hbalock);
2674 }
2675 
2676 /**
2677  * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2678  * @phba: pointer to lpfc hba data structure.
2679  *
2680  * This routine stops all the timers associated with a HBA. This function is
2681  * invoked before either putting a HBA offline or unloading the driver.
2682  **/
2683 void
2684 lpfc_stop_hba_timers(struct lpfc_hba *phba)
2685 {
2686         lpfc_stop_vport_timers(phba->pport);
2687         del_timer_sync(&phba->sli.mbox_tmo);
2688         del_timer_sync(&phba->fabric_block_timer);
2689         del_timer_sync(&phba->eratt_poll);
2690         del_timer_sync(&phba->hb_tmofunc);
2691         if (phba->sli_rev == LPFC_SLI_REV4) {
2692                 del_timer_sync(&phba->rrq_tmr);
2693                 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
2694         }
2695         phba->hb_outstanding = 0;
2696 
2697         switch (phba->pci_dev_grp) {
2698         case LPFC_PCI_DEV_LP:
2699                 /* Stop any LightPulse device specific driver timers */
2700                 del_timer_sync(&phba->fcp_poll_timer);
2701                 break;
2702         case LPFC_PCI_DEV_OC:
2703                 /* Stop any OneConnect device sepcific driver timers */
2704                 lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2705                 break;
2706         default:
2707                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2708                                 "0297 Invalid device group (x%x)\n",
2709                                 phba->pci_dev_grp);
2710                 break;
2711         }
2712         return;
2713 }
2714 
2715 /**
2716  * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2717  * @phba: pointer to lpfc hba data structure.
2718  *
2719  * This routine marks a HBA's management interface as blocked. Once the HBA's
2720  * management interface is marked as blocked, all the user space access to
2721  * the HBA, whether they are from sysfs interface or libdfc interface will
2722  * all be blocked. The HBA is set to block the management interface when the
2723  * driver prepares the HBA interface for online or offline.
2724  **/
2725 static void
2726 lpfc_block_mgmt_io(struct lpfc_hba *phba, int mbx_action)
2727 {
2728         unsigned long iflag;
2729         uint8_t actcmd = MBX_HEARTBEAT;
2730         unsigned long timeout;
2731 
2732         spin_lock_irqsave(&phba->hbalock, iflag);
2733         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
2734         spin_unlock_irqrestore(&phba->hbalock, iflag);
2735         if (mbx_action == LPFC_MBX_NO_WAIT)
2736                 return;
2737         timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
2738         spin_lock_irqsave(&phba->hbalock, iflag);
2739         if (phba->sli.mbox_active) {
2740                 actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
2741                 /* Determine how long we might wait for the active mailbox
2742                  * command to be gracefully completed by firmware.
2743                  */
2744                 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
2745                                 phba->sli.mbox_active) * 1000) + jiffies;
2746         }
2747         spin_unlock_irqrestore(&phba->hbalock, iflag);
2748 
2749         /* Wait for the outstnading mailbox command to complete */
2750         while (phba->sli.mbox_active) {
2751                 /* Check active mailbox complete status every 2ms */
2752                 msleep(2);
2753                 if (time_after(jiffies, timeout)) {
2754                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2755                                 "2813 Mgmt IO is Blocked %x "
2756                                 "- mbox cmd %x still active\n",
2757                                 phba->sli.sli_flag, actcmd);
2758                         break;
2759                 }
2760         }
2761 }
2762 
2763 /**
2764  * lpfc_sli4_node_prep - Assign RPIs for active nodes.
2765  * @phba: pointer to lpfc hba data structure.
2766  *
2767  * Allocate RPIs for all active remote nodes. This is needed whenever
2768  * an SLI4 adapter is reset and the driver is not unloading. Its purpose
2769  * is to fixup the temporary rpi assignments.
2770  **/
2771 void
2772 lpfc_sli4_node_prep(struct lpfc_hba *phba)
2773 {
2774         struct lpfc_nodelist  *ndlp, *next_ndlp;
2775         struct lpfc_vport **vports;
2776         int i;
2777 
2778         if (phba->sli_rev != LPFC_SLI_REV4)
2779                 return;
2780 
2781         vports = lpfc_create_vport_work_array(phba);
2782         if (vports != NULL) {
2783                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2784                         if (vports[i]->load_flag & FC_UNLOADING)
2785                                 continue;
2786 
2787                         list_for_each_entry_safe(ndlp, next_ndlp,
2788                                                  &vports[i]->fc_nodes,
2789                                                  nlp_listp) {
2790                                 if (NLP_CHK_NODE_ACT(ndlp)) {
2791                                         ndlp->nlp_rpi =
2792                                                 lpfc_sli4_alloc_rpi(phba);
2793                                         lpfc_printf_vlog(ndlp->vport, KERN_INFO,
2794                                                          LOG_NODE,
2795                                                          "0009 rpi:%x DID:%x "
2796                                                          "flg:%x map:%x %p\n",
2797                                                          ndlp->nlp_rpi,
2798                                                          ndlp->nlp_DID,
2799                                                          ndlp->nlp_flag,
2800                                                          ndlp->nlp_usg_map,
2801                                                          ndlp);
2802                                 }
2803                         }
2804                 }
2805         }
2806         lpfc_destroy_vport_work_array(phba, vports);
2807 }
2808 
2809 /**
2810  * lpfc_online - Initialize and bring a HBA online
2811  * @phba: pointer to lpfc hba data structure.
2812  *
2813  * This routine initializes the HBA and brings a HBA online. During this
2814  * process, the management interface is blocked to prevent user space access
2815  * to the HBA interfering with the driver initialization.
2816  *
2817  * Return codes
2818  *   0 - successful
2819  *   1 - failed
2820  **/
2821 int
2822 lpfc_online(struct lpfc_hba *phba)
2823 {
2824         struct lpfc_vport *vport;
2825         struct lpfc_vport **vports;
2826         int i;
2827         bool vpis_cleared = false;
2828 
2829         if (!phba)
2830                 return 0;
2831         vport = phba->pport;
2832 
2833         if (!(vport->fc_flag & FC_OFFLINE_MODE))
2834                 return 0;
2835 
2836         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2837                         "0458 Bring Adapter online\n");
2838 
2839         lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
2840 
2841         if (!lpfc_sli_queue_setup(phba)) {
2842                 lpfc_unblock_mgmt_io(phba);
2843                 return 1;
2844         }
2845 
2846         if (phba->sli_rev == LPFC_SLI_REV4) {
2847                 if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */
2848                         lpfc_unblock_mgmt_io(phba);
2849                         return 1;
2850                 }
2851                 spin_lock_irq(&phba->hbalock);
2852                 if (!phba->sli4_hba.max_cfg_param.vpi_used)
2853                         vpis_cleared = true;
2854                 spin_unlock_irq(&phba->hbalock);
2855         } else {
2856                 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */
2857                         lpfc_unblock_mgmt_io(phba);
2858                         return 1;
2859                 }
2860         }
2861 
2862         vports = lpfc_create_vport_work_array(phba);
2863         if (vports != NULL) {
2864                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2865                         struct Scsi_Host *shost;
2866                         shost = lpfc_shost_from_vport(vports[i]);
2867                         spin_lock_irq(shost->host_lock);
2868                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
2869                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2870                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2871                         if (phba->sli_rev == LPFC_SLI_REV4) {
2872                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
2873                                 if ((vpis_cleared) &&
2874                                     (vports[i]->port_type !=
2875                                         LPFC_PHYSICAL_PORT))
2876                                         vports[i]->vpi = 0;
2877                         }
2878                         spin_unlock_irq(shost->host_lock);
2879                 }
2880         }
2881         lpfc_destroy_vport_work_array(phba, vports);
2882 
2883         lpfc_unblock_mgmt_io(phba);
2884         return 0;
2885 }
2886 
2887 /**
2888  * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
2889  * @phba: pointer to lpfc hba data structure.
2890  *
2891  * This routine marks a HBA's management interface as not blocked. Once the
2892  * HBA's management interface is marked as not blocked, all the user space
2893  * access to the HBA, whether they are from sysfs interface or libdfc
2894  * interface will be allowed. The HBA is set to block the management interface
2895  * when the driver prepares the HBA interface for online or offline and then
2896  * set to unblock the management interface afterwards.
2897  **/
2898 void
2899 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
2900 {
2901         unsigned long iflag;
2902 
2903         spin_lock_irqsave(&phba->hbalock, iflag);
2904         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
2905         spin_unlock_irqrestore(&phba->hbalock, iflag);
2906 }
2907 
2908 /**
2909  * lpfc_offline_prep - Prepare a HBA to be brought offline
2910  * @phba: pointer to lpfc hba data structure.
2911  *
2912  * This routine is invoked to prepare a HBA to be brought offline. It performs
2913  * unregistration login to all the nodes on all vports and flushes the mailbox
2914  * queue to make it ready to be brought offline.
2915  **/
2916 void
2917 lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action)
2918 {
2919         struct lpfc_vport *vport = phba->pport;
2920         struct lpfc_nodelist  *ndlp, *next_ndlp;
2921         struct lpfc_vport **vports;
2922         struct Scsi_Host *shost;
2923         int i;
2924 
2925         if (vport->fc_flag & FC_OFFLINE_MODE)
2926                 return;
2927 
2928         lpfc_block_mgmt_io(phba, mbx_action);
2929 
2930         lpfc_linkdown(phba);
2931 
2932         /* Issue an unreg_login to all nodes on all vports */
2933         vports = lpfc_create_vport_work_array(phba);
2934         if (vports != NULL) {
2935                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2936                         if (vports[i]->load_flag & FC_UNLOADING)
2937                                 continue;
2938                         shost = lpfc_shost_from_vport(vports[i]);
2939                         spin_lock_irq(shost->host_lock);
2940                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
2941                         vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2942                         vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
2943                         spin_unlock_irq(shost->host_lock);
2944 
2945                         shost = lpfc_shost_from_vport(vports[i]);
2946                         list_for_each_entry_safe(ndlp, next_ndlp,
2947                                                  &vports[i]->fc_nodes,
2948                                                  nlp_listp) {
2949                                 if (!NLP_CHK_NODE_ACT(ndlp))
2950                                         continue;
2951                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
2952                                         continue;
2953                                 if (ndlp->nlp_type & NLP_FABRIC) {
2954                                         lpfc_disc_state_machine(vports[i], ndlp,
2955                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
2956                                         lpfc_disc_state_machine(vports[i], ndlp,
2957                                                 NULL, NLP_EVT_DEVICE_RM);
2958                                 }
2959                                 spin_lock_irq(shost->host_lock);
2960                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2961                                 spin_unlock_irq(shost->host_lock);
2962                                 /*
2963                                  * Whenever an SLI4 port goes offline, free the
2964                                  * RPI. Get a new RPI when the adapter port
2965                                  * comes back online.
2966                                  */
2967                                 if (phba->sli_rev == LPFC_SLI_REV4) {
2968                                         lpfc_printf_vlog(ndlp->vport,
2969                                                          KERN_INFO, LOG_NODE,
2970                                                          "0011 lpfc_offline: "
2971                                                          "ndlp:x%p did %x "
2972                                                          "usgmap:x%x rpi:%x\n",
2973                                                          ndlp, ndlp->nlp_DID,
2974                                                          ndlp->nlp_usg_map,
2975                                                          ndlp->nlp_rpi);
2976 
2977                                         lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
2978                                 }
2979                                 lpfc_unreg_rpi(vports[i], ndlp);
2980                         }
2981                 }
2982         }
2983         lpfc_destroy_vport_work_array(phba, vports);
2984 
2985         lpfc_sli_mbox_sys_shutdown(phba, mbx_action);
2986 }
2987 
2988 /**
2989  * lpfc_offline - Bring a HBA offline
2990  * @phba: pointer to lpfc hba data structure.
2991  *
2992  * This routine actually brings a HBA offline. It stops all the timers
2993  * associated with the HBA, brings down the SLI layer, and eventually
2994  * marks the HBA as in offline state for the upper layer protocol.
2995  **/
2996 void
2997 lpfc_offline(struct lpfc_hba *phba)
2998 {
2999         struct Scsi_Host  *shost;
3000         struct lpfc_vport **vports;
3001         int i;
3002 
3003         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
3004                 return;
3005 
3006         /* stop port and all timers associated with this hba */
3007         lpfc_stop_port(phba);
3008         vports = lpfc_create_vport_work_array(phba);
3009         if (vports != NULL)
3010                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
3011                         lpfc_stop_vport_timers(vports[i]);
3012         lpfc_destroy_vport_work_array(phba, vports);
3013         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3014                         "0460 Bring Adapter offline\n");
3015         /* Bring down the SLI Layer and cleanup.  The HBA is offline
3016            now.  */
3017         lpfc_sli_hba_down(phba);
3018         spin_lock_irq(&phba->hbalock);
3019         phba->work_ha = 0;
3020         spin_unlock_irq(&phba->hbalock);
3021         vports = lpfc_create_vport_work_array(phba);
3022         if (vports != NULL)
3023                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3024                         shost = lpfc_shost_from_vport(vports[i]);
3025                         spin_lock_irq(shost->host_lock);
3026                         vports[i]->work_port_events = 0;
3027                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
3028                         spin_unlock_irq(shost->host_lock);
3029                 }
3030         lpfc_destroy_vport_work_array(phba, vports);
3031 }
3032 
3033 /**
3034  * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
3035  * @phba: pointer to lpfc hba data structure.
3036  *
3037  * This routine is to free all the SCSI buffers and IOCBs from the driver
3038  * list back to kernel. It is called from lpfc_pci_remove_one to free
3039  * the internal resources before the device is removed from the system.
3040  **/
3041 static void
3042 lpfc_scsi_free(struct lpfc_hba *phba)
3043 {
3044         struct lpfc_scsi_buf *sb, *sb_next;
3045         struct lpfc_iocbq *io, *io_next;
3046 
3047         spin_lock_irq(&phba->hbalock);
3048 
3049         /* Release all the lpfc_scsi_bufs maintained by this host. */
3050 
3051         spin_lock(&phba->scsi_buf_list_put_lock);
3052         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_put,
3053                                  list) {
3054                 list_del(&sb->list);
3055                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
3056                               sb->dma_handle);
3057                 kfree(sb);
3058                 phba->total_scsi_bufs--;
3059         }
3060         spin_unlock(&phba->scsi_buf_list_put_lock);
3061 
3062         spin_lock(&phba->scsi_buf_list_get_lock);
3063         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_get,
3064                                  list) {
3065                 list_del(&sb->list);
3066                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
3067                               sb->dma_handle);
3068                 kfree(sb);
3069                 phba->total_scsi_bufs--;
3070         }
3071         spin_unlock(&phba->scsi_buf_list_get_lock);
3072 
3073         /* Release all the lpfc_iocbq entries maintained by this host. */
3074         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
3075                 list_del(&io->list);
3076                 kfree(io);
3077                 phba->total_iocbq_bufs--;
3078         }
3079 
3080         spin_unlock_irq(&phba->hbalock);
3081 }
3082 
3083 /**
3084  * lpfc_sli4_xri_sgl_update - update xri-sgl sizing and mapping
3085  * @phba: pointer to lpfc hba data structure.
3086  *
3087  * This routine first calculates the sizes of the current els and allocated
3088  * scsi sgl lists, and then goes through all sgls to updates the physical
3089  * XRIs assigned due to port function reset. During port initialization, the
3090  * current els and allocated scsi sgl lists are 0s.
3091  *
3092  * Return codes
3093  *   0 - successful (for now, it always returns 0)
3094  **/
3095 int
3096 lpfc_sli4_xri_sgl_update(struct lpfc_hba *phba)
3097 {
3098         struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
3099         struct lpfc_scsi_buf *psb = NULL, *psb_next = NULL;
3100         uint16_t i, lxri, xri_cnt, els_xri_cnt, scsi_xri_cnt;
3101         LIST_HEAD(els_sgl_list);
3102         LIST_HEAD(scsi_sgl_list);
3103         int rc;
3104         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3105 
3106         /*
3107          * update on pci function's els xri-sgl list
3108          */
3109         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3110         if (els_xri_cnt > phba->sli4_hba.els_xri_cnt) {
3111                 /* els xri-sgl expanded */
3112                 xri_cnt = els_xri_cnt - phba->sli4_hba.els_xri_cnt;
3113                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3114                                 "3157 ELS xri-sgl count increased from "
3115                                 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3116                                 els_xri_cnt);
3117                 /* allocate the additional els sgls */
3118                 for (i = 0; i < xri_cnt; i++) {
3119                         sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3120                                              GFP_KERNEL);
3121                         if (sglq_entry == NULL) {
3122                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3123                                                 "2562 Failure to allocate an "
3124                                                 "ELS sgl entry:%d\n", i);
3125                                 rc = -ENOMEM;
3126                                 goto out_free_mem;
3127                         }
3128                         sglq_entry->buff_type = GEN_BUFF_TYPE;
3129                         sglq_entry->virt = lpfc_mbuf_alloc(phba, 0,
3130                                                            &sglq_entry->phys);
3131                         if (sglq_entry->virt == NULL) {
3132                                 kfree(sglq_entry);
3133                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3134                                                 "2563 Failure to allocate an "
3135                                                 "ELS mbuf:%d\n", i);
3136                                 rc = -ENOMEM;
3137                                 goto out_free_mem;
3138                         }
3139                         sglq_entry->sgl = sglq_entry->virt;
3140                         memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
3141                         sglq_entry->state = SGL_FREED;
3142                         list_add_tail(&sglq_entry->list, &els_sgl_list);
3143                 }
3144                 spin_lock_irq(&phba->hbalock);
3145                 spin_lock(&pring->ring_lock);
3146                 list_splice_init(&els_sgl_list, &phba->sli4_hba.lpfc_sgl_list);
3147                 spin_unlock(&pring->ring_lock);
3148                 spin_unlock_irq(&phba->hbalock);
3149         } else if (els_xri_cnt < phba->sli4_hba.els_xri_cnt) {
3150                 /* els xri-sgl shrinked */
3151                 xri_cnt = phba->sli4_hba.els_xri_cnt - els_xri_cnt;
3152                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3153                                 "3158 ELS xri-sgl count decreased from "
3154                                 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3155                                 els_xri_cnt);
3156                 spin_lock_irq(&phba->hbalock);
3157                 spin_lock(&pring->ring_lock);
3158                 list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &els_sgl_list);
3159                 spin_unlock(&pring->ring_lock);
3160                 spin_unlock_irq(&phba->hbalock);
3161                 /* release extra els sgls from list */
3162                 for (i = 0; i < xri_cnt; i++) {
3163                         list_remove_head(&els_sgl_list,
3164                                          sglq_entry, struct lpfc_sglq, list);
3165                         if (sglq_entry) {
3166                                 lpfc_mbuf_free(phba, sglq_entry->virt,
3167                                                sglq_entry->phys);
3168                                 kfree(sglq_entry);
3169                         }
3170                 }
3171                 spin_lock_irq(&phba->hbalock);
3172                 spin_lock(&pring->ring_lock);
3173                 list_splice_init(&els_sgl_list, &phba->sli4_hba.lpfc_sgl_list);
3174                 spin_unlock(&pring->ring_lock);
3175                 spin_unlock_irq(&phba->hbalock);
3176         } else
3177                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3178                                 "3163 ELS xri-sgl count unchanged: %d\n",
3179                                 els_xri_cnt);
3180         phba->sli4_hba.els_xri_cnt = els_xri_cnt;
3181 
3182         /* update xris to els sgls on the list */
3183         sglq_entry = NULL;
3184         sglq_entry_next = NULL;
3185         list_for_each_entry_safe(sglq_entry, sglq_entry_next,
3186                                  &phba->sli4_hba.lpfc_sgl_list, list) {
3187                 lxri = lpfc_sli4_next_xritag(phba);
3188                 if (lxri == NO_XRI) {
3189                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3190                                         "2400 Failed to allocate xri for "
3191                                         "ELS sgl\n");
3192                         rc = -ENOMEM;
3193                         goto out_free_mem;
3194                 }
3195                 sglq_entry->sli4_lxritag = lxri;
3196                 sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3197         }
3198 
3199         /*
3200          * update on pci function's allocated scsi xri-sgl list
3201          */
3202         phba->total_scsi_bufs = 0;
3203 
3204         /* maximum number of xris available for scsi buffers */
3205         phba->sli4_hba.scsi_xri_max = phba->sli4_hba.max_cfg_param.max_xri -
3206                                       els_xri_cnt;
3207 
3208         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3209                         "2401 Current allocated SCSI xri-sgl count:%d, "
3210                         "maximum  SCSI xri count:%d\n",
3211                         phba->sli4_hba.scsi_xri_cnt,
3212                         phba->sli4_hba.scsi_xri_max);
3213 
3214         spin_lock_irq(&phba->scsi_buf_list_get_lock);
3215         spin_lock(&phba->scsi_buf_list_put_lock);
3216         list_splice_init(&phba->lpfc_scsi_buf_list_get, &scsi_sgl_list);
3217         list_splice(&phba->lpfc_scsi_buf_list_put, &scsi_sgl_list);
3218         spin_unlock(&phba->scsi_buf_list_put_lock);
3219         spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3220 
3221         if (phba->sli4_hba.scsi_xri_cnt > phba->sli4_hba.scsi_xri_max) {
3222                 /* max scsi xri shrinked below the allocated scsi buffers */
3223                 scsi_xri_cnt = phba->sli4_hba.scsi_xri_cnt -
3224                                         phba->sli4_hba.scsi_xri_max;
3225                 /* release the extra allocated scsi buffers */
3226                 for (i = 0; i < scsi_xri_cnt; i++) {
3227                         list_remove_head(&scsi_sgl_list, psb,
3228                                          struct lpfc_scsi_buf, list);
3229                         if (psb) {
3230                                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
3231                                               psb->data, psb->dma_handle);
3232                                 kfree(psb);
3233                         }
3234                 }
3235                 spin_lock_irq(&phba->scsi_buf_list_get_lock);
3236                 phba->sli4_hba.scsi_xri_cnt -= scsi_xri_cnt;
3237                 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3238         }
3239 
3240         /* update xris associated to remaining allocated scsi buffers */
3241         psb = NULL;
3242         psb_next = NULL;
3243         list_for_each_entry_safe(psb, psb_next, &scsi_sgl_list, list) {
3244                 lxri = lpfc_sli4_next_xritag(phba);
3245                 if (lxri == NO_XRI) {
3246                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3247                                         "2560 Failed to allocate xri for "
3248                                         "scsi buffer\n");
3249                         rc = -ENOMEM;
3250                         goto out_free_mem;
3251                 }
3252                 psb->cur_iocbq.sli4_lxritag = lxri;
3253                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3254         }
3255         spin_lock_irq(&phba->scsi_buf_list_get_lock);
3256         spin_lock(&phba->scsi_buf_list_put_lock);
3257         list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list_get);
3258         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
3259         spin_unlock(&phba->scsi_buf_list_put_lock);
3260         spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3261 
3262         return 0;
3263 
3264 out_free_mem:
3265         lpfc_free_els_sgl_list(phba);
3266         lpfc_scsi_free(phba);
3267         return rc;
3268 }
3269 
3270 /**
3271  * lpfc_create_port - Create an FC port
3272  * @phba: pointer to lpfc hba data structure.
3273  * @instance: a unique integer ID to this FC port.
3274  * @dev: pointer to the device data structure.
3275  *
3276  * This routine creates a FC port for the upper layer protocol. The FC port
3277  * can be created on top of either a physical port or a virtual port provided
3278  * by the HBA. This routine also allocates a SCSI host data structure (shost)
3279  * and associates the FC port created before adding the shost into the SCSI
3280  * layer.
3281  *
3282  * Return codes
3283  *   @vport - pointer to the virtual N_Port data structure.
3284  *   NULL - port create failed.
3285  **/
3286 struct lpfc_vport *
3287 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
3288 {
3289         struct lpfc_vport *vport;
3290         struct Scsi_Host  *shost;
3291         int error = 0;
3292 
3293         if (dev != &phba->pcidev->dev) {
3294                 shost = scsi_host_alloc(&lpfc_vport_template,
3295                                         sizeof(struct lpfc_vport));
3296         } else {
3297                 if (phba->sli_rev == LPFC_SLI_REV4)
3298                         shost = scsi_host_alloc(&lpfc_template,
3299                                         sizeof(struct lpfc_vport));
3300                 else
3301                         shost = scsi_host_alloc(&lpfc_template_s3,
3302                                         sizeof(struct lpfc_vport));
3303         }
3304         if (!shost)
3305                 goto out;
3306 
3307         vport = (struct lpfc_vport *) shost->hostdata;
3308         vport->phba = phba;
3309         vport->load_flag |= FC_LOADING;
3310         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3311         vport->fc_rscn_flush = 0;
3312 
3313         lpfc_get_vport_cfgparam(vport);
3314         shost->unique_id = instance;
3315         shost->max_id = LPFC_MAX_TARGET;
3316         shost->max_lun = vport->cfg_max_luns;
3317         shost->this_id = -1;
3318         shost->max_cmd_len = 16;
3319         shost->nr_hw_queues = phba->cfg_fcp_io_channel;
3320         if (phba->sli_rev == LPFC_SLI_REV4) {
3321                 shost->dma_boundary =
3322                         phba->sli4_hba.pc_sli4_params.sge_supp_len-1;
3323                 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
3324         }
3325 
3326         /*
3327          * Set initial can_queue value since 0 is no longer supported and
3328          * scsi_add_host will fail. This will be adjusted later based on the
3329          * max xri value determined in hba setup.
3330          */
3331         shost->can_queue = phba->cfg_hba_queue_depth - 10;
3332         if (dev != &phba->pcidev->dev) {
3333                 shost->transportt = lpfc_vport_transport_template;
3334                 vport->port_type = LPFC_NPIV_PORT;
3335         } else {
3336                 shost->transportt = lpfc_transport_template;
3337                 vport->port_type = LPFC_PHYSICAL_PORT;
3338         }
3339 
3340         /* Initialize all internally managed lists. */
3341         INIT_LIST_HEAD(&vport->fc_nodes);
3342         INIT_LIST_HEAD(&vport->rcv_buffer_list);
3343         spin_lock_init(&vport->work_port_lock);
3344 
3345         init_timer(&vport->fc_disctmo);
3346         vport->fc_disctmo.function = lpfc_disc_timeout;
3347         vport->fc_disctmo.data = (unsigned long)vport;
3348 
3349         init_timer(&vport->els_tmofunc);
3350         vport->els_tmofunc.function = lpfc_els_timeout;
3351         vport->els_tmofunc.data = (unsigned long)vport;
3352 
3353         init_timer(&vport->delayed_disc_tmo);
3354         vport->delayed_disc_tmo.function = lpfc_delayed_disc_tmo;
3355         vport->delayed_disc_tmo.data = (unsigned long)vport;
3356 
3357         error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
3358         if (error)
3359                 goto out_put_shost;
3360 
3361         spin_lock_irq(&phba->hbalock);
3362         list_add_tail(&vport->listentry, &phba->port_list);
3363         spin_unlock_irq(&phba->hbalock);
3364         return vport;
3365 
3366 out_put_shost:
3367         scsi_host_put(shost);
3368 out:
3369         return NULL;
3370 }
3371 
3372 /**
3373  * destroy_port -  destroy an FC port
3374  * @vport: pointer to an lpfc virtual N_Port data structure.
3375  *
3376  * This routine destroys a FC port from the upper layer protocol. All the
3377  * resources associated with the port are released.
3378  **/
3379 void
3380 destroy_port(struct lpfc_vport *vport)
3381 {
3382         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3383         struct lpfc_hba  *phba = vport->phba;
3384 
3385         lpfc_debugfs_terminate(vport);
3386         fc_remove_host(shost);
3387         scsi_remove_host(shost);
3388 
3389         spin_lock_irq(&phba->hbalock);
3390         list_del_init(&vport->listentry);
3391         spin_unlock_irq(&phba->hbalock);
3392 
3393         lpfc_cleanup(vport);
3394         return;
3395 }
3396 
3397 /**
3398  * lpfc_get_instance - Get a unique integer ID
3399  *
3400  * This routine allocates a unique integer ID from lpfc_hba_index pool. It
3401  * uses the kernel idr facility to perform the task.
3402  *
3403  * Return codes:
3404  *   instance - a unique integer ID allocated as the new instance.
3405  *   -1 - lpfc get instance failed.
3406  **/
3407 int
3408 lpfc_get_instance(void)
3409 {
3410         int ret;
3411 
3412         ret = idr_alloc(&lpfc_hba_index, NULL, 0, 0, GFP_KERNEL);
3413         return ret < 0 ? -1 : ret;
3414 }
3415 
3416 /**
3417  * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
3418  * @shost: pointer to SCSI host data structure.
3419  * @time: elapsed time of the scan in jiffies.
3420  *
3421  * This routine is called by the SCSI layer with a SCSI host to determine
3422  * whether the scan host is finished.
3423  *
3424  * Note: there is no scan_start function as adapter initialization will have
3425  * asynchronously kicked off the link initialization.
3426  *
3427  * Return codes
3428  *   0 - SCSI host scan is not over yet.
3429  *   1 - SCSI host scan is over.
3430  **/
3431 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
3432 {
3433         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3434         struct lpfc_hba   *phba = vport->phba;
3435         int stat = 0;
3436 
3437         spin_lock_irq(shost->host_lock);
3438 
3439         if (vport->load_flag & FC_UNLOADING) {
3440                 stat = 1;
3441                 goto finished;
3442         }
3443         if (time >= msecs_to_jiffies(30 * 1000)) {
3444                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3445                                 "0461 Scanning longer than 30 "
3446                                 "seconds.  Continuing initialization\n");
3447                 stat = 1;
3448                 goto finished;
3449         }
3450         if (time >= msecs_to_jiffies(15 * 1000) &&
3451             phba->link_state <= LPFC_LINK_DOWN) {
3452                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3453                                 "0465 Link down longer than 15 "
3454                                 "seconds.  Continuing initialization\n");
3455                 stat = 1;
3456                 goto finished;
3457         }
3458 
3459         if (vport->port_state != LPFC_VPORT_READY)
3460                 goto finished;
3461         if (vport->num_disc_nodes || vport->fc_prli_sent)
3462                 goto finished;
3463         if (vport->fc_map_cnt == 0 && time < msecs_to_jiffies(2 * 1000))
3464                 goto finished;
3465         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
3466                 goto finished;
3467 
3468         stat = 1;
3469 
3470 finished:
3471         spin_unlock_irq(shost->host_lock);
3472         return stat;
3473 }
3474 
3475 /**
3476  * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
3477  * @shost: pointer to SCSI host data structure.
3478  *
3479  * This routine initializes a given SCSI host attributes on a FC port. The
3480  * SCSI host can be either on top of a physical port or a virtual port.
3481  **/
3482 void lpfc_host_attrib_init(struct Scsi_Host *shost)
3483 {
3484         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3485         struct lpfc_hba   *phba = vport->phba;
3486         /*
3487          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
3488          */
3489 
3490         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
3491         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
3492         fc_host_supported_classes(shost) = FC_COS_CLASS3;
3493 
3494         memset(fc_host_supported_fc4s(shost), 0,
3495                sizeof(fc_host_supported_fc4s(shost)));
3496         fc_host_supported_fc4s(shost)[2] = 1;
3497         fc_host_supported_fc4s(shost)[7] = 1;
3498 
3499         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
3500                                  sizeof fc_host_symbolic_name(shost));
3501 
3502         fc_host_supported_speeds(shost) = 0;
3503         if (phba->lmt & LMT_32Gb)
3504                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_32GBIT;
3505         if (phba->lmt & LMT_16Gb)
3506                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_16GBIT;
3507         if (phba->lmt & LMT_10Gb)
3508                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
3509         if (phba->lmt & LMT_8Gb)
3510                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
3511         if (phba->lmt & LMT_4Gb)
3512                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
3513         if (phba->lmt & LMT_2Gb)
3514                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
3515         if (phba->lmt & LMT_1Gb)
3516                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
3517 
3518         fc_host_maxframe_size(shost) =
3519                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
3520                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
3521 
3522         fc_host_dev_loss_tmo(shost) = vport->cfg_devloss_tmo;
3523 
3524         /* This value is also unchanging */
3525         memset(fc_host_active_fc4s(shost), 0,
3526                sizeof(fc_host_active_fc4s(shost)));
3527         fc_host_active_fc4s(shost)[2] = 1;
3528         fc_host_active_fc4s(shost)[7] = 1;
3529 
3530         fc_host_max_npiv_vports(shost) = phba->max_vpi;
3531         spin_lock_irq(shost->host_lock);
3532         vport->load_flag &= ~FC_LOADING;
3533         spin_unlock_irq(shost->host_lock);
3534 }
3535 
3536 /**
3537  * lpfc_stop_port_s3 - Stop SLI3 device port
3538  * @phba: pointer to lpfc hba data structure.
3539  *
3540  * This routine is invoked to stop an SLI3 device port, it stops the device
3541  * from generating interrupts and stops the device driver's timers for the
3542  * device.
3543  **/
3544 static void
3545 lpfc_stop_port_s3(struct lpfc_hba *phba)
3546 {
3547         /* Clear all interrupt enable conditions */
3548         writel(0, phba->HCregaddr);
3549         readl(phba->HCregaddr); /* flush */
3550         /* Clear all pending interrupts */
3551         writel(0xffffffff, phba->HAregaddr);
3552         readl(phba->HAregaddr); /* flush */
3553 
3554         /* Reset some HBA SLI setup states */
3555         lpfc_stop_hba_timers(phba);
3556         phba->pport->work_port_events = 0;
3557 }
3558 
3559 /**
3560  * lpfc_stop_port_s4 - Stop SLI4 device port
3561  * @phba: pointer to lpfc hba data structure.
3562  *
3563  * This routine is invoked to stop an SLI4 device port, it stops the device
3564  * from generating interrupts and stops the device driver's timers for the
3565  * device.
3566  **/
3567 static void
3568 lpfc_stop_port_s4(struct lpfc_hba *phba)
3569 {
3570         /* Reset some HBA SLI4 setup states */
3571         lpfc_stop_hba_timers(phba);
3572         phba->pport->work_port_events = 0;
3573         phba->sli4_hba.intr_enable = 0;
3574 }
3575 
3576 /**
3577  * lpfc_stop_port - Wrapper function for stopping hba port
3578  * @phba: Pointer to HBA context object.
3579  *
3580  * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
3581  * the API jump table function pointer from the lpfc_hba struct.
3582  **/
3583 void
3584 lpfc_stop_port(struct lpfc_hba *phba)
3585 {
3586         phba->lpfc_stop_port(phba);
3587 }
3588 
3589 /**
3590  * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
3591  * @phba: Pointer to hba for which this call is being executed.
3592  *
3593  * This routine starts the timer waiting for the FCF rediscovery to complete.
3594  **/
3595 void
3596 lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
3597 {
3598         unsigned long fcf_redisc_wait_tmo =
3599                 (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
3600         /* Start fcf rediscovery wait period timer */
3601         mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
3602         spin_lock_irq(&phba->hbalock);
3603         /* Allow action to new fcf asynchronous event */
3604         phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
3605         /* Mark the FCF rediscovery pending state */
3606         phba->fcf.fcf_flag |= FCF_REDISC_PEND;
3607         spin_unlock_irq(&phba->hbalock);
3608 }
3609 
3610 /**
3611  * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
3612  * @ptr: Map to lpfc_hba data structure pointer.
3613  *
3614  * This routine is invoked when waiting for FCF table rediscover has been
3615  * timed out. If new FCF record(s) has (have) been discovered during the
3616  * wait period, a new FCF event shall be added to the FCOE async event
3617  * list, and then worker thread shall be waked up for processing from the
3618  * worker thread context.
3619  **/
3620 static void
3621 lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
3622 {
3623         struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
3624 
3625         /* Don't send FCF rediscovery event if timer cancelled */
3626         spin_lock_irq(&phba->hbalock);
3627         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
3628                 spin_unlock_irq(&phba->hbalock);
3629                 return;
3630         }
3631         /* Clear FCF rediscovery timer pending flag */
3632         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
3633         /* FCF rediscovery event to worker thread */
3634         phba->fcf.fcf_flag |= FCF_REDISC_EVT;
3635         spin_unlock_irq(&phba->hbalock);
3636         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
3637                         "2776 FCF rediscover quiescent timer expired\n");
3638         /* wake up worker thread */
3639         lpfc_worker_wake_up(phba);
3640 }
3641 
3642 /**
3643  * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
3644  * @phba: pointer to lpfc hba data structure.
3645  * @acqe_link: pointer to the async link completion queue entry.
3646  *
3647  * This routine is to parse the SLI4 link-attention link fault code and
3648  * translate it into the base driver's read link attention mailbox command
3649  * status.
3650  *
3651  * Return: Link-attention status in terms of base driver's coding.
3652  **/
3653 static uint16_t
3654 lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba,
3655                            struct lpfc_acqe_link *acqe_link)
3656 {
3657         uint16_t latt_fault;
3658 
3659         switch (bf_get(lpfc_acqe_link_fault, acqe_link)) {
3660         case LPFC_ASYNC_LINK_FAULT_NONE:
3661         case LPFC_ASYNC_LINK_FAULT_LOCAL:
3662         case LPFC_ASYNC_LINK_FAULT_REMOTE:
3663                 latt_fault = 0;
3664                 break;
3665         default:
3666                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3667                                 "0398 Invalid link fault code: x%x\n",
3668                                 bf_get(lpfc_acqe_link_fault, acqe_link));
3669                 latt_fault = MBXERR_ERROR;
3670                 break;
3671         }
3672         return latt_fault;
3673 }
3674 
3675 /**
3676  * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
3677  * @phba: pointer to lpfc hba data structure.
3678  * @acqe_link: pointer to the async link completion queue entry.
3679  *
3680  * This routine is to parse the SLI4 link attention type and translate it
3681  * into the base driver's link attention type coding.
3682  *
3683  * Return: Link attention type in terms of base driver's coding.
3684  **/
3685 static uint8_t
3686 lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
3687                           struct lpfc_acqe_link *acqe_link)
3688 {
3689         uint8_t att_type;
3690 
3691         switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
3692         case LPFC_ASYNC_LINK_STATUS_DOWN:
3693         case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
3694                 att_type = LPFC_ATT_LINK_DOWN;
3695                 break;
3696         case LPFC_ASYNC_LINK_STATUS_UP:
3697                 /* Ignore physical link up events - wait for logical link up */
3698                 att_type = LPFC_ATT_RESERVED;
3699                 break;
3700         case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
3701                 att_type = LPFC_ATT_LINK_UP;
3702                 break;
3703         default:
3704                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3705                                 "0399 Invalid link attention type: x%x\n",
3706                                 bf_get(lpfc_acqe_link_status, acqe_link));
3707                 att_type = LPFC_ATT_RESERVED;
3708                 break;
3709         }
3710         return att_type;
3711 }
3712 
3713 /**
3714  * lpfc_sli_port_speed_get - Get sli3 link speed code to link speed
3715  * @phba: pointer to lpfc hba data structure.
3716  *
3717  * This routine is to get an SLI3 FC port's link speed in Mbps.
3718  *
3719  * Return: link speed in terms of Mbps.
3720  **/
3721 uint32_t
3722 lpfc_sli_port_speed_get(struct lpfc_hba *phba)
3723 {
3724         uint32_t link_speed;
3725 
3726         if (!lpfc_is_link_up(phba))
3727                 return 0;
3728 
3729         if (phba->sli_rev <= LPFC_SLI_REV3) {
3730                 switch (phba->fc_linkspeed) {
3731                 case LPFC_LINK_SPEED_1GHZ:
3732                         link_speed = 1000;
3733                         break;
3734                 case LPFC_LINK_SPEED_2GHZ:
3735                         link_speed = 2000;
3736                         break;
3737                 case LPFC_LINK_SPEED_4GHZ:
3738                         link_speed = 4000;
3739                         break;
3740                 case LPFC_LINK_SPEED_8GHZ:
3741                         link_speed = 8000;
3742                         break;
3743                 case LPFC_LINK_SPEED_10GHZ:
3744                         link_speed = 10000;
3745                         break;
3746                 case LPFC_LINK_SPEED_16GHZ:
3747                         link_speed = 16000;
3748                         break;
3749                 default:
3750                         link_speed = 0;
3751                 }
3752         } else {
3753                 if (phba->sli4_hba.link_state.logical_speed)
3754                         link_speed =
3755                               phba->sli4_hba.link_state.logical_speed;
3756                 else
3757                         link_speed = phba->sli4_hba.link_state.speed;
3758         }
3759         return link_speed;
3760 }
3761 
3762 /**
3763  * lpfc_sli4_port_speed_parse - Parse async evt link speed code to link speed
3764  * @phba: pointer to lpfc hba data structure.
3765  * @evt_code: asynchronous event code.
3766  * @speed_code: asynchronous event link speed code.
3767  *
3768  * This routine is to parse the giving SLI4 async event link speed code into
3769  * value of Mbps for the link speed.
3770  *
3771  * Return: link speed in terms of Mbps.
3772  **/
3773 static uint32_t
3774 lpfc_sli4_port_speed_parse(struct lpfc_hba *phba, uint32_t evt_code,
3775                            uint8_t speed_code)
3776 {
3777         uint32_t port_speed;
3778 
3779         switch (evt_code) {
3780         case LPFC_TRAILER_CODE_LINK:
3781                 switch (speed_code) {
3782                 case LPFC_ASYNC_LINK_SPEED_ZERO:
3783                         port_speed = 0;
3784                         break;
3785                 case LPFC_ASYNC_LINK_SPEED_10MBPS:
3786                         port_speed = 10;
3787                         break;
3788                 case LPFC_ASYNC_LINK_SPEED_100MBPS:
3789                         port_speed = 100;
3790                         break;
3791                 case LPFC_ASYNC_LINK_SPEED_1GBPS:
3792                         port_speed = 1000;
3793                         break;
3794                 case LPFC_ASYNC_LINK_SPEED_10GBPS:
3795                         port_speed = 10000;
3796                         break;
3797                 case LPFC_ASYNC_LINK_SPEED_20GBPS:
3798                         port_speed = 20000;
3799                         break;
3800                 case LPFC_ASYNC_LINK_SPEED_25GBPS:
3801                         port_speed = 25000;
3802                         break;
3803                 case LPFC_ASYNC_LINK_SPEED_40GBPS:
3804                         port_speed = 40000;
3805                         break;
3806                 default:
3807                         port_speed = 0;
3808                 }
3809                 break;
3810         case LPFC_TRAILER_CODE_FC:
3811                 switch (speed_code) {
3812                 case LPFC_FC_LA_SPEED_UNKNOWN:
3813                         port_speed = 0;
3814                         break;
3815                 case LPFC_FC_LA_SPEED_1G:
3816                         port_speed = 1000;
3817                         break;
3818                 case LPFC_FC_LA_SPEED_2G:
3819                         port_speed = 2000;
3820                         break;
3821                 case LPFC_FC_LA_SPEED_4G:
3822                         port_speed = 4000;
3823                         break;
3824                 case LPFC_FC_LA_SPEED_8G:
3825                         port_speed = 8000;
3826                         break;
3827                 case LPFC_FC_LA_SPEED_10G:
3828                         port_speed = 10000;
3829                         break;
3830                 case LPFC_FC_LA_SPEED_16G:
3831                         port_speed = 16000;
3832                         break;
3833                 case LPFC_FC_LA_SPEED_32G:
3834                         port_speed = 32000;
3835                         break;
3836                 default:
3837                         port_speed = 0;
3838                 }
3839                 break;
3840         default:
3841                 port_speed = 0;
3842         }
3843         return port_speed;
3844 }
3845 
3846 /**
3847  * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event
3848  * @phba: pointer to lpfc hba data structure.
3849  * @acqe_link: pointer to the async link completion queue entry.
3850  *
3851  * This routine is to handle the SLI4 asynchronous FCoE link event.
3852  **/
3853 static void
3854 lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
3855                          struct lpfc_acqe_link *acqe_link)
3856 {
3857         struct lpfc_dmabuf *mp;
3858         LPFC_MBOXQ_t *pmb;
3859         MAILBOX_t *mb;
3860         struct lpfc_mbx_read_top *la;
3861         uint8_t att_type;
3862         int rc;
3863 
3864         att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
3865         if (att_type != LPFC_ATT_LINK_DOWN && att_type != LPFC_ATT_LINK_UP)
3866                 return;
3867         phba->fcoe_eventtag = acqe_link->event_tag;
3868         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3869         if (!pmb) {
3870                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3871                                 "0395 The mboxq allocation failed\n");
3872                 return;
3873         }
3874         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
3875         if (!mp) {
3876                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3877                                 "0396 The lpfc_dmabuf allocation failed\n");
3878                 goto out_free_pmb;
3879         }
3880         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3881         if (!mp->virt) {
3882                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3883                                 "0397 The mbuf allocation failed\n");
3884                 goto out_free_dmabuf;
3885         }
3886 
3887         /* Cleanup any outstanding ELS commands */
3888         lpfc_els_flush_all_cmd(phba);
3889 
3890         /* Block ELS IOCBs until we have done process link event */
3891         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
3892 
3893         /* Update link event statistics */
3894         phba->sli.slistat.link_event++;
3895 
3896         /* Create lpfc_handle_latt mailbox command from link ACQE */
3897         lpfc_read_topology(phba, pmb, mp);
3898         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
3899         pmb->vport = phba->pport;
3900 
3901         /* Keep the link status for extra SLI4 state machine reference */
3902         phba->sli4_hba.link_state.speed =
3903                         lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_LINK,
3904                                 bf_get(lpfc_acqe_link_speed, acqe_link));
3905         phba->sli4_hba.link_state.duplex =
3906                                 bf_get(lpfc_acqe_link_duplex, acqe_link);
3907         phba->sli4_hba.link_state.status =
3908                                 bf_get(lpfc_acqe_link_status, acqe_link);
3909         phba->sli4_hba.link_state.type =
3910                                 bf_get(lpfc_acqe_link_type, acqe_link);
3911         phba->sli4_hba.link_state.number =
3912                                 bf_get(lpfc_acqe_link_number, acqe_link);
3913         phba->sli4_hba.link_state.fault =
3914                                 bf_get(lpfc_acqe_link_fault, acqe_link);
3915         phba->sli4_hba.link_state.logical_speed =
3916                         bf_get(lpfc_acqe_logical_link_speed, acqe_link) * 10;
3917 
3918         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3919                         "2900 Async FC/FCoE Link event - Speed:%dGBit "
3920                         "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
3921                         "Logical speed:%dMbps Fault:%d\n",
3922                         phba->sli4_hba.link_state.speed,
3923                         phba->sli4_hba.link_state.topology,
3924                         phba->sli4_hba.link_state.status,
3925                         phba->sli4_hba.link_state.type,
3926                         phba->sli4_hba.link_state.number,
3927                         phba->sli4_hba.link_state.logical_speed,
3928                         phba->sli4_hba.link_state.fault);
3929         /*
3930          * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch
3931          * topology info. Note: Optional for non FC-AL ports.
3932          */
3933         if (!(phba->hba_flag & HBA_FCOE_MODE)) {
3934                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
3935                 if (rc == MBX_NOT_FINISHED)
3936                         goto out_free_dmabuf;
3937                 return;
3938         }
3939         /*
3940          * For FCoE Mode: fill in all the topology information we need and call
3941          * the READ_TOPOLOGY completion routine to continue without actually
3942          * sending the READ_TOPOLOGY mailbox command to the port.
3943          */
3944         /* Parse and translate status field */
3945         mb = &pmb->u.mb;
3946         mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
3947 
3948         /* Parse and translate link attention fields */
3949         la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
3950         la->eventTag = acqe_link->event_tag;
3951         bf_set(lpfc_mbx_read_top_att_type, la, att_type);
3952         bf_set(lpfc_mbx_read_top_link_spd, la,
3953                (bf_get(lpfc_acqe_link_speed, acqe_link)));
3954 
3955         /* Fake the the following irrelvant fields */
3956         bf_set(lpfc_mbx_read_top_topology, la, LPFC_TOPOLOGY_PT_PT);
3957         bf_set(lpfc_mbx_read_top_alpa_granted, la, 0);
3958         bf_set(lpfc_mbx_read_top_il, la, 0);
3959         bf_set(lpfc_mbx_read_top_pb, la, 0);
3960         bf_set(lpfc_mbx_read_top_fa, la, 0);
3961         bf_set(lpfc_mbx_read_top_mm, la, 0);
3962 
3963         /* Invoke the lpfc_handle_latt mailbox command callback function */
3964         lpfc_mbx_cmpl_read_topology(phba, pmb);
3965 
3966         return;
3967 
3968 out_free_dmabuf:
3969         kfree(mp);
3970 out_free_pmb:
3971         mempool_free(pmb, phba->mbox_mem_pool);
3972 }
3973 
3974 /**
3975  * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event
3976  * @phba: pointer to lpfc hba data structure.
3977  * @acqe_fc: pointer to the async fc completion queue entry.
3978  *
3979  * This routine is to handle the SLI4 asynchronous FC event. It will simply log
3980  * that the event was received and then issue a read_topology mailbox command so
3981  * that the rest of the driver will treat it the same as SLI3.
3982  **/
3983 static void
3984 lpfc_sli4_async_fc_evt(struct lpfc_hba *phba, struct lpfc_acqe_fc_la *acqe_fc)
3985 {
3986         struct lpfc_dmabuf *mp;
3987         LPFC_MBOXQ_t *pmb;
3988         int rc;
3989 
3990         if (bf_get(lpfc_trailer_type, acqe_fc) !=
3991             LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
3992                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3993                                 "2895 Non FC link Event detected.(%d)\n",
3994                                 bf_get(lpfc_trailer_type, acqe_fc));
3995                 return;
3996         }
3997         /* Keep the link status for extra SLI4 state machine reference */
3998         phba->sli4_hba.link_state.speed =
3999                         lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_FC,
4000                                 bf_get(lpfc_acqe_fc_la_speed, acqe_fc));
4001         phba->sli4_hba.link_state.duplex = LPFC_ASYNC_LINK_DUPLEX_FULL;
4002         phba->sli4_hba.link_state.topology =
4003                                 bf_get(lpfc_acqe_fc_la_topology, acqe_fc);
4004         phba->sli4_hba.link_state.status =
4005                                 bf_get(lpfc_acqe_fc_la_att_type, acqe_fc);
4006         phba->sli4_hba.link_state.type =
4007                                 bf_get(lpfc_acqe_fc_la_port_type, acqe_fc);
4008         phba->sli4_hba.link_state.number =
4009                                 bf_get(lpfc_acqe_fc_la_port_number, acqe_fc);
4010         phba->sli4_hba.link_state.fault =
4011                                 bf_get(lpfc_acqe_link_fault, acqe_fc);
4012         phba->sli4_hba.link_state.logical_speed =
4013                                 bf_get(lpfc_acqe_fc_la_llink_spd, acqe_fc) * 10;
4014         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4015                         "2896 Async FC event - Speed:%dGBaud Topology:x%x "
4016                         "LA Type:x%x Port Type:%d Port Number:%d Logical speed:"
4017                         "%dMbps Fault:%d\n",
4018                         phba->sli4_hba.link_state.speed,
4019                         phba->sli4_hba.link_state.topology,
4020                         phba->sli4_hba.link_state.status,
4021                         phba->sli4_hba.link_state.type,
4022                         phba->sli4_hba.link_state.number,
4023                         phba->sli4_hba.link_state.logical_speed,
4024                         phba->sli4_hba.link_state.fault);
4025         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4026         if (!pmb) {
4027                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4028                                 "2897 The mboxq allocation failed\n");
4029                 return;
4030         }
4031         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4032         if (!mp) {
4033                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4034                                 "2898 The lpfc_dmabuf allocation failed\n");
4035                 goto out_free_pmb;
4036         }
4037         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4038         if (!mp->virt) {
4039                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4040                                 "2899 The mbuf allocation failed\n");
4041                 goto out_free_dmabuf;
4042         }
4043 
4044         /* Cleanup any outstanding ELS commands */
4045         lpfc_els_flush_all_cmd(phba);
4046 
4047         /* Block ELS IOCBs until we have done process link event */
4048         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
4049 
4050         /* Update link event statistics */
4051         phba->sli.slistat.link_event++;
4052 
4053         /* Create lpfc_handle_latt mailbox command from link ACQE */
4054         lpfc_read_topology(phba, pmb, mp);
4055         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
4056         pmb->vport = phba->pport;
4057 
4058         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4059         if (rc == MBX_NOT_FINISHED)
4060                 goto out_free_dmabuf;
4061         return;
4062 
4063 out_free_dmabuf:
4064         kfree(mp);
4065 out_free_pmb:
4066         mempool_free(pmb, phba->mbox_mem_pool);
4067 }
4068 
4069 /**
4070  * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
4071  * @phba: pointer to lpfc hba data structure.
4072  * @acqe_fc: pointer to the async SLI completion queue entry.
4073  *
4074  * This routine is to handle the SLI4 asynchronous SLI events.
4075  **/
4076 static void
4077 lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli)
4078 {
4079         char port_name;
4080         char message[128];
4081         uint8_t status;
4082         uint8_t evt_type;
4083         uint8_t operational = 0;
4084         struct temp_event temp_event_data;
4085         struct lpfc_acqe_misconfigured_event *misconfigured;
4086         struct Scsi_Host  *shost;
4087 
4088         evt_type = bf_get(lpfc_trailer_type, acqe_sli);
4089 
4090         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4091                         "2901 Async SLI event - Event Data1:x%08x Event Data2:"
4092                         "x%08x SLI Event Type:%d\n",
4093                         acqe_sli->event_data1, acqe_sli->event_data2,
4094                         evt_type);
4095 
4096         port_name = phba->Port[0];
4097         if (port_name == 0x00)
4098                 port_name = '?'; /* get port name is empty */
4099 
4100         switch (evt_type) {
4101         case LPFC_SLI_EVENT_TYPE_OVER_TEMP:
4102                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4103                 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
4104                 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4105 
4106                 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
4107                                 "3190 Over Temperature:%d Celsius- Port Name %c\n",
4108                                 acqe_sli->event_data1, port_name);
4109 
4110                 shost = lpfc_shost_from_vport(phba->pport);
4111                 fc_host_post_vendor_event(shost, fc_get_event_number(),
4112                                           sizeof(temp_event_data),
4113                                           (char *)&temp_event_data,
4114                                           SCSI_NL_VID_TYPE_PCI
4115                                           | PCI_VENDOR_ID_EMULEX);
4116                 break;
4117         case LPFC_SLI_EVENT_TYPE_NORM_TEMP:
4118                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4119                 temp_event_data.event_code = LPFC_NORMAL_TEMP;
4120                 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4121 
4122                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4123                                 "3191 Normal Temperature:%d Celsius - Port Name %c\n",
4124                                 acqe_sli->event_data1, port_name);
4125 
4126                 shost = lpfc_shost_from_vport(phba->pport);
4127                 fc_host_post_vendor_event(shost, fc_get_event_number(),
4128                                           sizeof(temp_event_data),
4129                                           (char *)&temp_event_data,
4130                                           SCSI_NL_VID_TYPE_PCI
4131                                           | PCI_VENDOR_ID_EMULEX);
4132                 break;
4133         case LPFC_SLI_EVENT_TYPE_MISCONFIGURED:
4134                 misconfigured = (struct lpfc_acqe_misconfigured_event *)
4135                                         &acqe_sli->event_data1;
4136 
4137                 /* fetch the status for this port */
4138                 switch (phba->sli4_hba.lnk_info.lnk_no) {
4139                 case LPFC_LINK_NUMBER_0:
4140                         status = bf_get(lpfc_sli_misconfigured_port0_state,
4141                                         &misconfigured->theEvent);
4142                         operational = bf_get(lpfc_sli_misconfigured_port0_op,
4143                                         &misconfigured->theEvent);
4144                         break;
4145                 case LPFC_LINK_NUMBER_1:
4146                         status = bf_get(lpfc_sli_misconfigured_port1_state,
4147                                         &misconfigured->theEvent);
4148                         operational = bf_get(lpfc_sli_misconfigured_port1_op,
4149                                         &misconfigured->theEvent);
4150                         break;
4151                 case LPFC_LINK_NUMBER_2:
4152                         status = bf_get(lpfc_sli_misconfigured_port2_state,
4153                                         &misconfigured->theEvent);
4154                         operational = bf_get(lpfc_sli_misconfigured_port2_op,
4155                                         &misconfigured->theEvent);
4156                         break;
4157                 case LPFC_LINK_NUMBER_3:
4158                         status = bf_get(lpfc_sli_misconfigured_port3_state,
4159                                         &misconfigured->theEvent);
4160                         operational = bf_get(lpfc_sli_misconfigured_port3_op,
4161                                         &misconfigured->theEvent);
4162                         break;
4163                 default:
4164                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4165                                         "3296 "
4166                                         "LPFC_SLI_EVENT_TYPE_MISCONFIGURED "
4167                                         "event: Invalid link %d",
4168                                         phba->sli4_hba.lnk_info.lnk_no);
4169                         return;
4170                 }
4171 
4172                 /* Skip if optic state unchanged */
4173                 if (phba->sli4_hba.lnk_info.optic_state == status)
4174                         return;
4175 
4176                 switch (status) {
4177                 case LPFC_SLI_EVENT_STATUS_VALID:
4178                         sprintf(message, "Physical Link is functional");
4179                         break;
4180                 case LPFC_SLI_EVENT_STATUS_NOT_PRESENT:
4181                         sprintf(message, "Optics faulted/incorrectly "
4182                                 "installed/not installed - Reseat optics, "
4183                                 "if issue not resolved, replace.");
4184                         break;
4185                 case LPFC_SLI_EVENT_STATUS_WRONG_TYPE:
4186                         sprintf(message,
4187                                 "Optics of two types installed - Remove one "
4188                                 "optic or install matching pair of optics.");
4189                         break;
4190                 case LPFC_SLI_EVENT_STATUS_UNSUPPORTED:
4191                         sprintf(message, "Incompatible optics - Replace with "
4192                                 "compatible optics for card to function.");
4193                         break;
4194                 case LPFC_SLI_EVENT_STATUS_UNQUALIFIED:
4195                         sprintf(message, "Unqualified optics - Replace with "
4196                                 "Avago optics for Warranty and Technical "
4197                                 "Support - Link is%s operational",
4198                                 (operational) ? "" : " not");
4199                         break;
4200                 case LPFC_SLI_EVENT_STATUS_UNCERTIFIED:
4201                         sprintf(message, "Uncertified optics - Replace with "
4202                                 "Avago-certified optics to enable link "
4203                                 "operation - Link is%s operational",
4204                                 (operational) ? "" : " not");
4205                         break;
4206                 default:
4207                         /* firmware is reporting a status we don't know about */
4208                         sprintf(message, "Unknown event status x%02x", status);
4209                         break;
4210                 }
4211                 phba->sli4_hba.lnk_info.optic_state = status;
4212                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4213                                 "3176 Port Name %c %s\n", port_name, message);
4214                 break;
4215         case LPFC_SLI_EVENT_TYPE_REMOTE_DPORT:
4216                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4217                                 "3192 Remote DPort Test Initiated - "
4218                                 "Event Data1:x%08x Event Data2: x%08x\n",
4219                                 acqe_sli->event_data1, acqe_sli->event_data2);
4220                 break;
4221         default:
4222                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4223                                 "3193 Async SLI event - Event Data1:x%08x Event Data2:"
4224                                 "x%08x SLI Event Type:%d\n",
4225                                 acqe_sli->event_data1, acqe_sli->event_data2,
4226                                 evt_type);
4227                 break;
4228         }
4229 }
4230 
4231 /**
4232  * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
4233  * @vport: pointer to vport data structure.
4234  *
4235  * This routine is to perform Clear Virtual Link (CVL) on a vport in
4236  * response to a CVL event.
4237  *
4238  * Return the pointer to the ndlp with the vport if successful, otherwise
4239  * return NULL.
4240  **/
4241 static struct lpfc_nodelist *
4242 lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
4243 {
4244         struct lpfc_nodelist *ndlp;
4245         struct Scsi_Host *shost;
4246         struct lpfc_hba *phba;
4247 
4248         if (!vport)
4249                 return NULL;
4250         phba = vport->phba;
4251         if (!phba)
4252                 return NULL;
4253         ndlp = lpfc_findnode_did(vport, Fabric_DID);
4254         if (!ndlp) {
4255                 /* Cannot find existing Fabric ndlp, so allocate a new one */
4256                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4257                 if (!ndlp)
4258                         return 0;
4259                 lpfc_nlp_init(vport, ndlp, Fabric_DID);
4260                 /* Set the node type */
4261                 ndlp->nlp_type |= NLP_FABRIC;
4262                 /* Put ndlp onto node list */
4263                 lpfc_enqueue_node(vport, ndlp);
4264         } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4265                 /* re-setup ndlp without removing from node list */
4266                 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
4267                 if (!ndlp)
4268                         return 0;
4269         }
4270         if ((phba->pport->port_state < LPFC_FLOGI) &&
4271                 (phba->pport->port_state != LPFC_VPORT_FAILED))
4272                 return NULL;
4273         /* If virtual link is not yet instantiated ignore CVL */
4274         if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC)
4275                 && (vport->port_state != LPFC_VPORT_FAILED))
4276                 return NULL;
4277         shost = lpfc_shost_from_vport(vport);
4278         if (!shost)
4279                 return NULL;
4280         lpfc_linkdown_port(vport);
4281         lpfc_cleanup_pending_mbox(vport);
4282         spin_lock_irq(shost->host_lock);
4283         vport->fc_flag |= FC_VPORT_CVL_RCVD;
4284         spin_unlock_irq(shost->host_lock);
4285 
4286         return ndlp;
4287 }
4288 
4289 /**
4290  * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
4291  * @vport: pointer to lpfc hba data structure.
4292  *
4293  * This routine is to perform Clear Virtual Link (CVL) on all vports in
4294  * response to a FCF dead event.
4295  **/
4296 static void
4297 lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
4298 {
4299         struct lpfc_vport **vports;
4300         int i;
4301 
4302         vports = lpfc_create_vport_work_array(phba);
4303         if (vports)
4304                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
4305                         lpfc_sli4_perform_vport_cvl(vports[i]);
4306         lpfc_destroy_vport_work_array(phba, vports);
4307 }
4308 
4309 /**
4310  * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
4311  * @phba: pointer to lpfc hba data structure.
4312  * @acqe_link: pointer to the async fcoe completion queue entry.
4313  *
4314  * This routine is to handle the SLI4 asynchronous fcoe event.
4315  **/
4316 static void
4317 lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
4318                         struct lpfc_acqe_fip *acqe_fip)
4319 {
4320         uint8_t event_type = bf_get(lpfc_trailer_type, acqe_fip);
4321         int rc;
4322         struct lpfc_vport *vport;
4323         struct lpfc_nodelist *ndlp;
4324         struct Scsi_Host  *shost;
4325         int active_vlink_present;
4326         struct lpfc_vport **vports;
4327         int i;
4328 
4329         phba->fc_eventTag = acqe_fip->event_tag;
4330         phba->fcoe_eventtag = acqe_fip->event_tag;
4331         switch (event_type) {
4332         case LPFC_FIP_EVENT_TYPE_NEW_FCF:
4333         case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:
4334                 if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)
4335                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4336                                         LOG_DISCOVERY,
4337                                         "2546 New FCF event, evt_tag:x%x, "
4338                                         "index:x%x\n",
4339                                         acqe_fip->event_tag,
4340                                         acqe_fip->index);
4341                 else
4342                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP |
4343                                         LOG_DISCOVERY,
4344                                         "2788 FCF param modified event, "
4345                                         "evt_tag:x%x, index:x%x\n",
4346                                         acqe_fip->event_tag,
4347                                         acqe_fip->index);
4348                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4349                         /*
4350                          * During period of FCF discovery, read the FCF
4351                          * table record indexed by the event to update
4352                          * FCF roundrobin failover eligible FCF bmask.
4353                          */
4354                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
4355                                         LOG_DISCOVERY,
4356                                         "2779 Read FCF (x%x) for updating "
4357                                         "roundrobin FCF failover bmask\n",
4358                                         acqe_fip->index);
4359                         rc = lpfc_sli4_read_fcf_rec(phba, acqe_fip->index);
4360                 }
4361 
4362                 /* If the FCF discovery is in progress, do nothing. */
4363                 spin_lock_irq(&phba->hbalock);
4364                 if (phba->hba_flag & FCF_TS_INPROG) {
4365                         spin_unlock_irq(&phba->hbalock);
4366                         break;
4367                 }
4368                 /* If fast FCF failover rescan event is pending, do nothing */
4369                 if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
4370                         spin_unlock_irq(&phba->hbalock);
4371                         break;
4372                 }
4373 
4374                 /* If the FCF has been in discovered state, do nothing. */
4375                 if (phba->fcf.fcf_flag & FCF_SCAN_DONE) {
4376                         spin_unlock_irq(&phba->hbalock);
4377                         break;
4378                 }
4379                 spin_unlock_irq(&phba->hbalock);
4380 
4381                 /* Otherwise, scan the entire FCF table and re-discover SAN */
4382                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
4383                                 "2770 Start FCF table scan per async FCF "
4384                                 "event, evt_tag:x%x, index:x%x\n",
4385                                 acqe_fip->event_tag, acqe_fip->index);
4386                 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
4387                                                      LPFC_FCOE_FCF_GET_FIRST);
4388                 if (rc)
4389                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4390                                         "2547 Issue FCF scan read FCF mailbox "
4391                                         "command failed (x%x)\n", rc);
4392                 break;
4393 
4394         case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:
4395                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4396                         "2548 FCF Table full count 0x%x tag 0x%x\n",
4397                         bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),
4398                         acqe_fip->event_tag);
4399                 break;
4400 
4401         case LPFC_FIP_EVENT_TYPE_FCF_DEAD:
4402                 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
4403                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4404                         "2549 FCF (x%x) disconnected from network, "
4405                         "tag:x%x\n", acqe_fip->index, acqe_fip->event_tag);
4406                 /*
4407                  * If we are in the middle of FCF failover process, clear
4408                  * the corresponding FCF bit in the roundrobin bitmap.
4409                  */
4410                 spin_lock_irq(&phba->hbalock);
4411                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4412                         spin_unlock_irq(&phba->hbalock);
4413                         /* Update FLOGI FCF failover eligible FCF bmask */
4414                         lpfc_sli4_fcf_rr_index_clear(phba, acqe_fip->index);
4415                         break;
4416                 }
4417                 spin_unlock_irq(&phba->hbalock);
4418 
4419                 /* If the event is not for currently used fcf do nothing */
4420                 if (phba->fcf.current_rec.fcf_indx != acqe_fip->index)
4421                         break;
4422 
4423                 /*
4424                  * Otherwise, request the port to rediscover the entire FCF
4425                  * table for a fast recovery from case that the current FCF
4426                  * is no longer valid as we are not in the middle of FCF
4427                  * failover process already.
4428                  */
4429                 spin_lock_irq(&phba->hbalock);
4430                 /* Mark the fast failover process in progress */
4431                 phba->fcf.fcf_flag |= FCF_DEAD_DISC;
4432                 spin_unlock_irq(&phba->hbalock);
4433 
4434                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
4435                                 "2771 Start FCF fast failover process due to "
4436                                 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
4437                                 "\n", acqe_fip->event_tag, acqe_fip->index);
4438                 rc = lpfc_sli4_redisc_fcf_table(phba);
4439                 if (rc) {
4440                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4441                                         LOG_DISCOVERY,
4442                                         "2772 Issue FCF rediscover mabilbox "
4443                                         "command failed, fail through to FCF "
4444                                         "dead event\n");
4445                         spin_lock_irq(&phba->hbalock);
4446                         phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
4447                         spin_unlock_irq(&phba->hbalock);
4448                         /*
4449                          * Last resort will fail over by treating this
4450                          * as a link down to FCF registration.
4451                          */
4452                         lpfc_sli4_fcf_dead_failthrough(phba);
4453                 } else {
4454                         /* Reset FCF roundrobin bmask for new discovery */
4455                         lpfc_sli4_clear_fcf_rr_bmask(phba);
4456                         /*
4457                          * Handling fast FCF failover to a DEAD FCF event is
4458                          * considered equalivant to receiving CVL to all vports.
4459                          */
4460                         lpfc_sli4_perform_all_vport_cvl(phba);
4461                 }
4462                 break;
4463         case LPFC_FIP_EVENT_TYPE_CVL:
4464                 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
4465                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4466                         "2718 Clear Virtual Link Received for VPI 0x%x"
4467                         " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
4468 
4469                 vport = lpfc_find_vport_by_vpid(phba,
4470                                                 acqe_fip->index);
4471                 ndlp = lpfc_sli4_perform_vport_cvl(vport);
4472                 if (!ndlp)
4473                         break;
4474                 active_vlink_present = 0;
4475 
4476                 vports = lpfc_create_vport_work_array(phba);
4477                 if (vports) {
4478                         for (i = 0; i <= phba->max_vports && vports[i] != NULL;
4479                                         i++) {
4480                                 if ((!(vports[i]->fc_flag &
4481                                         FC_VPORT_CVL_RCVD)) &&
4482                                         (vports[i]->port_state > LPFC_FDISC)) {
4483                                         active_vlink_present = 1;
4484                                         break;
4485                                 }
4486                         }
4487                         lpfc_destroy_vport_work_array(phba, vports);
4488                 }
4489 
4490                 /*
4491                  * Don't re-instantiate if vport is marked for deletion.
4492                  * If we are here first then vport_delete is going to wait
4493                  * for discovery to complete.
4494                  */
4495                 if (!(vport->load_flag & FC_UNLOADING) &&
4496                                         active_vlink_present) {
4497                         /*
4498                          * If there are other active VLinks present,
4499                          * re-instantiate the Vlink using FDISC.
4500                          */
4501                         mod_timer(&ndlp->nlp_delayfunc,
4502                                   jiffies + msecs_to_jiffies(1000));
4503                         shost = lpfc_shost_from_vport(vport);
4504                         spin_lock_irq(shost->host_lock);
4505                         ndlp->nlp_flag |= NLP_DELAY_TMO;
4506                         spin_unlock_irq(shost->host_lock);
4507                         ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
4508                         vport->port_state = LPFC_FDISC;
4509                 } else {
4510                         /*
4511                          * Otherwise, we request port to rediscover
4512                          * the entire FCF table for a fast recovery
4513                          * from possible case that the current FCF
4514                          * is no longer valid if we are not already
4515                          * in the FCF failover process.
4516                          */
4517                         spin_lock_irq(&phba->hbalock);
4518                         if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4519                                 spin_unlock_irq(&phba->hbalock);
4520                                 break;
4521                         }
4522                         /* Mark the fast failover process in progress */
4523                         phba->fcf.fcf_flag |= FCF_ACVL_DISC;
4524                         spin_unlock_irq(&phba->hbalock);
4525                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
4526                                         LOG_DISCOVERY,
4527                                         "2773 Start FCF failover per CVL, "
4528                                         "evt_tag:x%x\n", acqe_fip->event_tag);
4529                         rc = lpfc_sli4_redisc_fcf_table(phba);
4530                         if (rc) {
4531                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4532                                                 LOG_DISCOVERY,
4533                                                 "2774 Issue FCF rediscover "
4534                                                 "mabilbox command failed, "
4535                                                 "through to CVL event\n");
4536                                 spin_lock_irq(&phba->hbalock);
4537                                 phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
4538                                 spin_unlock_irq(&phba->hbalock);
4539                                 /*
4540                                  * Last resort will be re-try on the
4541                                  * the current registered FCF entry.
4542                                  */
4543                                 lpfc_retry_pport_discovery(phba);
4544                         } else
4545                                 /*
4546                                  * Reset FCF roundrobin bmask for new
4547                                  * discovery.
4548                                  */
4549                                 lpfc_sli4_clear_fcf_rr_bmask(phba);
4550                 }
4551                 break;
4552         default:
4553                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4554                         "0288 Unknown FCoE event type 0x%x event tag "
4555                         "0x%x\n", event_type, acqe_fip->event_tag);
4556                 break;
4557         }
4558 }
4559 
4560 /**
4561  * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
4562  * @phba: pointer to lpfc hba data structure.
4563  * @acqe_link: pointer to the async dcbx completion queue entry.
4564  *
4565  * This routine is to handle the SLI4 asynchronous dcbx event.
4566  **/
4567 static void
4568 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
4569                          struct lpfc_acqe_dcbx *acqe_dcbx)
4570 {
4571         phba->fc_eventTag = acqe_dcbx->event_tag;
4572         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4573                         "0290 The SLI4 DCBX asynchronous event is not "
4574                         "handled yet\n");
4575 }
4576 
4577 /**
4578  * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
4579  * @phba: pointer to lpfc hba data structure.
4580  * @acqe_link: pointer to the async grp5 completion queue entry.
4581  *
4582  * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
4583  * is an asynchronous notified of a logical link speed change.  The Port
4584  * reports the logical link speed in units of 10Mbps.
4585  **/
4586 static void
4587 lpfc_sli4_async_grp5_evt(struct lpfc_hba *phba,
4588                          struct lpfc_acqe_grp5 *acqe_grp5)
4589 {
4590         uint16_t prev_ll_spd;
4591 
4592         phba->fc_eventTag = acqe_grp5->event_tag;
4593         phba->fcoe_eventtag = acqe_grp5->event_tag;
4594         prev_ll_spd = phba->sli4_hba.link_state.logical_speed;
4595         phba->sli4_hba.link_state.logical_speed =
4596                 (bf_get(lpfc_acqe_grp5_llink_spd, acqe_grp5)) * 10;
4597         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4598                         "2789 GRP5 Async Event: Updating logical link speed "
4599                         "from %dMbps to %dMbps\n", prev_ll_spd,
4600                         phba->sli4_hba.link_state.logical_speed);
4601 }
4602 
4603 /**
4604  * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
4605  * @phba: pointer to lpfc hba data structure.
4606  *
4607  * This routine is invoked by the worker thread to process all the pending
4608  * SLI4 asynchronous events.
4609  **/
4610 void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
4611 {
4612         struct lpfc_cq_event *cq_event;
4613 
4614         /* First, declare the async event has been handled */
4615         spin_lock_irq(&phba->hbalock);
4616         phba->hba_flag &= ~ASYNC_EVENT;
4617         spin_unlock_irq(&phba->hbalock);
4618         /* Now, handle all the async events */
4619         while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) {
4620                 /* Get the first event from the head of the event queue */
4621                 spin_lock_irq(&phba->hbalock);
4622                 list_remove_head(&phba->sli4_hba.sp_asynce_work_queue,
4623                                  cq_event, struct lpfc_cq_event, list);
4624                 spin_unlock_irq(&phba->hbalock);
4625                 /* Process the asynchronous event */
4626                 switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) {
4627                 case LPFC_TRAILER_CODE_LINK:
4628                         lpfc_sli4_async_link_evt(phba,
4629                                                  &cq_event->cqe.acqe_link);
4630                         break;
4631                 case LPFC_TRAILER_CODE_FCOE:
4632                         lpfc_sli4_async_fip_evt(phba, &cq_event->cqe.acqe_fip);
4633                         break;
4634                 case LPFC_TRAILER_CODE_DCBX:
4635                         lpfc_sli4_async_dcbx_evt(phba,
4636                                                  &cq_event->cqe.acqe_dcbx);
4637                         break;
4638                 case LPFC_TRAILER_CODE_GRP5:
4639                         lpfc_sli4_async_grp5_evt(phba,
4640                                                  &cq_event->cqe.acqe_grp5);
4641                         break;
4642                 case LPFC_TRAILER_CODE_FC:
4643                         lpfc_sli4_async_fc_evt(phba, &cq_event->cqe.acqe_fc);
4644                         break;
4645                 case LPFC_TRAILER_CODE_SLI:
4646                         lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);
4647                         break;
4648                 default:
4649                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4650                                         "1804 Invalid asynchrous event code: "
4651                                         "x%x\n", bf_get(lpfc_trailer_code,
4652                                         &cq_event->cqe.mcqe_cmpl));
4653                         break;
4654                 }
4655                 /* Free the completion event processed to the free pool */
4656                 lpfc_sli4_cq_event_release(phba, cq_event);
4657         }
4658 }
4659 
4660 /**
4661  * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
4662  * @phba: pointer to lpfc hba data structure.
4663  *
4664  * This routine is invoked by the worker thread to process FCF table
4665  * rediscovery pending completion event.
4666  **/
4667 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
4668 {
4669         int rc;
4670 
4671         spin_lock_irq(&phba->hbalock);
4672         /* Clear FCF rediscovery timeout event */
4673         phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
4674         /* Clear driver fast failover FCF record flag */
4675         phba->fcf.failover_rec.flag = 0;
4676         /* Set state for FCF fast failover */
4677         phba->fcf.fcf_flag |= FCF_REDISC_FOV;
4678         spin_unlock_irq(&phba->hbalock);
4679 
4680         /* Scan FCF table from the first entry to re-discover SAN */
4681         lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
4682                         "2777 Start post-quiescent FCF table scan\n");
4683         rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
4684         if (rc)
4685                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4686                                 "2747 Issue FCF scan read FCF mailbox "
4687                                 "command failed 0x%x\n", rc);
4688 }
4689 
4690 /**
4691  * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
4692  * @phba: pointer to lpfc hba data structure.
4693  * @dev_grp: The HBA PCI-Device group number.
4694  *
4695  * This routine is invoked to set up the per HBA PCI-Device group function
4696  * API jump table entries.
4697  *
4698  * Return: 0 if success, otherwise -ENODEV
4699  **/
4700 int
4701 lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4702 {
4703         int rc;
4704 
4705         /* Set up lpfc PCI-device group */
4706         phba->pci_dev_grp = dev_grp;
4707 
4708         /* The LPFC_PCI_DEV_OC uses SLI4 */
4709         if (dev_grp == LPFC_PCI_DEV_OC)
4710                 phba->sli_rev = LPFC_SLI_REV4;
4711 
4712         /* Set up device INIT API function jump table */
4713         rc = lpfc_init_api_table_setup(phba, dev_grp);
4714         if (rc)
4715                 return -ENODEV;
4716         /* Set up SCSI API function jump table */
4717         rc = lpfc_scsi_api_table_setup(phba, dev_grp);
4718         if (rc)
4719                 return -ENODEV;
4720         /* Set up SLI API function jump table */
4721         rc = lpfc_sli_api_table_setup(phba, dev_grp);
4722         if (rc)
4723                 return -ENODEV;
4724         /* Set up MBOX API function jump table */
4725         rc = lpfc_mbox_api_table_setup(phba, dev_grp);
4726         if (rc)
4727                 return -ENODEV;
4728 
4729         return 0;
4730 }
4731 
4732 /**
4733  * lpfc_log_intr_mode - Log the active interrupt mode
4734  * @phba: pointer to lpfc hba data structure.
4735  * @intr_mode: active interrupt mode adopted.
4736  *
4737  * This routine it invoked to log the currently used active interrupt mode
4738  * to the device.
4739  **/
4740 static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
4741 {
4742         switch (intr_mode) {
4743         case 0:
4744                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4745                                 "0470 Enable INTx interrupt mode.\n");
4746                 break;
4747         case 1:
4748                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4749                                 "0481 Enabled MSI interrupt mode.\n");
4750                 break;
4751         case 2:
4752                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4753                                 "0480 Enabled MSI-X interrupt mode.\n");
4754                 break;
4755         default:
4756                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4757                                 "0482 Illegal interrupt mode.\n");
4758                 break;
4759         }
4760         return;
4761 }
4762 
4763 /**
4764  * lpfc_enable_pci_dev - Enable a generic PCI device.
4765  * @phba: pointer to lpfc hba data structure.
4766  *
4767  * This routine is invoked to enable the PCI device that is common to all
4768  * PCI devices.
4769  *
4770  * Return codes
4771  *      0 - successful
4772  *      other values - error
4773  **/
4774 static int
4775 lpfc_enable_pci_dev(struct lpfc_hba *phba)
4776 {
4777         struct pci_dev *pdev;
4778         int bars = 0;
4779 
4780         /* Obtain PCI device reference */
4781         if (!phba->pcidev)
4782                 goto out_error;
4783         else
4784                 pdev = phba->pcidev;
4785         /* Select PCI BARs */
4786         bars = pci_select_bars(pdev, IORESOURCE_MEM);
4787         /* Enable PCI device */
4788         if (pci_enable_device_mem(pdev))
4789                 goto out_error;
4790         /* Request PCI resource for the device */
4791         if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
4792                 goto out_disable_device;
4793         /* Set up device as PCI master and save state for EEH */
4794         pci_set_master(pdev);
4795         pci_try_set_mwi(pdev);
4796         pci_save_state(pdev);
4797 
4798         /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
4799         if (pci_is_pcie(pdev))
4800                 pdev->needs_freset = 1;
4801 
4802         return 0;
4803 
4804 out_disable_device:
4805         pci_disable_device(pdev);
4806 out_error:
4807         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4808                         "1401 Failed to enable pci device, bars:x%x\n", bars);
4809         return -ENODEV;
4810 }
4811 
4812 /**
4813  * lpfc_disable_pci_dev - Disable a generic PCI device.
4814  * @phba: pointer to lpfc hba data structure.
4815  *
4816  * This routine is invoked to disable the PCI device that is common to all
4817  * PCI devices.
4818  **/
4819 static void
4820 lpfc_disable_pci_dev(struct lpfc_hba *phba)
4821 {
4822         struct pci_dev *pdev;
4823         int bars;
4824 
4825         /* Obtain PCI device reference */
4826         if (!phba->pcidev)
4827                 return;
4828         else
4829                 pdev = phba->pcidev;
4830         /* Select PCI BARs */
4831         bars = pci_select_bars(pdev, IORESOURCE_MEM);
4832         /* Release PCI resource and disable PCI device */
4833         pci_release_selected_regions(pdev, bars);
4834         pci_disable_device(pdev);
4835 
4836         return;
4837 }
4838 
4839 /**
4840  * lpfc_reset_hba - Reset a hba
4841  * @phba: pointer to lpfc hba data structure.
4842  *
4843  * This routine is invoked to reset a hba device. It brings the HBA
4844  * offline, performs a board restart, and then brings the board back
4845  * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
4846  * on outstanding mailbox commands.
4847  **/
4848 void
4849 lpfc_reset_hba(struct lpfc_hba *phba)
4850 {
4851         /* If resets are disabled then set error state and return. */
4852         if (!phba->cfg_enable_hba_reset) {
4853                 phba->link_state = LPFC_HBA_ERROR;
4854                 return;
4855         }
4856         if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
4857                 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
4858         else
4859                 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
4860         lpfc_offline(phba);
4861         lpfc_sli_brdrestart(phba);
4862         lpfc_online(phba);
4863         lpfc_unblock_mgmt_io(phba);
4864 }
4865 
4866 /**
4867  * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions
4868  * @phba: pointer to lpfc hba data structure.
4869  *
4870  * This function enables the PCI SR-IOV virtual functions to a physical
4871  * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
4872  * enable the number of virtual functions to the physical function. As
4873  * not all devices support SR-IOV, the return code from the pci_enable_sriov()
4874  * API call does not considered as an error condition for most of the device.
4875  **/
4876 uint16_t
4877 lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *phba)
4878 {
4879         struct pci_dev *pdev = phba->pcidev;
4880         uint16_t nr_virtfn;
4881         int pos;
4882 
4883         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
4884         if (pos == 0)
4885                 return 0;
4886 
4887         pci_read_config_word(pdev, pos + PCI_SRIOV_TOTAL_VF, &nr_virtfn);
4888         return nr_virtfn;
4889 }
4890 
4891 /**
4892  * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
4893  * @phba: pointer to lpfc hba data structure.
4894  * @nr_vfn: number of virtual functions to be enabled.
4895  *
4896  * This function enables the PCI SR-IOV virtual functions to a physical
4897  * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
4898  * enable the number of virtual functions to the physical function. As
4899  * not all devices support SR-IOV, the return code from the pci_enable_sriov()
4900  * API call does not considered as an error condition for most of the device.
4901  **/
4902 int
4903 lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn)
4904 {
4905         struct pci_dev *pdev = phba->pcidev;
4906         uint16_t max_nr_vfn;
4907         int rc;
4908 
4909         max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);
4910         if (nr_vfn > max_nr_vfn) {
4911                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4912                                 "3057 Requested vfs (%d) greater than "
4913                                 "supported vfs (%d)", nr_vfn, max_nr_vfn);
4914                 return -EINVAL;
4915         }
4916 
4917         rc = pci_enable_sriov(pdev, nr_vfn);
4918         if (rc) {
4919                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
4920                                 "2806 Failed to enable sriov on this device "
4921                                 "with vfn number nr_vf:%d, rc:%d\n",
4922                                 nr_vfn, rc);
4923         } else
4924                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
4925                                 "2807 Successful enable sriov on this device "
4926                                 "with vfn number nr_vf:%d\n", nr_vfn);
4927         return rc;
4928 }
4929 
4930 /**
4931  * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev.
4932  * @phba: pointer to lpfc hba data structure.
4933  *
4934  * This routine is invoked to set up the driver internal resources specific to
4935  * support the SLI-3 HBA device it attached to.
4936  *
4937  * Return codes
4938  *      0 - successful
4939  *      other values - error
4940  **/
4941 static int
4942 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
4943 {
4944         struct lpfc_sli *psli;
4945         int rc;
4946 
4947         /*
4948          * Initialize timers used by driver
4949          */
4950 
4951         /* Heartbeat timer */
4952         init_timer(&phba->hb_tmofunc);
4953         phba->hb_tmofunc.function = lpfc_hb_timeout;
4954         phba->hb_tmofunc.data = (unsigned long)phba;
4955 
4956         psli = &phba->sli;
4957         /* MBOX heartbeat timer */
4958         init_timer(&psli->mbox_tmo);
4959         psli->mbox_tmo.function = lpfc_mbox_timeout;
4960         psli->mbox_tmo.data = (unsigned long) phba;
4961         /* FCP polling mode timer */
4962         init_timer(&phba->fcp_poll_timer);
4963         phba->fcp_poll_timer.function = lpfc_poll_timeout;
4964         phba->fcp_poll_timer.data = (unsigned long) phba;
4965         /* Fabric block timer */
4966         init_timer(&phba->fabric_block_timer);
4967         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
4968         phba->fabric_block_timer.data = (unsigned long) phba;
4969         /* EA polling mode timer */
4970         init_timer(&phba->eratt_poll);
4971         phba->eratt_poll.function = lpfc_poll_eratt;
4972         phba->eratt_poll.data = (unsigned long) phba;
4973 
4974         /* Host attention work mask setup */
4975         phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
4976         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
4977 
4978         /* Get all the module params for configuring this host */
4979         lpfc_get_cfgparam(phba);
4980         if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) {
4981                 phba->menlo_flag |= HBA_MENLO_SUPPORT;
4982                 /* check for menlo minimum sg count */
4983                 if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT)
4984                         phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT;
4985         }
4986 
4987         if (!phba->sli.ring)
4988                 phba->sli.ring = kzalloc(LPFC_SLI3_MAX_RING *
4989                         sizeof(struct lpfc_sli_ring), GFP_KERNEL);
4990         if (!phba->sli.ring)
4991                 return -ENOMEM;
4992 
4993         /*
4994          * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
4995          * used to create the sg_dma_buf_pool must be dynamically calculated.
4996          */
4997 
4998         /* Initialize the host templates the configured values. */
4999         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5000         lpfc_template_s3.sg_tablesize = phba->cfg_sg_seg_cnt;
5001 
5002         /* There are going to be 2 reserved BDEs: 1 FCP cmnd + 1 FCP rsp */
5003         if (phba->cfg_enable_bg) {
5004                 /*
5005                  * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
5006                  * the FCP rsp, and a BDE for each. Sice we have no control
5007                  * over how many protection data segments the SCSI Layer
5008                  * will hand us (ie: there could be one for every block
5009                  * in the IO), we just allocate enough BDEs to accomidate
5010                  * our max amount and we need to limit lpfc_sg_seg_cnt to
5011                  * minimize the risk of running out.
5012                  */
5013                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5014                         sizeof(struct fcp_rsp) +
5015                         (LPFC_MAX_SG_SEG_CNT * sizeof(struct ulp_bde64));
5016 
5017                 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SEG_CNT_DIF)
5018                         phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT_DIF;
5019 
5020                 /* Total BDEs in BPL for scsi_sg_list and scsi_sg_prot_list */
5021                 phba->cfg_total_seg_cnt = LPFC_MAX_SG_SEG_CNT;
5022         } else {
5023                 /*
5024                  * The scsi_buf for a regular I/O will hold the FCP cmnd,
5025                  * the FCP rsp, a BDE for each, and a BDE for up to
5026                  * cfg_sg_seg_cnt data segments.
5027                  */
5028                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5029                         sizeof(struct fcp_rsp) +
5030                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
5031 
5032                 /* Total BDEs in BPL for scsi_sg_list */
5033                 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
5034         }
5035 
5036         lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5037                         "9088 sg_tablesize:%d dmabuf_size:%d total_bde:%d\n",
5038                         phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5039                         phba->cfg_total_seg_cnt);
5040 
5041         phba->max_vpi = LPFC_MAX_VPI;
5042         /* This will be set to correct value after config_port mbox */
5043         phba->max_vports = 0;
5044 
5045         /*
5046          * Initialize the SLI Layer to run with lpfc HBAs.
5047          */
5048         lpfc_sli_setup(phba);
5049         lpfc_sli_queue_setup(phba);
5050 
5051         /* Allocate device driver memory */
5052         if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
5053                 return -ENOMEM;
5054 
5055         /*
5056          * Enable sr-iov virtual functions if supported and configured
5057          * through the module parameter.
5058          */
5059         if (phba->cfg_sriov_nr_virtfn > 0) {
5060                 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
5061                                                  phba->cfg_sriov_nr_virtfn);
5062                 if (rc) {
5063                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5064                                         "2808 Requested number of SR-IOV "
5065                                         "virtual functions (%d) is not "
5066                                         "supported\n",
5067                                         phba->cfg_sriov_nr_virtfn);
5068                         phba->cfg_sriov_nr_virtfn = 0;
5069                 }
5070         }
5071 
5072         return 0;
5073 }
5074 
5075 /**
5076  * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
5077  * @phba: pointer to lpfc hba data structure.
5078  *
5079  * This routine is invoked to unset the driver internal resources set up
5080  * specific for supporting the SLI-3 HBA device it attached to.
5081  **/
5082 static void
5083 lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
5084 {
5085         /* Free device driver memory allocated */
5086         lpfc_mem_free_all(phba);
5087 
5088         return;
5089 }
5090 
5091 /**
5092  * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
5093  * @phba: pointer to lpfc hba data structure.
5094  *
5095  * This routine is invoked to set up the driver internal resources specific to
5096  * support the SLI-4 HBA device it attached to.
5097  *
5098  * Return codes
5099  *      0 - successful
5100  *      other values - error
5101  **/
5102 static int
5103 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
5104 {
5105         struct lpfc_vector_map_info *cpup;
5106         struct lpfc_sli *psli;
5107         LPFC_MBOXQ_t *mboxq;
5108         int rc, i, hbq_count, max_buf_size;
5109         uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
5110         struct lpfc_mqe *mqe;
5111         int longs;
5112         int fof_vectors = 0;
5113 
5114         /* Get all the module params for configuring this host */
5115         lpfc_get_cfgparam(phba);
5116 
5117         /* Before proceed, wait for POST done and device ready */
5118         rc = lpfc_sli4_post_status_check(phba);
5119         if (rc)
5120                 return -ENODEV;
5121 
5122         /*
5123          * Initialize timers used by driver
5124          */
5125 
5126         /* Heartbeat timer */
5127         init_timer(&phba->hb_tmofunc);
5128         phba->hb_tmofunc.function = lpfc_hb_timeout;
5129         phba->hb_tmofunc.data = (unsigned long)phba;
5130         init_timer(&phba->rrq_tmr);
5131         phba->rrq_tmr.function = lpfc_rrq_timeout;
5132         phba->rrq_tmr.data = (unsigned long)phba;
5133 
5134         psli = &phba->sli;
5135         /* MBOX heartbeat timer */
5136         init_timer(&psli->mbox_tmo);
5137         psli->mbox_tmo.function = lpfc_mbox_timeout;
5138         psli->mbox_tmo.data = (unsigned long) phba;
5139         /* Fabric block timer */
5140         init_timer(&phba->fabric_block_timer);
5141         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
5142         phba->fabric_block_timer.data = (unsigned long) phba;
5143         /* EA polling mode timer */
5144         init_timer(&phba->eratt_poll);
5145         phba->eratt_poll.function = lpfc_poll_eratt;
5146         phba->eratt_poll.data = (unsigned long) phba;
5147         /* FCF rediscover timer */
5148         init_timer(&phba->fcf.redisc_wait);
5149         phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo;
5150         phba->fcf.redisc_wait.data = (unsigned long)phba;
5151 
5152         /*
5153          * Control structure for handling external multi-buffer mailbox
5154          * command pass-through.
5155          */
5156         memset((uint8_t *)&phba->mbox_ext_buf_ctx, 0,
5157                 sizeof(struct lpfc_mbox_ext_buf_ctx));
5158         INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
5159 
5160         phba->max_vpi = LPFC_MAX_VPI;
5161 
5162         /* This will be set to correct value after the read_config mbox */
5163         phba->max_vports = 0;
5164 
5165         /* Program the default value of vlan_id and fc_map */
5166         phba->valid_vlan = 0;
5167         phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
5168         phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
5169         phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
5170 
5171         /*
5172          * For SLI4, instead of using ring 0 (LPFC_FCP_RING) for FCP commands
5173          * we will associate a new ring, for each FCP fastpath EQ/CQ/WQ tuple.
5174          */
5175         if (!phba->sli.ring)
5176                 phba->sli.ring = kzalloc(
5177                         (LPFC_SLI3_MAX_RING + phba->cfg_fcp_io_channel) *
5178                         sizeof(struct lpfc_sli_ring), GFP_KERNEL);
5179         if (!phba->sli.ring)
5180                 return -ENOMEM;
5181 
5182         /*
5183          * It doesn't matter what family our adapter is in, we are
5184          * limited to 2 Pages, 512 SGEs, for our SGL.
5185          * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
5186          */
5187         max_buf_size = (2 * SLI4_PAGE_SIZE);
5188         if (phba->cfg_sg_seg_cnt > LPFC_MAX_SGL_SEG_CNT - 2)
5189                 phba->cfg_sg_seg_cnt = LPFC_MAX_SGL_SEG_CNT - 2;
5190 
5191         /*
5192          * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
5193          * used to create the sg_dma_buf_pool must be dynamically calculated.
5194          */
5195 
5196         if (phba->cfg_enable_bg) {
5197                 /*
5198                  * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
5199                  * the FCP rsp, and a SGE for each. Sice we have no control
5200                  * over how many protection data segments the SCSI Layer
5201                  * will hand us (ie: there could be one for every block
5202                  * in the IO), we just allocate enough SGEs to accomidate
5203                  * our max amount and we need to limit lpfc_sg_seg_cnt to
5204                  * minimize the risk of running out.
5205                  */
5206                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5207                         sizeof(struct fcp_rsp) + max_buf_size;
5208 
5209                 /* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
5210                 phba->cfg_total_seg_cnt = LPFC_MAX_SGL_SEG_CNT;
5211 
5212                 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SLI4_SEG_CNT_DIF)
5213                         phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SLI4_SEG_CNT_DIF;
5214         } else {
5215                 /*
5216                  * The scsi_buf for a regular I/O will hold the FCP cmnd,
5217                  * the FCP rsp, a SGE for each, and a SGE for up to
5218                  * cfg_sg_seg_cnt data segments.
5219                  */
5220                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5221                         sizeof(struct fcp_rsp) +
5222                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge));
5223 
5224                 /* Total SGEs for scsi_sg_list */
5225                 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
5226                 /*
5227                  * NOTE: if (phba->cfg_sg_seg_cnt + 2) <= 256 we only need
5228                  * to post 1 page for the SGL.
5229                  */
5230         }
5231 
5232         /* Initialize the host templates with the updated values. */
5233         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5234         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5235 
5236         if (phba->cfg_sg_dma_buf_size  <= LPFC_MIN_SG_SLI4_BUF_SZ)
5237                 phba->cfg_sg_dma_buf_size = LPFC_MIN_SG_SLI4_BUF_SZ;
5238         else
5239                 phba->cfg_sg_dma_buf_size =
5240                         SLI4_PAGE_ALIGN(phba->cfg_sg_dma_buf_size);
5241 
5242         lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5243                         "9087 sg_tablesize:%d dmabuf_size:%d total_sge:%d\n",
5244                         phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5245                         phba->cfg_total_seg_cnt);
5246 
5247         /* Initialize buffer queue management fields */
5248         hbq_count = lpfc_sli_hbq_count();
5249         for (i = 0; i < hbq_count; ++i)
5250                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
5251         INIT_LIST_HEAD(&phba->rb_pend_list);
5252         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc;
5253         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free;
5254 
5255         /*
5256          * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
5257          */
5258         /* Initialize the Abort scsi buffer list used by driver */
5259         spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock);
5260         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
5261         /* This abort list used by worker thread */
5262         spin_lock_init(&phba->sli4_hba.abts_sgl_list_lock);
5263 
5264         /*
5265          * Initialize driver internal slow-path work queues
5266          */
5267 
5268         /* Driver internel slow-path CQ Event pool */
5269         INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
5270         /* Response IOCB work queue list */
5271         INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
5272         /* Asynchronous event CQ Event work queue list */
5273         INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
5274         /* Fast-path XRI aborted CQ Event work queue list */
5275         INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
5276         /* Slow-path XRI aborted CQ Event work queue list */
5277         INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue);
5278         /* Receive queue CQ Event work queue list */
5279         INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
5280 
5281         /* Initialize extent block lists. */
5282         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_blk_list);
5283         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_xri_blk_list);
5284         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_vfi_blk_list);
5285         INIT_LIST_HEAD(&phba->lpfc_vpi_blk_list);
5286 
5287         /* initialize optic_state to 0xFF */
5288         phba->sli4_hba.lnk_info.optic_state = 0xff;
5289 
5290         /* Initialize the driver internal SLI layer lists. */
5291         lpfc_sli_setup(phba);
5292         lpfc_sli_queue_setup(phba);
5293 
5294         /* Allocate device driver memory */
5295         rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ);
5296         if (rc)
5297                 return -ENOMEM;
5298 
5299         /* IF Type 2 ports get initialized now. */
5300         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
5301             LPFC_SLI_INTF_IF_TYPE_2) {
5302                 rc = lpfc_pci_function_reset(phba);
5303                 if (unlikely(rc))
5304                         return -ENODEV;
5305                 phba->temp_sensor_support = 1;
5306         }
5307 
5308         /* Create the bootstrap mailbox command */
5309         rc = lpfc_create_bootstrap_mbox(phba);
5310         if (unlikely(rc))
5311                 goto out_free_mem;
5312 
5313         /* Set up the host's endian order with the device. */
5314         rc = lpfc_setup_endian_order(phba);
5315         if (unlikely(rc))
5316                 goto out_free_bsmbx;
5317 
5318         /* Set up the hba's configuration parameters. */
5319         rc = lpfc_sli4_read_config(phba);
5320         if (unlikely(rc))
5321                 goto out_free_bsmbx;
5322         rc = lpfc_mem_alloc_active_rrq_pool_s4(phba);
5323         if (unlikely(rc))
5324                 goto out_free_bsmbx;
5325 
5326         /* IF Type 0 ports get initialized now. */
5327         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
5328             LPFC_SLI_INTF_IF_TYPE_0) {
5329                 rc = lpfc_pci_function_reset(phba);
5330                 if (unlikely(rc))
5331                         goto out_free_bsmbx;
5332         }
5333 
5334         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
5335                                                        GFP_KERNEL);
5336         if (!mboxq) {
5337                 rc = -ENOMEM;
5338                 goto out_free_bsmbx;
5339         }
5340 
5341         /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */
5342         lpfc_supported_pages(mboxq);
5343         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5344         if (!rc) {
5345                 mqe = &mboxq->u.mqe;
5346                 memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
5347                        LPFC_MAX_SUPPORTED_PAGES);
5348                 for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
5349                         switch (pn_page[i]) {
5350                         case LPFC_SLI4_PARAMETERS:
5351                                 phba->sli4_hba.pc_sli4_params.supported = 1;
5352                                 break;
5353                         default:
5354                                 break;
5355                         }
5356                 }
5357                 /* Read the port's SLI4 Parameters capabilities if supported. */
5358                 if (phba->sli4_hba.pc_sli4_params.supported)
5359                         rc = lpfc_pc_sli4_params_get(phba, mboxq);
5360                 if (rc) {
5361                         mempool_free(mboxq, phba->mbox_mem_pool);
5362                         rc = -EIO;
5363                         goto out_free_bsmbx;
5364                 }
5365         }
5366         /*
5367          * Get sli4 parameters that override parameters from Port capabilities.
5368          * If this call fails, it isn't critical unless the SLI4 parameters come
5369          * back in conflict.
5370          */
5371         rc = lpfc_get_sli4_parameters(phba, mboxq);
5372         if (rc) {
5373                 if (phba->sli4_hba.extents_in_use &&
5374                     phba->sli4_hba.rpi_hdrs_in_use) {
5375                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5376                                 "2999 Unsupported SLI4 Parameters "
5377                                 "Extents and RPI headers enabled.\n");
5378                         goto out_free_bsmbx;
5379                 }
5380         }
5381         mempool_free(mboxq, phba->mbox_mem_pool);
5382 
5383         /* Verify OAS is supported */
5384         lpfc_sli4_oas_verify(phba);
5385         if (phba->cfg_fof)
5386                 fof_vectors = 1;
5387 
5388         /* Verify all the SLI4 queues */
5389         rc = lpfc_sli4_queue_verify(phba);
5390         if (rc)
5391                 goto out_free_bsmbx;
5392 
5393         /* Create driver internal CQE event pool */
5394         rc = lpfc_sli4_cq_event_pool_create(phba);
5395         if (rc)
5396                 goto out_free_bsmbx;
5397 
5398         /* Initialize sgl lists per host */
5399         lpfc_init_sgl_list(phba);
5400 
5401         /* Allocate and initialize active sgl array */
5402         rc = lpfc_init_active_sgl_array(phba);
5403         if (rc) {
5404                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5405                                 "1430 Failed to initialize sgl list.\n");
5406                 goto out_destroy_cq_event_pool;
5407         }
5408         rc = lpfc_sli4_init_rpi_hdrs(phba);
5409         if (rc) {
5410                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5411                                 "1432 Failed to initialize rpi headers.\n");
5412                 goto out_free_active_sgl;
5413         }
5414 
5415         /* Allocate eligible FCF bmask memory for FCF roundrobin failover */
5416         longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;
5417         phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long),
5418                                          GFP_KERNEL);
5419         if (!phba->fcf.fcf_rr_bmask) {
5420                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5421                                 "2759 Failed allocate memory for FCF round "
5422                                 "robin failover bmask\n");
5423                 rc = -ENOMEM;
5424                 goto out_remove_rpi_hdrs;
5425         }
5426 
5427         phba->sli4_hba.fcp_eq_hdl =
5428                         kzalloc((sizeof(struct lpfc_fcp_eq_hdl) *
5429                             (fof_vectors + phba->cfg_fcp_io_channel)),
5430                             GFP_KERNEL);
5431         if (!phba->sli4_hba.fcp_eq_hdl) {
5432                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5433                                 "2572 Failed allocate memory for "
5434                                 "fast-path per-EQ handle array\n");
5435                 rc = -ENOMEM;
5436                 goto out_free_fcf_rr_bmask;
5437         }
5438 
5439         phba->sli4_hba.msix_entries = kzalloc((sizeof(struct msix_entry) *
5440                                   (fof_vectors +
5441                                    phba->cfg_fcp_io_channel)), GFP_KERNEL);
5442         if (!phba->sli4_hba.msix_entries) {
5443                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5444                                 "2573 Failed allocate memory for msi-x "
5445                                 "interrupt vector entries\n");
5446                 rc = -ENOMEM;
5447                 goto out_free_fcp_eq_hdl;
5448         }
5449 
5450         phba->sli4_hba.cpu_map = kzalloc((sizeof(struct lpfc_vector_map_info) *
5451                                          phba->sli4_hba.num_present_cpu),
5452                                          GFP_KERNEL);
5453         if (!phba->sli4_hba.cpu_map) {
5454                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5455                                 "3327 Failed allocate memory for msi-x "
5456                                 "interrupt vector mapping\n");
5457                 rc = -ENOMEM;
5458                 goto out_free_msix;
5459         }
5460         if (lpfc_used_cpu == NULL) {
5461                 lpfc_used_cpu = kzalloc((sizeof(uint16_t) * lpfc_present_cpu),
5462                                          GFP_KERNEL);
5463                 if (!lpfc_used_cpu) {
5464                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5465                                         "3335 Failed allocate memory for msi-x "
5466                                         "interrupt vector mapping\n");
5467                         kfree(phba->sli4_hba.cpu_map);
5468                         rc = -ENOMEM;
5469                         goto out_free_msix;
5470                 }
5471                 for (i = 0; i < lpfc_present_cpu; i++)
5472                         lpfc_used_cpu[i] = LPFC_VECTOR_MAP_EMPTY;
5473         }
5474 
5475         /* Initialize io channels for round robin */
5476         cpup = phba->sli4_hba.cpu_map;
5477         rc = 0;
5478         for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
5479                 cpup->channel_id = rc;
5480                 rc++;
5481                 if (rc >= phba->cfg_fcp_io_channel)
5482                         rc = 0;
5483         }
5484 
5485         /*
5486          * Enable sr-iov virtual functions if supported and configured
5487          * through the module parameter.
5488          */
5489         if (phba->cfg_sriov_nr_virtfn > 0) {
5490                 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
5491                                                  phba->cfg_sriov_nr_virtfn);
5492                 if (rc) {
5493                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5494                                         "3020 Requested number of SR-IOV "
5495                                         "virtual functions (%d) is not "
5496                                         "supported\n",
5497                                         phba->cfg_sriov_nr_virtfn);
5498                         phba->cfg_sriov_nr_virtfn = 0;
5499                 }
5500         }
5501 
5502         return 0;
5503 
5504 out_free_msix:
5505         kfree(phba->sli4_hba.msix_entries);
5506 out_free_fcp_eq_hdl:
5507         kfree(phba->sli4_hba.fcp_eq_hdl);
5508 out_free_fcf_rr_bmask:
5509         kfree(phba->fcf.fcf_rr_bmask);
5510 out_remove_rpi_hdrs:
5511         lpfc_sli4_remove_rpi_hdrs(phba);
5512 out_free_active_sgl:
5513         lpfc_free_active_sgl(phba);
5514 out_destroy_cq_event_pool:
5515         lpfc_sli4_cq_event_pool_destroy(phba);
5516 out_free_bsmbx:
5517         lpfc_destroy_bootstrap_mbox(phba);
5518 out_free_mem:
5519         lpfc_mem_free(phba);
5520         return rc;
5521 }
5522 
5523 /**
5524  * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
5525  * @phba: pointer to lpfc hba data structure.
5526  *
5527  * This routine is invoked to unset the driver internal resources set up
5528  * specific for supporting the SLI-4 HBA device it attached to.
5529  **/
5530 static void
5531 lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
5532 {
5533         struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
5534 
5535         /* Free memory allocated for msi-x interrupt vector to CPU mapping */
5536         kfree(phba->sli4_hba.cpu_map);
5537         phba->sli4_hba.num_present_cpu = 0;
5538         phba->sli4_hba.num_online_cpu = 0;
5539         phba->sli4_hba.curr_disp_cpu = 0;
5540 
5541         /* Free memory allocated for msi-x interrupt vector entries */
5542         kfree(phba->sli4_hba.msix_entries);
5543 
5544         /* Free memory allocated for fast-path work queue handles */
5545         kfree(phba->sli4_hba.fcp_eq_hdl);
5546 
5547         /* Free the allocated rpi headers. */
5548         lpfc_sli4_remove_rpi_hdrs(phba);
5549         lpfc_sli4_remove_rpis(phba);
5550 
5551         /* Free eligible FCF index bmask */
5552         kfree(phba->fcf.fcf_rr_bmask);
5553 
5554         /* Free the ELS sgl list */
5555         lpfc_free_active_sgl(phba);
5556         lpfc_free_els_sgl_list(phba);
5557 
5558         /* Free the completion queue EQ event pool */
5559         lpfc_sli4_cq_event_release_all(phba);
5560         lpfc_sli4_cq_event_pool_destroy(phba);
5561 
5562         /* Release resource identifiers. */
5563         lpfc_sli4_dealloc_resource_identifiers(phba);
5564 
5565         /* Free the bsmbx region. */
5566         lpfc_destroy_bootstrap_mbox(phba);
5567 
5568         /* Free the SLI Layer memory with SLI4 HBAs */
5569         lpfc_mem_free_all(phba);
5570 
5571         /* Free the current connect table */
5572         list_for_each_entry_safe(conn_entry, next_conn_entry,
5573                 &phba->fcf_conn_rec_list, list) {
5574                 list_del_init(&conn_entry->list);
5575                 kfree(conn_entry);
5576         }
5577 
5578         return;
5579 }
5580 
5581 /**
5582  * lpfc_init_api_table_setup - Set up init api function jump table
5583  * @phba: The hba struct for which this call is being executed.
5584  * @dev_grp: The HBA PCI-Device group number.
5585  *
5586  * This routine sets up the device INIT interface API function jump table
5587  * in @phba struct.
5588  *
5589  * Returns: 0 - success, -ENODEV - failure.
5590  **/
5591 int
5592 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
5593 {
5594         phba->lpfc_hba_init_link = lpfc_hba_init_link;
5595         phba->lpfc_hba_down_link = lpfc_hba_down_link;
5596         phba->lpfc_selective_reset = lpfc_selective_reset;
5597         switch (dev_grp) {
5598         case LPFC_PCI_DEV_LP:
5599                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
5600                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
5601                 phba->lpfc_stop_port = lpfc_stop_port_s3;
5602                 break;
5603         case LPFC_PCI_DEV_OC:
5604                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s4;
5605                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s4;
5606                 phba->lpfc_stop_port = lpfc_stop_port_s4;
5607                 break;
5608         default:
5609                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5610                                 "1431 Invalid HBA PCI-device group: 0x%x\n",
5611                                 dev_grp);
5612                 return -ENODEV;
5613                 break;
5614         }
5615         return 0;
5616 }
5617 
5618 /**
5619  * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
5620  * @phba: pointer to lpfc hba data structure.
5621  *
5622  * This routine is invoked to set up the driver internal resources before the
5623  * device specific resource setup to support the HBA device it attached to.
5624  *
5625  * Return codes
5626  *      0 - successful
5627  *      other values - error
5628  **/
5629 static int
5630 lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
5631 {
5632         /*
5633          * Driver resources common to all SLI revisions
5634          */
5635         atomic_set(&phba->fast_event_count, 0);
5636         spin_lock_init(&phba->hbalock);
5637 
5638         /* Initialize ndlp management spinlock */
5639         spin_lock_init(&phba->ndlp_lock);
5640 
5641         INIT_LIST_HEAD(&phba->port_list);
5642         INIT_LIST_HEAD(&phba->work_list);
5643         init_waitqueue_head(&phba->wait_4_mlo_m_q);
5644 
5645         /* Initialize the wait queue head for the kernel thread */
5646         init_waitqueue_head(&phba->work_waitq);
5647 
5648         /* Initialize the scsi buffer list used by driver for scsi IO */
5649         spin_lock_init(&phba->scsi_buf_list_get_lock);
5650         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_get);
5651         spin_lock_init(&phba->scsi_buf_list_put_lock);
5652         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
5653 
5654         /* Initialize the fabric iocb list */
5655         INIT_LIST_HEAD(&phba->fabric_iocb_list);
5656 
5657         /* Initialize list to save ELS buffers */
5658         INIT_LIST_HEAD(&phba->elsbuf);
5659 
5660         /* Initialize FCF connection rec list */
5661         INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
5662 
5663         /* Initialize OAS configuration list */
5664         spin_lock_init(&phba->devicelock);
5665         INIT_LIST_HEAD(&phba->luns);
5666 
5667         return 0;
5668 }
5669 
5670 /**
5671  * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
5672  * @phba: pointer to lpfc hba data structure.
5673  *
5674  * This routine is invoked to set up the driver internal resources after the
5675  * device specific resource setup to support the HBA device it attached to.
5676  *
5677  * Return codes
5678  *      0 - successful
5679  *      other values - error
5680  **/
5681 static int
5682 lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
5683 {
5684         int error;
5685 
5686         /* Startup the kernel thread for this host adapter. */
5687         phba->worker_thread = kthread_run(lpfc_do_work, phba,
5688                                           "lpfc_worker_%d", phba->brd_no);
5689         if (IS_ERR(phba->worker_thread)) {
5690                 error = PTR_ERR(phba->worker_thread);
5691                 return error;
5692         }
5693 
5694         return 0;
5695 }
5696 
5697 /**
5698  * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
5699  * @phba: pointer to lpfc hba data structure.
5700  *
5701  * This routine is invoked to unset the driver internal resources set up after
5702  * the device specific resource setup for supporting the HBA device it
5703  * attached to.
5704  **/
5705 static void
5706 lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
5707 {
5708         /* Stop kernel worker thread */
5709         kthread_stop(phba->worker_thread);
5710 }
5711 
5712 /**
5713  * lpfc_free_iocb_list - Free iocb list.
5714  * @phba: pointer to lpfc hba data structure.
5715  *
5716  * This routine is invoked to free the driver's IOCB list and memory.
5717  **/
5718 static void
5719 lpfc_free_iocb_list(struct lpfc_hba *phba)
5720 {
5721         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
5722 
5723         spin_lock_irq(&phba->hbalock);
5724         list_for_each_entry_safe(iocbq_entry, iocbq_next,
5725                                  &phba->lpfc_iocb_list, list) {
5726                 list_del(&iocbq_entry->list);
5727                 kfree(iocbq_entry);
5728                 phba->total_iocbq_bufs--;
5729         }
5730         spin_unlock_irq(&phba->hbalock);
5731 
5732         return;
5733 }
5734 
5735 /**
5736  * lpfc_init_iocb_list - Allocate and initialize iocb list.
5737  * @phba: pointer to lpfc hba data structure.
5738  *
5739  * This routine is invoked to allocate and initizlize the driver's IOCB
5740  * list and set up the IOCB tag array accordingly.
5741  *
5742  * Return codes
5743  *      0 - successful
5744  *      other values - error
5745  **/
5746 static int
5747 lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
5748 {
5749         struct lpfc_iocbq *iocbq_entry = NULL;
5750         uint16_t iotag;
5751         int i;
5752 
5753         /* Initialize and populate the iocb list per host.  */
5754         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
5755         for (i = 0; i < iocb_count; i++) {
5756                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
5757                 if (iocbq_entry == NULL) {
5758                         printk(KERN_ERR "%s: only allocated %d iocbs of "
5759                                 "expected %d count. Unloading driver.\n",
5760                                 __func__, i, LPFC_IOCB_LIST_CNT);
5761                         goto out_free_iocbq;
5762                 }
5763 
5764                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
5765                 if (iotag == 0) {
5766                         kfree(iocbq_entry);
5767                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
5768                                 "Unloading driver.\n", __func__);
5769                         goto out_free_iocbq;
5770                 }
5771                 iocbq_entry->sli4_lxritag = NO_XRI;
5772                 iocbq_entry->sli4_xritag = NO_XRI;
5773 
5774                 spin_lock_irq(&phba->hbalock);
5775                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
5776                 phba->total_iocbq_bufs++;
5777                 spin_unlock_irq(&phba->hbalock);
5778         }
5779 
5780         return 0;
5781 
5782 out_free_iocbq:
5783         lpfc_free_iocb_list(phba);
5784 
5785         return -ENOMEM;
5786 }
5787 
5788 /**
5789  * lpfc_free_sgl_list - Free a given sgl list.
5790  * @phba: pointer to lpfc hba data structure.
5791  * @sglq_list: pointer to the head of sgl list.
5792  *
5793  * This routine is invoked to free a give sgl list and memory.
5794  **/
5795 void
5796 lpfc_free_sgl_list(struct lpfc_hba *phba, struct list_head *sglq_list)
5797 {
5798         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
5799 
5800         list_for_each_entry_safe(sglq_entry, sglq_next, sglq_list, list) {
5801                 list_del(&sglq_entry->list);
5802                 lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
5803                 kfree(sglq_entry);
5804         }
5805 }
5806 
5807 /**
5808  * lpfc_free_els_sgl_list - Free els sgl list.
5809  * @phba: pointer to lpfc hba data structure.
5810  *
5811  * This routine is invoked to free the driver's els sgl list and memory.
5812  **/
5813 static void
5814 lpfc_free_els_sgl_list(struct lpfc_hba *phba)
5815 {
5816         LIST_HEAD(sglq_list);
5817         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
5818 
5819         /* Retrieve all els sgls from driver list */
5820         spin_lock_irq(&phba->hbalock);
5821         spin_lock(&pring->ring_lock);
5822         list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &sglq_list);
5823         spin_unlock(&pring->ring_lock);
5824         spin_unlock_irq(&phba->hbalock);
5825 
5826         /* Now free the sgl list */
5827         lpfc_free_sgl_list(phba, &sglq_list);
5828 }
5829 
5830 /**
5831  * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
5832  * @phba: pointer to lpfc hba data structure.
5833  *
5834  * This routine is invoked to allocate the driver's active sgl memory.
5835  * This array will hold the sglq_entry's for active IOs.
5836  **/
5837 static int
5838 lpfc_init_active_sgl_array(struct lpfc_hba *phba)
5839 {
5840         int size;
5841         size = sizeof(struct lpfc_sglq *);
5842         size *= phba->sli4_hba.max_cfg_param.max_xri;
5843 
5844         phba->sli4_hba.lpfc_sglq_active_list =
5845                 kzalloc(size, GFP_KERNEL);
5846         if (!phba->sli4_hba.lpfc_sglq_active_list)
5847                 return -ENOMEM;
5848         return 0;
5849 }
5850 
5851 /**
5852  * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
5853  * @phba: pointer to lpfc hba data structure.
5854  *
5855  * This routine is invoked to walk through the array of active sglq entries
5856  * and free all of the resources.
5857  * This is just a place holder for now.
5858  **/
5859 static void
5860 lpfc_free_active_sgl(struct lpfc_hba *phba)
5861 {
5862         kfree(phba->sli4_hba.lpfc_sglq_active_list);
5863 }
5864 
5865 /**
5866  * lpfc_init_sgl_list - Allocate and initialize sgl list.
5867  * @phba: pointer to lpfc hba data structure.
5868  *
5869  * This routine is invoked to allocate and initizlize the driver's sgl
5870  * list and set up the sgl xritag tag array accordingly.
5871  *
5872  **/
5873 static void
5874 lpfc_init_sgl_list(struct lpfc_hba *phba)
5875 {
5876         /* Initialize and populate the sglq list per host/VF. */
5877         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list);
5878         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
5879 
5880         /* els xri-sgl book keeping */
5881         phba->sli4_hba.els_xri_cnt = 0;
5882 
5883         /* scsi xri-buffer book keeping */
5884         phba->sli4_hba.scsi_xri_cnt = 0;
5885 }
5886 
5887 /**
5888  * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
5889  * @phba: pointer to lpfc hba data structure.
5890  *
5891  * This routine is invoked to post rpi header templates to the
5892  * port for those SLI4 ports that do not support extents.  This routine
5893  * posts a PAGE_SIZE memory region to the port to hold up to
5894  * PAGE_SIZE modulo 64 rpi context headers.  This is an initialization routine
5895  * and should be called only when interrupts are disabled.
5896  *
5897  * Return codes
5898  *      0 - successful
5899  *      -ERROR - otherwise.
5900  **/
5901 int
5902 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
5903 {
5904         int rc = 0;
5905         struct lpfc_rpi_hdr *rpi_hdr;
5906 
5907         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
5908         if (!phba->sli4_hba.rpi_hdrs_in_use)
5909                 return rc;
5910         if (phba->sli4_hba.extents_in_use)
5911                 return -EIO;
5912 
5913         rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
5914         if (!rpi_hdr) {
5915                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
5916                                 "0391 Error during rpi post operation\n");
5917                 lpfc_sli4_remove_rpis(phba);
5918                 rc = -ENODEV;
5919         }
5920 
5921         return rc;
5922 }
5923 
5924 /**
5925  * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
5926  * @phba: pointer to lpfc hba data structure.
5927  *
5928  * This routine is invoked to allocate a single 4KB memory region to
5929  * support rpis and stores them in the phba.  This single region
5930  * provides support for up to 64 rpis.  The region is used globally
5931  * by the device.
5932  *
5933  * Returns:
5934  *   A valid rpi hdr on success.
5935  *   A NULL pointer on any failure.
5936  **/
5937 struct lpfc_rpi_hdr *
5938 lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
5939 {
5940         uint16_t rpi_limit, curr_rpi_range;
5941         struct lpfc_dmabuf *dmabuf;
5942         struct lpfc_rpi_hdr *rpi_hdr;
5943         uint32_t rpi_count;
5944 
5945         /*
5946          * If the SLI4 port supports extents, posting the rpi header isn't
5947          * required.  Set the expected maximum count and let the actual value
5948          * get set when extents are fully allocated.
5949          */
5950         if (!phba->sli4_hba.rpi_hdrs_in_use)
5951                 return NULL;
5952         if (phba->sli4_hba.extents_in_use)
5953                 return NULL;
5954 
5955         /* The limit on the logical index is just the max_rpi count. */
5956         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
5957         phba->sli4_hba.max_cfg_param.max_rpi - 1;
5958 
5959         spin_lock_irq(&phba->hbalock);
5960         /*
5961          * Establish the starting RPI in this header block.  The starting
5962          * rpi is normalized to a zero base because the physical rpi is
5963          * port based.
5964          */
5965         curr_rpi_range = phba->sli4_hba.next_rpi;
5966         spin_unlock_irq(&phba->hbalock);
5967 
5968         /*
5969          * The port has a limited number of rpis. The increment here
5970          * is LPFC_RPI_HDR_COUNT - 1 to account for the starting value
5971          * and to allow the full max_rpi range per port.
5972          */
5973         if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
5974                 rpi_count = rpi_limit - curr_rpi_range;
5975         else
5976                 rpi_count = LPFC_RPI_HDR_COUNT;
5977 
5978         if (!rpi_count)
5979                 return NULL;
5980         /*
5981          * First allocate the protocol header region for the port.  The
5982          * port expects a 4KB DMA-mapped memory region that is 4K aligned.
5983          */
5984         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
5985         if (!dmabuf)
5986                 return NULL;
5987 
5988         dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
5989                                            LPFC_HDR_TEMPLATE_SIZE,
5990                                            &dmabuf->phys, GFP_KERNEL);
5991         if (!dmabuf->virt) {
5992                 rpi_hdr = NULL;
5993                 goto err_free_dmabuf;
5994         }
5995 
5996         if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) {
5997                 rpi_hdr = NULL;
5998                 goto err_free_coherent;
5999         }
6000 
6001         /* Save the rpi header data for cleanup later. */
6002         rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL);
6003         if (!rpi_hdr)
6004                 goto err_free_coherent;
6005 
6006         rpi_hdr->dmabuf = dmabuf;
6007         rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
6008         rpi_hdr->page_count = 1;
6009         spin_lock_irq(&phba->hbalock);
6010 
6011         /* The rpi_hdr stores the logical index only. */
6012         rpi_hdr->start_rpi = curr_rpi_range;
6013         list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
6014 
6015         /*
6016          * The next_rpi stores the next logical module-64 rpi value used
6017          * to post physical rpis in subsequent rpi postings.
6018          */
6019         phba->sli4_hba.next_rpi += rpi_count;
6020         spin_unlock_irq(&phba->hbalock);
6021         return rpi_hdr;
6022 
6023  err_free_coherent:
6024         dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE,
6025                           dmabuf->virt, dmabuf->phys);
6026  err_free_dmabuf:
6027         kfree(dmabuf);
6028         return NULL;
6029 }
6030 
6031 /**
6032  * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
6033  * @phba: pointer to lpfc hba data structure.
6034  *
6035  * This routine is invoked to remove all memory resources allocated
6036  * to support rpis for SLI4 ports not supporting extents. This routine
6037  * presumes the caller has released all rpis consumed by fabric or port
6038  * logins and is prepared to have the header pages removed.
6039  **/
6040 void
6041 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
6042 {
6043         struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
6044 
6045         if (!phba->sli4_hba.rpi_hdrs_in_use)
6046                 goto exit;
6047 
6048         list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
6049                                  &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
6050                 list_del(&rpi_hdr->list);
6051                 dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len,
6052                                   rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys);
6053                 kfree(rpi_hdr->dmabuf);
6054                 kfree(rpi_hdr);
6055         }
6056  exit:
6057         /* There are no rpis available to the port now. */
6058         phba->sli4_hba.next_rpi = 0;
6059 }
6060 
6061 /**
6062  * lpfc_hba_alloc - Allocate driver hba data structure for a device.
6063  * @pdev: pointer to pci device data structure.
6064  *
6065  * This routine is invoked to allocate the driver hba data structure for an
6066  * HBA device. If the allocation is successful, the phba reference to the
6067  * PCI device data structure is set.
6068  *
6069  * Return codes
6070  *      pointer to @phba - successful
6071  *      NULL - error
6072  **/
6073 static struct lpfc_hba *
6074 lpfc_hba_alloc(struct pci_dev *pdev)
6075 {
6076         struct lpfc_hba *phba;
6077 
6078         /* Allocate memory for HBA structure */
6079         phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
6080         if (!phba) {
6081                 dev_err(&pdev->dev, "failed to allocate hba struct\n");
6082                 return NULL;
6083         }
6084 
6085         /* Set reference to PCI device in HBA structure */
6086         phba->pcidev = pdev;
6087 
6088         /* Assign an unused board number */
6089         phba->brd_no = lpfc_get_instance();
6090         if (phba->brd_no < 0) {
6091                 kfree(phba);
6092                 return NULL;
6093         }
6094 
6095         spin_lock_init(&phba->ct_ev_lock);
6096         INIT_LIST_HEAD(&phba->ct_ev_waiters);
6097 
6098         return phba;
6099 }
6100 
6101 /**
6102  * lpfc_hba_free - Free driver hba data structure with a device.
6103  * @phba: pointer to lpfc hba data structure.
6104  *
6105  * This routine is invoked to free the driver hba data structure with an
6106  * HBA device.
6107  **/
6108 static void
6109 lpfc_hba_free(struct lpfc_hba *phba)
6110 {
6111         /* Release the driver assigned board number */
6112         idr_remove(&lpfc_hba_index, phba->brd_no);
6113 
6114         /* Free memory allocated with sli rings */
6115         kfree(phba->sli.ring);
6116         phba->sli.ring = NULL;
6117 
6118         kfree(phba);
6119         return;
6120 }
6121 
6122 /**
6123  * lpfc_create_shost - Create hba physical port with associated scsi host.
6124  * @phba: pointer to lpfc hba data structure.
6125  *
6126  * This routine is invoked to create HBA physical port and associate a SCSI
6127  * host with it.
6128  *
6129  * Return codes
6130  *      0 - successful
6131  *      other values - error
6132  **/
6133 static int
6134 lpfc_create_shost(struct lpfc_hba *phba)
6135 {
6136         struct lpfc_vport *vport;
6137         struct Scsi_Host  *shost;
6138 
6139         /* Initialize HBA FC structure */
6140         phba->fc_edtov = FF_DEF_EDTOV;
6141         phba->fc_ratov = FF_DEF_RATOV;
6142         phba->fc_altov = FF_DEF_ALTOV;
6143         phba->fc_arbtov = FF_DEF_ARBTOV;
6144 
6145         atomic_set(&phba->sdev_cnt, 0);
6146         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
6147         if (!vport)
6148                 return -ENODEV;
6149 
6150         shost = lpfc_shost_from_vport(vport);
6151         phba->pport = vport;
6152         lpfc_debugfs_initialize(vport);
6153         /* Put reference to SCSI host to driver's device private data */
6154         pci_set_drvdata(phba->pcidev, shost);
6155 
6156         /*
6157          * At this point we are fully registered with PSA. In addition,
6158          * any initial discovery should be completed.
6159          */
6160         vport->load_flag |= FC_ALLOW_FDMI;
6161         if (phba->cfg_enable_SmartSAN ||
6162             (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
6163 
6164                 /* Setup appropriate attribute masks */
6165                 vport->fdmi_hba_mask = LPFC_FDMI2_HBA_ATTR;
6166                 if (phba->cfg_enable_SmartSAN)
6167                         vport->fdmi_port_mask = LPFC_FDMI2_SMART_ATTR;
6168                 else
6169                         vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
6170         }
6171         return 0;
6172 }
6173 
6174 /**
6175  * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
6176  * @phba: pointer to lpfc hba data structure.
6177  *
6178  * This routine is invoked to destroy HBA physical port and the associated
6179  * SCSI host.
6180  **/
6181 static void
6182 lpfc_destroy_shost(struct lpfc_hba *phba)
6183 {
6184         struct lpfc_vport *vport = phba->pport;
6185 
6186         /* Destroy physical port that associated with the SCSI host */
6187         destroy_port(vport);
6188 
6189         return;
6190 }
6191 
6192 /**
6193  * lpfc_setup_bg - Setup Block guard structures and debug areas.
6194  * @phba: pointer to lpfc hba data structure.
6195  * @shost: the shost to be used to detect Block guard settings.
6196  *
6197  * This routine sets up the local Block guard protocol settings for @shost.
6198  * This routine also allocates memory for debugging bg buffers.
6199  **/
6200 static void
6201 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
6202 {
6203         uint32_t old_mask;
6204         uint32_t old_guard;
6205 
6206         int pagecnt = 10;
6207         if (lpfc_prot_mask && lpfc_prot_guard) {
6208                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6209                                 "1478 Registering BlockGuard with the "
6210                                 "SCSI layer\n");
6211 
6212                 old_mask = lpfc_prot_mask;
6213                 old_guard = lpfc_prot_guard;
6214 
6215                 /* Only allow supported values */
6216                 lpfc_prot_mask &= (SHOST_DIF_TYPE1_PROTECTION |
6217                         SHOST_DIX_TYPE0_PROTECTION |
6218                         SHOST_DIX_TYPE1_PROTECTION);
6219                 lpfc_prot_guard &= (SHOST_DIX_GUARD_IP | SHOST_DIX_GUARD_CRC);
6220 
6221                 /* DIF Type 1 protection for profiles AST1/C1 is end to end */
6222                 if (lpfc_prot_mask == SHOST_DIX_TYPE1_PROTECTION)
6223                         lpfc_prot_mask |= SHOST_DIF_TYPE1_PROTECTION;
6224 
6225                 if (lpfc_prot_mask && lpfc_prot_guard) {
6226                         if ((old_mask != lpfc_prot_mask) ||
6227                                 (old_guard != lpfc_prot_guard))
6228                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6229                                         "1475 Registering BlockGuard with the "
6230                                         "SCSI layer: mask %d  guard %d\n",
6231                                         lpfc_prot_mask, lpfc_prot_guard);
6232 
6233                         scsi_host_set_prot(shost, lpfc_prot_mask);
6234                         scsi_host_set_guard(shost, lpfc_prot_guard);
6235                 } else
6236                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6237                                 "1479 Not Registering BlockGuard with the SCSI "
6238                                 "layer, Bad protection parameters: %d %d\n",
6239                                 old_mask, old_guard);
6240         }
6241 
6242         if (!_dump_buf_data) {
6243                 while (pagecnt) {
6244                         spin_lock_init(&_dump_buf_lock);
6245                         _dump_buf_data =
6246                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
6247                         if (_dump_buf_data) {
6248                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6249                                         "9043 BLKGRD: allocated %d pages for "
6250                                        "_dump_buf_data at 0x%p\n",
6251                                        (1 << pagecnt), _dump_buf_data);
6252                                 _dump_buf_data_order = pagecnt;
6253                                 memset(_dump_buf_data, 0,
6254                                        ((1 << PAGE_SHIFT) << pagecnt));
6255                                 break;
6256                         } else
6257                                 --pagecnt;
6258                 }
6259                 if (!_dump_buf_data_order)
6260                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6261                                 "9044 BLKGRD: ERROR unable to allocate "
6262                                "memory for hexdump\n");
6263         } else
6264                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6265                         "9045 BLKGRD: already allocated _dump_buf_data=0x%p"
6266                        "\n", _dump_buf_data);
6267         if (!_dump_buf_dif) {
6268                 while (pagecnt) {
6269                         _dump_buf_dif =
6270                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
6271                         if (_dump_buf_dif) {
6272                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6273                                         "9046 BLKGRD: allocated %d pages for "
6274                                        "_dump_buf_dif at 0x%p\n",
6275                                        (1 << pagecnt), _dump_buf_dif);
6276                                 _dump_buf_dif_order = pagecnt;
6277                                 memset(_dump_buf_dif, 0,
6278                                        ((1 << PAGE_SHIFT) << pagecnt));
6279                                 break;
6280                         } else
6281                                 --pagecnt;
6282                 }
6283                 if (!_dump_buf_dif_order)
6284                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6285                         "9047 BLKGRD: ERROR unable to allocate "
6286                                "memory for hexdump\n");
6287         } else
6288                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6289                         "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
6290                        _dump_buf_dif);
6291 }
6292 
6293 /**
6294  * lpfc_post_init_setup - Perform necessary device post initialization setup.
6295  * @phba: pointer to lpfc hba data structure.
6296  *
6297  * This routine is invoked to perform all the necessary post initialization
6298  * setup for the device.
6299  **/
6300 static void
6301 lpfc_post_init_setup(struct lpfc_hba *phba)
6302 {
6303         struct Scsi_Host  *shost;
6304         struct lpfc_adapter_event_header adapter_event;
6305 
6306         /* Get the default values for Model Name and Description */
6307         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
6308 
6309         /*
6310          * hba setup may have changed the hba_queue_depth so we need to
6311          * adjust the value of can_queue.
6312          */
6313         shost = pci_get_drvdata(phba->pcidev);
6314         shost->can_queue = phba->cfg_hba_queue_depth - 10;
6315         if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
6316                 lpfc_setup_bg(phba, shost);
6317 
6318         lpfc_host_attrib_init(shost);
6319 
6320         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
6321                 spin_lock_irq(shost->host_lock);
6322                 lpfc_poll_start_timer(phba);
6323                 spin_unlock_irq(shost->host_lock);
6324         }
6325 
6326         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6327                         "0428 Perform SCSI scan\n");
6328         /* Send board arrival event to upper layer */
6329         adapter_event.event_type = FC_REG_ADAPTER_EVENT;
6330         adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
6331         fc_host_post_vendor_event(shost, fc_get_event_number(),
6332                                   sizeof(adapter_event),
6333                                   (char *) &adapter_event,
6334                                   LPFC_NL_VENDOR_ID);
6335         return;
6336 }
6337 
6338 /**
6339  * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
6340  * @phba: pointer to lpfc hba data structure.
6341  *
6342  * This routine is invoked to set up the PCI device memory space for device
6343  * with SLI-3 interface spec.
6344  *
6345  * Return codes
6346  *      0 - successful
6347  *      other values - error
6348  **/
6349 static int
6350 lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
6351 {
6352         struct pci_dev *pdev;
6353         unsigned long bar0map_len, bar2map_len;
6354         int i, hbq_count;
6355         void *ptr;
6356         int error = -ENODEV;
6357 
6358         /* Obtain PCI device reference */
6359         if (!phba->pcidev)
6360                 return error;
6361         else
6362                 pdev = phba->pcidev;
6363 
6364         /* Set the device DMA mask size */
6365         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
6366          || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
6367                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
6368                  || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
6369                         return error;
6370                 }
6371         }
6372 
6373         /* Get the bus address of Bar0 and Bar2 and the number of bytes
6374          * required by each mapping.
6375          */
6376         phba->pci_bar0_map = pci_resource_start(pdev, 0);
6377         bar0map_len = pci_resource_len(pdev, 0);
6378 
6379         phba->pci_bar2_map = pci_resource_start(pdev, 2);
6380         bar2map_len = pci_resource_len(pdev, 2);
6381 
6382         /* Map HBA SLIM to a kernel virtual address. */
6383         phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
6384         if (!phba->slim_memmap_p) {
6385                 dev_printk(KERN_ERR, &pdev->dev,
6386                            "ioremap failed for SLIM memory.\n");
6387                 goto out;
6388         }
6389 
6390         /* Map HBA Control Registers to a kernel virtual address. */
6391         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
6392         if (!phba->ctrl_regs_memmap_p) {
6393                 dev_printk(KERN_ERR, &pdev->dev,
6394                            "ioremap failed for HBA control registers.\n");
6395                 goto out_iounmap_slim;
6396         }
6397 
6398         /* Allocate memory for SLI-2 structures */
6399         phba->slim2p.virt = dma_zalloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
6400                                                 &phba->slim2p.phys, GFP_KERNEL);
6401         if (!phba->slim2p.virt)
6402                 goto out_iounmap;
6403 
6404         phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
6405         phba->mbox_ext = (phba->slim2p.virt +
6406                 offsetof(struct lpfc_sli2_slim, mbx_ext_words));
6407         phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
6408         phba->IOCBs = (phba->slim2p.virt +
6409                        offsetof(struct lpfc_sli2_slim, IOCBs));
6410 
6411         phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
6412                                                  lpfc_sli_hbq_size(),
6413                                                  &phba->hbqslimp.phys,
6414                                                  GFP_KERNEL);
6415         if (!phba->hbqslimp.virt)
6416                 goto out_free_slim;
6417 
6418         hbq_count = lpfc_sli_hbq_count();
6419         ptr = phba->hbqslimp.virt;
6420         for (i = 0; i < hbq_count; ++i) {
6421                 phba->hbqs[i].hbq_virt = ptr;
6422                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
6423                 ptr += (lpfc_hbq_defs[i]->entry_count *
6424                         sizeof(struct lpfc_hbq_entry));
6425         }
6426         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
6427         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
6428 
6429         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
6430 
6431         INIT_LIST_HEAD(&phba->rb_pend_list);
6432 
6433         phba->MBslimaddr = phba->slim_memmap_p;
6434         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
6435         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
6436         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
6437         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
6438 
6439         return 0;
6440 
6441 out_free_slim:
6442         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
6443                           phba->slim2p.virt, phba->slim2p.phys);
6444 out_iounmap:
6445         iounmap(phba->ctrl_regs_memmap_p);
6446 out_iounmap_slim:
6447         iounmap(phba->slim_memmap_p);
6448 out:
6449         return error;
6450 }
6451 
6452 /**
6453  * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
6454  * @phba: pointer to lpfc hba data structure.
6455  *
6456  * This routine is invoked to unset the PCI device memory space for device
6457  * with SLI-3 interface spec.
6458  **/
6459 static void
6460 lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
6461 {
6462         struct pci_dev *pdev;
6463 
6464         /* Obtain PCI device reference */
6465         if (!phba->pcidev)
6466                 return;
6467         else
6468                 pdev = phba->pcidev;
6469 
6470         /* Free coherent DMA memory allocated */
6471         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
6472                           phba->hbqslimp.virt, phba->hbqslimp.phys);
6473         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
6474                           phba->slim2p.virt, phba->slim2p.phys);
6475 
6476         /* I/O memory unmap */
6477         iounmap(phba->ctrl_regs_memmap_p);
6478         iounmap(phba->slim_memmap_p);
6479 
6480         return;
6481 }
6482 
6483 /**
6484  * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
6485  * @phba: pointer to lpfc hba data structure.
6486  *
6487  * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
6488  * done and check status.
6489  *
6490  * Return 0 if successful, otherwise -ENODEV.
6491  **/
6492 int
6493 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
6494 {
6495         struct lpfc_register portsmphr_reg, uerrlo_reg, uerrhi_reg;
6496         struct lpfc_register reg_data;
6497         int i, port_error = 0;
6498         uint32_t if_type;
6499 
6500         memset(&portsmphr_reg, 0, sizeof(portsmphr_reg));
6501         memset(&reg_data, 0, sizeof(reg_data));
6502         if (!phba->sli4_hba.PSMPHRregaddr)
6503                 return -ENODEV;
6504 
6505         /* Wait up to 30 seconds for the SLI Port POST done and ready */
6506         for (i = 0; i < 3000; i++) {
6507                 if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
6508                         &portsmphr_reg.word0) ||
6509                         (bf_get(lpfc_port_smphr_perr, &portsmphr_reg))) {
6510                         /* Port has a fatal POST error, break out */
6511                         port_error = -ENODEV;
6512                         break;
6513                 }
6514                 if (LPFC_POST_STAGE_PORT_READY ==
6515                     bf_get(lpfc_port_smphr_port_status, &portsmphr_reg))
6516                         break;
6517                 msleep(10);
6518         }
6519 
6520         /*
6521          * If there was a port error during POST, then don't proceed with
6522          * other register reads as the data may not be valid.  Just exit.
6523          */
6524         if (port_error) {
6525                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6526                         "1408 Port Failed POST - portsmphr=0x%x, "
6527                         "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
6528                         "scr2=x%x, hscratch=x%x, pstatus=x%x\n",
6529                         portsmphr_reg.word0,
6530                         bf_get(lpfc_port_smphr_perr, &portsmphr_reg),
6531                         bf_get(lpfc_port_smphr_sfi, &portsmphr_reg),
6532                         bf_get(lpfc_port_smphr_nip, &portsmphr_reg),
6533                         bf_get(lpfc_port_smphr_ipc, &portsmphr_reg),
6534                         bf_get(lpfc_port_smphr_scr1, &portsmphr_reg),
6535                         bf_get(lpfc_port_smphr_scr2, &portsmphr_reg),
6536                         bf_get(lpfc_port_smphr_host_scratch, &portsmphr_reg),
6537                         bf_get(lpfc_port_smphr_port_status, &portsmphr_reg));
6538         } else {
6539                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6540                                 "2534 Device Info: SLIFamily=0x%x, "
6541                                 "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, "
6542                                 "SLIHint_2=0x%x, FT=0x%x\n",
6543                                 bf_get(lpfc_sli_intf_sli_family,
6544                                        &phba->sli4_hba.sli_intf),
6545                                 bf_get(lpfc_sli_intf_slirev,
6546                                        &phba->sli4_hba.sli_intf),
6547                                 bf_get(lpfc_sli_intf_if_type,
6548                                        &phba->sli4_hba.sli_intf),
6549                                 bf_get(lpfc_sli_intf_sli_hint1,
6550                                        &phba->sli4_hba.sli_intf),
6551                                 bf_get(lpfc_sli_intf_sli_hint2,
6552                                        &phba->sli4_hba.sli_intf),
6553                                 bf_get(lpfc_sli_intf_func_type,
6554                                        &phba->sli4_hba.sli_intf));
6555                 /*
6556                  * Check for other Port errors during the initialization
6557                  * process.  Fail the load if the port did not come up
6558                  * correctly.
6559                  */
6560                 if_type = bf_get(lpfc_sli_intf_if_type,
6561                                  &phba->sli4_hba.sli_intf);
6562                 switch (if_type) {
6563                 case LPFC_SLI_INTF_IF_TYPE_0:
6564                         phba->sli4_hba.ue_mask_lo =
6565                               readl(phba->sli4_hba.u.if_type0.UEMASKLOregaddr);
6566                         phba->sli4_hba.ue_mask_hi =
6567                               readl(phba->sli4_hba.u.if_type0.UEMASKHIregaddr);
6568                         uerrlo_reg.word0 =
6569                               readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
6570                         uerrhi_reg.word0 =
6571                                 readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
6572                         if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
6573                             (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
6574                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6575                                                 "1422 Unrecoverable Error "
6576                                                 "Detected during POST "
6577                                                 "uerr_lo_reg=0x%x, "
6578                                                 "uerr_hi_reg=0x%x, "
6579                                                 "ue_mask_lo_reg=0x%x, "
6580                                                 "ue_mask_hi_reg=0x%x\n",
6581                                                 uerrlo_reg.word0,
6582                                                 uerrhi_reg.word0,
6583                                                 phba->sli4_hba.ue_mask_lo,
6584                                                 phba->sli4_hba.ue_mask_hi);
6585                                 port_error = -ENODEV;
6586                         }
6587                         break;
6588                 case LPFC_SLI_INTF_IF_TYPE_2:
6589                         /* Final checks.  The port status should be clean. */
6590                         if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
6591                                 &reg_data.word0) ||
6592                                 (bf_get(lpfc_sliport_status_err, &reg_data) &&
6593                                  !bf_get(lpfc_sliport_status_rn, &reg_data))) {
6594                                 phba->work_status[0] =
6595                                         readl(phba->sli4_hba.u.if_type2.
6596                                               ERR1regaddr);
6597                                 phba->work_status[1] =
6598                                         readl(phba->sli4_hba.u.if_type2.
6599                                               ERR2regaddr);
6600                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6601                                         "2888 Unrecoverable port error "
6602                                         "following POST: port status reg "
6603                                         "0x%x, port_smphr reg 0x%x, "
6604                                         "error 1=0x%x, error 2=0x%x\n",
6605                                         reg_data.word0,
6606                                         portsmphr_reg.word0,
6607                                         phba->work_status[0],
6608                                         phba->work_status[1]);
6609                                 port_error = -ENODEV;
6610                         }
6611                         break;
6612                 case LPFC_SLI_INTF_IF_TYPE_1:
6613                 default:
6614                         break;
6615                 }
6616         }
6617         return port_error;
6618 }
6619 
6620 /**
6621  * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
6622  * @phba: pointer to lpfc hba data structure.
6623  * @if_type:  The SLI4 interface type getting configured.
6624  *
6625  * This routine is invoked to set up SLI4 BAR0 PCI config space register
6626  * memory map.
6627  **/
6628 static void
6629 lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type)
6630 {
6631         switch (if_type) {
6632         case LPFC_SLI_INTF_IF_TYPE_0:
6633                 phba->sli4_hba.u.if_type0.UERRLOregaddr =
6634                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_LO;
6635                 phba->sli4_hba.u.if_type0.UERRHIregaddr =
6636                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_HI;
6637                 phba->sli4_hba.u.if_type0.UEMASKLOregaddr =
6638                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_LO;
6639                 phba->sli4_hba.u.if_type0.UEMASKHIregaddr =
6640                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_HI;
6641                 phba->sli4_hba.SLIINTFregaddr =
6642                         phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
6643                 break;
6644         case LPFC_SLI_INTF_IF_TYPE_2:
6645                 phba->sli4_hba.u.if_type2.ERR1regaddr =
6646                         phba->sli4_hba.conf_regs_memmap_p +
6647                                                 LPFC_CTL_PORT_ER1_OFFSET;
6648                 phba->sli4_hba.u.if_type2.ERR2regaddr =
6649                         phba->sli4_hba.conf_regs_memmap_p +
6650                                                 LPFC_CTL_PORT_ER2_OFFSET;
6651                 phba->sli4_hba.u.if_type2.CTRLregaddr =
6652                         phba->sli4_hba.conf_regs_memmap_p +
6653                                                 LPFC_CTL_PORT_CTL_OFFSET;
6654                 phba->sli4_hba.u.if_type2.STATUSregaddr =
6655                         phba->sli4_hba.conf_regs_memmap_p +
6656                                                 LPFC_CTL_PORT_STA_OFFSET;
6657                 phba->sli4_hba.SLIINTFregaddr =
6658                         phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
6659                 phba->sli4_hba.PSMPHRregaddr =
6660                         phba->sli4_hba.conf_regs_memmap_p +
6661                                                 LPFC_CTL_PORT_SEM_OFFSET;
6662                 phba->sli4_hba.RQDBregaddr =
6663                         phba->sli4_hba.conf_regs_memmap_p +
6664                                                 LPFC_ULP0_RQ_DOORBELL;
6665                 phba->sli4_hba.WQDBregaddr =
6666                         phba->sli4_hba.conf_regs_memmap_p +
6667                                                 LPFC_ULP0_WQ_DOORBELL;
6668                 phba->sli4_hba.EQCQDBregaddr =
6669                         phba->sli4_hba.conf_regs_memmap_p + LPFC_EQCQ_DOORBELL;
6670                 phba->sli4_hba.MQDBregaddr =
6671                         phba->sli4_hba.conf_regs_memmap_p + LPFC_MQ_DOORBELL;
6672                 phba->sli4_hba.BMBXregaddr =
6673                         phba->sli4_hba.conf_regs_memmap_p + LPFC_BMBX;
6674                 break;
6675         case LPFC_SLI_INTF_IF_TYPE_1:
6676         default:
6677                 dev_printk(KERN_ERR, &phba->pcidev->dev,
6678                            "FATAL - unsupported SLI4 interface type - %d\n",
6679                            if_type);
6680                 break;
6681         }
6682 }
6683 
6684 /**
6685  * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
6686  * @phba: pointer to lpfc hba data structure.
6687  *
6688  * This routine is invoked to set up SLI4 BAR1 control status register (CSR)
6689  * memory map.
6690  **/
6691 static void
6692 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
6693 {
6694         phba->sli4_hba.PSMPHRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
6695                 LPFC_SLIPORT_IF0_SMPHR;
6696         phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
6697                 LPFC_HST_ISR0;
6698         phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
6699                 LPFC_HST_IMR0;
6700         phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
6701                 LPFC_HST_ISCR0;
6702 }
6703 
6704 /**
6705  * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
6706  * @phba: pointer to lpfc hba data structure.
6707  * @vf: virtual function number
6708  *
6709  * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
6710  * based on the given viftual function number, @vf.
6711  *
6712  * Return 0 if successful, otherwise -ENODEV.
6713  **/
6714 static int
6715 lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
6716 {
6717         if (vf > LPFC_VIR_FUNC_MAX)
6718                 return -ENODEV;
6719 
6720         phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
6721                                 vf * LPFC_VFR_PAGE_SIZE +
6722                                         LPFC_ULP0_RQ_DOORBELL);
6723         phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
6724                                 vf * LPFC_VFR_PAGE_SIZE +
6725                                         LPFC_ULP0_WQ_DOORBELL);
6726         phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
6727                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL);
6728         phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
6729                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL);
6730         phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
6731                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX);
6732         return 0;
6733 }
6734 
6735 /**
6736  * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
6737  * @phba: pointer to lpfc hba data structure.
6738  *
6739  * This routine is invoked to create the bootstrap mailbox
6740  * region consistent with the SLI-4 interface spec.  This
6741  * routine allocates all memory necessary to communicate
6742  * mailbox commands to the port and sets up all alignment
6743  * needs.  No locks are expected to be held when calling
6744  * this routine.
6745  *
6746  * Return codes
6747  *      0 - successful
6748  *      -ENOMEM - could not allocated memory.
6749  **/
6750 static int
6751 lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
6752 {
6753         uint32_t bmbx_size;
6754         struct lpfc_dmabuf *dmabuf;
6755         struct dma_address *dma_address;
6756         uint32_t pa_addr;
6757         uint64_t phys_addr;
6758 
6759         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
6760         if (!dmabuf)
6761                 return -ENOMEM;
6762 
6763         /*
6764          * The bootstrap mailbox region is comprised of 2 parts
6765          * plus an alignment restriction of 16 bytes.
6766          */
6767         bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
6768         dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, bmbx_size,
6769                                            &dmabuf->phys, GFP_KERNEL);
6770         if (!dmabuf->virt) {
6771                 kfree(dmabuf);
6772                 return -ENOMEM;
6773         }
6774 
6775         /*
6776          * Initialize the bootstrap mailbox pointers now so that the register
6777          * operations are simple later.  The mailbox dma address is required
6778          * to be 16-byte aligned.  Also align the virtual memory as each
6779          * maibox is copied into the bmbx mailbox region before issuing the
6780          * command to the port.
6781          */
6782         phba->sli4_hba.bmbx.dmabuf = dmabuf;
6783         phba->sli4_hba.bmbx.bmbx_size = bmbx_size;
6784 
6785         phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt,
6786                                               LPFC_ALIGN_16_BYTE);
6787         phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys,
6788                                               LPFC_ALIGN_16_BYTE);
6789 
6790         /*
6791          * Set the high and low physical addresses now.  The SLI4 alignment
6792          * requirement is 16 bytes and the mailbox is posted to the port
6793          * as two 30-bit addresses.  The other data is a bit marking whether
6794          * the 30-bit address is the high or low address.
6795          * Upcast bmbx aphys to 64bits so shift instruction compiles
6796          * clean on 32 bit machines.
6797          */
6798         dma_address = &phba->sli4_hba.bmbx.dma_address;
6799         phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys;
6800         pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff);
6801         dma_address->addr_hi = (uint32_t) ((pa_addr << 2) |
6802                                            LPFC_BMBX_BIT1_ADDR_HI);
6803 
6804         pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff);
6805         dma_address->addr_lo = (uint32_t) ((pa_addr << 2) |
6806                                            LPFC_BMBX_BIT1_ADDR_LO);
6807         return 0;
6808 }
6809 
6810 /**
6811  * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
6812  * @phba: pointer to lpfc hba data structure.
6813  *
6814  * This routine is invoked to teardown the bootstrap mailbox
6815  * region and release all host resources. This routine requires
6816  * the caller to ensure all mailbox commands recovered, no
6817  * additional mailbox comands are sent, and interrupts are disabled
6818  * before calling this routine.
6819  *
6820  **/
6821 static void
6822 lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
6823 {
6824         dma_free_coherent(&phba->pcidev->dev,
6825                           phba->sli4_hba.bmbx.bmbx_size,
6826                           phba->sli4_hba.bmbx.dmabuf->virt,
6827                           phba->sli4_hba.bmbx.dmabuf->phys);
6828 
6829         kfree(phba->sli4_hba.bmbx.dmabuf);
6830         memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx));
6831 }
6832 
6833 /**
6834  * lpfc_sli4_read_config - Get the config parameters.
6835  * @phba: pointer to lpfc hba data structure.
6836  *
6837  * This routine is invoked to read the configuration parameters from the HBA.
6838  * The configuration parameters are used to set the base and maximum values
6839  * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
6840  * allocation for the port.
6841  *
6842  * Return codes
6843  *      0 - successful
6844  *      -ENOMEM - No available memory
6845  *      -EIO - The mailbox failed to complete successfully.
6846  **/
6847 int
6848 lpfc_sli4_read_config(struct lpfc_hba *phba)
6849 {
6850         LPFC_MBOXQ_t *pmb;
6851         struct lpfc_mbx_read_config *rd_config;
6852         union  lpfc_sli4_cfg_shdr *shdr;
6853         uint32_t shdr_status, shdr_add_status;
6854         struct lpfc_mbx_get_func_cfg *get_func_cfg;
6855         struct lpfc_rsrc_desc_fcfcoe *desc;
6856         char *pdesc_0;
6857         int length, i, rc = 0, rc2;
6858 
6859         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6860         if (!pmb) {
6861                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6862                                 "2011 Unable to allocate memory for issuing "
6863                                 "SLI_CONFIG_SPECIAL mailbox command\n");
6864                 return -ENOMEM;
6865         }
6866 
6867         lpfc_read_config(phba, pmb);
6868 
6869         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
6870         if (rc != MBX_SUCCESS) {
6871                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6872                         "2012 Mailbox failed , mbxCmd x%x "
6873                         "READ_CONFIG, mbxStatus x%x\n",
6874                         bf_get(lpfc_mqe_command, &pmb->u.mqe),
6875                         bf_get(lpfc_mqe_status, &pmb->u.mqe));
6876                 rc = -EIO;
6877         } else {
6878                 rd_config = &pmb->u.mqe.un.rd_config;
6879                 if (bf_get(lpfc_mbx_rd_conf_lnk_ldv, rd_config)) {
6880                         phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_VAL;
6881                         phba->sli4_hba.lnk_info.lnk_tp =
6882                                 bf_get(lpfc_mbx_rd_conf_lnk_type, rd_config);
6883                         phba->sli4_hba.lnk_info.lnk_no =
6884                                 bf_get(lpfc_mbx_rd_conf_lnk_numb, rd_config);
6885                         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
6886                                         "3081 lnk_type:%d, lnk_numb:%d\n",
6887                                         phba->sli4_hba.lnk_info.lnk_tp,
6888                                         phba->sli4_hba.lnk_info.lnk_no);
6889                 } else
6890                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
6891                                         "3082 Mailbox (x%x) returned ldv:x0\n",
6892                                         bf_get(lpfc_mqe_command, &pmb->u.mqe));
6893                 phba->sli4_hba.extents_in_use =
6894                         bf_get(lpfc_mbx_rd_conf_extnts_inuse, rd_config);
6895                 phba->sli4_hba.max_cfg_param.max_xri =
6896                         bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
6897                 phba->sli4_hba.max_cfg_param.xri_base =
6898                         bf_get(lpfc_mbx_rd_conf_xri_base, rd_config);
6899                 phba->sli4_hba.max_cfg_param.max_vpi =
6900                         bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config);
6901                 phba->sli4_hba.max_cfg_param.vpi_base =
6902                         bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config);
6903                 phba->sli4_hba.max_cfg_param.max_rpi =
6904                         bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
6905                 phba->sli4_hba.max_cfg_param.rpi_base =
6906                         bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config);
6907                 phba->sli4_hba.max_cfg_param.max_vfi =
6908                         bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config);
6909                 phba->sli4_hba.max_cfg_param.vfi_base =
6910                         bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
6911                 phba->sli4_hba.max_cfg_param.max_fcfi =
6912                         bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
6913                 phba->sli4_hba.max_cfg_param.max_eq =
6914                         bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
6915                 phba->sli4_hba.max_cfg_param.max_rq =
6916                         bf_get(lpfc_mbx_rd_conf_rq_count, rd_config);
6917                 phba->sli4_hba.max_cfg_param.max_wq =
6918                         bf_get(lpfc_mbx_rd_conf_wq_count, rd_config);
6919                 phba->sli4_hba.max_cfg_param.max_cq =
6920                         bf_get(lpfc_mbx_rd_conf_cq_count, rd_config);
6921                 phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config);
6922                 phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base;
6923                 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
6924                 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
6925                 phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
6926                                 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
6927                 phba->max_vports = phba->max_vpi;
6928                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
6929                                 "2003 cfg params Extents? %d "
6930                                 "XRI(B:%d M:%d), "
6931                                 "VPI(B:%d M:%d) "
6932                                 "VFI(B:%d M:%d) "
6933                                 "RPI(B:%d M:%d) "
6934                                 "FCFI(Count:%d)\n",
6935                                 phba->sli4_hba.extents_in_use,
6936                                 phba->sli4_hba.max_cfg_param.xri_base,
6937                                 phba->sli4_hba.max_cfg_param.max_xri,
6938                                 phba->sli4_hba.max_cfg_param.vpi_base,
6939                                 phba->sli4_hba.max_cfg_param.max_vpi,
6940                                 phba->sli4_hba.max_cfg_param.vfi_base,
6941                                 phba->sli4_hba.max_cfg_param.max_vfi,
6942                                 phba->sli4_hba.max_cfg_param.rpi_base,
6943                                 phba->sli4_hba.max_cfg_param.max_rpi,
6944                                 phba->sli4_hba.max_cfg_param.max_fcfi);
6945         }
6946 
6947         if (rc)
6948                 goto read_cfg_out;
6949 
6950         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
6951         length = phba->sli4_hba.max_cfg_param.max_xri -
6952                         lpfc_sli4_get_els_iocb_cnt(phba);
6953         if (phba->cfg_hba_queue_depth > length) {
6954                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6955                                 "3361 HBA queue depth changed from %d to %d\n",
6956                                 phba->cfg_hba_queue_depth, length);
6957                 phba->cfg_hba_queue_depth = length;
6958         }
6959 
6960         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
6961             LPFC_SLI_INTF_IF_TYPE_2)
6962                 goto read_cfg_out;
6963 
6964         /* get the pf# and vf# for SLI4 if_type 2 port */
6965         length = (sizeof(struct lpfc_mbx_get_func_cfg) -
6966                   sizeof(struct lpfc_sli4_cfg_mhdr));
6967         lpfc_sli4_config(phba, pmb, LPFC_MBOX_SUBSYSTEM_COMMON,
6968                          LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG,
6969                          length, LPFC_SLI4_MBX_EMBED);
6970 
6971         rc2 = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
6972         shdr = (union lpfc_sli4_cfg_shdr *)
6973                                 &pmb->u.mqe.un.sli4_config.header.cfg_shdr;
6974         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
6975         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
6976         if (rc2 || shdr_status || shdr_add_status) {
6977                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6978                                 "3026 Mailbox failed , mbxCmd x%x "
6979                                 "GET_FUNCTION_CONFIG, mbxStatus x%x\n",
6980                                 bf_get(lpfc_mqe_command, &pmb->u.mqe),
6981                                 bf_get(lpfc_mqe_status, &pmb->u.mqe));
6982                 goto read_cfg_out;
6983         }
6984 
6985         /* search for fc_fcoe resrouce descriptor */
6986         get_func_cfg = &pmb->u.mqe.un.get_func_cfg;
6987 
6988         pdesc_0 = (char *)&get_func_cfg->func_cfg.desc[0];
6989         desc = (struct lpfc_rsrc_desc_fcfcoe *)pdesc_0;
6990         length = bf_get(lpfc_rsrc_desc_fcfcoe_length, desc);
6991         if (length == LPFC_RSRC_DESC_TYPE_FCFCOE_V0_RSVD)
6992                 length = LPFC_RSRC_DESC_TYPE_FCFCOE_V0_LENGTH;
6993         else if (length != LPFC_RSRC_DESC_TYPE_FCFCOE_V1_LENGTH)
6994                 goto read_cfg_out;
6995 
6996         for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
6997                 desc = (struct lpfc_rsrc_desc_fcfcoe *)(pdesc_0 + length * i);
6998                 if (LPFC_RSRC_DESC_TYPE_FCFCOE ==
6999                     bf_get(lpfc_rsrc_desc_fcfcoe_type, desc)) {
7000                         phba->sli4_hba.iov.pf_number =
7001                                 bf_get(lpfc_rsrc_desc_fcfcoe_pfnum, desc);
7002                         phba->sli4_hba.iov.vf_number =
7003                                 bf_get(lpfc_rsrc_desc_fcfcoe_vfnum, desc);
7004                         break;
7005                 }
7006         }
7007 
7008         if (i < LPFC_RSRC_DESC_MAX_NUM)
7009                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7010                                 "3027 GET_FUNCTION_CONFIG: pf_number:%d, "
7011                                 "vf_number:%d\n", phba->sli4_hba.iov.pf_number,
7012                                 phba->sli4_hba.iov.vf_number);
7013         else
7014                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7015                                 "3028 GET_FUNCTION_CONFIG: failed to find "
7016                                 "Resrouce Descriptor:x%x\n",
7017                                 LPFC_RSRC_DESC_TYPE_FCFCOE);
7018 
7019 read_cfg_out:
7020         mempool_free(pmb, phba->mbox_mem_pool);
7021         return rc;
7022 }
7023 
7024 /**
7025  * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port.
7026  * @phba: pointer to lpfc hba data structure.
7027  *
7028  * This routine is invoked to setup the port-side endian order when
7029  * the port if_type is 0.  This routine has no function for other
7030  * if_types.
7031  *
7032  * Return codes
7033  *      0 - successful
7034  *      -ENOMEM - No available memory
7035  *      -EIO - The mailbox failed to complete successfully.
7036  **/
7037 static int
7038 lpfc_setup_endian_order(struct lpfc_hba *phba)
7039 {
7040         LPFC_MBOXQ_t *mboxq;
7041         uint32_t if_type, rc = 0;
7042         uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
7043                                       HOST_ENDIAN_HIGH_WORD1};
7044 
7045         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
7046         switch (if_type) {
7047         case LPFC_SLI_INTF_IF_TYPE_0:
7048                 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
7049                                                        GFP_KERNEL);
7050                 if (!mboxq) {
7051                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7052                                         "0492 Unable to allocate memory for "
7053                                         "issuing SLI_CONFIG_SPECIAL mailbox "
7054                                         "command\n");
7055                         return -ENOMEM;
7056                 }
7057 
7058                 /*
7059                  * The SLI4_CONFIG_SPECIAL mailbox command requires the first
7060                  * two words to contain special data values and no other data.
7061                  */
7062                 memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
7063                 memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
7064                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
7065                 if (rc != MBX_SUCCESS) {
7066                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7067                                         "0493 SLI_CONFIG_SPECIAL mailbox "
7068                                         "failed with status x%x\n",
7069                                         rc);
7070                         rc = -EIO;
7071                 }
7072                 mempool_free(mboxq, phba->mbox_mem_pool);
7073                 break;
7074         case LPFC_SLI_INTF_IF_TYPE_2:
7075         case LPFC_SLI_INTF_IF_TYPE_1:
7076         default:
7077                 break;
7078         }
7079         return rc;
7080 }
7081 
7082 /**
7083  * lpfc_sli4_queue_verify - Verify and update EQ and CQ counts
7084  * @phba: pointer to lpfc hba data structure.
7085  *
7086  * This routine is invoked to check the user settable queue counts for EQs and
7087  * CQs. after this routine is called the counts will be set to valid values that
7088  * adhere to the constraints of the system's interrupt vectors and the port's
7089  * queue resources.
7090  *
7091  * Return codes
7092  *      0 - successful
7093  *      -ENOMEM - No available memory
7094  **/
7095 static int
7096 lpfc_sli4_queue_verify(struct lpfc_hba *phba)
7097 {
7098         int cfg_fcp_io_channel;
7099         uint32_t cpu;
7100         uint32_t i = 0;
7101         int fof_vectors = phba->cfg_fof ? 1 : 0;
7102 
7103         /*
7104          * Sanity check for configured queue parameters against the run-time
7105          * device parameters
7106          */
7107 
7108         /* Sanity check on HBA EQ parameters */
7109         cfg_fcp_io_channel = phba->cfg_fcp_io_channel;
7110 
7111         /* It doesn't make sense to have more io channels then online CPUs */
7112         for_each_present_cpu(cpu) {
7113                 if (cpu_online(cpu))
7114                         i++;
7115         }
7116         phba->sli4_hba.num_online_cpu = i;
7117         phba->sli4_hba.num_present_cpu = lpfc_present_cpu;
7118         phba->sli4_hba.curr_disp_cpu = 0;
7119 
7120         if (i < cfg_fcp_io_channel) {
7121                 lpfc_printf_log(phba,
7122                                 KERN_ERR, LOG_INIT,
7123                                 "3188 Reducing IO channels to match number of "
7124                                 "online CPUs: from %d to %d\n",
7125                                 cfg_fcp_io_channel, i);
7126                 cfg_fcp_io_channel = i;
7127         }
7128 
7129         if (cfg_fcp_io_channel + fof_vectors >
7130             phba->sli4_hba.max_cfg_param.max_eq) {
7131                 if (phba->sli4_hba.max_cfg_param.max_eq <
7132                     LPFC_FCP_IO_CHAN_MIN) {
7133                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7134                                         "2574 Not enough EQs (%d) from the "
7135                                         "pci function for supporting FCP "
7136                                         "EQs (%d)\n",
7137                                         phba->sli4_hba.max_cfg_param.max_eq,
7138                                         phba->cfg_fcp_io_channel);
7139                         goto out_error;
7140                 }
7141                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7142                                 "2575 Reducing IO channels to match number of "
7143                                 "available EQs: from %d to %d\n",
7144                                 cfg_fcp_io_channel,
7145                                 phba->sli4_hba.max_cfg_param.max_eq);
7146                 cfg_fcp_io_channel = phba->sli4_hba.max_cfg_param.max_eq -
7147                         fof_vectors;
7148         }
7149 
7150         /* The actual number of FCP event queues adopted */
7151         phba->cfg_fcp_io_channel = cfg_fcp_io_channel;
7152 
7153         /* Get EQ depth from module parameter, fake the default for now */
7154         phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
7155         phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
7156 
7157         /* Get CQ depth from module parameter, fake the default for now */
7158         phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
7159         phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
7160 
7161         return 0;
7162 out_error:
7163         return -ENOMEM;
7164 }
7165 
7166 /**
7167  * lpfc_sli4_queue_create - Create all the SLI4 queues
7168  * @phba: pointer to lpfc hba data structure.
7169  *
7170  * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
7171  * operation. For each SLI4 queue type, the parameters such as queue entry
7172  * count (queue depth) shall be taken from the module parameter. For now,
7173  * we just use some constant number as place holder.
7174  *
7175  * Return codes
7176  *      0 - successful
7177  *      -ENOMEM - No availble memory
7178  *      -EIO - The mailbox failed to complete successfully.
7179  **/
7180 int
7181 lpfc_sli4_queue_create(struct lpfc_hba *phba)
7182 {
7183         struct lpfc_queue *qdesc;
7184         int idx;
7185 
7186         /*
7187          * Create HBA Record arrays.
7188          */
7189         if (!phba->cfg_fcp_io_channel)
7190                 return -ERANGE;
7191 
7192         phba->sli4_hba.mq_esize = LPFC_MQE_SIZE;
7193         phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT;
7194         phba->sli4_hba.wq_esize = LPFC_WQE_SIZE;
7195         phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT;
7196         phba->sli4_hba.rq_esize = LPFC_RQE_SIZE;
7197         phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT;
7198 
7199         phba->sli4_hba.hba_eq =  kzalloc((sizeof(struct lpfc_queue *) *
7200                                 phba->cfg_fcp_io_channel), GFP_KERNEL);
7201         if (!phba->sli4_hba.hba_eq) {
7202                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7203                         "2576 Failed allocate memory for "
7204                         "fast-path EQ record array\n");
7205                 goto out_error;
7206         }
7207 
7208         phba->sli4_hba.fcp_cq = kzalloc((sizeof(struct lpfc_queue *) *
7209                                 phba->cfg_fcp_io_channel), GFP_KERNEL);
7210         if (!phba->sli4_hba.fcp_cq) {
7211                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7212                                 "2577 Failed allocate memory for fast-path "
7213                                 "CQ record array\n");
7214                 goto out_error;
7215         }
7216 
7217         phba->sli4_hba.fcp_wq = kzalloc((sizeof(struct lpfc_queue *) *
7218                                 phba->cfg_fcp_io_channel), GFP_KERNEL);
7219         if (!phba->sli4_hba.fcp_wq) {
7220                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7221                                 "2578 Failed allocate memory for fast-path "
7222                                 "WQ record array\n");
7223                 goto out_error;
7224         }
7225 
7226         /*
7227          * Since the first EQ can have multiple CQs associated with it,
7228          * this array is used to quickly see if we have a FCP fast-path
7229          * CQ match.
7230          */
7231         phba->sli4_hba.fcp_cq_map = kzalloc((sizeof(uint16_t) *
7232                                          phba->cfg_fcp_io_channel), GFP_KERNEL);
7233         if (!phba->sli4_hba.fcp_cq_map) {
7234                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7235                                 "2545 Failed allocate memory for fast-path "
7236                                 "CQ map\n");
7237                 goto out_error;
7238         }
7239 
7240         /*
7241          * Create HBA Event Queues (EQs).  The cfg_fcp_io_channel specifies
7242          * how many EQs to create.
7243          */
7244         for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++) {
7245 
7246                 /* Create EQs */
7247                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
7248                                               phba->sli4_hba.eq_ecount);
7249                 if (!qdesc) {
7250                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7251                                         "0497 Failed allocate EQ (%d)\n", idx);
7252                         goto out_error;
7253                 }
7254                 phba->sli4_hba.hba_eq[idx] = qdesc;
7255 
7256                 /* Create Fast Path FCP CQs */
7257                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
7258                                               phba->sli4_hba.cq_ecount);
7259                 if (!qdesc) {
7260                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7261                                         "0499 Failed allocate fast-path FCP "
7262                                         "CQ (%d)\n", idx);
7263                         goto out_error;
7264                 }
7265                 phba->sli4_hba.fcp_cq[idx] = qdesc;
7266 
7267                 /* Create Fast Path FCP WQs */
7268                 if (phba->fcp_embed_io) {
7269                         qdesc = lpfc_sli4_queue_alloc(phba,
7270                                                       LPFC_WQE128_SIZE,
7271                                                       LPFC_WQE128_DEF_COUNT);
7272                 } else {
7273                         qdesc = lpfc_sli4_queue_alloc(phba,
7274                                                       phba->sli4_hba.wq_esize,
7275                                                       phba->sli4_hba.wq_ecount);
7276                 }
7277                 if (!qdesc) {
7278                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7279                                         "0503 Failed allocate fast-path FCP "
7280                                         "WQ (%d)\n", idx);
7281                         goto out_error;
7282                 }
7283                 phba->sli4_hba.fcp_wq[idx] = qdesc;
7284         }
7285 
7286 
7287         /*
7288          * Create Slow Path Completion Queues (CQs)
7289          */
7290 
7291         /* Create slow-path Mailbox Command Complete Queue */
7292         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
7293                                       phba->sli4_hba.cq_ecount);
7294         if (!qdesc) {
7295                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7296                                 "0500 Failed allocate slow-path mailbox CQ\n");
7297                 goto out_error;
7298         }
7299         phba->sli4_hba.mbx_cq = qdesc;
7300 
7301         /* Create slow-path ELS Complete Queue */
7302         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
7303                                       phba->sli4_hba.cq_ecount);
7304         if (!qdesc) {
7305                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7306                                 "0501 Failed allocate slow-path ELS CQ\n");
7307                 goto out_error;
7308         }
7309         phba->sli4_hba.els_cq = qdesc;
7310 
7311 
7312         /*
7313          * Create Slow Path Work Queues (WQs)
7314          */
7315 
7316         /* Create Mailbox Command Queue */
7317 
7318         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize,
7319                                       phba->sli4_hba.mq_ecount);
7320         if (!qdesc) {
7321                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7322                                 "0505 Failed allocate slow-path MQ\n");
7323                 goto out_error;
7324         }
7325         phba->sli4_hba.mbx_wq = qdesc;
7326 
7327         /*
7328          * Create ELS Work Queues
7329          */
7330 
7331         /* Create slow-path ELS Work Queue */
7332         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
7333                                       phba->sli4_hba.wq_ecount);
7334         if (!qdesc) {
7335                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7336                                 "0504 Failed allocate slow-path ELS WQ\n");
7337                 goto out_error;
7338         }
7339         phba->sli4_hba.els_wq = qdesc;
7340 
7341         /*
7342          * Create Receive Queue (RQ)
7343          */
7344 
7345         /* Create Receive Queue for header */
7346         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
7347                                       phba->sli4_hba.rq_ecount);
7348         if (!qdesc) {
7349                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7350                                 "0506 Failed allocate receive HRQ\n");
7351                 goto out_error;
7352         }
7353         phba->sli4_hba.hdr_rq = qdesc;
7354 
7355         /* Create Receive Queue for data */
7356         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
7357                                       phba->sli4_hba.rq_ecount);
7358         if (!qdesc) {
7359                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7360                                 "0507 Failed allocate receive DRQ\n");
7361                 goto out_error;
7362         }
7363         phba->sli4_hba.dat_rq = qdesc;
7364 
7365         /* Create the Queues needed for Flash Optimized Fabric operations */
7366         if (phba->cfg_fof)
7367                 lpfc_fof_queue_create(phba);
7368         return 0;
7369 
7370 out_error:
7371         lpfc_sli4_queue_destroy(phba);
7372         return -ENOMEM;
7373 }
7374 
7375 /**
7376  * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
7377  * @phba: pointer to lpfc hba data structure.
7378  *
7379  * This routine is invoked to release all the SLI4 queues with the FCoE HBA
7380  * operation.
7381  *
7382  * Return codes
7383  *      0 - successful
7384  *      -ENOMEM - No available memory
7385  *      -EIO - The mailbox failed to complete successfully.
7386  **/
7387 void
7388 lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
7389 {
7390         int idx;
7391 
7392         if (phba->cfg_fof)
7393                 lpfc_fof_queue_destroy(phba);
7394 
7395         if (phba->sli4_hba.hba_eq != NULL) {
7396                 /* Release HBA event queue */
7397                 for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++) {
7398                         if (phba->sli4_hba.hba_eq[idx] != NULL) {
7399                                 lpfc_sli4_queue_free(
7400                                         phba->sli4_hba.hba_eq[idx]);
7401                                 phba->sli4_hba.hba_eq[idx] = NULL;
7402                         }
7403                 }
7404                 kfree(phba->sli4_hba.hba_eq);
7405                 phba->sli4_hba.hba_eq = NULL;
7406         }
7407 
7408         if (phba->sli4_hba.fcp_cq != NULL) {
7409                 /* Release FCP completion queue */
7410                 for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++) {
7411                         if (phba->sli4_hba.fcp_cq[idx] != NULL) {
7412                                 lpfc_sli4_queue_free(
7413                                         phba->sli4_hba.fcp_cq[idx]);
7414                                 phba->sli4_hba.fcp_cq[idx] = NULL;
7415                         }
7416                 }
7417                 kfree(phba->sli4_hba.fcp_cq);
7418                 phba->sli4_hba.fcp_cq = NULL;
7419         }
7420 
7421         if (phba->sli4_hba.fcp_wq != NULL) {
7422                 /* Release FCP work queue */
7423                 for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++) {
7424                         if (phba->sli4_hba.fcp_wq[idx] != NULL) {
7425                                 lpfc_sli4_queue_free(
7426