1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
4 * ���Broadcom��� refers to Broadcom Inc. and/or its subsidiaries.
5 */
6
7#include "efct_driver.h"
8
9#include "efct_hw.h"
10#include "efct_unsol.h"
11#include "efct_scsi.h"
12
13LIST_HEAD(efct_devices);
14
15static int logmask;
16module_param(logmask, int, 0444);
17MODULE_PARM_DESC(logmask, "logging bitmask (default 0)");
18
19static struct libefc_function_template efct_libefc_templ = {
20	.issue_mbox_rqst = efct_issue_mbox_rqst,
21	.send_els = efct_els_hw_srrs_send,
22	.send_bls = efct_efc_bls_send,
23
24	.new_nport = efct_scsi_tgt_new_nport,
25	.del_nport = efct_scsi_tgt_del_nport,
26	.scsi_new_node = efct_scsi_new_initiator,
27	.scsi_del_node = efct_scsi_del_initiator,
28	.hw_seq_free = efct_efc_hw_sequence_free,
29};
30
31static int
32efct_device_init(void)
33{
34	int rc;
35
36	/* driver-wide init for target-server */
37	rc = efct_scsi_tgt_driver_init();
38	if (rc) {
39		pr_err("efct_scsi_tgt_init failed rc=%d\n", rc);
40		return rc;
41	}
42
43	rc = efct_scsi_reg_fc_transport();
44	if (rc) {
45		efct_scsi_tgt_driver_exit();
46		pr_err("failed to register to FC host\n");
47		return rc;
48	}
49
50	return 0;
51}
52
53static void
54efct_device_shutdown(void)
55{
56	efct_scsi_release_fc_transport();
57
58	efct_scsi_tgt_driver_exit();
59}
60
61static void *
62efct_device_alloc(u32 nid)
63{
64	struct efct *efct = NULL;
65
66	efct = kzalloc_node(sizeof(*efct), GFP_KERNEL, nid);
67	if (!efct)
68		return efct;
69
70	INIT_LIST_HEAD(&efct->list_entry);
71	list_add_tail(&efct->list_entry, &efct_devices);
72
73	return efct;
74}
75
76static void
77efct_teardown_msix(struct efct *efct)
78{
79	u32 i;
80
81	for (i = 0; i < efct->n_msix_vec; i++) {
82		free_irq(pci_irq_vector(efct->pci, i),
83			 &efct->intr_context[i]);
84	}
85
86	pci_free_irq_vectors(efct->pci);
87}
88
89static int
90efct_efclib_config(struct efct *efct, struct libefc_function_template *tt)
91{
92	struct efc *efc;
93	struct sli4 *sli;
94	int rc = 0;
95
96	efc = kzalloc(sizeof(*efc), GFP_KERNEL);
97	if (!efc)
98		return -ENOMEM;
99
100	efct->efcport = efc;
101
102	memcpy(&efc->tt, tt, sizeof(*tt));
103	efc->base = efct;
104	efc->pci = efct->pci;
105
106	efc->def_wwnn = efct_get_wwnn(&efct->hw);
107	efc->def_wwpn = efct_get_wwpn(&efct->hw);
108	efc->enable_tgt = 1;
109	efc->log_level = EFC_LOG_LIB;
110
111	sli = &efct->hw.sli;
112	efc->max_xfer_size = sli->sge_supported_length *
113			     sli_get_max_sgl(&efct->hw.sli);
114	efc->sli = sli;
115	efc->fcfi = efct->hw.fcf_indicator;
116
117	rc = efcport_init(efc);
118	if (rc)
119		efc_log_err(efc, "efcport_init failed\n");
120
121	return rc;
122}
123
124static int efct_request_firmware_update(struct efct *efct);
125
126static const char*
127efct_pci_model(u16 device)
128{
129	switch (device) {
130	case EFCT_DEVICE_LANCER_G6:	return "LPE31004";
131	case EFCT_DEVICE_LANCER_G7:	return "LPE36000";
132	default:			return "unknown";
133	}
134}
135
136static int
137efct_device_attach(struct efct *efct)
138{
139	u32 rc = 0, i = 0;
140
141	if (efct->attached) {
142		efc_log_err(efct, "Device is already attached\n");
143		return -EIO;
144	}
145
146	snprintf(efct->name, sizeof(efct->name), "[%s%d] ", "fc",
147		 efct->instance_index);
148
149	efct->logmask = logmask;
150	efct->filter_def = EFCT_DEFAULT_FILTER;
151	efct->max_isr_time_msec = EFCT_OS_MAX_ISR_TIME_MSEC;
152
153	efct->model = efct_pci_model(efct->pci->device);
154
155	efct->efct_req_fw_upgrade = true;
156
157	/* Allocate transport object and bring online */
158	efct->xport = efct_xport_alloc(efct);
159	if (!efct->xport) {
160		efc_log_err(efct, "failed to allocate transport object\n");
161		rc = -ENOMEM;
162		goto out;
163	}
164
165	rc = efct_xport_attach(efct->xport);
166	if (rc) {
167		efc_log_err(efct, "failed to attach transport object\n");
168		goto xport_out;
169	}
170
171	rc = efct_xport_initialize(efct->xport);
172	if (rc) {
173		efc_log_err(efct, "failed to initialize transport object\n");
174		goto xport_out;
175	}
176
177	rc = efct_efclib_config(efct, &efct_libefc_templ);
178	if (rc) {
179		efc_log_err(efct, "failed to init efclib\n");
180		goto efclib_out;
181	}
182
183	for (i = 0; i < efct->n_msix_vec; i++) {
184		efc_log_debug(efct, "irq %d enabled\n", i);
185		enable_irq(pci_irq_vector(efct->pci, i));
186	}
187
188	efct->attached = true;
189
190	if (efct->efct_req_fw_upgrade)
191		efct_request_firmware_update(efct);
192
193	return rc;
194
195efclib_out:
196	efct_xport_detach(efct->xport);
197xport_out:
198	efct_xport_free(efct->xport);
199	efct->xport = NULL;
200out:
201	return rc;
202}
203
204static int
205efct_device_detach(struct efct *efct)
206{
207	int i;
208
209	if (!efct || !efct->attached) {
210		pr_err("Device is not attached\n");
211		return -EIO;
212	}
213
214	if (efct_xport_control(efct->xport, EFCT_XPORT_SHUTDOWN))
215		efc_log_err(efct, "Transport Shutdown timed out\n");
216
217	for (i = 0; i < efct->n_msix_vec; i++)
218		disable_irq(pci_irq_vector(efct->pci, i));
219
220	efct_xport_detach(efct->xport);
221
222	efct_xport_free(efct->xport);
223	efct->xport = NULL;
224
225	efcport_destroy(efct->efcport);
226	kfree(efct->efcport);
227
228	efct->attached = false;
229
230	return 0;
231}
232
233static void
234efct_fw_write_cb(int status, u32 actual_write_length,
235		 u32 change_status, void *arg)
236{
237	struct efct_fw_write_result *result = arg;
238
239	result->status = status;
240	result->actual_xfer = actual_write_length;
241	result->change_status = change_status;
242
243	complete(&result->done);
244}
245
246static int
247efct_firmware_write(struct efct *efct, const u8 *buf, size_t buf_len,
248		    u8 *change_status)
249{
250	int rc = 0;
251	u32 bytes_left;
252	u32 xfer_size;
253	u32 offset;
254	struct efc_dma dma;
255	int last = 0;
256	struct efct_fw_write_result result;
257
258	init_completion(&result.done);
259
260	bytes_left = buf_len;
261	offset = 0;
262
263	dma.size = FW_WRITE_BUFSIZE;
264	dma.virt = dma_alloc_coherent(&efct->pci->dev,
265				      dma.size, &dma.phys, GFP_KERNEL);
266	if (!dma.virt)
267		return -ENOMEM;
268
269	while (bytes_left > 0) {
270		if (bytes_left > FW_WRITE_BUFSIZE)
271			xfer_size = FW_WRITE_BUFSIZE;
272		else
273			xfer_size = bytes_left;
274
275		memcpy(dma.virt, buf + offset, xfer_size);
276
277		if (bytes_left == xfer_size)
278			last = 1;
279
280		efct_hw_firmware_write(&efct->hw, &dma, xfer_size, offset,
281				       last, efct_fw_write_cb, &result);
282
283		if (wait_for_completion_interruptible(&result.done) != 0) {
284			rc = -ENXIO;
285			break;
286		}
287
288		if (result.actual_xfer == 0 || result.status != 0) {
289			rc = -EFAULT;
290			break;
291		}
292
293		if (last)
294			*change_status = result.change_status;
295
296		bytes_left -= result.actual_xfer;
297		offset += result.actual_xfer;
298	}
299
300	dma_free_coherent(&efct->pci->dev, dma.size, dma.virt, dma.phys);
301	return rc;
302}
303
304static int
305efct_fw_reset(struct efct *efct)
306{
307	/*
308	 * Firmware reset to activate the new firmware.
309	 * Function 0 will update and load the new firmware
310	 * during attach.
311	 */
312	if (timer_pending(&efct->xport->stats_timer))
313		del_timer(&efct->xport->stats_timer);
314
315	if (efct_hw_reset(&efct->hw, EFCT_HW_RESET_FIRMWARE)) {
316		efc_log_info(efct, "failed to reset firmware\n");
317		return -EIO;
318	}
319
320	efc_log_info(efct, "successfully reset firmware.Now resetting port\n");
321
322	efct_device_detach(efct);
323	return efct_device_attach(efct);
324}
325
326static int
327efct_request_firmware_update(struct efct *efct)
328{
329	int rc = 0;
330	u8 file_name[256], fw_change_status = 0;
331	const struct firmware *fw;
332	struct efct_hw_grp_hdr *fw_image;
333
334	snprintf(file_name, 256, "%s.grp", efct->model);
335
336	rc = request_firmware(&fw, file_name, &efct->pci->dev);
337	if (rc) {
338		efc_log_debug(efct, "Firmware file(%s) not found.\n", file_name);
339		return rc;
340	}
341
342	fw_image = (struct efct_hw_grp_hdr *)fw->data;
343
344	if (!strncmp(efct->hw.sli.fw_name[0], fw_image->revision,
345		     strnlen(fw_image->revision, 16))) {
346		efc_log_debug(efct,
347			      "Skip update. Firmware is already up to date.\n");
348		goto exit;
349	}
350
351	efc_log_info(efct, "Firmware update is initiated. %s -> %s\n",
352		     efct->hw.sli.fw_name[0], fw_image->revision);
353
354	rc = efct_firmware_write(efct, fw->data, fw->size, &fw_change_status);
355	if (rc) {
356		efc_log_err(efct, "Firmware update failed. rc = %d\n", rc);
357		goto exit;
358	}
359
360	efc_log_info(efct, "Firmware updated successfully\n");
361	switch (fw_change_status) {
362	case 0x00:
363		efc_log_info(efct, "New firmware is active.\n");
364		break;
365	case 0x01:
366		efc_log_info(efct,
367			"System reboot needed to activate the new firmware\n");
368		break;
369	case 0x02:
370	case 0x03:
371		efc_log_info(efct,
372			     "firmware reset to activate the new firmware\n");
373		efct_fw_reset(efct);
374		break;
375	default:
376		efc_log_info(efct, "Unexpected value change_status:%d\n",
377			     fw_change_status);
378		break;
379	}
380
381exit:
382	release_firmware(fw);
383
384	return rc;
385}
386
387static void
388efct_device_free(struct efct *efct)
389{
390	if (efct) {
391		list_del(&efct->list_entry);
392		kfree(efct);
393	}
394}
395
396static int
397efct_device_interrupts_required(struct efct *efct)
398{
399	int rc;
400
401	rc = efct_hw_setup(&efct->hw, efct, efct->pci);
402	if (rc < 0)
403		return rc;
404
405	return efct->hw.config.n_eq;
406}
407
408static irqreturn_t
409efct_intr_thread(int irq, void *handle)
410{
411	struct efct_intr_context *intr_ctx = handle;
412	struct efct *efct = intr_ctx->efct;
413
414	efct_hw_process(&efct->hw, intr_ctx->index, efct->max_isr_time_msec);
415	return IRQ_HANDLED;
416}
417
418static irqreturn_t
419efct_intr_msix(int irq, void *handle)
420{
421	return IRQ_WAKE_THREAD;
422}
423
424static int
425efct_setup_msix(struct efct *efct, u32 num_intrs)
426{
427	int rc = 0, i;
428
429	if (!pci_find_capability(efct->pci, PCI_CAP_ID_MSIX)) {
430		dev_err(&efct->pci->dev,
431			"%s : MSI-X not available\n", __func__);
432		return -EIO;
433	}
434
435	efct->n_msix_vec = num_intrs;
436
437	rc = pci_alloc_irq_vectors(efct->pci, num_intrs, num_intrs,
438				   PCI_IRQ_MSIX | PCI_IRQ_AFFINITY);
439
440	if (rc < 0) {
441		dev_err(&efct->pci->dev, "Failed to alloc irq : %d\n", rc);
442		return rc;
443	}
444
445	for (i = 0; i < num_intrs; i++) {
446		struct efct_intr_context *intr_ctx = NULL;
447
448		intr_ctx = &efct->intr_context[i];
449		intr_ctx->efct = efct;
450		intr_ctx->index = i;
451
452		rc = request_threaded_irq(pci_irq_vector(efct->pci, i),
453					  efct_intr_msix, efct_intr_thread, 0,
454					  EFCT_DRIVER_NAME, intr_ctx);
455		if (rc) {
456			dev_err(&efct->pci->dev,
457				"Failed to register %d vector: %d\n", i, rc);
458			goto out;
459		}
460	}
461
462	return rc;
463
464out:
465	while (--i >= 0)
466		free_irq(pci_irq_vector(efct->pci, i),
467			 &efct->intr_context[i]);
468
469	pci_free_irq_vectors(efct->pci);
470	return rc;
471}
472
473static struct pci_device_id efct_pci_table[] = {
474	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G6), 0},
475	{PCI_DEVICE(EFCT_VENDOR_ID, EFCT_DEVICE_LANCER_G7), 0},
476	{}	/* terminate list */
477};
478
479static int
480efct_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
481{
482	struct efct *efct = NULL;
483	int rc;
484	u32 i, r;
485	int num_interrupts = 0;
486	int nid;
487
488	dev_info(&pdev->dev, "%s\n", EFCT_DRIVER_NAME);
489
490	rc = pci_enable_device_mem(pdev);
491	if (rc)
492		return rc;
493
494	pci_set_master(pdev);
495
496	rc = pci_set_mwi(pdev);
497	if (rc) {
498		dev_info(&pdev->dev, "pci_set_mwi returned %d\n", rc);
499		goto mwi_out;
500	}
501
502	rc = pci_request_regions(pdev, EFCT_DRIVER_NAME);
503	if (rc) {
504		dev_err(&pdev->dev, "pci_request_regions failed %d\n", rc);
505		goto req_regions_out;
506	}
507
508	/* Fetch the Numa node id for this device */
509	nid = dev_to_node(&pdev->dev);
510	if (nid < 0) {
511		dev_err(&pdev->dev, "Warning Numa node ID is %d\n", nid);
512		nid = 0;
513	}
514
515	/* Allocate efct */
516	efct = efct_device_alloc(nid);
517	if (!efct) {
518		dev_err(&pdev->dev, "Failed to allocate efct\n");
519		rc = -ENOMEM;
520		goto alloc_out;
521	}
522
523	efct->pci = pdev;
524	efct->numa_node = nid;
525
526	/* Map all memory BARs */
527	for (i = 0, r = 0; i < EFCT_PCI_MAX_REGS; i++) {
528		if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
529			efct->reg[r] = ioremap(pci_resource_start(pdev, i),
530					       pci_resource_len(pdev, i));
531			r++;
532		}
533
534		/*
535		 * If the 64-bit attribute is set, both this BAR and the
536		 * next form the complete address. Skip processing the
537		 * next BAR.
538		 */
539		if (pci_resource_flags(pdev, i) & IORESOURCE_MEM_64)
540			i++;
541	}
542
543	pci_set_drvdata(pdev, efct);
544
545	rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
546	if (rc) {
547		dev_err(&pdev->dev, "setting DMA_BIT_MASK failed\n");
548		goto dma_mask_out;
549	}
550
551	num_interrupts = efct_device_interrupts_required(efct);
552	if (num_interrupts < 0) {
553		efc_log_err(efct, "efct_device_interrupts_required failed\n");
554		rc = -1;
555		goto dma_mask_out;
556	}
557
558	/*
559	 * Initialize MSIX interrupts, note,
560	 * efct_setup_msix() enables the interrupt
561	 */
562	rc = efct_setup_msix(efct, num_interrupts);
563	if (rc) {
564		dev_err(&pdev->dev, "Can't setup msix\n");
565		goto dma_mask_out;
566	}
567	/* Disable interrupt for now */
568	for (i = 0; i < efct->n_msix_vec; i++) {
569		efc_log_debug(efct, "irq %d disabled\n", i);
570		disable_irq(pci_irq_vector(efct->pci, i));
571	}
572
573	rc = efct_device_attach(efct);
574	if (rc)
575		goto attach_out;
576
577	return 0;
578
579attach_out:
580	efct_teardown_msix(efct);
581dma_mask_out:
582	pci_set_drvdata(pdev, NULL);
583
584	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
585		if (efct->reg[i])
586			iounmap(efct->reg[i]);
587	}
588	efct_device_free(efct);
589alloc_out:
590	pci_release_regions(pdev);
591req_regions_out:
592	pci_clear_mwi(pdev);
593mwi_out:
594	pci_disable_device(pdev);
595	return rc;
596}
597
598static void
599efct_pci_remove(struct pci_dev *pdev)
600{
601	struct efct *efct = pci_get_drvdata(pdev);
602	u32 i;
603
604	if (!efct)
605		return;
606
607	efct_device_detach(efct);
608
609	efct_teardown_msix(efct);
610
611	for (i = 0; i < EFCT_PCI_MAX_REGS; i++) {
612		if (efct->reg[i])
613			iounmap(efct->reg[i]);
614	}
615
616	pci_set_drvdata(pdev, NULL);
617
618	efct_device_free(efct);
619
620	pci_release_regions(pdev);
621
622	pci_disable_device(pdev);
623}
624
625static void
626efct_device_prep_for_reset(struct efct *efct, struct pci_dev *pdev)
627{
628	if (efct) {
629		efc_log_debug(efct,
630			      "PCI channel disable preparing for reset\n");
631		efct_device_detach(efct);
632		/* Disable interrupt and pci device */
633		efct_teardown_msix(efct);
634	}
635	pci_disable_device(pdev);
636}
637
638static void
639efct_device_prep_for_recover(struct efct *efct)
640{
641	if (efct) {
642		efc_log_debug(efct, "PCI channel preparing for recovery\n");
643		efct_hw_io_abort_all(&efct->hw);
644	}
645}
646
647/**
648 * efct_pci_io_error_detected - method for handling PCI I/O error
649 * @pdev: pointer to PCI device.
650 * @state: the current PCI connection state.
651 *
652 * This routine is registered to the PCI subsystem for error handling. This
653 * function is called by the PCI subsystem after a PCI bus error affecting
654 * this device has been detected. When this routine is invoked, it dispatches
655 * device error detected handling routine, which will perform the proper
656 * error detected operation.
657 *
658 * Return codes
659 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
660 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered
661 */
662static pci_ers_result_t
663efct_pci_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
664{
665	struct efct *efct = pci_get_drvdata(pdev);
666	pci_ers_result_t rc;
667
668	switch (state) {
669	case pci_channel_io_normal:
670		efct_device_prep_for_recover(efct);
671		rc = PCI_ERS_RESULT_CAN_RECOVER;
672		break;
673	case pci_channel_io_frozen:
674		efct_device_prep_for_reset(efct, pdev);
675		rc = PCI_ERS_RESULT_NEED_RESET;
676		break;
677	case pci_channel_io_perm_failure:
678		efct_device_detach(efct);
679		rc = PCI_ERS_RESULT_DISCONNECT;
680		break;
681	default:
682		efc_log_debug(efct, "Unknown PCI error state:0x%x\n", state);
683		efct_device_prep_for_reset(efct, pdev);
684		rc = PCI_ERS_RESULT_NEED_RESET;
685		break;
686	}
687
688	return rc;
689}
690
691static pci_ers_result_t
692efct_pci_io_slot_reset(struct pci_dev *pdev)
693{
694	int rc;
695	struct efct *efct = pci_get_drvdata(pdev);
696
697	rc = pci_enable_device_mem(pdev);
698	if (rc) {
699		efc_log_err(efct, "failed to enable PCI device after reset\n");
700		return PCI_ERS_RESULT_DISCONNECT;
701	}
702
703	/*
704	 * As the new kernel behavior of pci_restore_state() API call clears
705	 * device saved_state flag, need to save the restored state again.
706	 */
707
708	pci_save_state(pdev);
709
710	pci_set_master(pdev);
711
712	rc = efct_setup_msix(efct, efct->n_msix_vec);
713	if (rc)
714		efc_log_err(efct, "rc %d returned, IRQ allocation failed\n",
715			    rc);
716
717	/* Perform device reset */
718	efct_device_detach(efct);
719	/* Bring device to online*/
720	efct_device_attach(efct);
721
722	return PCI_ERS_RESULT_RECOVERED;
723}
724
725static void
726efct_pci_io_resume(struct pci_dev *pdev)
727{
728	struct efct *efct = pci_get_drvdata(pdev);
729
730	/* Perform device reset */
731	efct_device_detach(efct);
732	/* Bring device to online*/
733	efct_device_attach(efct);
734}
735
736MODULE_DEVICE_TABLE(pci, efct_pci_table);
737
738static struct pci_error_handlers efct_pci_err_handler = {
739	.error_detected = efct_pci_io_error_detected,
740	.slot_reset = efct_pci_io_slot_reset,
741	.resume = efct_pci_io_resume,
742};
743
744static struct pci_driver efct_pci_driver = {
745	.name		= EFCT_DRIVER_NAME,
746	.id_table	= efct_pci_table,
747	.probe		= efct_pci_probe,
748	.remove		= efct_pci_remove,
749	.err_handler	= &efct_pci_err_handler,
750};
751
752static
753int __init efct_init(void)
754{
755	int rc;
756
757	rc = efct_device_init();
758	if (rc) {
759		pr_err("efct_device_init failed rc=%d\n", rc);
760		return rc;
761	}
762
763	rc = pci_register_driver(&efct_pci_driver);
764	if (rc) {
765		pr_err("pci_register_driver failed rc=%d\n", rc);
766		efct_device_shutdown();
767	}
768
769	return rc;
770}
771
772static void __exit efct_exit(void)
773{
774	pci_unregister_driver(&efct_pci_driver);
775	efct_device_shutdown();
776}
777
778module_init(efct_init);
779module_exit(efct_exit);
780MODULE_VERSION(EFCT_DRIVER_VERSION);
781MODULE_LICENSE("GPL");
782MODULE_AUTHOR("Broadcom");
783