drivers/scsi/elx/efct/efct_driver.c - SHIFTPHONES/mainline/linux - Gitiles

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
  */

 #include "efct_driver.h"

 #include "efct_hw.h"
 #include "efct_unsol.h"
 #include "efct_scsi.h"

 LIST_HEAD(efct_devices);

 static int logmask;
 module_param(logmask, int, 0444);
 MODULE_PARM_DESC(logmask, "logging bitmask (default 0)");

 static struct libefc_function_template efct_libefc_templ = {
 	.issue_mbox_rqst = efct_issue_mbox_rqst,
 	.send_els = efct_els_hw_srrs_send,
 	.send_bls = efct_efc_bls_send,

 	.new_nport = efct_scsi_tgt_new_nport,
 	.del_nport = efct_scsi_tgt_del_nport,
 	.scsi_new_node = efct_scsi_new_initiator,
 	.scsi_del_node = efct_scsi_del_initiator,
 	.hw_seq_free = efct_efc_hw_sequence_free,
 };

 static int
 efct_device_init(void)
 {
 	int rc;

 	/* driver-wide init for target-server */
 	rc = efct_scsi_tgt_driver_init();
 	if (rc) {
 		pr_err("efct_scsi_tgt_init failed rc=%d\n", rc);
 		return rc;
 	}

 	rc = efct_scsi_reg_fc_transport();
 	if (rc) {
 		pr_err("failed to register to FC host\n");
 		return rc;
 	}

 	return 0;
 }

 static void
 efct_device_shutdown(void)
 {
 	efct_scsi_release_fc_transport();

 	efct_scsi_tgt_driver_exit();
 }

 static void *
 efct_device_alloc(u32 nid)
 {
 	struct efct *efct = NULL;

 	efct = kzalloc_node(sizeof(*efct), GFP_KERNEL, nid);
 	if (!efct)
 		return efct;

 	INIT_LIST_HEAD(&efct->list_entry);
 	list_add_tail(&efct->list_entry, &efct_devices);

 	return efct;
 }

 static void
 efct_teardown_msix(struct efct *efct)
 {
 	u32 i;

 	for (i = 0; i < efct->n_msix_vec; i++) {
 		free_irq(pci_irq_vector(efct->pci, i),
 			 &efct->intr_context[i]);
 	}

 	pci_free_irq_vectors(efct->pci);
 }

 static int
 efct_efclib_config(struct efct *efct, struct libefc_function_template *tt)
 {
 	struct efc *efc;
 	struct sli4 *sli;
 	int rc = 0;

 	efc = kzalloc(sizeof(*efc), GFP_KERNEL);
 	if (!efc)
 		return -ENOMEM;

 	efct->efcport = efc;

 	memcpy(&efc->tt, tt, sizeof(*tt));
 	efc->base = efct;
 	efc->pci = efct->pci;

 	efc->def_wwnn = efct_get_wwnn(&efct->hw);
 	efc->def_wwpn = efct_get_wwpn(&efct->hw);
 	efc->enable_tgt = 1;
 	efc->log_level = EFC_LOG_LIB;

 	sli = &efct->hw.sli;
 	efc->max_xfer_size = sli->sge_supported_length *
 			     sli_get_max_sgl(&efct->hw.sli);
 	efc->sli = sli;
 	efc->fcfi = efct->hw.fcf_indicator;

 	rc = efcport_init(efc);
 	if (rc)
 		efc_log_err(efc, "efcport_init failed\n");

 	return rc;
 }

 static int efct_request_firmware_update(struct efct *efct);

 static const char*
 efct_pci_model(u16 device)
 {
 	switch (device) {
 	case EFCT_DEVICE_LANCER_G6:	return "LPE31004";
 	case EFCT_DEVICE_LANCER_G7:	return "LPE36000";
 	default:			return "unknown";
 	}
 }

 static int
 efct_device_attach(struct efct *efct)
 {
 	u32 rc = 0, i = 0;

 	if (efct->attached) {
 		efc_log_err(efct, "Device is already attached\n");
 		return -EIO;
 	}

 	snprintf(efct->name, sizeof(efct->name), "[%s%d] ", "fc",
 		 efct->instance_index);

 	efct->logmask = logmask;
 	efct->filter_def = EFCT_DEFAULT_FILTER;
 	efct->max_isr_time_msec = EFCT_OS_MAX_ISR_TIME_MSEC;

 	efct->model = efct_pci_model(efct->pci->device);

 	efct->efct_req_fw_upgrade = true;

 	/* Allocate transport object and bring online */
 	efct->xport = efct_xport_alloc(efct);
 	if (!efct->xport) {
 		efc_log_err(efct, "failed to allocate transport object\n");
 		rc = -ENOMEM;
 		goto out;
 	}

 	rc = efct_xport_attach(efct->xport);
 	if (rc) {
 		efc_log_err(efct, "failed to attach transport object\n");
 		goto xport_out;
 	}

 	rc = efct_xport_initialize(efct->xport);
 	if (rc) {
 		efc_log_err(efct, "failed to initialize transport object\n");
 		goto xport_out;
 	}

 	rc = efct_efclib_config(efct, &efct_libefc_templ);
 	if (rc) {
 		efc_log_err(efct, "failed to init efclib\n");
 		goto efclib_out;
 	}

 	for (i = 0; i < efct->n_msix_vec; i++) {
 		efc_log_debug(efct, "irq %d enabled\n", i);
 		enable_irq(pci_irq_vector(efct->pci, i));
 	}

 	efct->attached = true;

 	if (efct->efct_req_fw_upgrade)
 		efct_request_firmware_update(efct);

 	return rc;

 efclib_out:
 	efct_xport_detach(efct->xport);
 xport_out:
 	efct_xport_free(efct->xport);
 	efct->xport = NULL;
 out:
 	return rc;
 }

 static int
 efct_device_detach(struct efct *efct)
 {
 	int i;

 	if (!efct || !efct->attached) {
 		pr_err("Device is not attached\n");
 		return -EIO;
 	}

 	if (efct_xport_control(efct->xport, EFCT_XPORT_SHUTDOWN))
 		efc_log_err(efct, "Transport Shutdown timed out\n");

 	for (i = 0; i < efct->n_msix_vec; i++)
 		disable_irq(pci_irq_vector(efct->pci, i));

 	efct_xport_detach(efct->xport);

 	efct_xport_free(efct->xport);
 	efct->xport = NULL;

 	efcport_destroy(efct->efcport);
 	kfree(efct->efcport);

 	efct->attached = false;

 	return 0;
 }

 static void
 efct_fw_write_cb(int status, u32 actual_write_length,
 		 u32 change_status, void *arg)
 {
 	struct efct_fw_write_result *result = arg;

 	result->status = status;
 	result->actual_xfer = actual_write_length;
 	result->change_status = change_status;

 	complete(&result->done);
 }

 static int
 efct_firmware_write(struct efct *efct, const u8 *buf, size_t buf_len,
 		    u8 *change_status)
 {
 	int rc = 0;
 	u32 bytes_left;
 	u32 xfer_size;
 	u32 offset;
 	struct efc_dma dma;
 	int last = 0;
 	struct efct_fw_write_result result;

 	init_completion(&result.done);

 	bytes_left = buf_len;
 	offset = 0;

 	dma.size = FW_WRITE_BUFSIZE;
 	dma.virt = dma_alloc_coherent(&efct->pci->dev,
 				      dma.size, &dma.phys, GFP_KERNEL);
 	if (!dma.virt)
 		return -ENOMEM;

 	while (bytes_left > 0) {
 		if (bytes_left > FW_WRITE_BUFSIZE)
 			xfer_size = FW_WRITE_BUFSIZE;
 		else
 			xfer_size = bytes_left;

 		memcpy(dma.virt, buf + offset, xfer_size);

 		if (bytes_left == xfer_size)
 			last = 1;

 		efct_hw_firmware_write(&efct->hw, &dma, xfer_size, offset,
 				       last, efct_fw_write_cb, &result);

 		if (wait_for_completion_interruptible(&result.done) != 0) {
 			rc = -ENXIO;
 			break;
 		}

 		if (result.actual_xfer == 0 || result.status != 0) {
 			rc = -EFAULT;
 			break;
 		}

 		if (last)
 			*change_status = result.change_status;

 		bytes_left -= result.actual_xfer;
 		offset += result.actual_xfer;
 	}

 	dma_free_coherent(&efct->pci->dev, dma.size, dma.virt, dma.phys);
 	return rc;
 }

 static int
 efct_fw_reset(struct efct *efct)
 {
 	/*
 	 * Firmware reset to activate the new firmware.
 	 * Function 0 will update and load the new firmware
 	 * during attach.
 	 */
 	if (timer_pending(&efct->xport->stats_timer))
 		del_timer(&efct->xport->stats_timer);

 	if (efct_hw_reset(&efct->hw, EFCT_HW_RESET_FIRMWARE)) {
 		efc_log_info(efct, "failed to reset firmware\n");
 		return -EIO;
 	}

 	efc_log_info(efct, "successfully reset firmware.Now resetting port\n");

 	efct_device_detach(efct);
 	return efct_device_attach(efct);
 }

 static int
 efct_request_firmware_update(struct efct *efct)
 {
 	int rc = 0;
 	u8 file_name[256], fw_change_status = 0;
 	const struct firmware *fw;
 	struct efct_hw_grp_hdr *fw_image;

 	snprintf(file_name, 256, "%s.grp", efct->model);

 	rc = request_firmware(&fw, file_name, &efct->pci->dev);
 	if (rc) {
 		efc_log_debug(efct, "Firmware file(%s) not found.\n", file_name);
 		return rc;
 	}

 	fw_image = (struct efct_hw_grp_hdr *)fw->data;

 	if (!strncmp(efct->hw.sli.fw_name[0], fw_image->revision,
 		     strnlen(fw_image->revision, 16))) {
 		efc_log_debug(efct,
 			      "Skip update. Firmware is already up to date.\n");
 		goto exit;
 	}

 	efc_log_info(efct, "Firmware update is initiated. %s -> %s\n",
 		     efct->hw.sli.fw_name[0], fw_image->revision);

 	rc = efct_firmware_write(efct, fw->data, fw->size, &fw_change_status);
 	if (rc) {
 		efc_log_err(efct, "Firmware update failed. rc = %d\n", rc);
 		goto exit;
 	}

 	efc_log_info(efct, "Firmware updated successfully\n");
 	switch (fw_change_status) {
 	case 0x00:
 		efc_log_info(efct, "New firmware is active.\n");
 		break;
 	case 0x01:
 		efc_log_info(efct,
 			"System reboot needed to activate the new firmware\n");
 		break;
 	case 0x02:
 	case 0x03:
 		efc_log_info(efct,
 			     "firmware reset to activate the new firmware\n");
 		efct_fw_reset(efct);
 		break;
 	default:
 		efc_log_info(efct, "Unexpected value change_status:%d\n",
 			     fw_change_status);
 		break;
 	}

 exit:
 	release_firmware(fw);

 	return rc;
 }

 static void
 efct_device_free(struct efct *efct)
 {
 	if (efct) {
 		list_del(&efct->list_entry);
 		kfree(efct);
 	}
 }

 static int
 efct_device_interrupts_required(struct efct *efct)
 {
 	int rc;

 	rc = efct_hw_setup(&efct->hw, efct, efct->pci);
 	if (rc < 0)
 		return rc;

 	return efct->hw.config.n_eq;
 }

 static irqreturn_t
 efct_intr_thread(int irq, void *handle)
 {
 	struct efct_intr_context *intr_ctx = handle;
 	struct efct *efct = intr_ctx->efct;

 	efct_hw_process(&efct->hw, intr_ctx->index, efct->max_isr_time_msec);
 	return IRQ_HANDLED;
 }

 static irqreturn_t
 efct_intr_msix(int irq, void *handle)
 {
 	return IRQ_WAKE_THREAD;
 }

 static int
 efct_setup_msix(struct efct *efct, u32 num_intrs)
 {
 	int rc = 0, i;

 	if (!pci_find_capability(efct->pci, PCI_CAP_ID_MSIX)) {
 		dev_err(&efct->pci->dev,
 			"%s : MSI-X not available\n", __func__);
 		return -EIO;
 	}

 	efct->n_msix_vec = num_intrs;

 	rc = pci_alloc_irq_vectors(efct->pci, num_intrs, num_intrs,
 				   PCI_IRQ_MSIX | PCI_IRQ_AFFINITY);

 	if (rc < 0) {
 		dev_err(&efct->pci->dev, "Failed to alloc irq : %d\n", rc);
 		return rc;
 	}

 	for (i = 0; i < num_intrs; i++) {
 		struct efct_intr_context *intr_ctx = NULL;

 		intr_ctx = &efct->intr_context[i];
 		intr_ctx->efct = efct;
 		intr_ctx->index = i;

 		rc = request_threaded_irq(pci_irq_vector(efct->pci, i),
 					  efct_intr_msix, efct_intr_thread, 0,
 					  EFCT_DRIVER_NAME, intr_ctx);
 		if (rc) {
 			dev_err(&efct->pci->dev,
 				"Failed to register %d vector: %d\n", i, rc);
 			goto out;
 		}
 	}

 	return rc;

 out:
 	while (--i >= 0)
 		free_irq(pci_irq_vector(efct->pci, i),
 			 &efct->intr_context[i]);

 	pci_free_irq_vectors(efct->pci);
 	return rc;
 }

 static struct pci_device_id efct_pci_table[] = {
 	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G6), 0},
 	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G7), 0},
 	{}	/* terminate list */
 };

 static int
 efct_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
 	struct efct *efct = NULL;
 	int rc;
 	u32 i, r;
 	int num_interrupts = 0;
 	int nid;

 	dev_info(&pdev->dev, "%s\n", EFCT_DRIVER_NAME);

 	rc = pci_enable_device_mem(pdev);
 	if (rc)
 		return rc;

 	pci_set_master(pdev);

 	rc = pci_set_mwi(pdev);
 	if (rc) {
 		dev_info(&pdev->dev, "pci_set_mwi returned %d\n", rc);
 		goto mwi_out;
 	}

 	rc = pci_request_regions(pdev, EFCT_DRIVER_NAME);
 	if (rc) {
 		dev_err(&pdev->dev, "pci_request_regions failed %d\n", rc);
 		goto req_regions_out;
 	}

 	/* Fetch the Numa node id for this device */
 	nid = dev_to_node(&pdev->dev);
 	if (nid < 0) {
 		dev_err(&pdev->dev, "Warning Numa node ID is %d\n", nid);
 		nid = 0;
 	}

 	/* Allocate efct */
 	efct = efct_device_alloc(nid);
 	if (!efct) {
 		dev_err(&pdev->dev, "Failed to allocate efct\n");
 		rc = -ENOMEM;
 		goto alloc_out;
 	}

 	efct->pci = pdev;
 	efct->numa_node = nid;

 	/* Map all memory BARs */
 	for (i = 0, r = 0; i < EFCT_PCI_MAX_REGS; i++) {
 		if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
 			efct->reg[r] = ioremap(pci_resource_start(pdev, i),
 					       pci_resource_len(pdev, i));
 			r++;
 		}

 		/*
 		 * If the 64-bit attribute is set, both this BAR and the
 		 * next form the complete address. Skip processing the
 		 * next BAR.
 		 */
 		if (pci_resource_flags(pdev, i) & IORESOURCE_MEM_64)
 			i++;
 	}

 	pci_set_drvdata(pdev, efct);

 	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
 	if (rc) {
 		dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n");
 		goto dma_mask_out;
 	}

 	num_interrupts = efct_device_interrupts_required(efct);
 	if (num_interrupts < 0) {
 		efc_log_err(efct, "efct_device_interrupts_required failed\n");
 		rc = -1;
 		goto dma_mask_out;
 	}

 	/*
 	 * Initialize MSIX interrupts, note,
 	 * efct_setup_msix() enables the interrupt
 	 */
 	rc = efct_setup_msix(efct, num_interrupts);
 	if (rc) {
 		dev_err(&pdev->dev, "Can't setup msix\n");
 		goto dma_mask_out;
 	}
 	/* Disable interrupt for now */
 	for (i = 0; i < efct->n_msix_vec; i++) {
 		efc_log_debug(efct, "irq %d disabled\n", i);
 		disable_irq(pci_irq_vector(efct->pci, i));
 	}

 	rc = efct_device_attach(efct);
 	if (rc)
 		goto attach_out;

 	return 0;

 attach_out:
 	efct_teardown_msix(efct);
 dma_mask_out:
 	pci_set_drvdata(pdev, NULL);

 	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
 		if (efct->reg[i])
 			iounmap(efct->reg[i]);
 	}
 	efct_device_free(efct);
 alloc_out:
 	pci_release_regions(pdev);
 req_regions_out:
 	pci_clear_mwi(pdev);
 mwi_out:
 	pci_disable_device(pdev);
 	return rc;
 }

 static void
 efct_pci_remove(struct pci_dev *pdev)
 {
 	struct efct *efct = pci_get_drvdata(pdev);
 	u32 i;

 	if (!efct)
 		return;

 	efct_device_detach(efct);

 	efct_teardown_msix(efct);

 	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
 		if (efct->reg[i])
 			iounmap(efct->reg[i]);
 	}

 	pci_set_drvdata(pdev, NULL);

 	efct_device_free(efct);

 	pci_release_regions(pdev);

 	pci_disable_device(pdev);
 }

 static void
 efct_device_prep_for_reset(struct efct *efct, struct pci_dev *pdev)
 {
 	if (efct) {
 		efc_log_debug(efct,
 			      "PCI channel disable preparing for reset\n");
 		efct_device_detach(efct);
 		/* Disable interrupt and pci device */
 		efct_teardown_msix(efct);
 	}
 	pci_disable_device(pdev);
 }

 static void
 efct_device_prep_for_recover(struct efct *efct)
 {
 	if (efct) {
 		efc_log_debug(efct, "PCI channel preparing for recovery\n");
 		efct_hw_io_abort_all(&efct->hw);
 	}
 }

 /**
  * efct_pci_io_error_detected - method for handling PCI I/O error
  * @pdev: pointer to PCI device.
  * @state: the current PCI connection state.
  *
  * This routine is registered to the PCI subsystem for error handling. This
  * function is called by the PCI subsystem after a PCI bus error affecting
  * this device has been detected. When this routine is invoked, it dispatches
  * device error detected handling routine, which will perform the proper
  * error detected operation.
  *
  * Return codes
  * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
  * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
  */
 static pci_ers_result_t
 efct_pci_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
 {
 	struct efct *efct = pci_get_drvdata(pdev);
 	pci_ers_result_t rc;

 	switch (state) {
 	case pci_channel_io_normal:
 		efct_device_prep_for_recover(efct);
 		rc = PCI_ERS_RESULT_CAN_RECOVER;
 		break;
 	case pci_channel_io_frozen:
 		efct_device_prep_for_reset(efct, pdev);
 		rc = PCI_ERS_RESULT_NEED_RESET;
 		break;
 	case pci_channel_io_perm_failure:
 		efct_device_detach(efct);
 		rc = PCI_ERS_RESULT_DISCONNECT;
 		break;
 	default:
 		efc_log_debug(efct, "Unknown PCI error state:0x%x\n", state);
 		efct_device_prep_for_reset(efct, pdev);
 		rc = PCI_ERS_RESULT_NEED_RESET;
 		break;
 	}

 	return rc;
 }

 static pci_ers_result_t
 efct_pci_io_slot_reset(struct pci_dev *pdev)
 {
 	int rc;
 	struct efct *efct = pci_get_drvdata(pdev);

 	rc = pci_enable_device_mem(pdev);
 	if (rc) {
 		efc_log_err(efct, "failed to enable PCI device after reset\n");
 		return PCI_ERS_RESULT_DISCONNECT;
 	}

 	/*
 	 * As the new kernel behavior of pci_restore_state() API call clears
 	 * device saved_state flag, need to save the restored state again.
 	 */

 	pci_save_state(pdev);

 	pci_set_master(pdev);

 	rc = efct_setup_msix(efct, efct->n_msix_vec);
 	if (rc)
 		efc_log_err(efct, "rc %d returned, IRQ allocation failed\n",
 			    rc);

 	/* Perform device reset */
 	efct_device_detach(efct);
 	/* Bring device to online*/
 	efct_device_attach(efct);

 	return PCI_ERS_RESULT_RECOVERED;
 }

 static void
 efct_pci_io_resume(struct pci_dev *pdev)
 {
 	struct efct *efct = pci_get_drvdata(pdev);

 	/* Perform device reset */
 	efct_device_detach(efct);
 	/* Bring device to online*/
 	efct_device_attach(efct);
 }

 MODULE_DEVICE_TABLE(pci, efct_pci_table);

 static struct pci_error_handlers efct_pci_err_handler = {
 	.error_detected = efct_pci_io_error_detected,
 	.slot_reset = efct_pci_io_slot_reset,
 	.resume = efct_pci_io_resume,
 };

 static struct pci_driver efct_pci_driver = {
 	.name		= EFCT_DRIVER_NAME,
 	.id_table	= efct_pci_table,
 	.probe		= efct_pci_probe,
 	.remove		= efct_pci_remove,
 	.err_handler	= &efct_pci_err_handler,
 };

 static
 int __init efct_init(void)
 {
 	int rc;

 	rc = efct_device_init();
 	if (rc) {
 		pr_err("efct_device_init failed rc=%d\n", rc);
 		return rc;
 	}

 	rc = pci_register_driver(&efct_pci_driver);
 	if (rc) {
 		pr_err("pci_register_driver failed rc=%d\n", rc);
 		efct_device_shutdown();
 	}

 	return rc;
 }

 static void __exit efct_exit(void)
 {
 	pci_unregister_driver(&efct_pci_driver);
 	efct_device_shutdown();
 }

 module_init(efct_init);
 module_exit(efct_exit);
 MODULE_VERSION(EFCT_DRIVER_VERSION);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Broadcom");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Copyright (C) 2021 Broadcom. All Rights Reserved. The term
	* “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
	*/

	#include "efct_driver.h"

	#include "efct_hw.h"
	#include "efct_unsol.h"
	#include "efct_scsi.h"

	LIST_HEAD(efct_devices);

	static int logmask;
	module_param(logmask, int, 0444);
	MODULE_PARM_DESC(logmask, "logging bitmask (default 0)");

	static struct libefc_function_template efct_libefc_templ = {
	.issue_mbox_rqst = efct_issue_mbox_rqst,
	.send_els = efct_els_hw_srrs_send,
	.send_bls = efct_efc_bls_send,

	.new_nport = efct_scsi_tgt_new_nport,
	.del_nport = efct_scsi_tgt_del_nport,
	.scsi_new_node = efct_scsi_new_initiator,
	.scsi_del_node = efct_scsi_del_initiator,
	.hw_seq_free = efct_efc_hw_sequence_free,
	};

	static int
	efct_device_init(void)
	{
	int rc;

	/* driver-wide init for target-server */
	rc = efct_scsi_tgt_driver_init();
	if (rc) {
	pr_err("efct_scsi_tgt_init failed rc=%d\n", rc);
	return rc;
	}

	rc = efct_scsi_reg_fc_transport();
	if (rc) {
	pr_err("failed to register to FC host\n");
	return rc;
	}

	return 0;
	}

	static void
	efct_device_shutdown(void)
	{
	efct_scsi_release_fc_transport();

	efct_scsi_tgt_driver_exit();
	}

	static void *
	efct_device_alloc(u32 nid)
	{
	struct efct *efct = NULL;

	efct = kzalloc_node(sizeof(*efct), GFP_KERNEL, nid);
	if (!efct)
	return efct;

	INIT_LIST_HEAD(&efct->list_entry);
	list_add_tail(&efct->list_entry, &efct_devices);

	return efct;
	}

	static void
	efct_teardown_msix(struct efct *efct)
	{
	u32 i;

	for (i = 0; i < efct->n_msix_vec; i++) {
	free_irq(pci_irq_vector(efct->pci, i),
	&efct->intr_context[i]);
	}

	pci_free_irq_vectors(efct->pci);
	}

	static int
	efct_efclib_config(struct efct efct, struct libefc_function_template tt)
	{
	struct efc *efc;
	struct sli4 *sli;
	int rc = 0;

	efc = kzalloc(sizeof(*efc), GFP_KERNEL);
	if (!efc)
	return -ENOMEM;

	efct->efcport = efc;

	memcpy(&efc->tt, tt, sizeof(*tt));
	efc->base = efct;
	efc->pci = efct->pci;

	efc->def_wwnn = efct_get_wwnn(&efct->hw);
	efc->def_wwpn = efct_get_wwpn(&efct->hw);
	efc->enable_tgt = 1;
	efc->log_level = EFC_LOG_LIB;

	sli = &efct->hw.sli;
	efc->max_xfer_size = sli->sge_supported_length *
	sli_get_max_sgl(&efct->hw.sli);
	efc->sli = sli;
	efc->fcfi = efct->hw.fcf_indicator;

	rc = efcport_init(efc);
	if (rc)
	efc_log_err(efc, "efcport_init failed\n");

	return rc;
	}

	static int efct_request_firmware_update(struct efct *efct);

	static const char*
	efct_pci_model(u16 device)
	{
	switch (device) {
	case EFCT_DEVICE_LANCER_G6: return "LPE31004";
	case EFCT_DEVICE_LANCER_G7: return "LPE36000";
	default: return "unknown";
	}
	}

	static int
	efct_device_attach(struct efct *efct)
	{
	u32 rc = 0, i = 0;

	if (efct->attached) {
	efc_log_err(efct, "Device is already attached\n");
	return -EIO;
	}

	snprintf(efct->name, sizeof(efct->name), "[%s%d] ", "fc",
	efct->instance_index);

	efct->logmask = logmask;
	efct->filter_def = EFCT_DEFAULT_FILTER;
	efct->max_isr_time_msec = EFCT_OS_MAX_ISR_TIME_MSEC;

	efct->model = efct_pci_model(efct->pci->device);

	efct->efct_req_fw_upgrade = true;

	/* Allocate transport object and bring online */
	efct->xport = efct_xport_alloc(efct);
	if (!efct->xport) {
	efc_log_err(efct, "failed to allocate transport object\n");
	rc = -ENOMEM;
	goto out;
	}

	rc = efct_xport_attach(efct->xport);
	if (rc) {
	efc_log_err(efct, "failed to attach transport object\n");
	goto xport_out;
	}

	rc = efct_xport_initialize(efct->xport);
	if (rc) {
	efc_log_err(efct, "failed to initialize transport object\n");
	goto xport_out;
	}

	rc = efct_efclib_config(efct, &efct_libefc_templ);
	if (rc) {
	efc_log_err(efct, "failed to init efclib\n");
	goto efclib_out;
	}

	for (i = 0; i < efct->n_msix_vec; i++) {
	efc_log_debug(efct, "irq %d enabled\n", i);
	enable_irq(pci_irq_vector(efct->pci, i));
	}

	efct->attached = true;

	if (efct->efct_req_fw_upgrade)
	efct_request_firmware_update(efct);

	return rc;

	efclib_out:
	efct_xport_detach(efct->xport);
	xport_out:
	efct_xport_free(efct->xport);
	efct->xport = NULL;
	out:
	return rc;
	}

	static int
	efct_device_detach(struct efct *efct)
	{
	int i;

	if (!efct \|\| !efct->attached) {
	pr_err("Device is not attached\n");
	return -EIO;
	}

	if (efct_xport_control(efct->xport, EFCT_XPORT_SHUTDOWN))
	efc_log_err(efct, "Transport Shutdown timed out\n");

	for (i = 0; i < efct->n_msix_vec; i++)
	disable_irq(pci_irq_vector(efct->pci, i));

	efct_xport_detach(efct->xport);

	efct_xport_free(efct->xport);
	efct->xport = NULL;

	efcport_destroy(efct->efcport);
	kfree(efct->efcport);

	efct->attached = false;

	return 0;
	}

	static void
	efct_fw_write_cb(int status, u32 actual_write_length,
	u32 change_status, void *arg)
	{
	struct efct_fw_write_result *result = arg;

	result->status = status;
	result->actual_xfer = actual_write_length;
	result->change_status = change_status;

	complete(&result->done);
	}

	static int
	efct_firmware_write(struct efct efct, const u8 buf, size_t buf_len,
	u8 *change_status)
	{
	int rc = 0;
	u32 bytes_left;
	u32 xfer_size;
	u32 offset;
	struct efc_dma dma;
	int last = 0;
	struct efct_fw_write_result result;

	init_completion(&result.done);

	bytes_left = buf_len;
	offset = 0;

	dma.size = FW_WRITE_BUFSIZE;
	dma.virt = dma_alloc_coherent(&efct->pci->dev,
	dma.size, &dma.phys, GFP_KERNEL);
	if (!dma.virt)
	return -ENOMEM;

	while (bytes_left > 0) {
	if (bytes_left > FW_WRITE_BUFSIZE)
	xfer_size = FW_WRITE_BUFSIZE;
	else
	xfer_size = bytes_left;

	memcpy(dma.virt, buf + offset, xfer_size);

	if (bytes_left == xfer_size)
	last = 1;

	efct_hw_firmware_write(&efct->hw, &dma, xfer_size, offset,
	last, efct_fw_write_cb, &result);

	if (wait_for_completion_interruptible(&result.done) != 0) {
	rc = -ENXIO;
	break;
	}

	if (result.actual_xfer == 0 \|\| result.status != 0) {
	rc = -EFAULT;
	break;
	}

	if (last)
	*change_status = result.change_status;

	bytes_left -= result.actual_xfer;
	offset += result.actual_xfer;
	}

	dma_free_coherent(&efct->pci->dev, dma.size, dma.virt, dma.phys);
	return rc;
	}

	static int
	efct_fw_reset(struct efct *efct)
	{
	/*
	* Firmware reset to activate the new firmware.
	* Function 0 will update and load the new firmware
	* during attach.
	*/
	if (timer_pending(&efct->xport->stats_timer))
	del_timer(&efct->xport->stats_timer);

	if (efct_hw_reset(&efct->hw, EFCT_HW_RESET_FIRMWARE)) {
	efc_log_info(efct, "failed to reset firmware\n");
	return -EIO;
	}

	efc_log_info(efct, "successfully reset firmware.Now resetting port\n");

	efct_device_detach(efct);
	return efct_device_attach(efct);
	}

	static int
	efct_request_firmware_update(struct efct *efct)
	{
	int rc = 0;
	u8 file_name[256], fw_change_status = 0;
	const struct firmware *fw;
	struct efct_hw_grp_hdr *fw_image;

	snprintf(file_name, 256, "%s.grp", efct->model);

	rc = request_firmware(&fw, file_name, &efct->pci->dev);
	if (rc) {
	efc_log_debug(efct, "Firmware file(%s) not found.\n", file_name);
	return rc;
	}

	fw_image = (struct efct_hw_grp_hdr *)fw->data;

	if (!strncmp(efct->hw.sli.fw_name[0], fw_image->revision,
	strnlen(fw_image->revision, 16))) {
	efc_log_debug(efct,
	"Skip update. Firmware is already up to date.\n");
	goto exit;
	}

	efc_log_info(efct, "Firmware update is initiated. %s -> %s\n",
	efct->hw.sli.fw_name[0], fw_image->revision);

	rc = efct_firmware_write(efct, fw->data, fw->size, &fw_change_status);
	if (rc) {
	efc_log_err(efct, "Firmware update failed. rc = %d\n", rc);
	goto exit;
	}

	efc_log_info(efct, "Firmware updated successfully\n");
	switch (fw_change_status) {
	case 0x00:
	efc_log_info(efct, "New firmware is active.\n");
	break;
	case 0x01:
	efc_log_info(efct,
	"System reboot needed to activate the new firmware\n");
	break;
	case 0x02:
	case 0x03:
	efc_log_info(efct,
	"firmware reset to activate the new firmware\n");
	efct_fw_reset(efct);
	break;
	default:
	efc_log_info(efct, "Unexpected value change_status:%d\n",
	fw_change_status);
	break;
	}

	exit:
	release_firmware(fw);

	return rc;
	}

	static void
	efct_device_free(struct efct *efct)
	{
	if (efct) {
	list_del(&efct->list_entry);
	kfree(efct);
	}
	}

	static int
	efct_device_interrupts_required(struct efct *efct)
	{
	int rc;

	rc = efct_hw_setup(&efct->hw, efct, efct->pci);
	if (rc < 0)
	return rc;

	return efct->hw.config.n_eq;
	}

	static irqreturn_t
	efct_intr_thread(int irq, void *handle)
	{
	struct efct_intr_context *intr_ctx = handle;
	struct efct *efct = intr_ctx->efct;

	efct_hw_process(&efct->hw, intr_ctx->index, efct->max_isr_time_msec);
	return IRQ_HANDLED;
	}

	static irqreturn_t
	efct_intr_msix(int irq, void *handle)
	{
	return IRQ_WAKE_THREAD;
	}

	static int
	efct_setup_msix(struct efct *efct, u32 num_intrs)
	{
	int rc = 0, i;

	if (!pci_find_capability(efct->pci, PCI_CAP_ID_MSIX)) {
	dev_err(&efct->pci->dev,
	"%s : MSI-X not available\n", __func__);
	return -EIO;
	}

	efct->n_msix_vec = num_intrs;

	rc = pci_alloc_irq_vectors(efct->pci, num_intrs, num_intrs,
	PCI_IRQ_MSIX \| PCI_IRQ_AFFINITY);

	if (rc < 0) {
	dev_err(&efct->pci->dev, "Failed to alloc irq : %d\n", rc);
	return rc;
	}

	for (i = 0; i < num_intrs; i++) {
	struct efct_intr_context *intr_ctx = NULL;

	intr_ctx = &efct->intr_context[i];
	intr_ctx->efct = efct;
	intr_ctx->index = i;

	rc = request_threaded_irq(pci_irq_vector(efct->pci, i),
	efct_intr_msix, efct_intr_thread, 0,
	EFCT_DRIVER_NAME, intr_ctx);
	if (rc) {
	dev_err(&efct->pci->dev,
	"Failed to register %d vector: %d\n", i, rc);
	goto out;
	}
	}

	return rc;

	out:
	while (--i >= 0)
	free_irq(pci_irq_vector(efct->pci, i),
	&efct->intr_context[i]);

	pci_free_irq_vectors(efct->pci);
	return rc;
	}

	static struct pci_device_id efct_pci_table[] = {
	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G6), 0},
	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G7), 0},
	{} /* terminate list */
	};

	static int
	efct_pci_probe(struct pci_dev pdev, const struct pci_device_id ent)
	{
	struct efct *efct = NULL;
	int rc;
	u32 i, r;
	int num_interrupts = 0;
	int nid;

	dev_info(&pdev->dev, "%s\n", EFCT_DRIVER_NAME);

	rc = pci_enable_device_mem(pdev);
	if (rc)
	return rc;

	pci_set_master(pdev);

	rc = pci_set_mwi(pdev);
	if (rc) {
	dev_info(&pdev->dev, "pci_set_mwi returned %d\n", rc);
	goto mwi_out;
	}

	rc = pci_request_regions(pdev, EFCT_DRIVER_NAME);
	if (rc) {
	dev_err(&pdev->dev, "pci_request_regions failed %d\n", rc);
	goto req_regions_out;
	}

	/* Fetch the Numa node id for this device */
	nid = dev_to_node(&pdev->dev);
	if (nid < 0) {
	dev_err(&pdev->dev, "Warning Numa node ID is %d\n", nid);
	nid = 0;
	}

	/* Allocate efct */
	efct = efct_device_alloc(nid);
	if (!efct) {
	dev_err(&pdev->dev, "Failed to allocate efct\n");
	rc = -ENOMEM;
	goto alloc_out;
	}

	efct->pci = pdev;
	efct->numa_node = nid;

	/* Map all memory BARs */
	for (i = 0, r = 0; i < EFCT_PCI_MAX_REGS; i++) {
	if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
	efct->reg[r] = ioremap(pci_resource_start(pdev, i),
	pci_resource_len(pdev, i));
	r++;
	}

	/*
	* If the 64-bit attribute is set, both this BAR and the
	* next form the complete address. Skip processing the
	* next BAR.
	*/
	if (pci_resource_flags(pdev, i) & IORESOURCE_MEM_64)
	i++;
	}

	pci_set_drvdata(pdev, efct);

	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
	if (rc) {
	dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n");
	goto dma_mask_out;
	}

	num_interrupts = efct_device_interrupts_required(efct);
	if (num_interrupts < 0) {
	efc_log_err(efct, "efct_device_interrupts_required failed\n");
	rc = -1;
	goto dma_mask_out;
	}

	/*
	* Initialize MSIX interrupts, note,
	* efct_setup_msix() enables the interrupt
	*/
	rc = efct_setup_msix(efct, num_interrupts);
	if (rc) {
	dev_err(&pdev->dev, "Can't setup msix\n");
	goto dma_mask_out;
	}
	/* Disable interrupt for now */
	for (i = 0; i < efct->n_msix_vec; i++) {
	efc_log_debug(efct, "irq %d disabled\n", i);
	disable_irq(pci_irq_vector(efct->pci, i));
	}

	rc = efct_device_attach(efct);
	if (rc)
	goto attach_out;

	return 0;

	attach_out:
	efct_teardown_msix(efct);
	dma_mask_out:
	pci_set_drvdata(pdev, NULL);

	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
	if (efct->reg[i])
	iounmap(efct->reg[i]);
	}
	efct_device_free(efct);
	alloc_out:
	pci_release_regions(pdev);
	req_regions_out:
	pci_clear_mwi(pdev);
	mwi_out:
	pci_disable_device(pdev);
	return rc;
	}

	static void
	efct_pci_remove(struct pci_dev *pdev)
	{
	struct efct *efct = pci_get_drvdata(pdev);
	u32 i;

	if (!efct)
	return;

	efct_device_detach(efct);

	efct_teardown_msix(efct);

	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
	if (efct->reg[i])
	iounmap(efct->reg[i]);
	}

	pci_set_drvdata(pdev, NULL);

	efct_device_free(efct);

	pci_release_regions(pdev);

	pci_disable_device(pdev);
	}

	static void
	efct_device_prep_for_reset(struct efct efct, struct pci_dev pdev)
	{
	if (efct) {
	efc_log_debug(efct,
	"PCI channel disable preparing for reset\n");
	efct_device_detach(efct);
	/* Disable interrupt and pci device */
	efct_teardown_msix(efct);
	}
	pci_disable_device(pdev);
	}

	static void
	efct_device_prep_for_recover(struct efct *efct)
	{
	if (efct) {
	efc_log_debug(efct, "PCI channel preparing for recovery\n");
	efct_hw_io_abort_all(&efct->hw);
	}
	}

	/**
	* efct_pci_io_error_detected - method for handling PCI I/O error
	* @pdev: pointer to PCI device.
	* @state: the current PCI connection state.
	*
	* This routine is registered to the PCI subsystem for error handling. This
	* function is called by the PCI subsystem after a PCI bus error affecting
	* this device has been detected. When this routine is invoked, it dispatches
	* device error detected handling routine, which will perform the proper
	* error detected operation.
	*
	* Return codes
	* PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
	* PCI_ERS_RESULT_DISCONNECT - device could not be recovered
	*/
	static pci_ers_result_t
	efct_pci_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
	{
	struct efct *efct = pci_get_drvdata(pdev);
	pci_ers_result_t rc;

	switch (state) {
	case pci_channel_io_normal:
	efct_device_prep_for_recover(efct);
	rc = PCI_ERS_RESULT_CAN_RECOVER;
	break;
	case pci_channel_io_frozen:
	efct_device_prep_for_reset(efct, pdev);
	rc = PCI_ERS_RESULT_NEED_RESET;
	break;
	case pci_channel_io_perm_failure:
	efct_device_detach(efct);
	rc = PCI_ERS_RESULT_DISCONNECT;
	break;
	default:
	efc_log_debug(efct, "Unknown PCI error state:0x%x\n", state);
	efct_device_prep_for_reset(efct, pdev);
	rc = PCI_ERS_RESULT_NEED_RESET;
	break;
	}

	return rc;
	}

	static pci_ers_result_t
	efct_pci_io_slot_reset(struct pci_dev *pdev)
	{
	int rc;
	struct efct *efct = pci_get_drvdata(pdev);

	rc = pci_enable_device_mem(pdev);
	if (rc) {
	efc_log_err(efct, "failed to enable PCI device after reset\n");
	return PCI_ERS_RESULT_DISCONNECT;
	}

	/*
	* As the new kernel behavior of pci_restore_state() API call clears
	* device saved_state flag, need to save the restored state again.
	*/

	pci_save_state(pdev);

	pci_set_master(pdev);

	rc = efct_setup_msix(efct, efct->n_msix_vec);
	if (rc)
	efc_log_err(efct, "rc %d returned, IRQ allocation failed\n",
	rc);

	/* Perform device reset */
	efct_device_detach(efct);
	/* Bring device to online*/
	efct_device_attach(efct);

	return PCI_ERS_RESULT_RECOVERED;
	}

	static void
	efct_pci_io_resume(struct pci_dev *pdev)
	{
	struct efct *efct = pci_get_drvdata(pdev);

	/* Perform device reset */
	efct_device_detach(efct);
	/* Bring device to online*/
	efct_device_attach(efct);
	}

	MODULE_DEVICE_TABLE(pci, efct_pci_table);

	static struct pci_error_handlers efct_pci_err_handler = {
	.error_detected = efct_pci_io_error_detected,
	.slot_reset = efct_pci_io_slot_reset,
	.resume = efct_pci_io_resume,
	};

	static struct pci_driver efct_pci_driver = {
	.name = EFCT_DRIVER_NAME,
	.id_table = efct_pci_table,
	.probe = efct_pci_probe,
	.remove = efct_pci_remove,
	.err_handler = &efct_pci_err_handler,
	};

	static
	int __init efct_init(void)
	{
	int rc;

	rc = efct_device_init();
	if (rc) {
	pr_err("efct_device_init failed rc=%d\n", rc);
	return rc;
	}

	rc = pci_register_driver(&efct_pci_driver);
	if (rc) {
	pr_err("pci_register_driver failed rc=%d\n", rc);
	efct_device_shutdown();
	}

	return rc;
	}

	static void __exit efct_exit(void)
	{
	pci_unregister_driver(&efct_pci_driver);
	efct_device_shutdown();
	}

	module_init(efct_init);
	module_exit(efct_exit);
	MODULE_VERSION(EFCT_DRIVER_VERSION);
	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("Broadcom");