Commit e40d5d78 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'netronome-NFP4000-and-NFP6000-PF-driver' 



Jakub Kicinski says:

====================
Netronome NFP4000 and NFP6000 PF driver

This is a base PF driver for Netronome NFP4000 and NFP6000 chips.  This
series doesn't add any exciting new features, it provides a foundation
for supporting more advanced firmware applications.

Patch 1 moves a bitfield-related helper from our BPF code to the global
header.

Patch 2 renames the kernel module and adds a new main file.  We were
considering 3-module approach (pf, vf, common netdev library) but
ultimately settled on a single module to keep things simple.

Patch 3 adds support for accessing chip internals.  It provides a way of
configuring access windows to different parts of chip memory and issuing
pretty much any commands on chip's NoC.

Patches 4, 5, 6, 7, 8 provide support for accessing and interpreting
various hardware and firmware information structures.

Patch 9 introduces service processor (NSP) ABI.  This ABI gives us
access to PHY/SFP module configuration and information as well as
methods for unloading and loading application firmware.

Patches 10 and 11 modify the existing netdev code to make it possible
to support multi-port devices (sharing a PCI device).

Patch 12 adds a new driver probe path which will be used for the PF
PCI device IDs.  It utilizes the newly added infrastructure and is able
to load application FW and spawn netdevs for all card's ports.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 4f2bd6b3 63461a02

drivers/net/ethernet/netronome/Kconfig

+9 −9
Original line number Diff line number Diff line
@@ -15,21 +15,21 @@ config NET_VENDOR_NETRONOME 


if NET_VENDOR_NETRONOME



config NFP_NETVF

	tristate "Netronome(R) NFP4000/NFP6000 VF NIC driver"

config NFP

	tristate "Netronome(R) NFP4000/NFP6000 NIC driver"

	depends on PCI && PCI_MSI

	depends on VXLAN || VXLAN=n

	---help---

	  This driver supports SR-IOV virtual functions of

	  the Netronome(R) NFP4000/NFP6000 cards working as

	  a advanced Ethernet NIC.

	  This driver supports the Netronome(R) NFP4000/NFP6000 based

	  cards working as a advanced Ethernet NIC.  It works with both

	  SR-IOV physical and virtual functions.



config NFP_NET_DEBUG

	bool "Debug support for Netronome(R) NFP3200/NFP6000 NIC drivers"

	depends on NFP_NET || NFP_NETVF

config NFP_DEBUG

	bool "Debug support for Netronome(R) NFP4000/NFP6000 NIC drivers"

	depends on NFP

	---help---

	  Enable extra sanity checks and debugfs support in

	  Netronome(R) NFP3200/NFP6000 NIC PF and VF drivers.

	  Netronome(R) NFP4000/NFP6000 NIC drivers.

	  Note: selecting this option may adversely impact

		performance.

drivers/net/ethernet/netronome/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -2,4 +2,4 @@ 
# Makefile for the Netronome network device drivers

#



obj-$(CONFIG_NFP_NETVF) += nfp/
 
obj-$(CONFIG_NFP) += nfp/

drivers/net/ethernet/netronome/nfp/Makefile

+17 −4
Original line number Diff line number Diff line 
obj-$(CONFIG_NFP_NETVF)	+= nfp_netvf.o

obj-$(CONFIG_NFP)	+= nfp.o



nfp_netvf-objs := \

nfp-objs := \

	    nfpcore/nfp6000_pcie.o \

	    nfpcore/nfp_cppcore.o \

	    nfpcore/nfp_cpplib.o \

	    nfpcore/nfp_hwinfo.o \

	    nfpcore/nfp_mip.o \

	    nfpcore/nfp_nffw.o \

	    nfpcore/nfp_nsp.o \

	    nfpcore/nfp_nsp_eth.o \

	    nfpcore/nfp_resource.o \

	    nfpcore/nfp_rtsym.o \

	    nfpcore/nfp_target.o \

	    nfp_main.o \

	    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)

nfp_netvf-objs += \

nfp-objs += \

	    nfp_bpf_verifier.o \

	    nfp_bpf_jit.o

endif



nfp_netvf-$(CONFIG_NFP_NET_DEBUG) += nfp_net_debugfs.o
 
nfp-$(CONFIG_NFP_DEBUG) += nfp_net_debugfs.o

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

+0 −2
Original line number Diff line number Diff line
@@ -39,8 +39,6 @@ 
#include <linux/list.h>

#include <linux/types.h>



#define FIELD_FIT(mask, val)  (!((((u64)val) << __bf_shf(mask)) & ~(mask)))



/* For branch fixup logic use up-most byte of branch instruction as scratch

 * area.  Remember to clear this before sending instructions to HW!

 */

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

0 → 100644
+415 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015-2017 Netronome Systems, Inc.

 *

 * This software is dual licensed under the GNU General License Version 2,

 * June 1991 as shown in the file COPYING in the top-level directory of this

 * source tree or the BSD 2-Clause License provided below.  You have the

 * option to license this software under the complete terms of either license.

 *

 * The BSD 2-Clause License:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      1. Redistributions of source code must retain the above

 *         copyright notice, this list of conditions and the following

 *         disclaimer.

 *

 *      2. Redistributions in binary form must reproduce the above

 *         copyright notice, this list of conditions and the following

 *         disclaimer in the documentation and/or other materials

 *         provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



/*

 * nfp_main.c

 * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>

 *          Alejandro Lucero <alejandro.lucero@netronome.com>

 *          Jason McMullan <jason.mcmullan@netronome.com>

 *          Rolf Neugebauer <rolf.neugebauer@netronome.com>

 */



#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/pci.h>

#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;



	pr_info("%s: NFP PCIe Driver, Copyright (C) 2014-2017 Netronome Systems\n",

		nfp_driver_name);



	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_unreg_pf;



	return err;



err_unreg_pf:

	pci_unregister_driver(&nfp_pci_driver);

err_destroy_debugfs:

	nfp_net_debugfs_destroy();

	return err;

}



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.");

CRA Git | Maintained and supported by SUSTech CRA and CCSE