]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/scsi/lpfc/lpfc_init.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


40ffa01111427bd9677ad152fa567490963b0b81
[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / lpfc / lpfc_init.c
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Limited and/or its subsidiaries. *
6 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
8 * www.broadcom.com *
9 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
10 * *
11 * This program is free software; you can redistribute it and/or *
12 * modify it under the terms of version 2 of the GNU General *
13 * Public License as published by the Free Software Foundation. *
14 * This program is distributed in the hope that it will be useful. *
15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19 * TO BE LEGALLY INVALID. See the GNU General Public License for *
20 * more details, a copy of which can be found in the file COPYING *
21 * included with this package. *
22 *******************************************************************/
23
24 #include <linux/blkdev.h>
25 #include <linux/delay.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/idr.h>
28 #include <linux/interrupt.h>
29 #include <linux/module.h>
30 #include <linux/kthread.h>
31 #include <linux/pci.h>
32 #include <linux/spinlock.h>
33 #include <linux/ctype.h>
34 #include <linux/aer.h>
35 #include <linux/slab.h>
36 #include <linux/firmware.h>
37 #include <linux/miscdevice.h>
38 #include <linux/percpu.h>
39 #include <linux/msi.h>
40 #include <linux/bitops.h>
41
42 #include <scsi/scsi.h>
43 #include <scsi/scsi_device.h>
44 #include <scsi/scsi_host.h>
45 #include <scsi/scsi_transport_fc.h>
46 #include <scsi/scsi_tcq.h>
47 #include <scsi/fc/fc_fs.h>
48
49 #include <linux/nvme-fc-driver.h>
50
51 #include "lpfc_hw4.h"
52 #include "lpfc_hw.h"
53 #include "lpfc_sli.h"
54 #include "lpfc_sli4.h"
55 #include "lpfc_nl.h"
56 #include "lpfc_disc.h"
57 #include "lpfc.h"
58 #include "lpfc_scsi.h"
59 #include "lpfc_nvme.h"
60 #include "lpfc_nvmet.h"
61 #include "lpfc_logmsg.h"
62 #include "lpfc_crtn.h"
63 #include "lpfc_vport.h"
64 #include "lpfc_version.h"
65 #include "lpfc_ids.h"
66
67 char *_dump_buf_data;
68 unsigned long _dump_buf_data_order;
69 char *_dump_buf_dif;
70 unsigned long _dump_buf_dif_order;
71 spinlock_t _dump_buf_lock;
72
73 /* Used when mapping IRQ vectors in a driver centric manner */
74 uint16_t *lpfc_used_cpu;
75 uint32_t lpfc_present_cpu;
76
77 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
78 static int lpfc_post_rcv_buf(struct lpfc_hba *);
79 static int lpfc_sli4_queue_verify(struct lpfc_hba *);
80 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
81 static int lpfc_setup_endian_order(struct lpfc_hba *);
82 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
83 static void lpfc_free_els_sgl_list(struct lpfc_hba *);
84 static void lpfc_free_nvmet_sgl_list(struct lpfc_hba *);
85 static void lpfc_init_sgl_list(struct lpfc_hba *);
86 static int lpfc_init_active_sgl_array(struct lpfc_hba *);
87 static void lpfc_free_active_sgl(struct lpfc_hba *);
88 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
89 static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
90 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
91 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
92 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
93 static void lpfc_sli4_disable_intr(struct lpfc_hba *);
94 static uint32_t lpfc_sli4_enable_intr(struct lpfc_hba *, uint32_t);
95 static void lpfc_sli4_oas_verify(struct lpfc_hba *phba);
96
97 static struct scsi_transport_template *lpfc_transport_template = NULL;
98 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
99 static DEFINE_IDR(lpfc_hba_index);
100 #define LPFC_NVMET_BUF_POST 254
101
102 /**
103 * lpfc_config_port_prep - Perform lpfc initialization prior to config port
104 * @phba: pointer to lpfc hba data structure.
105 *
106 * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
107 * mailbox command. It retrieves the revision information from the HBA and
108 * collects the Vital Product Data (VPD) about the HBA for preparing the
109 * configuration of the HBA.
110 *
111 * Return codes:
112 * 0 - success.
113 * -ERESTART - requests the SLI layer to reset the HBA and try again.
114 * Any other value - indicates an error.
115 **/
116 int
117 lpfc_config_port_prep(struct lpfc_hba *phba)
118 {
119 lpfc_vpd_t *vp = &phba->vpd;
120 int i = 0, rc;
121 LPFC_MBOXQ_t *pmb;
122 MAILBOX_t *mb;
123 char *lpfc_vpd_data = NULL;
124 uint16_t offset = 0;
125 static char licensed[56] =
126 "key unlock for use with gnu public licensed code only\0";
127 static int init_key = 1;
128
129 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
130 if (!pmb) {
131 phba->link_state = LPFC_HBA_ERROR;
132 return -ENOMEM;
133 }
134
135 mb = &pmb->u.mb;
136 phba->link_state = LPFC_INIT_MBX_CMDS;
137
138 if (lpfc_is_LC_HBA(phba->pcidev->device)) {
139 if (init_key) {
140 uint32_t *ptext = (uint32_t *) licensed;
141
142 for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
143 *ptext = cpu_to_be32(*ptext);
144 init_key = 0;
145 }
146
147 lpfc_read_nv(phba, pmb);
148 memset((char*)mb->un.varRDnvp.rsvd3, 0,
149 sizeof (mb->un.varRDnvp.rsvd3));
150 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
151 sizeof (licensed));
152
153 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
154
155 if (rc != MBX_SUCCESS) {
156 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
157 "0324 Config Port initialization "
158 "error, mbxCmd x%x READ_NVPARM, "
159 "mbxStatus x%x\n",
160 mb->mbxCommand, mb->mbxStatus);
161 mempool_free(pmb, phba->mbox_mem_pool);
162 return -ERESTART;
163 }
164 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
165 sizeof(phba->wwnn));
166 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
167 sizeof(phba->wwpn));
168 }
169
170 phba->sli3_options = 0x0;
171
172 /* Setup and issue mailbox READ REV command */
173 lpfc_read_rev(phba, pmb);
174 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
175 if (rc != MBX_SUCCESS) {
176 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
177 "0439 Adapter failed to init, mbxCmd x%x "
178 "READ_REV, mbxStatus x%x\n",
179 mb->mbxCommand, mb->mbxStatus);
180 mempool_free( pmb, phba->mbox_mem_pool);
181 return -ERESTART;
182 }
183
184
185 /*
186 * The value of rr must be 1 since the driver set the cv field to 1.
187 * This setting requires the FW to set all revision fields.
188 */
189 if (mb->un.varRdRev.rr == 0) {
190 vp->rev.rBit = 0;
191 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
192 "0440 Adapter failed to init, READ_REV has "
193 "missing revision information.\n");
194 mempool_free(pmb, phba->mbox_mem_pool);
195 return -ERESTART;
196 }
197
198 if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
199 mempool_free(pmb, phba->mbox_mem_pool);
200 return -EINVAL;
201 }
202
203 /* Save information as VPD data */
204 vp->rev.rBit = 1;
205 memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
206 vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
207 memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
208 vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
209 memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
210 vp->rev.biuRev = mb->un.varRdRev.biuRev;
211 vp->rev.smRev = mb->un.varRdRev.smRev;
212 vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
213 vp->rev.endecRev = mb->un.varRdRev.endecRev;
214 vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
215 vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
216 vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
217 vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
218 vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
219 vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
220
221 /* If the sli feature level is less then 9, we must
222 * tear down all RPIs and VPIs on link down if NPIV
223 * is enabled.
224 */
225 if (vp->rev.feaLevelHigh < 9)
226 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
227
228 if (lpfc_is_LC_HBA(phba->pcidev->device))
229 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
230 sizeof (phba->RandomData));
231
232 /* Get adapter VPD information */
233 lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
234 if (!lpfc_vpd_data)
235 goto out_free_mbox;
236 do {
237 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
238 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
239
240 if (rc != MBX_SUCCESS) {
241 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
242 "0441 VPD not present on adapter, "
243 "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
244 mb->mbxCommand, mb->mbxStatus);
245 mb->un.varDmp.word_cnt = 0;
246 }
247 /* dump mem may return a zero when finished or we got a
248 * mailbox error, either way we are done.
249 */
250 if (mb->un.varDmp.word_cnt == 0)
251 break;
252 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
253 mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
254 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
255 lpfc_vpd_data + offset,
256 mb->un.varDmp.word_cnt);
257 offset += mb->un.varDmp.word_cnt;
258 } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
259 lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
260
261 kfree(lpfc_vpd_data);
262 out_free_mbox:
263 mempool_free(pmb, phba->mbox_mem_pool);
264 return 0;
265 }
266
267 /**
268 * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
269 * @phba: pointer to lpfc hba data structure.
270 * @pmboxq: pointer to the driver internal queue element for mailbox command.
271 *
272 * This is the completion handler for driver's configuring asynchronous event
273 * mailbox command to the device. If the mailbox command returns successfully,
274 * it will set internal async event support flag to 1; otherwise, it will
275 * set internal async event support flag to 0.
276 **/
277 static void
278 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
279 {
280 if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS)
281 phba->temp_sensor_support = 1;
282 else
283 phba->temp_sensor_support = 0;
284 mempool_free(pmboxq, phba->mbox_mem_pool);
285 return;
286 }
287
288 /**
289 * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
290 * @phba: pointer to lpfc hba data structure.
291 * @pmboxq: pointer to the driver internal queue element for mailbox command.
292 *
293 * This is the completion handler for dump mailbox command for getting
294 * wake up parameters. When this command complete, the response contain
295 * Option rom version of the HBA. This function translate the version number
296 * into a human readable string and store it in OptionROMVersion.
297 **/
298 static void
299 lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
300 {
301 struct prog_id *prg;
302 uint32_t prog_id_word;
303 char dist = ' ';
304 /* character array used for decoding dist type. */
305 char dist_char[] = "nabx";
306
307 if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) {
308 mempool_free(pmboxq, phba->mbox_mem_pool);
309 return;
310 }
311
312 prg = (struct prog_id *) &prog_id_word;
313
314 /* word 7 contain option rom version */
315 prog_id_word = pmboxq->u.mb.un.varWords[7];
316
317 /* Decode the Option rom version word to a readable string */
318 if (prg->dist < 4)
319 dist = dist_char[prg->dist];
320
321 if ((prg->dist == 3) && (prg->num == 0))
322 snprintf(phba->OptionROMVersion, 32, "%d.%d%d",
323 prg->ver, prg->rev, prg->lev);
324 else
325 snprintf(phba->OptionROMVersion, 32, "%d.%d%d%c%d",
326 prg->ver, prg->rev, prg->lev,
327 dist, prg->num);
328 mempool_free(pmboxq, phba->mbox_mem_pool);
329 return;
330 }
331
332 /**
333 * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname,
334 * cfg_soft_wwnn, cfg_soft_wwpn
335 * @vport: pointer to lpfc vport data structure.
336 *
337 *
338 * Return codes
339 * None.
340 **/
341 void
342 lpfc_update_vport_wwn(struct lpfc_vport *vport)
343 {
344 uint8_t vvvl = vport->fc_sparam.cmn.valid_vendor_ver_level;
345 u32 *fawwpn_key = (u32 *)&vport->fc_sparam.un.vendorVersion[0];
346
347 /* If the soft name exists then update it using the service params */
348 if (vport->phba->cfg_soft_wwnn)
349 u64_to_wwn(vport->phba->cfg_soft_wwnn,
350 vport->fc_sparam.nodeName.u.wwn);
351 if (vport->phba->cfg_soft_wwpn)
352 u64_to_wwn(vport->phba->cfg_soft_wwpn,
353 vport->fc_sparam.portName.u.wwn);
354
355 /*
356 * If the name is empty or there exists a soft name
357 * then copy the service params name, otherwise use the fc name
358 */
359 if (vport->fc_nodename.u.wwn[0] == 0 || vport->phba->cfg_soft_wwnn)
360 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
361 sizeof(struct lpfc_name));
362 else
363 memcpy(&vport->fc_sparam.nodeName, &vport->fc_nodename,
364 sizeof(struct lpfc_name));
365
366 /*
367 * If the port name has changed, then set the Param changes flag
368 * to unreg the login
369 */
370 if (vport->fc_portname.u.wwn[0] != 0 &&
371 memcmp(&vport->fc_portname, &vport->fc_sparam.portName,
372 sizeof(struct lpfc_name)))
373 vport->vport_flag |= FAWWPN_PARAM_CHG;
374
375 if (vport->fc_portname.u.wwn[0] == 0 ||
376 vport->phba->cfg_soft_wwpn ||
377 (vvvl == 1 && cpu_to_be32(*fawwpn_key) == FAPWWN_KEY_VENDOR) ||
378 vport->vport_flag & FAWWPN_SET) {
379 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
380 sizeof(struct lpfc_name));
381 vport->vport_flag &= ~FAWWPN_SET;
382 if (vvvl == 1 && cpu_to_be32(*fawwpn_key) == FAPWWN_KEY_VENDOR)
383 vport->vport_flag |= FAWWPN_SET;
384 }
385 else
386 memcpy(&vport->fc_sparam.portName, &vport->fc_portname,
387 sizeof(struct lpfc_name));
388 }
389
390 /**
391 * lpfc_config_port_post - Perform lpfc initialization after config port
392 * @phba: pointer to lpfc hba data structure.
393 *
394 * This routine will do LPFC initialization after the CONFIG_PORT mailbox
395 * command call. It performs all internal resource and state setups on the
396 * port: post IOCB buffers, enable appropriate host interrupt attentions,
397 * ELS ring timers, etc.
398 *
399 * Return codes
400 * 0 - success.
401 * Any other value - error.
402 **/
403 int
404 lpfc_config_port_post(struct lpfc_hba *phba)
405 {
406 struct lpfc_vport *vport = phba->pport;
407 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
408 LPFC_MBOXQ_t *pmb;
409 MAILBOX_t *mb;
410 struct lpfc_dmabuf *mp;
411 struct lpfc_sli *psli = &phba->sli;
412 uint32_t status, timeout;
413 int i, j;
414 int rc;
415
416 spin_lock_irq(&phba->hbalock);
417 /*
418 * If the Config port completed correctly the HBA is not
419 * over heated any more.
420 */
421 if (phba->over_temp_state == HBA_OVER_TEMP)
422 phba->over_temp_state = HBA_NORMAL_TEMP;
423 spin_unlock_irq(&phba->hbalock);
424
425 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
426 if (!pmb) {
427 phba->link_state = LPFC_HBA_ERROR;
428 return -ENOMEM;
429 }
430 mb = &pmb->u.mb;
431
432 /* Get login parameters for NID. */
433 rc = lpfc_read_sparam(phba, pmb, 0);
434 if (rc) {
435 mempool_free(pmb, phba->mbox_mem_pool);
436 return -ENOMEM;
437 }
438
439 pmb->vport = vport;
440 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
441 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
442 "0448 Adapter failed init, mbxCmd x%x "
443 "READ_SPARM mbxStatus x%x\n",
444 mb->mbxCommand, mb->mbxStatus);
445 phba->link_state = LPFC_HBA_ERROR;
446 mp = (struct lpfc_dmabuf *) pmb->context1;
447 mempool_free(pmb, phba->mbox_mem_pool);
448 lpfc_mbuf_free(phba, mp->virt, mp->phys);
449 kfree(mp);
450 return -EIO;
451 }
452
453 mp = (struct lpfc_dmabuf *) pmb->context1;
454
455 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
456 lpfc_mbuf_free(phba, mp->virt, mp->phys);
457 kfree(mp);
458 pmb->context1 = NULL;
459 lpfc_update_vport_wwn(vport);
460
461 /* Update the fc_host data structures with new wwn. */
462 fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
463 fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
464 fc_host_max_npiv_vports(shost) = phba->max_vpi;
465
466 /* If no serial number in VPD data, use low 6 bytes of WWNN */
467 /* This should be consolidated into parse_vpd ? - mr */
468 if (phba->SerialNumber[0] == 0) {
469 uint8_t *outptr;
470
471 outptr = &vport->fc_nodename.u.s.IEEE[0];
472 for (i = 0; i < 12; i++) {
473 status = *outptr++;
474 j = ((status & 0xf0) >> 4);
475 if (j <= 9)
476 phba->SerialNumber[i] =
477 (char)((uint8_t) 0x30 + (uint8_t) j);
478 else
479 phba->SerialNumber[i] =
480 (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
481 i++;
482 j = (status & 0xf);
483 if (j <= 9)
484 phba->SerialNumber[i] =
485 (char)((uint8_t) 0x30 + (uint8_t) j);
486 else
487 phba->SerialNumber[i] =
488 (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
489 }
490 }
491
492 lpfc_read_config(phba, pmb);
493 pmb->vport = vport;
494 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
495 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
496 "0453 Adapter failed to init, mbxCmd x%x "
497 "READ_CONFIG, mbxStatus x%x\n",
498 mb->mbxCommand, mb->mbxStatus);
499 phba->link_state = LPFC_HBA_ERROR;
500 mempool_free( pmb, phba->mbox_mem_pool);
501 return -EIO;
502 }
503
504 /* Check if the port is disabled */
505 lpfc_sli_read_link_ste(phba);
506
507 /* Reset the DFT_HBA_Q_DEPTH to the max xri */
508 i = (mb->un.varRdConfig.max_xri + 1);
509 if (phba->cfg_hba_queue_depth > i) {
510 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
511 "3359 HBA queue depth changed from %d to %d\n",
512 phba->cfg_hba_queue_depth, i);
513 phba->cfg_hba_queue_depth = i;
514 }
515
516 /* Reset the DFT_LUN_Q_DEPTH to (max xri >> 3) */
517 i = (mb->un.varRdConfig.max_xri >> 3);
518 if (phba->pport->cfg_lun_queue_depth > i) {
519 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
520 "3360 LUN queue depth changed from %d to %d\n",
521 phba->pport->cfg_lun_queue_depth, i);
522 phba->pport->cfg_lun_queue_depth = i;
523 }
524
525 phba->lmt = mb->un.varRdConfig.lmt;
526
527 /* Get the default values for Model Name and Description */
528 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
529
530 phba->link_state = LPFC_LINK_DOWN;
531
532 /* Only process IOCBs on ELS ring till hba_state is READY */
533 if (psli->sli3_ring[LPFC_EXTRA_RING].sli.sli3.cmdringaddr)
534 psli->sli3_ring[LPFC_EXTRA_RING].flag |= LPFC_STOP_IOCB_EVENT;
535 if (psli->sli3_ring[LPFC_FCP_RING].sli.sli3.cmdringaddr)
536 psli->sli3_ring[LPFC_FCP_RING].flag |= LPFC_STOP_IOCB_EVENT;
537
538 /* Post receive buffers for desired rings */
539 if (phba->sli_rev != 3)
540 lpfc_post_rcv_buf(phba);
541
542 /*
543 * Configure HBA MSI-X attention conditions to messages if MSI-X mode
544 */
545 if (phba->intr_type == MSIX) {
546 rc = lpfc_config_msi(phba, pmb);
547 if (rc) {
548 mempool_free(pmb, phba->mbox_mem_pool);
549 return -EIO;
550 }
551 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
552 if (rc != MBX_SUCCESS) {
553 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
554 "0352 Config MSI mailbox command "
555 "failed, mbxCmd x%x, mbxStatus x%x\n",
556 pmb->u.mb.mbxCommand,
557 pmb->u.mb.mbxStatus);
558 mempool_free(pmb, phba->mbox_mem_pool);
559 return -EIO;
560 }
561 }
562
563 spin_lock_irq(&phba->hbalock);
564 /* Initialize ERATT handling flag */
565 phba->hba_flag &= ~HBA_ERATT_HANDLED;
566
567 /* Enable appropriate host interrupts */
568 if (lpfc_readl(phba->HCregaddr, &status)) {
569 spin_unlock_irq(&phba->hbalock);
570 return -EIO;
571 }
572 status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
573 if (psli->num_rings > 0)
574 status |= HC_R0INT_ENA;
575 if (psli->num_rings > 1)
576 status |= HC_R1INT_ENA;
577 if (psli->num_rings > 2)
578 status |= HC_R2INT_ENA;
579 if (psli->num_rings > 3)
580 status |= HC_R3INT_ENA;
581
582 if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
583 (phba->cfg_poll & DISABLE_FCP_RING_INT))
584 status &= ~(HC_R0INT_ENA);
585
586 writel(status, phba->HCregaddr);
587 readl(phba->HCregaddr); /* flush */
588 spin_unlock_irq(&phba->hbalock);
589
590 /* Set up ring-0 (ELS) timer */
591 timeout = phba->fc_ratov * 2;
592 mod_timer(&vport->els_tmofunc,
593 jiffies + msecs_to_jiffies(1000 * timeout));
594 /* Set up heart beat (HB) timer */
595 mod_timer(&phba->hb_tmofunc,
596 jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
597 phba->hb_outstanding = 0;
598 phba->last_completion_time = jiffies;
599 /* Set up error attention (ERATT) polling timer */
600 mod_timer(&phba->eratt_poll,
601 jiffies + msecs_to_jiffies(1000 * phba->eratt_poll_interval));
602
603 if (phba->hba_flag & LINK_DISABLED) {
604 lpfc_printf_log(phba,
605 KERN_ERR, LOG_INIT,
606 "2598 Adapter Link is disabled.\n");
607 lpfc_down_link(phba, pmb);
608 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
609 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
610 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
611 lpfc_printf_log(phba,
612 KERN_ERR, LOG_INIT,
613 "2599 Adapter failed to issue DOWN_LINK"
614 " mbox command rc 0x%x\n", rc);
615
616 mempool_free(pmb, phba->mbox_mem_pool);
617 return -EIO;
618 }
619 } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
620 mempool_free(pmb, phba->mbox_mem_pool);
621 rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
622 if (rc)
623 return rc;
624 }
625 /* MBOX buffer will be freed in mbox compl */
626 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
627 if (!pmb) {
628 phba->link_state = LPFC_HBA_ERROR;
629 return -ENOMEM;
630 }
631
632 lpfc_config_async(phba, pmb, LPFC_ELS_RING);
633 pmb->mbox_cmpl = lpfc_config_async_cmpl;
634 pmb->vport = phba->pport;
635 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
636
637 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
638 lpfc_printf_log(phba,
639 KERN_ERR,
640 LOG_INIT,
641 "0456 Adapter failed to issue "
642 "ASYNCEVT_ENABLE mbox status x%x\n",
643 rc);
644 mempool_free(pmb, phba->mbox_mem_pool);
645 }
646
647 /* Get Option rom version */
648 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
649 if (!pmb) {
650 phba->link_state = LPFC_HBA_ERROR;
651 return -ENOMEM;
652 }
653
654 lpfc_dump_wakeup_param(phba, pmb);
655 pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
656 pmb->vport = phba->pport;
657 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
658
659 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
660 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "
661 "to get Option ROM version status x%x\n", rc);
662 mempool_free(pmb, phba->mbox_mem_pool);
663 }
664
665 return 0;
666 }
667
668 /**
669 * lpfc_hba_init_link - Initialize the FC link
670 * @phba: pointer to lpfc hba data structure.
671 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
672 *
673 * This routine will issue the INIT_LINK mailbox command call.
674 * It is available to other drivers through the lpfc_hba data
675 * structure for use as a delayed link up mechanism with the
676 * module parameter lpfc_suppress_link_up.
677 *
678 * Return code
679 * 0 - success
680 * Any other value - error
681 **/
682 static int
683 lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
684 {
685 return lpfc_hba_init_link_fc_topology(phba, phba->cfg_topology, flag);
686 }
687
688 /**
689 * lpfc_hba_init_link_fc_topology - Initialize FC link with desired topology
690 * @phba: pointer to lpfc hba data structure.
691 * @fc_topology: desired fc topology.
692 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
693 *
694 * This routine will issue the INIT_LINK mailbox command call.
695 * It is available to other drivers through the lpfc_hba data
696 * structure for use as a delayed link up mechanism with the
697 * module parameter lpfc_suppress_link_up.
698 *
699 * Return code
700 * 0 - success
701 * Any other value - error
702 **/
703 int
704 lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology,
705 uint32_t flag)
706 {
707 struct lpfc_vport *vport = phba->pport;
708 LPFC_MBOXQ_t *pmb;
709 MAILBOX_t *mb;
710 int rc;
711
712 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
713 if (!pmb) {
714 phba->link_state = LPFC_HBA_ERROR;
715 return -ENOMEM;
716 }
717 mb = &pmb->u.mb;
718 pmb->vport = vport;
719
720 if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_MAX) ||
721 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G) &&
722 !(phba->lmt & LMT_1Gb)) ||
723 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G) &&
724 !(phba->lmt & LMT_2Gb)) ||
725 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G) &&
726 !(phba->lmt & LMT_4Gb)) ||
727 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G) &&
728 !(phba->lmt & LMT_8Gb)) ||
729 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G) &&
730 !(phba->lmt & LMT_10Gb)) ||
731 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G) &&
732 !(phba->lmt & LMT_16Gb)) ||
733 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_32G) &&
734 !(phba->lmt & LMT_32Gb))) {
735 /* Reset link speed to auto */
736 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
737 "1302 Invalid speed for this board:%d "
738 "Reset link speed to auto.\n",
739 phba->cfg_link_speed);
740 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
741 }
742 lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed);
743 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
744 if (phba->sli_rev < LPFC_SLI_REV4)
745 lpfc_set_loopback_flag(phba);
746 rc = lpfc_sli_issue_mbox(phba, pmb, flag);
747 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
748 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
749 "0498 Adapter failed to init, mbxCmd x%x "
750 "INIT_LINK, mbxStatus x%x\n",
751 mb->mbxCommand, mb->mbxStatus);
752 if (phba->sli_rev <= LPFC_SLI_REV3) {
753 /* Clear all interrupt enable conditions */
754 writel(0, phba->HCregaddr);
755 readl(phba->HCregaddr); /* flush */
756 /* Clear all pending interrupts */
757 writel(0xffffffff, phba->HAregaddr);
758 readl(phba->HAregaddr); /* flush */
759 }
760 phba->link_state = LPFC_HBA_ERROR;
761 if (rc != MBX_BUSY || flag == MBX_POLL)
762 mempool_free(pmb, phba->mbox_mem_pool);
763 return -EIO;
764 }
765 phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK;
766 if (flag == MBX_POLL)
767 mempool_free(pmb, phba->mbox_mem_pool);
768
769 return 0;
770 }
771
772 /**
773 * lpfc_hba_down_link - this routine downs the FC link
774 * @phba: pointer to lpfc hba data structure.
775 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
776 *
777 * This routine will issue the DOWN_LINK mailbox command call.
778 * It is available to other drivers through the lpfc_hba data
779 * structure for use to stop the link.
780 *
781 * Return code
782 * 0 - success
783 * Any other value - error
784 **/
785 static int
786 lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag)
787 {
788 LPFC_MBOXQ_t *pmb;
789 int rc;
790
791 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
792 if (!pmb) {
793 phba->link_state = LPFC_HBA_ERROR;
794 return -ENOMEM;
795 }
796
797 lpfc_printf_log(phba,
798 KERN_ERR, LOG_INIT,
799 "0491 Adapter Link is disabled.\n");
800 lpfc_down_link(phba, pmb);
801 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
802 rc = lpfc_sli_issue_mbox(phba, pmb, flag);
803 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
804 lpfc_printf_log(phba,
805 KERN_ERR, LOG_INIT,
806 "2522 Adapter failed to issue DOWN_LINK"
807 " mbox command rc 0x%x\n", rc);
808
809 mempool_free(pmb, phba->mbox_mem_pool);
810 return -EIO;
811 }
812 if (flag == MBX_POLL)
813 mempool_free(pmb, phba->mbox_mem_pool);
814
815 return 0;
816 }
817
818 /**
819 * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
820 * @phba: pointer to lpfc HBA data structure.
821 *
822 * This routine will do LPFC uninitialization before the HBA is reset when
823 * bringing down the SLI Layer.
824 *
825 * Return codes
826 * 0 - success.
827 * Any other value - error.
828 **/
829 int
830 lpfc_hba_down_prep(struct lpfc_hba *phba)
831 {
832 struct lpfc_vport **vports;
833 int i;
834
835 if (phba->sli_rev <= LPFC_SLI_REV3) {
836 /* Disable interrupts */
837 writel(0, phba->HCregaddr);
838 readl(phba->HCregaddr); /* flush */
839 }
840
841 if (phba->pport->load_flag & FC_UNLOADING)
842 lpfc_cleanup_discovery_resources(phba->pport);
843 else {
844 vports = lpfc_create_vport_work_array(phba);
845 if (vports != NULL)
846 for (i = 0; i <= phba->max_vports &&
847 vports[i] != NULL; i++)
848 lpfc_cleanup_discovery_resources(vports[i]);
849 lpfc_destroy_vport_work_array(phba, vports);
850 }
851 return 0;
852 }
853
854 /**
855 * lpfc_sli4_free_sp_events - Cleanup sp_queue_events to free
856 * rspiocb which got deferred
857 *
858 * @phba: pointer to lpfc HBA data structure.
859 *
860 * This routine will cleanup completed slow path events after HBA is reset
861 * when bringing down the SLI Layer.
862 *
863 *
864 * Return codes
865 * void.
866 **/
867 static void
868 lpfc_sli4_free_sp_events(struct lpfc_hba *phba)
869 {
870 struct lpfc_iocbq *rspiocbq;
871 struct hbq_dmabuf *dmabuf;
872 struct lpfc_cq_event *cq_event;
873
874 spin_lock_irq(&phba->hbalock);
875 phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
876 spin_unlock_irq(&phba->hbalock);
877
878 while (!list_empty(&phba->sli4_hba.sp_queue_event)) {
879 /* Get the response iocb from the head of work queue */
880 spin_lock_irq(&phba->hbalock);
881 list_remove_head(&phba->sli4_hba.sp_queue_event,
882 cq_event, struct lpfc_cq_event, list);
883 spin_unlock_irq(&phba->hbalock);
884
885 switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {
886 case CQE_CODE_COMPL_WQE:
887 rspiocbq = container_of(cq_event, struct lpfc_iocbq,
888 cq_event);
889 lpfc_sli_release_iocbq(phba, rspiocbq);
890 break;
891 case CQE_CODE_RECEIVE:
892 case CQE_CODE_RECEIVE_V1:
893 dmabuf = container_of(cq_event, struct hbq_dmabuf,
894 cq_event);
895 lpfc_in_buf_free(phba, &dmabuf->dbuf);
896 }
897 }
898 }
899
900 /**
901 * lpfc_hba_free_post_buf - Perform lpfc uninitialization after HBA reset
902 * @phba: pointer to lpfc HBA data structure.
903 *
904 * This routine will cleanup posted ELS buffers after the HBA is reset
905 * when bringing down the SLI Layer.
906 *
907 *
908 * Return codes
909 * void.
910 **/
911 static void
912 lpfc_hba_free_post_buf(struct lpfc_hba *phba)
913 {
914 struct lpfc_sli *psli = &phba->sli;
915 struct lpfc_sli_ring *pring;
916 struct lpfc_dmabuf *mp, *next_mp;
917 LIST_HEAD(buflist);
918 int count;
919
920 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
921 lpfc_sli_hbqbuf_free_all(phba);
922 else {
923 /* Cleanup preposted buffers on the ELS ring */
924 pring = &psli->sli3_ring[LPFC_ELS_RING];
925 spin_lock_irq(&phba->hbalock);
926 list_splice_init(&pring->postbufq, &buflist);
927 spin_unlock_irq(&phba->hbalock);
928
929 count = 0;
930 list_for_each_entry_safe(mp, next_mp, &buflist, list) {
931 list_del(&mp->list);
932 count++;
933 lpfc_mbuf_free(phba, mp->virt, mp->phys);
934 kfree(mp);
935 }
936
937 spin_lock_irq(&phba->hbalock);
938 pring->postbufq_cnt -= count;
939 spin_unlock_irq(&phba->hbalock);
940 }
941 }
942
943 /**
944 * lpfc_hba_clean_txcmplq - Perform lpfc uninitialization after HBA reset
945 * @phba: pointer to lpfc HBA data structure.
946 *
947 * This routine will cleanup the txcmplq after the HBA is reset when bringing
948 * down the SLI Layer.
949 *
950 * Return codes
951 * void
952 **/
953 static void
954 lpfc_hba_clean_txcmplq(struct lpfc_hba *phba)
955 {
956 struct lpfc_sli *psli = &phba->sli;
957 struct lpfc_queue *qp = NULL;
958 struct lpfc_sli_ring *pring;
959 LIST_HEAD(completions);
960 int i;
961
962 if (phba->sli_rev != LPFC_SLI_REV4) {
963 for (i = 0; i < psli->num_rings; i++) {
964 pring = &psli->sli3_ring[i];
965 spin_lock_irq(&phba->hbalock);
966 /* At this point in time the HBA is either reset or DOA
967 * Nothing should be on txcmplq as it will
968 * NEVER complete.
969 */
970 list_splice_init(&pring->txcmplq, &completions);
971 pring->txcmplq_cnt = 0;
972 spin_unlock_irq(&phba->hbalock);
973
974 lpfc_sli_abort_iocb_ring(phba, pring);
975 }
976 /* Cancel all the IOCBs from the completions list */
977 lpfc_sli_cancel_iocbs(phba, &completions,
978 IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
979 return;
980 }
981 list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
982 pring = qp->pring;
983 if (!pring)
984 continue;
985 spin_lock_irq(&pring->ring_lock);
986 list_splice_init(&pring->txcmplq, &completions);
987 pring->txcmplq_cnt = 0;
988 spin_unlock_irq(&pring->ring_lock);
989 lpfc_sli_abort_iocb_ring(phba, pring);
990 }
991 /* Cancel all the IOCBs from the completions list */
992 lpfc_sli_cancel_iocbs(phba, &completions,
993 IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
994 }
995
996 /**
997 * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
998 int i;
999 * @phba: pointer to lpfc HBA data structure.
1000 *
1001 * This routine will do uninitialization after the HBA is reset when bring
1002 * down the SLI Layer.
1003 *
1004 * Return codes
1005 * 0 - success.
1006 * Any other value - error.
1007 **/
1008 static int
1009 lpfc_hba_down_post_s3(struct lpfc_hba *phba)
1010 {
1011 lpfc_hba_free_post_buf(phba);
1012 lpfc_hba_clean_txcmplq(phba);
1013 return 0;
1014 }
1015
1016 /**
1017 * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
1018 * @phba: pointer to lpfc HBA data structure.
1019 *
1020 * This routine will do uninitialization after the HBA is reset when bring
1021 * down the SLI Layer.
1022 *
1023 * Return codes
1024 * 0 - success.
1025 * Any other value - error.
1026 **/
1027 static int
1028 lpfc_hba_down_post_s4(struct lpfc_hba *phba)
1029 {
1030 struct lpfc_scsi_buf *psb, *psb_next;
1031 struct lpfc_nvmet_rcv_ctx *ctxp, *ctxp_next;
1032 LIST_HEAD(aborts);
1033 LIST_HEAD(nvme_aborts);
1034 LIST_HEAD(nvmet_aborts);
1035 unsigned long iflag = 0;
1036 struct lpfc_sglq *sglq_entry = NULL;
1037 int cnt;
1038
1039
1040 lpfc_sli_hbqbuf_free_all(phba);
1041 lpfc_hba_clean_txcmplq(phba);
1042
1043 /* At this point in time the HBA is either reset or DOA. Either
1044 * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
1045 * on the lpfc_els_sgl_list so that it can either be freed if the
1046 * driver is unloading or reposted if the driver is restarting
1047 * the port.
1048 */
1049 spin_lock_irq(&phba->hbalock); /* required for lpfc_els_sgl_list and */
1050 /* scsl_buf_list */
1051 /* sgl_list_lock required because worker thread uses this
1052 * list.
1053 */
1054 spin_lock(&phba->sli4_hba.sgl_list_lock);
1055 list_for_each_entry(sglq_entry,
1056 &phba->sli4_hba.lpfc_abts_els_sgl_list, list)
1057 sglq_entry->state = SGL_FREED;
1058
1059 list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
1060 &phba->sli4_hba.lpfc_els_sgl_list);
1061
1062
1063 spin_unlock(&phba->sli4_hba.sgl_list_lock);
1064 /* abts_scsi_buf_list_lock required because worker thread uses this
1065 * list.
1066 */
1067 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
1068 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1069 list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list,
1070 &aborts);
1071 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1072 }
1073
1074 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
1075 spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock);
1076 list_splice_init(&phba->sli4_hba.lpfc_abts_nvme_buf_list,
1077 &nvme_aborts);
1078 list_splice_init(&phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
1079 &nvmet_aborts);
1080 spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock);
1081 }
1082
1083 spin_unlock_irq(&phba->hbalock);
1084
1085 list_for_each_entry_safe(psb, psb_next, &aborts, list) {
1086 psb->pCmd = NULL;
1087 psb->status = IOSTAT_SUCCESS;
1088 }
1089 spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
1090 list_splice(&aborts, &phba->lpfc_scsi_buf_list_put);
1091 spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
1092
1093 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
1094 cnt = 0;
1095 list_for_each_entry_safe(psb, psb_next, &nvme_aborts, list) {
1096 psb->pCmd = NULL;
1097 psb->status = IOSTAT_SUCCESS;
1098 cnt++;
1099 }
1100 spin_lock_irqsave(&phba->nvme_buf_list_put_lock, iflag);
1101 phba->put_nvme_bufs += cnt;
1102 list_splice(&nvme_aborts, &phba->lpfc_nvme_buf_list_put);
1103 spin_unlock_irqrestore(&phba->nvme_buf_list_put_lock, iflag);
1104
1105 list_for_each_entry_safe(ctxp, ctxp_next, &nvmet_aborts, list) {
1106 ctxp->flag &= ~(LPFC_NVMET_XBUSY | LPFC_NVMET_ABORT_OP);
1107 lpfc_nvmet_ctxbuf_post(phba, ctxp->ctxbuf);
1108 }
1109 }
1110
1111 lpfc_sli4_free_sp_events(phba);
1112 return 0;
1113 }
1114
1115 /**
1116 * lpfc_hba_down_post - Wrapper func for hba down post routine
1117 * @phba: pointer to lpfc HBA data structure.
1118 *
1119 * This routine wraps the actual SLI3 or SLI4 routine for performing
1120 * uninitialization after the HBA is reset when bring down the SLI Layer.
1121 *
1122 * Return codes
1123 * 0 - success.
1124 * Any other value - error.
1125 **/
1126 int
1127 lpfc_hba_down_post(struct lpfc_hba *phba)
1128 {
1129 return (*phba->lpfc_hba_down_post)(phba);
1130 }
1131
1132 /**
1133 * lpfc_hb_timeout - The HBA-timer timeout handler
1134 * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1135 *
1136 * This is the HBA-timer timeout handler registered to the lpfc driver. When
1137 * this timer fires, a HBA timeout event shall be posted to the lpfc driver
1138 * work-port-events bitmap and the worker thread is notified. This timeout
1139 * event will be used by the worker thread to invoke the actual timeout
1140 * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
1141 * be performed in the timeout handler and the HBA timeout event bit shall
1142 * be cleared by the worker thread after it has taken the event bitmap out.
1143 **/
1144 static void
1145 lpfc_hb_timeout(struct timer_list *t)
1146 {
1147 struct lpfc_hba *phba;
1148 uint32_t tmo_posted;
1149 unsigned long iflag;
1150
1151 phba = from_timer(phba, t, hb_tmofunc);
1152
1153 /* Check for heart beat timeout conditions */
1154 spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1155 tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
1156 if (!tmo_posted)
1157 phba->pport->work_port_events |= WORKER_HB_TMO;
1158 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1159
1160 /* Tell the worker thread there is work to do */
1161 if (!tmo_posted)
1162 lpfc_worker_wake_up(phba);
1163 return;
1164 }
1165
1166 /**
1167 * lpfc_rrq_timeout - The RRQ-timer timeout handler
1168 * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1169 *
1170 * This is the RRQ-timer timeout handler registered to the lpfc driver. When
1171 * this timer fires, a RRQ timeout event shall be posted to the lpfc driver
1172 * work-port-events bitmap and the worker thread is notified. This timeout
1173 * event will be used by the worker thread to invoke the actual timeout
1174 * handler routine, lpfc_rrq_handler. Any periodical operations will
1175 * be performed in the timeout handler and the RRQ timeout event bit shall
1176 * be cleared by the worker thread after it has taken the event bitmap out.
1177 **/
1178 static void
1179 lpfc_rrq_timeout(struct timer_list *t)
1180 {
1181 struct lpfc_hba *phba;
1182 unsigned long iflag;
1183
1184 phba = from_timer(phba, t, rrq_tmr);
1185 spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1186 if (!(phba->pport->load_flag & FC_UNLOADING))
1187 phba->hba_flag |= HBA_RRQ_ACTIVE;
1188 else
1189 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
1190 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1191
1192 if (!(phba->pport->load_flag & FC_UNLOADING))
1193 lpfc_worker_wake_up(phba);
1194 }
1195
1196 /**
1197 * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
1198 * @phba: pointer to lpfc hba data structure.
1199 * @pmboxq: pointer to the driver internal queue element for mailbox command.
1200 *
1201 * This is the callback function to the lpfc heart-beat mailbox command.
1202 * If configured, the lpfc driver issues the heart-beat mailbox command to
1203 * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
1204 * heart-beat mailbox command is issued, the driver shall set up heart-beat
1205 * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
1206 * heart-beat outstanding state. Once the mailbox command comes back and
1207 * no error conditions detected, the heart-beat mailbox command timer is
1208 * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
1209 * state is cleared for the next heart-beat. If the timer expired with the
1210 * heart-beat outstanding state set, the driver will put the HBA offline.
1211 **/
1212 static void
1213 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
1214 {
1215 unsigned long drvr_flag;
1216
1217 spin_lock_irqsave(&phba->hbalock, drvr_flag);
1218 phba->hb_outstanding = 0;
1219 spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1220
1221 /* Check and reset heart-beat timer is necessary */
1222 mempool_free(pmboxq, phba->mbox_mem_pool);
1223 if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
1224 !(phba->link_state == LPFC_HBA_ERROR) &&
1225 !(phba->pport->load_flag & FC_UNLOADING))
1226 mod_timer(&phba->hb_tmofunc,
1227 jiffies +
1228 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1229 return;
1230 }
1231
1232 /**
1233 * lpfc_hb_timeout_handler - The HBA-timer timeout handler
1234 * @phba: pointer to lpfc hba data structure.
1235 *
1236 * This is the actual HBA-timer timeout handler to be invoked by the worker
1237 * thread whenever the HBA timer fired and HBA-timeout event posted. This
1238 * handler performs any periodic operations needed for the device. If such
1239 * periodic event has already been attended to either in the interrupt handler
1240 * or by processing slow-ring or fast-ring events within the HBA-timer
1241 * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
1242 * the timer for the next timeout period. If lpfc heart-beat mailbox command
1243 * is configured and there is no heart-beat mailbox command outstanding, a
1244 * heart-beat mailbox is issued and timer set properly. Otherwise, if there
1245 * has been a heart-beat mailbox command outstanding, the HBA shall be put
1246 * to offline.
1247 **/
1248 void
1249 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
1250 {
1251 struct lpfc_vport **vports;
1252 LPFC_MBOXQ_t *pmboxq;
1253 struct lpfc_dmabuf *buf_ptr;
1254 int retval, i;
1255 struct lpfc_sli *psli = &phba->sli;
1256 LIST_HEAD(completions);
1257 struct lpfc_queue *qp;
1258 unsigned long time_elapsed;
1259 uint32_t tick_cqe, max_cqe, val;
1260 uint64_t tot, data1, data2, data3;
1261 struct lpfc_nvmet_tgtport *tgtp;
1262 struct lpfc_register reg_data;
1263 void __iomem *eqdreg = phba->sli4_hba.u.if_type2.EQDregaddr;
1264
1265 vports = lpfc_create_vport_work_array(phba);
1266 if (vports != NULL)
1267 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
1268 lpfc_rcv_seq_check_edtov(vports[i]);
1269 lpfc_fdmi_num_disc_check(vports[i]);
1270 }
1271 lpfc_destroy_vport_work_array(phba, vports);
1272
1273 if ((phba->link_state == LPFC_HBA_ERROR) ||
1274 (phba->pport->load_flag & FC_UNLOADING) ||
1275 (phba->pport->fc_flag & FC_OFFLINE_MODE))
1276 return;
1277
1278 if (phba->cfg_auto_imax) {
1279 if (!phba->last_eqdelay_time) {
1280 phba->last_eqdelay_time = jiffies;
1281 goto skip_eqdelay;
1282 }
1283 time_elapsed = jiffies - phba->last_eqdelay_time;
1284 phba->last_eqdelay_time = jiffies;
1285
1286 tot = 0xffff;
1287 /* Check outstanding IO count */
1288 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
1289 if (phba->nvmet_support) {
1290 tgtp = phba->targetport->private;
1291 /* Calculate outstanding IOs */
1292 tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
1293 tot += atomic_read(&tgtp->xmt_fcp_release);
1294 tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
1295 } else {
1296 tot = atomic_read(&phba->fc4NvmeIoCmpls);
1297 data1 = atomic_read(
1298 &phba->fc4NvmeInputRequests);
1299 data2 = atomic_read(
1300 &phba->fc4NvmeOutputRequests);
1301 data3 = atomic_read(
1302 &phba->fc4NvmeControlRequests);
1303 tot = (data1 + data2 + data3) - tot;
1304 }
1305 }
1306
1307 /* Interrupts per sec per EQ */
1308 val = phba->cfg_fcp_imax / phba->io_channel_irqs;
1309 tick_cqe = val / CONFIG_HZ; /* Per tick per EQ */
1310
1311 /* Assume 1 CQE/ISR, calc max CQEs allowed for time duration */
1312 max_cqe = time_elapsed * tick_cqe;
1313
1314 for (i = 0; i < phba->io_channel_irqs; i++) {
1315 /* Fast-path EQ */
1316 qp = phba->sli4_hba.hba_eq[i];
1317 if (!qp)
1318 continue;
1319
1320 /* Use no EQ delay if we don't have many outstanding
1321 * IOs, or if we are only processing 1 CQE/ISR or less.
1322 * Otherwise, assume we can process up to lpfc_fcp_imax
1323 * interrupts per HBA.
1324 */
1325 if (tot < LPFC_NODELAY_MAX_IO ||
1326 qp->EQ_cqe_cnt <= max_cqe)
1327 val = 0;
1328 else
1329 val = phba->cfg_fcp_imax;
1330
1331 if (phba->sli.sli_flag & LPFC_SLI_USE_EQDR) {
1332 /* Use EQ Delay Register method */
1333
1334 /* Convert for EQ Delay register */
1335 if (val) {
1336 /* First, interrupts per sec per EQ */
1337 val = phba->cfg_fcp_imax /
1338 phba->io_channel_irqs;
1339
1340 /* us delay between each interrupt */
1341 val = LPFC_SEC_TO_USEC / val;
1342 }
1343 if (val != qp->q_mode) {
1344 reg_data.word0 = 0;
1345 bf_set(lpfc_sliport_eqdelay_id,
1346 &reg_data, qp->queue_id);
1347 bf_set(lpfc_sliport_eqdelay_delay,
1348 &reg_data, val);
1349 writel(reg_data.word0, eqdreg);
1350 }
1351 } else {
1352 /* Use mbox command method */
1353 if (val != qp->q_mode)
1354 lpfc_modify_hba_eq_delay(phba, i,
1355 1, val);
1356 }
1357
1358 /*
1359 * val is cfg_fcp_imax or 0 for mbox delay or us delay
1360 * between interrupts for EQDR.
1361 */
1362 qp->q_mode = val;
1363 qp->EQ_cqe_cnt = 0;
1364 }
1365 }
1366
1367 skip_eqdelay:
1368 spin_lock_irq(&phba->pport->work_port_lock);
1369
1370 if (time_after(phba->last_completion_time +
1371 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL),
1372 jiffies)) {
1373 spin_unlock_irq(&phba->pport->work_port_lock);
1374 if (!phba->hb_outstanding)
1375 mod_timer(&phba->hb_tmofunc,
1376 jiffies +
1377 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1378 else
1379 mod_timer(&phba->hb_tmofunc,
1380 jiffies +
1381 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1382 return;
1383 }
1384 spin_unlock_irq(&phba->pport->work_port_lock);
1385
1386 if (phba->elsbuf_cnt &&
1387 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
1388 spin_lock_irq(&phba->hbalock);
1389 list_splice_init(&phba->elsbuf, &completions);
1390 phba->elsbuf_cnt = 0;
1391 phba->elsbuf_prev_cnt = 0;
1392 spin_unlock_irq(&phba->hbalock);
1393
1394 while (!list_empty(&completions)) {
1395 list_remove_head(&completions, buf_ptr,
1396 struct lpfc_dmabuf, list);
1397 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1398 kfree(buf_ptr);
1399 }
1400 }
1401 phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
1402
1403 /* If there is no heart beat outstanding, issue a heartbeat command */
1404 if (phba->cfg_enable_hba_heartbeat) {
1405 if (!phba->hb_outstanding) {
1406 if ((!(psli->sli_flag & LPFC_SLI_MBOX_ACTIVE)) &&
1407 (list_empty(&psli->mboxq))) {
1408 pmboxq = mempool_alloc(phba->mbox_mem_pool,
1409 GFP_KERNEL);
1410 if (!pmboxq) {
1411 mod_timer(&phba->hb_tmofunc,
1412 jiffies +
1413 msecs_to_jiffies(1000 *
1414 LPFC_HB_MBOX_INTERVAL));
1415 return;
1416 }
1417
1418 lpfc_heart_beat(phba, pmboxq);
1419 pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
1420 pmboxq->vport = phba->pport;
1421 retval = lpfc_sli_issue_mbox(phba, pmboxq,
1422 MBX_NOWAIT);
1423
1424 if (retval != MBX_BUSY &&
1425 retval != MBX_SUCCESS) {
1426 mempool_free(pmboxq,
1427 phba->mbox_mem_pool);
1428 mod_timer(&phba->hb_tmofunc,
1429 jiffies +
1430 msecs_to_jiffies(1000 *
1431 LPFC_HB_MBOX_INTERVAL));
1432 return;
1433 }
1434 phba->skipped_hb = 0;
1435 phba->hb_outstanding = 1;
1436 } else if (time_before_eq(phba->last_completion_time,
1437 phba->skipped_hb)) {
1438 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1439 "2857 Last completion time not "
1440 " updated in %d ms\n",
1441 jiffies_to_msecs(jiffies
1442 - phba->last_completion_time));
1443 } else
1444 phba->skipped_hb = jiffies;
1445
1446 mod_timer(&phba->hb_tmofunc,
1447 jiffies +
1448 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1449 return;
1450 } else {
1451 /*
1452 * If heart beat timeout called with hb_outstanding set
1453 * we need to give the hb mailbox cmd a chance to
1454 * complete or TMO.
1455 */
1456 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1457 "0459 Adapter heartbeat still out"
1458 "standing:last compl time was %d ms.\n",
1459 jiffies_to_msecs(jiffies
1460 - phba->last_completion_time));
1461 mod_timer(&phba->hb_tmofunc,
1462 jiffies +
1463 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1464 }
1465 } else {
1466 mod_timer(&phba->hb_tmofunc,
1467 jiffies +
1468 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1469 }
1470 }
1471
1472 /**
1473 * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1474 * @phba: pointer to lpfc hba data structure.
1475 *
1476 * This routine is called to bring the HBA offline when HBA hardware error
1477 * other than Port Error 6 has been detected.
1478 **/
1479 static void
1480 lpfc_offline_eratt(struct lpfc_hba *phba)
1481 {
1482 struct lpfc_sli *psli = &phba->sli;
1483
1484 spin_lock_irq(&phba->hbalock);
1485 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1486 spin_unlock_irq(&phba->hbalock);
1487 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1488
1489 lpfc_offline(phba);
1490 lpfc_reset_barrier(phba);
1491 spin_lock_irq(&phba->hbalock);
1492 lpfc_sli_brdreset(phba);
1493 spin_unlock_irq(&phba->hbalock);
1494 lpfc_hba_down_post(phba);
1495 lpfc_sli_brdready(phba, HS_MBRDY);
1496 lpfc_unblock_mgmt_io(phba);
1497 phba->link_state = LPFC_HBA_ERROR;
1498 return;
1499 }
1500
1501 /**
1502 * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1503 * @phba: pointer to lpfc hba data structure.
1504 *
1505 * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1506 * other than Port Error 6 has been detected.
1507 **/
1508 void
1509 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
1510 {
1511 spin_lock_irq(&phba->hbalock);
1512 phba->link_state = LPFC_HBA_ERROR;
1513 spin_unlock_irq(&phba->hbalock);
1514
1515 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1516 lpfc_offline(phba);
1517 lpfc_hba_down_post(phba);
1518 lpfc_unblock_mgmt_io(phba);
1519 }
1520
1521 /**
1522 * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1523 * @phba: pointer to lpfc hba data structure.
1524 *
1525 * This routine is invoked to handle the deferred HBA hardware error
1526 * conditions. This type of error is indicated by HBA by setting ER1
1527 * and another ER bit in the host status register. The driver will
1528 * wait until the ER1 bit clears before handling the error condition.
1529 **/
1530 static void
1531 lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
1532 {
1533 uint32_t old_host_status = phba->work_hs;
1534 struct lpfc_sli *psli = &phba->sli;
1535
1536 /* If the pci channel is offline, ignore possible errors,
1537 * since we cannot communicate with the pci card anyway.
1538 */
1539 if (pci_channel_offline(phba->pcidev)) {
1540 spin_lock_irq(&phba->hbalock);
1541 phba->hba_flag &= ~DEFER_ERATT;
1542 spin_unlock_irq(&phba->hbalock);
1543 return;
1544 }
1545
1546 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1547 "0479 Deferred Adapter Hardware Error "
1548 "Data: x%x x%x x%x\n",
1549 phba->work_hs,
1550 phba->work_status[0], phba->work_status[1]);
1551
1552 spin_lock_irq(&phba->hbalock);
1553 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1554 spin_unlock_irq(&phba->hbalock);
1555
1556
1557 /*
1558 * Firmware stops when it triggred erratt. That could cause the I/Os
1559 * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1560 * SCSI layer retry it after re-establishing link.
1561 */
1562 lpfc_sli_abort_fcp_rings(phba);
1563
1564 /*
1565 * There was a firmware error. Take the hba offline and then
1566 * attempt to restart it.
1567 */
1568 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
1569 lpfc_offline(phba);
1570
1571 /* Wait for the ER1 bit to clear.*/
1572 while (phba->work_hs & HS_FFER1) {
1573 msleep(100);
1574 if (lpfc_readl(phba->HSregaddr, &phba->work_hs)) {
1575 phba->work_hs = UNPLUG_ERR ;
1576 break;
1577 }
1578 /* If driver is unloading let the worker thread continue */
1579 if (phba->pport->load_flag & FC_UNLOADING) {
1580 phba->work_hs = 0;
1581 break;
1582 }
1583 }
1584
1585 /*
1586 * This is to ptrotect against a race condition in which
1587 * first write to the host attention register clear the
1588 * host status register.
1589 */
1590 if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
1591 phba->work_hs = old_host_status & ~HS_FFER1;
1592
1593 spin_lock_irq(&phba->hbalock);
1594 phba->hba_flag &= ~DEFER_ERATT;
1595 spin_unlock_irq(&phba->hbalock);
1596 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
1597 phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
1598 }
1599
1600 static void
1601 lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
1602 {
1603 struct lpfc_board_event_header board_event;
1604 struct Scsi_Host *shost;
1605
1606 board_event.event_type = FC_REG_BOARD_EVENT;
1607 board_event.subcategory = LPFC_EVENT_PORTINTERR;
1608 shost = lpfc_shost_from_vport(phba->pport);
1609 fc_host_post_vendor_event(shost, fc_get_event_number(),
1610 sizeof(board_event),
1611 (char *) &board_event,
1612 LPFC_NL_VENDOR_ID);
1613 }
1614
1615 /**
1616 * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1617 * @phba: pointer to lpfc hba data structure.
1618 *
1619 * This routine is invoked to handle the following HBA hardware error
1620 * conditions:
1621 * 1 - HBA error attention interrupt
1622 * 2 - DMA ring index out of range
1623 * 3 - Mailbox command came back as unknown
1624 **/
1625 static void
1626 lpfc_handle_eratt_s3(struct lpfc_hba *phba)
1627 {
1628 struct lpfc_vport *vport = phba->pport;
1629 struct lpfc_sli *psli = &phba->sli;
1630 uint32_t event_data;
1631 unsigned long temperature;
1632 struct temp_event temp_event_data;
1633 struct Scsi_Host *shost;
1634
1635 /* If the pci channel is offline, ignore possible errors,
1636 * since we cannot communicate with the pci card anyway.
1637 */
1638 if (pci_channel_offline(phba->pcidev)) {
1639 spin_lock_irq(&phba->hbalock);
1640 phba->hba_flag &= ~DEFER_ERATT;
1641 spin_unlock_irq(&phba->hbalock);
1642 return;
1643 }
1644
1645 /* If resets are disabled then leave the HBA alone and return */
1646 if (!phba->cfg_enable_hba_reset)
1647 return;
1648
1649 /* Send an internal error event to mgmt application */
1650 lpfc_board_errevt_to_mgmt(phba);
1651
1652 if (phba->hba_flag & DEFER_ERATT)
1653 lpfc_handle_deferred_eratt(phba);
1654
1655 if ((phba->work_hs & HS_FFER6) || (phba->work_hs & HS_FFER8)) {
1656 if (phba->work_hs & HS_FFER6)
1657 /* Re-establishing Link */
1658 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1659 "1301 Re-establishing Link "
1660 "Data: x%x x%x x%x\n",
1661 phba->work_hs, phba->work_status[0],
1662 phba->work_status[1]);
1663 if (phba->work_hs & HS_FFER8)
1664 /* Device Zeroization */
1665 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1666 "2861 Host Authentication device "
1667 "zeroization Data:x%x x%x x%x\n",
1668 phba->work_hs, phba->work_status[0],
1669 phba->work_status[1]);
1670
1671 spin_lock_irq(&phba->hbalock);
1672 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1673 spin_unlock_irq(&phba->hbalock);
1674
1675 /*
1676 * Firmware stops when it triggled erratt with HS_FFER6.
1677 * That could cause the I/Os dropped by the firmware.
1678 * Error iocb (I/O) on txcmplq and let the SCSI layer
1679 * retry it after re-establishing link.
1680 */
1681 lpfc_sli_abort_fcp_rings(phba);
1682
1683 /*
1684 * There was a firmware error. Take the hba offline and then
1685 * attempt to restart it.
1686 */
1687 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1688 lpfc_offline(phba);
1689 lpfc_sli_brdrestart(phba);
1690 if (lpfc_online(phba) == 0) { /* Initialize the HBA */
1691 lpfc_unblock_mgmt_io(phba);
1692 return;
1693 }
1694 lpfc_unblock_mgmt_io(phba);
1695 } else if (phba->work_hs & HS_CRIT_TEMP) {
1696 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
1697 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1698 temp_event_data.event_code = LPFC_CRIT_TEMP;
1699 temp_event_data.data = (uint32_t)temperature;
1700
1701 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1702 "0406 Adapter maximum temperature exceeded "
1703 "(%ld), taking this port offline "
1704 "Data: x%x x%x x%x\n",
1705 temperature, phba->work_hs,
1706 phba->work_status[0], phba->work_status[1]);
1707
1708 shost = lpfc_shost_from_vport(phba->pport);
1709 fc_host_post_vendor_event(shost, fc_get_event_number(),
1710 sizeof(temp_event_data),
1711 (char *) &temp_event_data,
1712 SCSI_NL_VID_TYPE_PCI
1713 | PCI_VENDOR_ID_EMULEX);
1714
1715 spin_lock_irq(&phba->hbalock);
1716 phba->over_temp_state = HBA_OVER_TEMP;
1717 spin_unlock_irq(&phba->hbalock);
1718 lpfc_offline_eratt(phba);
1719
1720 } else {
1721 /* The if clause above forces this code path when the status
1722 * failure is a value other than FFER6. Do not call the offline
1723 * twice. This is the adapter hardware error path.
1724 */
1725 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1726 "0457 Adapter Hardware Error "
1727 "Data: x%x x%x x%x\n",
1728 phba->work_hs,
1729 phba->work_status[0], phba->work_status[1]);
1730
1731 event_data = FC_REG_DUMP_EVENT;
1732 shost = lpfc_shost_from_vport(vport);
1733 fc_host_post_vendor_event(shost, fc_get_event_number(),
1734 sizeof(event_data), (char *) &event_data,
1735 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1736
1737 lpfc_offline_eratt(phba);
1738 }
1739 return;
1740 }
1741
1742 /**
1743 * lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
1744 * @phba: pointer to lpfc hba data structure.
1745 * @mbx_action: flag for mailbox shutdown action.
1746 *
1747 * This routine is invoked to perform an SLI4 port PCI function reset in
1748 * response to port status register polling attention. It waits for port
1749 * status register (ERR, RDY, RN) bits before proceeding with function reset.
1750 * During this process, interrupt vectors are freed and later requested
1751 * for handling possible port resource change.
1752 **/
1753 static int
1754 lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action,
1755 bool en_rn_msg)
1756 {
1757 int rc;
1758 uint32_t intr_mode;
1759
1760 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
1761 LPFC_SLI_INTF_IF_TYPE_2) {
1762 /*
1763 * On error status condition, driver need to wait for port
1764 * ready before performing reset.
1765 */
1766 rc = lpfc_sli4_pdev_status_reg_wait(phba);
1767 if (rc)
1768 return rc;
1769 }
1770
1771 /* need reset: attempt for port recovery */
1772 if (en_rn_msg)
1773 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1774 "2887 Reset Needed: Attempting Port "
1775 "Recovery...\n");
1776 lpfc_offline_prep(phba, mbx_action);
1777 lpfc_offline(phba);
1778 /* release interrupt for possible resource change */
1779 lpfc_sli4_disable_intr(phba);
1780 lpfc_sli_brdrestart(phba);
1781 /* request and enable interrupt */
1782 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
1783 if (intr_mode == LPFC_INTR_ERROR) {
1784 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1785 "3175 Failed to enable interrupt\n");
1786 return -EIO;
1787 }
1788 phba->intr_mode = intr_mode;
1789 rc = lpfc_online(phba);
1790 if (rc == 0)
1791 lpfc_unblock_mgmt_io(phba);
1792
1793 return rc;
1794 }
1795
1796 /**
1797 * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1798 * @phba: pointer to lpfc hba data structure.
1799 *
1800 * This routine is invoked to handle the SLI4 HBA hardware error attention
1801 * conditions.
1802 **/
1803 static void
1804 lpfc_handle_eratt_s4(struct lpfc_hba *phba)
1805 {
1806 struct lpfc_vport *vport = phba->pport;
1807 uint32_t event_data;
1808 struct Scsi_Host *shost;
1809 uint32_t if_type;
1810 struct lpfc_register portstat_reg = {0};
1811 uint32_t reg_err1, reg_err2;
1812 uint32_t uerrlo_reg, uemasklo_reg;
1813 uint32_t smphr_port_status = 0, pci_rd_rc1, pci_rd_rc2;
1814 bool en_rn_msg = true;
1815 struct temp_event temp_event_data;
1816 struct lpfc_register portsmphr_reg;
1817 int rc, i;
1818
1819 /* If the pci channel is offline, ignore possible errors, since
1820 * we cannot communicate with the pci card anyway.
1821 */
1822 if (pci_channel_offline(phba->pcidev))
1823 return;
1824
1825 memset(&portsmphr_reg, 0, sizeof(portsmphr_reg));
1826 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
1827 switch (if_type) {
1828 case LPFC_SLI_INTF_IF_TYPE_0:
1829 pci_rd_rc1 = lpfc_readl(
1830 phba->sli4_hba.u.if_type0.UERRLOregaddr,
1831 &uerrlo_reg);
1832 pci_rd_rc2 = lpfc_readl(
1833 phba->sli4_hba.u.if_type0.UEMASKLOregaddr,
1834 &uemasklo_reg);
1835 /* consider PCI bus read error as pci_channel_offline */
1836 if (pci_rd_rc1 == -EIO && pci_rd_rc2 == -EIO)
1837 return;
1838 if (!(phba->hba_flag & HBA_RECOVERABLE_UE)) {
1839 lpfc_sli4_offline_eratt(phba);
1840 return;
1841 }
1842 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1843 "7623 Checking UE recoverable");
1844
1845 for (i = 0; i < phba->sli4_hba.ue_to_sr / 1000; i++) {
1846 if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
1847 &portsmphr_reg.word0))
1848 continue;
1849
1850 smphr_port_status = bf_get(lpfc_port_smphr_port_status,
1851 &portsmphr_reg);
1852 if ((smphr_port_status & LPFC_PORT_SEM_MASK) ==
1853 LPFC_PORT_SEM_UE_RECOVERABLE)
1854 break;
1855 /*Sleep for 1Sec, before checking SEMAPHORE */
1856 msleep(1000);
1857 }
1858
1859 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1860 "4827 smphr_port_status x%x : Waited %dSec",
1861 smphr_port_status, i);
1862
1863 /* Recoverable UE, reset the HBA device */
1864 if ((smphr_port_status & LPFC_PORT_SEM_MASK) ==
1865 LPFC_PORT_SEM_UE_RECOVERABLE) {
1866 for (i = 0; i < 20; i++) {
1867 msleep(1000);
1868 if (!lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
1869 &portsmphr_reg.word0) &&
1870 (LPFC_POST_STAGE_PORT_READY ==
1871 bf_get(lpfc_port_smphr_port_status,
1872 &portsmphr_reg))) {
1873 rc = lpfc_sli4_port_sta_fn_reset(phba,
1874 LPFC_MBX_NO_WAIT, en_rn_msg);
1875 if (rc == 0)
1876 return;
1877 lpfc_printf_log(phba,
1878 KERN_ERR, LOG_INIT,
1879 "4215 Failed to recover UE");
1880 break;
1881 }
1882 }
1883 }
1884 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1885 "7624 Firmware not ready: Failing UE recovery,"
1886 " waited %dSec", i);
1887 lpfc_sli4_offline_eratt(phba);
1888 break;
1889
1890 case LPFC_SLI_INTF_IF_TYPE_2:
1891 pci_rd_rc1 = lpfc_readl(
1892 phba->sli4_hba.u.if_type2.STATUSregaddr,
1893 &portstat_reg.word0);
1894 /* consider PCI bus read error as pci_channel_offline */
1895 if (pci_rd_rc1 == -EIO) {
1896 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1897 "3151 PCI bus read access failure: x%x\n",
1898 readl(phba->sli4_hba.u.if_type2.STATUSregaddr));
1899 return;
1900 }
1901 reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
1902 reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
1903 if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {
1904 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1905 "2889 Port Overtemperature event, "
1906 "taking port offline Data: x%x x%x\n",
1907 reg_err1, reg_err2);
1908
1909 phba->sfp_alarm |= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;
1910 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1911 temp_event_data.event_code = LPFC_CRIT_TEMP;
1912 temp_event_data.data = 0xFFFFFFFF;
1913
1914 shost = lpfc_shost_from_vport(phba->pport);
1915 fc_host_post_vendor_event(shost, fc_get_event_number(),
1916 sizeof(temp_event_data),
1917 (char *)&temp_event_data,
1918 SCSI_NL_VID_TYPE_PCI
1919 | PCI_VENDOR_ID_EMULEX);
1920
1921 spin_lock_irq(&phba->hbalock);
1922 phba->over_temp_state = HBA_OVER_TEMP;
1923 spin_unlock_irq(&phba->hbalock);
1924 lpfc_sli4_offline_eratt(phba);
1925 return;
1926 }
1927 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1928 reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) {
1929 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1930 "3143 Port Down: Firmware Update "
1931 "Detected\n");
1932 en_rn_msg = false;
1933 } else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1934 reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1935 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1936 "3144 Port Down: Debug Dump\n");
1937 else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1938 reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)
1939 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1940 "3145 Port Down: Provisioning\n");
1941
1942 /* If resets are disabled then leave the HBA alone and return */
1943 if (!phba->cfg_enable_hba_reset)
1944 return;
1945
1946 /* Check port status register for function reset */
1947 rc = lpfc_sli4_port_sta_fn_reset(phba, LPFC_MBX_NO_WAIT,
1948 en_rn_msg);
1949 if (rc == 0) {
1950 /* don't report event on forced debug dump */
1951 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1952 reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1953 return;
1954 else
1955 break;
1956 }
1957 /* fall through for not able to recover */
1958 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1959 "3152 Unrecoverable error, bring the port "
1960 "offline\n");
1961 lpfc_sli4_offline_eratt(phba);
1962 break;
1963 case LPFC_SLI_INTF_IF_TYPE_1:
1964 default:
1965 break;
1966 }
1967 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1968 "3123 Report dump event to upper layer\n");
1969 /* Send an internal error event to mgmt application */
1970 lpfc_board_errevt_to_mgmt(phba);
1971
1972 event_data = FC_REG_DUMP_EVENT;
1973 shost = lpfc_shost_from_vport(vport);
1974 fc_host_post_vendor_event(shost, fc_get_event_number(),
1975 sizeof(event_data), (char *) &event_data,
1976 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1977 }
1978
1979 /**
1980 * lpfc_handle_eratt - Wrapper func for handling hba error attention
1981 * @phba: pointer to lpfc HBA data structure.
1982 *
1983 * This routine wraps the actual SLI3 or SLI4 hba error attention handling
1984 * routine from the API jump table function pointer from the lpfc_hba struct.
1985 *
1986 * Return codes
1987 * 0 - success.
1988 * Any other value - error.
1989 **/
1990 void
1991 lpfc_handle_eratt(struct lpfc_hba *phba)
1992 {
1993 (*phba->lpfc_handle_eratt)(phba);
1994 }
1995
1996 /**
1997 * lpfc_handle_latt - The HBA link event handler
1998 * @phba: pointer to lpfc hba data structure.
1999 *
2000 * This routine is invoked from the worker thread to handle a HBA host
2001 * attention link event. SLI3 only.
2002 **/
2003 void
2004 lpfc_handle_latt(struct lpfc_hba *phba)
2005 {
2006 struct lpfc_vport *vport = phba->pport;
2007 struct lpfc_sli *psli = &phba->sli;
2008 LPFC_MBOXQ_t *pmb;
2009 volatile uint32_t control;
2010 struct lpfc_dmabuf *mp;
2011 int rc = 0;
2012
2013 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2014 if (!pmb) {
2015 rc = 1;
2016 goto lpfc_handle_latt_err_exit;
2017 }
2018
2019 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2020 if (!mp) {
2021 rc = 2;
2022 goto lpfc_handle_latt_free_pmb;
2023 }
2024
2025 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
2026 if (!mp->virt) {
2027 rc = 3;
2028 goto lpfc_handle_latt_free_mp;
2029 }
2030
2031 /* Cleanup any outstanding ELS commands */
2032 lpfc_els_flush_all_cmd(phba);
2033
2034 psli->slistat.link_event++;
2035 lpfc_read_topology(phba, pmb, mp);
2036 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
2037 pmb->vport = vport;
2038 /* Block ELS IOCBs until we have processed this mbox command */
2039 phba->sli.sli3_ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
2040 rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
2041 if (rc == MBX_NOT_FINISHED) {
2042 rc = 4;
2043 goto lpfc_handle_latt_free_mbuf;
2044 }
2045
2046 /* Clear Link Attention in HA REG */
2047 spin_lock_irq(&phba->hbalock);
2048 writel(HA_LATT, phba->HAregaddr);
2049 readl(phba->HAregaddr); /* flush */
2050 spin_unlock_irq(&phba->hbalock);
2051
2052 return;
2053
2054 lpfc_handle_latt_free_mbuf:
2055 phba->sli.sli3_ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
2056 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2057 lpfc_handle_latt_free_mp:
2058 kfree(mp);
2059 lpfc_handle_latt_free_pmb:
2060 mempool_free(pmb, phba->mbox_mem_pool);
2061 lpfc_handle_latt_err_exit:
2062 /* Enable Link attention interrupts */
2063 spin_lock_irq(&phba->hbalock);
2064 psli->sli_flag |= LPFC_PROCESS_LA;
2065 control = readl(phba->HCregaddr);
2066 control |= HC_LAINT_ENA;
2067 writel(control, phba->HCregaddr);
2068 readl(phba->HCregaddr); /* flush */
2069
2070 /* Clear Link Attention in HA REG */
2071 writel(HA_LATT, phba->HAregaddr);
2072 readl(phba->HAregaddr); /* flush */
2073 spin_unlock_irq(&phba->hbalock);
2074 lpfc_linkdown(phba);
2075 phba->link_state = LPFC_HBA_ERROR;
2076
2077 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
2078 "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
2079
2080 return;
2081 }
2082
2083 /**
2084 * lpfc_parse_vpd - Parse VPD (Vital Product Data)
2085 * @phba: pointer to lpfc hba data structure.
2086 * @vpd: pointer to the vital product data.
2087 * @len: length of the vital product data in bytes.
2088 *
2089 * This routine parses the Vital Product Data (VPD). The VPD is treated as
2090 * an array of characters. In this routine, the ModelName, ProgramType, and
2091 * ModelDesc, etc. fields of the phba data structure will be populated.
2092 *
2093 * Return codes
2094 * 0 - pointer to the VPD passed in is NULL
2095 * 1 - success
2096 **/
2097 int
2098 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
2099 {
2100 uint8_t lenlo, lenhi;
2101 int Length;
2102 int i, j;
2103 int finished = 0;
2104 int index = 0;
2105
2106 if (!vpd)
2107 return 0;
2108
2109 /* Vital Product */
2110 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2111 "0455 Vital Product Data: x%x x%x x%x x%x\n",
2112 (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
2113 (uint32_t) vpd[3]);
2114 while (!finished && (index < (len - 4))) {
2115 switch (vpd[index]) {
2116 case 0x82:
2117 case 0x91:
2118 index += 1;
2119 lenlo = vpd[index];
2120 index += 1;
2121 lenhi = vpd[index];
2122 index += 1;
2123 i = ((((unsigned short)lenhi) << 8) + lenlo);
2124 index += i;
2125 break;
2126 case 0x90:
2127 index += 1;
2128 lenlo = vpd[index];
2129 index += 1;
2130 lenhi = vpd[index];
2131 index += 1;
2132 Length = ((((unsigned short)lenhi) << 8) + lenlo);
2133 if (Length > len - index)
2134 Length = len - index;
2135 while (Length > 0) {
2136 /* Look for Serial Number */
2137 if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
2138 index += 2;
2139 i = vpd[index];
2140 index += 1;
2141 j = 0;
2142 Length -= (3+i);
2143 while(i--) {
2144 phba->SerialNumber[j++] = vpd[index++];
2145 if (j == 31)
2146 break;
2147 }
2148 phba->SerialNumber[j] = 0;
2149 continue;
2150 }
2151 else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
2152 phba->vpd_flag |= VPD_MODEL_DESC;
2153 index += 2;
2154 i = vpd[index];
2155 index += 1;
2156 j = 0;
2157 Length -= (3+i);
2158 while(i--) {
2159 phba->ModelDesc[j++] = vpd[index++];
2160 if (j == 255)
2161 break;
2162 }
2163 phba->ModelDesc[j] = 0;
2164 continue;
2165 }
2166 else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
2167 phba->vpd_flag |= VPD_MODEL_NAME;
2168 index += 2;
2169 i = vpd[index];
2170 index += 1;
2171 j = 0;
2172 Length -= (3+i);
2173 while(i--) {
2174 phba->ModelName[j++] = vpd[index++];
2175 if (j == 79)
2176 break;
2177 }
2178 phba->ModelName[j] = 0;
2179 continue;
2180 }
2181 else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
2182 phba->vpd_flag |= VPD_PROGRAM_TYPE;
2183 index += 2;
2184 i = vpd[index];
2185 index += 1;
2186 j = 0;
2187 Length -= (3+i);
2188 while(i--) {
2189 phba->ProgramType[j++] = vpd[index++];
2190 if (j == 255)
2191 break;
2192 }
2193 phba->ProgramType[j] = 0;
2194 continue;
2195 }
2196 else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
2197 phba->vpd_flag |= VPD_PORT;
2198 index += 2;
2199 i = vpd[index];
2200 index += 1;
2201 j = 0;
2202 Length -= (3+i);
2203 while(i--) {
2204 if ((phba->sli_rev == LPFC_SLI_REV4) &&
2205 (phba->sli4_hba.pport_name_sta ==
2206 LPFC_SLI4_PPNAME_GET)) {
2207 j++;
2208 index++;
2209 } else
2210 phba->Port[j++] = vpd[index++];
2211 if (j == 19)
2212 break;
2213 }
2214 if ((phba->sli_rev != LPFC_SLI_REV4) ||
2215 (phba->sli4_hba.pport_name_sta ==
2216 LPFC_SLI4_PPNAME_NON))
2217 phba->Port[j] = 0;
2218 continue;
2219 }
2220 else {
2221 index += 2;
2222 i = vpd[index];
2223 index += 1;
2224 index += i;
2225 Length -= (3 + i);
2226 }
2227 }
2228 finished = 0;
2229 break;
2230 case 0x78:
2231 finished = 1;
2232 break;
2233 default:
2234 index ++;
2235 break;
2236 }
2237 }
2238
2239 return(1);
2240 }
2241
2242 /**
2243 * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
2244 * @phba: pointer to lpfc hba data structure.
2245 * @mdp: pointer to the data structure to hold the derived model name.
2246 * @descp: pointer to the data structure to hold the derived description.
2247 *
2248 * This routine retrieves HBA's description based on its registered PCI device
2249 * ID. The @descp passed into this function points to an array of 256 chars. It
2250 * shall be returned with the model name, maximum speed, and the host bus type.
2251 * The @mdp passed into this function points to an array of 80 chars. When the
2252 * function returns, the @mdp will be filled with the model name.
2253 **/
2254 static void
2255 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
2256 {
2257 lpfc_vpd_t *vp;
2258 uint16_t dev_id = phba->pcidev->device;
2259 int max_speed;
2260 int GE = 0;
2261 int oneConnect = 0; /* default is not a oneConnect */
2262 struct {
2263 char *name;
2264 char *bus;
2265 char *function;
2266 } m = {"<Unknown>", "", ""};
2267
2268 if (mdp && mdp[0] != '\0'
2269 && descp && descp[0] != '\0')
2270 return;
2271
2272 if (phba->lmt & LMT_32Gb)
2273 max_speed = 32;
2274 else if (phba->lmt & LMT_16Gb)
2275 max_speed = 16;
2276 else if (phba->lmt & LMT_10Gb)
2277 max_speed = 10;
2278 else if (phba->lmt & LMT_8Gb)
2279 max_speed = 8;
2280 else if (phba->lmt & LMT_4Gb)
2281 max_speed = 4;
2282 else if (phba->lmt & LMT_2Gb)
2283 max_speed = 2;
2284 else if (phba->lmt & LMT_1Gb)
2285 max_speed = 1;
2286 else
2287 max_speed = 0;
2288
2289 vp = &phba->vpd;
2290
2291 switch (dev_id) {
2292 case PCI_DEVICE_ID_FIREFLY:
2293 m = (typeof(m)){"LP6000", "PCI",
2294 "Obsolete, Unsupported Fibre Channel Adapter"};
2295 break;
2296 case PCI_DEVICE_ID_SUPERFLY:
2297 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
2298 m = (typeof(m)){"LP7000", "PCI", ""};
2299 else
2300 m = (typeof(m)){"LP7000E", "PCI", ""};
2301 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2302 break;
2303 case PCI_DEVICE_ID_DRAGONFLY:
2304 m = (typeof(m)){"LP8000", "PCI",
2305 "Obsolete, Unsupported Fibre Channel Adapter"};
2306 break;
2307 case PCI_DEVICE_ID_CENTAUR:
2308 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
2309 m = (typeof(m)){"LP9002", "PCI", ""};
2310 else
2311 m = (typeof(m)){"LP9000", "PCI", ""};
2312 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2313 break;
2314 case PCI_DEVICE_ID_RFLY:
2315 m = (typeof(m)){"LP952", "PCI",
2316 "Obsolete, Unsupported Fibre Channel Adapter"};
2317 break;
2318 case PCI_DEVICE_ID_PEGASUS:
2319 m = (typeof(m)){"LP9802", "PCI-X",
2320 "Obsolete, Unsupported Fibre Channel Adapter"};
2321 break;
2322 case PCI_DEVICE_ID_THOR:
2323 m = (typeof(m)){"LP10000", "PCI-X",
2324 "Obsolete, Unsupported Fibre Channel Adapter"};
2325 break;
2326 case PCI_DEVICE_ID_VIPER:
2327 m = (typeof(m)){"LPX1000", "PCI-X",
2328 "Obsolete, Unsupported Fibre Channel Adapter"};
2329 break;
2330 case PCI_DEVICE_ID_PFLY:
2331 m = (typeof(m)){"LP982", "PCI-X",
2332 "Obsolete, Unsupported Fibre Channel Adapter"};
2333 break;
2334 case PCI_DEVICE_ID_TFLY:
2335 m = (typeof(m)){"LP1050", "PCI-X",
2336 "Obsolete, Unsupported Fibre Channel Adapter"};
2337 break;
2338 case PCI_DEVICE_ID_HELIOS:
2339 m = (typeof(m)){"LP11000", "PCI-X2",
2340 "Obsolete, Unsupported Fibre Channel Adapter"};
2341 break;
2342 case PCI_DEVICE_ID_HELIOS_SCSP:
2343 m = (typeof(m)){"LP11000-SP", "PCI-X2",
2344 "Obsolete, Unsupported Fibre Channel Adapter"};
2345 break;
2346 case PCI_DEVICE_ID_HELIOS_DCSP:
2347 m = (typeof(m)){"LP11002-SP", "PCI-X2",
2348 "Obsolete, Unsupported Fibre Channel Adapter"};
2349 break;
2350 case PCI_DEVICE_ID_NEPTUNE:
2351 m = (typeof(m)){"LPe1000", "PCIe",
2352 "Obsolete, Unsupported Fibre Channel Adapter"};
2353 break;
2354 case PCI_DEVICE_ID_NEPTUNE_SCSP:
2355 m = (typeof(m)){"LPe1000-SP", "PCIe",
2356 "Obsolete, Unsupported Fibre Channel Adapter"};
2357 break;
2358 case PCI_DEVICE_ID_NEPTUNE_DCSP:
2359 m = (typeof(m)){"LPe1002-SP", "PCIe",
2360 "Obsolete, Unsupported Fibre Channel Adapter"};
2361 break;
2362 case PCI_DEVICE_ID_BMID:
2363 m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
2364 break;
2365 case PCI_DEVICE_ID_BSMB:
2366 m = (typeof(m)){"LP111", "PCI-X2",
2367 "Obsolete, Unsupported Fibre Channel Adapter"};
2368 break;
2369 case PCI_DEVICE_ID_ZEPHYR:
2370 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2371 break;
2372 case PCI_DEVICE_ID_ZEPHYR_SCSP:
2373 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2374 break;
2375 case PCI_DEVICE_ID_ZEPHYR_DCSP:
2376 m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
2377 GE = 1;
2378 break;
2379 case PCI_DEVICE_ID_ZMID:
2380 m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
2381 break;
2382 case PCI_DEVICE_ID_ZSMB:
2383 m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
2384 break;
2385 case PCI_DEVICE_ID_LP101:
2386 m = (typeof(m)){"LP101", "PCI-X",
2387 "Obsolete, Unsupported Fibre Channel Adapter"};
2388 break;
2389 case PCI_DEVICE_ID_LP10000S:
2390 m = (typeof(m)){"LP10000-S", "PCI",
2391 "Obsolete, Unsupported Fibre Channel Adapter"};
2392 break;
2393 case PCI_DEVICE_ID_LP11000S:
2394 m = (typeof(m)){"LP11000-S", "PCI-X2",
2395 "Obsolete, Unsupported Fibre Channel Adapter"};
2396 break;
2397 case PCI_DEVICE_ID_LPE11000S:
2398 m = (typeof(m)){"LPe11000-S", "PCIe",
2399 "Obsolete, Unsupported Fibre Channel Adapter"};
2400 break;
2401 case PCI_DEVICE_ID_SAT:
2402 m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
2403 break;
2404 case PCI_DEVICE_ID_SAT_MID:
2405 m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
2406 break;
2407 case PCI_DEVICE_ID_SAT_SMB:
2408 m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
2409 break;
2410 case PCI_DEVICE_ID_SAT_DCSP:
2411 m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
2412 break;
2413 case PCI_DEVICE_ID_SAT_SCSP:
2414 m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
2415 break;
2416 case PCI_DEVICE_ID_SAT_S:
2417 m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
2418 break;
2419 case PCI_DEVICE_ID_HORNET:
2420 m = (typeof(m)){"LP21000", "PCIe",
2421 "Obsolete, Unsupported FCoE Adapter"};
2422 GE = 1;
2423 break;
2424 case PCI_DEVICE_ID_PROTEUS_VF:
2425 m = (typeof(m)){"LPev12000", "PCIe IOV",
2426 "Obsolete, Unsupported Fibre Channel Adapter"};
2427 break;
2428 case PCI_DEVICE_ID_PROTEUS_PF:
2429 m = (typeof(m)){"LPev12000", "PCIe IOV",
2430 "Obsolete, Unsupported Fibre Channel Adapter"};
2431 break;
2432 case PCI_DEVICE_ID_PROTEUS_S:
2433 m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
2434 "Obsolete, Unsupported Fibre Channel Adapter"};
2435 break;
2436 case PCI_DEVICE_ID_TIGERSHARK:
2437 oneConnect = 1;
2438 m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
2439 break;
2440 case PCI_DEVICE_ID_TOMCAT:
2441 oneConnect = 1;
2442 m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
2443 break;
2444 case PCI_DEVICE_ID_FALCON:
2445 m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
2446 "EmulexSecure Fibre"};
2447 break;
2448 case PCI_DEVICE_ID_BALIUS:
2449 m = (typeof(m)){"LPVe12002", "PCIe Shared I/O",
2450 "Obsolete, Unsupported Fibre Channel Adapter"};
2451 break;
2452 case PCI_DEVICE_ID_LANCER_FC:
2453 m = (typeof(m)){"LPe16000", "PCIe", "Fibre Channel Adapter"};
2454 break;
2455 case PCI_DEVICE_ID_LANCER_FC_VF:
2456 m = (typeof(m)){"LPe16000", "PCIe",
2457 "Obsolete, Unsupported Fibre Channel Adapter"};
2458 break;
2459 case PCI_DEVICE_ID_LANCER_FCOE:
2460 oneConnect = 1;
2461 m = (typeof(m)){"OCe15100", "PCIe", "FCoE"};
2462 break;
2463 case PCI_DEVICE_ID_LANCER_FCOE_VF:
2464 oneConnect = 1;
2465 m = (typeof(m)){"OCe15100", "PCIe",
2466 "Obsolete, Unsupported FCoE"};
2467 break;
2468 case PCI_DEVICE_ID_LANCER_G6_FC:
2469 m = (typeof(m)){"LPe32000", "PCIe", "Fibre Channel Adapter"};
2470 break;
2471 case PCI_DEVICE_ID_SKYHAWK:
2472 case PCI_DEVICE_ID_SKYHAWK_VF:
2473 oneConnect = 1;
2474 m = (typeof(m)){"OCe14000", "PCIe", "FCoE"};
2475 break;
2476 default:
2477 m = (typeof(m)){"Unknown", "", ""};
2478 break;
2479 }
2480
2481 if (mdp && mdp[0] == '\0')
2482 snprintf(mdp, 79,"%s", m.name);
2483 /*
2484 * oneConnect hba requires special processing, they are all initiators
2485 * and we put the port number on the end
2486 */
2487 if (descp && descp[0] == '\0') {
2488 if (oneConnect)
2489 snprintf(descp, 255,
2490 "Emulex OneConnect %s, %s Initiator %s",
2491 m.name, m.function,
2492 phba->Port);
2493 else if (max_speed == 0)
2494 snprintf(descp, 255,
2495 "Emulex %s %s %s",
2496 m.name, m.bus, m.function);
2497 else
2498 snprintf(descp, 255,
2499 "Emulex %s %d%s %s %s",
2500 m.name, max_speed, (GE) ? "GE" : "Gb",
2501 m.bus, m.function);
2502 }
2503 }
2504
2505 /**
2506 * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
2507 * @phba: pointer to lpfc hba data structure.
2508 * @pring: pointer to a IOCB ring.
2509 * @cnt: the number of IOCBs to be posted to the IOCB ring.
2510 *
2511 * This routine posts a given number of IOCBs with the associated DMA buffer
2512 * descriptors specified by the cnt argument to the given IOCB ring.
2513 *
2514 * Return codes
2515 * The number of IOCBs NOT able to be posted to the IOCB ring.
2516 **/
2517 int
2518 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
2519 {
2520 IOCB_t *icmd;
2521 struct lpfc_iocbq *iocb;
2522 struct lpfc_dmabuf *mp1, *mp2;
2523
2524 cnt += pring->missbufcnt;
2525
2526 /* While there are buffers to post */
2527 while (cnt > 0) {
2528 /* Allocate buffer for command iocb */
2529 iocb = lpfc_sli_get_iocbq(phba);
2530 if (iocb == NULL) {
2531 pring->missbufcnt = cnt;
2532 return cnt;
2533 }
2534 icmd = &iocb->iocb;
2535
2536 /* 2 buffers can be posted per command */
2537 /* Allocate buffer to post */
2538 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2539 if (mp1)
2540 mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
2541 if (!mp1 || !mp1->virt) {
2542 kfree(mp1);
2543 lpfc_sli_release_iocbq(phba, iocb);
2544 pring->missbufcnt = cnt;
2545 return cnt;
2546 }
2547
2548 INIT_LIST_HEAD(&mp1->list);
2549 /* Allocate buffer to post */
2550 if (cnt > 1) {
2551 mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2552 if (mp2)
2553 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
2554 &mp2->phys);
2555 if (!mp2 || !mp2->virt) {
2556 kfree(mp2);
2557 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2558 kfree(mp1);
2559 lpfc_sli_release_iocbq(phba, iocb);
2560 pring->missbufcnt = cnt;
2561 return cnt;
2562 }
2563
2564 INIT_LIST_HEAD(&mp2->list);
2565 } else {
2566 mp2 = NULL;
2567 }
2568
2569 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
2570 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
2571 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
2572 icmd->ulpBdeCount = 1;
2573 cnt--;
2574 if (mp2) {
2575 icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
2576 icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
2577 icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
2578 cnt--;
2579 icmd->ulpBdeCount = 2;
2580 }
2581
2582 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
2583 icmd->ulpLe = 1;
2584
2585 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
2586 IOCB_ERROR) {
2587 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2588 kfree(mp1);
2589 cnt++;
2590 if (mp2) {
2591 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
2592 kfree(mp2);
2593 cnt++;
2594 }
2595 lpfc_sli_release_iocbq(phba, iocb);
2596 pring->missbufcnt = cnt;
2597 return cnt;
2598 }
2599 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
2600 if (mp2)
2601 lpfc_sli_ringpostbuf_put(phba, pring, mp2);
2602 }
2603 pring->missbufcnt = 0;
2604 return 0;
2605 }
2606
2607 /**
2608 * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
2609 * @phba: pointer to lpfc hba data structure.
2610 *
2611 * This routine posts initial receive IOCB buffers to the ELS ring. The
2612 * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
2613 * set to 64 IOCBs. SLI3 only.
2614 *
2615 * Return codes
2616 * 0 - success (currently always success)
2617 **/
2618 static int
2619 lpfc_post_rcv_buf(struct lpfc_hba *phba)
2620 {
2621 struct lpfc_sli *psli = &phba->sli;
2622
2623 /* Ring 0, ELS / CT buffers */
2624 lpfc_post_buffer(phba, &psli->sli3_ring[LPFC_ELS_RING], LPFC_BUF_RING0);
2625 /* Ring 2 - FCP no buffers needed */
2626
2627 return 0;
2628 }
2629
2630 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
2631
2632 /**
2633 * lpfc_sha_init - Set up initial array of hash table entries
2634 * @HashResultPointer: pointer to an array as hash table.
2635 *
2636 * This routine sets up the initial values to the array of hash table entries
2637 * for the LC HBAs.
2638 **/
2639 static void
2640 lpfc_sha_init(uint32_t * HashResultPointer)
2641 {
2642 HashResultPointer[0] = 0x67452301;
2643 HashResultPointer[1] = 0xEFCDAB89;
2644 HashResultPointer[2] = 0x98BADCFE;
2645 HashResultPointer[3] = 0x10325476;
2646 HashResultPointer[4] = 0xC3D2E1F0;
2647 }
2648
2649 /**
2650 * lpfc_sha_iterate - Iterate initial hash table with the working hash table
2651 * @HashResultPointer: pointer to an initial/result hash table.
2652 * @HashWorkingPointer: pointer to an working hash table.
2653 *
2654 * This routine iterates an initial hash table pointed by @HashResultPointer
2655 * with the values from the working hash table pointeed by @HashWorkingPointer.
2656 * The results are putting back to the initial hash table, returned through
2657 * the @HashResultPointer as the result hash table.
2658 **/
2659 static void
2660 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
2661 {
2662 int t;
2663 uint32_t TEMP;
2664 uint32_t A, B, C, D, E;
2665 t = 16;
2666 do {
2667 HashWorkingPointer[t] =
2668 S(1,
2669 HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
2670 8] ^
2671 HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
2672 } while (++t <= 79);
2673 t = 0;
2674 A = HashResultPointer[0];
2675 B = HashResultPointer[1];
2676 C = HashResultPointer[2];
2677 D = HashResultPointer[3];
2678 E = HashResultPointer[4];
2679
2680 do {
2681 if (t < 20) {
2682 TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
2683 } else if (t < 40) {
2684 TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
2685 } else if (t < 60) {
2686 TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
2687 } else {
2688 TEMP = (B ^ C ^ D) + 0xCA62C1D6;
2689 }
2690 TEMP += S(5, A) + E + HashWorkingPointer[t];
2691 E = D;
2692 D = C;
2693 C = S(30, B);
2694 B = A;
2695 A = TEMP;
2696 } while (++t <= 79);
2697
2698 HashResultPointer[0] += A;
2699 HashResultPointer[1] += B;
2700 HashResultPointer[2] += C;
2701 HashResultPointer[3] += D;
2702 HashResultPointer[4] += E;
2703
2704 }
2705
2706 /**
2707 * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2708 * @RandomChallenge: pointer to the entry of host challenge random number array.
2709 * @HashWorking: pointer to the entry of the working hash array.
2710 *
2711 * This routine calculates the working hash array referred by @HashWorking
2712 * from the challenge random numbers associated with the host, referred by
2713 * @RandomChallenge. The result is put into the entry of the working hash
2714 * array and returned by reference through @HashWorking.
2715 **/
2716 static void
2717 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
2718 {
2719 *HashWorking = (*RandomChallenge ^ *HashWorking);
2720 }
2721
2722 /**
2723 * lpfc_hba_init - Perform special handling for LC HBA initialization
2724 * @phba: pointer to lpfc hba data structure.
2725 * @hbainit: pointer to an array of unsigned 32-bit integers.
2726 *
2727 * This routine performs the special handling for LC HBA initialization.
2728 **/
2729 void
2730 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
2731 {
2732 int t;
2733 uint32_t *HashWorking;
2734 uint32_t *pwwnn = (uint32_t *) phba->wwnn;
2735
2736 HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
2737 if (!HashWorking)
2738 return;
2739
2740 HashWorking[0] = HashWorking[78] = *pwwnn++;
2741 HashWorking[1] = HashWorking[79] = *pwwnn;
2742
2743 for (t = 0; t < 7; t++)
2744 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
2745
2746 lpfc_sha_init(hbainit);
2747 lpfc_sha_iterate(hbainit, HashWorking);
2748 kfree(HashWorking);
2749 }
2750
2751 /**
2752 * lpfc_cleanup - Performs vport cleanups before deleting a vport
2753 * @vport: pointer to a virtual N_Port data structure.
2754 *
2755 * This routine performs the necessary cleanups before deleting the @vport.
2756 * It invokes the discovery state machine to perform necessary state
2757 * transitions and to release the ndlps associated with the @vport. Note,
2758 * the physical port is treated as @vport 0.
2759 **/
2760 void
2761 lpfc_cleanup(struct lpfc_vport *vport)
2762 {
2763 struct lpfc_hba *phba = vport->phba;
2764 struct lpfc_nodelist *ndlp, *next_ndlp;
2765 int i = 0;
2766
2767 if (phba->link_state > LPFC_LINK_DOWN)
2768 lpfc_port_link_failure(vport);
2769
2770 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2771 if (!NLP_CHK_NODE_ACT(ndlp)) {
2772 ndlp = lpfc_enable_node(vport, ndlp,
2773 NLP_STE_UNUSED_NODE);
2774 if (!ndlp)
2775 continue;
2776 spin_lock_irq(&phba->ndlp_lock);
2777 NLP_SET_FREE_REQ(ndlp);
2778 spin_unlock_irq(&phba->ndlp_lock);
2779 /* Trigger the release of the ndlp memory */
2780 lpfc_nlp_put(ndlp);
2781 continue;
2782 }
2783 spin_lock_irq(&phba->ndlp_lock);
2784 if (NLP_CHK_FREE_REQ(ndlp)) {
2785 /* The ndlp should not be in memory free mode already */
2786 spin_unlock_irq(&phba->ndlp_lock);
2787 continue;
2788 } else
2789 /* Indicate request for freeing ndlp memory */
2790 NLP_SET_FREE_REQ(ndlp);
2791 spin_unlock_irq(&phba->ndlp_lock);
2792
2793 if (vport->port_type != LPFC_PHYSICAL_PORT &&
2794 ndlp->nlp_DID == Fabric_DID) {
2795 /* Just free up ndlp with Fabric_DID for vports */
2796 lpfc_nlp_put(ndlp);
2797 continue;
2798 }
2799
2800 /* take care of nodes in unused state before the state
2801 * machine taking action.
2802 */
2803 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) {
2804 lpfc_nlp_put(ndlp);
2805 continue;
2806 }
2807
2808 if (ndlp->nlp_type & NLP_FABRIC)
2809 lpfc_disc_state_machine(vport, ndlp, NULL,
2810 NLP_EVT_DEVICE_RECOVERY);
2811
2812 lpfc_disc_state_machine(vport, ndlp, NULL,
2813 NLP_EVT_DEVICE_RM);
2814 }
2815
2816 /* At this point, ALL ndlp's should be gone
2817 * because of the previous NLP_EVT_DEVICE_RM.
2818 * Lets wait for this to happen, if needed.
2819 */
2820 while (!list_empty(&vport->fc_nodes)) {
2821 if (i++ > 3000) {
2822 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2823 "0233 Nodelist not empty\n");
2824 list_for_each_entry_safe(ndlp, next_ndlp,
2825 &vport->fc_nodes, nlp_listp) {
2826 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2827 LOG_NODE,
2828 "0282 did:x%x ndlp:x%p "
2829 "usgmap:x%x refcnt:%d\n",
2830 ndlp->nlp_DID, (void *)ndlp,
2831 ndlp->nlp_usg_map,
2832 kref_read(&ndlp->kref));
2833 }
2834 break;
2835 }
2836
2837 /* Wait for any activity on ndlps to settle */
2838 msleep(10);
2839 }
2840 lpfc_cleanup_vports_rrqs(vport, NULL);
2841 }
2842
2843 /**
2844 * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2845 * @vport: pointer to a virtual N_Port data structure.
2846 *
2847 * This routine stops all the timers associated with a @vport. This function
2848 * is invoked before disabling or deleting a @vport. Note that the physical
2849 * port is treated as @vport 0.
2850 **/
2851 void
2852 lpfc_stop_vport_timers(struct lpfc_vport *vport)
2853 {
2854 del_timer_sync(&vport->els_tmofunc);
2855 del_timer_sync(&vport->delayed_disc_tmo);
2856 lpfc_can_disctmo(vport);
2857 return;
2858 }
2859
2860 /**
2861 * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2862 * @phba: pointer to lpfc hba data structure.
2863 *
2864 * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2865 * caller of this routine should already hold the host lock.
2866 **/
2867 void
2868 __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2869 {
2870 /* Clear pending FCF rediscovery wait flag */
2871 phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2872
2873 /* Now, try to stop the timer */
2874 del_timer(&phba->fcf.redisc_wait);
2875 }
2876
2877 /**
2878 * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2879 * @phba: pointer to lpfc hba data structure.
2880 *
2881 * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2882 * checks whether the FCF rediscovery wait timer is pending with the host
2883 * lock held before proceeding with disabling the timer and clearing the
2884 * wait timer pendig flag.
2885 **/
2886 void
2887 lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2888 {
2889 spin_lock_irq(&phba->hbalock);
2890 if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2891 /* FCF rediscovery timer already fired or stopped */
2892 spin_unlock_irq(&phba->hbalock);
2893 return;
2894 }
2895 __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2896 /* Clear failover in progress flags */
2897 phba->fcf.fcf_flag &= ~(FCF_DEAD_DISC | FCF_ACVL_DISC);
2898 spin_unlock_irq(&phba->hbalock);
2899 }
2900
2901 /**
2902 * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2903 * @phba: pointer to lpfc hba data structure.
2904 *
2905 * This routine stops all the timers associated with a HBA. This function is
2906 * invoked before either putting a HBA offline or unloading the driver.
2907 **/
2908 void
2909 lpfc_stop_hba_timers(struct lpfc_hba *phba)
2910 {
2911 lpfc_stop_vport_timers(phba->pport);
2912 del_timer_sync(&phba->sli.mbox_tmo);
2913 del_timer_sync(&phba->fabric_block_timer);
2914 del_timer_sync(&phba->eratt_poll);
2915 del_timer_sync(&phba->hb_tmofunc);
2916 if (phba->sli_rev == LPFC_SLI_REV4) {
2917 del_timer_sync(&phba->rrq_tmr);
2918 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
2919 }
2920 phba->hb_outstanding = 0;
2921
2922 switch (phba->pci_dev_grp) {
2923 case LPFC_PCI_DEV_LP:
2924 /* Stop any LightPulse device specific driver timers */
2925 del_timer_sync(&phba->fcp_poll_timer);
2926 break;
2927 case LPFC_PCI_DEV_OC:
2928 /* Stop any OneConnect device sepcific driver timers */
2929 lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2930 break;
2931 default:
2932 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2933 "0297 Invalid device group (x%x)\n",
2934 phba->pci_dev_grp);
2935 break;
2936 }
2937 return;
2938 }
2939
2940 /**
2941 * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2942 * @phba: pointer to lpfc hba data structure.
2943 *
2944 * This routine marks a HBA's management interface as blocked. Once the HBA's
2945 * management interface is marked as blocked, all the user space access to
2946 * the HBA, whether they are from sysfs interface or libdfc interface will
2947 * all be blocked. The HBA is set to block the management interface when the
2948 * driver prepares the HBA interface for online or offline.
2949 **/
2950 static void
2951 lpfc_block_mgmt_io(struct lpfc_hba *phba, int mbx_action)
2952 {
2953 unsigned long iflag;
2954 uint8_t actcmd = MBX_HEARTBEAT;
2955 unsigned long timeout;
2956
2957 spin_lock_irqsave(&phba->hbalock, iflag);
2958 phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
2959 spin_unlock_irqrestore(&phba->hbalock, iflag);
2960 if (mbx_action == LPFC_MBX_NO_WAIT)
2961 return;
2962 timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
2963 spin_lock_irqsave(&phba->hbalock, iflag);
2964 if (phba->sli.mbox_active) {
2965 actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
2966 /* Determine how long we might wait for the active mailbox
2967 * command to be gracefully completed by firmware.
2968 */
2969 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
2970 phba->sli.mbox_active) * 1000) + jiffies;
2971 }
2972 spin_unlock_irqrestore(&phba->hbalock, iflag);
2973
2974 /* Wait for the outstnading mailbox command to complete */
2975 while (phba->sli.mbox_active) {
2976 /* Check active mailbox complete status every 2ms */
2977 msleep(2);
2978 if (time_after(jiffies, timeout)) {
2979 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2980 "2813 Mgmt IO is Blocked %x "
2981 "- mbox cmd %x still active\n",
2982 phba->sli.sli_flag, actcmd);
2983 break;
2984 }
2985 }
2986 }
2987
2988 /**
2989 * lpfc_sli4_node_prep - Assign RPIs for active nodes.
2990 * @phba: pointer to lpfc hba data structure.
2991 *
2992 * Allocate RPIs for all active remote nodes. This is needed whenever
2993 * an SLI4 adapter is reset and the driver is not unloading. Its purpose
2994 * is to fixup the temporary rpi assignments.
2995 **/
2996 void
2997 lpfc_sli4_node_prep(struct lpfc_hba *phba)
2998 {
2999 struct lpfc_nodelist *ndlp, *next_ndlp;
3000 struct lpfc_vport **vports;
3001 int i, rpi;
3002 unsigned long flags;
3003
3004 if (phba->sli_rev != LPFC_SLI_REV4)
3005 return;
3006
3007 vports = lpfc_create_vport_work_array(phba);
3008 if (vports == NULL)
3009 return;
3010
3011 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3012 if (vports[i]->load_flag & FC_UNLOADING)
3013 continue;
3014
3015 list_for_each_entry_safe(ndlp, next_ndlp,
3016 &vports[i]->fc_nodes,
3017 nlp_listp) {
3018 if (!NLP_CHK_NODE_ACT(ndlp))
3019 continue;
3020 rpi = lpfc_sli4_alloc_rpi(phba);
3021 if (rpi == LPFC_RPI_ALLOC_ERROR) {
3022 spin_lock_irqsave(&phba->ndlp_lock, flags);
3023 NLP_CLR_NODE_ACT(ndlp);
3024 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3025 continue;
3026 }
3027 ndlp->nlp_rpi = rpi;
3028 lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
3029 "0009 rpi:%x DID:%x "
3030 "flg:%x map:%x %p\n", ndlp->nlp_rpi,
3031 ndlp->nlp_DID, ndlp->nlp_flag,
3032 ndlp->nlp_usg_map, ndlp);
3033 }
3034 }
3035 lpfc_destroy_vport_work_array(phba, vports);
3036 }
3037
3038 /**
3039 * lpfc_online - Initialize and bring a HBA online
3040 * @phba: pointer to lpfc hba data structure.
3041 *
3042 * This routine initializes the HBA and brings a HBA online. During this
3043 * process, the management interface is blocked to prevent user space access
3044 * to the HBA interfering with the driver initialization.
3045 *
3046 * Return codes
3047 * 0 - successful
3048 * 1 - failed
3049 **/
3050 int
3051 lpfc_online(struct lpfc_hba *phba)
3052 {
3053 struct lpfc_vport *vport;
3054 struct lpfc_vport **vports;
3055 int i, error = 0;
3056 bool vpis_cleared = false;
3057
3058 if (!phba)
3059 return 0;
3060 vport = phba->pport;
3061
3062 if (!(vport->fc_flag & FC_OFFLINE_MODE))
3063 return 0;
3064
3065 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3066 "0458 Bring Adapter online\n");
3067
3068 lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
3069
3070 if (phba->sli_rev == LPFC_SLI_REV4) {
3071 if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */
3072 lpfc_unblock_mgmt_io(phba);
3073 return 1;
3074 }
3075 spin_lock_irq(&phba->hbalock);
3076 if (!phba->sli4_hba.max_cfg_param.vpi_used)
3077 vpis_cleared = true;
3078 spin_unlock_irq(&phba->hbalock);
3079
3080 /* Reestablish the local initiator port.
3081 * The offline process destroyed the previous lport.
3082 */
3083 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
3084 !phba->nvmet_support) {
3085 error = lpfc_nvme_create_localport(phba->pport);
3086 if (error)
3087 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3088 "6132 NVME restore reg failed "
3089 "on nvmei error x%x\n", error);
3090 }
3091 } else {
3092 lpfc_sli_queue_init(phba);
3093 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */
3094 lpfc_unblock_mgmt_io(phba);
3095 return 1;
3096 }
3097 }
3098
3099 vports = lpfc_create_vport_work_array(phba);
3100 if (vports != NULL) {
3101 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3102 struct Scsi_Host *shost;
3103 shost = lpfc_shost_from_vport(vports[i]);
3104 spin_lock_irq(shost->host_lock);
3105 vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
3106 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
3107 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3108 if (phba->sli_rev == LPFC_SLI_REV4) {
3109 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
3110 if ((vpis_cleared) &&
3111 (vports[i]->port_type !=
3112 LPFC_PHYSICAL_PORT))
3113 vports[i]->vpi = 0;
3114 }
3115 spin_unlock_irq(shost->host_lock);
3116 }
3117 }
3118 lpfc_destroy_vport_work_array(phba, vports);
3119
3120 lpfc_unblock_mgmt_io(phba);
3121 return 0;
3122 }
3123
3124 /**
3125 * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
3126 * @phba: pointer to lpfc hba data structure.
3127 *
3128 * This routine marks a HBA's management interface as not blocked. Once the
3129 * HBA's management interface is marked as not blocked, all the user space
3130 * access to the HBA, whether they are from sysfs interface or libdfc
3131 * interface will be allowed. The HBA is set to block the management interface
3132 * when the driver prepares the HBA interface for online or offline and then
3133 * set to unblock the management interface afterwards.
3134 **/
3135 void
3136 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
3137 {
3138 unsigned long iflag;
3139
3140 spin_lock_irqsave(&phba->hbalock, iflag);
3141 phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
3142 spin_unlock_irqrestore(&phba->hbalock, iflag);
3143 }
3144
3145 /**
3146 * lpfc_offline_prep - Prepare a HBA to be brought offline
3147 * @phba: pointer to lpfc hba data structure.
3148 *
3149 * This routine is invoked to prepare a HBA to be brought offline. It performs
3150 * unregistration login to all the nodes on all vports and flushes the mailbox
3151 * queue to make it ready to be brought offline.
3152 **/
3153 void
3154 lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action)
3155 {
3156 struct lpfc_vport *vport = phba->pport;
3157 struct lpfc_nodelist *ndlp, *next_ndlp;
3158 struct lpfc_vport **vports;
3159 struct Scsi_Host *shost;
3160 int i;
3161
3162 if (vport->fc_flag & FC_OFFLINE_MODE)
3163 return;
3164
3165 lpfc_block_mgmt_io(phba, mbx_action);
3166
3167 lpfc_linkdown(phba);
3168
3169 /* Issue an unreg_login to all nodes on all vports */
3170 vports = lpfc_create_vport_work_array(phba);
3171 if (vports != NULL) {
3172 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3173 if (vports[i]->load_flag & FC_UNLOADING)
3174 continue;
3175 shost = lpfc_shost_from_vport(vports[i]);
3176 spin_lock_irq(shost->host_lock);
3177 vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
3178 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3179 vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
3180 spin_unlock_irq(shost->host_lock);
3181
3182 shost = lpfc_shost_from_vport(vports[i]);
3183 list_for_each_entry_safe(ndlp, next_ndlp,
3184 &vports[i]->fc_nodes,
3185 nlp_listp) {
3186 if (!NLP_CHK_NODE_ACT(ndlp))
3187 continue;
3188 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
3189 continue;
3190 if (ndlp->nlp_type & NLP_FABRIC) {
3191 lpfc_disc_state_machine(vports[i], ndlp,
3192 NULL, NLP_EVT_DEVICE_RECOVERY);
3193 lpfc_disc_state_machine(vports[i], ndlp,
3194 NULL, NLP_EVT_DEVICE_RM);
3195 }
3196 spin_lock_irq(shost->host_lock);
3197 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
3198 spin_unlock_irq(shost->host_lock);
3199 /*
3200 * Whenever an SLI4 port goes offline, free the
3201 * RPI. Get a new RPI when the adapter port
3202 * comes back online.
3203 */
3204 if (phba->sli_rev == LPFC_SLI_REV4) {
3205 lpfc_printf_vlog(ndlp->vport,
3206 KERN_INFO, LOG_NODE,
3207 "0011 lpfc_offline: "
3208 "ndlp:x%p did %x "
3209 "usgmap:x%x rpi:%x\n",
3210 ndlp, ndlp->nlp_DID,
3211 ndlp->nlp_usg_map,
3212 ndlp->nlp_rpi);
3213
3214 lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
3215 }
3216 lpfc_unreg_rpi(vports[i], ndlp);
3217 }
3218 }
3219 }
3220 lpfc_destroy_vport_work_array(phba, vports);
3221
3222 lpfc_sli_mbox_sys_shutdown(phba, mbx_action);
3223
3224 if (phba->wq)
3225 flush_workqueue(phba->wq);
3226 }
3227
3228 /**
3229 * lpfc_offline - Bring a HBA offline
3230 * @phba: pointer to lpfc hba data structure.
3231 *
3232 * This routine actually brings a HBA offline. It stops all the timers
3233 * associated with the HBA, brings down the SLI layer, and eventually
3234 * marks the HBA as in offline state for the upper layer protocol.
3235 **/
3236 void
3237 lpfc_offline(struct lpfc_hba *phba)
3238 {
3239 struct Scsi_Host *shost;
3240 struct lpfc_vport **vports;
3241 int i;
3242
3243 if (phba->pport->fc_flag & FC_OFFLINE_MODE)
3244 return;
3245
3246 /* stop port and all timers associated with this hba */
3247 lpfc_stop_port(phba);
3248
3249 /* Tear down the local and target port registrations. The
3250 * nvme transports need to cleanup.
3251 */
3252 lpfc_nvmet_destroy_targetport(phba);
3253 lpfc_nvme_destroy_localport(phba->pport);
3254
3255 vports = lpfc_create_vport_work_array(phba);
3256 if (vports != NULL)
3257 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
3258 lpfc_stop_vport_timers(vports[i]);
3259 lpfc_destroy_vport_work_array(phba, vports);
3260 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3261 "0460 Bring Adapter offline\n");
3262 /* Bring down the SLI Layer and cleanup. The HBA is offline
3263 now. */
3264 lpfc_sli_hba_down(phba);
3265 spin_lock_irq(&phba->hbalock);
3266 phba->work_ha = 0;
3267 spin_unlock_irq(&phba->hbalock);
3268 vports = lpfc_create_vport_work_array(phba);
3269 if (vports != NULL)
3270 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3271 shost = lpfc_shost_from_vport(vports[i]);
3272 spin_lock_irq(shost->host_lock);
3273 vports[i]->work_port_events = 0;
3274 vports[i]->fc_flag |= FC_OFFLINE_MODE;
3275 spin_unlock_irq(shost->host_lock);
3276 }
3277 lpfc_destroy_vport_work_array(phba, vports);
3278 }
3279
3280 /**
3281 * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
3282 * @phba: pointer to lpfc hba data structure.
3283 *
3284 * This routine is to free all the SCSI buffers and IOCBs from the driver
3285 * list back to kernel. It is called from lpfc_pci_remove_one to free
3286 * the internal resources before the device is removed from the system.
3287 **/
3288 static void
3289 lpfc_scsi_free(struct lpfc_hba *phba)
3290 {
3291 struct lpfc_scsi_buf *sb, *sb_next;
3292
3293 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
3294 return;
3295
3296 spin_lock_irq(&phba->hbalock);
3297
3298 /* Release all the lpfc_scsi_bufs maintained by this host. */
3299
3300 spin_lock(&phba->scsi_buf_list_put_lock);
3301 list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_put,
3302 list) {
3303 list_del(&sb->list);
3304 dma_pool_free(phba->lpfc_sg_dma_buf_pool, sb->data,
3305 sb->dma_handle);
3306 kfree(sb);
3307 phba->total_scsi_bufs--;
3308 }
3309 spin_unlock(&phba->scsi_buf_list_put_lock);
3310
3311 spin_lock(&phba->scsi_buf_list_get_lock);
3312 list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_get,
3313 list) {
3314 list_del(&sb->list);
3315 dma_pool_free(phba->lpfc_sg_dma_buf_pool, sb->data,
3316 sb->dma_handle);
3317 kfree(sb);
3318 phba->total_scsi_bufs--;
3319 }
3320 spin_unlock(&phba->scsi_buf_list_get_lock);
3321 spin_unlock_irq(&phba->hbalock);
3322 }
3323 /**
3324 * lpfc_nvme_free - Free all the NVME buffers and IOCBs from driver lists
3325 * @phba: pointer to lpfc hba data structure.
3326 *
3327 * This routine is to free all the NVME buffers and IOCBs from the driver
3328 * list back to kernel. It is called from lpfc_pci_remove_one to free
3329 * the internal resources before the device is removed from the system.
3330 **/
3331 static void
3332 lpfc_nvme_free(struct lpfc_hba *phba)
3333 {
3334 struct lpfc_nvme_buf *lpfc_ncmd, *lpfc_ncmd_next;
3335
3336 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
3337 return;
3338
3339 spin_lock_irq(&phba->hbalock);
3340
3341 /* Release all the lpfc_nvme_bufs maintained by this host. */
3342 spin_lock(&phba->nvme_buf_list_put_lock);
3343 list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3344 &phba->lpfc_nvme_buf_list_put, list) {
3345 list_del(&lpfc_ncmd->list);
3346 phba->put_nvme_bufs--;
3347 dma_pool_free(phba->lpfc_sg_dma_buf_pool, lpfc_ncmd->data,
3348 lpfc_ncmd->dma_handle);
3349 kfree(lpfc_ncmd);
3350 phba->total_nvme_bufs--;
3351 }
3352 spin_unlock(&phba->nvme_buf_list_put_lock);
3353
3354 spin_lock(&phba->nvme_buf_list_get_lock);
3355 list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3356 &phba->lpfc_nvme_buf_list_get, list) {
3357 list_del(&lpfc_ncmd->list);
3358 phba->get_nvme_bufs--;
3359 dma_pool_free(phba->lpfc_sg_dma_buf_pool, lpfc_ncmd->data,
3360 lpfc_ncmd->dma_handle);
3361 kfree(lpfc_ncmd);
3362 phba->total_nvme_bufs--;
3363 }
3364 spin_unlock(&phba->nvme_buf_list_get_lock);
3365 spin_unlock_irq(&phba->hbalock);
3366 }
3367 /**
3368 * lpfc_sli4_els_sgl_update - update ELS xri-sgl sizing and mapping
3369 * @phba: pointer to lpfc hba data structure.
3370 *
3371 * This routine first calculates the sizes of the current els and allocated
3372 * scsi sgl lists, and then goes through all sgls to updates the physical
3373 * XRIs assigned due to port function reset. During port initialization, the
3374 * current els and allocated scsi sgl lists are 0s.
3375 *
3376 * Return codes
3377 * 0 - successful (for now, it always returns 0)
3378 **/
3379 int
3380 lpfc_sli4_els_sgl_update(struct lpfc_hba *phba)
3381 {
3382 struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
3383 uint16_t i, lxri, xri_cnt, els_xri_cnt;
3384 LIST_HEAD(els_sgl_list);
3385 int rc;
3386
3387 /*
3388 * update on pci function's els xri-sgl list
3389 */
3390 els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3391
3392 if (els_xri_cnt > phba->sli4_hba.els_xri_cnt) {
3393 /* els xri-sgl expanded */
3394 xri_cnt = els_xri_cnt - phba->sli4_hba.els_xri_cnt;
3395 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3396 "3157 ELS xri-sgl count increased from "
3397 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3398 els_xri_cnt);
3399 /* allocate the additional els sgls */
3400 for (i = 0; i < xri_cnt; i++) {
3401 sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3402 GFP_KERNEL);
3403 if (sglq_entry == NULL) {
3404 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3405 "2562 Failure to allocate an "
3406 "ELS sgl entry:%d\n", i);
3407 rc = -ENOMEM;
3408 goto out_free_mem;
3409 }
3410 sglq_entry->buff_type = GEN_BUFF_TYPE;
3411 sglq_entry->virt = lpfc_mbuf_alloc(phba, 0,
3412 &sglq_entry->phys);
3413 if (sglq_entry->virt == NULL) {
3414 kfree(sglq_entry);
3415 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3416 "2563 Failure to allocate an "
3417 "ELS mbuf:%d\n", i);
3418 rc = -ENOMEM;
3419 goto out_free_mem;
3420 }
3421 sglq_entry->sgl = sglq_entry->virt;
3422 memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
3423 sglq_entry->state = SGL_FREED;
3424 list_add_tail(&sglq_entry->list, &els_sgl_list);
3425 }
3426 spin_lock_irq(&phba->hbalock);
3427 spin_lock(&phba->sli4_hba.sgl_list_lock);
3428 list_splice_init(&els_sgl_list,
3429 &phba->sli4_hba.lpfc_els_sgl_list);
3430 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3431 spin_unlock_irq(&phba->hbalock);
3432 } else if (els_xri_cnt < phba->sli4_hba.els_xri_cnt) {
3433 /* els xri-sgl shrinked */
3434 xri_cnt = phba->sli4_hba.els_xri_cnt - els_xri_cnt;
3435 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3436 "3158 ELS xri-sgl count decreased from "
3437 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3438 els_xri_cnt);
3439 spin_lock_irq(&phba->hbalock);
3440 spin_lock(&phba->sli4_hba.sgl_list_lock);
3441 list_splice_init(&phba->sli4_hba.lpfc_els_sgl_list,
3442 &els_sgl_list);
3443 /* release extra els sgls from list */
3444 for (i = 0; i < xri_cnt; i++) {
3445 list_remove_head(&els_sgl_list,
3446 sglq_entry, struct lpfc_sglq, list);
3447 if (sglq_entry) {
3448 __lpfc_mbuf_free(phba, sglq_entry->virt,
3449 sglq_entry->phys);
3450 kfree(sglq_entry);
3451 }
3452 }
3453 list_splice_init(&els_sgl_list,
3454 &phba->sli4_hba.lpfc_els_sgl_list);
3455 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3456 spin_unlock_irq(&phba->hbalock);
3457 } else
3458 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3459 "3163 ELS xri-sgl count unchanged: %d\n",
3460 els_xri_cnt);
3461 phba->sli4_hba.els_xri_cnt = els_xri_cnt;
3462
3463 /* update xris to els sgls on the list */
3464 sglq_entry = NULL;
3465 sglq_entry_next = NULL;
3466 list_for_each_entry_safe(sglq_entry, sglq_entry_next,
3467 &phba->sli4_hba.lpfc_els_sgl_list, list) {
3468 lxri = lpfc_sli4_next_xritag(phba);
3469 if (lxri == NO_XRI) {
3470 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3471 "2400 Failed to allocate xri for "
3472 "ELS sgl\n");
3473 rc = -ENOMEM;
3474 goto out_free_mem;
3475 }
3476 sglq_entry->sli4_lxritag = lxri;
3477 sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3478 }
3479 return 0;
3480
3481 out_free_mem:
3482 lpfc_free_els_sgl_list(phba);
3483 return rc;
3484 }
3485
3486 /**
3487 * lpfc_sli4_nvmet_sgl_update - update xri-sgl sizing and mapping
3488 * @phba: pointer to lpfc hba data structure.
3489 *
3490 * This routine first calculates the sizes of the current els and allocated
3491 * scsi sgl lists, and then goes through all sgls to updates the physical
3492 * XRIs assigned due to port function reset. During port initialization, the
3493 * current els and allocated scsi sgl lists are 0s.
3494 *
3495 * Return codes
3496 * 0 - successful (for now, it always returns 0)
3497 **/
3498 int
3499 lpfc_sli4_nvmet_sgl_update(struct lpfc_hba *phba)
3500 {
3501 struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
3502 uint16_t i, lxri, xri_cnt, els_xri_cnt;
3503 uint16_t nvmet_xri_cnt;
3504 LIST_HEAD(nvmet_sgl_list);
3505 int rc;
3506
3507 /*
3508 * update on pci function's nvmet xri-sgl list
3509 */
3510 els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3511
3512 /* For NVMET, ALL remaining XRIs are dedicated for IO processing */
3513 nvmet_xri_cnt = phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
3514 if (nvmet_xri_cnt > phba->sli4_hba.nvmet_xri_cnt) {
3515 /* els xri-sgl expanded */
3516 xri_cnt = nvmet_xri_cnt - phba->sli4_hba.nvmet_xri_cnt;
3517 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3518 "6302 NVMET xri-sgl cnt grew from %d to %d\n",
3519 phba->sli4_hba.nvmet_xri_cnt, nvmet_xri_cnt);
3520 /* allocate the additional nvmet sgls */
3521 for (i = 0; i < xri_cnt; i++) {
3522 sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3523 GFP_KERNEL);
3524 if (sglq_entry == NULL) {
3525 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3526 "6303 Failure to allocate an "
3527 "NVMET sgl entry:%d\n", i);
3528 rc = -ENOMEM;
3529 goto out_free_mem;
3530 }
3531 sglq_entry->buff_type = NVMET_BUFF_TYPE;
3532 sglq_entry->virt = lpfc_nvmet_buf_alloc(phba, 0,
3533 &sglq_entry->phys);
3534 if (sglq_entry->virt == NULL) {
3535 kfree(sglq_entry);
3536 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3537 "6304 Failure to allocate an "
3538 "NVMET buf:%d\n", i);
3539 rc = -ENOMEM;
3540 goto out_free_mem;
3541 }
3542 sglq_entry->sgl = sglq_entry->virt;
3543 memset(sglq_entry->sgl, 0,
3544 phba->cfg_sg_dma_buf_size);
3545 sglq_entry->state = SGL_FREED;
3546 list_add_tail(&sglq_entry->list, &nvmet_sgl_list);
3547 }
3548 spin_lock_irq(&phba->hbalock);
3549 spin_lock(&phba->sli4_hba.sgl_list_lock);
3550 list_splice_init(&nvmet_sgl_list,
3551 &phba->sli4_hba.lpfc_nvmet_sgl_list);
3552 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3553 spin_unlock_irq(&phba->hbalock);
3554 } else if (nvmet_xri_cnt < phba->sli4_hba.nvmet_xri_cnt) {
3555 /* nvmet xri-sgl shrunk */
3556 xri_cnt = phba->sli4_hba.nvmet_xri_cnt - nvmet_xri_cnt;
3557 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3558 "6305 NVMET xri-sgl count decreased from "
3559 "%d to %d\n", phba->sli4_hba.nvmet_xri_cnt,
3560 nvmet_xri_cnt);
3561 spin_lock_irq(&phba->hbalock);
3562 spin_lock(&phba->sli4_hba.sgl_list_lock);
3563 list_splice_init(&phba->sli4_hba.lpfc_nvmet_sgl_list,
3564 &nvmet_sgl_list);
3565 /* release extra nvmet sgls from list */
3566 for (i = 0; i < xri_cnt; i++) {
3567 list_remove_head(&nvmet_sgl_list,
3568 sglq_entry, struct lpfc_sglq, list);
3569 if (sglq_entry) {
3570 lpfc_nvmet_buf_free(phba, sglq_entry->virt,
3571 sglq_entry->phys);
3572 kfree(sglq_entry);
3573 }
3574 }
3575 list_splice_init(&nvmet_sgl_list,
3576 &phba->sli4_hba.lpfc_nvmet_sgl_list);
3577 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3578 spin_unlock_irq(&phba->hbalock);
3579 } else
3580 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3581 "6306 NVMET xri-sgl count unchanged: %d\n",
3582 nvmet_xri_cnt);
3583 phba->sli4_hba.nvmet_xri_cnt = nvmet_xri_cnt;
3584
3585 /* update xris to nvmet sgls on the list */
3586 sglq_entry = NULL;
3587 sglq_entry_next = NULL;
3588 list_for_each_entry_safe(sglq_entry, sglq_entry_next,
3589 &phba->sli4_hba.lpfc_nvmet_sgl_list, list) {
3590 lxri = lpfc_sli4_next_xritag(phba);
3591 if (lxri == NO_XRI) {
3592 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3593 "6307 Failed to allocate xri for "
3594 "NVMET sgl\n");
3595 rc = -ENOMEM;
3596 goto out_free_mem;
3597 }
3598 sglq_entry->sli4_lxritag = lxri;
3599 sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3600 }
3601 return 0;
3602
3603 out_free_mem:
3604 lpfc_free_nvmet_sgl_list(phba);
3605 return rc;
3606 }
3607
3608 /**
3609 * lpfc_sli4_scsi_sgl_update - update xri-sgl sizing and mapping
3610 * @phba: pointer to lpfc hba data structure.
3611 *
3612 * This routine first calculates the sizes of the current els and allocated
3613 * scsi sgl lists, and then goes through all sgls to updates the physical
3614 * XRIs assigned due to port function reset. During port initialization, the
3615 * current els and allocated scsi sgl lists are 0s.
3616 *
3617 * Return codes
3618 * 0 - successful (for now, it always returns 0)
3619 **/
3620 int
3621 lpfc_sli4_scsi_sgl_update(struct lpfc_hba *phba)
3622 {
3623 struct lpfc_scsi_buf *psb, *psb_next;
3624 uint16_t i, lxri, els_xri_cnt, scsi_xri_cnt;
3625 LIST_HEAD(scsi_sgl_list);
3626 int rc;
3627
3628 /*
3629 * update on pci function's els xri-sgl list
3630 */
3631 els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3632 phba->total_scsi_bufs = 0;
3633
3634 /*
3635 * update on pci function's allocated scsi xri-sgl list
3636 */
3637 /* maximum number of xris available for scsi buffers */
3638 phba->sli4_hba.scsi_xri_max = phba->sli4_hba.max_cfg_param.max_xri -
3639 els_xri_cnt;
3640
3641 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
3642 return 0;
3643
3644 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
3645 phba->sli4_hba.scsi_xri_max = /* Split them up */
3646 (phba->sli4_hba.scsi_xri_max *
3647 phba->cfg_xri_split) / 100;
3648
3649 spin_lock_irq(&phba->scsi_buf_list_get_lock);
3650 spin_lock(&phba->scsi_buf_list_put_lock);
3651 list_splice_init(&phba->lpfc_scsi_buf_list_get, &scsi_sgl_list);
3652 list_splice(&phba->lpfc_scsi_buf_list_put, &scsi_sgl_list);
3653 spin_unlock(&phba->scsi_buf_list_put_lock);
3654 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3655
3656 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3657 "6060 Current allocated SCSI xri-sgl count:%d, "
3658 "maximum SCSI xri count:%d (split:%d)\n",
3659 phba->sli4_hba.scsi_xri_cnt,
3660 phba->sli4_hba.scsi_xri_max, phba->cfg_xri_split);
3661
3662 if (phba->sli4_hba.scsi_xri_cnt > phba->sli4_hba.scsi_xri_max) {
3663 /* max scsi xri shrinked below the allocated scsi buffers */
3664 scsi_xri_cnt = phba->sli4_hba.scsi_xri_cnt -
3665 phba->sli4_hba.scsi_xri_max;
3666 /* release the extra allocated scsi buffers */
3667 for (i = 0; i < scsi_xri_cnt; i++) {
3668 list_remove_head(&scsi_sgl_list, psb,
3669 struct lpfc_scsi_buf, list);
3670 if (psb) {
3671 dma_pool_free(phba->lpfc_sg_dma_buf_pool,
3672 psb->data, psb->dma_handle);
3673 kfree(psb);
3674 }
3675 }
3676 spin_lock_irq(&phba->scsi_buf_list_get_lock);
3677 phba->sli4_hba.scsi_xri_cnt -= scsi_xri_cnt;
3678 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3679 }
3680
3681 /* update xris associated to remaining allocated scsi buffers */
3682 psb = NULL;
3683 psb_next = NULL;
3684 list_for_each_entry_safe(psb, psb_next, &scsi_sgl_list, list) {
3685 lxri = lpfc_sli4_next_xritag(phba);
3686 if (lxri == NO_XRI) {
3687 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3688 "2560 Failed to allocate xri for "
3689 "scsi buffer\n");
3690 rc = -ENOMEM;
3691 goto out_free_mem;
3692 }
3693 psb->cur_iocbq.sli4_lxritag = lxri;
3694 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3695 }
3696 spin_lock_irq(&phba->scsi_buf_list_get_lock);
3697 spin_lock(&phba->scsi_buf_list_put_lock);
3698 list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list_get);
3699 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
3700 spin_unlock(&phba->scsi_buf_list_put_lock);
3701 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3702 return 0;
3703
3704 out_free_mem:
3705 lpfc_scsi_free(phba);
3706 return rc;
3707 }
3708
3709 static uint64_t
3710 lpfc_get_wwpn(struct lpfc_hba *phba)
3711 {
3712 uint64_t wwn;
3713 int rc;
3714 LPFC_MBOXQ_t *mboxq;
3715 MAILBOX_t *mb;
3716
3717 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
3718 GFP_KERNEL);
3719 if (!mboxq)
3720 return (uint64_t)-1;
3721
3722 /* First get WWN of HBA instance */
3723 lpfc_read_nv(phba, mboxq);
3724 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
3725 if (rc != MBX_SUCCESS) {
3726 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3727 "6019 Mailbox failed , mbxCmd x%x "
3728 "READ_NV, mbxStatus x%x\n",
3729 bf_get(lpfc_mqe_command, &mboxq->u.mqe),
3730 bf_get(lpfc_mqe_status, &mboxq->u.mqe));
3731 mempool_free(mboxq, phba->mbox_mem_pool);
3732 return (uint64_t) -1;
3733 }
3734 mb = &mboxq->u.mb;
3735 memcpy(&wwn, (char *)mb->un.varRDnvp.portname, sizeof(uint64_t));
3736 /* wwn is WWPN of HBA instance */
3737 mempool_free(mboxq, phba->mbox_mem_pool);
3738 if (phba->sli_rev == LPFC_SLI_REV4)
3739 return be64_to_cpu(wwn);
3740 else
3741 return rol64(wwn, 32);
3742 }
3743
3744 /**
3745 * lpfc_sli4_nvme_sgl_update - update xri-sgl sizing and mapping
3746 * @phba: pointer to lpfc hba data structure.
3747 *
3748 * This routine first calculates the sizes of the current els and allocated
3749 * scsi sgl lists, and then goes through all sgls to updates the physical
3750 * XRIs assigned due to port function reset. During port initialization, the
3751 * current els and allocated scsi sgl lists are 0s.
3752 *
3753 * Return codes
3754 * 0 - successful (for now, it always returns 0)
3755 **/
3756 int
3757 lpfc_sli4_nvme_sgl_update(struct lpfc_hba *phba)
3758 {
3759 struct lpfc_nvme_buf *lpfc_ncmd = NULL, *lpfc_ncmd_next = NULL;
3760 uint16_t i, lxri, els_xri_cnt;
3761 uint16_t nvme_xri_cnt, nvme_xri_max;
3762 LIST_HEAD(nvme_sgl_list);
3763 int rc, cnt;
3764
3765 phba->total_nvme_bufs = 0;
3766 phba->get_nvme_bufs = 0;
3767 phba->put_nvme_bufs = 0;
3768
3769 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
3770 return 0;
3771 /*
3772 * update on pci function's allocated nvme xri-sgl list
3773 */
3774
3775 /* maximum number of xris available for nvme buffers */
3776 els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3777 nvme_xri_max = phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
3778 phba->sli4_hba.nvme_xri_max = nvme_xri_max;
3779 phba->sli4_hba.nvme_xri_max -= phba->sli4_hba.scsi_xri_max;
3780
3781 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3782 "6074 Current allocated NVME xri-sgl count:%d, "
3783 "maximum NVME xri count:%d\n",
3784 phba->sli4_hba.nvme_xri_cnt,
3785 phba->sli4_hba.nvme_xri_max);
3786
3787 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3788 spin_lock(&phba->nvme_buf_list_put_lock);
3789 list_splice_init(&phba->lpfc_nvme_buf_list_get, &nvme_sgl_list);
3790 list_splice(&phba->lpfc_nvme_buf_list_put, &nvme_sgl_list);
3791 cnt = phba->get_nvme_bufs + phba->put_nvme_bufs;
3792 phba->get_nvme_bufs = 0;
3793 phba->put_nvme_bufs = 0;
3794 spin_unlock(&phba->nvme_buf_list_put_lock);
3795 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3796
3797 if (phba->sli4_hba.nvme_xri_cnt > phba->sli4_hba.nvme_xri_max) {
3798 /* max nvme xri shrunk below the allocated nvme buffers */
3799 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3800 nvme_xri_cnt = phba->sli4_hba.nvme_xri_cnt -
3801 phba->sli4_hba.nvme_xri_max;
3802 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3803 /* release the extra allocated nvme buffers */
3804 for (i = 0; i < nvme_xri_cnt; i++) {
3805 list_remove_head(&nvme_sgl_list, lpfc_ncmd,
3806 struct lpfc_nvme_buf, list);
3807 if (lpfc_ncmd) {
3808 dma_pool_free(phba->lpfc_sg_dma_buf_pool,
3809 lpfc_ncmd->data,
3810 lpfc_ncmd->dma_handle);
3811 kfree(lpfc_ncmd);
3812 }
3813 }
3814 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3815 phba->sli4_hba.nvme_xri_cnt -= nvme_xri_cnt;
3816 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3817 }
3818
3819 /* update xris associated to remaining allocated nvme buffers */
3820 lpfc_ncmd = NULL;
3821 lpfc_ncmd_next = NULL;
3822 list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3823 &nvme_sgl_list, list) {
3824 lxri = lpfc_sli4_next_xritag(phba);
3825 if (lxri == NO_XRI) {
3826 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3827 "6075 Failed to allocate xri for "
3828 "nvme buffer\n");
3829 rc = -ENOMEM;
3830 goto out_free_mem;
3831 }
3832 lpfc_ncmd->cur_iocbq.sli4_lxritag = lxri;
3833 lpfc_ncmd->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3834 }
3835 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3836 spin_lock(&phba->nvme_buf_list_put_lock);
3837 list_splice_init(&nvme_sgl_list, &phba->lpfc_nvme_buf_list_get);
3838 phba->get_nvme_bufs = cnt;
3839 INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_put);
3840 spin_unlock(&phba->nvme_buf_list_put_lock);
3841 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3842 return 0;
3843
3844 out_free_mem:
3845 lpfc_nvme_free(phba);
3846 return rc;
3847 }
3848
3849 /**
3850 * lpfc_create_port - Create an FC port
3851 * @phba: pointer to lpfc hba data structure.
3852 * @instance: a unique integer ID to this FC port.
3853 * @dev: pointer to the device data structure.
3854 *
3855 * This routine creates a FC port for the upper layer protocol. The FC port
3856 * can be created on top of either a physical port or a virtual port provided
3857 * by the HBA. This routine also allocates a SCSI host data structure (shost)
3858 * and associates the FC port created before adding the shost into the SCSI
3859 * layer.
3860 *
3861 * Return codes
3862 * @vport - pointer to the virtual N_Port data structure.
3863 * NULL - port create failed.
3864 **/
3865 struct lpfc_vport *
3866 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
3867 {
3868 struct lpfc_vport *vport;
3869 struct Scsi_Host *shost = NULL;
3870 int error = 0;
3871 int i;
3872 uint64_t wwn;
3873 bool use_no_reset_hba = false;
3874 int rc;
3875
3876 if (lpfc_no_hba_reset_cnt) {
3877 if (phba->sli_rev < LPFC_SLI_REV4 &&
3878 dev == &phba->pcidev->dev) {
3879 /* Reset the port first */
3880 lpfc_sli_brdrestart(phba);
3881 rc = lpfc_sli_chipset_init(phba);
3882 if (rc)
3883 return NULL;
3884 }
3885 wwn = lpfc_get_wwpn(phba);
3886 }
3887
3888 for (i = 0; i < lpfc_no_hba_reset_cnt; i++) {
3889 if (wwn == lpfc_no_hba_reset[i]) {
3890 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3891 "6020 Setting use_no_reset port=%llx\n",
3892 wwn);
3893 use_no_reset_hba = true;
3894 break;
3895 }
3896 }
3897
3898 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
3899 if (dev != &phba->pcidev->dev) {
3900 shost = scsi_host_alloc(&lpfc_vport_template,
3901 sizeof(struct lpfc_vport));
3902 } else {
3903 if (!use_no_reset_hba)
3904 shost = scsi_host_alloc(&lpfc_template,
3905 sizeof(struct lpfc_vport));
3906 else
3907 shost = scsi_host_alloc(&lpfc_template_no_hr,
3908 sizeof(struct lpfc_vport));
3909 }
3910 } else if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
3911 shost = scsi_host_alloc(&lpfc_template_nvme,
3912 sizeof(struct lpfc_vport));
3913 }
3914 if (!shost)
3915 goto out;
3916
3917 vport = (struct lpfc_vport *) shost->hostdata;
3918 vport->phba = phba;
3919 vport->load_flag |= FC_LOADING;
3920 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3921 vport->fc_rscn_flush = 0;
3922 lpfc_get_vport_cfgparam(vport);
3923
3924 shost->unique_id = instance;
3925 shost->max_id = LPFC_MAX_TARGET;
3926 shost->max_lun = vport->cfg_max_luns;
3927 shost->this_id = -1;
3928 shost->max_cmd_len = 16;
3929 shost->nr_hw_queues = phba->cfg_fcp_io_channel;
3930 if (phba->sli_rev == LPFC_SLI_REV4) {
3931 shost->dma_boundary =
3932 phba->sli4_hba.pc_sli4_params.sge_supp_len-1;
3933 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
3934 }
3935
3936 /*
3937 * Set initial can_queue value since 0 is no longer supported and
3938 * scsi_add_host will fail. This will be adjusted later based on the
3939 * max xri value determined in hba setup.
3940 */
3941 shost->can_queue = phba->cfg_hba_queue_depth - 10;
3942 if (dev != &phba->pcidev->dev) {
3943 shost->transportt = lpfc_vport_transport_template;
3944 vport->port_type = LPFC_NPIV_PORT;
3945 } else {
3946 shost->transportt = lpfc_transport_template;
3947 vport->port_type = LPFC_PHYSICAL_PORT;
3948 }
3949
3950 /* Initialize all internally managed lists. */
3951 INIT_LIST_HEAD(&vport->fc_nodes);
3952 INIT_LIST_HEAD(&vport->rcv_buffer_list);
3953 spin_lock_init(&vport->work_port_lock);
3954
3955 timer_setup(&vport->fc_disctmo, lpfc_disc_timeout, 0);
3956
3957 timer_setup(&vport->els_tmofunc, lpfc_els_timeout, 0);
3958
3959 timer_setup(&vport->delayed_disc_tmo, lpfc_delayed_disc_tmo, 0);
3960
3961 error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
3962 if (error)
3963 goto out_put_shost;
3964
3965 spin_lock_irq(&phba->hbalock);
3966 list_add_tail(&vport->listentry, &phba->port_list);
3967 spin_unlock_irq(&phba->hbalock);
3968 return vport;
3969
3970 out_put_shost:
3971 scsi_host_put(shost);
3972 out:
3973 return NULL;
3974 }
3975
3976 /**
3977 * destroy_port - destroy an FC port
3978 * @vport: pointer to an lpfc virtual N_Port data structure.
3979 *
3980 * This routine destroys a FC port from the upper layer protocol. All the
3981 * resources associated with the port are released.
3982 **/
3983 void
3984 destroy_port(struct lpfc_vport *vport)
3985 {
3986 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3987 struct lpfc_hba *phba = vport->phba;
3988
3989 lpfc_debugfs_terminate(vport);
3990 fc_remove_host(shost);
3991 scsi_remove_host(shost);
3992
3993 spin_lock_irq(&phba->hbalock);
3994 list_del_init(&vport->listentry);
3995 spin_unlock_irq(&phba->hbalock);
3996
3997 lpfc_cleanup(vport);
3998 return;
3999 }
4000
4001 /**
4002 * lpfc_get_instance - Get a unique integer ID
4003 *
4004 * This routine allocates a unique integer ID from lpfc_hba_index pool. It
4005 * uses the kernel idr facility to perform the task.
4006 *
4007 * Return codes:
4008 * instance - a unique integer ID allocated as the new instance.
4009 * -1 - lpfc get instance failed.
4010 **/
4011 int
4012 lpfc_get_instance(void)
4013 {
4014 int ret;
4015
4016 ret = idr_alloc(&lpfc_hba_index, NULL, 0, 0, GFP_KERNEL);
4017 return ret < 0 ? -1 : ret;
4018 }
4019
4020 /**
4021 * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
4022 * @shost: pointer to SCSI host data structure.
4023 * @time: elapsed time of the scan in jiffies.
4024 *
4025 * This routine is called by the SCSI layer with a SCSI host to determine
4026 * whether the scan host is finished.
4027 *
4028 * Note: there is no scan_start function as adapter initialization will have
4029 * asynchronously kicked off the link initialization.
4030 *
4031 * Return codes
4032 * 0 - SCSI host scan is not over yet.
4033 * 1 - SCSI host scan is over.
4034 **/
4035 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
4036 {
4037 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4038 struct lpfc_hba *phba = vport->phba;
4039 int stat = 0;
4040
4041 spin_lock_irq(shost->host_lock);
4042
4043 if (vport->load_flag & FC_UNLOADING) {
4044 stat = 1;
4045 goto finished;
4046 }
4047 if (time >= msecs_to_jiffies(30 * 1000)) {
4048 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4049 "0461 Scanning longer than 30 "
4050 "seconds. Continuing initialization\n");
4051 stat = 1;
4052 goto finished;
4053 }
4054 if (time >= msecs_to_jiffies(15 * 1000) &&
4055 phba->link_state <= LPFC_LINK_DOWN) {
4056 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4057 "0465 Link down longer than 15 "
4058 "seconds. Continuing initialization\n");
4059 stat = 1;
4060 goto finished;
4061 }
4062
4063 if (vport->port_state != LPFC_VPORT_READY)
4064 goto finished;
4065 if (vport->num_disc_nodes || vport->fc_prli_sent)
4066 goto finished;
4067 if (vport->fc_map_cnt == 0 && time < msecs_to_jiffies(2 * 1000))
4068 goto finished;
4069 if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
4070 goto finished;
4071
4072 stat = 1;
4073
4074 finished:
4075 spin_unlock_irq(shost->host_lock);
4076 return stat;
4077 }
4078
4079 /**
4080 * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
4081 * @shost: pointer to SCSI host data structure.
4082 *
4083 * This routine initializes a given SCSI host attributes on a FC port. The
4084 * SCSI host can be either on top of a physical port or a virtual port.
4085 **/
4086 void lpfc_host_attrib_init(struct Scsi_Host *shost)
4087 {
4088 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4089 struct lpfc_hba *phba = vport->phba;
4090 /*
4091 * Set fixed host attributes. Must done after lpfc_sli_hba_setup().
4092 */
4093
4094 fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
4095 fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
4096 fc_host_supported_classes(shost) = FC_COS_CLASS3;
4097
4098 memset(fc_host_supported_fc4s(shost), 0,
4099 sizeof(fc_host_supported_fc4s(shost)));
4100 fc_host_supported_fc4s(shost)[2] = 1;
4101 fc_host_supported_fc4s(shost)[7] = 1;
4102
4103 lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
4104 sizeof fc_host_symbolic_name(shost));
4105
4106 fc_host_supported_speeds(shost) = 0;
4107 if (phba->lmt & LMT_32Gb)
4108 fc_host_supported_speeds(shost) |= FC_PORTSPEED_32GBIT;
4109 if (phba->lmt & LMT_16Gb)
4110 fc_host_supported_speeds(shost) |= FC_PORTSPEED_16GBIT;
4111 if (phba->lmt & LMT_10Gb)
4112 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
4113 if (phba->lmt & LMT_8Gb)
4114 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
4115 if (phba->lmt & LMT_4Gb)
4116 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
4117 if (phba->lmt & LMT_2Gb)
4118 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
4119 if (phba->lmt & LMT_1Gb)
4120 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
4121
4122 fc_host_maxframe_size(shost) =
4123 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
4124 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
4125
4126 fc_host_dev_loss_tmo(shost) = vport->cfg_devloss_tmo;
4127
4128 /* This value is also unchanging */
4129 memset(fc_host_active_fc4s(shost), 0,
4130 sizeof(fc_host_active_fc4s(shost)));
4131 fc_host_active_fc4s(shost)[2] = 1;
4132 fc_host_active_fc4s(shost)[7] = 1;
4133
4134 fc_host_max_npiv_vports(shost) = phba->max_vpi;
4135 spin_lock_irq(shost->host_lock);
4136 vport->load_flag &= ~FC_LOADING;
4137 spin_unlock_irq(shost->host_lock);
4138 }
4139
4140 /**
4141 * lpfc_stop_port_s3 - Stop SLI3 device port
4142 * @phba: pointer to lpfc hba data structure.
4143 *
4144 * This routine is invoked to stop an SLI3 device port, it stops the device
4145 * from generating interrupts and stops the device driver's timers for the
4146 * device.
4147 **/
4148 static void
4149 lpfc_stop_port_s3(struct lpfc_hba *phba)
4150 {
4151 /* Clear all interrupt enable conditions */
4152 writel(0, phba->HCregaddr);
4153 readl(phba->HCregaddr); /* flush */
4154 /* Clear all pending interrupts */
4155 writel(0xffffffff, phba->HAregaddr);
4156 readl(phba->HAregaddr); /* flush */
4157
4158 /* Reset some HBA SLI setup states */
4159 lpfc_stop_hba_timers(phba);
4160 phba->pport->work_port_events = 0;
4161 }
4162
4163 /**
4164 * lpfc_stop_port_s4 - Stop SLI4 device port
4165 * @phba: pointer to lpfc hba data structure.
4166 *
4167 * This routine is invoked to stop an SLI4 device port, it stops the device
4168 * from generating interrupts and stops the device driver's timers for the
4169 * device.
4170 **/
4171 static void
4172 lpfc_stop_port_s4(struct lpfc_hba *phba)
4173 {
4174 /* Reset some HBA SLI4 setup states */
4175 lpfc_stop_hba_timers(phba);
4176 phba->pport->work_port_events = 0;
4177 phba->sli4_hba.intr_enable = 0;
4178 }
4179
4180 /**
4181 * lpfc_stop_port - Wrapper function for stopping hba port
4182 * @phba: Pointer to HBA context object.
4183 *
4184 * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
4185 * the API jump table function pointer from the lpfc_hba struct.
4186 **/
4187 void
4188 lpfc_stop_port(struct lpfc_hba *phba)
4189 {
4190 phba->lpfc_stop_port(phba);
4191
4192 if (phba->wq)
4193 flush_workqueue(phba->wq);
4194 }
4195
4196 /**
4197 * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
4198 * @phba: Pointer to hba for which this call is being executed.
4199 *
4200 * This routine starts the timer waiting for the FCF rediscovery to complete.
4201 **/
4202 void
4203 lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
4204 {
4205 unsigned long fcf_redisc_wait_tmo =
4206 (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
4207 /* Start fcf rediscovery wait period timer */
4208 mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
4209 spin_lock_irq(&phba->hbalock);
4210 /* Allow action to new fcf asynchronous event */
4211 phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
4212 /* Mark the FCF rediscovery pending state */
4213 phba->fcf.fcf_flag |= FCF_REDISC_PEND;
4214 spin_unlock_irq(&phba->hbalock);
4215 }
4216
4217 /**
4218 * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
4219 * @ptr: Map to lpfc_hba data structure pointer.
4220 *
4221 * This routine is invoked when waiting for FCF table rediscover has been
4222 * timed out. If new FCF record(s) has (have) been discovered during the
4223 * wait period, a new FCF event shall be added to the FCOE async event
4224 * list, and then worker thread shall be waked up for processing from the
4225 * worker thread context.
4226 **/
4227 static void
4228 lpfc_sli4_fcf_redisc_wait_tmo(struct timer_list *t)
4229 {
4230 struct lpfc_hba *phba = from_timer(phba, t, fcf.redisc_wait);
4231
4232 /* Don't send FCF rediscovery event if timer cancelled */
4233 spin_lock_irq(&phba->hbalock);
4234 if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
4235 spin_unlock_irq(&phba->hbalock);
4236 return;
4237 }
4238 /* Clear FCF rediscovery timer pending flag */
4239 phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
4240 /* FCF rediscovery event to worker thread */
4241 phba->fcf.fcf_flag |= FCF_REDISC_EVT;
4242 spin_unlock_irq(&phba->hbalock);
4243 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
4244 "2776 FCF rediscover quiescent timer expired\n");
4245 /* wake up worker thread */
4246 lpfc_worker_wake_up(phba);
4247 }
4248
4249 /**
4250 * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
4251 * @phba: pointer to lpfc hba data structure.
4252 * @acqe_link: pointer to the async link completion queue entry.
4253 *
4254 * This routine is to parse the SLI4 link-attention link fault code and
4255 * translate it into the base driver's read link attention mailbox command
4256 * status.
4257 *
4258 * Return: Link-attention status in terms of base driver's coding.
4259 **/
4260 static uint16_t
4261 lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba,
4262 struct lpfc_acqe_link *acqe_link)
4263 {
4264 uint16_t latt_fault;
4265
4266 switch (bf_get(lpfc_acqe_link_fault, acqe_link)) {
4267 case LPFC_ASYNC_LINK_FAULT_NONE:
4268 case LPFC_ASYNC_LINK_FAULT_LOCAL:
4269 case LPFC_ASYNC_LINK_FAULT_REMOTE:
4270 latt_fault = 0;
4271 break;
4272 default:
4273 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4274 "0398 Invalid link fault code: x%x\n",
4275 bf_get(lpfc_acqe_link_fault, acqe_link));
4276 latt_fault = MBXERR_ERROR;
4277 break;
4278 }
4279 return latt_fault;
4280 }
4281
4282 /**
4283 * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
4284 * @phba: pointer to lpfc hba data structure.
4285 * @acqe_link: pointer to the async link completion queue entry.
4286 *
4287 * This routine is to parse the SLI4 link attention type and translate it
4288 * into the base driver's link attention type coding.
4289 *
4290 * Return: Link attention type in terms of base driver's coding.
4291 **/
4292 static uint8_t
4293 lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
4294 struct lpfc_acqe_link *acqe_link)
4295 {
4296 uint8_t att_type;
4297
4298 switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
4299 case LPFC_ASYNC_LINK_STATUS_DOWN:
4300 case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
4301 att_type = LPFC_ATT_LINK_DOWN;
4302 break;
4303 case LPFC_ASYNC_LINK_STATUS_UP:
4304 /* Ignore physical link up events - wait for logical link up */
4305 att_type = LPFC_ATT_RESERVED;
4306 break;
4307 case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
4308 att_type = LPFC_ATT_LINK_UP;
4309 break;
4310 default:
4311 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4312 "0399 Invalid link attention type: x%x\n",
4313 bf_get(lpfc_acqe_link_status, acqe_link));
4314 att_type = LPFC_ATT_RESERVED;
4315 break;
4316 }
4317 return att_type;
4318 }
4319
4320 /**
4321 * lpfc_sli_port_speed_get - Get sli3 link speed code to link speed
4322 * @phba: pointer to lpfc hba data structure.
4323 *
4324 * This routine is to get an SLI3 FC port's link speed in Mbps.
4325 *
4326 * Return: link speed in terms of Mbps.
4327 **/
4328 uint32_t
4329 lpfc_sli_port_speed_get(struct lpfc_hba *phba)
4330 {
4331 uint32_t link_speed;
4332
4333 if (!lpfc_is_link_up(phba))
4334 return 0;
4335
4336 if (phba->sli_rev <= LPFC_SLI_REV3) {
4337 switch (phba->fc_linkspeed) {
4338 case LPFC_LINK_SPEED_1GHZ:
4339 link_speed = 1000;
4340 break;
4341 case LPFC_LINK_SPEED_2GHZ:
4342 link_speed = 2000;
4343 break;
4344 case LPFC_LINK_SPEED_4GHZ:
4345 link_speed = 4000;
4346 break;
4347 case LPFC_LINK_SPEED_8GHZ:
4348 link_speed = 8000;
4349 break;
4350 case LPFC_LINK_SPEED_10GHZ:
4351 link_speed = 10000;
4352 break;
4353 case LPFC_LINK_SPEED_16GHZ:
4354 link_speed = 16000;
4355 break;
4356 default:
4357 link_speed = 0;
4358 }
4359 } else {
4360 if (phba->sli4_hba.link_state.logical_speed)
4361 link_speed =
4362 phba->sli4_hba.link_state.logical_speed;
4363 else
4364 link_speed = phba->sli4_hba.link_state.speed;
4365 }
4366 return link_speed;
4367 }
4368
4369 /**
4370 * lpfc_sli4_port_speed_parse - Parse async evt link speed code to link speed
4371 * @phba: pointer to lpfc hba data structure.
4372 * @evt_code: asynchronous event code.
4373 * @speed_code: asynchronous event link speed code.
4374 *
4375 * This routine is to parse the giving SLI4 async event link speed code into
4376 * value of Mbps for the link speed.
4377 *
4378 * Return: link speed in terms of Mbps.
4379 **/
4380 static uint32_t
4381 lpfc_sli4_port_speed_parse(struct lpfc_hba *phba, uint32_t evt_code,
4382 uint8_t speed_code)
4383 {
4384 uint32_t port_speed;
4385
4386 switch (evt_code) {
4387 case LPFC_TRAILER_CODE_LINK:
4388 switch (speed_code) {
4389 case LPFC_ASYNC_LINK_SPEED_ZERO:
4390 port_speed = 0;
4391 break;
4392 case LPFC_ASYNC_LINK_SPEED_10MBPS:
4393 port_speed = 10;
4394 break;
4395 case LPFC_ASYNC_LINK_SPEED_100MBPS:
4396 port_speed = 100;
4397 break;
4398 case LPFC_ASYNC_LINK_SPEED_1GBPS:
4399 port_speed = 1000;
4400 break;
4401 case LPFC_ASYNC_LINK_SPEED_10GBPS:
4402 port_speed = 10000;
4403 break;
4404 case LPFC_ASYNC_LINK_SPEED_20GBPS:
4405 port_speed = 20000;
4406 break;
4407 case LPFC_ASYNC_LINK_SPEED_25GBPS:
4408 port_speed = 25000;
4409 break;
4410 case LPFC_ASYNC_LINK_SPEED_40GBPS:
4411 port_speed = 40000;
4412 break;
4413 default:
4414 port_speed = 0;
4415 }
4416 break;
4417 case LPFC_TRAILER_CODE_FC:
4418 switch (speed_code) {
4419 case LPFC_FC_LA_SPEED_UNKNOWN:
4420 port_speed = 0;
4421 break;
4422 case LPFC_FC_LA_SPEED_1G:
4423 port_speed = 1000;
4424 break;
4425 case LPFC_FC_LA_SPEED_2G:
4426 port_speed = 2000;
4427 break;
4428 case LPFC_FC_LA_SPEED_4G:
4429 port_speed = 4000;
4430 break;
4431 case LPFC_FC_LA_SPEED_8G:
4432 port_speed = 8000;
4433 break;
4434 case LPFC_FC_LA_SPEED_10G:
4435 port_speed = 10000;
4436 break;
4437 case LPFC_FC_LA_SPEED_16G:
4438 port_speed = 16000;
4439 break;
4440 case LPFC_FC_LA_SPEED_32G:
4441 port_speed = 32000;
4442 break;
4443 default:
4444 port_speed = 0;
4445 }
4446 break;
4447 default:
4448 port_speed = 0;
4449 }
4450 return port_speed;
4451 }
4452
4453 /**
4454 * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event
4455 * @phba: pointer to lpfc hba data structure.
4456 * @acqe_link: pointer to the async link completion queue entry.
4457 *
4458 * This routine is to handle the SLI4 asynchronous FCoE link event.
4459 **/
4460 static void
4461 lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
4462 struct lpfc_acqe_link *acqe_link)
4463 {
4464 struct lpfc_dmabuf *mp;
4465 LPFC_MBOXQ_t *pmb;
4466 MAILBOX_t *mb;
4467 struct lpfc_mbx_read_top *la;
4468 uint8_t att_type;
4469 int rc;
4470
4471 att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
4472 if (att_type != LPFC_ATT_LINK_DOWN && att_type != LPFC_ATT_LINK_UP)
4473 return;
4474 phba->fcoe_eventtag = acqe_link->event_tag;
4475 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4476 if (!pmb) {
4477 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4478 "0395 The mboxq allocation failed\n");
4479 return;
4480 }
4481 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4482 if (!mp) {
4483 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4484 "0396 The lpfc_dmabuf allocation failed\n");
4485 goto out_free_pmb;
4486 }
4487 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4488 if (!mp->virt) {
4489 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4490 "0397 The mbuf allocation failed\n");
4491 goto out_free_dmabuf;
4492 }
4493
4494 /* Cleanup any outstanding ELS commands */
4495 lpfc_els_flush_all_cmd(phba);
4496
4497 /* Block ELS IOCBs until we have done process link event */
4498 phba->sli4_hba.els_wq->pring->flag |= LPFC_STOP_IOCB_EVENT;
4499
4500 /* Update link event statistics */
4501 phba->sli.slistat.link_event++;
4502
4503 /* Create lpfc_handle_latt mailbox command from link ACQE */
4504 lpfc_read_topology(phba, pmb, mp);
4505 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
4506 pmb->vport = phba->pport;
4507
4508 /* Keep the link status for extra SLI4 state machine reference */
4509 phba->sli4_hba.link_state.speed =
4510 lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_LINK,
4511 bf_get(lpfc_acqe_link_speed, acqe_link));
4512 phba->sli4_hba.link_state.duplex =
4513 bf_get(lpfc_acqe_link_duplex, acqe_link);
4514 phba->sli4_hba.link_state.status =
4515 bf_get(lpfc_acqe_link_status, acqe_link);
4516 phba->sli4_hba.link_state.type =
4517 bf_get(lpfc_acqe_link_type, acqe_link);
4518 phba->sli4_hba.link_state.number =
4519 bf_get(lpfc_acqe_link_number, acqe_link);
4520 phba->sli4_hba.link_state.fault =
4521 bf_get(lpfc_acqe_link_fault, acqe_link);
4522 phba->sli4_hba.link_state.logical_speed =
4523 bf_get(lpfc_acqe_logical_link_speed, acqe_link) * 10;
4524
4525 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4526 "2900 Async FC/FCoE Link event - Speed:%dGBit "
4527 "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
4528 "Logical speed:%dMbps Fault:%d\n",
4529 phba->sli4_hba.link_state.speed,
4530 phba->sli4_hba.link_state.topology,
4531 phba->sli4_hba.link_state.status,
4532 phba->sli4_hba.link_state.type,
4533 phba->sli4_hba.link_state.number,
4534 phba->sli4_hba.link_state.logical_speed,
4535 phba->sli4_hba.link_state.fault);
4536 /*
4537 * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch
4538 * topology info. Note: Optional for non FC-AL ports.
4539 */
4540 if (!(phba->hba_flag & HBA_FCOE_MODE)) {
4541 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4542 if (rc == MBX_NOT_FINISHED)
4543 goto out_free_dmabuf;
4544 return;
4545 }
4546 /*
4547 * For FCoE Mode: fill in all the topology information we need and call
4548 * the READ_TOPOLOGY completion routine to continue without actually
4549 * sending the READ_TOPOLOGY mailbox command to the port.
4550 */
4551 /* Parse and translate status field */
4552 mb = &pmb->u.mb;
4553 mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
4554
4555 /* Parse and translate link attention fields */
4556 la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
4557 la->eventTag = acqe_link->event_tag;
4558 bf_set(lpfc_mbx_read_top_att_type, la, att_type);
4559 bf_set(lpfc_mbx_read_top_link_spd, la,
4560 (bf_get(lpfc_acqe_link_speed, acqe_link)));
4561
4562 /* Fake the the following irrelvant fields */
4563 bf_set(lpfc_mbx_read_top_topology, la, LPFC_TOPOLOGY_PT_PT);
4564 bf_set(lpfc_mbx_read_top_alpa_granted, la, 0);
4565 bf_set(lpfc_mbx_read_top_il, la, 0);
4566 bf_set(lpfc_mbx_read_top_pb, la, 0);
4567 bf_set(lpfc_mbx_read_top_fa, la, 0);
4568 bf_set(lpfc_mbx_read_top_mm, la, 0);
4569
4570 /* Invoke the lpfc_handle_latt mailbox command callback function */
4571 lpfc_mbx_cmpl_read_topology(phba, pmb);
4572
4573 return;
4574
4575 out_free_dmabuf:
4576 kfree(mp);
4577 out_free_pmb:
4578 mempool_free(pmb, phba->mbox_mem_pool);
4579 }
4580
4581 /**
4582 * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event
4583 * @phba: pointer to lpfc hba data structure.
4584 * @acqe_fc: pointer to the async fc completion queue entry.
4585 *
4586 * This routine is to handle the SLI4 asynchronous FC event. It will simply log
4587 * that the event was received and then issue a read_topology mailbox command so
4588 * that the rest of the driver will treat it the same as SLI3.
4589 **/
4590 static void
4591 lpfc_sli4_async_fc_evt(struct lpfc_hba *phba, struct lpfc_acqe_fc_la *acqe_fc)
4592 {
4593 struct lpfc_dmabuf *mp;
4594 LPFC_MBOXQ_t *pmb;
4595 MAILBOX_t *mb;
4596 struct lpfc_mbx_read_top *la;
4597 int rc;
4598
4599 if (bf_get(lpfc_trailer_type, acqe_fc) !=
4600 LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
4601 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4602 "2895 Non FC link Event detected.(%d)\n",
4603 bf_get(lpfc_trailer_type, acqe_fc));
4604 return;
4605 }
4606 /* Keep the link status for extra SLI4 state machine reference */
4607 phba->sli4_hba.link_state.speed =
4608 lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_FC,
4609 bf_get(lpfc_acqe_fc_la_speed, acqe_fc));
4610 phba->sli4_hba.link_state.duplex = LPFC_ASYNC_LINK_DUPLEX_FULL;
4611 phba->sli4_hba.link_state.topology =
4612 bf_get(lpfc_acqe_fc_la_topology, acqe_fc);
4613 phba->sli4_hba.link_state.status =
4614 bf_get(lpfc_acqe_fc_la_att_type, acqe_fc);
4615 phba->sli4_hba.link_state.type =
4616 bf_get(lpfc_acqe_fc_la_port_type, acqe_fc);
4617 phba->sli4_hba.link_state.number =
4618 bf_get(lpfc_acqe_fc_la_port_number, acqe_fc);
4619 phba->sli4_hba.link_state.fault =
4620 bf_get(lpfc_acqe_link_fault, acqe_fc);
4621 phba->sli4_hba.link_state.logical_speed =
4622 bf_get(lpfc_acqe_fc_la_llink_spd, acqe_fc) * 10;
4623 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4624 "2896 Async FC event - Speed:%dGBaud Topology:x%x "
4625 "LA Type:x%x Port Type:%d Port Number:%d Logical speed:"
4626 "%dMbps Fault:%d\n",
4627 phba->sli4_hba.link_state.speed,
4628 phba->sli4_hba.link_state.topology,
4629 phba->sli4_hba.link_state.status,
4630 phba->sli4_hba.link_state.type,
4631 phba->sli4_hba.link_state.number,
4632 phba->sli4_hba.link_state.logical_speed,
4633 phba->sli4_hba.link_state.fault);
4634 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4635 if (!pmb) {
4636 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4637 "2897 The mboxq allocation failed\n");
4638 return;
4639 }
4640 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4641 if (!mp) {
4642 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4643 "2898 The lpfc_dmabuf allocation failed\n");
4644 goto out_free_pmb;
4645 }
4646 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4647 if (!mp->virt) {
4648 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4649 "2899 The mbuf allocation failed\n");
4650 goto out_free_dmabuf;
4651 }
4652
4653 /* Cleanup any outstanding ELS commands */
4654 lpfc_els_flush_all_cmd(phba);
4655
4656 /* Block ELS IOCBs until we have done process link event */
4657 phba->sli4_hba.els_wq->pring->flag |= LPFC_STOP_IOCB_EVENT;
4658
4659 /* Update link event statistics */
4660 phba->sli.slistat.link_event++;
4661
4662 /* Create lpfc_handle_latt mailbox command from link ACQE */
4663 lpfc_read_topology(phba, pmb, mp);
4664 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
4665 pmb->vport = phba->pport;
4666
4667 if (phba->sli4_hba.link_state.status != LPFC_FC_LA_TYPE_LINK_UP) {
4668 phba->link_flag &= ~(LS_MDS_LINK_DOWN | LS_MDS_LOOPBACK);
4669
4670 switch (phba->sli4_hba.link_state.status) {
4671 case LPFC_FC_LA_TYPE_MDS_LINK_DOWN:
4672 phba->link_flag |= LS_MDS_LINK_DOWN;
4673 break;
4674 case LPFC_FC_LA_TYPE_MDS_LOOPBACK:
4675 phba->link_flag |= LS_MDS_LOOPBACK;
4676 break;
4677 default:
4678 break;
4679 }
4680
4681 /* Parse and translate status field */
4682 mb = &pmb->u.mb;
4683 mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba,
4684 (void *)acqe_fc);
4685
4686 /* Parse and translate link attention fields */
4687 la = (struct lpfc_mbx_read_top *)&pmb->u.mb.un.varReadTop;
4688 la->eventTag = acqe_fc->event_tag;
4689
4690 if (phba->sli4_hba.link_state.status ==
4691 LPFC_FC_LA_TYPE_UNEXP_WWPN) {
4692 bf_set(lpfc_mbx_read_top_att_type, la,
4693 LPFC_FC_LA_TYPE_UNEXP_WWPN);
4694 } else {
4695 bf_set(lpfc_mbx_read_top_att_type, la,
4696 LPFC_FC_LA_TYPE_LINK_DOWN);
4697 }
4698 /* Invoke the mailbox command callback function */
4699 lpfc_mbx_cmpl_read_topology(phba, pmb);
4700
4701 return;
4702 }
4703
4704 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4705 if (rc == MBX_NOT_FINISHED)
4706 goto out_free_dmabuf;
4707 return;
4708
4709 out_free_dmabuf:
4710 kfree(mp);
4711 out_free_pmb:
4712 mempool_free(pmb, phba->mbox_mem_pool);
4713 }
4714
4715 /**
4716 * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
4717 * @phba: pointer to lpfc hba data structure.
4718 * @acqe_fc: pointer to the async SLI completion queue entry.
4719 *
4720 * This routine is to handle the SLI4 asynchronous SLI events.
4721 **/
4722 static void
4723 lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli)
4724 {
4725 char port_name;
4726 char message[128];
4727 uint8_t status;
4728 uint8_t evt_type;
4729 uint8_t operational = 0;
4730 struct temp_event temp_event_data;
4731 struct lpfc_acqe_misconfigured_event *misconfigured;
4732 struct Scsi_Host *shost;
4733
4734 evt_type = bf_get(lpfc_trailer_type, acqe_sli);
4735
4736 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4737 "2901 Async SLI event - Event Data1:x%08x Event Data2:"
4738 "x%08x SLI Event Type:%d\n",
4739 acqe_sli->event_data1, acqe_sli->event_data2,
4740 evt_type);
4741
4742 port_name = phba->Port[0];
4743 if (port_name == 0x00)
4744 port_name = '?'; /* get port name is empty */
4745
4746 switch (evt_type) {
4747 case LPFC_SLI_EVENT_TYPE_OVER_TEMP:
4748 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4749 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
4750 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4751
4752 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
4753 "3190 Over Temperature:%d Celsius- Port Name %c\n",
4754 acqe_sli->event_data1, port_name);
4755
4756 phba->sfp_warning |= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;
4757 shost = lpfc_shost_from_vport(phba->pport);
4758 fc_host_post_vendor_event(shost, fc_get_event_number(),
4759 sizeof(temp_event_data),
4760 (char *)&temp_event_data,
4761 SCSI_NL_VID_TYPE_PCI
4762 | PCI_VENDOR_ID_EMULEX);
4763 break;
4764 case LPFC_SLI_EVENT_TYPE_NORM_TEMP:
4765 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4766 temp_event_data.event_code = LPFC_NORMAL_TEMP;
4767 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4768
4769 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4770 "3191 Normal Temperature:%d Celsius - Port Name %c\n",
4771 acqe_sli->event_data1, port_name);
4772
4773 shost = lpfc_shost_from_vport(phba->pport);
4774 fc_host_post_vendor_event(shost, fc_get_event_number(),
4775 sizeof(temp_event_data),
4776 (char *)&temp_event_data,
4777 SCSI_NL_VID_TYPE_PCI
4778 | PCI_VENDOR_ID_EMULEX);
4779 break;
4780 case LPFC_SLI_EVENT_TYPE_MISCONFIGURED:
4781 misconfigured = (struct lpfc_acqe_misconfigured_event *)
4782 &acqe_sli->event_data1;
4783
4784 /* fetch the status for this port */
4785 switch (phba->sli4_hba.lnk_info.lnk_no) {
4786 case LPFC_LINK_NUMBER_0:
4787 status = bf_get(lpfc_sli_misconfigured_port0_state,
4788 &misconfigured->theEvent);
4789 operational = bf_get(lpfc_sli_misconfigured_port0_op,
4790 &misconfigured->theEvent);
4791 break;
4792 case LPFC_LINK_NUMBER_1:
4793 status = bf_get(lpfc_sli_misconfigured_port1_state,
4794 &misconfigured->theEvent);
4795 operational = bf_get(lpfc_sli_misconfigured_port1_op,
4796 &misconfigured->theEvent);
4797 break;
4798 case LPFC_LINK_NUMBER_2:
4799 status = bf_get(lpfc_sli_misconfigured_port2_state,
4800 &misconfigured->theEvent);
4801 operational = bf_get(lpfc_sli_misconfigured_port2_op,
4802 &misconfigured->theEvent);
4803 break;
4804 case LPFC_LINK_NUMBER_3:
4805 status = bf_get(lpfc_sli_misconfigured_port3_state,
4806 &misconfigured->theEvent);
4807 operational = bf_get(lpfc_sli_misconfigured_port3_op,
4808 &misconfigured->theEvent);
4809 break;
4810 default:
4811 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4812 "3296 "
4813 "LPFC_SLI_EVENT_TYPE_MISCONFIGURED "
4814 "event: Invalid link %d",
4815 phba->sli4_hba.lnk_info.lnk_no);
4816 return;
4817 }
4818
4819 /* Skip if optic state unchanged */
4820 if (phba->sli4_hba.lnk_info.optic_state == status)
4821 return;
4822
4823 switch (status) {
4824 case LPFC_SLI_EVENT_STATUS_VALID:
4825 sprintf(message, "Physical Link is functional");
4826 break;
4827 case LPFC_SLI_EVENT_STATUS_NOT_PRESENT:
4828 sprintf(message, "Optics faulted/incorrectly "
4829 "installed/not installed - Reseat optics, "
4830 "if issue not resolved, replace.");
4831 break;
4832 case LPFC_SLI_EVENT_STATUS_WRONG_TYPE:
4833 sprintf(message,
4834 "Optics of two types installed - Remove one "
4835 "optic or install matching pair of optics.");
4836 break;
4837 case LPFC_SLI_EVENT_STATUS_UNSUPPORTED:
4838 sprintf(message, "Incompatible optics - Replace with "
4839 "compatible optics for card to function.");
4840 break;
4841 case LPFC_SLI_EVENT_STATUS_UNQUALIFIED:
4842 sprintf(message, "Unqualified optics - Replace with "
4843 "Avago optics for Warranty and Technical "
4844 "Support - Link is%s operational",
4845 (operational) ? " not" : "");
4846 break;
4847 case LPFC_SLI_EVENT_STATUS_UNCERTIFIED:
4848 sprintf(message, "Uncertified optics - Replace with "
4849 "Avago-certified optics to enable link "
4850 "operation - Link is%s operational",
4851 (operational) ? " not" : "");
4852 break;
4853 default:
4854 /* firmware is reporting a status we don't know about */
4855 sprintf(message, "Unknown event status x%02x", status);
4856 break;
4857 }
4858 phba->sli4_hba.lnk_info.optic_state = status;
4859 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4860 "3176 Port Name %c %s\n", port_name, message);
4861 break;
4862 case LPFC_SLI_EVENT_TYPE_REMOTE_DPORT:
4863 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4864 "3192 Remote DPort Test Initiated - "
4865 "Event Data1:x%08x Event Data2: x%08x\n",
4866 acqe_sli->event_data1, acqe_sli->event_data2);
4867 break;
4868 default:
4869 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4870 "3193 Async SLI event - Event Data1:x%08x Event Data2:"
4871 "x%08x SLI Event Type:%d\n",
4872 acqe_sli->event_data1, acqe_sli->event_data2,
4873 evt_type);
4874 break;
4875 }
4876 }
4877
4878 /**
4879 * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
4880 * @vport: pointer to vport data structure.
4881 *
4882 * This routine is to perform Clear Virtual Link (CVL) on a vport in
4883 * response to a CVL event.
4884 *
4885 * Return the pointer to the ndlp with the vport if successful, otherwise
4886 * return NULL.
4887 **/
4888 static struct lpfc_nodelist *
4889 lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
4890 {
4891 struct lpfc_nodelist *ndlp;
4892 struct Scsi_Host *shost;
4893 struct lpfc_hba *phba;
4894
4895 if (!vport)
4896 return NULL;
4897 phba = vport->phba;
4898 if (!phba)
4899 return NULL;
4900 ndlp = lpfc_findnode_did(vport, Fabric_DID);
4901 if (!ndlp) {
4902 /* Cannot find existing Fabric ndlp, so allocate a new one */
4903 ndlp = lpfc_nlp_init(vport, Fabric_DID);
4904 if (!ndlp)
4905 return 0;
4906 /* Set the node type */
4907 ndlp->nlp_type |= NLP_FABRIC;
4908 /* Put ndlp onto node list */
4909 lpfc_enqueue_node(vport, ndlp);
4910 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4911 /* re-setup ndlp without removing from node list */
4912 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
4913 if (!ndlp)
4914 return 0;
4915 }
4916 if ((phba->pport->port_state < LPFC_FLOGI) &&
4917 (phba->pport->port_state != LPFC_VPORT_FAILED))
4918 return NULL;
4919 /* If virtual link is not yet instantiated ignore CVL */
4920 if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC)
4921 && (vport->port_state != LPFC_VPORT_FAILED))
4922 return NULL;
4923 shost = lpfc_shost_from_vport(vport);
4924 if (!shost)
4925 return NULL;
4926 lpfc_linkdown_port(vport);
4927 lpfc_cleanup_pending_mbox(vport);
4928 spin_lock_irq(shost->host_lock);
4929 vport->fc_flag |= FC_VPORT_CVL_RCVD;
4930 spin_unlock_irq(shost->host_lock);
4931
4932 return ndlp;
4933 }
4934
4935 /**
4936 * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
4937 * @vport: pointer to lpfc hba data structure.
4938 *
4939 * This routine is to perform Clear Virtual Link (CVL) on all vports in
4940 * response to a FCF dead event.
4941 **/
4942 static void
4943 lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
4944 {
4945 struct lpfc_vport **vports;
4946 int i;
4947
4948 vports = lpfc_create_vport_work_array(phba);
4949 if (vports)
4950 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
4951 lpfc_sli4_perform_vport_cvl(vports[i]);
4952 lpfc_destroy_vport_work_array(phba, vports);
4953 }
4954
4955 /**
4956 * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
4957 * @phba: pointer to lpfc hba data structure.
4958 * @acqe_link: pointer to the async fcoe completion queue entry.
4959 *
4960 * This routine is to handle the SLI4 asynchronous fcoe event.
4961 **/
4962 static void
4963 lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
4964 struct lpfc_acqe_fip *acqe_fip)
4965 {
4966 uint8_t event_type = bf_get(lpfc_trailer_type, acqe_fip);
4967 int rc;
4968 struct lpfc_vport *vport;
4969 struct lpfc_nodelist *ndlp;
4970 struct Scsi_Host *shost;
4971 int active_vlink_present;
4972 struct lpfc_vport **vports;
4973 int i;
4974
4975 phba->fc_eventTag = acqe_fip->event_tag;
4976 phba->fcoe_eventtag = acqe_fip->event_tag;
4977 switch (event_type) {
4978 case LPFC_FIP_EVENT_TYPE_NEW_FCF:
4979 case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:
4980 if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)
4981 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4982 LOG_DISCOVERY,
4983 "2546 New FCF event, evt_tag:x%x, "
4984 "index:x%x\n",
4985 acqe_fip->event_tag,
4986 acqe_fip->index);
4987 else
4988 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP |
4989 LOG_DISCOVERY,
4990 "2788 FCF param modified event, "
4991 "evt_tag:x%x, index:x%x\n",
4992 acqe_fip->event_tag,
4993 acqe_fip->index);
4994 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4995 /*
4996 * During period of FCF discovery, read the FCF
4997 * table record indexed by the event to update
4998 * FCF roundrobin failover eligible FCF bmask.
4999 */
5000 lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
5001 LOG_DISCOVERY,
5002 "2779 Read FCF (x%x) for updating "
5003 "roundrobin FCF failover bmask\n",
5004 acqe_fip->index);
5005 rc = lpfc_sli4_read_fcf_rec(phba, acqe_fip->index);
5006 }
5007
5008 /* If the FCF discovery is in progress, do nothing. */
5009 spin_lock_irq(&phba->hbalock);
5010 if (phba->hba_flag & FCF_TS_INPROG) {
5011 spin_unlock_irq(&phba->hbalock);
5012 break;
5013 }
5014 /* If fast FCF failover rescan event is pending, do nothing */
5015 if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
5016 spin_unlock_irq(&phba->hbalock);
5017 break;
5018 }
5019
5020 /* If the FCF has been in discovered state, do nothing. */
5021 if (phba->fcf.fcf_flag & FCF_SCAN_DONE) {
5022 spin_unlock_irq(&phba->hbalock);
5023 break;
5024 }
5025 spin_unlock_irq(&phba->hbalock);
5026
5027 /* Otherwise, scan the entire FCF table and re-discover SAN */
5028 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
5029 "2770 Start FCF table scan per async FCF "
5030 "event, evt_tag:x%x, index:x%x\n",
5031 acqe_fip->event_tag, acqe_fip->index);
5032 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
5033 LPFC_FCOE_FCF_GET_FIRST);
5034 if (rc)
5035 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
5036 "2547 Issue FCF scan read FCF mailbox "
5037 "command failed (x%x)\n", rc);
5038 break;
5039
5040 case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:
5041 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5042 "2548 FCF Table full count 0x%x tag 0x%x\n",
5043 bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),
5044 acqe_fip->event_tag);
5045 break;
5046
5047 case LPFC_FIP_EVENT_TYPE_FCF_DEAD:
5048 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
5049 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
5050 "2549 FCF (x%x) disconnected from network, "
5051 "tag:x%x\n", acqe_fip->index, acqe_fip->event_tag);
5052 /*
5053 * If we are in the middle of FCF failover process, clear
5054 * the corresponding FCF bit in the roundrobin bitmap.
5055 */
5056 spin_lock_irq(&phba->hbalock);
5057 if ((phba->fcf.fcf_flag & FCF_DISCOVERY) &&
5058 (phba->fcf.current_rec.fcf_indx != acqe_fip->index)) {
5059 spin_unlock_irq(&phba->hbalock);
5060 /* Update FLOGI FCF failover eligible FCF bmask */
5061 lpfc_sli4_fcf_rr_index_clear(phba, acqe_fip->index);
5062 break;
5063 }
5064 spin_unlock_irq(&phba->hbalock);
5065
5066 /* If the event is not for currently used fcf do nothing */
5067 if (phba->fcf.current_rec.fcf_indx != acqe_fip->index)
5068 break;
5069
5070 /*
5071 * Otherwise, request the port to rediscover the entire FCF
5072 * table for a fast recovery from case that the current FCF
5073 * is no longer valid as we are not in the middle of FCF
5074 * failover process already.
5075 */
5076 spin_lock_irq(&phba->hbalock);
5077 /* Mark the fast failover process in progress */
5078 phba->fcf.fcf_flag |= FCF_DEAD_DISC;
5079 spin_unlock_irq(&phba->hbalock);
5080
5081 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
5082 "2771 Start FCF fast failover process due to "
5083 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
5084 "\n", acqe_fip->event_tag, acqe_fip->index);
5085 rc = lpfc_sli4_redisc_fcf_table(phba);
5086 if (rc) {
5087 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
5088 LOG_DISCOVERY,
5089 "2772 Issue FCF rediscover mabilbox "
5090 "command failed, fail through to FCF "
5091 "dead event\n");
5092 spin_lock_irq(&phba->hbalock);
5093 phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
5094 spin_unlock_irq(&phba->hbalock);
5095 /*
5096 * Last resort will fail over by treating this
5097 * as a link down to FCF registration.
5098 */
5099 lpfc_sli4_fcf_dead_failthrough(phba);
5100 } else {
5101 /* Reset FCF roundrobin bmask for new discovery */
5102 lpfc_sli4_clear_fcf_rr_bmask(phba);
5103 /*
5104 * Handling fast FCF failover to a DEAD FCF event is
5105 * considered equalivant to receiving CVL to all vports.
5106 */
5107 lpfc_sli4_perform_all_vport_cvl(phba);
5108 }
5109 break;
5110 case LPFC_FIP_EVENT_TYPE_CVL:
5111 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
5112 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
5113 "2718 Clear Virtual Link Received for VPI 0x%x"
5114 " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
5115
5116 vport = lpfc_find_vport_by_vpid(phba,
5117 acqe_fip->index);
5118 ndlp = lpfc_sli4_perform_vport_cvl(vport);
5119 if (!ndlp)
5120 break;
5121 active_vlink_present = 0;
5122
5123 vports = lpfc_create_vport_work_array(phba);
5124 if (vports) {
5125 for (i = 0; i <= phba->max_vports && vports[i] != NULL;
5126 i++) {
5127 if ((!(vports[i]->fc_flag &
5128 FC_VPORT_CVL_RCVD)) &&
5129 (vports[i]->port_state > LPFC_FDISC)) {
5130 active_vlink_present = 1;
5131 break;
5132 }
5133 }
5134 lpfc_destroy_vport_work_array(phba, vports);
5135 }
5136
5137 /*
5138 * Don't re-instantiate if vport is marked for deletion.
5139 * If we are here first then vport_delete is going to wait
5140 * for discovery to complete.
5141 */
5142 if (!(vport->load_flag & FC_UNLOADING) &&
5143 active_vlink_present) {
5144 /*
5145 * If there are other active VLinks present,
5146 * re-instantiate the Vlink using FDISC.
5147 */
5148 mod_timer(&ndlp->nlp_delayfunc,
5149 jiffies + msecs_to_jiffies(1000));
5150 shost = lpfc_shost_from_vport(vport);
5151 spin_lock_irq(shost->host_lock);
5152 ndlp->nlp_flag |= NLP_DELAY_TMO;
5153 spin_unlock_irq(shost->host_lock);
5154 ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
5155 vport->port_state = LPFC_FDISC;
5156 } else {
5157 /*
5158 * Otherwise, we request port to rediscover
5159 * the entire FCF table for a fast recovery
5160 * from possible case that the current FCF
5161 * is no longer valid if we are not already
5162 * in the FCF failover process.
5163 */
5164 spin_lock_irq(&phba->hbalock);
5165 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
5166 spin_unlock_irq(&phba->hbalock);
5167 break;
5168 }
5169 /* Mark the fast failover process in progress */
5170 phba->fcf.fcf_flag |= FCF_ACVL_DISC;
5171 spin_unlock_irq(&phba->hbalock);
5172 lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
5173 LOG_DISCOVERY,
5174 "2773 Start FCF failover per CVL, "
5175 "evt_tag:x%x\n", acqe_fip->event_tag);
5176 rc = lpfc_sli4_redisc_fcf_table(phba);
5177 if (rc) {
5178 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
5179 LOG_DISCOVERY,
5180 "2774 Issue FCF rediscover "
5181 "mabilbox command failed, "
5182 "through to CVL event\n");
5183 spin_lock_irq(&phba->hbalock);
5184 phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
5185 spin_unlock_irq(&phba->hbalock);
5186 /*
5187 * Last resort will be re-try on the
5188 * the current registered FCF entry.
5189 */
5190 lpfc_retry_pport_discovery(phba);
5191 } else
5192 /*
5193 * Reset FCF roundrobin bmask for new
5194 * discovery.
5195 */
5196 lpfc_sli4_clear_fcf_rr_bmask(phba);
5197 }
5198 break;
5199 default:
5200 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5201 "0288 Unknown FCoE event type 0x%x event tag "
5202 "0x%x\n", event_type, acqe_fip->event_tag);
5203 break;
5204 }
5205 }
5206
5207 /**
5208 * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
5209 * @phba: pointer to lpfc hba data structure.
5210 * @acqe_link: pointer to the async dcbx completion queue entry.
5211 *
5212 * This routine is to handle the SLI4 asynchronous dcbx event.
5213 **/
5214 static void
5215 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
5216 struct lpfc_acqe_dcbx *acqe_dcbx)
5217 {
5218 phba->fc_eventTag = acqe_dcbx->event_tag;
5219 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5220 "0290 The SLI4 DCBX asynchronous event is not "
5221 "handled yet\n");
5222 }
5223
5224 /**
5225 * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
5226 * @phba: pointer to lpfc hba data structure.
5227 * @acqe_link: pointer to the async grp5 completion queue entry.
5228 *
5229 * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
5230 * is an asynchronous notified of a logical link speed change. The Port
5231 * reports the logical link speed in units of 10Mbps.
5232 **/
5233 static void
5234 lpfc_sli4_async_grp5_evt(struct lpfc_hba *phba,
5235 struct lpfc_acqe_grp5 *acqe_grp5)
5236 {
5237 uint16_t prev_ll_spd;
5238
5239 phba->fc_eventTag = acqe_grp5->event_tag;
5240 phba->fcoe_eventtag = acqe_grp5->event_tag;
5241 prev_ll_spd = phba->sli4_hba.link_state.logical_speed;
5242 phba->sli4_hba.link_state.logical_speed =
5243 (bf_get(lpfc_acqe_grp5_llink_spd, acqe_grp5)) * 10;
5244 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5245 "2789 GRP5 Async Event: Updating logical link speed "
5246 "from %dMbps to %dMbps\n", prev_ll_spd,
5247 phba->sli4_hba.link_state.logical_speed);
5248 }
5249
5250 /**
5251 * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
5252 * @phba: pointer to lpfc hba data structure.
5253 *
5254 * This routine is invoked by the worker thread to process all the pending
5255 * SLI4 asynchronous events.
5256 **/
5257 void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
5258 {
5259 struct lpfc_cq_event *cq_event;
5260
5261 /* First, declare the async event has been handled */
5262 spin_lock_irq(&phba->hbalock);
5263 phba->hba_flag &= ~ASYNC_EVENT;
5264 spin_unlock_irq(&phba->hbalock);
5265 /* Now, handle all the async events */
5266 while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) {
5267 /* Get the first event from the head of the event queue */
5268 spin_lock_irq(&phba->hbalock);
5269 list_remove_head(&phba->sli4_hba.sp_asynce_work_queue,
5270 cq_event, struct lpfc_cq_event, list);
5271 spin_unlock_irq(&phba->hbalock);
5272 /* Process the asynchronous event */
5273 switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) {
5274 case LPFC_TRAILER_CODE_LINK:
5275 lpfc_sli4_async_link_evt(phba,
5276 &cq_event->cqe.acqe_link);
5277 break;
5278 case LPFC_TRAILER_CODE_FCOE:
5279 lpfc_sli4_async_fip_evt(phba, &cq_event->cqe.acqe_fip);
5280 break;
5281 case LPFC_TRAILER_CODE_DCBX:
5282 lpfc_sli4_async_dcbx_evt(phba,
5283 &cq_event->cqe.acqe_dcbx);
5284 break;
5285 case LPFC_TRAILER_CODE_GRP5:
5286 lpfc_sli4_async_grp5_evt(phba,
5287 &cq_event->cqe.acqe_grp5);
5288 break;
5289 case LPFC_TRAILER_CODE_FC:
5290 lpfc_sli4_async_fc_evt(phba, &cq_event->cqe.acqe_fc);
5291 break;
5292 case LPFC_TRAILER_CODE_SLI:
5293 lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);
5294 break;
5295 default:
5296 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5297 "1804 Invalid asynchrous event code: "
5298 "x%x\n", bf_get(lpfc_trailer_code,
5299 &cq_event->cqe.mcqe_cmpl));
5300 break;
5301 }
5302 /* Free the completion event processed to the free pool */
5303 lpfc_sli4_cq_event_release(phba, cq_event);
5304 }
5305 }
5306
5307 /**
5308 * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
5309 * @phba: pointer to lpfc hba data structure.
5310 *
5311 * This routine is invoked by the worker thread to process FCF table
5312 * rediscovery pending completion event.
5313 **/
5314 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
5315 {
5316 int rc;
5317
5318 spin_lock_irq(&phba->hbalock);
5319 /* Clear FCF rediscovery timeout event */
5320 phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
5321 /* Clear driver fast failover FCF record flag */
5322 phba->fcf.failover_rec.flag = 0;
5323 /* Set state for FCF fast failover */
5324 phba->fcf.fcf_flag |= FCF_REDISC_FOV;
5325 spin_unlock_irq(&phba->hbalock);
5326
5327 /* Scan FCF table from the first entry to re-discover SAN */
5328 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
5329 "2777 Start post-quiescent FCF table scan\n");
5330 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
5331 if (rc)
5332 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
5333 "2747 Issue FCF scan read FCF mailbox "
5334 "command failed 0x%x\n", rc);
5335 }
5336
5337 /**
5338 * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
5339 * @phba: pointer to lpfc hba data structure.
5340 * @dev_grp: The HBA PCI-Device group number.
5341 *
5342 * This routine is invoked to set up the per HBA PCI-Device group function
5343 * API jump table entries.
5344 *
5345 * Return: 0 if success, otherwise -ENODEV
5346 **/
5347 int
5348 lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
5349 {
5350 int rc;
5351
5352 /* Set up lpfc PCI-device group */
5353 phba->pci_dev_grp = dev_grp;
5354
5355 /* The LPFC_PCI_DEV_OC uses SLI4 */
5356 if (dev_grp == LPFC_PCI_DEV_OC)
5357 phba->sli_rev = LPFC_SLI_REV4;
5358
5359 /* Set up device INIT API function jump table */
5360 rc = lpfc_init_api_table_setup(phba, dev_grp);
5361 if (rc)
5362 return -ENODEV;
5363 /* Set up SCSI API function jump table */
5364 rc = lpfc_scsi_api_table_setup(phba, dev_grp);
5365 if (rc)
5366 return -ENODEV;
5367 /* Set up SLI API function jump table */
5368 rc = lpfc_sli_api_table_setup(phba, dev_grp);
5369 if (rc)
5370 return -ENODEV;
5371 /* Set up MBOX API function jump table */
5372 rc = lpfc_mbox_api_table_setup(phba, dev_grp);
5373 if (rc)
5374 return -ENODEV;
5375
5376 return 0;
5377 }
5378
5379 /**
5380 * lpfc_log_intr_mode - Log the active interrupt mode
5381 * @phba: pointer to lpfc hba data structure.
5382 * @intr_mode: active interrupt mode adopted.
5383 *
5384 * This routine it invoked to log the currently used active interrupt mode
5385 * to the device.
5386 **/
5387 static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
5388 {
5389 switch (intr_mode) {
5390 case 0:
5391 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5392 "0470 Enable INTx interrupt mode.\n");
5393 break;
5394 case 1:
5395 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5396 "0481 Enabled MSI interrupt mode.\n");
5397 break;
5398 case 2:
5399 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5400 "0480 Enabled MSI-X interrupt mode.\n");
5401 break;
5402 default:
5403 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5404 "0482 Illegal interrupt mode.\n");
5405 break;
5406 }
5407 return;
5408 }
5409
5410 /**
5411 * lpfc_enable_pci_dev - Enable a generic PCI device.
5412 * @phba: pointer to lpfc hba data structure.
5413 *
5414 * This routine is invoked to enable the PCI device that is common to all
5415 * PCI devices.
5416 *
5417 * Return codes
5418 * 0 - successful
5419 * other values - error
5420 **/
5421 static int
5422 lpfc_enable_pci_dev(struct lpfc_hba *phba)
5423 {
5424 struct pci_dev *pdev;
5425
5426 /* Obtain PCI device reference */
5427 if (!phba->pcidev)
5428 goto out_error;
5429 else
5430 pdev = phba->pcidev;
5431 /* Enable PCI device */
5432 if (pci_enable_device_mem(pdev))
5433 goto out_error;
5434 /* Request PCI resource for the device */
5435 if (pci_request_mem_regions(pdev, LPFC_DRIVER_NAME))
5436 goto out_disable_device;
5437 /* Set up device as PCI master and save state for EEH */
5438 pci_set_master(pdev);
5439 pci_try_set_mwi(pdev);
5440 pci_save_state(pdev);
5441
5442 /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
5443 if (pci_is_pcie(pdev))
5444 pdev->needs_freset = 1;
5445
5446 return 0;
5447
5448 out_disable_device:
5449 pci_disable_device(pdev);
5450 out_error:
5451 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5452 "1401 Failed to enable pci device\n");
5453 return -ENODEV;
5454 }
5455
5456 /**
5457 * lpfc_disable_pci_dev - Disable a generic PCI device.
5458 * @phba: pointer to lpfc hba data structure.
5459 *
5460 * This routine is invoked to disable the PCI device that is common to all
5461 * PCI devices.
5462 **/
5463 static void
5464 lpfc_disable_pci_dev(struct lpfc_hba *phba)
5465 {
5466 struct pci_dev *pdev;
5467
5468 /* Obtain PCI device reference */
5469 if (!phba->pcidev)
5470 return;
5471 else
5472 pdev = phba->pcidev;
5473 /* Release PCI resource and disable PCI device */
5474 pci_release_mem_regions(pdev);
5475 pci_disable_device(pdev);
5476
5477 return;
5478 }
5479
5480 /**
5481 * lpfc_reset_hba - Reset a hba
5482 * @phba: pointer to lpfc hba data structure.
5483 *
5484 * This routine is invoked to reset a hba device. It brings the HBA
5485 * offline, performs a board restart, and then brings the board back
5486 * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
5487 * on outstanding mailbox commands.
5488 **/
5489 void
5490 lpfc_reset_hba(struct lpfc_hba *phba)
5491 {
5492 /* If resets are disabled then set error state and return. */
5493 if (!phba->cfg_enable_hba_reset) {
5494 phba->link_state = LPFC_HBA_ERROR;
5495 return;
5496 }
5497 if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
5498 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
5499 else
5500 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
5501 lpfc_offline(phba);
5502 lpfc_sli_brdrestart(phba);
5503 lpfc_online(phba);
5504 lpfc_unblock_mgmt_io(phba);
5505 }
5506
5507 /**
5508 * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions
5509 * @phba: pointer to lpfc hba data structure.
5510 *
5511 * This function enables the PCI SR-IOV virtual functions to a physical
5512 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
5513 * enable the number of virtual functions to the physical function. As
5514 * not all devices support SR-IOV, the return code from the pci_enable_sriov()
5515 * API call does not considered as an error condition for most of the device.
5516 **/
5517 uint16_t
5518 lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *phba)
5519 {
5520 struct pci_dev *pdev = phba->pcidev;
5521 uint16_t nr_virtfn;
5522 int pos;
5523
5524 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
5525 if (pos == 0)
5526 return 0;
5527
5528 pci_read_config_word(pdev, pos + PCI_SRIOV_TOTAL_VF, &nr_virtfn);
5529 return nr_virtfn;
5530 }
5531
5532 /**
5533 * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
5534 * @phba: pointer to lpfc hba data structure.
5535 * @nr_vfn: number of virtual functions to be enabled.
5536 *
5537 * This function enables the PCI SR-IOV virtual functions to a physical
5538 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
5539 * enable the number of virtual functions to the physical function. As
5540 * not all devices support SR-IOV, the return code from the pci_enable_sriov()
5541 * API call does not considered as an error condition for most of the device.
5542 **/
5543 int
5544 lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn)
5545 {
5546 struct pci_dev *pdev = phba->pcidev;
5547 uint16_t max_nr_vfn;
5548 int rc;
5549
5550 max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);
5551 if (nr_vfn > max_nr_vfn) {
5552 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5553 "3057 Requested vfs (%d) greater than "
5554 "supported vfs (%d)", nr_vfn, max_nr_vfn);
5555 return -EINVAL;
5556 }
5557
5558 rc = pci_enable_sriov(pdev, nr_vfn);
5559 if (rc) {
5560 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5561 "2806 Failed to enable sriov on this device "
5562 "with vfn number nr_vf:%d, rc:%d\n",
5563 nr_vfn, rc);
5564 } else
5565 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5566 "2807 Successful enable sriov on this device "
5567 "with vfn number nr_vf:%d\n", nr_vfn);
5568 return rc;
5569 }
5570
5571 /**
5572 * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
5573 * @phba: pointer to lpfc hba data structure.
5574 *
5575 * This routine is invoked to set up the driver internal resources before the
5576 * device specific resource setup to support the HBA device it attached to.
5577 *
5578 * Return codes
5579 * 0 - successful
5580 * other values - error
5581 **/
5582 static int
5583 lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
5584 {
5585 struct lpfc_sli *psli = &phba->sli;
5586
5587 /*
5588 * Driver resources common to all SLI revisions
5589 */
5590 atomic_set(&phba->fast_event_count, 0);
5591 spin_lock_init(&phba->hbalock);
5592
5593 /* Initialize ndlp management spinlock */
5594 spin_lock_init(&phba->ndlp_lock);
5595
5596 INIT_LIST_HEAD(&phba->port_list);
5597 INIT_LIST_HEAD(&phba->work_list);
5598 init_waitqueue_head(&phba->wait_4_mlo_m_q);
5599
5600 /* Initialize the wait queue head for the kernel thread */
5601 init_waitqueue_head(&phba->work_waitq);
5602
5603 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5604 "1403 Protocols supported %s %s %s\n",
5605 ((phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ?
5606 "SCSI" : " "),
5607 ((phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) ?
5608 "NVME" : " "),
5609 (phba->nvmet_support ? "NVMET" : " "));
5610
5611 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
5612 /* Initialize the scsi buffer list used by driver for scsi IO */
5613 spin_lock_init(&phba->scsi_buf_list_get_lock);
5614 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_get);
5615 spin_lock_init(&phba->scsi_buf_list_put_lock);
5616 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
5617 }
5618
5619 if ((phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) &&
5620 (phba->nvmet_support == 0)) {
5621 /* Initialize the NVME buffer list used by driver for NVME IO */
5622 spin_lock_init(&phba->nvme_buf_list_get_lock);
5623 INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_get);
5624 phba->get_nvme_bufs = 0;
5625 spin_lock_init(&phba->nvme_buf_list_put_lock);
5626 INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_put);
5627 phba->put_nvme_bufs = 0;
5628 }
5629
5630 /* Initialize the fabric iocb list */
5631 INIT_LIST_HEAD(&phba->fabric_iocb_list);
5632
5633 /* Initialize list to save ELS buffers */
5634 INIT_LIST_HEAD(&phba->elsbuf);
5635
5636 /* Initialize FCF connection rec list */
5637 INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
5638
5639 /* Initialize OAS configuration list */
5640 spin_lock_init(&phba->devicelock);
5641 INIT_LIST_HEAD(&phba->luns);
5642
5643 /* MBOX heartbeat timer */
5644 timer_setup(&psli->mbox_tmo, lpfc_mbox_timeout, 0);
5645 /* Fabric block timer */
5646 timer_setup(&phba->fabric_block_timer, lpfc_fabric_block_timeout, 0);
5647 /* EA polling mode timer */
5648 timer_setup(&phba->eratt_poll, lpfc_poll_eratt, 0);
5649 /* Heartbeat timer */
5650 timer_setup(&phba->hb_tmofunc, lpfc_hb_timeout, 0);
5651
5652 return 0;
5653 }
5654
5655 /**
5656 * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev
5657 * @phba: pointer to lpfc hba data structure.
5658 *
5659 * This routine is invoked to set up the driver internal resources specific to
5660 * support the SLI-3 HBA device it attached to.
5661 *
5662 * Return codes
5663 * 0 - successful
5664 * other values - error
5665 **/
5666 static int
5667 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
5668 {
5669 int rc;
5670
5671 /*
5672 * Initialize timers used by driver
5673 */
5674
5675 /* FCP polling mode timer */
5676 timer_setup(&phba->fcp_poll_timer, lpfc_poll_timeout, 0);
5677
5678 /* Host attention work mask setup */
5679 phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
5680 phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
5681
5682 /* Get all the module params for configuring this host */
5683 lpfc_get_cfgparam(phba);
5684 /* Set up phase-1 common device driver resources */
5685
5686 rc = lpfc_setup_driver_resource_phase1(phba);
5687 if (rc)
5688 return -ENODEV;
5689
5690 if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) {
5691 phba->menlo_flag |= HBA_MENLO_SUPPORT;
5692 /* check for menlo minimum sg count */
5693 if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT)
5694 phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT;
5695 }
5696
5697 if (!phba->sli.sli3_ring)
5698 phba->sli.sli3_ring = kzalloc(LPFC_SLI3_MAX_RING *
5699 sizeof(struct lpfc_sli_ring), GFP_KERNEL);
5700 if (!phba->sli.sli3_ring)
5701 return -ENOMEM;
5702
5703 /*
5704 * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
5705 * used to create the sg_dma_buf_pool must be dynamically calculated.
5706 */
5707
5708 /* Initialize the host templates the configured values. */
5709 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5710 lpfc_template_no_hr.sg_tablesize = phba->cfg_sg_seg_cnt;
5711 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5712
5713 /* There are going to be 2 reserved BDEs: 1 FCP cmnd + 1 FCP rsp */
5714 if (phba->cfg_enable_bg) {
5715 /*
5716 * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
5717 * the FCP rsp, and a BDE for each. Sice we have no control
5718 * over how many protection data segments the SCSI Layer
5719 * will hand us (ie: there could be one for every block
5720 * in the IO), we just allocate enough BDEs to accomidate
5721 * our max amount and we need to limit lpfc_sg_seg_cnt to
5722 * minimize the risk of running out.
5723 */
5724 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5725 sizeof(struct fcp_rsp) +
5726 (LPFC_MAX_SG_SEG_CNT * sizeof(struct ulp_bde64));
5727
5728 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SEG_CNT_DIF)
5729 phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT_DIF;
5730
5731 /* Total BDEs in BPL for scsi_sg_list and scsi_sg_prot_list */
5732 phba->cfg_total_seg_cnt = LPFC_MAX_SG_SEG_CNT;
5733 } else {
5734 /*
5735 * The scsi_buf for a regular I/O will hold the FCP cmnd,
5736 * the FCP rsp, a BDE for each, and a BDE for up to
5737 * cfg_sg_seg_cnt data segments.
5738 */
5739 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5740 sizeof(struct fcp_rsp) +
5741 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
5742
5743 /* Total BDEs in BPL for scsi_sg_list */
5744 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
5745 }
5746
5747 lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5748 "9088 sg_tablesize:%d dmabuf_size:%d total_bde:%d\n",
5749 phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5750 phba->cfg_total_seg_cnt);
5751
5752 phba->max_vpi = LPFC_MAX_VPI;
5753 /* This will be set to correct value after config_port mbox */
5754 phba->max_vports = 0;
5755
5756 /*
5757 * Initialize the SLI Layer to run with lpfc HBAs.
5758 */
5759 lpfc_sli_setup(phba);
5760 lpfc_sli_queue_init(phba);
5761
5762 /* Allocate device driver memory */
5763 if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
5764 return -ENOMEM;
5765
5766 /*
5767 * Enable sr-iov virtual functions if supported and configured
5768 * through the module parameter.
5769 */
5770 if (phba->cfg_sriov_nr_virtfn > 0) {
5771 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
5772 phba->cfg_sriov_nr_virtfn);
5773 if (rc) {
5774 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5775 "2808 Requested number of SR-IOV "
5776 "virtual functions (%d) is not "
5777 "supported\n",
5778 phba->cfg_sriov_nr_virtfn);
5779 phba->cfg_sriov_nr_virtfn = 0;
5780 }
5781 }
5782
5783 return 0;
5784 }
5785
5786 /**
5787 * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
5788 * @phba: pointer to lpfc hba data structure.
5789 *
5790 * This routine is invoked to unset the driver internal resources set up
5791 * specific for supporting the SLI-3 HBA device it attached to.
5792 **/
5793 static void
5794 lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
5795 {
5796 /* Free device driver memory allocated */
5797 lpfc_mem_free_all(phba);
5798
5799 return;
5800 }
5801
5802 /**
5803 * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
5804 * @phba: pointer to lpfc hba data structure.
5805 *
5806 * This routine is invoked to set up the driver internal resources specific to
5807 * support the SLI-4 HBA device it attached to.
5808 *
5809 * Return codes
5810 * 0 - successful
5811 * other values - error
5812 **/
5813 static int
5814 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
5815 {
5816 LPFC_MBOXQ_t *mboxq;
5817 MAILBOX_t *mb;
5818 int rc, i, max_buf_size;
5819 uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
5820 struct lpfc_mqe *mqe;
5821 int longs;
5822 int fof_vectors = 0;
5823 int extra;
5824 uint64_t wwn;
5825
5826 phba->sli4_hba.num_online_cpu = num_online_cpus();
5827 phba->sli4_hba.num_present_cpu = lpfc_present_cpu;
5828 phba->sli4_hba.curr_disp_cpu = 0;
5829
5830 /* Get all the module params for configuring this host */
5831 lpfc_get_cfgparam(phba);
5832
5833 /* Set up phase-1 common device driver resources */
5834 rc = lpfc_setup_driver_resource_phase1(phba);
5835 if (rc)
5836 return -ENODEV;
5837
5838 /* Before proceed, wait for POST done and device ready */
5839 rc = lpfc_sli4_post_status_check(phba);
5840 if (rc)
5841 return -ENODEV;
5842
5843 /*
5844 * Initialize timers used by driver
5845 */
5846
5847 timer_setup(&phba->rrq_tmr, lpfc_rrq_timeout, 0);
5848
5849 /* FCF rediscover timer */
5850 timer_setup(&phba->fcf.redisc_wait, lpfc_sli4_fcf_redisc_wait_tmo, 0);
5851
5852 /*
5853 * Control structure for handling external multi-buffer mailbox
5854 * command pass-through.
5855 */
5856 memset((uint8_t *)&phba->mbox_ext_buf_ctx, 0,
5857 sizeof(struct lpfc_mbox_ext_buf_ctx));
5858 INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
5859
5860 phba->max_vpi = LPFC_MAX_VPI;
5861
5862 /* This will be set to correct value after the read_config mbox */
5863 phba->max_vports = 0;
5864
5865 /* Program the default value of vlan_id and fc_map */
5866 phba->valid_vlan = 0;
5867 phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
5868 phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
5869 phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
5870
5871 /*
5872 * For SLI4, instead of using ring 0 (LPFC_FCP_RING) for FCP commands
5873 * we will associate a new ring, for each EQ/CQ/WQ tuple.
5874 * The WQ create will allocate the ring.
5875 */
5876
5877 /*
5878 * 1 for cmd, 1 for rsp, NVME adds an extra one
5879 * for boundary conditions in its max_sgl_segment template.
5880 */
5881 extra = 2;
5882 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
5883 extra++;
5884
5885 /*
5886 * It doesn't matter what family our adapter is in, we are
5887 * limited to 2 Pages, 512 SGEs, for our SGL.
5888 * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
5889 */
5890 max_buf_size = (2 * SLI4_PAGE_SIZE);
5891 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SGL_SEG_CNT - extra)
5892 phba->cfg_sg_seg_cnt = LPFC_MAX_SGL_SEG_CNT - extra;
5893
5894 /*
5895 * Since lpfc_sg_seg_cnt is module param, the sg_dma_buf_size
5896 * used to create the sg_dma_buf_pool must be calculated.
5897 */
5898 if (phba->cfg_enable_bg) {
5899 /*
5900 * The scsi_buf for a T10-DIF I/O holds the FCP cmnd,
5901 * the FCP rsp, and a SGE. Sice we have no control
5902 * over how many protection segments the SCSI Layer
5903 * will hand us (ie: there could be one for every block
5904 * in the IO), just allocate enough SGEs to accomidate
5905 * our max amount and we need to limit lpfc_sg_seg_cnt
5906 * to minimize the risk of running out.
5907 */
5908 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5909 sizeof(struct fcp_rsp) + max_buf_size;
5910
5911 /* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
5912 phba->cfg_total_seg_cnt = LPFC_MAX_SGL_SEG_CNT;
5913
5914 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SLI4_SEG_CNT_DIF)
5915 phba->cfg_sg_seg_cnt =
5916 LPFC_MAX_SG_SLI4_SEG_CNT_DIF;
5917 } else {
5918 /*
5919 * The scsi_buf for a regular I/O holds the FCP cmnd,
5920 * the FCP rsp, a SGE for each, and a SGE for up to
5921 * cfg_sg_seg_cnt data segments.
5922 */
5923 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5924 sizeof(struct fcp_rsp) +
5925 ((phba->cfg_sg_seg_cnt + extra) *
5926 sizeof(struct sli4_sge));
5927
5928 /* Total SGEs for scsi_sg_list */
5929 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + extra;
5930
5931 /*
5932 * NOTE: if (phba->cfg_sg_seg_cnt + extra) <= 256 we only
5933 * need to post 1 page for the SGL.
5934 */
5935 }
5936
5937 /* Initialize the host templates with the updated values. */
5938 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5939 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5940 lpfc_template_no_hr.sg_tablesize = phba->cfg_sg_seg_cnt;
5941
5942 if (phba->cfg_sg_dma_buf_size <= LPFC_MIN_SG_SLI4_BUF_SZ)
5943 phba->cfg_sg_dma_buf_size = LPFC_MIN_SG_SLI4_BUF_SZ;
5944 else
5945 phba->cfg_sg_dma_buf_size =
5946 SLI4_PAGE_ALIGN(phba->cfg_sg_dma_buf_size);
5947
5948 lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5949 "9087 sg_tablesize:%d dmabuf_size:%d total_sge:%d\n",
5950 phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5951 phba->cfg_total_seg_cnt);
5952
5953 /* Initialize buffer queue management fields */
5954 INIT_LIST_HEAD(&phba->hbqs[LPFC_ELS_HBQ].hbq_buffer_list);
5955 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc;
5956 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free;
5957
5958 /*
5959 * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
5960 */
5961 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
5962 /* Initialize the Abort scsi buffer list used by driver */
5963 spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock);
5964 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
5965 }
5966
5967 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
5968 /* Initialize the Abort nvme buffer list used by driver */
5969 spin_lock_init(&phba->sli4_hba.abts_nvme_buf_list_lock);
5970 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_nvme_buf_list);
5971 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_nvmet_ctx_list);
5972 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_nvmet_io_wait_list);
5973 }
5974
5975 /* This abort list used by worker thread */
5976 spin_lock_init(&phba->sli4_hba.sgl_list_lock);
5977 spin_lock_init(&phba->sli4_hba.nvmet_io_wait_lock);
5978
5979 /*
5980 * Initialize driver internal slow-path work queues
5981 */
5982
5983 /* Driver internel slow-path CQ Event pool */
5984 INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
5985 /* Response IOCB work queue list */
5986 INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
5987 /* Asynchronous event CQ Event work queue list */
5988 INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
5989 /* Fast-path XRI aborted CQ Event work queue list */
5990 INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
5991 /* Slow-path XRI aborted CQ Event work queue list */
5992 INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue);
5993 /* Receive queue CQ Event work queue list */
5994 INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
5995
5996 /* Initialize extent block lists. */
5997 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_blk_list);
5998 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_xri_blk_list);
5999 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_vfi_blk_list);
6000 INIT_LIST_HEAD(&phba->lpfc_vpi_blk_list);
6001
6002 /* Initialize mboxq lists. If the early init routines fail
6003 * these lists need to be correctly initialized.
6004 */
6005 INIT_LIST_HEAD(&phba->sli.mboxq);
6006 INIT_LIST_HEAD(&phba->sli.mboxq_cmpl);
6007
6008 /* initialize optic_state to 0xFF */
6009 phba->sli4_hba.lnk_info.optic_state = 0xff;
6010
6011 /* Allocate device driver memory */
6012 rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ);
6013 if (rc)
6014 return -ENOMEM;
6015
6016 /* IF Type 2 ports get initialized now. */
6017 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
6018 LPFC_SLI_INTF_IF_TYPE_2) {
6019 rc = lpfc_pci_function_reset(phba);
6020 if (unlikely(rc)) {
6021 rc = -ENODEV;
6022 goto out_free_mem;
6023 }
6024 phba->temp_sensor_support = 1;
6025 }
6026
6027 /* Create the bootstrap mailbox command */
6028 rc = lpfc_create_bootstrap_mbox(phba);
6029 if (unlikely(rc))
6030 goto out_free_mem;
6031
6032 /* Set up the host's endian order with the device. */
6033 rc = lpfc_setup_endian_order(phba);
6034 if (unlikely(rc))
6035 goto out_free_bsmbx;
6036
6037 /* Set up the hba's configuration parameters. */
6038 rc = lpfc_sli4_read_config(phba);
6039 if (unlikely(rc))
6040 goto out_free_bsmbx;
6041 rc = lpfc_mem_alloc_active_rrq_pool_s4(phba);
6042 if (unlikely(rc))
6043 goto out_free_bsmbx;
6044
6045 /* IF Type 0 ports get initialized now. */
6046 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
6047 LPFC_SLI_INTF_IF_TYPE_0) {
6048 rc = lpfc_pci_function_reset(phba);
6049 if (unlikely(rc))
6050 goto out_free_bsmbx;
6051 }
6052
6053 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
6054 GFP_KERNEL);
6055 if (!mboxq) {
6056 rc = -ENOMEM;
6057 goto out_free_bsmbx;
6058 }
6059
6060 /* Check for NVMET being configured */
6061 phba->nvmet_support = 0;
6062 if (lpfc_enable_nvmet_cnt) {
6063
6064 /* First get WWN of HBA instance */
6065 lpfc_read_nv(phba, mboxq);
6066 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6067 if (rc != MBX_SUCCESS) {
6068 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6069 "6016 Mailbox failed , mbxCmd x%x "
6070 "READ_NV, mbxStatus x%x\n",
6071 bf_get(lpfc_mqe_command, &mboxq->u.mqe),
6072 bf_get(lpfc_mqe_status, &mboxq->u.mqe));
6073 mempool_free(mboxq, phba->mbox_mem_pool);
6074 rc = -EIO;
6075 goto out_free_bsmbx;
6076 }
6077 mb = &mboxq->u.mb;
6078 memcpy(&wwn, (char *)mb->un.varRDnvp.nodename,
6079 sizeof(uint64_t));
6080 wwn = cpu_to_be64(wwn);
6081 phba->sli4_hba.wwnn.u.name = wwn;
6082 memcpy(&wwn, (char *)mb->un.varRDnvp.portname,
6083 sizeof(uint64_t));
6084 /* wwn is WWPN of HBA instance */
6085 wwn = cpu_to_be64(wwn);
6086 phba->sli4_hba.wwpn.u.name = wwn;
6087
6088 /* Check to see if it matches any module parameter */
6089 for (i = 0; i < lpfc_enable_nvmet_cnt; i++) {
6090 if (wwn == lpfc_enable_nvmet[i]) {
6091 #if (IS_ENABLED(CONFIG_NVME_TARGET_FC))
6092 if (lpfc_nvmet_mem_alloc(phba))
6093 break;
6094
6095 phba->nvmet_support = 1; /* a match */
6096
6097 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6098 "6017 NVME Target %016llx\n",
6099 wwn);
6100 #else
6101 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6102 "6021 Can't enable NVME Target."
6103 " NVME_TARGET_FC infrastructure"
6104 " is not in kernel\n");
6105 #endif
6106 break;
6107 }
6108 }
6109 }
6110
6111 lpfc_nvme_mod_param_dep(phba);
6112
6113 /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */
6114 lpfc_supported_pages(mboxq);
6115 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6116 if (!rc) {
6117 mqe = &mboxq->u.mqe;
6118 memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
6119 LPFC_MAX_SUPPORTED_PAGES);
6120 for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
6121 switch (pn_page[i]) {
6122 case LPFC_SLI4_PARAMETERS:
6123 phba->sli4_hba.pc_sli4_params.supported = 1;
6124 break;
6125 default:
6126 break;
6127 }
6128 }
6129 /* Read the port's SLI4 Parameters capabilities if supported. */
6130 if (phba->sli4_hba.pc_sli4_params.supported)
6131 rc = lpfc_pc_sli4_params_get(phba, mboxq);
6132 if (rc) {
6133 mempool_free(mboxq, phba->mbox_mem_pool);
6134 rc = -EIO;
6135 goto out_free_bsmbx;
6136 }
6137 }
6138
6139 /*
6140 * Get sli4 parameters that override parameters from Port capabilities.
6141 * If this call fails, it isn't critical unless the SLI4 parameters come
6142 * back in conflict.
6143 */
6144 rc = lpfc_get_sli4_parameters(phba, mboxq);
6145 if (rc) {
6146 if (phba->sli4_hba.extents_in_use &&
6147 phba->sli4_hba.rpi_hdrs_in_use) {
6148 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6149 "2999 Unsupported SLI4 Parameters "
6150 "Extents and RPI headers enabled.\n");
6151 }
6152 mempool_free(mboxq, phba->mbox_mem_pool);
6153 rc = -EIO;
6154 goto out_free_bsmbx;
6155 }
6156
6157 mempool_free(mboxq, phba->mbox_mem_pool);
6158
6159 /* Verify OAS is supported */
6160 lpfc_sli4_oas_verify(phba);
6161 if (phba->cfg_fof)
6162 fof_vectors = 1;
6163
6164 /* Verify all the SLI4 queues */
6165 rc = lpfc_sli4_queue_verify(phba);
6166 if (rc)
6167 goto out_free_bsmbx;
6168
6169 /* Create driver internal CQE event pool */
6170 rc = lpfc_sli4_cq_event_pool_create(phba);
6171 if (rc)
6172 goto out_free_bsmbx;
6173
6174 /* Initialize sgl lists per host */
6175 lpfc_init_sgl_list(phba);
6176
6177 /* Allocate and initialize active sgl array */
6178 rc = lpfc_init_active_sgl_array(phba);
6179 if (rc) {
6180 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6181 "1430 Failed to initialize sgl list.\n");
6182 goto out_destroy_cq_event_pool;
6183 }
6184 rc = lpfc_sli4_init_rpi_hdrs(phba);
6185 if (rc) {
6186 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6187 "1432 Failed to initialize rpi headers.\n");
6188 goto out_free_active_sgl;
6189 }
6190
6191 /* Allocate eligible FCF bmask memory for FCF roundrobin failover */
6192 longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;
6193 phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long),
6194 GFP_KERNEL);
6195 if (!phba->fcf.fcf_rr_bmask) {
6196 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6197 "2759 Failed allocate memory for FCF round "
6198 "robin failover bmask\n");
6199 rc = -ENOMEM;
6200 goto out_remove_rpi_hdrs;
6201 }
6202
6203 phba->sli4_hba.hba_eq_hdl = kcalloc(fof_vectors + phba->io_channel_irqs,
6204 sizeof(struct lpfc_hba_eq_hdl),
6205 GFP_KERNEL);
6206 if (!phba->sli4_hba.hba_eq_hdl) {
6207 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6208 "2572 Failed allocate memory for "
6209 "fast-path per-EQ handle array\n");
6210 rc = -ENOMEM;
6211 goto out_free_fcf_rr_bmask;
6212 }
6213
6214 phba->sli4_hba.cpu_map = kcalloc(phba->sli4_hba.num_present_cpu,
6215 sizeof(struct lpfc_vector_map_info),
6216 GFP_KERNEL);
6217 if (!phba->sli4_hba.cpu_map) {
6218 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6219 "3327 Failed allocate memory for msi-x "
6220 "interrupt vector mapping\n");
6221 rc = -ENOMEM;
6222 goto out_free_hba_eq_hdl;
6223 }
6224 if (lpfc_used_cpu == NULL) {
6225 lpfc_used_cpu = kcalloc(lpfc_present_cpu, sizeof(uint16_t),
6226 GFP_KERNEL);
6227 if (!lpfc_used_cpu) {
6228 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6229 "3335 Failed allocate memory for msi-x "
6230 "interrupt vector mapping\n");
6231 kfree(phba->sli4_hba.cpu_map);
6232 rc = -ENOMEM;
6233 goto out_free_hba_eq_hdl;
6234 }
6235 for (i = 0; i < lpfc_present_cpu; i++)
6236 lpfc_used_cpu[i] = LPFC_VECTOR_MAP_EMPTY;
6237 }
6238
6239 /*
6240 * Enable sr-iov virtual functions if supported and configured
6241 * through the module parameter.
6242 */
6243 if (phba->cfg_sriov_nr_virtfn > 0) {
6244 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
6245 phba->cfg_sriov_nr_virtfn);
6246 if (rc) {
6247 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6248 "3020 Requested number of SR-IOV "
6249 "virtual functions (%d) is not "
6250 "supported\n",
6251 phba->cfg_sriov_nr_virtfn);
6252 phba->cfg_sriov_nr_virtfn = 0;
6253 }
6254 }
6255
6256 return 0;
6257
6258 out_free_hba_eq_hdl:
6259 kfree(phba->sli4_hba.hba_eq_hdl);
6260 out_free_fcf_rr_bmask:
6261 kfree(phba->fcf.fcf_rr_bmask);
6262 out_remove_rpi_hdrs:
6263 lpfc_sli4_remove_rpi_hdrs(phba);
6264 out_free_active_sgl:
6265 lpfc_free_active_sgl(phba);
6266 out_destroy_cq_event_pool:
6267 lpfc_sli4_cq_event_pool_destroy(phba);
6268 out_free_bsmbx:
6269 lpfc_destroy_bootstrap_mbox(phba);
6270 out_free_mem:
6271 lpfc_mem_free(phba);
6272 return rc;
6273 }
6274
6275 /**
6276 * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
6277 * @phba: pointer to lpfc hba data structure.
6278 *
6279 * This routine is invoked to unset the driver internal resources set up
6280 * specific for supporting the SLI-4 HBA device it attached to.
6281 **/
6282 static void
6283 lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
6284 {
6285 struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
6286
6287 /* Free memory allocated for msi-x interrupt vector to CPU mapping */
6288 kfree(phba->sli4_hba.cpu_map);
6289 phba->sli4_hba.num_present_cpu = 0;
6290 phba->sli4_hba.num_online_cpu = 0;
6291 phba->sli4_hba.curr_disp_cpu = 0;
6292
6293 /* Free memory allocated for fast-path work queue handles */
6294 kfree(phba->sli4_hba.hba_eq_hdl);
6295
6296 /* Free the allocated rpi headers. */
6297 lpfc_sli4_remove_rpi_hdrs(phba);
6298 lpfc_sli4_remove_rpis(phba);
6299
6300 /* Free eligible FCF index bmask */
6301 kfree(phba->fcf.fcf_rr_bmask);
6302
6303 /* Free the ELS sgl list */
6304 lpfc_free_active_sgl(phba);
6305 lpfc_free_els_sgl_list(phba);
6306 lpfc_free_nvmet_sgl_list(phba);
6307
6308 /* Free the completion queue EQ event pool */
6309 lpfc_sli4_cq_event_release_all(phba);
6310 lpfc_sli4_cq_event_pool_destroy(phba);
6311
6312 /* Release resource identifiers. */
6313 lpfc_sli4_dealloc_resource_identifiers(phba);
6314
6315 /* Free the bsmbx region. */
6316 lpfc_destroy_bootstrap_mbox(phba);
6317
6318 /* Free the SLI Layer memory with SLI4 HBAs */
6319 lpfc_mem_free_all(phba);
6320
6321 /* Free the current connect table */
6322 list_for_each_entry_safe(conn_entry, next_conn_entry,
6323 &phba->fcf_conn_rec_list, list) {
6324 list_del_init(&conn_entry->list);
6325 kfree(conn_entry);
6326 }
6327
6328 return;
6329 }
6330
6331 /**
6332 * lpfc_init_api_table_setup - Set up init api function jump table
6333 * @phba: The hba struct for which this call is being executed.
6334 * @dev_grp: The HBA PCI-Device group number.
6335 *
6336 * This routine sets up the device INIT interface API function jump table
6337 * in @phba struct.
6338 *
6339 * Returns: 0 - success, -ENODEV - failure.
6340 **/
6341 int
6342 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
6343 {
6344 phba->lpfc_hba_init_link = lpfc_hba_init_link;
6345 phba->lpfc_hba_down_link = lpfc_hba_down_link;
6346 phba->lpfc_selective_reset = lpfc_selective_reset;
6347 switch (dev_grp) {
6348 case LPFC_PCI_DEV_LP:
6349 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
6350 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
6351 phba->lpfc_stop_port = lpfc_stop_port_s3;
6352 break;
6353 case LPFC_PCI_DEV_OC:
6354 phba->lpfc_hba_down_post = lpfc_hba_down_post_s4;
6355 phba->lpfc_handle_eratt = lpfc_handle_eratt_s4;
6356 phba->lpfc_stop_port = lpfc_stop_port_s4;
6357 break;
6358 default:
6359 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6360 "1431 Invalid HBA PCI-device group: 0x%x\n",
6361 dev_grp);
6362 return -ENODEV;
6363 break;
6364 }
6365 return 0;
6366 }
6367
6368 /**
6369 * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
6370 * @phba: pointer to lpfc hba data structure.
6371 *
6372 * This routine is invoked to set up the driver internal resources after the
6373 * device specific resource setup to support the HBA device it attached to.
6374 *
6375 * Return codes
6376 * 0 - successful
6377 * other values - error
6378 **/
6379 static int
6380 lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
6381 {
6382 int error;
6383
6384 /* Startup the kernel thread for this host adapter. */
6385 phba->worker_thread = kthread_run(lpfc_do_work, phba,
6386 "lpfc_worker_%d", phba->brd_no);
6387 if (IS_ERR(phba->worker_thread)) {
6388 error = PTR_ERR(phba->worker_thread);
6389 return error;
6390 }
6391
6392 /* workqueue for deferred irq use */
6393 phba->wq = alloc_workqueue("lpfc_wq", WQ_MEM_RECLAIM, 0);
6394
6395 return 0;
6396 }
6397
6398 /**
6399 * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
6400 * @phba: pointer to lpfc hba data structure.
6401 *
6402 * This routine is invoked to unset the driver internal resources set up after
6403 * the device specific resource setup for supporting the HBA device it
6404 * attached to.
6405 **/
6406 static void
6407 lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
6408 {
6409 if (phba->wq) {
6410 flush_workqueue(phba->wq);
6411 destroy_workqueue(phba->wq);
6412 phba->wq = NULL;
6413 }
6414
6415 /* Stop kernel worker thread */
6416 kthread_stop(phba->worker_thread);
6417 }
6418
6419 /**
6420 * lpfc_free_iocb_list - Free iocb list.
6421 * @phba: pointer to lpfc hba data structure.
6422 *
6423 * This routine is invoked to free the driver's IOCB list and memory.
6424 **/
6425 void
6426 lpfc_free_iocb_list(struct lpfc_hba *phba)
6427 {
6428 struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
6429
6430 spin_lock_irq(&phba->hbalock);
6431 list_for_each_entry_safe(iocbq_entry, iocbq_next,
6432 &phba->lpfc_iocb_list, list) {
6433 list_del(&iocbq_entry->list);
6434 kfree(iocbq_entry);
6435 phba->total_iocbq_bufs--;
6436 }
6437 spin_unlock_irq(&phba->hbalock);
6438
6439 return;
6440 }
6441
6442 /**
6443 * lpfc_init_iocb_list - Allocate and initialize iocb list.
6444 * @phba: pointer to lpfc hba data structure.
6445 *
6446 * This routine is invoked to allocate and initizlize the driver's IOCB
6447 * list and set up the IOCB tag array accordingly.
6448 *
6449 * Return codes
6450 * 0 - successful
6451 * other values - error
6452 **/
6453 int
6454 lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
6455 {
6456 struct lpfc_iocbq *iocbq_entry = NULL;
6457 uint16_t iotag;
6458 int i;
6459
6460 /* Initialize and populate the iocb list per host. */
6461 INIT_LIST_HEAD(&phba->lpfc_iocb_list);
6462 for (i = 0; i < iocb_count; i++) {
6463 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
6464 if (iocbq_entry == NULL) {
6465 printk(KERN_ERR "%s: only allocated %d iocbs of "
6466 "expected %d count. Unloading driver.\n",
6467 __func__, i, LPFC_IOCB_LIST_CNT);
6468 goto out_free_iocbq;
6469 }
6470
6471 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
6472 if (iotag == 0) {
6473 kfree(iocbq_entry);
6474 printk(KERN_ERR "%s: failed to allocate IOTAG. "
6475 "Unloading driver.\n", __func__);
6476 goto out_free_iocbq;
6477 }
6478 iocbq_entry->sli4_lxritag = NO_XRI;
6479 iocbq_entry->sli4_xritag = NO_XRI;
6480
6481 spin_lock_irq(&phba->hbalock);
6482 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
6483 phba->total_iocbq_bufs++;
6484 spin_unlock_irq(&phba->hbalock);
6485 }
6486
6487 return 0;
6488
6489 out_free_iocbq:
6490 lpfc_free_iocb_list(phba);
6491
6492 return -ENOMEM;
6493 }
6494
6495 /**
6496 * lpfc_free_sgl_list - Free a given sgl list.
6497 * @phba: pointer to lpfc hba data structure.
6498 * @sglq_list: pointer to the head of sgl list.
6499 *
6500 * This routine is invoked to free a give sgl list and memory.
6501 **/
6502 void
6503 lpfc_free_sgl_list(struct lpfc_hba *phba, struct list_head *sglq_list)
6504 {
6505 struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
6506
6507 list_for_each_entry_safe(sglq_entry, sglq_next, sglq_list, list) {
6508 list_del(&sglq_entry->list);
6509 lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
6510 kfree(sglq_entry);
6511 }
6512 }
6513
6514 /**
6515 * lpfc_free_els_sgl_list - Free els sgl list.
6516 * @phba: pointer to lpfc hba data structure.
6517 *
6518 * This routine is invoked to free the driver's els sgl list and memory.
6519 **/
6520 static void
6521 lpfc_free_els_sgl_list(struct lpfc_hba *phba)
6522 {
6523 LIST_HEAD(sglq_list);
6524
6525 /* Retrieve all els sgls from driver list */
6526 spin_lock_irq(&phba->hbalock);
6527 spin_lock(&phba->sli4_hba.sgl_list_lock);
6528 list_splice_init(&phba->sli4_hba.lpfc_els_sgl_list, &sglq_list);
6529 spin_unlock(&phba->sli4_hba.sgl_list_lock);
6530 spin_unlock_irq(&phba->hbalock);
6531
6532 /* Now free the sgl list */
6533 lpfc_free_sgl_list(phba, &sglq_list);
6534 }
6535
6536 /**
6537 * lpfc_free_nvmet_sgl_list - Free nvmet sgl list.
6538 * @phba: pointer to lpfc hba data structure.
6539 *
6540 * This routine is invoked to free the driver's nvmet sgl list and memory.
6541 **/
6542 static void
6543 lpfc_free_nvmet_sgl_list(struct lpfc_hba *phba)
6544 {
6545 struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
6546 LIST_HEAD(sglq_list);
6547
6548 /* Retrieve all nvmet sgls from driver list */
6549 spin_lock_irq(&phba->hbalock);
6550 spin_lock(&phba->sli4_hba.sgl_list_lock);
6551 list_splice_init(&phba->sli4_hba.lpfc_nvmet_sgl_list, &sglq_list);
6552 spin_unlock(&phba->sli4_hba.sgl_list_lock);
6553 spin_unlock_irq(&phba->hbalock);
6554
6555 /* Now free the sgl list */
6556 list_for_each_entry_safe(sglq_entry, sglq_next, &sglq_list, list) {
6557 list_del(&sglq_entry->list);
6558 lpfc_nvmet_buf_free(phba, sglq_entry->virt, sglq_entry->phys);
6559 kfree(sglq_entry);
6560 }
6561
6562 /* Update the nvmet_xri_cnt to reflect no current sgls.
6563 * The next initialization cycle sets the count and allocates
6564 * the sgls over again.
6565 */
6566 phba->sli4_hba.nvmet_xri_cnt = 0;
6567 }
6568
6569 /**
6570 * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
6571 * @phba: pointer to lpfc hba data structure.
6572 *
6573 * This routine is invoked to allocate the driver's active sgl memory.
6574 * This array will hold the sglq_entry's for active IOs.
6575 **/
6576 static int
6577 lpfc_init_active_sgl_array(struct lpfc_hba *phba)
6578 {
6579 int size;
6580 size = sizeof(struct lpfc_sglq *);
6581 size *= phba->sli4_hba.max_cfg_param.max_xri;
6582
6583 phba->sli4_hba.lpfc_sglq_active_list =
6584 kzalloc(size, GFP_KERNEL);
6585 if (!phba->sli4_hba.lpfc_sglq_active_list)
6586 return -ENOMEM;
6587 return 0;
6588 }
6589
6590 /**
6591 * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
6592 * @phba: pointer to lpfc hba data structure.
6593 *
6594 * This routine is invoked to walk through the array of active sglq entries
6595 * and free all of the resources.
6596 * This is just a place holder for now.
6597 **/
6598 static void
6599 lpfc_free_active_sgl(struct lpfc_hba *phba)
6600 {
6601 kfree(phba->sli4_hba.lpfc_sglq_active_list);
6602 }
6603
6604 /**
6605 * lpfc_init_sgl_list - Allocate and initialize sgl list.
6606 * @phba: pointer to lpfc hba data structure.
6607 *
6608 * This routine is invoked to allocate and initizlize the driver's sgl
6609 * list and set up the sgl xritag tag array accordingly.
6610 *
6611 **/
6612 static void
6613 lpfc_init_sgl_list(struct lpfc_hba *phba)
6614 {
6615 /* Initialize and populate the sglq list per host/VF. */
6616 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_els_sgl_list);
6617 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
6618 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_nvmet_sgl_list);
6619 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_nvmet_ctx_list);
6620
6621 /* els xri-sgl book keeping */
6622 phba->sli4_hba.els_xri_cnt = 0;
6623
6624 /* scsi xri-buffer book keeping */
6625 phba->sli4_hba.scsi_xri_cnt = 0;
6626
6627 /* nvme xri-buffer book keeping */
6628 phba->sli4_hba.nvme_xri_cnt = 0;
6629 }
6630
6631 /**
6632 * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
6633 * @phba: pointer to lpfc hba data structure.
6634 *
6635 * This routine is invoked to post rpi header templates to the
6636 * port for those SLI4 ports that do not support extents. This routine
6637 * posts a PAGE_SIZE memory region to the port to hold up to
6638 * PAGE_SIZE modulo 64 rpi context headers. This is an initialization routine
6639 * and should be called only when interrupts are disabled.
6640 *
6641 * Return codes
6642 * 0 - successful
6643 * -ERROR - otherwise.
6644 **/
6645 int
6646 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
6647 {
6648 int rc = 0;
6649 struct lpfc_rpi_hdr *rpi_hdr;
6650
6651 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
6652 if (!phba->sli4_hba.rpi_hdrs_in_use)
6653 return rc;
6654 if (phba->sli4_hba.extents_in_use)
6655 return -EIO;
6656
6657 rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
6658 if (!rpi_hdr) {
6659 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6660 "0391 Error during rpi post operation\n");
6661 lpfc_sli4_remove_rpis(phba);
6662 rc = -ENODEV;
6663 }
6664
6665 return rc;
6666 }
6667
6668 /**
6669 * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
6670 * @phba: pointer to lpfc hba data structure.
6671 *
6672 * This routine is invoked to allocate a single 4KB memory region to
6673 * support rpis and stores them in the phba. This single region
6674 * provides support for up to 64 rpis. The region is used globally
6675 * by the device.
6676 *
6677 * Returns:
6678 * A valid rpi hdr on success.
6679 * A NULL pointer on any failure.
6680 **/
6681 struct lpfc_rpi_hdr *
6682 lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
6683 {
6684 uint16_t rpi_limit, curr_rpi_range;
6685 struct lpfc_dmabuf *dmabuf;
6686 struct lpfc_rpi_hdr *rpi_hdr;
6687
6688 /*
6689 * If the SLI4 port supports extents, posting the rpi header isn't
6690 * required. Set the expected maximum count and let the actual value
6691 * get set when extents are fully allocated.
6692 */
6693 if (!phba->sli4_hba.rpi_hdrs_in_use)
6694 return NULL;
6695 if (phba->sli4_hba.extents_in_use)
6696 return NULL;
6697
6698 /* The limit on the logical index is just the max_rpi count. */
6699 rpi_limit = phba->sli4_hba.max_cfg_param.max_rpi;
6700
6701 spin_lock_irq(&phba->hbalock);
6702 /*
6703 * Establish the starting RPI in this header block. The starting
6704 * rpi is normalized to a zero base because the physical rpi is
6705 * port based.
6706 */
6707 curr_rpi_range = phba->sli4_hba.next_rpi;
6708 spin_unlock_irq(&phba->hbalock);
6709
6710 /* Reached full RPI range */
6711 if (curr_rpi_range == rpi_limit)
6712 return NULL;
6713
6714 /*
6715 * First allocate the protocol header region for the port. The
6716 * port expects a 4KB DMA-mapped memory region that is 4K aligned.
6717 */
6718 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
6719 if (!dmabuf)
6720 return NULL;
6721
6722 dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
6723 LPFC_HDR_TEMPLATE_SIZE,
6724 &dmabuf->phys, GFP_KERNEL);
6725 if (!dmabuf->virt) {
6726 rpi_hdr = NULL;
6727 goto err_free_dmabuf;
6728 }
6729
6730 if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) {
6731 rpi_hdr = NULL;
6732 goto err_free_coherent;
6733 }
6734
6735 /* Save the rpi header data for cleanup later. */
6736 rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL);
6737 if (!rpi_hdr)
6738 goto err_free_coherent;
6739
6740 rpi_hdr->dmabuf = dmabuf;
6741 rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
6742 rpi_hdr->page_count = 1;
6743 spin_lock_irq(&phba->hbalock);
6744
6745 /* The rpi_hdr stores the logical index only. */
6746 rpi_hdr->start_rpi = curr_rpi_range;
6747 rpi_hdr->next_rpi = phba->sli4_hba.next_rpi + LPFC_RPI_HDR_COUNT;
6748 list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
6749
6750 spin_unlock_irq(&phba->hbalock);
6751 return rpi_hdr;
6752
6753 err_free_coherent:
6754 dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE,
6755 dmabuf->virt, dmabuf->phys);
6756 err_free_dmabuf:
6757 kfree(dmabuf);
6758 return NULL;
6759 }
6760
6761 /**
6762 * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
6763 * @phba: pointer to lpfc hba data structure.
6764 *
6765 * This routine is invoked to remove all memory resources allocated
6766 * to support rpis for SLI4 ports not supporting extents. This routine
6767 * presumes the caller has released all rpis consumed by fabric or port
6768 * logins and is prepared to have the header pages removed.
6769 **/
6770 void
6771 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
6772 {
6773 struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
6774
6775 if (!phba->sli4_hba.rpi_hdrs_in_use)
6776 goto exit;
6777
6778 list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
6779 &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
6780 list_del(&rpi_hdr->list);
6781 dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len,
6782 rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys);
6783 kfree(rpi_hdr->dmabuf);
6784 kfree(rpi_hdr);
6785 }
6786 exit:
6787 /* There are no rpis available to the port now. */
6788 phba->sli4_hba.next_rpi = 0;
6789 }
6790
6791 /**
6792 * lpfc_hba_alloc - Allocate driver hba data structure for a device.
6793 * @pdev: pointer to pci device data structure.
6794 *
6795 * This routine is invoked to allocate the driver hba data structure for an
6796 * HBA device. If the allocation is successful, the phba reference to the
6797 * PCI device data structure is set.
6798 *
6799 * Return codes
6800 * pointer to @phba - successful
6801 * NULL - error
6802 **/
6803 static struct lpfc_hba *
6804 lpfc_hba_alloc(struct pci_dev *pdev)
6805 {
6806 struct lpfc_hba *phba;
6807
6808 /* Allocate memory for HBA structure */
6809 phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
6810 if (!phba) {
6811 dev_err(&pdev->dev, "failed to allocate hba struct\n");
6812 return NULL;
6813 }
6814
6815 /* Set reference to PCI device in HBA structure */
6816 phba->pcidev = pdev;
6817
6818 /* Assign an unused board number */
6819 phba->brd_no = lpfc_get_instance();
6820 if (phba->brd_no < 0) {
6821 kfree(phba);
6822 return NULL;
6823 }
6824 phba->eratt_poll_interval = LPFC_ERATT_POLL_INTERVAL;
6825
6826 spin_lock_init(&phba->ct_ev_lock);
6827 INIT_LIST_HEAD(&phba->ct_ev_waiters);
6828
6829 return phba;
6830 }
6831
6832 /**
6833 * lpfc_hba_free - Free driver hba data structure with a device.
6834 * @phba: pointer to lpfc hba data structure.
6835 *
6836 * This routine is invoked to free the driver hba data structure with an
6837 * HBA device.
6838 **/
6839 static void
6840 lpfc_hba_free(struct lpfc_hba *phba)
6841 {
6842 /* Release the driver assigned board number */
6843 idr_remove(&lpfc_hba_index, phba->brd_no);
6844
6845 /* Free memory allocated with sli3 rings */
6846 kfree(phba->sli.sli3_ring);
6847 phba->sli.sli3_ring = NULL;
6848
6849 kfree(phba);
6850 return;
6851 }
6852
6853 /**
6854 * lpfc_create_shost - Create hba physical port with associated scsi host.
6855 * @phba: pointer to lpfc hba data structure.
6856 *
6857 * This routine is invoked to create HBA physical port and associate a SCSI
6858 * host with it.
6859 *
6860 * Return codes
6861 * 0 - successful
6862 * other values - error
6863 **/
6864 static int
6865 lpfc_create_shost(struct lpfc_hba *phba)
6866 {
6867 struct lpfc_vport *vport;
6868 struct Scsi_Host *shost;
6869
6870 /* Initialize HBA FC structure */
6871 phba->fc_edtov = FF_DEF_EDTOV;
6872 phba->fc_ratov = FF_DEF_RATOV;
6873 phba->fc_altov = FF_DEF_ALTOV;
6874 phba->fc_arbtov = FF_DEF_ARBTOV;
6875
6876 atomic_set(&phba->sdev_cnt, 0);
6877 atomic_set(&phba->fc4ScsiInputRequests, 0);
6878 atomic_set(&phba->fc4ScsiOutputRequests, 0);
6879 atomic_set(&phba->fc4ScsiControlRequests, 0);
6880 atomic_set(&phba->fc4ScsiIoCmpls, 0);
6881 atomic_set(&phba->fc4NvmeInputRequests, 0);
6882 atomic_set(&phba->fc4NvmeOutputRequests, 0);
6883 atomic_set(&phba->fc4NvmeControlRequests, 0);
6884 atomic_set(&phba->fc4NvmeIoCmpls, 0);
6885 atomic_set(&phba->fc4NvmeLsRequests, 0);
6886 atomic_set(&phba->fc4NvmeLsCmpls, 0);
6887 vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
6888 if (!vport)
6889 return -ENODEV;
6890
6891 shost = lpfc_shost_from_vport(vport);
6892 phba->pport = vport;
6893
6894 if (phba->nvmet_support) {
6895 /* Only 1 vport (pport) will support NVME target */
6896 if (phba->txrdy_payload_pool == NULL) {
6897 phba->txrdy_payload_pool = dma_pool_create(
6898 "txrdy_pool", &phba->pcidev->dev,
6899 TXRDY_PAYLOAD_LEN, 16, 0);
6900 if (phba->txrdy_payload_pool) {
6901 phba->targetport = NULL;
6902 phba->cfg_enable_fc4_type = LPFC_ENABLE_NVME;
6903 lpfc_printf_log(phba, KERN_INFO,
6904 LOG_INIT | LOG_NVME_DISC,
6905 "6076 NVME Target Found\n");
6906 }
6907 }
6908 }
6909
6910 lpfc_debugfs_initialize(vport);
6911 /* Put reference to SCSI host to driver's device private data */
6912 pci_set_drvdata(phba->pcidev, shost);
6913
6914 /*
6915 * At this point we are fully registered with PSA. In addition,
6916 * any initial discovery should be completed.
6917 */
6918 vport->load_flag |= FC_ALLOW_FDMI;
6919 if (phba->cfg_enable_SmartSAN ||
6920 (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
6921
6922 /* Setup appropriate attribute masks */
6923 vport->fdmi_hba_mask = LPFC_FDMI2_HBA_ATTR;
6924 if (phba->cfg_enable_SmartSAN)
6925 vport->fdmi_port_mask = LPFC_FDMI2_SMART_ATTR;
6926 else
6927 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
6928 }
6929 return 0;
6930 }
6931
6932 /**
6933 * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
6934 * @phba: pointer to lpfc hba data structure.
6935 *
6936 * This routine is invoked to destroy HBA physical port and the associated
6937 * SCSI host.
6938 **/
6939 static void
6940 lpfc_destroy_shost(struct lpfc_hba *phba)
6941 {
6942 struct lpfc_vport *vport = phba->pport;
6943
6944 /* Destroy physical port that associated with the SCSI host */
6945 destroy_port(vport);
6946
6947 return;
6948 }
6949
6950 /**
6951 * lpfc_setup_bg - Setup Block guard structures and debug areas.
6952 * @phba: pointer to lpfc hba data structure.
6953 * @shost: the shost to be used to detect Block guard settings.
6954 *
6955 * This routine sets up the local Block guard protocol settings for @shost.
6956 * This routine also allocates memory for debugging bg buffers.
6957 **/
6958 static void
6959 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
6960 {
6961 uint32_t old_mask;
6962 uint32_t old_guard;
6963
6964 int pagecnt = 10;
6965 if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
6966 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6967 "1478 Registering BlockGuard with the "
6968 "SCSI layer\n");
6969
6970 old_mask = phba->cfg_prot_mask;
6971 old_guard = phba->cfg_prot_guard;
6972
6973 /* Only allow supported values */
6974 phba->cfg_prot_mask &= (SHOST_DIF_TYPE1_PROTECTION |
6975 SHOST_DIX_TYPE0_PROTECTION |
6976 SHOST_DIX_TYPE1_PROTECTION);
6977 phba->cfg_prot_guard &= (SHOST_DIX_GUARD_IP |
6978 SHOST_DIX_GUARD_CRC);
6979
6980 /* DIF Type 1 protection for profiles AST1/C1 is end to end */
6981 if (phba->cfg_prot_mask == SHOST_DIX_TYPE1_PROTECTION)
6982 phba->cfg_prot_mask |= SHOST_DIF_TYPE1_PROTECTION;
6983
6984 if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
6985 if ((old_mask != phba->cfg_prot_mask) ||
6986 (old_guard != phba->cfg_prot_guard))
6987 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6988 "1475 Registering BlockGuard with the "
6989 "SCSI layer: mask %d guard %d\n",
6990 phba->cfg_prot_mask,
6991 phba->cfg_prot_guard);
6992
6993 scsi_host_set_prot(shost, phba->cfg_prot_mask);
6994 scsi_host_set_guard(shost, phba->cfg_prot_guard);
6995 } else
6996 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6997 "1479 Not Registering BlockGuard with the SCSI "
6998 "layer, Bad protection parameters: %d %d\n",
6999 old_mask, old_guard);
7000 }
7001
7002 if (!_dump_buf_data) {
7003 while (pagecnt) {
7004 spin_lock_init(&_dump_buf_lock);
7005 _dump_buf_data =
7006 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
7007 if (_dump_buf_data) {
7008 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7009 "9043 BLKGRD: allocated %d pages for "
7010 "_dump_buf_data at 0x%p\n",
7011 (1 << pagecnt), _dump_buf_data);
7012 _dump_buf_data_order = pagecnt;
7013 memset(_dump_buf_data, 0,
7014 ((1 << PAGE_SHIFT) << pagecnt));
7015 break;
7016 } else
7017 --pagecnt;
7018 }
7019 if (!_dump_buf_data_order)
7020 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7021 "9044 BLKGRD: ERROR unable to allocate "
7022 "memory for hexdump\n");
7023 } else
7024 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7025 "9045 BLKGRD: already allocated _dump_buf_data=0x%p"
7026 "\n", _dump_buf_data);
7027 if (!_dump_buf_dif) {
7028 while (pagecnt) {
7029 _dump_buf_dif =
7030 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
7031 if (_dump_buf_dif) {
7032 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7033 "9046 BLKGRD: allocated %d pages for "
7034 "_dump_buf_dif at 0x%p\n",
7035 (1 << pagecnt), _dump_buf_dif);
7036 _dump_buf_dif_order = pagecnt;
7037 memset(_dump_buf_dif, 0,
7038 ((1 << PAGE_SHIFT) << pagecnt));
7039 break;
7040 } else
7041 --pagecnt;
7042 }
7043 if (!_dump_buf_dif_order)
7044 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7045 "9047 BLKGRD: ERROR unable to allocate "
7046 "memory for hexdump\n");
7047 } else
7048 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
7049 "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
7050 _dump_buf_dif);
7051 }
7052
7053 /**
7054 * lpfc_post_init_setup - Perform necessary device post initialization setup.
7055 * @phba: pointer to lpfc hba data structure.
7056 *
7057 * This routine is invoked to perform all the necessary post initialization
7058 * setup for the device.
7059 **/
7060 static void
7061 lpfc_post_init_setup(struct lpfc_hba *phba)
7062 {
7063 struct Scsi_Host *shost;
7064 struct lpfc_adapter_event_header adapter_event;
7065
7066 /* Get the default values for Model Name and Description */
7067 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
7068
7069 /*
7070 * hba setup may have changed the hba_queue_depth so we need to
7071 * adjust the value of can_queue.
7072 */
7073 shost = pci_get_drvdata(phba->pcidev);
7074 shost->can_queue = phba->cfg_hba_queue_depth - 10;
7075 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
7076 lpfc_setup_bg(phba, shost);
7077
7078 lpfc_host_attrib_init(shost);
7079
7080 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
7081 spin_lock_irq(shost->host_lock);
7082 lpfc_poll_start_timer(phba);
7083 spin_unlock_irq(shost->host_lock);
7084 }
7085
7086 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7087 "0428 Perform SCSI scan\n");
7088 /* Send board arrival event to upper layer */
7089 adapter_event.event_type = FC_REG_ADAPTER_EVENT;
7090 adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
7091 fc_host_post_vendor_event(shost, fc_get_event_number(),
7092 sizeof(adapter_event),
7093 (char *) &adapter_event,
7094 LPFC_NL_VENDOR_ID);
7095 return;
7096 }
7097
7098 /**
7099 * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
7100 * @phba: pointer to lpfc hba data structure.
7101 *
7102 * This routine is invoked to set up the PCI device memory space for device
7103 * with SLI-3 interface spec.
7104 *
7105 * Return codes
7106 * 0 - successful
7107 * other values - error
7108 **/
7109 static int
7110 lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
7111 {
7112 struct pci_dev *pdev;
7113 unsigned long bar0map_len, bar2map_len;
7114 int i, hbq_count;
7115 void *ptr;
7116 int error = -ENODEV;
7117
7118 /* Obtain PCI device reference */
7119 if (!phba->pcidev)
7120 return error;
7121 else
7122 pdev = phba->pcidev;
7123
7124 /* Set the device DMA mask size */
7125 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
7126 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
7127 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
7128 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
7129 return error;
7130 }
7131 }
7132
7133 /* Get the bus address of Bar0 and Bar2 and the number of bytes
7134 * required by each mapping.
7135 */
7136 phba->pci_bar0_map = pci_resource_start(pdev, 0);
7137 bar0map_len = pci_resource_len(pdev, 0);
7138
7139 phba->pci_bar2_map = pci_resource_start(pdev, 2);
7140 bar2map_len = pci_resource_len(pdev, 2);
7141
7142 /* Map HBA SLIM to a kernel virtual address. */
7143 phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
7144 if (!phba->slim_memmap_p) {
7145 dev_printk(KERN_ERR, &pdev->dev,
7146 "ioremap failed for SLIM memory.\n");
7147 goto out;
7148 }
7149
7150 /* Map HBA Control Registers to a kernel virtual address. */
7151 phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
7152 if (!phba->ctrl_regs_memmap_p) {
7153 dev_printk(KERN_ERR, &pdev->dev,
7154 "ioremap failed for HBA control registers.\n");
7155 goto out_iounmap_slim;
7156 }
7157
7158 /* Allocate memory for SLI-2 structures */
7159 phba->slim2p.virt = dma_zalloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7160 &phba->slim2p.phys, GFP_KERNEL);
7161 if (!phba->slim2p.virt)
7162 goto out_iounmap;
7163
7164 phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
7165 phba->mbox_ext = (phba->slim2p.virt +
7166 offsetof(struct lpfc_sli2_slim, mbx_ext_words));
7167 phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
7168 phba->IOCBs = (phba->slim2p.virt +
7169 offsetof(struct lpfc_sli2_slim, IOCBs));
7170
7171 phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
7172 lpfc_sli_hbq_size(),
7173 &phba->hbqslimp.phys,
7174 GFP_KERNEL);
7175 if (!phba->hbqslimp.virt)
7176 goto out_free_slim;
7177
7178 hbq_count = lpfc_sli_hbq_count();
7179 ptr = phba->hbqslimp.virt;
7180 for (i = 0; i < hbq_count; ++i) {
7181 phba->hbqs[i].hbq_virt = ptr;
7182 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
7183 ptr += (lpfc_hbq_defs[i]->entry_count *
7184 sizeof(struct lpfc_hbq_entry));
7185 }
7186 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
7187 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
7188
7189 memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
7190
7191 phba->MBslimaddr = phba->slim_memmap_p;
7192 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
7193 phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
7194 phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
7195 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
7196
7197 return 0;
7198
7199 out_free_slim:
7200 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7201 phba->slim2p.virt, phba->slim2p.phys);
7202 out_iounmap:
7203 iounmap(phba->ctrl_regs_memmap_p);
7204 out_iounmap_slim:
7205 iounmap(phba->slim_memmap_p);
7206 out:
7207 return error;
7208 }
7209
7210 /**
7211 * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
7212 * @phba: pointer to lpfc hba data structure.
7213 *
7214 * This routine is invoked to unset the PCI device memory space for device
7215 * with SLI-3 interface spec.
7216 **/
7217 static void
7218 lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
7219 {
7220 struct pci_dev *pdev;
7221
7222 /* Obtain PCI device reference */
7223 if (!phba->pcidev)
7224 return;
7225 else
7226 pdev = phba->pcidev;
7227
7228 /* Free coherent DMA memory allocated */
7229 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
7230 phba->hbqslimp.virt, phba->hbqslimp.phys);
7231 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7232 phba->slim2p.virt, phba->slim2p.phys);
7233
7234 /* I/O memory unmap */
7235 iounmap(phba->ctrl_regs_memmap_p);
7236 iounmap(phba->slim_memmap_p);
7237
7238 return;
7239 }
7240
7241 /**
7242 * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
7243 * @phba: pointer to lpfc hba data structure.
7244 *
7245 * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
7246 * done and check status.
7247 *
7248 * Return 0 if successful, otherwise -ENODEV.
7249 **/
7250 int
7251 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
7252 {
7253 struct lpfc_register portsmphr_reg, uerrlo_reg, uerrhi_reg;
7254 struct lpfc_register reg_data;
7255 int i, port_error = 0;
7256 uint32_t if_type;
7257
7258 memset(&portsmphr_reg, 0, sizeof(portsmphr_reg));
7259 memset(&reg_data, 0, sizeof(reg_data));
7260 if (!phba->sli4_hba.PSMPHRregaddr)
7261 return -ENODEV;
7262
7263 /* Wait up to 30 seconds for the SLI Port POST done and ready */
7264 for (i = 0; i < 3000; i++) {
7265 if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
7266 &portsmphr_reg.word0) ||
7267 (bf_get(lpfc_port_smphr_perr, &portsmphr_reg))) {
7268 /* Port has a fatal POST error, break out */
7269 port_error = -ENODEV;
7270 break;
7271 }
7272 if (LPFC_POST_STAGE_PORT_READY ==
7273 bf_get(lpfc_port_smphr_port_status, &portsmphr_reg))
7274 break;
7275 msleep(10);
7276 }
7277
7278 /*
7279 * If there was a port error during POST, then don't proceed with
7280 * other register reads as the data may not be valid. Just exit.
7281 */
7282 if (port_error) {
7283 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7284 "1408 Port Failed POST - portsmphr=0x%x, "
7285 "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
7286 "scr2=x%x, hscratch=x%x, pstatus=x%x\n",
7287 portsmphr_reg.word0,
7288 bf_get(lpfc_port_smphr_perr, &portsmphr_reg),
7289 bf_get(lpfc_port_smphr_sfi, &portsmphr_reg),
7290 bf_get(lpfc_port_smphr_nip, &portsmphr_reg),
7291 bf_get(lpfc_port_smphr_ipc, &portsmphr_reg),
7292 bf_get(lpfc_port_smphr_scr1, &portsmphr_reg),
7293 bf_get(lpfc_port_smphr_scr2, &portsmphr_reg),
7294 bf_get(lpfc_port_smphr_host_scratch, &portsmphr_reg),
7295 bf_get(lpfc_port_smphr_port_status, &portsmphr_reg));
7296 } else {
7297 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7298 "2534 Device Info: SLIFamily=0x%x, "
7299 "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, "
7300 "SLIHint_2=0x%x, FT=0x%x\n",
7301 bf_get(lpfc_sli_intf_sli_family,
7302 &phba->sli4_hba.sli_intf),
7303 bf_get(lpfc_sli_intf_slirev,
7304 &phba->sli4_hba.sli_intf),
7305 bf_get(lpfc_sli_intf_if_type,
7306 &phba->sli4_hba.sli_intf),
7307 bf_get(lpfc_sli_intf_sli_hint1,
7308 &phba->sli4_hba.sli_intf),
7309 bf_get(lpfc_sli_intf_sli_hint2,
7310 &phba->sli4_hba.sli_intf),
7311 bf_get(lpfc_sli_intf_func_type,
7312 &phba->sli4_hba.sli_intf));
7313 /*
7314 * Check for other Port errors during the initialization
7315 * process. Fail the load if the port did not come up
7316 * correctly.
7317 */
7318 if_type = bf_get(lpfc_sli_intf_if_type,
7319 &phba->sli4_hba.sli_intf);
7320 switch (if_type) {
7321 case LPFC_SLI_INTF_IF_TYPE_0:
7322 phba->sli4_hba.ue_mask_lo =
7323 readl(phba->sli4_hba.u.if_type0.UEMASKLOregaddr);
7324 phba->sli4_hba.ue_mask_hi =
7325 readl(phba->sli4_hba.u.if_type0.UEMASKHIregaddr);
7326 uerrlo_reg.word0 =
7327 readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
7328 uerrhi_reg.word0 =
7329 readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
7330 if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
7331 (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
7332 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7333 "1422 Unrecoverable Error "
7334 "Detected during POST "
7335 "uerr_lo_reg=0x%x, "
7336 "uerr_hi_reg=0x%x, "
7337 "ue_mask_lo_reg=0x%x, "
7338 "ue_mask_hi_reg=0x%x\n",
7339 uerrlo_reg.word0,
7340 uerrhi_reg.word0,
7341 phba->sli4_hba.ue_mask_lo,
7342 phba->sli4_hba.ue_mask_hi);
7343 port_error = -ENODEV;
7344 }
7345 break;
7346 case LPFC_SLI_INTF_IF_TYPE_2:
7347 /* Final checks. The port status should be clean. */
7348 if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
7349 &reg_data.word0) ||
7350 (bf_get(lpfc_sliport_status_err, &reg_data) &&
7351 !bf_get(lpfc_sliport_status_rn, &reg_data))) {
7352 phba->work_status[0] =
7353 readl(phba->sli4_hba.u.if_type2.
7354 ERR1regaddr);
7355 phba->work_status[1] =
7356 readl(phba->sli4_hba.u.if_type2.
7357 ERR2regaddr);
7358 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7359 "2888 Unrecoverable port error "
7360 "following POST: port status reg "
7361 "0x%x, port_smphr reg 0x%x, "
7362 "error 1=0x%x, error 2=0x%x\n",
7363 reg_data.word0,
7364 portsmphr_reg.word0,
7365 phba->work_status[0],
7366 phba->work_status[1]);
7367 port_error = -ENODEV;
7368 }
7369 break;
7370 case LPFC_SLI_INTF_IF_TYPE_1:
7371 default:
7372 break;
7373 }
7374 }
7375 return port_error;
7376 }
7377
7378 /**
7379 * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
7380 * @phba: pointer to lpfc hba data structure.
7381 * @if_type: The SLI4 interface type getting configured.
7382 *
7383 * This routine is invoked to set up SLI4 BAR0 PCI config space register
7384 * memory map.
7385 **/
7386 static void
7387 lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type)
7388 {
7389 switch (if_type) {
7390 case LPFC_SLI_INTF_IF_TYPE_0:
7391 phba->sli4_hba.u.if_type0.UERRLOregaddr =
7392 phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_LO;
7393 phba->sli4_hba.u.if_type0.UERRHIregaddr =
7394 phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_HI;
7395 phba->sli4_hba.u.if_type0.UEMASKLOregaddr =
7396 phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_LO;
7397 phba->sli4_hba.u.if_type0.UEMASKHIregaddr =
7398 phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_HI;
7399 phba->sli4_hba.SLIINTFregaddr =
7400 phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
7401 break;
7402 case LPFC_SLI_INTF_IF_TYPE_2:
7403 phba->sli4_hba.u.if_type2.EQDregaddr =
7404 phba->sli4_hba.conf_regs_memmap_p +
7405 LPFC_CTL_PORT_EQ_DELAY_OFFSET;
7406 phba->sli4_hba.u.if_type2.ERR1regaddr =
7407 phba->sli4_hba.conf_regs_memmap_p +
7408 LPFC_CTL_PORT_ER1_OFFSET;
7409 phba->sli4_hba.u.if_type2.ERR2regaddr =
7410 phba->sli4_hba.conf_regs_memmap_p +
7411 LPFC_CTL_PORT_ER2_OFFSET;
7412 phba->sli4_hba.u.if_type2.CTRLregaddr =
7413 phba->sli4_hba.conf_regs_memmap_p +
7414 LPFC_CTL_PORT_CTL_OFFSET;
7415 phba->sli4_hba.u.if_type2.STATUSregaddr =
7416 phba->sli4_hba.conf_regs_memmap_p +
7417 LPFC_CTL_PORT_STA_OFFSET;
7418 phba->sli4_hba.SLIINTFregaddr =
7419 phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
7420 phba->sli4_hba.PSMPHRregaddr =
7421 phba->sli4_hba.conf_regs_memmap_p +
7422 LPFC_CTL_PORT_SEM_OFFSET;
7423 phba->sli4_hba.RQDBregaddr =
7424 phba->sli4_hba.conf_regs_memmap_p +
7425 LPFC_ULP0_RQ_DOORBELL;
7426 phba->sli4_hba.WQDBregaddr =
7427 phba->sli4_hba.conf_regs_memmap_p +
7428 LPFC_ULP0_WQ_DOORBELL;
7429 phba->sli4_hba.EQCQDBregaddr =
7430 phba->sli4_hba.conf_regs_memmap_p + LPFC_EQCQ_DOORBELL;
7431 phba->sli4_hba.MQDBregaddr =
7432 phba->sli4_hba.conf_regs_memmap_p + LPFC_MQ_DOORBELL;
7433 phba->sli4_hba.BMBXregaddr =
7434 phba->sli4_hba.conf_regs_memmap_p + LPFC_BMBX;
7435 break;
7436 case LPFC_SLI_INTF_IF_TYPE_1:
7437 default:
7438 dev_printk(KERN_ERR, &phba->pcidev->dev,
7439 "FATAL - unsupported SLI4 interface type - %d\n",
7440 if_type);
7441 break;
7442 }
7443 }
7444
7445 /**
7446 * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
7447 * @phba: pointer to lpfc hba data structure.
7448 *
7449 * This routine is invoked to set up SLI4 BAR1 control status register (CSR)
7450 * memory map.
7451 **/
7452 static void
7453 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
7454 {
7455 phba->sli4_hba.PSMPHRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7456 LPFC_SLIPORT_IF0_SMPHR;
7457 phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7458 LPFC_HST_ISR0;
7459 phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7460 LPFC_HST_IMR0;
7461 phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7462 LPFC_HST_ISCR0;
7463 }
7464
7465 /**
7466 * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
7467 * @phba: pointer to lpfc hba data structure.
7468 * @vf: virtual function number
7469 *
7470 * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
7471 * based on the given viftual function number, @vf.
7472 *
7473 * Return 0 if successful, otherwise -ENODEV.
7474 **/
7475 static int
7476 lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
7477 {
7478 if (vf > LPFC_VIR_FUNC_MAX)
7479 return -ENODEV;
7480
7481 phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7482 vf * LPFC_VFR_PAGE_SIZE +
7483 LPFC_ULP0_RQ_DOORBELL);
7484 phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7485 vf * LPFC_VFR_PAGE_SIZE +
7486 LPFC_ULP0_WQ_DOORBELL);
7487 phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7488 vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL);
7489 phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7490 vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL);
7491 phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7492 vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX);
7493 return 0;
7494 }
7495
7496 /**
7497 * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
7498 * @phba: pointer to lpfc hba data structure.
7499 *
7500 * This routine is invoked to create the bootstrap mailbox
7501 * region consistent with the SLI-4 interface spec. This
7502 * routine allocates all memory necessary to communicate
7503 * mailbox commands to the port and sets up all alignment
7504 * needs. No locks are expected to be held when calling
7505 * this routine.
7506 *
7507 * Return codes
7508 * 0 - successful
7509 * -ENOMEM - could not allocated memory.
7510 **/
7511 static int
7512 lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
7513 {
7514 uint32_t bmbx_size;
7515 struct lpfc_dmabuf *dmabuf;
7516 struct dma_address *dma_address;
7517 uint32_t pa_addr;
7518 uint64_t phys_addr;
7519
7520 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
7521 if (!dmabuf)
7522 return -ENOMEM;
7523
7524 /*
7525 * The bootstrap mailbox region is comprised of 2 parts
7526 * plus an alignment restriction of 16 bytes.
7527 */
7528 bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
7529 dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, bmbx_size,
7530 &dmabuf->phys, GFP_KERNEL);
7531 if (!dmabuf->virt) {
7532 kfree(dmabuf);
7533 return -ENOMEM;
7534 }
7535
7536 /*
7537 * Initialize the bootstrap mailbox pointers now so that the register
7538 * operations are simple later. The mailbox dma address is required
7539 * to be 16-byte aligned. Also align the virtual memory as each
7540 * maibox is copied into the bmbx mailbox region before issuing the
7541 * command to the port.
7542 */
7543 phba->sli4_hba.bmbx.dmabuf = dmabuf;
7544 phba->sli4_hba.bmbx.bmbx_size = bmbx_size;
7545
7546 phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt,
7547 LPFC_ALIGN_16_BYTE);
7548 phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys,
7549 LPFC_ALIGN_16_BYTE);
7550
7551 /*
7552 * Set the high and low physical addresses now. The SLI4 alignment
7553 * requirement is 16 bytes and the mailbox is posted to the port
7554 * as two 30-bit addresses. The other data is a bit marking whether
7555 * the 30-bit address is the high or low address.
7556 * Upcast bmbx aphys to 64bits so shift instruction compiles
7557 * clean on 32 bit machines.
7558 */
7559 dma_address = &phba->sli4_hba.bmbx.dma_address;
7560 phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys;
7561 pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff);
7562 dma_address->addr_hi = (uint32_t) ((pa_addr << 2) |
7563 LPFC_BMBX_BIT1_ADDR_HI);
7564
7565 pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff);
7566 dma_address->addr_lo = (uint32_t) ((pa_addr << 2) |
7567 LPFC_BMBX_BIT1_ADDR_LO);
7568 return 0;
7569 }
7570
7571 /**
7572 * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
7573 * @phba: pointer to lpfc hba data structure.
7574 *
7575 * This routine is invoked to teardown the bootstrap mailbox
7576 * region and release all host resources. This routine requires
7577 * the caller to ensure all mailbox commands recovered, no
7578 * additional mailbox comands are sent, and interrupts are disabled
7579 * before calling this routine.
7580 *
7581 **/
7582 static void
7583 lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
7584 {
7585 dma_free_coherent(&phba->pcidev->dev,
7586 phba->sli4_hba.bmbx.bmbx_size,
7587 phba->sli4_hba.bmbx.dmabuf->virt,
7588 phba->sli4_hba.bmbx.dmabuf->phys);
7589
7590 kfree(phba->sli4_hba.bmbx.dmabuf);
7591 memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx));
7592 }
7593
7594 /**
7595 * lpfc_sli4_read_config - Get the config parameters.
7596 * @phba: pointer to lpfc hba data structure.
7597 *
7598 * This routine is invoked to read the configuration parameters from the HBA.
7599 * The configuration parameters are used to set the base and maximum values
7600 * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
7601 * allocation for the port.
7602 *
7603 * Return codes
7604 * 0 - successful
7605 * -ENOMEM - No available memory
7606 * -EIO - The mailbox failed to complete successfully.
7607 **/
7608 int
7609 lpfc_sli4_read_config(struct lpfc_hba *phba)
7610 {
7611 LPFC_MBOXQ_t *pmb;
7612 struct lpfc_mbx_read_config *rd_config;
7613 union lpfc_sli4_cfg_shdr *shdr;
7614 uint32_t shdr_status, shdr_add_status;
7615 struct lpfc_mbx_get_func_cfg *get_func_cfg;
7616 struct lpfc_rsrc_desc_fcfcoe *desc;
7617 char *pdesc_0;
7618 uint16_t forced_link_speed;
7619 uint32_t if_type;
7620 int length, i, rc = 0, rc2;
7621
7622 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7623 if (!pmb) {
7624 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7625 "2011 Unable to allocate memory for issuing "
7626 "SLI_CONFIG_SPECIAL mailbox command\n");
7627 return -ENOMEM;
7628 }
7629
7630 lpfc_read_config(phba, pmb);
7631
7632 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
7633 if (rc != MBX_SUCCESS) {
7634 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7635 "2012 Mailbox failed , mbxCmd x%x "
7636 "READ_CONFIG, mbxStatus x%x\n",
7637 bf_get(lpfc_mqe_command, &pmb->u.mqe),
7638 bf_get(lpfc_mqe_status, &pmb->u.mqe));
7639 rc = -EIO;
7640 } else {
7641 rd_config = &pmb->u.mqe.un.rd_config;
7642 if (bf_get(lpfc_mbx_rd_conf_lnk_ldv, rd_config)) {
7643 phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_VAL;
7644 phba->sli4_hba.lnk_info.lnk_tp =
7645 bf_get(lpfc_mbx_rd_conf_lnk_type, rd_config);
7646 phba->sli4_hba.lnk_info.lnk_no =
7647 bf_get(lpfc_mbx_rd_conf_lnk_numb, rd_config);
7648 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7649 "3081 lnk_type:%d, lnk_numb:%d\n",
7650 phba->sli4_hba.lnk_info.lnk_tp,
7651 phba->sli4_hba.lnk_info.lnk_no);
7652 } else
7653 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
7654 "3082 Mailbox (x%x) returned ldv:x0\n",
7655 bf_get(lpfc_mqe_command, &pmb->u.mqe));
7656 if (bf_get(lpfc_mbx_rd_conf_bbscn_def, rd_config)) {
7657 phba->bbcredit_support = 1;
7658 phba->sli4_hba.bbscn_params.word0 = rd_config->word8;
7659 }
7660
7661 phba->sli4_hba.extents_in_use =
7662 bf_get(lpfc_mbx_rd_conf_extnts_inuse, rd_config);
7663 phba->sli4_hba.max_cfg_param.max_xri =
7664 bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
7665 phba->sli4_hba.max_cfg_param.xri_base =
7666 bf_get(lpfc_mbx_rd_conf_xri_base, rd_config);
7667 phba->sli4_hba.max_cfg_param.max_vpi =
7668 bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config);
7669 phba->sli4_hba.max_cfg_param.vpi_base =
7670 bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config);
7671 phba->sli4_hba.max_cfg_param.max_rpi =
7672 bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
7673 phba->sli4_hba.max_cfg_param.rpi_base =
7674 bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config);
7675 phba->sli4_hba.max_cfg_param.max_vfi =
7676 bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config);
7677 phba->sli4_hba.max_cfg_param.vfi_base =
7678 bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
7679 phba->sli4_hba.max_cfg_param.max_fcfi =
7680 bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
7681 phba->sli4_hba.max_cfg_param.max_eq =
7682 bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
7683 phba->sli4_hba.max_cfg_param.max_rq =
7684 bf_get(lpfc_mbx_rd_conf_rq_count, rd_config);
7685 phba->sli4_hba.max_cfg_param.max_wq =
7686 bf_get(lpfc_mbx_rd_conf_wq_count, rd_config);
7687 phba->sli4_hba.max_cfg_param.max_cq =
7688 bf_get(lpfc_mbx_rd_conf_cq_count, rd_config);
7689 phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config);
7690 phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base;
7691 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
7692 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
7693 phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
7694 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
7695 phba->max_vports = phba->max_vpi;
7696 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7697 "2003 cfg params Extents? %d "
7698 "XRI(B:%d M:%d), "
7699 "VPI(B:%d M:%d) "
7700 "VFI(B:%d M:%d) "
7701 "RPI(B:%d M:%d) "
7702 "FCFI:%d EQ:%d CQ:%d WQ:%d RQ:%d\n",
7703 phba->sli4_hba.extents_in_use,
7704 phba->sli4_hba.max_cfg_param.xri_base,
7705 phba->sli4_hba.max_cfg_param.max_xri,
7706 phba->sli4_hba.max_cfg_param.vpi_base,
7707 phba->sli4_hba.max_cfg_param.max_vpi,
7708 phba->sli4_hba.max_cfg_param.vfi_base,
7709 phba->sli4_hba.max_cfg_param.max_vfi,
7710 phba->sli4_hba.max_cfg_param.rpi_base,
7711 phba->sli4_hba.max_cfg_param.max_rpi,
7712 phba->sli4_hba.max_cfg_param.max_fcfi,
7713 phba->sli4_hba.max_cfg_param.max_eq,
7714 phba->sli4_hba.max_cfg_param.max_cq,
7715 phba->sli4_hba.max_cfg_param.max_wq,
7716 phba->sli4_hba.max_cfg_param.max_rq);
7717
7718 }
7719
7720 if (rc)
7721 goto read_cfg_out;
7722
7723 /* Update link speed if forced link speed is supported */
7724 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
7725 if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
7726 forced_link_speed =
7727 bf_get(lpfc_mbx_rd_conf_link_speed, rd_config);
7728 if (forced_link_speed) {
7729 phba->hba_flag |= HBA_FORCED_LINK_SPEED;
7730
7731 switch (forced_link_speed) {
7732 case LINK_SPEED_1G:
7733 phba->cfg_link_speed =
7734 LPFC_USER_LINK_SPEED_1G;
7735 break;
7736 case LINK_SPEED_2G:
7737 phba->cfg_link_speed =
7738 LPFC_USER_LINK_SPEED_2G;
7739 break;
7740 case LINK_SPEED_4G:
7741 phba->cfg_link_speed =
7742 LPFC_USER_LINK_SPEED_4G;
7743 break;
7744 case LINK_SPEED_8G:
7745 phba->cfg_link_speed =
7746 LPFC_USER_LINK_SPEED_8G;
7747 break;
7748 case LINK_SPEED_10G:
7749 phba->cfg_link_speed =
7750 LPFC_USER_LINK_SPEED_10G;
7751 break;
7752 case LINK_SPEED_16G:
7753 phba->cfg_link_speed =
7754 LPFC_USER_LINK_SPEED_16G;
7755 break;
7756 case LINK_SPEED_32G:
7757 phba->cfg_link_speed =
7758 LPFC_USER_LINK_SPEED_32G;
7759 break;
7760 case 0xffff:
7761 phba->cfg_link_speed =
7762 LPFC_USER_LINK_SPEED_AUTO;
7763 break;
7764 default:
7765 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7766 "0047 Unrecognized link "
7767 "speed : %d\n",
7768 forced_link_speed);
7769 phba->cfg_link_speed =
7770 LPFC_USER_LINK_SPEED_AUTO;
7771 }
7772 }
7773 }
7774
7775 /* Reset the DFT_HBA_Q_DEPTH to the max xri */
7776 length = phba->sli4_hba.max_cfg_param.max_xri -
7777 lpfc_sli4_get_els_iocb_cnt(phba);
7778 if (phba->cfg_hba_queue_depth > length) {
7779 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
7780 "3361 HBA queue depth changed from %d to %d\n",
7781 phba->cfg_hba_queue_depth, length);
7782 phba->cfg_hba_queue_depth = length;
7783 }
7784
7785 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
7786 LPFC_SLI_INTF_IF_TYPE_2)
7787 goto read_cfg_out;
7788
7789 /* get the pf# and vf# for SLI4 if_type 2 port */
7790 length = (sizeof(struct lpfc_mbx_get_func_cfg) -
7791 sizeof(struct lpfc_sli4_cfg_mhdr));
7792 lpfc_sli4_config(phba, pmb, LPFC_MBOX_SUBSYSTEM_COMMON,
7793 LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG,
7794 length, LPFC_SLI4_MBX_EMBED);
7795
7796 rc2 = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
7797 shdr = (union lpfc_sli4_cfg_shdr *)
7798 &pmb->u.mqe.un.sli4_config.header.cfg_shdr;
7799 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
7800 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
7801 if (rc2 || shdr_status || shdr_add_status) {
7802 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7803 "3026 Mailbox failed , mbxCmd x%x "
7804 "GET_FUNCTION_CONFIG, mbxStatus x%x\n",
7805 bf_get(lpfc_mqe_command, &pmb->u.mqe),
7806 bf_get(lpfc_mqe_status, &pmb->u.mqe));
7807 goto read_cfg_out;
7808 }
7809
7810 /* search for fc_fcoe resrouce descriptor */
7811 get_func_cfg = &pmb->u.mqe.un.get_func_cfg;
7812
7813 pdesc_0 = (char *)&get_func_cfg->func_cfg.desc[0];
7814 desc = (struct lpfc_rsrc_desc_fcfcoe *)pdesc_0;
7815 length = bf_get(lpfc_rsrc_desc_fcfcoe_length, desc);
7816 if (length == LPFC_RSRC_DESC_TYPE_FCFCOE_V0_RSVD)
7817 length = LPFC_RSRC_DESC_TYPE_FCFCOE_V0_LENGTH;
7818 else if (length != LPFC_RSRC_DESC_TYPE_FCFCOE_V1_LENGTH)
7819 goto read_cfg_out;
7820
7821 for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
7822 desc = (struct lpfc_rsrc_desc_fcfcoe *)(pdesc_0 + length * i);
7823 if (LPFC_RSRC_DESC_TYPE_FCFCOE ==
7824 bf_get(lpfc_rsrc_desc_fcfcoe_type, desc)) {
7825 phba->sli4_hba.iov.pf_number =
7826 bf_get(lpfc_rsrc_desc_fcfcoe_pfnum, desc);
7827 phba->sli4_hba.iov.vf_number =
7828 bf_get(lpfc_rsrc_desc_fcfcoe_vfnum, desc);
7829 break;
7830 }
7831 }
7832
7833 if (i < LPFC_RSRC_DESC_MAX_NUM)
7834 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7835 "3027 GET_FUNCTION_CONFIG: pf_number:%d, "
7836 "vf_number:%d\n", phba->sli4_hba.iov.pf_number,
7837 phba->sli4_hba.iov.vf_number);
7838 else
7839 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7840 "3028 GET_FUNCTION_CONFIG: failed to find "
7841 "Resrouce Descriptor:x%x\n",
7842 LPFC_RSRC_DESC_TYPE_FCFCOE);
7843
7844 read_cfg_out:
7845 mempool_free(pmb, phba->mbox_mem_pool);
7846 return rc;
7847 }
7848
7849 /**
7850 * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port.
7851 * @phba: pointer to lpfc hba data structure.
7852 *
7853 * This routine is invoked to setup the port-side endian order when
7854 * the port if_type is 0. This routine has no function for other
7855 * if_types.
7856 *
7857 * Return codes
7858 * 0 - successful
7859 * -ENOMEM - No available memory
7860 * -EIO - The mailbox failed to complete successfully.
7861 **/
7862 static int
7863 lpfc_setup_endian_order(struct lpfc_hba *phba)
7864 {
7865 LPFC_MBOXQ_t *mboxq;
7866 uint32_t if_type, rc = 0;
7867 uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
7868 HOST_ENDIAN_HIGH_WORD1};
7869
7870 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
7871 switch (if_type) {
7872 case LPFC_SLI_INTF_IF_TYPE_0:
7873 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
7874 GFP_KERNEL);
7875 if (!mboxq) {
7876 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7877 "0492 Unable to allocate memory for "
7878 "issuing SLI_CONFIG_SPECIAL mailbox "
7879 "command\n");
7880 return -ENOMEM;
7881 }
7882
7883 /*
7884 * The SLI4_CONFIG_SPECIAL mailbox command requires the first
7885 * two words to contain special data values and no other data.
7886 */
7887 memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
7888 memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
7889 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
7890 if (rc != MBX_SUCCESS) {
7891 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7892 "0493 SLI_CONFIG_SPECIAL mailbox "
7893 "failed with status x%x\n",
7894 rc);
7895 rc = -EIO;
7896 }
7897 mempool_free(mboxq, phba->mbox_mem_pool);
7898 break;
7899 case LPFC_SLI_INTF_IF_TYPE_2:
7900 case LPFC_SLI_INTF_IF_TYPE_1:
7901 default:
7902 break;
7903 }
7904 return rc;
7905 }
7906
7907 /**
7908 * lpfc_sli4_queue_verify - Verify and update EQ counts
7909 * @phba: pointer to lpfc hba data structure.
7910 *
7911 * This routine is invoked to check the user settable queue counts for EQs.
7912 * After this routine is called the counts will be set to valid values that
7913 * adhere to the constraints of the system's interrupt vectors and the port's
7914 * queue resources.
7915 *
7916 * Return codes
7917 * 0 - successful
7918 * -ENOMEM - No available memory
7919 **/
7920 static int
7921 lpfc_sli4_queue_verify(struct lpfc_hba *phba)
7922 {
7923 int io_channel;
7924 int fof_vectors = phba->cfg_fof ? 1 : 0;
7925
7926 /*
7927 * Sanity check for configured queue parameters against the run-time
7928 * device parameters
7929 */
7930
7931 /* Sanity check on HBA EQ parameters */
7932 io_channel = phba->io_channel_irqs;
7933
7934 if (phba->sli4_hba.num_online_cpu < io_channel) {
7935 lpfc_printf_log(phba,
7936 KERN_ERR, LOG_INIT,
7937 "3188 Reducing IO channels to match number of "
7938 "online CPUs: from %d to %d\n",
7939 io_channel, phba->sli4_hba.num_online_cpu);
7940 io_channel = phba->sli4_hba.num_online_cpu;
7941 }
7942
7943 if (io_channel + fof_vectors > phba->sli4_hba.max_cfg_param.max_eq) {
7944 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7945 "2575 Reducing IO channels to match number of "
7946 "available EQs: from %d to %d\n",
7947 io_channel,
7948 phba->sli4_hba.max_cfg_param.max_eq);
7949 io_channel = phba->sli4_hba.max_cfg_param.max_eq - fof_vectors;
7950 }
7951
7952 /* The actual number of FCP / NVME event queues adopted */
7953 if (io_channel != phba->io_channel_irqs)
7954 phba->io_channel_irqs = io_channel;
7955 if (phba->cfg_fcp_io_channel > io_channel)
7956 phba->cfg_fcp_io_channel = io_channel;
7957 if (phba->cfg_nvme_io_channel > io_channel)
7958 phba->cfg_nvme_io_channel = io_channel;
7959 if (phba->nvmet_support) {
7960 if (phba->cfg_nvme_io_channel < phba->cfg_nvmet_mrq)
7961 phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel;
7962 }
7963 if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
7964 phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
7965
7966 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7967 "2574 IO channels: irqs %d fcp %d nvme %d MRQ: %d\n",
7968 phba->io_channel_irqs, phba->cfg_fcp_io_channel,
7969 phba->cfg_nvme_io_channel, phba->cfg_nvmet_mrq);
7970
7971 /* Get EQ depth from module parameter, fake the default for now */
7972 phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
7973 phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
7974
7975 /* Get CQ depth from module parameter, fake the default for now */
7976 phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
7977 phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
7978 return 0;
7979 }
7980
7981 static int
7982 lpfc_alloc_nvme_wq_cq(struct lpfc_hba *phba, int wqidx)
7983 {
7984 struct lpfc_queue *qdesc;
7985
7986 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_EXPANDED_PAGE_SIZE,
7987 phba->sli4_hba.cq_esize,
7988 LPFC_CQE_EXP_COUNT);
7989 if (!qdesc) {
7990 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7991 "0508 Failed allocate fast-path NVME CQ (%d)\n",
7992 wqidx);
7993 return 1;
7994 }
7995 phba->sli4_hba.nvme_cq[wqidx] = qdesc;
7996
7997 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_EXPANDED_PAGE_SIZE,
7998 LPFC_WQE128_SIZE, LPFC_WQE_EXP_COUNT);
7999 if (!qdesc) {
8000 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8001 "0509 Failed allocate fast-path NVME WQ (%d)\n",
8002 wqidx);
8003 return 1;
8004 }
8005 phba->sli4_hba.nvme_wq[wqidx] = qdesc;
8006 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8007 return 0;
8008 }
8009
8010 static int
8011 lpfc_alloc_fcp_wq_cq(struct lpfc_hba *phba, int wqidx)
8012 {
8013 struct lpfc_queue *qdesc;
8014 uint32_t wqesize;
8015
8016 /* Create Fast Path FCP CQs */
8017 if (phba->enab_exp_wqcq_pages)
8018 /* Increase the CQ size when WQEs contain an embedded cdb */
8019 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_EXPANDED_PAGE_SIZE,
8020 phba->sli4_hba.cq_esize,
8021 LPFC_CQE_EXP_COUNT);
8022
8023 else
8024 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8025 phba->sli4_hba.cq_esize,
8026 phba->sli4_hba.cq_ecount);
8027 if (!qdesc) {
8028 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8029 "0499 Failed allocate fast-path FCP CQ (%d)\n", wqidx);
8030 return 1;
8031 }
8032 phba->sli4_hba.fcp_cq[wqidx] = qdesc;
8033
8034 /* Create Fast Path FCP WQs */
8035 if (phba->enab_exp_wqcq_pages) {
8036 /* Increase the WQ size when WQEs contain an embedded cdb */
8037 wqesize = (phba->fcp_embed_io) ?
8038 LPFC_WQE128_SIZE : phba->sli4_hba.wq_esize;
8039 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_EXPANDED_PAGE_SIZE,
8040 wqesize,
8041 LPFC_WQE_EXP_COUNT);
8042 } else
8043 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8044 phba->sli4_hba.wq_esize,
8045 phba->sli4_hba.wq_ecount);
8046
8047 if (!qdesc) {
8048 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8049 "0503 Failed allocate fast-path FCP WQ (%d)\n",
8050 wqidx);
8051 return 1;
8052 }
8053 phba->sli4_hba.fcp_wq[wqidx] = qdesc;
8054 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8055 return 0;
8056 }
8057
8058 /**
8059 * lpfc_sli4_queue_create - Create all the SLI4 queues
8060 * @phba: pointer to lpfc hba data structure.
8061 *
8062 * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
8063 * operation. For each SLI4 queue type, the parameters such as queue entry
8064 * count (queue depth) shall be taken from the module parameter. For now,
8065 * we just use some constant number as place holder.
8066 *
8067 * Return codes
8068 * 0 - successful
8069 * -ENOMEM - No availble memory
8070 * -EIO - The mailbox failed to complete successfully.
8071 **/
8072 int
8073 lpfc_sli4_queue_create(struct lpfc_hba *phba)
8074 {
8075 struct lpfc_queue *qdesc;
8076 int idx, io_channel;
8077
8078 /*
8079 * Create HBA Record arrays.
8080 * Both NVME and FCP will share that same vectors / EQs
8081 */
8082 io_channel = phba->io_channel_irqs;
8083 if (!io_channel)
8084 return -ERANGE;
8085
8086 phba->sli4_hba.mq_esize = LPFC_MQE_SIZE;
8087 phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT;
8088 phba->sli4_hba.wq_esize = LPFC_WQE_SIZE;
8089 phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT;
8090 phba->sli4_hba.rq_esize = LPFC_RQE_SIZE;
8091 phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT;
8092 phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
8093 phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
8094 phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
8095 phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
8096
8097 phba->sli4_hba.hba_eq = kcalloc(io_channel,
8098 sizeof(struct lpfc_queue *),
8099 GFP_KERNEL);
8100 if (!phba->sli4_hba.hba_eq) {
8101 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8102 "2576 Failed allocate memory for "
8103 "fast-path EQ record array\n");
8104 goto out_error;
8105 }
8106
8107 if (phba->cfg_fcp_io_channel) {
8108 phba->sli4_hba.fcp_cq = kcalloc(phba->cfg_fcp_io_channel,
8109 sizeof(struct lpfc_queue *),
8110 GFP_KERNEL);
8111 if (!phba->sli4_hba.fcp_cq) {
8112 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8113 "2577 Failed allocate memory for "
8114 "fast-path CQ record array\n");
8115 goto out_error;
8116 }
8117 phba->sli4_hba.fcp_wq = kcalloc(phba->cfg_fcp_io_channel,
8118 sizeof(struct lpfc_queue *),
8119 GFP_KERNEL);
8120 if (!phba->sli4_hba.fcp_wq) {
8121 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8122 "2578 Failed allocate memory for "
8123 "fast-path FCP WQ record array\n");
8124 goto out_error;
8125 }
8126 /*
8127 * Since the first EQ can have multiple CQs associated with it,
8128 * this array is used to quickly see if we have a FCP fast-path
8129 * CQ match.
8130 */
8131 phba->sli4_hba.fcp_cq_map = kcalloc(phba->cfg_fcp_io_channel,
8132 sizeof(uint16_t),
8133 GFP_KERNEL);
8134 if (!phba->sli4_hba.fcp_cq_map) {
8135 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8136 "2545 Failed allocate memory for "
8137 "fast-path CQ map\n");
8138 goto out_error;
8139 }
8140 }
8141
8142 if (phba->cfg_nvme_io_channel) {
8143 phba->sli4_hba.nvme_cq = kcalloc(phba->cfg_nvme_io_channel,
8144 sizeof(struct lpfc_queue *),
8145 GFP_KERNEL);
8146 if (!phba->sli4_hba.nvme_cq) {
8147 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8148 "6077 Failed allocate memory for "
8149 "fast-path CQ record array\n");
8150 goto out_error;
8151 }
8152
8153 phba->sli4_hba.nvme_wq = kcalloc(phba->cfg_nvme_io_channel,
8154 sizeof(struct lpfc_queue *),
8155 GFP_KERNEL);
8156 if (!phba->sli4_hba.nvme_wq) {
8157 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8158 "2581 Failed allocate memory for "
8159 "fast-path NVME WQ record array\n");
8160 goto out_error;
8161 }
8162
8163 /*
8164 * Since the first EQ can have multiple CQs associated with it,
8165 * this array is used to quickly see if we have a NVME fast-path
8166 * CQ match.
8167 */
8168 phba->sli4_hba.nvme_cq_map = kcalloc(phba->cfg_nvme_io_channel,
8169 sizeof(uint16_t),
8170 GFP_KERNEL);
8171 if (!phba->sli4_hba.nvme_cq_map) {
8172 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8173 "6078 Failed allocate memory for "
8174 "fast-path CQ map\n");
8175 goto out_error;
8176 }
8177
8178 if (phba->nvmet_support) {
8179 phba->sli4_hba.nvmet_cqset = kcalloc(
8180 phba->cfg_nvmet_mrq,
8181 sizeof(struct lpfc_queue *),
8182 GFP_KERNEL);
8183 if (!phba->sli4_hba.nvmet_cqset) {
8184 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8185 "3121 Fail allocate memory for "
8186 "fast-path CQ set array\n");
8187 goto out_error;
8188 }
8189 phba->sli4_hba.nvmet_mrq_hdr = kcalloc(
8190 phba->cfg_nvmet_mrq,
8191 sizeof(struct lpfc_queue *),
8192 GFP_KERNEL);
8193 if (!phba->sli4_hba.nvmet_mrq_hdr) {
8194 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8195 "3122 Fail allocate memory for "
8196 "fast-path RQ set hdr array\n");
8197 goto out_error;
8198 }
8199 phba->sli4_hba.nvmet_mrq_data = kcalloc(
8200 phba->cfg_nvmet_mrq,
8201 sizeof(struct lpfc_queue *),
8202 GFP_KERNEL);
8203 if (!phba->sli4_hba.nvmet_mrq_data) {
8204 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8205 "3124 Fail allocate memory for "
8206 "fast-path RQ set data array\n");
8207 goto out_error;
8208 }
8209 }
8210 }
8211
8212 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_wq_list);
8213
8214 /* Create HBA Event Queues (EQs) */
8215 for (idx = 0; idx < io_channel; idx++) {
8216 /* Create EQs */
8217 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8218 phba->sli4_hba.eq_esize,
8219 phba->sli4_hba.eq_ecount);
8220 if (!qdesc) {
8221 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8222 "0497 Failed allocate EQ (%d)\n", idx);
8223 goto out_error;
8224 }
8225 phba->sli4_hba.hba_eq[idx] = qdesc;
8226 }
8227
8228 /* FCP and NVME io channels are not required to be balanced */
8229
8230 for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++)
8231 if (lpfc_alloc_fcp_wq_cq(phba, idx))
8232 goto out_error;
8233
8234 for (idx = 0; idx < phba->cfg_nvme_io_channel; idx++)
8235 if (lpfc_alloc_nvme_wq_cq(phba, idx))
8236 goto out_error;
8237
8238 if (phba->nvmet_support) {
8239 for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
8240 qdesc = lpfc_sli4_queue_alloc(phba,
8241 LPFC_DEFAULT_PAGE_SIZE,
8242 phba->sli4_hba.cq_esize,
8243 phba->sli4_hba.cq_ecount);
8244 if (!qdesc) {
8245 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8246 "3142 Failed allocate NVME "
8247 "CQ Set (%d)\n", idx);
8248 goto out_error;
8249 }
8250 phba->sli4_hba.nvmet_cqset[idx] = qdesc;
8251 }
8252 }
8253
8254 /*
8255 * Create Slow Path Completion Queues (CQs)
8256 */
8257
8258 /* Create slow-path Mailbox Command Complete Queue */
8259 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8260 phba->sli4_hba.cq_esize,
8261 phba->sli4_hba.cq_ecount);
8262 if (!qdesc) {
8263 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8264 "0500 Failed allocate slow-path mailbox CQ\n");
8265 goto out_error;
8266 }
8267 phba->sli4_hba.mbx_cq = qdesc;
8268
8269 /* Create slow-path ELS Complete Queue */
8270 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8271 phba->sli4_hba.cq_esize,
8272 phba->sli4_hba.cq_ecount);
8273 if (!qdesc) {
8274 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8275 "0501 Failed allocate slow-path ELS CQ\n");
8276 goto out_error;
8277 }
8278 phba->sli4_hba.els_cq = qdesc;
8279
8280
8281 /*
8282 * Create Slow Path Work Queues (WQs)
8283 */
8284
8285 /* Create Mailbox Command Queue */
8286
8287 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8288 phba->sli4_hba.mq_esize,
8289 phba->sli4_hba.mq_ecount);
8290 if (!qdesc) {
8291 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8292 "0505 Failed allocate slow-path MQ\n");
8293 goto out_error;
8294 }
8295 phba->sli4_hba.mbx_wq = qdesc;
8296
8297 /*
8298 * Create ELS Work Queues
8299 */
8300
8301 /* Create slow-path ELS Work Queue */
8302 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8303 phba->sli4_hba.wq_esize,
8304 phba->sli4_hba.wq_ecount);
8305 if (!qdesc) {
8306 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8307 "0504 Failed allocate slow-path ELS WQ\n");
8308 goto out_error;
8309 }
8310 phba->sli4_hba.els_wq = qdesc;
8311 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8312
8313 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
8314 /* Create NVME LS Complete Queue */
8315 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8316 phba->sli4_hba.cq_esize,
8317 phba->sli4_hba.cq_ecount);
8318 if (!qdesc) {
8319 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8320 "6079 Failed allocate NVME LS CQ\n");
8321 goto out_error;
8322 }
8323 phba->sli4_hba.nvmels_cq = qdesc;
8324
8325 /* Create NVME LS Work Queue */
8326 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8327 phba->sli4_hba.wq_esize,
8328 phba->sli4_hba.wq_ecount);
8329 if (!qdesc) {
8330 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8331 "6080 Failed allocate NVME LS WQ\n");
8332 goto out_error;
8333 }
8334 phba->sli4_hba.nvmels_wq = qdesc;
8335 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8336 }
8337
8338 /*
8339 * Create Receive Queue (RQ)
8340 */
8341
8342 /* Create Receive Queue for header */
8343 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8344 phba->sli4_hba.rq_esize,
8345 phba->sli4_hba.rq_ecount);
8346 if (!qdesc) {
8347 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8348 "0506 Failed allocate receive HRQ\n");
8349 goto out_error;
8350 }
8351 phba->sli4_hba.hdr_rq = qdesc;
8352
8353 /* Create Receive Queue for data */
8354 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
8355 phba->sli4_hba.rq_esize,
8356 phba->sli4_hba.rq_ecount);
8357 if (!qdesc) {
8358 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8359 "0507 Failed allocate receive DRQ\n");
8360 goto out_error;
8361 }
8362 phba->sli4_hba.dat_rq = qdesc;
8363
8364 if (phba->nvmet_support) {
8365 for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
8366 /* Create NVMET Receive Queue for header */
8367 qdesc = lpfc_sli4_queue_alloc(phba,
8368 LPFC_DEFAULT_PAGE_SIZE,
8369 phba->sli4_hba.rq_esize,
8370 LPFC_NVMET_RQE_DEF_COUNT);
8371 if (!qdesc) {
8372 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8373 "3146 Failed allocate "
8374 "receive HRQ\n");
8375 goto out_error;
8376 }
8377 phba->sli4_hba.nvmet_mrq_hdr[idx] = qdesc;
8378
8379 /* Only needed for header of RQ pair */
8380 qdesc->rqbp = kzalloc(sizeof(struct lpfc_rqb),
8381 GFP_KERNEL);
8382 if (qdesc->rqbp == NULL) {
8383 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8384 "6131 Failed allocate "
8385 "Header RQBP\n");
8386 goto out_error;
8387 }
8388
8389 /* Put list in known state in case driver load fails. */
8390 INIT_LIST_HEAD(&qdesc->rqbp->rqb_buffer_list);
8391
8392 /* Create NVMET Receive Queue for data */
8393 qdesc = lpfc_sli4_queue_alloc(phba,
8394 LPFC_DEFAULT_PAGE_SIZE,
8395 phba->sli4_hba.rq_esize,
8396 LPFC_NVMET_RQE_DEF_COUNT);
8397 if (!qdesc) {
8398 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8399 "3156 Failed allocate "
8400 "receive DRQ\n");
8401 goto out_error;
8402 }
8403 phba->sli4_hba.nvmet_mrq_data[idx] = qdesc;
8404 }
8405 }
8406
8407 /* Create the Queues needed for Flash Optimized Fabric operations */
8408 if (phba->cfg_fof)
8409 lpfc_fof_queue_create(phba);
8410 return 0;
8411
8412 out_error:
8413 lpfc_sli4_queue_destroy(phba);
8414 return -ENOMEM;
8415 }
8416
8417 static inline void
8418 __lpfc_sli4_release_queue(struct lpfc_queue **qp)
8419 {
8420 if (*qp != NULL) {
8421 lpfc_sli4_queue_free(*qp);
8422 *qp = NULL;
8423 }
8424 }
8425
8426 static inline void
8427 lpfc_sli4_release_queues(struct lpfc_queue ***qs, int max)
8428 {
8429 int idx;
8430
8431 if (*qs == NULL)
8432 return;
8433
8434 for (idx = 0; idx < max; idx++)
8435 __lpfc_sli4_release_queue(&(*qs)[idx]);
8436
8437 kfree(*qs);
8438 *qs = NULL;
8439 }
8440
8441 static inline void
8442 lpfc_sli4_release_queue_map(uint16_t **qmap)
8443 {
8444 if (*qmap != NULL) {
8445 kfree(*qmap);
8446 *qmap = NULL;
8447 }
8448 }
8449
8450 /**
8451 * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
8452 * @phba: pointer to lpfc hba data structure.
8453 *
8454 * This routine is invoked to release all the SLI4 queues with the FCoE HBA
8455 * operation.
8456 *
8457 * Return codes
8458 * 0 - successful
8459 * -ENOMEM - No available memory
8460 * -EIO - The mailbox failed to complete successfully.
8461 **/
8462 void
8463 lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
8464 {
8465 if (phba->cfg_fof)
8466 lpfc_fof_queue_destroy(phba);
8467
8468 /* Release HBA eqs */
8469 lpfc_sli4_release_queues(&phba->sli4_hba.hba_eq, phba->io_channel_irqs);
8470
8471 /* Release FCP cqs */
8472 lpfc_sli4_release_queues(&phba->sli4_hba.fcp_cq,
8473 phba->cfg_fcp_io_channel);
8474
8475 /* Release FCP wqs */
8476 lpfc_sli4_release_queues(&phba->sli4_hba.fcp_wq,
8477 phba->cfg_fcp_io_channel);
8478
8479 /* Release FCP CQ mapping array */
8480 lpfc_sli4_release_queue_map(&phba->sli4_hba.fcp_cq_map);
8481
8482 /* Release NVME cqs */
8483 lpfc_sli4_release_queues(&phba->sli4_hba.nvme_cq,
8484 phba->cfg_nvme_io_channel);
8485
8486 /* Release NVME wqs */
8487 lpfc_sli4_release_queues(&phba->sli4_hba.nvme_wq,
8488 phba->cfg_nvme_io_channel);
8489
8490 /* Release NVME CQ mapping array */
8491 lpfc_sli4_release_queue_map(&phba->sli4_hba.nvme_cq_map);
8492
8493 if (phba->nvmet_support) {
8494 lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_cqset,
8495 phba->cfg_nvmet_mrq);
8496
8497 lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_mrq_hdr,
8498 phba->cfg_nvmet_mrq);
8499 lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_mrq_data,
8500 phba->cfg_nvmet_mrq);
8501 }
8502
8503 /* Release mailbox command work queue */
8504 __lpfc_sli4_release_queue(&phba->sli4_hba.mbx_wq);
8505
8506 /* Release ELS work queue */
8507 __lpfc_sli4_release_queue(&phba->sli4_hba.els_wq);
8508
8509 /* Release ELS work queue */
8510 __lpfc_sli4_release_queue(&phba->sli4_hba.nvmels_wq);
8511
8512 /* Release unsolicited receive queue */
8513 __lpfc_sli4_release_queue(&phba->sli4_hba.hdr_rq);
8514 __lpfc_sli4_release_queue(&phba->sli4_hba.dat_rq);
8515
8516 /* Release ELS complete queue */
8517 __lpfc_sli4_release_queue(&phba->sli4_hba.els_cq);
8518
8519 /* Release NVME LS complete queue */
8520 __lpfc_sli4_release_queue(&phba->sli4_hba.nvmels_cq);
8521
8522 /* Release mailbox command complete queue */
8523 __lpfc_sli4_release_queue(&phba->sli4_hba.mbx_cq);
8524
8525 /* Everything on this list has been freed */
8526 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_wq_list);
8527 }
8528
8529 int
8530 lpfc_free_rq_buffer(struct lpfc_hba *phba, struct lpfc_queue *rq)
8531 {
8532 struct lpfc_rqb *rqbp;
8533 struct lpfc_dmabuf *h_buf;
8534 struct rqb_dmabuf *rqb_buffer;
8535
8536 rqbp = rq->rqbp;
8537 while (!list_empty(&rqbp->rqb_buffer_list)) {
8538 list_remove_head(&rqbp->rqb_buffer_list, h_buf,
8539 struct lpfc_dmabuf, list);
8540
8541 rqb_buffer = container_of(h_buf, struct rqb_dmabuf, hbuf);
8542 (rqbp->rqb_free_buffer)(phba, rqb_buffer);
8543 rqbp->buffer_count--;
8544 }
8545 return 1;
8546 }
8547
8548 static int
8549 lpfc_create_wq_cq(struct lpfc_hba *phba, struct lpfc_queue *eq,
8550 struct lpfc_queue *cq, struct lpfc_queue *wq, uint16_t *cq_map,
8551 int qidx, uint32_t qtype)
8552 {
8553 struct lpfc_sli_ring *pring;
8554 int rc;
8555
8556 if (!eq || !cq || !wq) {
8557 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8558 "6085 Fast-path %s (%d) not allocated\n",
8559 ((eq) ? ((cq) ? "WQ" : "CQ") : "EQ"), qidx);
8560 return -ENOMEM;
8561 }
8562
8563 /* create the Cq first */
8564 rc = lpfc_cq_create(phba, cq, eq,
8565 (qtype == LPFC_MBOX) ? LPFC_MCQ : LPFC_WCQ, qtype);
8566 if (rc) {
8567 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8568 "6086 Failed setup of CQ (%d), rc = 0x%x\n",
8569 qidx, (uint32_t)rc);
8570 return rc;
8571 }
8572 cq->chann = qidx;
8573
8574 if (qtype != LPFC_MBOX) {
8575 /* Setup nvme_cq_map for fast lookup */
8576 if (cq_map)
8577 *cq_map = cq->queue_id;
8578
8579 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8580 "6087 CQ setup: cq[%d]-id=%d, parent eq[%d]-id=%d\n",
8581 qidx, cq->queue_id, qidx, eq->queue_id);
8582
8583 /* create the wq */
8584 rc = lpfc_wq_create(phba, wq, cq, qtype);
8585 if (rc) {
8586 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8587 "6123 Fail setup fastpath WQ (%d), rc = 0x%x\n",
8588 qidx, (uint32_t)rc);
8589 /* no need to tear down cq - caller will do so */
8590 return rc;
8591 }
8592 wq->chann = qidx;
8593
8594 /* Bind this CQ/WQ to the NVME ring */
8595 pring = wq->pring;
8596 pring->sli.sli4.wqp = (void *)wq;
8597 cq->pring = pring;
8598
8599 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8600 "2593 WQ setup: wq[%d]-id=%d assoc=%d, cq[%d]-id=%d\n",
8601 qidx, wq->queue_id, wq->assoc_qid, qidx, cq->queue_id);
8602 } else {
8603 rc = lpfc_mq_create(phba, wq, cq, LPFC_MBOX);
8604 if (rc) {
8605 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8606 "0539 Failed setup of slow-path MQ: "
8607 "rc = 0x%x\n", rc);
8608 /* no need to tear down cq - caller will do so */
8609 return rc;
8610 }
8611
8612 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8613 "2589 MBX MQ setup: wq-id=%d, parent cq-id=%d\n",
8614 phba->sli4_hba.mbx_wq->queue_id,
8615 phba->sli4_hba.mbx_cq->queue_id);
8616 }
8617
8618 return 0;
8619 }
8620
8621 /**
8622 * lpfc_sli4_queue_setup - Set up all the SLI4 queues
8623 * @phba: pointer to lpfc hba data structure.
8624 *
8625 * This routine is invoked to set up all the SLI4 queues for the FCoE HBA
8626 * operation.
8627 *
8628 * Return codes
8629 * 0 - successful
8630 * -ENOMEM - No available memory
8631 * -EIO - The mailbox failed to complete successfully.
8632 **/
8633 int
8634 lpfc_sli4_queue_setup(struct lpfc_hba *phba)
8635 {
8636 uint32_t shdr_status, shdr_add_status;
8637 union lpfc_sli4_cfg_shdr *shdr;
8638 LPFC_MBOXQ_t *mboxq;
8639 int qidx;
8640 uint32_t length, io_channel;
8641 int rc = -ENOMEM;
8642
8643 /* Check for dual-ULP support */
8644 mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
8645 if (!mboxq) {
8646 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8647 "3249 Unable to allocate memory for "
8648 "QUERY_FW_CFG mailbox command\n");
8649 return -ENOMEM;
8650 }
8651 length = (sizeof(struct lpfc_mbx_query_fw_config) -
8652 sizeof(struct lpfc_sli4_cfg_mhdr));
8653 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
8654 LPFC_MBOX_OPCODE_QUERY_FW_CFG,
8655 length, LPFC_SLI4_MBX_EMBED);
8656
8657 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
8658
8659 shdr = (union lpfc_sli4_cfg_shdr *)
8660 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
8661 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
8662 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
8663 if (shdr_status || shdr_add_status || rc) {
8664 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8665 "3250 QUERY_FW_CFG mailbox failed with status "
8666 "x%x add_status x%x, mbx status x%x\n",
8667 shdr_status, shdr_add_status, rc);
8668 if (rc != MBX_TIMEOUT)
8669 mempool_free(mboxq, phba->mbox_mem_pool);
8670 rc = -ENXIO;
8671 goto out_error;
8672 }
8673
8674 phba->sli4_hba.fw_func_mode =
8675 mboxq->u.mqe.un.query_fw_cfg.rsp.function_mode;
8676 phba->sli4_hba.ulp0_mode = mboxq->u.mqe.un.query_fw_cfg.rsp.ulp0_mode;
8677 phba->sli4_hba.ulp1_mode = mboxq->u.mqe.un.query_fw_cfg.rsp.ulp1_mode;
8678 phba->sli4_hba.physical_port =
8679 mboxq->u.mqe.un.query_fw_cfg.rsp.physical_port;
8680 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8681 "3251 QUERY_FW_CFG: func_mode:x%x, ulp0_mode:x%x, "
8682 "ulp1_mode:x%x\n", phba->sli4_hba.fw_func_mode,
8683 phba->sli4_hba.ulp0_mode, phba->sli4_hba.ulp1_mode);
8684
8685 if (rc != MBX_TIMEOUT)
8686 mempool_free(mboxq, phba->mbox_mem_pool);
8687
8688 /*
8689 * Set up HBA Event Queues (EQs)
8690 */
8691 io_channel = phba->io_channel_irqs;
8692
8693 /* Set up HBA event queue */
8694 if (io_channel && !phba->sli4_hba.hba_eq) {
8695 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8696 "3147 Fast-path EQs not allocated\n");
8697 rc = -ENOMEM;
8698 goto out_error;
8699 }
8700 for (qidx = 0; qidx < io_channel; qidx++) {
8701 if (!phba->sli4_hba.hba_eq[qidx]) {
8702 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8703 "0522 Fast-path EQ (%d) not "
8704 "allocated\n", qidx);
8705 rc = -ENOMEM;
8706 goto out_destroy;
8707 }
8708 rc = lpfc_eq_create(phba, phba->sli4_hba.hba_eq[qidx],
8709 phba->cfg_fcp_imax);
8710 if (rc) {
8711 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8712 "0523 Failed setup of fast-path EQ "
8713 "(%d), rc = 0x%x\n", qidx,
8714 (uint32_t)rc);
8715 goto out_destroy;
8716 }
8717 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8718 "2584 HBA EQ setup: queue[%d]-id=%d\n",
8719 qidx, phba->sli4_hba.hba_eq[qidx]->queue_id);
8720 }
8721
8722 if (phba->cfg_nvme_io_channel) {
8723 if (!phba->sli4_hba.nvme_cq || !phba->sli4_hba.nvme_wq) {
8724 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8725 "6084 Fast-path NVME %s array not allocated\n",
8726 (phba->sli4_hba.nvme_cq) ? "CQ" : "WQ");
8727 rc = -ENOMEM;
8728 goto out_destroy;
8729 }
8730
8731 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++) {
8732 rc = lpfc_create_wq_cq(phba,
8733 phba->sli4_hba.hba_eq[
8734 qidx % io_channel],
8735 phba->sli4_hba.nvme_cq[qidx],
8736 phba->sli4_hba.nvme_wq[qidx],
8737 &phba->sli4_hba.nvme_cq_map[qidx],
8738 qidx, LPFC_NVME);
8739 if (rc) {
8740 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8741 "6123 Failed to setup fastpath "
8742 "NVME WQ/CQ (%d), rc = 0x%x\n",
8743 qidx, (uint32_t)rc);
8744 goto out_destroy;
8745 }
8746 }
8747 }
8748
8749 if (phba->cfg_fcp_io_channel) {
8750 /* Set up fast-path FCP Response Complete Queue */
8751 if (!phba->sli4_hba.fcp_cq || !phba->sli4_hba.fcp_wq) {
8752 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8753 "3148 Fast-path FCP %s array not allocated\n",
8754 phba->sli4_hba.fcp_cq ? "WQ" : "CQ");
8755 rc = -ENOMEM;
8756 goto out_destroy;
8757 }
8758
8759 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++) {
8760 rc = lpfc_create_wq_cq(phba,
8761 phba->sli4_hba.hba_eq[
8762 qidx % io_channel],
8763 phba->sli4_hba.fcp_cq[qidx],
8764 phba->sli4_hba.fcp_wq[qidx],
8765 &phba->sli4_hba.fcp_cq_map[qidx],
8766 qidx, LPFC_FCP);
8767 if (rc) {
8768 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8769 "0535 Failed to setup fastpath "
8770 "FCP WQ/CQ (%d), rc = 0x%x\n",
8771 qidx, (uint32_t)rc);
8772 goto out_destroy;
8773 }
8774 }
8775 }
8776
8777 /*
8778 * Set up Slow Path Complete Queues (CQs)
8779 */
8780
8781 /* Set up slow-path MBOX CQ/MQ */
8782
8783 if (!phba->sli4_hba.mbx_cq || !phba->sli4_hba.mbx_wq) {
8784 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8785 "0528 %s not allocated\n",
8786 phba->sli4_hba.mbx_cq ?
8787 "Mailbox WQ" : "Mailbox CQ");
8788 rc = -ENOMEM;
8789 goto out_destroy;
8790 }
8791
8792 rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8793 phba->sli4_hba.mbx_cq,
8794 phba->sli4_hba.mbx_wq,
8795 NULL, 0, LPFC_MBOX);
8796 if (rc) {
8797 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8798 "0529 Failed setup of mailbox WQ/CQ: rc = 0x%x\n",
8799 (uint32_t)rc);
8800 goto out_destroy;
8801 }
8802 if (phba->nvmet_support) {
8803 if (!phba->sli4_hba.nvmet_cqset) {
8804 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8805 "3165 Fast-path NVME CQ Set "
8806 "array not allocated\n");
8807 rc = -ENOMEM;
8808 goto out_destroy;
8809 }
8810 if (phba->cfg_nvmet_mrq > 1) {
8811 rc = lpfc_cq_create_set(phba,
8812 phba->sli4_hba.nvmet_cqset,
8813 phba->sli4_hba.hba_eq,
8814 LPFC_WCQ, LPFC_NVMET);
8815 if (rc) {
8816 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8817 "3164 Failed setup of NVME CQ "
8818 "Set, rc = 0x%x\n",
8819 (uint32_t)rc);
8820 goto out_destroy;
8821 }
8822 } else {
8823 /* Set up NVMET Receive Complete Queue */
8824 rc = lpfc_cq_create(phba, phba->sli4_hba.nvmet_cqset[0],
8825 phba->sli4_hba.hba_eq[0],
8826 LPFC_WCQ, LPFC_NVMET);
8827 if (rc) {
8828 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8829 "6089 Failed setup NVMET CQ: "
8830 "rc = 0x%x\n", (uint32_t)rc);
8831 goto out_destroy;
8832 }
8833 phba->sli4_hba.nvmet_cqset[0]->chann = 0;
8834
8835 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8836 "6090 NVMET CQ setup: cq-id=%d, "
8837 "parent eq-id=%d\n",
8838 phba->sli4_hba.nvmet_cqset[0]->queue_id,
8839 phba->sli4_hba.hba_eq[0]->queue_id);
8840 }
8841 }
8842
8843 /* Set up slow-path ELS WQ/CQ */
8844 if (!phba->sli4_hba.els_cq || !phba->sli4_hba.els_wq) {
8845 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8846 "0530 ELS %s not allocated\n",
8847 phba->sli4_hba.els_cq ? "WQ" : "CQ");
8848 rc = -ENOMEM;
8849 goto out_destroy;
8850 }
8851 rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8852 phba->sli4_hba.els_cq,
8853 phba->sli4_hba.els_wq,
8854 NULL, 0, LPFC_ELS);
8855 if (rc) {
8856 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8857 "0529 Failed setup of ELS WQ/CQ: rc = 0x%x\n",
8858 (uint32_t)rc);
8859 goto out_destroy;
8860 }
8861 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8862 "2590 ELS WQ setup: wq-id=%d, parent cq-id=%d\n",
8863 phba->sli4_hba.els_wq->queue_id,
8864 phba->sli4_hba.els_cq->queue_id);
8865
8866 if (phba->cfg_nvme_io_channel) {
8867 /* Set up NVME LS Complete Queue */
8868 if (!phba->sli4_hba.nvmels_cq || !phba->sli4_hba.nvmels_wq) {
8869 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8870 "6091 LS %s not allocated\n",
8871 phba->sli4_hba.nvmels_cq ? "WQ" : "CQ");
8872 rc = -ENOMEM;
8873 goto out_destroy;
8874 }
8875 rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8876 phba->sli4_hba.nvmels_cq,
8877 phba->sli4_hba.nvmels_wq,
8878 NULL, 0, LPFC_NVME_LS);
8879 if (rc) {
8880 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8881 "0529 Failed setup of NVVME LS WQ/CQ: "
8882 "rc = 0x%x\n", (uint32_t)rc);
8883 goto out_destroy;
8884 }
8885
8886 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8887 "6096 ELS WQ setup: wq-id=%d, "
8888 "parent cq-id=%d\n",
8889 phba->sli4_hba.nvmels_wq->queue_id,
8890 phba->sli4_hba.nvmels_cq->queue_id);
8891 }
8892
8893 /*
8894 * Create NVMET Receive Queue (RQ)
8895 */
8896 if (phba->nvmet_support) {
8897 if ((!phba->sli4_hba.nvmet_cqset) ||
8898 (!phba->sli4_hba.nvmet_mrq_hdr) ||
8899 (!phba->sli4_hba.nvmet_mrq_data)) {
8900 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8901 "6130 MRQ CQ Queues not "
8902 "allocated\n");
8903 rc = -ENOMEM;
8904 goto out_destroy;
8905 }
8906 if (phba->cfg_nvmet_mrq > 1) {
8907 rc = lpfc_mrq_create(phba,
8908 phba->sli4_hba.nvmet_mrq_hdr,
8909 phba->sli4_hba.nvmet_mrq_data,
8910 phba->sli4_hba.nvmet_cqset,
8911 LPFC_NVMET);
8912 if (rc) {
8913 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8914 "6098 Failed setup of NVMET "
8915 "MRQ: rc = 0x%x\n",
8916 (uint32_t)rc);
8917 goto out_destroy;
8918 }
8919
8920 } else {
8921 rc = lpfc_rq_create(phba,
8922 phba->sli4_hba.nvmet_mrq_hdr[0],
8923 phba->sli4_hba.nvmet_mrq_data[0],
8924 phba->sli4_hba.nvmet_cqset[0],
8925 LPFC_NVMET);
8926 if (rc) {
8927 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8928 "6057 Failed setup of NVMET "
8929 "Receive Queue: rc = 0x%x\n",
8930 (uint32_t)rc);
8931 goto out_destroy;
8932 }
8933
8934 lpfc_printf_log(
8935 phba, KERN_INFO, LOG_INIT,
8936 "6099 NVMET RQ setup: hdr-rq-id=%d, "
8937 "dat-rq-id=%d parent cq-id=%d\n",
8938 phba->sli4_hba.nvmet_mrq_hdr[0]->queue_id,
8939 phba->sli4_hba.nvmet_mrq_data[0]->queue_id,
8940 phba->sli4_hba.nvmet_cqset[0]->queue_id);
8941
8942 }
8943 }
8944
8945 if (!phba->sli4_hba.hdr_rq || !phba->sli4_hba.dat_rq) {
8946 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8947 "0540 Receive Queue not allocated\n");
8948 rc = -ENOMEM;
8949 goto out_destroy;
8950 }
8951
8952 rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
8953 phba->sli4_hba.els_cq, LPFC_USOL);
8954 if (rc) {
8955 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8956 "0541 Failed setup of Receive Queue: "
8957 "rc = 0x%x\n", (uint32_t)rc);
8958 goto out_destroy;
8959 }
8960
8961 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8962 "2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d "
8963 "parent cq-id=%d\n",
8964 phba->sli4_hba.hdr_rq->queue_id,
8965 phba->sli4_hba.dat_rq->queue_id,
8966 phba->sli4_hba.els_cq->queue_id);
8967
8968 if (phba->cfg_fof) {
8969 rc = lpfc_fof_queue_setup(phba);
8970 if (rc) {
8971 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8972 "0549 Failed setup of FOF Queues: "
8973 "rc = 0x%x\n", rc);
8974 goto out_destroy;
8975 }
8976 }
8977
8978 for (qidx = 0; qidx < io_channel; qidx += LPFC_MAX_EQ_DELAY_EQID_CNT)
8979 lpfc_modify_hba_eq_delay(phba, qidx, LPFC_MAX_EQ_DELAY_EQID_CNT,
8980 phba->cfg_fcp_imax);
8981
8982 return 0;
8983
8984 out_destroy:
8985 lpfc_sli4_queue_unset(phba);
8986 out_error:
8987 return rc;
8988 }
8989
8990 /**
8991 * lpfc_sli4_queue_unset - Unset all the SLI4 queues
8992 * @phba: pointer to lpfc hba data structure.
8993 *
8994 * This routine is invoked to unset all the SLI4 queues with the FCoE HBA
8995 * operation.
8996 *
8997 * Return codes
8998 * 0 - successful
8999 * -ENOMEM - No available memory
9000 * -EIO - The mailbox failed to complete successfully.
9001 **/
9002 void
9003 lpfc_sli4_queue_unset(struct lpfc_hba *phba)
9004 {
9005 int qidx;
9006
9007 /* Unset the queues created for Flash Optimized Fabric operations */
9008 if (phba->cfg_fof)
9009 lpfc_fof_queue_destroy(phba);
9010
9011 /* Unset mailbox command work queue */
9012 if (phba->sli4_hba.mbx_wq)
9013 lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
9014
9015 /* Unset NVME LS work queue */
9016 if (phba->sli4_hba.nvmels_wq)
9017 lpfc_wq_destroy(phba, phba->sli4_hba.nvmels_wq);
9018
9019 /* Unset ELS work queue */
9020 if (phba->sli4_hba.els_wq)
9021 lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
9022
9023 /* Unset unsolicited receive queue */
9024 if (phba->sli4_hba.hdr_rq)
9025 lpfc_rq_destroy(phba, phba->sli4_hba.hdr_rq,
9026 phba->sli4_hba.dat_rq);
9027
9028 /* Unset FCP work queue */
9029 if (phba->sli4_hba.fcp_wq)
9030 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++)
9031 lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[qidx]);
9032
9033 /* Unset NVME work queue */
9034 if (phba->sli4_hba.nvme_wq) {
9035 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++)
9036 lpfc_wq_destroy(phba, phba->sli4_hba.nvme_wq[qidx]);
9037 }
9038
9039 /* Unset mailbox command complete queue */
9040 if (phba->sli4_hba.mbx_cq)
9041 lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
9042
9043 /* Unset ELS complete queue */
9044 if (phba->sli4_hba.els_cq)
9045 lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
9046
9047 /* Unset NVME LS complete queue */
9048 if (phba->sli4_hba.nvmels_cq)
9049 lpfc_cq_destroy(phba, phba->sli4_hba.nvmels_cq);
9050
9051 /* Unset NVME response complete queue */
9052 if (phba->sli4_hba.nvme_cq)
9053 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++)
9054 lpfc_cq_destroy(phba, phba->sli4_hba.nvme_cq[qidx]);
9055
9056 if (phba->nvmet_support) {
9057 /* Unset NVMET MRQ queue */
9058 if (phba->sli4_hba.nvmet_mrq_hdr) {
9059 for (qidx = 0; qidx < phba->cfg_nvmet_mrq; qidx++)
9060 lpfc_rq_destroy(
9061 phba,
9062 phba->sli4_hba.nvmet_mrq_hdr[qidx],
9063 phba->sli4_hba.nvmet_mrq_data[qidx]);
9064 }
9065
9066 /* Unset NVMET CQ Set complete queue */
9067 if (phba->sli4_hba.nvmet_cqset) {
9068 for (qidx = 0; qidx < phba->cfg_nvmet_mrq; qidx++)
9069 lpfc_cq_destroy(
9070 phba, phba->sli4_hba.nvmet_cqset[qidx]);
9071 }
9072 }
9073
9074 /* Unset FCP response complete queue */
9075 if (phba->sli4_hba.fcp_cq)
9076 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++)
9077 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[qidx]);
9078
9079 /* Unset fast-path event queue */
9080 if (phba->sli4_hba.hba_eq)
9081 for (qidx = 0; qidx < phba->io_channel_irqs; qidx++)
9082 lpfc_eq_destroy(phba, phba->sli4_hba.hba_eq[qidx]);
9083 }
9084
9085 /**
9086 * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool
9087 * @phba: pointer to lpfc hba data structure.
9088 *
9089 * This routine is invoked to allocate and set up a pool of completion queue
9090 * events. The body of the completion queue event is a completion queue entry
9091 * CQE. For now, this pool is used for the interrupt service routine to queue
9092 * the following HBA completion queue events for the worker thread to process:
9093 * - Mailbox asynchronous events
9094 * - Receive queue completion unsolicited events
9095 * Later, this can be used for all the slow-path events.
9096 *
9097 * Return codes
9098 * 0 - successful
9099 * -ENOMEM - No available memory
9100 **/
9101 static int
9102 lpfc_sli4_cq_event_pool_create(struct lpfc_hba *phba)
9103 {
9104 struct lpfc_cq_event *cq_event;
9105 int i;
9106
9107 for (i = 0; i < (4 * phba->sli4_hba.cq_ecount); i++) {
9108 cq_event = kmalloc(sizeof(struct lpfc_cq_event), GFP_KERNEL);
9109 if (!cq_event)
9110 goto out_pool_create_fail;
9111 list_add_tail(&cq_event->list,
9112 &phba->sli4_hba.sp_cqe_event_pool);
9113 }
9114 return 0;
9115
9116 out_pool_create_fail:
9117 lpfc_sli4_cq_event_pool_destroy(phba);
9118 return -ENOMEM;
9119 }
9120
9121 /**
9122 * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool
9123 * @phba: pointer to lpfc hba data structure.
9124 *
9125 * This routine is invoked to free the pool of completion queue events at
9126 * driver unload time. Note that, it is the responsibility of the driver
9127 * cleanup routine to free all the outstanding completion-queue events
9128 * allocated from this pool back into the pool before invoking this routine
9129 * to destroy the pool.
9130 **/
9131 static void
9132 lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *phba)
9133 {
9134 struct lpfc_cq_event *cq_event, *next_cq_event;
9135
9136 list_for_each_entry_safe(cq_event, next_cq_event,
9137 &phba->sli4_hba.sp_cqe_event_pool, list) {
9138 list_del(&cq_event->list);
9139 kfree(cq_event);
9140 }
9141 }
9142
9143 /**
9144 * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
9145 * @phba: pointer to lpfc hba data structure.
9146 *
9147 * This routine is the lock free version of the API invoked to allocate a
9148 * completion-queue event from the free pool.
9149 *
9150 * Return: Pointer to the newly allocated completion-queue event if successful
9151 * NULL otherwise.
9152 **/
9153 struct lpfc_cq_event *
9154 __lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
9155 {
9156 struct lpfc_cq_event *cq_event = NULL;
9157
9158 list_remove_head(&phba->sli4_hba.sp_cqe_event_pool, cq_event,
9159 struct lpfc_cq_event, list);
9160 return cq_event;
9161 }
9162
9163 /**
9164 * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
9165 * @phba: pointer to lpfc hba data structure.
9166 *
9167 * This routine is the lock version of the API invoked to allocate a
9168 * completion-queue event from the free pool.
9169 *
9170 * Return: Pointer to the newly allocated completion-queue event if successful
9171 * NULL otherwise.
9172 **/
9173 struct lpfc_cq_event *
9174 lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
9175 {
9176 struct lpfc_cq_event *cq_event;
9177 unsigned long iflags;
9178
9179 spin_lock_irqsave(&phba->hbalock, iflags);
9180 cq_event = __lpfc_sli4_cq_event_alloc(phba);
9181 spin_unlock_irqrestore(&phba->hbalock, iflags);
9182 return cq_event;
9183 }
9184
9185 /**
9186 * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
9187 * @phba: pointer to lpfc hba data structure.
9188 * @cq_event: pointer to the completion queue event to be freed.
9189 *
9190 * This routine is the lock free version of the API invoked to release a
9191 * completion-queue event back into the free pool.
9192 **/
9193 void
9194 __lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
9195 struct lpfc_cq_event *cq_event)
9196 {
9197 list_add_tail(&cq_event->list, &phba->sli4_hba.sp_cqe_event_pool);
9198 }
9199
9200 /**
9201 * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
9202 * @phba: pointer to lpfc hba data structure.
9203 * @cq_event: pointer to the completion queue event to be freed.
9204 *
9205 * This routine is the lock version of the API invoked to release a
9206 * completion-queue event back into the free pool.
9207 **/
9208 void
9209 lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
9210 struct lpfc_cq_event *cq_event)
9211 {
9212 unsigned long iflags;
9213 spin_lock_irqsave(&phba->hbalock, iflags);
9214 __lpfc_sli4_cq_event_release(phba, cq_event);
9215 spin_unlock_irqrestore(&phba->hbalock, iflags);
9216 }
9217
9218 /**
9219 * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool
9220 * @phba: pointer to lpfc hba data structure.
9221 *
9222 * This routine is to free all the pending completion-queue events to the
9223 * back into the free pool for device reset.
9224 **/
9225 static void
9226 lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba)
9227 {
9228 LIST_HEAD(cqelist);
9229 struct lpfc_cq_event *cqe;
9230 unsigned long iflags;
9231
9232 /* Retrieve all the pending WCQEs from pending WCQE lists */
9233 spin_lock_irqsave(&phba->hbalock, iflags);
9234 /* Pending FCP XRI abort events */
9235 list_splice_init(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue,
9236 &cqelist);
9237 /* Pending ELS XRI abort events */
9238 list_splice_init(&phba->sli4_hba.sp_els_xri_aborted_work_queue,
9239 &cqelist);
9240 /* Pending asynnc events */
9241 list_splice_init(&phba->sli4_hba.sp_asynce_work_queue,
9242 &cqelist);
9243 spin_unlock_irqrestore(&phba->hbalock, iflags);
9244
9245 while (!list_empty(&cqelist)) {
9246 list_remove_head(&cqelist, cqe, struct lpfc_cq_event, list);
9247 lpfc_sli4_cq_event_release(phba, cqe);
9248 }
9249 }
9250
9251 /**
9252 * lpfc_pci_function_reset - Reset pci function.
9253 * @phba: pointer to lpfc hba data structure.
9254 *
9255 * This routine is invoked to request a PCI function reset. It will destroys
9256 * all resources assigned to the PCI function which originates this request.
9257 *
9258 * Return codes
9259 * 0 - successful
9260 * -ENOMEM - No available memory
9261 * -EIO - The mailbox failed to complete successfully.
9262 **/
9263 int
9264 lpfc_pci_function_reset(struct lpfc_hba *phba)
9265 {
9266 LPFC_MBOXQ_t *mboxq;
9267 uint32_t rc = 0, if_type;
9268 uint32_t shdr_status, shdr_add_status;
9269 uint32_t rdy_chk;
9270 uint32_t port_reset = 0;
9271 union lpfc_sli4_cfg_shdr *shdr;
9272 struct lpfc_register reg_data;
9273 uint16_t devid;
9274
9275 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9276 switch (if_type) {
9277 case LPFC_SLI_INTF_IF_TYPE_0:
9278 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
9279 GFP_KERNEL);
9280 if (!mboxq) {
9281 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9282 "0494 Unable to allocate memory for "
9283 "issuing SLI_FUNCTION_RESET mailbox "
9284 "command\n");
9285 return -ENOMEM;
9286 }
9287
9288 /* Setup PCI function reset mailbox-ioctl command */
9289 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
9290 LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
9291 LPFC_SLI4_MBX_EMBED);
9292 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
9293 shdr = (union lpfc_sli4_cfg_shdr *)
9294 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
9295 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
9296 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
9297 &shdr->response);
9298 if (rc != MBX_TIMEOUT)
9299 mempool_free(mboxq, phba->mbox_mem_pool);
9300 if (shdr_status || shdr_add_status || rc) {
9301 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9302 "0495 SLI_FUNCTION_RESET mailbox "
9303 "failed with status x%x add_status x%x,"
9304 " mbx status x%x\n",
9305 shdr_status, shdr_add_status, rc);
9306 rc = -ENXIO;
9307 }
9308 break;
9309 case LPFC_SLI_INTF_IF_TYPE_2:
9310 wait:
9311 /*
9312 * Poll the Port Status Register and wait for RDY for
9313 * up to 30 seconds. If the port doesn't respond, treat
9314 * it as an error.
9315 */
9316 for (rdy_chk = 0; rdy_chk < 1500; rdy_chk++) {
9317 if (lpfc_readl(phba->sli4_hba.u.if_type2.
9318 STATUSregaddr, &reg_data.word0)) {
9319 rc = -ENODEV;
9320 goto out;
9321 }
9322 if (bf_get(lpfc_sliport_status_rdy, &reg_data))
9323 break;
9324 msleep(20);
9325 }
9326
9327 if (!bf_get(lpfc_sliport_status_rdy, &reg_data)) {
9328 phba->work_status[0] = readl(
9329 phba->sli4_hba.u.if_type2.ERR1regaddr);
9330 phba->work_status[1] = readl(
9331 phba->sli4_hba.u.if_type2.ERR2regaddr);
9332 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9333 "2890 Port not ready, port status reg "
9334 "0x%x error 1=0x%x, error 2=0x%x\n",
9335 reg_data.word0,
9336 phba->work_status[0],
9337 phba->work_status[1]);
9338 rc = -ENODEV;
9339 goto out;
9340 }
9341
9342 if (!port_reset) {
9343 /*
9344 * Reset the port now
9345 */
9346 reg_data.word0 = 0;
9347 bf_set(lpfc_sliport_ctrl_end, &reg_data,
9348 LPFC_SLIPORT_LITTLE_ENDIAN);
9349 bf_set(lpfc_sliport_ctrl_ip, &reg_data,
9350 LPFC_SLIPORT_INIT_PORT);
9351 writel(reg_data.word0, phba->sli4_hba.u.if_type2.
9352 CTRLregaddr);
9353 /* flush */
9354 pci_read_config_word(phba->pcidev,
9355 PCI_DEVICE_ID, &devid);
9356
9357 port_reset = 1;
9358 msleep(20);
9359 goto wait;
9360 } else if (bf_get(lpfc_sliport_status_rn, &reg_data)) {
9361 rc = -ENODEV;
9362 goto out;
9363 }
9364 break;
9365
9366 case LPFC_SLI_INTF_IF_TYPE_1:
9367 default:
9368 break;
9369 }
9370
9371 out:
9372 /* Catch the not-ready port failure after a port reset. */
9373 if (rc) {
9374 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9375 "3317 HBA not functional: IP Reset Failed "
9376 "try: echo fw_reset > board_mode\n");
9377 rc = -ENODEV;
9378 }
9379
9380 return rc;
9381 }
9382
9383 /**
9384 * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space.
9385 * @phba: pointer to lpfc hba data structure.
9386 *
9387 * This routine is invoked to set up the PCI device memory space for device
9388 * with SLI-4 interface spec.
9389 *
9390 * Return codes
9391 * 0 - successful
9392 * other values - error
9393 **/
9394 static int
9395 lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
9396 {
9397 struct pci_dev *pdev;
9398 unsigned long bar0map_len, bar1map_len, bar2map_len;
9399 int error = -ENODEV;
9400 uint32_t if_type;
9401
9402 /* Obtain PCI device reference */
9403 if (!phba->pcidev)
9404 return error;
9405 else
9406 pdev = phba->pcidev;
9407
9408 /* Set the device DMA mask size */
9409 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
9410 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
9411 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
9412 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
9413 return error;
9414 }
9415 }
9416
9417 /*
9418 * The BARs and register set definitions and offset locations are
9419 * dependent on the if_type.
9420 */
9421 if (pci_read_config_dword(pdev, LPFC_SLI_INTF,
9422 &phba->sli4_hba.sli_intf.word0)) {
9423 return error;
9424 }
9425
9426 /* There is no SLI3 failback for SLI4 devices. */
9427 if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) !=
9428 LPFC_SLI_INTF_VALID) {
9429 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9430 "2894 SLI_INTF reg contents invalid "
9431 "sli_intf reg 0x%x\n",
9432 phba->sli4_hba.sli_intf.word0);
9433 return error;
9434 }
9435
9436 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9437 /*
9438 * Get the bus address of SLI4 device Bar regions and the
9439 * number of bytes required by each mapping. The mapping of the
9440 * particular PCI BARs regions is dependent on the type of
9441 * SLI4 device.
9442 */
9443 if (pci_resource_start(pdev, PCI_64BIT_BAR0)) {
9444 phba->pci_bar0_map = pci_resource_start(pdev, PCI_64BIT_BAR0);
9445 bar0map_len = pci_resource_len(pdev, PCI_64BIT_BAR0);
9446
9447 /*
9448 * Map SLI4 PCI Config Space Register base to a kernel virtual
9449 * addr
9450 */
9451 phba->sli4_hba.conf_regs_memmap_p =
9452 ioremap(phba->pci_bar0_map, bar0map_len);
9453 if (!phba->sli4_hba.conf_regs_memmap_p) {
9454 dev_printk(KERN_ERR, &pdev->dev,
9455 "ioremap failed for SLI4 PCI config "
9456 "registers.\n");
9457 goto out;
9458 }
9459 phba->pci_bar0_memmap_p = phba->sli4_hba.conf_regs_memmap_p;
9460 /* Set up BAR0 PCI config space register memory map */
9461 lpfc_sli4_bar0_register_memmap(phba, if_type);
9462 } else {
9463 phba->pci_bar0_map = pci_resource_start(pdev, 1);
9464 bar0map_len = pci_resource_len(pdev, 1);
9465 if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
9466 dev_printk(KERN_ERR, &pdev->dev,
9467 "FATAL - No BAR0 mapping for SLI4, if_type 2\n");
9468 goto out;
9469 }
9470 phba->sli4_hba.conf_regs_memmap_p =
9471 ioremap(phba->pci_bar0_map, bar0map_len);
9472 if (!phba->sli4_hba.conf_regs_memmap_p) {
9473 dev_printk(KERN_ERR, &pdev->dev,
9474 "ioremap failed for SLI4 PCI config "
9475 "registers.\n");
9476 goto out;
9477 }
9478 lpfc_sli4_bar0_register_memmap(phba, if_type);
9479 }
9480
9481 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
9482 if (pci_resource_start(pdev, PCI_64BIT_BAR2)) {
9483 /*
9484 * Map SLI4 if type 0 HBA Control Register base to a
9485 * kernel virtual address and setup the registers.
9486 */
9487 phba->pci_bar1_map = pci_resource_start(pdev,
9488 PCI_64BIT_BAR2);
9489 bar1map_len = pci_resource_len(pdev, PCI_64BIT_BAR2);
9490 phba->sli4_hba.ctrl_regs_memmap_p =
9491 ioremap(phba->pci_bar1_map,
9492 bar1map_len);
9493 if (!phba->sli4_hba.ctrl_regs_memmap_p) {
9494 dev_err(&pdev->dev,
9495 "ioremap failed for SLI4 HBA "
9496 "control registers.\n");
9497 error = -ENOMEM;
9498 goto out_iounmap_conf;
9499 }
9500 phba->pci_bar2_memmap_p =
9501 phba->sli4_hba.ctrl_regs_memmap_p;
9502 lpfc_sli4_bar1_register_memmap(phba);
9503 } else {
9504 error = -ENOMEM;
9505 goto out_iounmap_conf;
9506 }
9507 }
9508
9509 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
9510 if (pci_resource_start(pdev, PCI_64BIT_BAR4)) {
9511 /*
9512 * Map SLI4 if type 0 HBA Doorbell Register base to
9513 * a kernel virtual address and setup the registers.
9514 */
9515 phba->pci_bar2_map = pci_resource_start(pdev,
9516 PCI_64BIT_BAR4);
9517 bar2map_len = pci_resource_len(pdev, PCI_64BIT_BAR4);
9518 phba->sli4_hba.drbl_regs_memmap_p =
9519 ioremap(phba->pci_bar2_map,
9520 bar2map_len);
9521 if (!phba->sli4_hba.drbl_regs_memmap_p) {
9522 dev_err(&pdev->dev,
9523 "ioremap failed for SLI4 HBA"
9524 " doorbell registers.\n");
9525 error = -ENOMEM;
9526 goto out_iounmap_ctrl;
9527 }
9528 phba->pci_bar4_memmap_p =
9529 phba->sli4_hba.drbl_regs_memmap_p;
9530 error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
9531 if (error)
9532 goto out_iounmap_all;
9533 } else {
9534 error = -ENOMEM;
9535 goto out_iounmap_all;
9536 }
9537 }
9538
9539 return 0;
9540
9541 out_iounmap_all:
9542 iounmap(phba->sli4_hba.drbl_regs_memmap_p);
9543 out_iounmap_ctrl:
9544 iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
9545 out_iounmap_conf:
9546 iounmap(phba->sli4_hba.conf_regs_memmap_p);
9547 out:
9548 return error;
9549 }
9550
9551 /**
9552 * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space.
9553 * @phba: pointer to lpfc hba data structure.
9554 *
9555 * This routine is invoked to unset the PCI device memory space for device
9556 * with SLI-4 interface spec.
9557 **/
9558 static void
9559 lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba)
9560 {
9561 uint32_t if_type;
9562 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9563
9564 switch (if_type) {
9565 case LPFC_SLI_INTF_IF_TYPE_0:
9566 iounmap(phba->sli4_hba.drbl_regs_memmap_p);
9567 iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
9568 iounmap(phba->sli4_hba.conf_regs_memmap_p);
9569 break;
9570 case LPFC_SLI_INTF_IF_TYPE_2:
9571 iounmap(phba->sli4_hba.conf_regs_memmap_p);
9572 break;
9573 case LPFC_SLI_INTF_IF_TYPE_1:
9574 default:
9575 dev_printk(KERN_ERR, &phba->pcidev->dev,
9576 "FATAL - unsupported SLI4 interface type - %d\n",
9577 if_type);
9578 break;
9579 }
9580 }
9581
9582 /**
9583 * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
9584 * @phba: pointer to lpfc hba data structure.
9585 *
9586 * This routine is invoked to enable the MSI-X interrupt vectors to device
9587 * with SLI-3 interface specs.
9588 *
9589 * Return codes
9590 * 0 - successful
9591 * other values - error
9592 **/
9593 static int
9594 lpfc_sli_enable_msix(struct lpfc_hba *phba)
9595 {
9596 int rc;
9597 LPFC_MBOXQ_t *pmb;
9598
9599 /* Set up MSI-X multi-message vectors */
9600 rc = pci_alloc_irq_vectors(phba->pcidev,
9601 LPFC_MSIX_VECTORS, LPFC_MSIX_VECTORS, PCI_IRQ_MSIX);
9602 if (rc < 0) {
9603 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9604 "0420 PCI enable MSI-X failed (%d)\n", rc);
9605 goto vec_fail_out;
9606 }
9607
9608 /*
9609 * Assign MSI-X vectors to interrupt handlers
9610 */
9611
9612 /* vector-0 is associated to slow-path handler */
9613 rc = request_irq(pci_irq_vector(phba->pcidev, 0),
9614 &lpfc_sli_sp_intr_handler, 0,
9615 LPFC_SP_DRIVER_HANDLER_NAME, phba);
9616 if (rc) {
9617 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9618 "0421 MSI-X slow-path request_irq failed "
9619 "(%d)\n", rc);
9620 goto msi_fail_out;
9621 }
9622
9623 /* vector-1 is associated to fast-path handler */
9624 rc = request_irq(pci_irq_vector(phba->pcidev, 1),
9625 &lpfc_sli_fp_intr_handler, 0,
9626 LPFC_FP_DRIVER_HANDLER_NAME, phba);
9627
9628 if (rc) {
9629 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9630 "0429 MSI-X fast-path request_irq failed "
9631 "(%d)\n", rc);
9632 goto irq_fail_out;
9633 }
9634
9635 /*
9636 * Configure HBA MSI-X attention conditions to messages
9637 */
9638 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
9639
9640 if (!pmb) {
9641 rc = -ENOMEM;
9642 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9643 "0474 Unable to allocate memory for issuing "
9644 "MBOX_CONFIG_MSI command\n");
9645 goto mem_fail_out;
9646 }
9647 rc = lpfc_config_msi(phba, pmb);
9648 if (rc)
9649 goto mbx_fail_out;
9650 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
9651 if (rc != MBX_SUCCESS) {
9652 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
9653 "0351 Config MSI mailbox command failed, "
9654 "mbxCmd x%x, mbxStatus x%x\n",
9655 pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus);
9656 goto mbx_fail_out;
9657 }
9658
9659 /* Free memory allocated for mailbox command */
9660 mempool_free(pmb, phba->mbox_mem_pool);
9661 return rc;
9662
9663 mbx_fail_out:
9664 /* Free memory allocated for mailbox command */
9665 mempool_free(pmb, phba->mbox_mem_pool);
9666
9667 mem_fail_out:
9668 /* free the irq already requested */
9669 free_irq(pci_irq_vector(phba->pcidev, 1), phba);
9670
9671 irq_fail_out:
9672 /* free the irq already requested */
9673 free_irq(pci_irq_vector(phba->pcidev, 0), phba);
9674
9675 msi_fail_out:
9676 /* Unconfigure MSI-X capability structure */
9677 pci_free_irq_vectors(phba->pcidev);
9678
9679 vec_fail_out:
9680 return rc;
9681 }
9682
9683 /**
9684 * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
9685 * @phba: pointer to lpfc hba data structure.
9686 *
9687 * This routine is invoked to enable the MSI interrupt mode to device with
9688 * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
9689 * enable the MSI vector. The device driver is responsible for calling the
9690 * request_irq() to register MSI vector with a interrupt the handler, which
9691 * is done in this function.
9692 *
9693 * Return codes
9694 * 0 - successful
9695 * other values - error
9696 */
9697 static int
9698 lpfc_sli_enable_msi(struct lpfc_hba *phba)
9699 {
9700 int rc;
9701
9702 rc = pci_enable_msi(phba->pcidev);
9703 if (!rc)
9704 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9705 "0462 PCI enable MSI mode success.\n");
9706 else {
9707 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9708 "0471 PCI enable MSI mode failed (%d)\n", rc);
9709 return rc;
9710 }
9711
9712 rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
9713 0, LPFC_DRIVER_NAME, phba);
9714 if (rc) {
9715 pci_disable_msi(phba->pcidev);
9716 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9717 "0478 MSI request_irq failed (%d)\n", rc);
9718 }
9719 return rc;
9720 }
9721
9722 /**
9723 * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
9724 * @phba: pointer to lpfc hba data structure.
9725 *
9726 * This routine is invoked to enable device interrupt and associate driver's
9727 * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
9728 * spec. Depends on the interrupt mode configured to the driver, the driver
9729 * will try to fallback from the configured interrupt mode to an interrupt
9730 * mode which is supported by the platform, kernel, and device in the order
9731 * of:
9732 * MSI-X -> MSI -> IRQ.
9733 *
9734 * Return codes
9735 * 0 - successful
9736 * other values - error
9737 **/
9738 static uint32_t
9739 lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
9740 {
9741 uint32_t intr_mode = LPFC_INTR_ERROR;
9742 int retval;
9743
9744 if (cfg_mode == 2) {
9745 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
9746 retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3);
9747 if (!retval) {
9748 /* Now, try to enable MSI-X interrupt mode */
9749 retval = lpfc_sli_enable_msix(phba);
9750 if (!retval) {
9751 /* Indicate initialization to MSI-X mode */
9752 phba->intr_type = MSIX;
9753 intr_mode = 2;
9754 }
9755 }
9756 }
9757
9758 /* Fallback to MSI if MSI-X initialization failed */
9759 if (cfg_mode >= 1 && phba->intr_type == NONE) {
9760 retval = lpfc_sli_enable_msi(phba);
9761 if (!retval) {
9762 /* Indicate initialization to MSI mode */
9763 phba->intr_type = MSI;
9764 intr_mode = 1;
9765 }
9766 }
9767
9768 /* Fallback to INTx if both MSI-X/MSI initalization failed */
9769 if (phba->intr_type == NONE) {
9770 retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
9771 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
9772 if (!retval) {
9773 /* Indicate initialization to INTx mode */
9774 phba->intr_type = INTx;
9775 intr_mode = 0;
9776 }
9777 }
9778 return intr_mode;
9779 }
9780
9781 /**
9782 * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
9783 * @phba: pointer to lpfc hba data structure.
9784 *
9785 * This routine is invoked to disable device interrupt and disassociate the
9786 * driver's interrupt handler(s) from interrupt vector(s) to device with
9787 * SLI-3 interface spec. Depending on the interrupt mode, the driver will
9788 * release the interrupt vector(s) for the message signaled interrupt.
9789 **/
9790 static void
9791 lpfc_sli_disable_intr(struct lpfc_hba *phba)
9792 {
9793 int nr_irqs, i;
9794
9795 if (phba->intr_type == MSIX)
9796 nr_irqs = LPFC_MSIX_VECTORS;
9797 else
9798 nr_irqs = 1;
9799
9800 for (i = 0; i < nr_irqs; i++)
9801 free_irq(pci_irq_vector(phba->pcidev, i), phba);
9802 pci_free_irq_vectors(phba->pcidev);
9803
9804 /* Reset interrupt management states */
9805 phba->intr_type = NONE;
9806 phba->sli.slistat.sli_intr = 0;
9807 }
9808
9809 /**
9810 * lpfc_cpu_affinity_check - Check vector CPU affinity mappings
9811 * @phba: pointer to lpfc hba data structure.
9812 * @vectors: number of msix vectors allocated.
9813 *
9814 * The routine will figure out the CPU affinity assignment for every
9815 * MSI-X vector allocated for the HBA. The hba_eq_hdl will be updated
9816 * with a pointer to the CPU mask that defines ALL the CPUs this vector
9817 * can be associated with. If the vector can be unquely associated with
9818 * a single CPU, that CPU will be recorded in hba_eq_hdl[index].cpu.
9819 * In addition, the CPU to IO channel mapping will be calculated
9820 * and the phba->sli4_hba.cpu_map array will reflect this.
9821 */
9822 static void
9823 lpfc_cpu_affinity_check(struct lpfc_hba *phba, int vectors)
9824 {
9825 struct lpfc_vector_map_info *cpup;
9826 int index = 0;
9827 int vec = 0;
9828 int cpu;
9829 #ifdef CONFIG_X86
9830 struct cpuinfo_x86 *cpuinfo;
9831 #endif
9832
9833 /* Init cpu_map array */
9834 memset(phba->sli4_hba.cpu_map, 0xff,
9835 (sizeof(struct lpfc_vector_map_info) *
9836 phba->sli4_hba.num_present_cpu));
9837
9838 /* Update CPU map with physical id and core id of each CPU */
9839 cpup = phba->sli4_hba.cpu_map;
9840 for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
9841 #ifdef CONFIG_X86
9842 cpuinfo = &cpu_data(cpu);
9843 cpup->phys_id = cpuinfo->phys_proc_id;
9844 cpup->core_id = cpuinfo->cpu_core_id;
9845 #else
9846 /* No distinction between CPUs for other platforms */
9847 cpup->phys_id = 0;
9848 cpup->core_id = 0;
9849 #endif
9850 cpup->channel_id = index; /* For now round robin */
9851 cpup->irq = pci_irq_vector(phba->pcidev, vec);
9852 vec++;
9853 if (vec >= vectors)
9854 vec = 0;
9855 index++;
9856 if (index >= phba->cfg_fcp_io_channel)
9857 index = 0;
9858 cpup++;
9859 }
9860 }
9861
9862
9863 /**
9864 * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
9865 * @phba: pointer to lpfc hba data structure.
9866 *
9867 * This routine is invoked to enable the MSI-X interrupt vectors to device
9868 * with SLI-4 interface spec.
9869 *
9870 * Return codes
9871 * 0 - successful
9872 * other values - error
9873 **/
9874 static int
9875 lpfc_sli4_enable_msix(struct lpfc_hba *phba)
9876 {
9877 int vectors, rc, index;
9878 char *name;
9879
9880 /* Set up MSI-X multi-message vectors */
9881 vectors = phba->io_channel_irqs;
9882 if (phba->cfg_fof)
9883 vectors++;
9884
9885 rc = pci_alloc_irq_vectors(phba->pcidev,
9886 (phba->nvmet_support) ? 1 : 2,
9887 vectors, PCI_IRQ_MSIX | PCI_IRQ_AFFINITY);
9888 if (rc < 0) {
9889 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9890 "0484 PCI enable MSI-X failed (%d)\n", rc);
9891 goto vec_fail_out;
9892 }
9893 vectors = rc;
9894
9895 /* Assign MSI-X vectors to interrupt handlers */
9896 for (index = 0; index < vectors; index++) {
9897 name = phba->sli4_hba.hba_eq_hdl[index].handler_name;
9898 memset(name, 0, LPFC_SLI4_HANDLER_NAME_SZ);
9899 snprintf(name, LPFC_SLI4_HANDLER_NAME_SZ,
9900 LPFC_DRIVER_HANDLER_NAME"%d", index);
9901
9902 phba->sli4_hba.hba_eq_hdl[index].idx = index;
9903 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
9904 atomic_set(&phba->sli4_hba.hba_eq_hdl[index].hba_eq_in_use, 1);
9905 if (phba->cfg_fof && (index == (vectors - 1)))
9906 rc = request_irq(pci_irq_vector(phba->pcidev, index),
9907 &lpfc_sli4_fof_intr_handler, 0,
9908 name,
9909 &phba->sli4_hba.hba_eq_hdl[index]);
9910 else
9911 rc = request_irq(pci_irq_vector(phba->pcidev, index),
9912 &lpfc_sli4_hba_intr_handler, 0,
9913 name,
9914 &phba->sli4_hba.hba_eq_hdl[index]);
9915 if (rc) {
9916 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9917 "0486 MSI-X fast-path (%d) "
9918 "request_irq failed (%d)\n", index, rc);
9919 goto cfg_fail_out;
9920 }
9921 }
9922
9923 if (phba->cfg_fof)
9924 vectors--;
9925
9926 if (vectors != phba->io_channel_irqs) {
9927 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9928 "3238 Reducing IO channels to match number of "
9929 "MSI-X vectors, requested %d got %d\n",
9930 phba->io_channel_irqs, vectors);
9931 if (phba->cfg_fcp_io_channel > vectors)
9932 phba->cfg_fcp_io_channel = vectors;
9933 if (phba->cfg_nvme_io_channel > vectors)
9934 phba->cfg_nvme_io_channel = vectors;
9935 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
9936 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
9937 else
9938 phba->io_channel_irqs = phba->cfg_nvme_io_channel;
9939 }
9940 lpfc_cpu_affinity_check(phba, vectors);
9941
9942 return rc;
9943
9944 cfg_fail_out:
9945 /* free the irq already requested */
9946 for (--index; index >= 0; index--)
9947 free_irq(pci_irq_vector(phba->pcidev, index),
9948 &phba->sli4_hba.hba_eq_hdl[index]);
9949
9950 /* Unconfigure MSI-X capability structure */
9951 pci_free_irq_vectors(phba->pcidev);
9952
9953 vec_fail_out:
9954 return rc;
9955 }
9956
9957 /**
9958 * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device
9959 * @phba: pointer to lpfc hba data structure.
9960 *
9961 * This routine is invoked to enable the MSI interrupt mode to device with
9962 * SLI-4 interface spec. The kernel function pci_enable_msi() is called
9963 * to enable the MSI vector. The device driver is responsible for calling
9964 * the request_irq() to register MSI vector with a interrupt the handler,
9965 * which is done in this function.
9966 *
9967 * Return codes
9968 * 0 - successful
9969 * other values - error
9970 **/
9971 static int
9972 lpfc_sli4_enable_msi(struct lpfc_hba *phba)
9973 {
9974 int rc, index;
9975
9976 rc = pci_enable_msi(phba->pcidev);
9977 if (!rc)
9978 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9979 "0487 PCI enable MSI mode success.\n");
9980 else {
9981 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9982 "0488 PCI enable MSI mode failed (%d)\n", rc);
9983 return rc;
9984 }
9985
9986 rc = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
9987 0, LPFC_DRIVER_NAME, phba);
9988 if (rc) {
9989 pci_disable_msi(phba->pcidev);
9990 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9991 "0490 MSI request_irq failed (%d)\n", rc);
9992 return rc;
9993 }
9994
9995 for (index = 0; index < phba->io_channel_irqs; index++) {
9996 phba->sli4_hba.hba_eq_hdl[index].idx = index;
9997 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
9998 }
9999
10000 if (phba->cfg_fof) {
10001 phba->sli4_hba.hba_eq_hdl[index].idx = index;
10002 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
10003 }
10004 return 0;
10005 }
10006
10007 /**
10008 * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
10009 * @phba: pointer to lpfc hba data structure.
10010 *
10011 * This routine is invoked to enable device interrupt and associate driver's
10012 * interrupt handler(s) to interrupt vector(s) to device with SLI-4
10013 * interface spec. Depends on the interrupt mode configured to the driver,
10014 * the driver will try to fallback from the configured interrupt mode to an
10015 * interrupt mode which is supported by the platform, kernel, and device in
10016 * the order of:
10017 * MSI-X -> MSI -> IRQ.
10018 *
10019 * Return codes
10020 * 0 - successful
10021 * other values - error
10022 **/
10023 static uint32_t
10024 lpfc_sli4_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
10025 {
10026 uint32_t intr_mode = LPFC_INTR_ERROR;
10027 int retval, idx;
10028
10029 if (cfg_mode == 2) {
10030 /* Preparation before conf_msi mbox cmd */
10031 retval = 0;
10032 if (!retval) {
10033 /* Now, try to enable MSI-X interrupt mode */
10034 retval = lpfc_sli4_enable_msix(phba);
10035 if (!retval) {
10036 /* Indicate initialization to MSI-X mode */
10037 phba->intr_type = MSIX;
10038 intr_mode = 2;
10039 }
10040 }
10041 }
10042
10043 /* Fallback to MSI if MSI-X initialization failed */
10044 if (cfg_mode >= 1 && phba->intr_type == NONE) {
10045 retval = lpfc_sli4_enable_msi(phba);
10046 if (!retval) {
10047 /* Indicate initialization to MSI mode */
10048 phba->intr_type = MSI;
10049 intr_mode = 1;
10050 }
10051 }
10052
10053 /* Fallback to INTx if both MSI-X/MSI initalization failed */
10054 if (phba->intr_type == NONE) {
10055 retval = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
10056 IRQF_SHARED, LPFC_DRIVER_NAME, phba);
10057 if (!retval) {
10058 struct lpfc_hba_eq_hdl *eqhdl;
10059
10060 /* Indicate initialization to INTx mode */
10061 phba->intr_type = INTx;
10062 intr_mode = 0;
10063
10064 for (idx = 0; idx < phba->io_channel_irqs; idx++) {
10065 eqhdl = &phba->sli4_hba.hba_eq_hdl[idx];
10066 eqhdl->idx = idx;
10067 eqhdl->phba = phba;
10068 atomic_set(&eqhdl->hba_eq_in_use, 1);
10069 }
10070 if (phba->cfg_fof) {
10071 eqhdl = &phba->sli4_hba.hba_eq_hdl[idx];
10072 eqhdl->idx = idx;
10073 eqhdl->phba = phba;
10074 atomic_set(&eqhdl->hba_eq_in_use, 1);
10075 }
10076 }
10077 }
10078 return intr_mode;
10079 }
10080
10081 /**
10082 * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device
10083 * @phba: pointer to lpfc hba data structure.
10084 *
10085 * This routine is invoked to disable device interrupt and disassociate
10086 * the driver's interrupt handler(s) from interrupt vector(s) to device
10087 * with SLI-4 interface spec. Depending on the interrupt mode, the driver
10088 * will release the interrupt vector(s) for the message signaled interrupt.
10089 **/
10090 static void
10091 lpfc_sli4_disable_intr(struct lpfc_hba *phba)
10092 {
10093 /* Disable the currently initialized interrupt mode */
10094 if (phba->intr_type == MSIX) {
10095 int index;
10096
10097 /* Free up MSI-X multi-message vectors */
10098 for (index = 0; index < phba->io_channel_irqs; index++)
10099 free_irq(pci_irq_vector(phba->pcidev, index),
10100 &phba->sli4_hba.hba_eq_hdl[index]);
10101
10102 if (phba->cfg_fof)
10103 free_irq(pci_irq_vector(phba->pcidev, index),
10104 &phba->sli4_hba.hba_eq_hdl[index]);
10105 } else {
10106 free_irq(phba->pcidev->irq, phba);
10107 }
10108
10109 pci_free_irq_vectors(phba->pcidev);
10110
10111 /* Reset interrupt management states */
10112 phba->intr_type = NONE;
10113 phba->sli.slistat.sli_intr = 0;
10114 }
10115
10116 /**
10117 * lpfc_unset_hba - Unset SLI3 hba device initialization
10118 * @phba: pointer to lpfc hba data structure.
10119 *
10120 * This routine is invoked to unset the HBA device initialization steps to
10121 * a device with SLI-3 interface spec.
10122 **/
10123 static void
10124 lpfc_unset_hba(struct lpfc_hba *phba)
10125 {
10126 struct lpfc_vport *vport = phba->pport;
10127 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
10128
10129 spin_lock_irq(shost->host_lock);
10130 vport->load_flag |= FC_UNLOADING;
10131 spin_unlock_irq(shost->host_lock);
10132
10133 kfree(phba->vpi_bmask);
10134 kfree(phba->vpi_ids);
10135
10136 lpfc_stop_hba_timers(phba);
10137
10138 phba->pport->work_port_events = 0;
10139
10140 lpfc_sli_hba_down(phba);
10141
10142 lpfc_sli_brdrestart(phba);
10143
10144 lpfc_sli_disable_intr(phba);
10145
10146 return;
10147 }
10148
10149 /**
10150 * lpfc_sli4_xri_exchange_busy_wait - Wait for device XRI exchange busy
10151 * @phba: Pointer to HBA context object.
10152 *
10153 * This function is called in the SLI4 code path to wait for completion
10154 * of device's XRIs exchange busy. It will check the XRI exchange busy
10155 * on outstanding FCP and ELS I/Os every 10ms for up to 10 seconds; after
10156 * that, it will check the XRI exchange busy on outstanding FCP and ELS
10157 * I/Os every 30 seconds, log error message, and wait forever. Only when
10158 * all XRI exchange busy complete, the driver unload shall proceed with
10159 * invoking the function reset ioctl mailbox command to the CNA and the
10160 * the rest of the driver unload resource release.
10161 **/
10162 static void
10163 lpfc_sli4_xri_exchange_busy_wait(struct lpfc_hba *phba)
10164 {
10165 int wait_time = 0;
10166 int nvme_xri_cmpl = 1;
10167 int nvmet_xri_cmpl = 1;
10168 int fcp_xri_cmpl = 1;
10169 int els_xri_cmpl = list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list);
10170
10171 /* Driver just aborted IOs during the hba_unset process. Pause
10172 * here to give the HBA time to complete the IO and get entries
10173 * into the abts lists.
10174 */
10175 msleep(LPFC_XRI_EXCH_BUSY_WAIT_T1 * 5);
10176
10177 /* Wait for NVME pending IO to flush back to transport. */
10178 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
10179 lpfc_nvme_wait_for_io_drain(phba);
10180
10181 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
10182 fcp_xri_cmpl =
10183 list_empty(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
10184 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
10185 nvme_xri_cmpl =
10186 list_empty(&phba->sli4_hba.lpfc_abts_nvme_buf_list);
10187 nvmet_xri_cmpl =
10188 list_empty(&phba->sli4_hba.lpfc_abts_nvmet_ctx_list);
10189 }
10190
10191 while (!fcp_xri_cmpl || !els_xri_cmpl || !nvme_xri_cmpl ||
10192 !nvmet_xri_cmpl) {
10193 if (wait_time > LPFC_XRI_EXCH_BUSY_WAIT_TMO) {
10194 if (!nvme_xri_cmpl)
10195 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10196 "6100 NVME XRI exchange busy "
10197 "wait time: %d seconds.\n",
10198 wait_time/1000);
10199 if (!fcp_xri_cmpl)
10200 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10201 "2877 FCP XRI exchange busy "
10202 "wait time: %d seconds.\n",
10203 wait_time/1000);
10204 if (!els_xri_cmpl)
10205 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10206 "2878 ELS XRI exchange busy "
10207 "wait time: %d seconds.\n",
10208 wait_time/1000);
10209 msleep(LPFC_XRI_EXCH_BUSY_WAIT_T2);
10210 wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T2;
10211 } else {
10212 msleep(LPFC_XRI_EXCH_BUSY_WAIT_T1);
10213 wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T1;
10214 }
10215 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
10216 nvme_xri_cmpl = list_empty(
10217 &phba->sli4_hba.lpfc_abts_nvme_buf_list);
10218 nvmet_xri_cmpl = list_empty(
10219 &phba->sli4_hba.lpfc_abts_nvmet_ctx_list);
10220 }
10221
10222 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
10223 fcp_xri_cmpl = list_empty(
10224 &phba->sli4_hba.lpfc_abts_scsi_buf_list);
10225
10226 els_xri_cmpl =
10227 list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list);
10228
10229 }
10230 }
10231
10232 /**
10233 * lpfc_sli4_hba_unset - Unset the fcoe hba
10234 * @phba: Pointer to HBA context object.
10235 *
10236 * This function is called in the SLI4 code path to reset the HBA's FCoE
10237 * function. The caller is not required to hold any lock. This routine
10238 * issues PCI function reset mailbox command to reset the FCoE function.
10239 * At the end of the function, it calls lpfc_hba_down_post function to
10240 * free any pending commands.
10241 **/
10242 static void
10243 lpfc_sli4_hba_unset(struct lpfc_hba *phba)
10244 {
10245 int wait_cnt = 0;
10246 LPFC_MBOXQ_t *mboxq;
10247 struct pci_dev *pdev = phba->pcidev;
10248
10249 lpfc_stop_hba_timers(phba);
10250 phba->sli4_hba.intr_enable = 0;
10251
10252 /*
10253 * Gracefully wait out the potential current outstanding asynchronous
10254 * mailbox command.
10255 */
10256
10257 /* First, block any pending async mailbox command from posted */
10258 spin_lock_irq(&phba->hbalock);
10259 phba->sli.sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
10260 spin_unlock_irq(&phba->hbalock);
10261 /* Now, trying to wait it out if we can */
10262 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
10263 msleep(10);
10264 if (++wait_cnt > LPFC_ACTIVE_MBOX_WAIT_CNT)
10265 break;
10266 }
10267 /* Forcefully release the outstanding mailbox command if timed out */
10268 if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
10269 spin_lock_irq(&phba->hbalock);
10270 mboxq = phba->sli.mbox_active;
10271 mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED;
10272 __lpfc_mbox_cmpl_put(phba, mboxq);
10273 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
10274 phba->sli.mbox_active = NULL;
10275 spin_unlock_irq(&phba->hbalock);
10276 }
10277
10278 /* Abort all iocbs associated with the hba */
10279 lpfc_sli_hba_iocb_abort(phba);
10280
10281 /* Wait for completion of device XRI exchange busy */
10282 lpfc_sli4_xri_exchange_busy_wait(phba);
10283
10284 /* Disable PCI subsystem interrupt */
10285 lpfc_sli4_disable_intr(phba);
10286
10287 /* Disable SR-IOV if enabled */
10288 if (phba->cfg_sriov_nr_virtfn)
10289 pci_disable_sriov(pdev);
10290
10291 /* Stop kthread signal shall trigger work_done one more time */
10292 kthread_stop(phba->worker_thread);
10293
10294 /* Unset the queues shared with the hardware then release all
10295 * allocated resources.
10296 */
10297 lpfc_sli4_queue_unset(phba);
10298 lpfc_sli4_queue_destroy(phba);
10299
10300 /* Reset SLI4 HBA FCoE function */
10301 lpfc_pci_function_reset(phba);
10302
10303 /* Stop the SLI4 device port */
10304 phba->pport->work_port_events = 0;
10305 }
10306
10307 /**
10308 * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
10309 * @phba: Pointer to HBA context object.
10310 * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
10311 *
10312 * This function is called in the SLI4 code path to read the port's
10313 * sli4 capabilities.
10314 *
10315 * This function may be be called from any context that can block-wait
10316 * for the completion. The expectation is that this routine is called
10317 * typically from probe_one or from the online routine.
10318 **/
10319 int
10320 lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
10321 {
10322 int rc;
10323 struct lpfc_mqe *mqe;
10324 struct lpfc_pc_sli4_params *sli4_params;
10325 uint32_t mbox_tmo;
10326
10327 rc = 0;
10328 mqe = &mboxq->u.mqe;
10329
10330 /* Read the port's SLI4 Parameters port capabilities */
10331 lpfc_pc_sli4_params(mboxq);
10332 if (!phba->sli4_hba.intr_enable)
10333 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
10334 else {
10335 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
10336 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
10337 }
10338
10339 if (unlikely(rc))
10340 return 1;
10341
10342 sli4_params = &phba->sli4_hba.pc_sli4_params;
10343 sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
10344 sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
10345 sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
10346 sli4_params->featurelevel_1 = bf_get(featurelevel_1,
10347 &mqe->un.sli4_params);
10348 sli4_params->featurelevel_2 = bf_get(featurelevel_2,
10349 &mqe->un.sli4_params);
10350 sli4_params->proto_types = mqe->un.sli4_params.word3;
10351 sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
10352 sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
10353 sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
10354 sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
10355 sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
10356 sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
10357 sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
10358 sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
10359 sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
10360 sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
10361 sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
10362 sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
10363 sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
10364 sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
10365 sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
10366 sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
10367 sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
10368 sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
10369 sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
10370 sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
10371
10372 /* Make sure that sge_supp_len can be handled by the driver */
10373 if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
10374 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
10375
10376 return rc;
10377 }
10378
10379 /**
10380 * lpfc_get_sli4_parameters - Get the SLI4 Config PARAMETERS.
10381 * @phba: Pointer to HBA context object.
10382 * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
10383 *
10384 * This function is called in the SLI4 code path to read the port's
10385 * sli4 capabilities.
10386 *
10387 * This function may be be called from any context that can block-wait
10388 * for the completion. The expectation is that this routine is called
10389 * typically from probe_one or from the online routine.
10390 **/
10391 int
10392 lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
10393 {
10394 int rc;
10395 struct lpfc_mqe *mqe = &mboxq->u.mqe;
10396 struct lpfc_pc_sli4_params *sli4_params;
10397 uint32_t mbox_tmo;
10398 int length;
10399 struct lpfc_sli4_parameters *mbx_sli4_parameters;
10400
10401 /*
10402 * By default, the driver assumes the SLI4 port requires RPI
10403 * header postings. The SLI4_PARAM response will correct this
10404 * assumption.
10405 */
10406 phba->sli4_hba.rpi_hdrs_in_use = 1;
10407
10408 /* Read the port's SLI4 Config Parameters */
10409 length = (sizeof(struct lpfc_mbx_get_sli4_parameters) -
10410 sizeof(struct lpfc_sli4_cfg_mhdr));
10411 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
10412 LPFC_MBOX_OPCODE_GET_SLI4_PARAMETERS,
10413 length, LPFC_SLI4_MBX_EMBED);
10414 if (!phba->sli4_hba.intr_enable)
10415 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
10416 else {
10417 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
10418 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
10419 }
10420 if (unlikely(rc))
10421 return rc;
10422 sli4_params = &phba->sli4_hba.pc_sli4_params;
10423 mbx_sli4_parameters = &mqe->un.get_sli4_parameters.sli4_parameters;
10424 sli4_params->if_type = bf_get(cfg_if_type, mbx_sli4_parameters);
10425 sli4_params->sli_rev = bf_get(cfg_sli_rev, mbx_sli4_parameters);
10426 sli4_params->sli_family = bf_get(cfg_sli_family, mbx_sli4_parameters);
10427 sli4_params->featurelevel_1 = bf_get(cfg_sli_hint_1,
10428 mbx_sli4_parameters);
10429 sli4_params->featurelevel_2 = bf_get(cfg_sli_hint_2,
10430 mbx_sli4_parameters);
10431 if (bf_get(cfg_phwq, mbx_sli4_parameters))
10432 phba->sli3_options |= LPFC_SLI4_PHWQ_ENABLED;
10433 else
10434 phba->sli3_options &= ~LPFC_SLI4_PHWQ_ENABLED;
10435 sli4_params->sge_supp_len = mbx_sli4_parameters->sge_supp_len;
10436 sli4_params->loopbk_scope = bf_get(loopbk_scope, mbx_sli4_parameters);
10437 sli4_params->oas_supported = bf_get(cfg_oas, mbx_sli4_parameters);
10438 sli4_params->cqv = bf_get(cfg_cqv, mbx_sli4_parameters);
10439 sli4_params->mqv = bf_get(cfg_mqv, mbx_sli4_parameters);
10440 sli4_params->wqv = bf_get(cfg_wqv, mbx_sli4_parameters);
10441 sli4_params->rqv = bf_get(cfg_rqv, mbx_sli4_parameters);
10442 sli4_params->wqsize = bf_get(cfg_wqsize, mbx_sli4_parameters);
10443 sli4_params->sgl_pages_max = bf_get(cfg_sgl_page_cnt,
10444 mbx_sli4_parameters);
10445 sli4_params->wqpcnt = bf_get(cfg_wqpcnt, mbx_sli4_parameters);
10446 sli4_params->sgl_pp_align = bf_get(cfg_sgl_pp_align,
10447 mbx_sli4_parameters);
10448 phba->sli4_hba.extents_in_use = bf_get(cfg_ext, mbx_sli4_parameters);
10449 phba->sli4_hba.rpi_hdrs_in_use = bf_get(cfg_hdrr, mbx_sli4_parameters);
10450 phba->nvme_support = (bf_get(cfg_nvme, mbx_sli4_parameters) &&
10451 bf_get(cfg_xib, mbx_sli4_parameters));
10452
10453 if ((phba->cfg_enable_fc4_type == LPFC_ENABLE_FCP) ||
10454 !phba->nvme_support) {
10455 phba->nvme_support = 0;
10456 phba->nvmet_support = 0;
10457 phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_OFF;
10458 phba->cfg_nvme_io_channel = 0;
10459 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
10460 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_NVME,
10461 "6101 Disabling NVME support: "
10462 "Not supported by firmware: %d %d\n",
10463 bf_get(cfg_nvme, mbx_sli4_parameters),
10464 bf_get(cfg_xib, mbx_sli4_parameters));
10465
10466 /* If firmware doesn't support NVME, just use SCSI support */
10467 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
10468 return -ENODEV;
10469 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
10470 }
10471
10472 if (bf_get(cfg_xib, mbx_sli4_parameters) && phba->cfg_suppress_rsp)
10473 phba->sli.sli_flag |= LPFC_SLI_SUPPRESS_RSP;
10474
10475 if (bf_get(cfg_eqdr, mbx_sli4_parameters))
10476 phba->sli.sli_flag |= LPFC_SLI_USE_EQDR;
10477
10478 /* Make sure that sge_supp_len can be handled by the driver */
10479 if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
10480 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
10481
10482 /*
10483 * Check whether the adapter supports an embedded copy of the
10484 * FCP CMD IU within the WQE for FCP_Ixxx commands. In order
10485 * to use this option, 128-byte WQEs must be used.
10486 */
10487 if (bf_get(cfg_ext_embed_cb, mbx_sli4_parameters))
10488 phba->fcp_embed_io = 1;
10489 else
10490 phba->fcp_embed_io = 0;
10491
10492 if ((bf_get(cfg_cqpsize, mbx_sli4_parameters) & LPFC_CQ_16K_PAGE_SZ) &&
10493 (bf_get(cfg_wqpsize, mbx_sli4_parameters) & LPFC_WQ_16K_PAGE_SZ) &&
10494 (sli4_params->wqsize & LPFC_WQ_SZ128_SUPPORT))
10495 phba->enab_exp_wqcq_pages = 1;
10496 else
10497 phba->enab_exp_wqcq_pages = 0;
10498 /*
10499 * Check if the SLI port supports MDS Diagnostics
10500 */
10501 if (bf_get(cfg_mds_diags, mbx_sli4_parameters))
10502 phba->mds_diags_support = 1;
10503 else
10504 phba->mds_diags_support = 0;
10505 return 0;
10506 }
10507
10508 /**
10509 * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
10510 * @pdev: pointer to PCI device
10511 * @pid: pointer to PCI device identifier
10512 *
10513 * This routine is to be called to attach a device with SLI-3 interface spec
10514 * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
10515 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
10516 * information of the device and driver to see if the driver state that it can
10517 * support this kind of device. If the match is successful, the driver core
10518 * invokes this routine. If this routine determines it can claim the HBA, it
10519 * does all the initialization that it needs to do to handle the HBA properly.
10520 *
10521 * Return code
10522 * 0 - driver can claim the device
10523 * negative value - driver can not claim the device
10524 **/
10525 static int
10526 lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
10527 {
10528 struct lpfc_hba *phba;
10529 struct lpfc_vport *vport = NULL;
10530 struct Scsi_Host *shost = NULL;
10531 int error;
10532 uint32_t cfg_mode, intr_mode;
10533
10534 /* Allocate memory for HBA structure */
10535 phba = lpfc_hba_alloc(pdev);
10536 if (!phba)
10537 return -ENOMEM;
10538
10539 /* Perform generic PCI device enabling operation */
10540 error = lpfc_enable_pci_dev(phba);
10541 if (error)
10542 goto out_free_phba;
10543
10544 /* Set up SLI API function jump table for PCI-device group-0 HBAs */
10545 error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP);
10546 if (error)
10547 goto out_disable_pci_dev;
10548
10549 /* Set up SLI-3 specific device PCI memory space */
10550 error = lpfc_sli_pci_mem_setup(phba);
10551 if (error) {
10552 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10553 "1402 Failed to set up pci memory space.\n");
10554 goto out_disable_pci_dev;
10555 }
10556
10557 /* Set up SLI-3 specific device driver resources */
10558 error = lpfc_sli_driver_resource_setup(phba);
10559 if (error) {
10560 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10561 "1404 Failed to set up driver resource.\n");
10562 goto out_unset_pci_mem_s3;
10563 }
10564
10565 /* Initialize and populate the iocb list per host */
10566
10567 error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT);
10568 if (error) {
10569 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10570 "1405 Failed to initialize iocb list.\n");
10571 goto out_unset_driver_resource_s3;
10572 }
10573
10574 /* Set up common device driver resources */
10575 error = lpfc_setup_driver_resource_phase2(phba);
10576 if (error) {
10577 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10578 "1406 Failed to set up driver resource.\n");
10579 goto out_free_iocb_list;
10580 }
10581
10582 /* Get the default values for Model Name and Description */
10583 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
10584
10585 /* Create SCSI host to the physical port */
10586 error = lpfc_create_shost(phba);
10587 if (error) {
10588 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10589 "1407 Failed to create scsi host.\n");
10590 goto out_unset_driver_resource;
10591 }
10592
10593 /* Configure sysfs attributes */
10594 vport = phba->pport;
10595 error = lpfc_alloc_sysfs_attr(vport);
10596 if (error) {
10597 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10598 "1476 Failed to allocate sysfs attr\n");
10599 goto out_destroy_shost;
10600 }
10601
10602 shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
10603 /* Now, trying to enable interrupt and bring up the device */
10604 cfg_mode = phba->cfg_use_msi;
10605 while (true) {
10606 /* Put device to a known state before enabling interrupt */
10607 lpfc_stop_port(phba);
10608 /* Configure and enable interrupt */
10609 intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
10610 if (intr_mode == LPFC_INTR_ERROR) {
10611 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10612 "0431 Failed to enable interrupt.\n");
10613 error = -ENODEV;
10614 goto out_free_sysfs_attr;
10615 }
10616 /* SLI-3 HBA setup */
10617 if (lpfc_sli_hba_setup(phba)) {
10618 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10619 "1477 Failed to set up hba\n");
10620 error = -ENODEV;
10621 goto out_remove_device;
10622 }
10623
10624 /* Wait 50ms for the interrupts of previous mailbox commands */
10625 msleep(50);
10626 /* Check active interrupts on message signaled interrupts */
10627 if (intr_mode == 0 ||
10628 phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) {
10629 /* Log the current active interrupt mode */
10630 phba->intr_mode = intr_mode;
10631 lpfc_log_intr_mode(phba, intr_mode);
10632 break;
10633 } else {
10634 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10635 "0447 Configure interrupt mode (%d) "
10636 "failed active interrupt test.\n",
10637 intr_mode);
10638 /* Disable the current interrupt mode */
10639 lpfc_sli_disable_intr(phba);
10640 /* Try next level of interrupt mode */
10641 cfg_mode = --intr_mode;
10642 }
10643 }
10644
10645 /* Perform post initialization setup */
10646 lpfc_post_init_setup(phba);
10647
10648 /* Check if there are static vports to be created. */
10649 lpfc_create_static_vport(phba);
10650
10651 return 0;
10652
10653 out_remove_device:
10654 lpfc_unset_hba(phba);
10655 out_free_sysfs_attr:
10656 lpfc_free_sysfs_attr(vport);
10657 out_destroy_shost:
10658 lpfc_destroy_shost(phba);
10659 out_unset_driver_resource:
10660 lpfc_unset_driver_resource_phase2(phba);
10661 out_free_iocb_list:
10662 lpfc_free_iocb_list(phba);
10663 out_unset_driver_resource_s3:
10664 lpfc_sli_driver_resource_unset(phba);
10665 out_unset_pci_mem_s3:
10666 lpfc_sli_pci_mem_unset(phba);
10667 out_disable_pci_dev:
10668 lpfc_disable_pci_dev(phba);
10669 if (shost)
10670 scsi_host_put(shost);
10671 out_free_phba:
10672 lpfc_hba_free(phba);
10673 return error;
10674 }
10675
10676 /**
10677 * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
10678 * @pdev: pointer to PCI device
10679 *
10680 * This routine is to be called to disattach a device with SLI-3 interface
10681 * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
10682 * removed from PCI bus, it performs all the necessary cleanup for the HBA
10683 * device to be removed from the PCI subsystem properly.
10684 **/
10685 static void
10686 lpfc_pci_remove_one_s3(struct pci_dev *pdev)
10687 {
10688 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10689 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
10690 struct lpfc_vport **vports;
10691 struct lpfc_hba *phba = vport->phba;
10692 int i;
10693
10694 spin_lock_irq(&phba->hbalock);
10695 vport->load_flag |= FC_UNLOADING;
10696 spin_unlock_irq(&phba->hbalock);
10697
10698 lpfc_free_sysfs_attr(vport);
10699
10700 /* Release all the vports against this physical port */
10701 vports = lpfc_create_vport_work_array(phba);
10702 if (vports != NULL)
10703 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
10704 if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
10705 continue;
10706 fc_vport_terminate(vports[i]->fc_vport);
10707 }
10708 lpfc_destroy_vport_work_array(phba, vports);
10709
10710 /* Remove FC host and then SCSI host with the physical port */
10711 fc_remove_host(shost);
10712 scsi_remove_host(shost);
10713
10714 lpfc_cleanup(vport);
10715
10716 /*
10717 * Bring down the SLI Layer. This step disable all interrupts,
10718 * clears the rings, discards all mailbox commands, and resets
10719 * the HBA.
10720 */
10721
10722 /* HBA interrupt will be disabled after this call */
10723 lpfc_sli_hba_down(phba);
10724 /* Stop kthread signal shall trigger work_done one more time */
10725 kthread_stop(phba->worker_thread);
10726 /* Final cleanup of txcmplq and reset the HBA */
10727 lpfc_sli_brdrestart(phba);
10728
10729 kfree(phba->vpi_bmask);
10730 kfree(phba->vpi_ids);
10731
10732 lpfc_stop_hba_timers(phba);
10733 spin_lock_irq(&phba->hbalock);
10734 list_del_init(&vport->listentry);
10735 spin_unlock_irq(&phba->hbalock);
10736
10737 lpfc_debugfs_terminate(vport);
10738
10739 /* Disable SR-IOV if enabled */
10740 if (phba->cfg_sriov_nr_virtfn)
10741 pci_disable_sriov(pdev);
10742
10743 /* Disable interrupt */
10744 lpfc_sli_disable_intr(phba);
10745
10746 scsi_host_put(shost);
10747
10748 /*
10749 * Call scsi_free before mem_free since scsi bufs are released to their
10750 * corresponding pools here.
10751 */
10752 lpfc_scsi_free(phba);
10753 lpfc_mem_free_all(phba);
10754
10755 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
10756 phba->hbqslimp.virt, phba->hbqslimp.phys);
10757
10758 /* Free resources associated with SLI2 interface */
10759 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
10760 phba->slim2p.virt, phba->slim2p.phys);
10761
10762 /* unmap adapter SLIM and Control Registers */
10763 iounmap(phba->ctrl_regs_memmap_p);
10764 iounmap(phba->slim_memmap_p);
10765
10766 lpfc_hba_free(phba);
10767
10768 pci_release_mem_regions(pdev);
10769 pci_disable_device(pdev);
10770 }
10771
10772 /**
10773 * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
10774 * @pdev: pointer to PCI device
10775 * @msg: power management message
10776 *
10777 * This routine is to be called from the kernel's PCI subsystem to support
10778 * system Power Management (PM) to device with SLI-3 interface spec. When
10779 * PM invokes this method, it quiesces the device by stopping the driver's
10780 * worker thread for the device, turning off device's interrupt and DMA,
10781 * and bring the device offline. Note that as the driver implements the
10782 * minimum PM requirements to a power-aware driver's PM support for the
10783 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
10784 * to the suspend() method call will be treated as SUSPEND and the driver will
10785 * fully reinitialize its device during resume() method call, the driver will
10786 * set device to PCI_D3hot state in PCI config space instead of setting it
10787 * according to the @msg provided by the PM.
10788 *
10789 * Return code
10790 * 0 - driver suspended the device
10791 * Error otherwise
10792 **/
10793 static int
10794 lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
10795 {
10796 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10797 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10798
10799 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10800 "0473 PCI device Power Management suspend.\n");
10801
10802 /* Bring down the device */
10803 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
10804 lpfc_offline(phba);
10805 kthread_stop(phba->worker_thread);
10806
10807 /* Disable interrupt from device */
10808 lpfc_sli_disable_intr(phba);
10809
10810 /* Save device state to PCI config space */
10811 pci_save_state(pdev);
10812 pci_set_power_state(pdev, PCI_D3hot);
10813
10814 return 0;
10815 }
10816
10817 /**
10818 * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
10819 * @pdev: pointer to PCI device
10820 *
10821 * This routine is to be called from the kernel's PCI subsystem to support
10822 * system Power Management (PM) to device with SLI-3 interface spec. When PM
10823 * invokes this method, it restores the device's PCI config space state and
10824 * fully reinitializes the device and brings it online. Note that as the
10825 * driver implements the minimum PM requirements to a power-aware driver's
10826 * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
10827 * FREEZE) to the suspend() method call will be treated as SUSPEND and the
10828 * driver will fully reinitialize its device during resume() method call,
10829 * the device will be set to PCI_D0 directly in PCI config space before
10830 * restoring the state.
10831 *
10832 * Return code
10833 * 0 - driver suspended the device
10834 * Error otherwise
10835 **/
10836 static int
10837 lpfc_pci_resume_one_s3(struct pci_dev *pdev)
10838 {
10839 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10840 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10841 uint32_t intr_mode;
10842 int error;
10843
10844 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10845 "0452 PCI device Power Management resume.\n");
10846
10847 /* Restore device state from PCI config space */
10848 pci_set_power_state(pdev, PCI_D0);
10849 pci_restore_state(pdev);
10850
10851 /*
10852 * As the new kernel behavior of pci_restore_state() API call clears
10853 * device saved_state flag, need to save the restored state again.
10854 */
10855 pci_save_state(pdev);
10856
10857 if (pdev->is_busmaster)
10858 pci_set_master(pdev);
10859
10860 /* Startup the kernel thread for this host adapter. */
10861 phba->worker_thread = kthread_run(lpfc_do_work, phba,
10862 "lpfc_worker_%d", phba->brd_no);
10863 if (IS_ERR(phba->worker_thread)) {
10864 error = PTR_ERR(phba->worker_thread);
10865 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10866 "0434 PM resume failed to start worker "
10867 "thread: error=x%x.\n", error);
10868 return error;
10869 }
10870
10871 /* Configure and enable interrupt */
10872 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
10873 if (intr_mode == LPFC_INTR_ERROR) {
10874 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10875 "0430 PM resume Failed to enable interrupt\n");
10876 return -EIO;
10877 } else
10878 phba->intr_mode = intr_mode;
10879
10880 /* Restart HBA and bring it online */
10881 lpfc_sli_brdrestart(phba);
10882 lpfc_online(phba);
10883
10884 /* Log the current active interrupt mode */
10885 lpfc_log_intr_mode(phba, phba->intr_mode);
10886
10887 return 0;
10888 }
10889
10890 /**
10891 * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
10892 * @phba: pointer to lpfc hba data structure.
10893 *
10894 * This routine is called to prepare the SLI3 device for PCI slot recover. It
10895 * aborts all the outstanding SCSI I/Os to the pci device.
10896 **/
10897 static void
10898 lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
10899 {
10900 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10901 "2723 PCI channel I/O abort preparing for recovery\n");
10902
10903 /*
10904 * There may be errored I/Os through HBA, abort all I/Os on txcmplq
10905 * and let the SCSI mid-layer to retry them to recover.
10906 */
10907 lpfc_sli_abort_fcp_rings(phba);
10908 }
10909
10910 /**
10911 * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
10912 * @phba: pointer to lpfc hba data structure.
10913 *
10914 * This routine is called to prepare the SLI3 device for PCI slot reset. It
10915 * disables the device interrupt and pci device, and aborts the internal FCP
10916 * pending I/Os.
10917 **/
10918 static void
10919 lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
10920 {
10921 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10922 "2710 PCI channel disable preparing for reset\n");
10923
10924 /* Block any management I/Os to the device */
10925 lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
10926
10927 /* Block all SCSI devices' I/Os on the host */
10928 lpfc_scsi_dev_block(phba);
10929
10930 /* Flush all driver's outstanding SCSI I/Os as we are to reset */
10931 lpfc_sli_flush_fcp_rings(phba);
10932
10933 /* stop all timers */
10934 lpfc_stop_hba_timers(phba);
10935
10936 /* Disable interrupt and pci device */
10937 lpfc_sli_disable_intr(phba);
10938 pci_disable_device(phba->pcidev);
10939 }
10940
10941 /**
10942 * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
10943 * @phba: pointer to lpfc hba data structure.
10944 *
10945 * This routine is called to prepare the SLI3 device for PCI slot permanently
10946 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
10947 * pending I/Os.
10948 **/
10949 static void
10950 lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba)
10951 {
10952 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10953 "2711 PCI channel permanent disable for failure\n");
10954 /* Block all SCSI devices' I/Os on the host */
10955 lpfc_scsi_dev_block(phba);
10956
10957 /* stop all timers */
10958 lpfc_stop_hba_timers(phba);
10959
10960 /* Clean up all driver's outstanding SCSI I/Os */
10961 lpfc_sli_flush_fcp_rings(phba);
10962 }
10963
10964 /**
10965 * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
10966 * @pdev: pointer to PCI device.
10967 * @state: the current PCI connection state.
10968 *
10969 * This routine is called from the PCI subsystem for I/O error handling to
10970 * device with SLI-3 interface spec. This function is called by the PCI
10971 * subsystem after a PCI bus error affecting this device has been detected.
10972 * When this function is invoked, it will need to stop all the I/Os and
10973 * interrupt(s) to the device. Once that is done, it will return
10974 * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
10975 * as desired.
10976 *
10977 * Return codes
10978 * PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
10979 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
10980 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
10981 **/
10982 static pci_ers_result_t
10983 lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
10984 {
10985 struct Scsi_Host *shost = pci_get_drvdata(pdev);
10986 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10987
10988 switch (state) {
10989 case pci_channel_io_normal:
10990 /* Non-fatal error, prepare for recovery */
10991 lpfc_sli_prep_dev_for_recover(phba);
10992 return PCI_ERS_RESULT_CAN_RECOVER;
10993 case pci_channel_io_frozen:
10994 /* Fatal error, prepare for slot reset */
10995 lpfc_sli_prep_dev_for_reset(phba);
10996 return PCI_ERS_RESULT_NEED_RESET;
10997 case pci_channel_io_perm_failure:
10998 /* Permanent failure, prepare for device down */
10999 lpfc_sli_prep_dev_for_perm_failure(phba);
11000 return PCI_ERS_RESULT_DISCONNECT;
11001 default:
11002 /* Unknown state, prepare and request slot reset */
11003 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11004 "0472 Unknown PCI error state: x%x\n", state);
11005 lpfc_sli_prep_dev_for_reset(phba);
11006 return PCI_ERS_RESULT_NEED_RESET;
11007 }
11008 }
11009
11010 /**
11011 * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
11012 * @pdev: pointer to PCI device.
11013 *
11014 * This routine is called from the PCI subsystem for error handling to
11015 * device with SLI-3 interface spec. This is called after PCI bus has been
11016 * reset to restart the PCI card from scratch, as if from a cold-boot.
11017 * During the PCI subsystem error recovery, after driver returns
11018 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
11019 * recovery and then call this routine before calling the .resume method
11020 * to recover the device. This function will initialize the HBA device,
11021 * enable the interrupt, but it will just put the HBA to offline state
11022 * without passing any I/O traffic.
11023 *
11024 * Return codes
11025 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
11026 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11027 */
11028 static pci_ers_result_t
11029 lpfc_io_slot_reset_s3(struct pci_dev *pdev)
11030 {
11031 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11032 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11033 struct lpfc_sli *psli = &phba->sli;
11034 uint32_t intr_mode;
11035
11036 dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
11037 if (pci_enable_device_mem(pdev)) {
11038 printk(KERN_ERR "lpfc: Cannot re-enable "
11039 "PCI device after reset.\n");
11040 return PCI_ERS_RESULT_DISCONNECT;
11041 }
11042
11043 pci_restore_state(pdev);
11044
11045 /*
11046 * As the new kernel behavior of pci_restore_state() API call clears
11047 * device saved_state flag, need to save the restored state again.
11048 */
11049 pci_save_state(pdev);
11050
11051 if (pdev->is_busmaster)
11052 pci_set_master(pdev);
11053
11054 spin_lock_irq(&phba->hbalock);
11055 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
11056 spin_unlock_irq(&phba->hbalock);
11057
11058 /* Configure and enable interrupt */
11059 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
11060 if (intr_mode == LPFC_INTR_ERROR) {
11061 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11062 "0427 Cannot re-enable interrupt after "
11063 "slot reset.\n");
11064 return PCI_ERS_RESULT_DISCONNECT;
11065 } else
11066 phba->intr_mode = intr_mode;
11067
11068 /* Take device offline, it will perform cleanup */
11069 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
11070 lpfc_offline(phba);
11071 lpfc_sli_brdrestart(phba);
11072
11073 /* Log the current active interrupt mode */
11074 lpfc_log_intr_mode(phba, phba->intr_mode);
11075
11076 return PCI_ERS_RESULT_RECOVERED;
11077 }
11078
11079 /**
11080 * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
11081 * @pdev: pointer to PCI device
11082 *
11083 * This routine is called from the PCI subsystem for error handling to device
11084 * with SLI-3 interface spec. It is called when kernel error recovery tells
11085 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
11086 * error recovery. After this call, traffic can start to flow from this device
11087 * again.
11088 */
11089 static void
11090 lpfc_io_resume_s3(struct pci_dev *pdev)
11091 {
11092 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11093 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11094
11095 /* Bring device online, it will be no-op for non-fatal error resume */
11096 lpfc_online(phba);
11097
11098 /* Clean up Advanced Error Reporting (AER) if needed */
11099 if (phba->hba_flag & HBA_AER_ENABLED)
11100 pci_cleanup_aer_uncorrect_error_status(pdev);
11101 }
11102
11103 /**
11104 * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve
11105 * @phba: pointer to lpfc hba data structure.
11106 *
11107 * returns the number of ELS/CT IOCBs to reserve
11108 **/
11109 int
11110 lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
11111 {
11112 int max_xri = phba->sli4_hba.max_cfg_param.max_xri;
11113
11114 if (phba->sli_rev == LPFC_SLI_REV4) {
11115 if (max_xri <= 100)
11116 return 10;
11117 else if (max_xri <= 256)
11118 return 25;
11119 else if (max_xri <= 512)
11120 return 50;
11121 else if (max_xri <= 1024)
11122 return 100;
11123 else if (max_xri <= 1536)
11124 return 150;
11125 else if (max_xri <= 2048)
11126 return 200;
11127 else
11128 return 250;
11129 } else
11130 return 0;
11131 }
11132
11133 /**
11134 * lpfc_sli4_get_iocb_cnt - Calculate the # of total IOCBs to reserve
11135 * @phba: pointer to lpfc hba data structure.
11136 *
11137 * returns the number of ELS/CT + NVMET IOCBs to reserve
11138 **/
11139 int
11140 lpfc_sli4_get_iocb_cnt(struct lpfc_hba *phba)
11141 {
11142 int max_xri = lpfc_sli4_get_els_iocb_cnt(phba);
11143
11144 if (phba->nvmet_support)
11145 max_xri += LPFC_NVMET_BUF_POST;
11146 return max_xri;
11147 }
11148
11149
11150 /**
11151 * lpfc_write_firmware - attempt to write a firmware image to the port
11152 * @fw: pointer to firmware image returned from request_firmware.
11153 * @phba: pointer to lpfc hba data structure.
11154 *
11155 **/
11156 static void
11157 lpfc_write_firmware(const struct firmware *fw, void *context)
11158 {
11159 struct lpfc_hba *phba = (struct lpfc_hba *)context;
11160 char fwrev[FW_REV_STR_SIZE];
11161 struct lpfc_grp_hdr *image;
11162 struct list_head dma_buffer_list;
11163 int i, rc = 0;
11164 struct lpfc_dmabuf *dmabuf, *next;
11165 uint32_t offset = 0, temp_offset = 0;
11166 uint32_t magic_number, ftype, fid, fsize;
11167
11168 /* It can be null in no-wait mode, sanity check */
11169 if (!fw) {
11170 rc = -ENXIO;
11171 goto out;
11172 }
11173 image = (struct lpfc_grp_hdr *)fw->data;
11174
11175 magic_number = be32_to_cpu(image->magic_number);
11176 ftype = bf_get_be32(lpfc_grp_hdr_file_type, image);
11177 fid = bf_get_be32(lpfc_grp_hdr_id, image),
11178 fsize = be32_to_cpu(image->size);
11179
11180 INIT_LIST_HEAD(&dma_buffer_list);
11181 if ((magic_number != LPFC_GROUP_OJECT_MAGIC_G5 &&
11182 magic_number != LPFC_GROUP_OJECT_MAGIC_G6) ||
11183 ftype != LPFC_FILE_TYPE_GROUP || fsize != fw->size) {
11184 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11185 "3022 Invalid FW image found. "
11186 "Magic:%x Type:%x ID:%x Size %d %zd\n",
11187 magic_number, ftype, fid, fsize, fw->size);
11188 rc = -EINVAL;
11189 goto release_out;
11190 }
11191 lpfc_decode_firmware_rev(phba, fwrev, 1);
11192 if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) {
11193 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11194 "3023 Updating Firmware, Current Version:%s "
11195 "New Version:%s\n",
11196 fwrev, image->revision);
11197 for (i = 0; i < LPFC_MBX_WR_CONFIG_MAX_BDE; i++) {
11198 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf),
11199 GFP_KERNEL);
11200 if (!dmabuf) {
11201 rc = -ENOMEM;
11202 goto release_out;
11203 }
11204 dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
11205 SLI4_PAGE_SIZE,
11206 &dmabuf->phys,
11207 GFP_KERNEL);
11208 if (!dmabuf->virt) {
11209 kfree(dmabuf);
11210 rc = -ENOMEM;
11211 goto release_out;
11212 }
11213 list_add_tail(&dmabuf->list, &dma_buffer_list);
11214 }
11215 while (offset < fw->size) {
11216 temp_offset = offset;
11217 list_for_each_entry(dmabuf, &dma_buffer_list, list) {
11218 if (temp_offset + SLI4_PAGE_SIZE > fw->size) {
11219 memcpy(dmabuf->virt,
11220 fw->data + temp_offset,
11221 fw->size - temp_offset);
11222 temp_offset = fw->size;
11223 break;
11224 }
11225 memcpy(dmabuf->virt, fw->data + temp_offset,
11226 SLI4_PAGE_SIZE);
11227 temp_offset += SLI4_PAGE_SIZE;
11228 }
11229 rc = lpfc_wr_object(phba, &dma_buffer_list,
11230 (fw->size - offset), &offset);
11231 if (rc)
11232 goto release_out;
11233 }
11234 rc = offset;
11235 }
11236
11237 release_out:
11238 list_for_each_entry_safe(dmabuf, next, &dma_buffer_list, list) {
11239 list_del(&dmabuf->list);
11240 dma_free_coherent(&phba->pcidev->dev, SLI4_PAGE_SIZE,
11241 dmabuf->virt, dmabuf->phys);
11242 kfree(dmabuf);
11243 }
11244 release_firmware(fw);
11245 out:
11246 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11247 "3024 Firmware update done: %d.\n", rc);
11248 return;
11249 }
11250
11251 /**
11252 * lpfc_sli4_request_firmware_update - Request linux generic firmware upgrade
11253 * @phba: pointer to lpfc hba data structure.
11254 *
11255 * This routine is called to perform Linux generic firmware upgrade on device
11256 * that supports such feature.
11257 **/
11258 int
11259 lpfc_sli4_request_firmware_update(struct lpfc_hba *phba, uint8_t fw_upgrade)
11260 {
11261 uint8_t file_name[ELX_MODEL_NAME_SIZE];
11262 int ret;
11263 const struct firmware *fw;
11264
11265 /* Only supported on SLI4 interface type 2 for now */
11266 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
11267 LPFC_SLI_INTF_IF_TYPE_2)
11268 return -EPERM;
11269
11270 snprintf(file_name, ELX_MODEL_NAME_SIZE, "%s.grp", phba->ModelName);
11271
11272 if (fw_upgrade == INT_FW_UPGRADE) {
11273 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
11274 file_name, &phba->pcidev->dev,
11275 GFP_KERNEL, (void *)phba,
11276 lpfc_write_firmware);
11277 } else if (fw_upgrade == RUN_FW_UPGRADE) {
11278 ret = request_firmware(&fw, file_name, &phba->pcidev->dev);
11279 if (!ret)
11280 lpfc_write_firmware(fw, (void *)phba);
11281 } else {
11282 ret = -EINVAL;
11283 }
11284
11285 return ret;
11286 }
11287
11288 /**
11289 * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
11290 * @pdev: pointer to PCI device
11291 * @pid: pointer to PCI device identifier
11292 *
11293 * This routine is called from the kernel's PCI subsystem to device with
11294 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
11295 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
11296 * information of the device and driver to see if the driver state that it
11297 * can support this kind of device. If the match is successful, the driver
11298 * core invokes this routine. If this routine determines it can claim the HBA,
11299 * it does all the initialization that it needs to do to handle the HBA
11300 * properly.
11301 *
11302 * Return code
11303 * 0 - driver can claim the device
11304 * negative value - driver can not claim the device
11305 **/
11306 static int
11307 lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
11308 {
11309 struct lpfc_hba *phba;
11310 struct lpfc_vport *vport = NULL;
11311 struct Scsi_Host *shost = NULL;
11312 int error;
11313 uint32_t cfg_mode, intr_mode;
11314
11315 /* Allocate memory for HBA structure */
11316 phba = lpfc_hba_alloc(pdev);
11317 if (!phba)
11318 return -ENOMEM;
11319
11320 /* Perform generic PCI device enabling operation */
11321 error = lpfc_enable_pci_dev(phba);
11322 if (error)
11323 goto out_free_phba;
11324
11325 /* Set up SLI API function jump table for PCI-device group-1 HBAs */
11326 error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_OC);
11327 if (error)
11328 goto out_disable_pci_dev;
11329
11330 /* Set up SLI-4 specific device PCI memory space */
11331 error = lpfc_sli4_pci_mem_setup(phba);
11332 if (error) {
11333 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11334 "1410 Failed to set up pci memory space.\n");
11335 goto out_disable_pci_dev;
11336 }
11337
11338 /* Set up SLI-4 Specific device driver resources */
11339 error = lpfc_sli4_driver_resource_setup(phba);
11340 if (error) {
11341 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11342 "1412 Failed to set up driver resource.\n");
11343 goto out_unset_pci_mem_s4;
11344 }
11345
11346 INIT_LIST_HEAD(&phba->active_rrq_list);
11347 INIT_LIST_HEAD(&phba->fcf.fcf_pri_list);
11348
11349 /* Set up common device driver resources */
11350 error = lpfc_setup_driver_resource_phase2(phba);
11351 if (error) {
11352 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11353 "1414 Failed to set up driver resource.\n");
11354 goto out_unset_driver_resource_s4;
11355 }
11356
11357 /* Get the default values for Model Name and Description */
11358 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
11359
11360 /* Create SCSI host to the physical port */
11361 error = lpfc_create_shost(phba);
11362 if (error) {
11363 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11364 "1415 Failed to create scsi host.\n");
11365 goto out_unset_driver_resource;
11366 }
11367
11368 /* Configure sysfs attributes */
11369 vport = phba->pport;
11370 error = lpfc_alloc_sysfs_attr(vport);
11371 if (error) {
11372 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11373 "1416 Failed to allocate sysfs attr\n");
11374 goto out_destroy_shost;
11375 }
11376
11377 shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
11378 /* Now, trying to enable interrupt and bring up the device */
11379 cfg_mode = phba->cfg_use_msi;
11380
11381 /* Put device to a known state before enabling interrupt */
11382 lpfc_stop_port(phba);
11383
11384 /* Configure and enable interrupt */
11385 intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);
11386 if (intr_mode == LPFC_INTR_ERROR) {
11387 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11388 "0426 Failed to enable interrupt.\n");
11389 error = -ENODEV;
11390 goto out_free_sysfs_attr;
11391 }
11392 /* Default to single EQ for non-MSI-X */
11393 if (phba->intr_type != MSIX) {
11394 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
11395 phba->cfg_fcp_io_channel = 1;
11396 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
11397 phba->cfg_nvme_io_channel = 1;
11398 if (phba->nvmet_support)
11399 phba->cfg_nvmet_mrq = 1;
11400 }
11401 phba->io_channel_irqs = 1;
11402 }
11403
11404 /* Set up SLI-4 HBA */
11405 if (lpfc_sli4_hba_setup(phba)) {
11406 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11407 "1421 Failed to set up hba\n");
11408 error = -ENODEV;
11409 goto out_disable_intr;
11410 }
11411
11412 /* Log the current active interrupt mode */
11413 phba->intr_mode = intr_mode;
11414 lpfc_log_intr_mode(phba, intr_mode);
11415
11416 /* Perform post initialization setup */
11417 lpfc_post_init_setup(phba);
11418
11419 /* NVME support in FW earlier in the driver load corrects the
11420 * FC4 type making a check for nvme_support unnecessary.
11421 */
11422 if ((phba->nvmet_support == 0) &&
11423 (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
11424 /* Create NVME binding with nvme_fc_transport. This
11425 * ensures the vport is initialized. If the localport
11426 * create fails, it should not unload the driver to
11427 * support field issues.
11428 */
11429 error = lpfc_nvme_create_localport(vport);
11430 if (error) {
11431 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11432 "6004 NVME registration failed, "
11433 "error x%x\n",
11434 error);
11435 }
11436 }
11437
11438 /* check for firmware upgrade or downgrade */
11439 if (phba->cfg_request_firmware_upgrade)
11440 lpfc_sli4_request_firmware_update(phba, INT_FW_UPGRADE);
11441
11442 /* Check if there are static vports to be created. */
11443 lpfc_create_static_vport(phba);
11444 return 0;
11445
11446 out_disable_intr:
11447 lpfc_sli4_disable_intr(phba);
11448 out_free_sysfs_attr:
11449 lpfc_free_sysfs_attr(vport);
11450 out_destroy_shost:
11451 lpfc_destroy_shost(phba);
11452 out_unset_driver_resource:
11453 lpfc_unset_driver_resource_phase2(phba);
11454 out_unset_driver_resource_s4:
11455 lpfc_sli4_driver_resource_unset(phba);
11456 out_unset_pci_mem_s4:
11457 lpfc_sli4_pci_mem_unset(phba);
11458 out_disable_pci_dev:
11459 lpfc_disable_pci_dev(phba);
11460 if (shost)
11461 scsi_host_put(shost);
11462 out_free_phba:
11463 lpfc_hba_free(phba);
11464 return error;
11465 }
11466
11467 /**
11468 * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem
11469 * @pdev: pointer to PCI device
11470 *
11471 * This routine is called from the kernel's PCI subsystem to device with
11472 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
11473 * removed from PCI bus, it performs all the necessary cleanup for the HBA
11474 * device to be removed from the PCI subsystem properly.
11475 **/
11476 static void
11477 lpfc_pci_remove_one_s4(struct pci_dev *pdev)
11478 {
11479 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11480 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
11481 struct lpfc_vport **vports;
11482 struct lpfc_hba *phba = vport->phba;
11483 int i;
11484
11485 /* Mark the device unloading flag */
11486 spin_lock_irq(&phba->hbalock);
11487 vport->load_flag |= FC_UNLOADING;
11488 spin_unlock_irq(&phba->hbalock);
11489
11490 /* Free the HBA sysfs attributes */
11491 lpfc_free_sysfs_attr(vport);
11492
11493 /* Release all the vports against this physical port */
11494 vports = lpfc_create_vport_work_array(phba);
11495 if (vports != NULL)
11496 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
11497 if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
11498 continue;
11499 fc_vport_terminate(vports[i]->fc_vport);
11500 }
11501 lpfc_destroy_vport_work_array(phba, vports);
11502
11503 /* Remove FC host and then SCSI host with the physical port */
11504 fc_remove_host(shost);
11505 scsi_remove_host(shost);
11506 /*
11507 * Bring down the SLI Layer. This step disables all interrupts,
11508 * clears the rings, discards all mailbox commands, and resets
11509 * the HBA FCoE function.
11510 */
11511 lpfc_debugfs_terminate(vport);
11512 lpfc_sli4_hba_unset(phba);
11513
11514 /* Perform ndlp cleanup on the physical port. The nvme and nvmet
11515 * localports are destroyed after to cleanup all transport memory.
11516 */
11517 lpfc_cleanup(vport);
11518 lpfc_nvmet_destroy_targetport(phba);
11519 lpfc_nvme_destroy_localport(vport);
11520
11521
11522 lpfc_stop_hba_timers(phba);
11523 spin_lock_irq(&phba->hbalock);
11524 list_del_init(&vport->listentry);
11525 spin_unlock_irq(&phba->hbalock);
11526
11527 /* Perform scsi free before driver resource_unset since scsi
11528 * buffers are released to their corresponding pools here.
11529 */
11530 lpfc_scsi_free(phba);
11531 lpfc_nvme_free(phba);
11532 lpfc_free_iocb_list(phba);
11533
11534 lpfc_sli4_driver_resource_unset(phba);
11535
11536 /* Unmap adapter Control and Doorbell registers */
11537 lpfc_sli4_pci_mem_unset(phba);
11538
11539 /* Release PCI resources and disable device's PCI function */
11540 scsi_host_put(shost);
11541 lpfc_disable_pci_dev(phba);
11542
11543 /* Finally, free the driver's device data structure */
11544 lpfc_hba_free(phba);
11545
11546 return;
11547 }
11548
11549 /**
11550 * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt
11551 * @pdev: pointer to PCI device
11552 * @msg: power management message
11553 *
11554 * This routine is called from the kernel's PCI subsystem to support system
11555 * Power Management (PM) to device with SLI-4 interface spec. When PM invokes
11556 * this method, it quiesces the device by stopping the driver's worker
11557 * thread for the device, turning off device's interrupt and DMA, and bring
11558 * the device offline. Note that as the driver implements the minimum PM
11559 * requirements to a power-aware driver's PM support for suspend/resume -- all
11560 * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
11561 * method call will be treated as SUSPEND and the driver will fully
11562 * reinitialize its device during resume() method call, the driver will set
11563 * device to PCI_D3hot state in PCI config space instead of setting it
11564 * according to the @msg provided by the PM.
11565 *
11566 * Return code
11567 * 0 - driver suspended the device
11568 * Error otherwise
11569 **/
11570 static int
11571 lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg)
11572 {
11573 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11574 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11575
11576 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11577 "2843 PCI device Power Management suspend.\n");
11578
11579 /* Bring down the device */
11580 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
11581 lpfc_offline(phba);
11582 kthread_stop(phba->worker_thread);
11583
11584 /* Disable interrupt from device */
11585 lpfc_sli4_disable_intr(phba);
11586 lpfc_sli4_queue_destroy(phba);
11587
11588 /* Save device state to PCI config space */
11589 pci_save_state(pdev);
11590 pci_set_power_state(pdev, PCI_D3hot);
11591
11592 return 0;
11593 }
11594
11595 /**
11596 * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt
11597 * @pdev: pointer to PCI device
11598 *
11599 * This routine is called from the kernel's PCI subsystem to support system
11600 * Power Management (PM) to device with SLI-4 interface spac. When PM invokes
11601 * this method, it restores the device's PCI config space state and fully
11602 * reinitializes the device and brings it online. Note that as the driver
11603 * implements the minimum PM requirements to a power-aware driver's PM for
11604 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
11605 * to the suspend() method call will be treated as SUSPEND and the driver
11606 * will fully reinitialize its device during resume() method call, the device
11607 * will be set to PCI_D0 directly in PCI config space before restoring the
11608 * state.
11609 *
11610 * Return code
11611 * 0 - driver suspended the device
11612 * Error otherwise
11613 **/
11614 static int
11615 lpfc_pci_resume_one_s4(struct pci_dev *pdev)
11616 {
11617 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11618 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11619 uint32_t intr_mode;
11620 int error;
11621
11622 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11623 "0292 PCI device Power Management resume.\n");
11624
11625 /* Restore device state from PCI config space */
11626 pci_set_power_state(pdev, PCI_D0);
11627 pci_restore_state(pdev);
11628
11629 /*
11630 * As the new kernel behavior of pci_restore_state() API call clears
11631 * device saved_state flag, need to save the restored state again.
11632 */
11633 pci_save_state(pdev);
11634
11635 if (pdev->is_busmaster)
11636 pci_set_master(pdev);
11637
11638 /* Startup the kernel thread for this host adapter. */
11639 phba->worker_thread = kthread_run(lpfc_do_work, phba,
11640 "lpfc_worker_%d", phba->brd_no);
11641 if (IS_ERR(phba->worker_thread)) {
11642 error = PTR_ERR(phba->worker_thread);
11643 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11644 "0293 PM resume failed to start worker "
11645 "thread: error=x%x.\n", error);
11646 return error;
11647 }
11648
11649 /* Configure and enable interrupt */
11650 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
11651 if (intr_mode == LPFC_INTR_ERROR) {
11652 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11653 "0294 PM resume Failed to enable interrupt\n");
11654 return -EIO;
11655 } else
11656 phba->intr_mode = intr_mode;
11657
11658 /* Restart HBA and bring it online */
11659 lpfc_sli_brdrestart(phba);
11660 lpfc_online(phba);
11661
11662 /* Log the current active interrupt mode */
11663 lpfc_log_intr_mode(phba, phba->intr_mode);
11664
11665 return 0;
11666 }
11667
11668 /**
11669 * lpfc_sli4_prep_dev_for_recover - Prepare SLI4 device for pci slot recover
11670 * @phba: pointer to lpfc hba data structure.
11671 *
11672 * This routine is called to prepare the SLI4 device for PCI slot recover. It
11673 * aborts all the outstanding SCSI I/Os to the pci device.
11674 **/
11675 static void
11676 lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba)
11677 {
11678 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11679 "2828 PCI channel I/O abort preparing for recovery\n");
11680 /*
11681 * There may be errored I/Os through HBA, abort all I/Os on txcmplq
11682 * and let the SCSI mid-layer to retry them to recover.
11683 */
11684 lpfc_sli_abort_fcp_rings(phba);
11685 }
11686
11687 /**
11688 * lpfc_sli4_prep_dev_for_reset - Prepare SLI4 device for pci slot reset
11689 * @phba: pointer to lpfc hba data structure.
11690 *
11691 * This routine is called to prepare the SLI4 device for PCI slot reset. It
11692 * disables the device interrupt and pci device, and aborts the internal FCP
11693 * pending I/Os.
11694 **/
11695 static void
11696 lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
11697 {
11698 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11699 "2826 PCI channel disable preparing for reset\n");
11700
11701 /* Block any management I/Os to the device */
11702 lpfc_block_mgmt_io(phba, LPFC_MBX_NO_WAIT);
11703
11704 /* Block all SCSI devices' I/Os on the host */
11705 lpfc_scsi_dev_block(phba);
11706
11707 /* Flush all driver's outstanding SCSI I/Os as we are to reset */
11708 lpfc_sli_flush_fcp_rings(phba);
11709
11710 /* Flush the outstanding NVME IOs if fc4 type enabled. */
11711 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
11712 lpfc_sli_flush_nvme_rings(phba);
11713
11714 /* stop all timers */
11715 lpfc_stop_hba_timers(phba);
11716
11717 /* Disable interrupt and pci device */
11718 lpfc_sli4_disable_intr(phba);
11719 lpfc_sli4_queue_destroy(phba);
11720 pci_disable_device(phba->pcidev);
11721 }
11722
11723 /**
11724 * lpfc_sli4_prep_dev_for_perm_failure - Prepare SLI4 dev for pci slot disable
11725 * @phba: pointer to lpfc hba data structure.
11726 *
11727 * This routine is called to prepare the SLI4 device for PCI slot permanently
11728 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
11729 * pending I/Os.
11730 **/
11731 static void
11732 lpfc_sli4_prep_dev_for_perm_failure(struct lpfc_hba *phba)
11733 {
11734 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11735 "2827 PCI channel permanent disable for failure\n");
11736
11737 /* Block all SCSI devices' I/Os on the host */
11738 lpfc_scsi_dev_block(phba);
11739
11740 /* stop all timers */
11741 lpfc_stop_hba_timers(phba);
11742
11743 /* Clean up all driver's outstanding SCSI I/Os */
11744 lpfc_sli_flush_fcp_rings(phba);
11745
11746 /* Flush the outstanding NVME IOs if fc4 type enabled. */
11747 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
11748 lpfc_sli_flush_nvme_rings(phba);
11749 }
11750
11751 /**
11752 * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device
11753 * @pdev: pointer to PCI device.
11754 * @state: the current PCI connection state.
11755 *
11756 * This routine is called from the PCI subsystem for error handling to device
11757 * with SLI-4 interface spec. This function is called by the PCI subsystem
11758 * after a PCI bus error affecting this device has been detected. When this
11759 * function is invoked, it will need to stop all the I/Os and interrupt(s)
11760 * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET
11761 * for the PCI subsystem to perform proper recovery as desired.
11762 *
11763 * Return codes
11764 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
11765 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11766 **/
11767 static pci_ers_result_t
11768 lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state)
11769 {
11770 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11771 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11772
11773 switch (state) {
11774 case pci_channel_io_normal:
11775 /* Non-fatal error, prepare for recovery */
11776 lpfc_sli4_prep_dev_for_recover(phba);
11777 return PCI_ERS_RESULT_CAN_RECOVER;
11778 case pci_channel_io_frozen:
11779 /* Fatal error, prepare for slot reset */
11780 lpfc_sli4_prep_dev_for_reset(phba);
11781 return PCI_ERS_RESULT_NEED_RESET;
11782 case pci_channel_io_perm_failure:
11783 /* Permanent failure, prepare for device down */
11784 lpfc_sli4_prep_dev_for_perm_failure(phba);
11785 return PCI_ERS_RESULT_DISCONNECT;
11786 default:
11787 /* Unknown state, prepare and request slot reset */
11788 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11789 "2825 Unknown PCI error state: x%x\n", state);
11790 lpfc_sli4_prep_dev_for_reset(phba);
11791 return PCI_ERS_RESULT_NEED_RESET;
11792 }
11793 }
11794
11795 /**
11796 * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch
11797 * @pdev: pointer to PCI device.
11798 *
11799 * This routine is called from the PCI subsystem for error handling to device
11800 * with SLI-4 interface spec. It is called after PCI bus has been reset to
11801 * restart the PCI card from scratch, as if from a cold-boot. During the
11802 * PCI subsystem error recovery, after the driver returns
11803 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
11804 * recovery and then call this routine before calling the .resume method to
11805 * recover the device. This function will initialize the HBA device, enable
11806 * the interrupt, but it will just put the HBA to offline state without
11807 * passing any I/O traffic.
11808 *
11809 * Return codes
11810 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
11811 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11812 */
11813 static pci_ers_result_t
11814 lpfc_io_slot_reset_s4(struct pci_dev *pdev)
11815 {
11816 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11817 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11818 struct lpfc_sli *psli = &phba->sli;
11819 uint32_t intr_mode;
11820
11821 dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
11822 if (pci_enable_device_mem(pdev)) {
11823 printk(KERN_ERR "lpfc: Cannot re-enable "
11824 "PCI device after reset.\n");
11825 return PCI_ERS_RESULT_DISCONNECT;
11826 }
11827
11828 pci_restore_state(pdev);
11829
11830 /*
11831 * As the new kernel behavior of pci_restore_state() API call clears
11832 * device saved_state flag, need to save the restored state again.
11833 */
11834 pci_save_state(pdev);
11835
11836 if (pdev->is_busmaster)
11837 pci_set_master(pdev);
11838
11839 spin_lock_irq(&phba->hbalock);
11840 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
11841 spin_unlock_irq(&phba->hbalock);
11842
11843 /* Configure and enable interrupt */
11844 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
11845 if (intr_mode == LPFC_INTR_ERROR) {
11846 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11847 "2824 Cannot re-enable interrupt after "
11848 "slot reset.\n");
11849 return PCI_ERS_RESULT_DISCONNECT;
11850 } else
11851 phba->intr_mode = intr_mode;
11852
11853 /* Log the current active interrupt mode */
11854 lpfc_log_intr_mode(phba, phba->intr_mode);
11855
11856 return PCI_ERS_RESULT_RECOVERED;
11857 }
11858
11859 /**
11860 * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device
11861 * @pdev: pointer to PCI device
11862 *
11863 * This routine is called from the PCI subsystem for error handling to device
11864 * with SLI-4 interface spec. It is called when kernel error recovery tells
11865 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
11866 * error recovery. After this call, traffic can start to flow from this device
11867 * again.
11868 **/
11869 static void
11870 lpfc_io_resume_s4(struct pci_dev *pdev)
11871 {
11872 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11873 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11874
11875 /*
11876 * In case of slot reset, as function reset is performed through
11877 * mailbox command which needs DMA to be enabled, this operation
11878 * has to be moved to the io resume phase. Taking device offline
11879 * will perform the necessary cleanup.
11880 */
11881 if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {
11882 /* Perform device reset */
11883 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
11884 lpfc_offline(phba);
11885 lpfc_sli_brdrestart(phba);
11886 /* Bring the device back online */
11887 lpfc_online(phba);
11888 }
11889
11890 /* Clean up Advanced Error Reporting (AER) if needed */
11891 if (phba->hba_flag & HBA_AER_ENABLED)
11892 pci_cleanup_aer_uncorrect_error_status(pdev);
11893 }
11894
11895 /**
11896 * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
11897 * @pdev: pointer to PCI device
11898 * @pid: pointer to PCI device identifier
11899 *
11900 * This routine is to be registered to the kernel's PCI subsystem. When an
11901 * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
11902 * at PCI device-specific information of the device and driver to see if the
11903 * driver state that it can support this kind of device. If the match is
11904 * successful, the driver core invokes this routine. This routine dispatches
11905 * the action to the proper SLI-3 or SLI-4 device probing routine, which will
11906 * do all the initialization that it needs to do to handle the HBA device
11907 * properly.
11908 *
11909 * Return code
11910 * 0 - driver can claim the device
11911 * negative value - driver can not claim the device
11912 **/
11913 static int
11914 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
11915 {
11916 int rc;
11917 struct lpfc_sli_intf intf;
11918
11919 if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
11920 return -ENODEV;
11921
11922 if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
11923 (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
11924 rc = lpfc_pci_probe_one_s4(pdev, pid);
11925 else
11926 rc = lpfc_pci_probe_one_s3(pdev, pid);
11927
11928 return rc;
11929 }
11930
11931 /**
11932 * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
11933 * @pdev: pointer to PCI device
11934 *
11935 * This routine is to be registered to the kernel's PCI subsystem. When an
11936 * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
11937 * This routine dispatches the action to the proper SLI-3 or SLI-4 device
11938 * remove routine, which will perform all the necessary cleanup for the
11939 * device to be removed from the PCI subsystem properly.
11940 **/
11941 static void
11942 lpfc_pci_remove_one(struct pci_dev *pdev)
11943 {
11944 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11945 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11946
11947 switch (phba->pci_dev_grp) {
11948 case LPFC_PCI_DEV_LP:
11949 lpfc_pci_remove_one_s3(pdev);
11950 break;
11951 case LPFC_PCI_DEV_OC:
11952 lpfc_pci_remove_one_s4(pdev);
11953 break;
11954 default:
11955 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11956 "1424 Invalid PCI device group: 0x%x\n",
11957 phba->pci_dev_grp);
11958 break;
11959 }
11960 return;
11961 }
11962
11963 /**
11964 * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
11965 * @pdev: pointer to PCI device
11966 * @msg: power management message
11967 *
11968 * This routine is to be registered to the kernel's PCI subsystem to support
11969 * system Power Management (PM). When PM invokes this method, it dispatches
11970 * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
11971 * suspend the device.
11972 *
11973 * Return code
11974 * 0 - driver suspended the device
11975 * Error otherwise
11976 **/
11977 static int
11978 lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
11979 {
11980 struct Scsi_Host *shost = pci_get_drvdata(pdev);
11981 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11982 int rc = -ENODEV;
11983
11984 switch (phba->pci_dev_grp) {
11985 case LPFC_PCI_DEV_LP:
11986 rc = lpfc_pci_suspend_one_s3(pdev, msg);
11987 break;
11988 case LPFC_PCI_DEV_OC:
11989 rc = lpfc_pci_suspend_one_s4(pdev, msg);
11990 break;
11991 default:
11992 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11993 "1425 Invalid PCI device group: 0x%x\n",
11994 phba->pci_dev_grp);
11995 break;
11996 }
11997 return rc;
11998 }
11999
12000 /**
12001 * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
12002 * @pdev: pointer to PCI device
12003 *
12004 * This routine is to be registered to the kernel's PCI subsystem to support
12005 * system Power Management (PM). When PM invokes this method, it dispatches
12006 * the action to the proper SLI-3 or SLI-4 device resume routine, which will
12007 * resume the device.
12008 *
12009 * Return code
12010 * 0 - driver suspended the device
12011 * Error otherwise
12012 **/
12013 static int
12014 lpfc_pci_resume_one(struct pci_dev *pdev)
12015 {
12016 struct Scsi_Host *shost = pci_get_drvdata(pdev);
12017 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
12018 int rc = -ENODEV;
12019
12020 switch (phba->pci_dev_grp) {
12021 case LPFC_PCI_DEV_LP:
12022 rc = lpfc_pci_resume_one_s3(pdev);
12023 break;
12024 case LPFC_PCI_DEV_OC:
12025 rc = lpfc_pci_resume_one_s4(pdev);
12026 break;
12027 default:
12028 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
12029 "1426 Invalid PCI device group: 0x%x\n",
12030 phba->pci_dev_grp);
12031 break;
12032 }
12033 return rc;
12034 }
12035
12036 /**
12037 * lpfc_io_error_detected - lpfc method for handling PCI I/O error
12038 * @pdev: pointer to PCI device.
12039 * @state: the current PCI connection state.
12040 *
12041 * This routine is registered to the PCI subsystem for error handling. This
12042 * function is called by the PCI subsystem after a PCI bus error affecting
12043 * this device has been detected. When this routine is invoked, it dispatches
12044 * the action to the proper SLI-3 or SLI-4 device error detected handling
12045 * routine, which will perform the proper error detected operation.
12046 *
12047 * Return codes
12048 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
12049 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
12050 **/
12051 static pci_ers_result_t
12052 lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
12053 {
12054 struct Scsi_Host *shost = pci_get_drvdata(pdev);
12055 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
12056 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
12057
12058 switch (phba->pci_dev_grp) {
12059 case LPFC_PCI_DEV_LP:
12060 rc = lpfc_io_error_detected_s3(pdev, state);
12061 break;
12062 case LPFC_PCI_DEV_OC:
12063 rc = lpfc_io_error_detected_s4(pdev, state);
12064 break;
12065 default:
12066 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
12067 "1427 Invalid PCI device group: 0x%x\n",
12068 phba->pci_dev_grp);
12069 break;
12070 }
12071 return rc;
12072 }
12073
12074 /**
12075 * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
12076 * @pdev: pointer to PCI device.
12077 *
12078 * This routine is registered to the PCI subsystem for error handling. This
12079 * function is called after PCI bus has been reset to restart the PCI card
12080 * from scratch, as if from a cold-boot. When this routine is invoked, it
12081 * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
12082 * routine, which will perform the proper device reset.
12083 *
12084 * Return codes
12085 * PCI_ERS_RESULT_RECOVERED - the device has been recovered
12086 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
12087 **/
12088 static pci_ers_result_t
12089 lpfc_io_slot_reset(struct pci_dev *pdev)
12090 {
12091 struct Scsi_Host *shost = pci_get_drvdata(pdev);
12092 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
12093 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
12094
12095 switch (phba->pci_dev_grp) {
12096 case LPFC_PCI_DEV_LP:
12097 rc = lpfc_io_slot_reset_s3(pdev);
12098 break;
12099 case LPFC_PCI_DEV_OC:
12100 rc = lpfc_io_slot_reset_s4(pdev);
12101 break;
12102 default:
12103 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
12104 "1428 Invalid PCI device group: 0x%x\n",
12105 phba->pci_dev_grp);
12106 break;
12107 }
12108 return rc;
12109 }
12110
12111 /**
12112 * lpfc_io_resume - lpfc method for resuming PCI I/O operation
12113 * @pdev: pointer to PCI device
12114 *
12115 * This routine is registered to the PCI subsystem for error handling. It
12116 * is called when kernel error recovery tells the lpfc driver that it is
12117 * OK to resume normal PCI operation after PCI bus error recovery. When
12118 * this routine is invoked, it dispatches the action to the proper SLI-3
12119 * or SLI-4 device io_resume routine, which will resume the device operation.
12120 **/
12121 static void
12122 lpfc_io_resume(struct pci_dev *pdev)
12123 {
12124 struct Scsi_Host *shost = pci_get_drvdata(pdev);
12125 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
12126
12127 switch (phba->pci_dev_grp) {
12128 case LPFC_PCI_DEV_LP:
12129 lpfc_io_resume_s3(pdev);
12130 break;
12131 case LPFC_PCI_DEV_OC:
12132 lpfc_io_resume_s4(pdev);
12133 break;
12134 default:
12135 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
12136 "1429 Invalid PCI device group: 0x%x\n",
12137 phba->pci_dev_grp);
12138 break;
12139 }
12140 return;
12141 }
12142
12143 /**
12144 * lpfc_sli4_oas_verify - Verify OAS is supported by this adapter
12145 * @phba: pointer to lpfc hba data structure.
12146 *
12147 * This routine checks to see if OAS is supported for this adapter. If
12148 * supported, the configure Flash Optimized Fabric flag is set. Otherwise,
12149 * the enable oas flag is cleared and the pool created for OAS device data
12150 * is destroyed.
12151 *
12152 **/
12153 void
12154 lpfc_sli4_oas_verify(struct lpfc_hba *phba)
12155 {
12156
12157 if (!phba->cfg_EnableXLane)
12158 return;
12159
12160 if (phba->sli4_hba.pc_sli4_params.oas_supported) {
12161 phba->cfg_fof = 1;
12162 } else {
12163 phba->cfg_fof = 0;
12164 if (phba->device_data_mem_pool)
12165 mempool_destroy(phba->device_data_mem_pool);
12166 phba->device_data_mem_pool = NULL;
12167 }
12168
12169 return;
12170 }
12171
12172 /**
12173 * lpfc_fof_queue_setup - Set up all the fof queues
12174 * @phba: pointer to lpfc hba data structure.
12175 *
12176 * This routine is invoked to set up all the fof queues for the FC HBA
12177 * operation.
12178 *
12179 * Return codes
12180 * 0 - successful
12181 * -ENOMEM - No available memory
12182 **/
12183 int
12184 lpfc_fof_queue_setup(struct lpfc_hba *phba)
12185 {
12186 struct lpfc_sli_ring *pring;
12187 int rc;
12188
12189 rc = lpfc_eq_create(phba, phba->sli4_hba.fof_eq, LPFC_MAX_IMAX);
12190 if (rc)
12191 return -ENOMEM;
12192
12193 if (phba->cfg_fof) {
12194
12195 rc = lpfc_cq_create(phba, phba->sli4_hba.oas_cq,
12196 phba->sli4_hba.fof_eq, LPFC_WCQ, LPFC_FCP);
12197 if (rc)
12198 goto out_oas_cq;
12199
12200 rc = lpfc_wq_create(phba, phba->sli4_hba.oas_wq,
12201 phba->sli4_hba.oas_cq, LPFC_FCP);
12202 if (rc)
12203 goto out_oas_wq;
12204
12205 /* Bind this CQ/WQ to the NVME ring */
12206 pring = phba->sli4_hba.oas_wq->pring;
12207 pring->sli.sli4.wqp =
12208 (void *)phba->sli4_hba.oas_wq;
12209 phba->sli4_hba.oas_cq->pring = pring;
12210 }
12211
12212 return 0;
12213
12214 out_oas_wq:
12215 lpfc_cq_destroy(phba, phba->sli4_hba.oas_cq);
12216 out_oas_cq:
12217 lpfc_eq_destroy(phba, phba->sli4_hba.fof_eq);
12218 return rc;
12219
12220 }
12221
12222 /**
12223 * lpfc_fof_queue_create - Create all the fof queues
12224 * @phba: pointer to lpfc hba data structure.
12225 *
12226 * This routine is invoked to allocate all the fof queues for the FC HBA
12227 * operation. For each SLI4 queue type, the parameters such as queue entry
12228 * count (queue depth) shall be taken from the module parameter. For now,
12229 * we just use some constant number as place holder.
12230 *
12231 * Return codes
12232 * 0 - successful
12233 * -ENOMEM - No availble memory
12234 * -EIO - The mailbox failed to complete successfully.
12235 **/
12236 int
12237 lpfc_fof_queue_create(struct lpfc_hba *phba)
12238 {
12239 struct lpfc_queue *qdesc;
12240 uint32_t wqesize;
12241
12242 /* Create FOF EQ */
12243 qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
12244 phba->sli4_hba.eq_esize,
12245 phba->sli4_hba.eq_ecount);
12246 if (!qdesc)
12247 goto out_error;
12248
12249 phba->sli4_hba.fof_eq = qdesc;
12250
12251 if (phba->cfg_fof) {
12252
12253 /* Create OAS CQ */
12254 if (phba->enab_exp_wqcq_pages)
12255 qdesc = lpfc_sli4_queue_alloc(phba,
12256 LPFC_EXPANDED_PAGE_SIZE,
12257 phba->sli4_hba.cq_esize,
12258 LPFC_CQE_EXP_COUNT);
12259 else
12260 qdesc = lpfc_sli4_queue_alloc(phba,
12261 LPFC_DEFAULT_PAGE_SIZE,
12262 phba->sli4_hba.cq_esize,
12263 phba->sli4_hba.cq_ecount);
12264 if (!qdesc)
12265 goto out_error;
12266
12267 phba->sli4_hba.oas_cq = qdesc;
12268
12269 /* Create OAS WQ */
12270 if (phba->enab_exp_wqcq_pages) {
12271 wqesize = (phba->fcp_embed_io) ?
12272 LPFC_WQE128_SIZE : phba->sli4_hba.wq_esize;
12273 qdesc = lpfc_sli4_queue_alloc(phba,
12274 LPFC_EXPANDED_PAGE_SIZE,
12275 wqesize,
12276 LPFC_WQE_EXP_COUNT);
12277 } else
12278 qdesc = lpfc_sli4_queue_alloc(phba,
12279 LPFC_DEFAULT_PAGE_SIZE,
12280 phba->sli4_hba.wq_esize,
12281 phba->sli4_hba.wq_ecount);
12282
12283 if (!qdesc)
12284 goto out_error;
12285
12286 phba->sli4_hba.oas_wq = qdesc;
12287 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
12288
12289 }
12290 return 0;
12291
12292 out_error:
12293 lpfc_fof_queue_destroy(phba);
12294 return -ENOMEM;
12295 }
12296
12297 /**
12298 * lpfc_fof_queue_destroy - Destroy all the fof queues
12299 * @phba: pointer to lpfc hba data structure.
12300 *
12301 * This routine is invoked to release all the SLI4 queues with the FC HBA
12302 * operation.
12303 *
12304 * Return codes
12305 * 0 - successful
12306 **/
12307 int
12308 lpfc_fof_queue_destroy(struct lpfc_hba *phba)
12309 {
12310 /* Release FOF Event queue */
12311 if (phba->sli4_hba.fof_eq != NULL) {
12312 lpfc_sli4_queue_free(phba->sli4_hba.fof_eq);
12313 phba->sli4_hba.fof_eq = NULL;
12314 }
12315
12316 /* Release OAS Completion queue */
12317 if (phba->sli4_hba.oas_cq != NULL) {
12318 lpfc_sli4_queue_free(phba->sli4_hba.oas_cq);
12319 phba->sli4_hba.oas_cq = NULL;
12320 }
12321
12322 /* Release OAS Work queue */
12323 if (phba->sli4_hba.oas_wq != NULL) {
12324 lpfc_sli4_queue_free(phba->sli4_hba.oas_wq);
12325 phba->sli4_hba.oas_wq = NULL;
12326 }
12327 return 0;
12328 }
12329
12330 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
12331
12332 static const struct pci_error_handlers lpfc_err_handler = {
12333 .error_detected = lpfc_io_error_detected,
12334 .slot_reset = lpfc_io_slot_reset,
12335 .resume = lpfc_io_resume,
12336 };
12337
12338 static struct pci_driver lpfc_driver = {
12339 .name = LPFC_DRIVER_NAME,
12340 .id_table = lpfc_id_table,
12341 .probe = lpfc_pci_probe_one,
12342 .remove = lpfc_pci_remove_one,
12343 .shutdown = lpfc_pci_remove_one,
12344 .suspend = lpfc_pci_suspend_one,
12345 .resume = lpfc_pci_resume_one,
12346 .err_handler = &lpfc_err_handler,
12347 };
12348
12349 static const struct file_operations lpfc_mgmt_fop = {
12350 .owner = THIS_MODULE,
12351 };
12352
12353 static struct miscdevice lpfc_mgmt_dev = {
12354 .minor = MISC_DYNAMIC_MINOR,
12355 .name = "lpfcmgmt",
12356 .fops = &lpfc_mgmt_fop,
12357 };
12358
12359 /**
12360 * lpfc_init - lpfc module initialization routine
12361 *
12362 * This routine is to be invoked when the lpfc module is loaded into the
12363 * kernel. The special kernel macro module_init() is used to indicate the
12364 * role of this routine to the kernel as lpfc module entry point.
12365 *
12366 * Return codes
12367 * 0 - successful
12368 * -ENOMEM - FC attach transport failed
12369 * all others - failed
12370 */
12371 static int __init
12372 lpfc_init(void)
12373 {
12374 int error = 0;
12375
12376 printk(LPFC_MODULE_DESC "\n");
12377 printk(LPFC_COPYRIGHT "\n");
12378
12379 error = misc_register(&lpfc_mgmt_dev);
12380 if (error)
12381 printk(KERN_ERR "Could not register lpfcmgmt device, "
12382 "misc_register returned with status %d", error);
12383
12384 lpfc_transport_functions.vport_create = lpfc_vport_create;
12385 lpfc_transport_functions.vport_delete = lpfc_vport_delete;
12386 lpfc_transport_template =
12387 fc_attach_transport(&lpfc_transport_functions);
12388 if (lpfc_transport_template == NULL)
12389 return -ENOMEM;
12390 lpfc_vport_transport_template =
12391 fc_attach_transport(&lpfc_vport_transport_functions);
12392 if (lpfc_vport_transport_template == NULL) {
12393 fc_release_transport(lpfc_transport_template);
12394 return -ENOMEM;
12395 }
12396
12397 /* Initialize in case vector mapping is needed */
12398 lpfc_used_cpu = NULL;
12399 lpfc_present_cpu = num_present_cpus();
12400
12401 error = pci_register_driver(&lpfc_driver);
12402 if (error) {
12403 fc_release_transport(lpfc_transport_template);
12404 fc_release_transport(lpfc_vport_transport_template);
12405 }
12406
12407 return error;
12408 }
12409
12410 /**
12411 * lpfc_exit - lpfc module removal routine
12412 *
12413 * This routine is invoked when the lpfc module is removed from the kernel.
12414 * The special kernel macro module_exit() is used to indicate the role of
12415 * this routine to the kernel as lpfc module exit point.
12416 */
12417 static void __exit
12418 lpfc_exit(void)
12419 {
12420 misc_deregister(&lpfc_mgmt_dev);
12421 pci_unregister_driver(&lpfc_driver);
12422 fc_release_transport(lpfc_transport_template);
12423 fc_release_transport(lpfc_vport_transport_template);
12424 if (_dump_buf_data) {
12425 printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for "
12426 "_dump_buf_data at 0x%p\n",
12427 (1L << _dump_buf_data_order), _dump_buf_data);
12428 free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
12429 }
12430
12431 if (_dump_buf_dif) {
12432 printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for "
12433 "_dump_buf_dif at 0x%p\n",
12434 (1L << _dump_buf_dif_order), _dump_buf_dif);
12435 free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
12436 }
12437 kfree(lpfc_used_cpu);
12438 idr_destroy(&lpfc_hba_index);
12439 }
12440
12441 module_init(lpfc_init);
12442 module_exit(lpfc_exit);
12443 MODULE_LICENSE("GPL");
12444 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
12445 MODULE_AUTHOR("Broadcom");
12446 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);
ubuntu-bionic-kernel mirror