Merge branch 'nfp-pci-core-hwmon-live-mac-addr-change' (f1bd4dae) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/net/ethernet/netronome/Kconfig

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,7 @@ config NFP
	tristate "Netronome(R) NFP4000/NFP6000 NIC driver"		tristate "Netronome(R) NFP4000/NFP6000 NIC driver"
	depends on PCI && PCI_MSI		depends on PCI && PCI_MSI
	depends on VXLAN \|\| VXLAN=n		depends on VXLAN \|\| VXLAN=n
			depends on MAY_USE_DEVLINK
	---help---		---help---
	This driver supports the Netronome(R) NFP4000/NFP6000 based		This driver supports the Netronome(R) NFP4000/NFP6000 based
	cards working as a advanced Ethernet NIC. It works with both		cards working as a advanced Ethernet NIC. It works with both

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,7 @@ nfp-objs := \
	nfpcore/nfp_target.o \		nfpcore/nfp_target.o \
	nfp_app.o \		nfp_app.o \
	nfp_devlink.o \		nfp_devlink.o \
			nfp_hwmon.o \
	nfp_main.o \		nfp_main.o \
	nfp_net_common.o \		nfp_net_common.o \
	nfp_net_ethtool.o \		nfp_net_ethtool.o \

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

0 → 100644

+192 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 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.
			*/

			#include <linux/kernel.h>
			#include <linux/bitops.h>
			#include <linux/hwmon.h>

			#include "nfpcore/nfp_cpp.h"
			#include "nfpcore/nfp_nsp.h"
			#include "nfp_main.h"

			#define NFP_TEMP_MAX (95 * 1000)
			#define NFP_TEMP_CRIT (105 * 1000)

			#define NFP_POWER_MAX (25 * 1000 * 1000)

			static int nfp_hwmon_sensor_id(enum hwmon_sensor_types type, int channel)
			{
			if (type == hwmon_temp)
			return NFP_SENSOR_CHIP_TEMPERATURE;
			if (type == hwmon_power)
			return NFP_SENSOR_ASSEMBLY_POWER + channel;
			return -EINVAL;
			}

			static int
			nfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
			int channel, long *val)
			{
			static const struct {
			enum hwmon_sensor_types type;
			u32 attr;
			long val;
			} const_vals[] = {
			{ hwmon_temp, hwmon_temp_max, NFP_TEMP_MAX },
			{ hwmon_temp, hwmon_temp_crit, NFP_TEMP_CRIT },
			{ hwmon_power, hwmon_power_max, NFP_POWER_MAX },
			};
			struct nfp_pf *pf = dev_get_drvdata(dev);
			enum nfp_nsp_sensor_id id;
			int err, i;

			for (i = 0; i < ARRAY_SIZE(const_vals); i++)
			if (const_vals[i].type == type && const_vals[i].attr == attr) {
			*val = const_vals[i].val;
			return 0;
			}

			err = nfp_hwmon_sensor_id(type, channel);
			if (err < 0)
			return err;
			id = err;

			if (!(pf->nspi->sensor_mask & BIT(id)))
			return -EOPNOTSUPP;

			if (type == hwmon_temp && attr == hwmon_temp_input)
			return nfp_hwmon_read_sensor(pf->cpp, id, val);
			if (type == hwmon_power && attr == hwmon_power_input)
			return nfp_hwmon_read_sensor(pf->cpp, id, val);

			return -EINVAL;
			}

			static umode_t
			nfp_hwmon_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
			int channel)
			{
			if (type == hwmon_temp) {
			switch (attr) {
			case hwmon_temp_input:
			case hwmon_temp_crit:
			case hwmon_temp_max:
			return 0444;
			}
			} else if (type == hwmon_power) {
			switch (attr) {
			case hwmon_power_input:
			case hwmon_power_max:
			return 0444;
			}
			}
			return 0;
			}

			static u32 nfp_chip_config[] = {
			HWMON_C_REGISTER_TZ,
			0
			};

			static const struct hwmon_channel_info nfp_chip = {
			.type = hwmon_chip,
			.config = nfp_chip_config,
			};

			static u32 nfp_temp_config[] = {
			HWMON_T_INPUT \| HWMON_T_MAX \| HWMON_T_CRIT,
			0
			};

			static const struct hwmon_channel_info nfp_temp = {
			.type = hwmon_temp,
			.config = nfp_temp_config,
			};

			static u32 nfp_power_config[] = {
			HWMON_P_INPUT \| HWMON_P_MAX,
			HWMON_P_INPUT,
			HWMON_P_INPUT,
			0
			};

			static const struct hwmon_channel_info nfp_power = {
			.type = hwmon_power,
			.config = nfp_power_config,
			};

			static const struct hwmon_channel_info *nfp_hwmon_info[] = {
			&nfp_chip,
			&nfp_temp,
			&nfp_power,
			NULL
			};

			static const struct hwmon_ops nfp_hwmon_ops = {
			.is_visible = nfp_hwmon_is_visible,
			.read = nfp_hwmon_read,
			};

			static const struct hwmon_chip_info nfp_chip_info = {
			.ops = &nfp_hwmon_ops,
			.info = nfp_hwmon_info,
			};

			int nfp_hwmon_register(struct nfp_pf *pf)
			{
			if (!IS_REACHABLE(CONFIG_HWMON))
			return 0;

			if (!pf->nspi) {
			nfp_warn(pf->cpp, "not registering HWMON (no NSP info)\n");
			return 0;
			}
			if (!pf->nspi->sensor_mask) {
			nfp_info(pf->cpp,
			"not registering HWMON (NSP doesn't report sensors)\n");
			return 0;
			}

			pf->hwmon_dev = hwmon_device_register_with_info(&pf->pdev->dev, "nfp",
			pf, &nfp_chip_info,
			NULL);
			return PTR_ERR_OR_ZERO(pf->hwmon_dev);
			}

			void nfp_hwmon_unregister(struct nfp_pf *pf)
			{
			if (!IS_REACHABLE(CONFIG_HWMON) \|\| !pf->hwmon_dev)
			return;

			hwmon_device_unregister(pf->hwmon_dev);
			}

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

+30 −14

Original line number	Original line	Diff line number	Diff line
	@@ -73,20 +73,22 @@ static const struct pci_device_id nfp_pci_device_ids[] = {
	};		};
	MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);		MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);

	static void nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf)		static int nfp_pcie_sriov_read_nfd_limit(struct nfp_pf *pf)
	{		{
	#ifdef CONFIG_PCI_IOV
	int err;		int err;

	pf->limit_vfs = nfp_rtsym_read_le(pf->cpp, "nfd_vf_cfg_max_vfs", &err);		pf->limit_vfs = nfp_rtsym_read_le(pf->cpp, "nfd_vf_cfg_max_vfs", &err);
	if (!err)		if (!err)
	return;		return pci_sriov_set_totalvfs(pf->pdev, pf->limit_vfs);

	pf->limit_vfs = ~0;		pf->limit_vfs = ~0;
			pci_sriov_set_totalvfs(pf->pdev, 0); /* 0 is unset */
	/* Allow any setting for backwards compatibility if symbol not found */		/* Allow any setting for backwards compatibility if symbol not found */
	if (err != -ENOENT)		if (err == -ENOENT)
			return 0;

	nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err);		nfp_warn(pf->cpp, "Warning: VF limit read failed: %d\n", err);
	#endif		return err;
	}		}

	static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)		static int nfp_pcie_sriov_enable(struct pci_dev *pdev, int num_vfs)
	@@ -255,7 +257,6 @@ nfp_fw_load(struct pci_dev pdev, struct nfp_pf pf, struct nfp_nsp *nsp)

	static int nfp_nsp_init(struct pci_dev pdev, struct nfp_pf pf)		static int nfp_nsp_init(struct pci_dev pdev, struct nfp_pf pf)
	{		{
	struct nfp_nsp_identify *nspi;
	struct nfp_nsp *nsp;		struct nfp_nsp *nsp;
	int err;		int err;

	@@ -272,11 +273,9 @@ static int nfp_nsp_init(struct pci_dev pdev, struct nfp_pf pf)

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

	nspi = __nfp_nsp_identify(nsp);		pf->nspi = __nfp_nsp_identify(nsp);
	if (nspi) {		if (pf->nspi)
	dev_info(&pdev->dev, "BSP: %s\n", nspi->version);		dev_info(&pdev->dev, "BSP: %s\n", pf->nspi->version);
	kfree(nspi);
	}

	err = nfp_fw_load(pdev, pf, nsp);		err = nfp_fw_load(pdev, pf, nsp);
	if (err < 0) {		if (err < 0) {
	@@ -373,18 +372,31 @@ static int nfp_pci_probe(struct pci_dev *pdev,
	if (err)		if (err)
	goto err_devlink_unreg;		goto err_devlink_unreg;

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

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

			err = nfp_hwmon_register(pf);
			if (err) {
			dev_err(&pdev->dev, "Failed to register hwmon info\n");
			goto err_net_remove;
			}

	return 0;		return 0;

			err_net_remove:
			nfp_net_pci_remove(pf);
			err_sriov_unlimit:
			pci_sriov_set_totalvfs(pf->pdev, 0);
	err_fw_unload:		err_fw_unload:
	if (pf->fw_loaded)		if (pf->fw_loaded)
	nfp_fw_unload(pf);		nfp_fw_unload(pf);
	kfree(pf->eth_tbl);		kfree(pf->eth_tbl);
			kfree(pf->nspi);
	err_devlink_unreg:		err_devlink_unreg:
	devlink_unregister(devlink);		devlink_unregister(devlink);
	err_cpp_free:		err_cpp_free:
	@@ -406,11 +418,14 @@ static void nfp_pci_remove(struct pci_dev *pdev)
	struct nfp_pf *pf = pci_get_drvdata(pdev);		struct nfp_pf *pf = pci_get_drvdata(pdev);
	struct devlink *devlink;		struct devlink *devlink;

			nfp_hwmon_unregister(pf);

	devlink = priv_to_devlink(pf);		devlink = priv_to_devlink(pf);

	nfp_net_pci_remove(pf);		nfp_net_pci_remove(pf);

	nfp_pcie_sriov_disable(pdev);		nfp_pcie_sriov_disable(pdev);
			pci_sriov_set_totalvfs(pf->pdev, 0);

	devlink_unregister(devlink);		devlink_unregister(devlink);

	@@ -421,6 +436,7 @@ static void nfp_pci_remove(struct pci_dev *pdev)
	nfp_cpp_free(pf->cpp);		nfp_cpp_free(pf->cpp);

	kfree(pf->eth_tbl);		kfree(pf->eth_tbl);
			kfree(pf->nspi);
	mutex_destroy(&pf->lock);		mutex_destroy(&pf->lock);
	devlink_free(devlink);		devlink_free(devlink);
	pci_release_regions(pdev);		pci_release_regions(pdev);

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

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -47,12 +47,14 @@
	#include <linux/workqueue.h>		#include <linux/workqueue.h>

	struct dentry;		struct dentry;
			struct device;
	struct devlink_ops;		struct devlink_ops;
	struct pci_dev;		struct pci_dev;

	struct nfp_cpp;		struct nfp_cpp;
	struct nfp_cpp_area;		struct nfp_cpp_area;
	struct nfp_eth_table;		struct nfp_eth_table;
			struct nfp_nsp_identify;

	/**		/**
	* struct nfp_pf - NFP PF-specific device structure		* struct nfp_pf - NFP PF-specific device structure
	@@ -67,6 +69,8 @@ struct nfp_eth_table;
	* @num_vfs: Number of SR-IOV VFs enabled		* @num_vfs: Number of SR-IOV VFs enabled
	* @fw_loaded: Is the firmware loaded?		* @fw_loaded: Is the firmware loaded?
	* @eth_tbl: NSP ETH table		* @eth_tbl: NSP ETH table
			* @nspi: NSP identification info
			* @hwmon_dev: pointer to hwmon device
	* @ddir: Per-device debugfs directory		* @ddir: Per-device debugfs directory
	* @max_data_vnics: Number of data vNICs app firmware supports		* @max_data_vnics: Number of data vNICs app firmware supports
	* @num_vnics: Number of vNICs spawned		* @num_vnics: Number of vNICs spawned
	@@ -94,6 +98,9 @@ struct nfp_pf {
	bool fw_loaded;		bool fw_loaded;

	struct nfp_eth_table *eth_tbl;		struct nfp_eth_table *eth_tbl;
			struct nfp_nsp_identify *nspi;

			struct device *hwmon_dev;

	struct dentry *ddir;		struct dentry *ddir;

	@@ -113,4 +120,7 @@ extern const struct devlink_ops nfp_devlink_ops;
	int nfp_net_pci_probe(struct nfp_pf *pf);		int nfp_net_pci_probe(struct nfp_pf *pf);
	void nfp_net_pci_remove(struct nfp_pf *pf);		void nfp_net_pci_remove(struct nfp_pf *pf);

			int nfp_hwmon_register(struct nfp_pf *pf);
			void nfp_hwmon_unregister(struct nfp_pf *pf);

	#endif /* NFP_MAIN_H */		#endif /* NFP_MAIN_H */