nfp: add the PF driver (63461a02) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@ nfp-objs := \
		nfp_net_common.o \
		nfp_net_ethtool.o \
		nfp_net_offload.o \
		nfp_net_main.o \
		nfp_netvf_main.o

		ifeq ($(CONFIG_BPF_SYSCALL),y)

drivers/net/ethernet/netronome/nfp/nfp_main.c

+331 −1

Original line number	Diff line number	Diff line
		@@ -45,12 +45,326 @@
		#include <linux/firmware.h>
		#include <linux/vermagic.h>

		#include "nfpcore/nfp.h"
		#include "nfpcore/nfp_cpp.h"
		#include "nfpcore/nfp_nsp_eth.h"

		#include "nfpcore/nfp6000_pcie.h"

		#include "nfp_main.h"
		#include "nfp_net.h"

		static const char nfp_driver_name[] = "nfp";
		const char nfp_driver_version[] = VERMAGIC_STRING;

		static const struct pci_device_id nfp_pci_device_ids[] = {
		{ PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_NFP6000,
		PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
		PCI_ANY_ID, 0,
		},
		{ PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_NFP4000,
		PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
		PCI_ANY_ID, 0,
		},
		{ 0, } /* Required last entry. */
		};
		MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);

		static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)
		{
		#ifdef CONFIG_PCI_IOV
		struct nfp_pf *pf = pci_get_drvdata(pdev);
		int err;

		err = pci_enable_sriov(pdev, num_vfs);
		if (err) {
		dev_warn(&pdev->dev, "Failed to enable PCI sriov: %d\n", err);
		return err;
		}

		pf->num_vfs = num_vfs;

		dev_dbg(&pdev->dev, "Created %d VFs.\n", pf->num_vfs);

		return num_vfs;
		#endif
		return 0;
		}

		static int nfp_pcie_sriov_disable(struct pci_dev *pdev)
		{
		#ifdef CONFIG_PCI_IOV
		struct nfp_pf *pf = pci_get_drvdata(pdev);

		/* If the VFs are assigned we cannot shut down SR-IOV without
		* causing issues, so just leave the hardware available but
		* disabled
		*/
		if (pci_vfs_assigned(pdev)) {
		dev_warn(&pdev->dev, "Disabling while VFs assigned - VFs will not be deallocated\n");
		return -EPERM;
		}

		pf->num_vfs = 0;

		pci_disable_sriov(pdev);
		dev_dbg(&pdev->dev, "Removed VFs.\n");
		#endif
		return 0;
		}

		static int nfp_pcie_sriov_configure(struct pci_dev *pdev, int num_vfs)
		{
		if (num_vfs == 0)
		return nfp_pcie_sriov_disable(pdev);
		else
		return nfp_pcie_sriov_enable(pdev, num_vfs);
		}

		/**
		* nfp_net_fw_find() - Find the correct firmware image for netdev mode
		* @pdev: PCI Device structure
		* @pf: NFP PF Device structure
		*
		* Return: firmware if found and requested successfully.
		*/
		static const struct firmware *
		nfp_net_fw_find(struct pci_dev pdev, struct nfp_pf pf)
		{
		const struct firmware *fw = NULL;
		struct nfp_eth_table_port *port;
		const char *fw_model;
		char fw_name[256];
		int spc, err = 0;
		int i, j;

		if (!pf->eth_tbl) {
		dev_err(&pdev->dev, "Error: can't identify media config\n");
		return NULL;
		}

		fw_model = nfp_hwinfo_lookup(pf->cpp, "assembly.partno");
		if (!fw_model) {
		dev_err(&pdev->dev, "Error: can't read part number\n");
		return NULL;
		}

		spc = ARRAY_SIZE(fw_name);
		spc -= snprintf(fw_name, spc, "netronome/nic_%s", fw_model);

		for (i = 0; spc > 0 && i < pf->eth_tbl->count; i += j) {
		port = &pf->eth_tbl->ports[i];
		j = 1;
		while (i + j < pf->eth_tbl->count &&
		port->speed == port[j].speed)
		j++;

		spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc,
		"_%dx%d", j, port->speed / 1000);
		}

		if (spc <= 0)
		return NULL;

		spc -= snprintf(&fw_name[ARRAY_SIZE(fw_name) - spc], spc, ".nffw");
		if (spc <= 0)
		return NULL;

		err = request_firmware(&fw, fw_name, &pdev->dev);
		if (err)
		return NULL;

		dev_info(&pdev->dev, "Loading FW image: %s\n", fw_name);

		return fw;
		}

		/**
		* nfp_net_fw_load() - Load the firmware image
		* @pdev: PCI Device structure
		* @pf: NFP PF Device structure
		* @nsp: NFP SP handle
		*
		* Return: -ERRNO, 0 for no firmware loaded, 1 for firmware loaded
		*/
		static int
		nfp_fw_load(struct pci_dev pdev, struct nfp_pf pf, struct nfp_nsp *nsp)
		{
		const struct firmware *fw;
		u16 interface;
		int err;

		interface = nfp_cpp_interface(pf->cpp);
		if (NFP_CPP_INTERFACE_UNIT_of(interface) != 0) {
		/* Only Unit 0 should reset or load firmware */
		dev_info(&pdev->dev, "Firmware will be loaded by partner\n");
		return 0;
		}

		fw = nfp_net_fw_find(pdev, pf);
		if (!fw)
		return 0;

		dev_info(&pdev->dev, "Soft-reset, loading FW image\n");
		err = nfp_nsp_device_soft_reset(nsp);
		if (err < 0) {
		dev_err(&pdev->dev, "Failed to soft reset the NFP: %d\n",
		err);
		goto exit_release_fw;
		}

		err = nfp_nsp_load_fw(nsp, fw);

		if (err < 0) {
		dev_err(&pdev->dev, "FW loading failed: %d\n", err);
		goto exit_release_fw;
		}

		dev_info(&pdev->dev, "Finished loading FW image\n");

		exit_release_fw:
		release_firmware(fw);

		return err < 0 ? err : 1;
		}

		static void nfp_fw_unload(struct nfp_pf *pf)
		{
		struct nfp_nsp *nsp;
		int err;

		nsp = nfp_nsp_open(pf->cpp);
		if (IS_ERR(nsp)) {
		nfp_err(pf->cpp, "Reset failed, can't open NSP\n");
		return;
		}

		err = nfp_nsp_device_soft_reset(nsp);
		if (err < 0)
		dev_warn(&pf->pdev->dev, "Couldn't unload firmware: %d\n", err);
		else
		dev_info(&pf->pdev->dev, "Firmware safely unloaded\n");

		nfp_nsp_close(nsp);
		}

		static int nfp_pci_probe(struct pci_dev *pdev,
		const struct pci_device_id *pci_id)
		{
		struct nfp_nsp *nsp;
		struct nfp_pf *pf;
		int err;

		err = pci_enable_device(pdev);
		if (err < 0)
		return err;

		pci_set_master(pdev);

		err = dma_set_mask_and_coherent(&pdev->dev,
		DMA_BIT_MASK(NFP_NET_MAX_DMA_BITS));
		if (err)
		goto err_pci_disable;

		err = pci_request_regions(pdev, nfp_driver_name);
		if (err < 0) {
		dev_err(&pdev->dev, "Unable to reserve pci resources.\n");
		goto err_pci_disable;
		}

		pf = kzalloc(sizeof(*pf), GFP_KERNEL);
		if (!pf) {
		err = -ENOMEM;
		goto err_rel_regions;
		}
		INIT_LIST_HEAD(&pf->ports);
		pci_set_drvdata(pdev, pf);
		pf->pdev = pdev;

		pf->cpp = nfp_cpp_from_nfp6000_pcie(pdev);
		if (IS_ERR_OR_NULL(pf->cpp)) {
		err = PTR_ERR(pf->cpp);
		if (err >= 0)
		err = -ENOMEM;
		goto err_disable_msix;
		}

		nsp = nfp_nsp_open(pf->cpp);
		if (IS_ERR(nsp)) {
		err = PTR_ERR(nsp);
		goto err_cpp_free;
		}

		err = nfp_nsp_wait(nsp);
		if (err < 0) {
		nfp_nsp_close(nsp);
		goto err_cpp_free;
		}

		pf->eth_tbl = __nfp_eth_read_ports(pf->cpp, nsp);

		err = nfp_fw_load(pdev, pf, nsp);
		nfp_nsp_close(nsp);
		if (err < 0) {
		dev_err(&pdev->dev, "Failed to load FW\n");
		goto err_eth_tbl_free;
		}

		pf->fw_loaded = !!err;

		err = nfp_net_pci_probe(pf);
		if (err)
		goto err_fw_unload;

		return 0;

		err_fw_unload:
		if (pf->fw_loaded)
		nfp_fw_unload(pf);
		err_eth_tbl_free:
		kfree(pf->eth_tbl);
		err_cpp_free:
		nfp_cpp_free(pf->cpp);
		err_disable_msix:
		pci_set_drvdata(pdev, NULL);
		kfree(pf);
		err_rel_regions:
		pci_release_regions(pdev);
		err_pci_disable:
		pci_disable_device(pdev);

		return err;
		}

		static void nfp_pci_remove(struct pci_dev *pdev)
		{
		struct nfp_pf *pf = pci_get_drvdata(pdev);

		if (!list_empty(&pf->ports))
		nfp_net_pci_remove(pf);

		nfp_pcie_sriov_disable(pdev);

		if (pf->fw_loaded)
		nfp_fw_unload(pf);

		pci_set_drvdata(pdev, NULL);
		nfp_cpp_free(pf->cpp);

		kfree(pf->eth_tbl);
		kfree(pf);
		pci_release_regions(pdev);
		pci_disable_device(pdev);
		}

		static struct pci_driver nfp_pci_driver = {
		.name = nfp_driver_name,
		.id_table = nfp_pci_device_ids,
		.probe = nfp_pci_probe,
		.remove = nfp_pci_remove,
		.sriov_configure = nfp_pcie_sriov_configure,
		};

		static int __init nfp_main_init(void)
		{
		int err;
		@@ -60,12 +374,18 @@ static int __init nfp_main_init(void)

		nfp_net_debugfs_create();

		err = pci_register_driver(&nfp_pci_driver);
		if (err < 0)
		goto err_destroy_debugfs;

		err = pci_register_driver(&nfp_netvf_pci_driver);
		if (err)
		goto err_destroy_debugfs;
		goto err_unreg_pf;

		return err;

		err_unreg_pf:
		pci_unregister_driver(&nfp_pci_driver);
		err_destroy_debugfs:
		nfp_net_debugfs_destroy();
		return err;
		@@ -74,12 +394,22 @@ static int __init nfp_main_init(void)
		static void __exit nfp_main_exit(void)
		{
		pci_unregister_driver(&nfp_netvf_pci_driver);
		pci_unregister_driver(&nfp_pci_driver);
		nfp_net_debugfs_destroy();
		}

		module_init(nfp_main_init);
		module_exit(nfp_main_exit);

		MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_1x40.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0081-0001_4x10.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0096-0001_2x10.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_2x40.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_4x10_1x40.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0097-0001_8x10.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x10.nffw");
		MODULE_FIRMWARE("netronome/nic_AMDA0099-0001_2x25.nffw");

		MODULE_AUTHOR("Netronome Systems <oss-drivers@netronome.com>");
		MODULE_LICENSE("GPL");
		MODULE_DESCRIPTION("The Netronome Flow Processor (NFP) driver.");

drivers/net/ethernet/netronome/nfp/nfp_main.h

+49 −0

Original line number	Diff line number	Diff line
		@@ -39,10 +39,59 @@
		#ifndef NFP_MAIN_H
		#define NFP_MAIN_H

		#include <linux/list.h>
		#include <linux/types.h>
		#include <linux/msi.h>
		#include <linux/pci.h>

		struct dentry;
		struct pci_dev;

		struct nfp_cpp;
		struct nfp_cpp_area;
		struct nfp_eth_table;

		/**
		* struct nfp_pf - NFP PF-specific device structure
		* @pdev: Backpointer to PCI device
		* @cpp: Pointer to the CPP handle
		* @ctrl_area: Pointer to the CPP area for the control BAR
		* @tx_area: Pointer to the CPP area for the TX queues
		* @rx_area: Pointer to the CPP area for the FL/RX queues
		* @irq_entries: Array of MSI-X entries for all ports
		* @num_vfs: Number of SR-IOV VFs enabled
		* @fw_loaded: Is the firmware loaded?
		* @eth_tbl: NSP ETH table
		* @ddir: Per-device debugfs directory
		* @num_ports: Number of adapter ports
		* @ports: Linked list of port structures (struct nfp_net)
		*/
		struct nfp_pf {
		struct pci_dev *pdev;

		struct nfp_cpp *cpp;

		struct nfp_cpp_area *ctrl_area;
		struct nfp_cpp_area *tx_area;
		struct nfp_cpp_area *rx_area;

		struct msix_entry *irq_entries;

		unsigned int num_vfs;

		bool fw_loaded;

		struct nfp_eth_table *eth_tbl;

		struct dentry *ddir;

		unsigned int num_ports;
		struct list_head ports;
		};

		extern struct pci_driver nfp_netvf_pci_driver;

		int nfp_net_pci_probe(struct nfp_pf *pf);
		void nfp_net_pci_remove(struct nfp_pf *pf);

		#endif /* NFP_MAIN_H */

drivers/net/ethernet/netronome/nfp/nfp_net.h

+4 −22

Original line number	Diff line number	Diff line
		@@ -43,6 +43,7 @@
		#define _NFP_NET_H_

		#include <linux/interrupt.h>
		#include <linux/list.h>
		#include <linux/netdevice.h>
		#include <linux/pci.h>
		#include <linux/io-64-nonatomic-hi-lo.h>
		@@ -434,20 +435,13 @@ struct nfp_stat_pair {
		* struct nfp_net - NFP network device structure
		* @pdev: Backpointer to PCI device
		* @netdev: Backpointer to net_device structure
		* @nfp_fallback: Is the driver used in fallback mode?
		* @is_vf: Is the driver attached to a VF?
		* @fw_loaded: Is the firmware loaded?
		* @bpf_offload_skip_sw: Offloaded BPF program will not be rerun by cls_bpf
		* @bpf_offload_xdp: Offloaded BPF program is XDP
		* @ctrl: Local copy of the control register/word.
		* @fl_bufsz: Currently configured size of the freelist buffers
		* @rx_offset: Offset in the RX buffers where packet data starts
		* @xdp_prog: Installed XDP program
		* @cpp: Pointer to the CPP handle
		* @nfp_dev_cpp: Pointer to the NFP Device handle
		* @ctrl_area: Pointer to the CPP area for the control BAR
		* @tx_area: Pointer to the CPP area for the TX queues
		* @rx_area: Pointer to the CPP area for the FL/RX queues
		* @fw_ver: Firmware version
		* @cap: Capabilities advertised by the Firmware
		* @max_mtu: Maximum support MTU advertised by the Firmware
		@@ -497,14 +491,13 @@ struct nfp_stat_pair {
		* @tx_bar: Pointer to mapped TX queues
		* @rx_bar: Pointer to mapped FL/RX queues
		* @debugfs_dir: Device directory in debugfs
		* @port_list: Entry on device port list
		*/
		struct nfp_net {
		struct pci_dev *pdev;
		struct net_device *netdev;

		unsigned nfp_fallback:1;
		unsigned is_vf:1;
		unsigned fw_loaded:1;
		unsigned bpf_offload_skip_sw:1;
		unsigned bpf_offload_xdp:1;

		@@ -518,18 +511,6 @@ struct nfp_net {
		struct nfp_net_tx_ring *tx_rings;
		struct nfp_net_rx_ring *rx_rings;

		#ifdef CONFIG_PCI_IOV
		unsigned int num_vfs;
		struct vf_data_storage *vfinfo;
		int vf_rate_link_speed;
		#endif

		struct nfp_cpp *cpp;
		struct platform_device *nfp_dev_cpp;
		struct nfp_cpp_area *ctrl_area;
		struct nfp_cpp_area *tx_area;
		struct nfp_cpp_area *rx_area;

		struct nfp_net_fw_version fw_ver;
		u32 cap;
		u32 max_mtu;
		@@ -592,11 +573,12 @@ struct nfp_net {
		u8 __iomem *qcp_cfg;

		u8 __iomem *ctrl_bar;
		u8 __iomem *q_bar;
		u8 __iomem *tx_bar;
		u8 __iomem *rx_bar;

		struct dentry *debugfs_dir;

		struct list_head port_list;
		};

		struct nfp_net_ring_set {

drivers/net/ethernet/netronome/nfp/nfp_net_main.c

0 → 100644

+585 −0

File added.

Preview size limit exceeded, changes collapsed.