Merge branch 'qed-introduce-devlink-health-support' (0caeba3d) · Commits · 戴 / test

drivers/net/ethernet/qlogic/Kconfig

+3 −2

Original line number	Diff line number	Diff line
		@@ -80,7 +80,7 @@ config QED
		select CRC8
		select NET_DEVLINK
		help
		This enables the support for ...
		This enables the support for Marvell FastLinQ adapters family.

		config QED_LL2
		bool
		@@ -100,7 +100,8 @@ config QEDE
		depends on QED
		imply PTP_1588_CLOCK
		help
		This enables the support for ...
		This enables the support for Marvell FastLinQ adapters family,
		ethernet driver.

		config QED_RDMA
		bool

drivers/net/ethernet/qlogic/qed/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@ qed-y := \
		qed_dcbx.o \
		qed_debug.o \
		qed_dev.o \
		qed_devlink.o \
		qed_hw.o \
		qed_init_fw_funcs.o \
		qed_init_ops.o \

drivers/net/ethernet/qlogic/qed/qed.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -807,6 +807,7 @@ struct qed_dev {
		struct qed_llh_info *p_llh_info;

		/* Linux specific here */
		struct qed_dev_info common_dev_info;
		struct qede_dev *edev;
		struct pci_dev *pdev;
		u32 flags;
		@@ -849,7 +850,6 @@ struct qed_dev {
		u32 rdma_max_srq_sge;
		u16 tunn_feature_mask;

		struct devlink *dl;
		bool iwarp_cmt;
		};

		@@ -981,6 +981,7 @@ void qed_bw_update(struct qed_hwfn hwfn, struct qed_ptt ptt);
		u32 qed_unzip_data(struct qed_hwfn *p_hwfn,
		u32 input_len, u8 *input_buf,
		u32 max_size, u8 *unzip_buf);
		int qed_recovery_process(struct qed_dev *cdev);
		void qed_schedule_recovery_handler(struct qed_hwfn *p_hwfn);
		void qed_hw_error_occurred(struct qed_hwfn *p_hwfn,
		enum qed_hw_err_type err_type);

drivers/net/ethernet/qlogic/qed/qed_dev.c

+9 −0

Original line number	Diff line number	Diff line
		@@ -3973,6 +3973,7 @@ static int qed_hw_get_nvm_info(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
		struct qed_mcp_link_speed_params *ext_speed;
		struct qed_mcp_link_capabilities *p_caps;
		struct qed_mcp_link_params *link;
		int i;

		/* Read global nvm_cfg address */
		nvm_cfg_addr = qed_rd(p_hwfn, p_ptt, MISC_REG_GEN_PURP_CR0);
		@@ -4290,6 +4291,14 @@ static int qed_hw_get_nvm_info(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
		__set_bit(QED_DEV_CAP_ROCE,
		&p_hwfn->hw_info.device_capabilities);

		/* Read device serial number information from shmem */
		addr = MCP_REG_SCRATCH + nvm_cfg1_offset +
		offsetof(struct nvm_cfg1, glob) +
		offsetof(struct nvm_cfg1_glob, serial_number);

		for (i = 0; i < 4; i++)
		p_hwfn->hw_info.part_num[i] = qed_rd(p_hwfn, p_ptt, addr + i * 4);

		return qed_mcp_fill_shmem_func_info(p_hwfn, p_ptt);
		}

drivers/net/ethernet/qlogic/qed/qed_devlink.c

0 → 100644

+259 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/* Marvell/Qlogic FastLinQ NIC driver
		*
		* Copyright (C) 2020 Marvell International Ltd.
		*/

		#include <linux/kernel.h>
		#include <linux/qed/qed_if.h>
		#include <linux/vmalloc.h>
		#include "qed.h"
		#include "qed_devlink.h"

		enum qed_devlink_param_id {
		QED_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
		QED_DEVLINK_PARAM_ID_IWARP_CMT,
		};

		struct qed_fw_fatal_ctx {
		enum qed_hw_err_type err_type;
		};

		int qed_report_fatal_error(struct devlink *devlink, enum qed_hw_err_type err_type)
		{
		struct qed_devlink *qdl = devlink_priv(devlink);
		struct qed_fw_fatal_ctx fw_fatal_ctx = {
		.err_type = err_type,
		};

		if (qdl->fw_reporter)
		devlink_health_report(qdl->fw_reporter,
		"Fatal error occurred", &fw_fatal_ctx);

		return 0;
		}

		static int
		qed_fw_fatal_reporter_dump(struct devlink_health_reporter *reporter,
		struct devlink_fmsg fmsg, void priv_ctx,
		struct netlink_ext_ack *extack)
		{
		struct qed_devlink *qdl = devlink_health_reporter_priv(reporter);
		struct qed_fw_fatal_ctx *fw_fatal_ctx = priv_ctx;
		struct qed_dev *cdev = qdl->cdev;
		u32 dbg_data_buf_size;
		u8 *p_dbg_data_buf;
		int err;

		/* Having context means that was a dump request after fatal,
		* so we enable extra debugging while gathering the dump,
		* just in case
		*/
		cdev->print_dbg_data = fw_fatal_ctx ? true : false;

		dbg_data_buf_size = qed_dbg_all_data_size(cdev);
		p_dbg_data_buf = vzalloc(dbg_data_buf_size);
		if (!p_dbg_data_buf) {
		DP_NOTICE(cdev,
		"Failed to allocate memory for a debug data buffer\n");
		return -ENOMEM;
		}

		err = qed_dbg_all_data(cdev, p_dbg_data_buf);
		if (err) {
		DP_NOTICE(cdev, "Failed to obtain debug data\n");
		vfree(p_dbg_data_buf);
		return err;
		}

		err = devlink_fmsg_binary_pair_put(fmsg, "dump_data",
		p_dbg_data_buf, dbg_data_buf_size);

		vfree(p_dbg_data_buf);

		return err;
		}

		static int
		qed_fw_fatal_reporter_recover(struct devlink_health_reporter *reporter,
		void *priv_ctx,
		struct netlink_ext_ack *extack)
		{
		struct qed_devlink *qdl = devlink_health_reporter_priv(reporter);
		struct qed_dev *cdev = qdl->cdev;

		qed_recovery_process(cdev);

		return 0;
		}

		static const struct devlink_health_reporter_ops qed_fw_fatal_reporter_ops = {
		.name = "fw_fatal",
		.recover = qed_fw_fatal_reporter_recover,
		.dump = qed_fw_fatal_reporter_dump,
		};

		#define QED_REPORTER_FW_GRACEFUL_PERIOD 1200000

		void qed_fw_reporters_create(struct devlink *devlink)
		{
		struct qed_devlink *dl = devlink_priv(devlink);

		dl->fw_reporter = devlink_health_reporter_create(devlink, &qed_fw_fatal_reporter_ops,
		QED_REPORTER_FW_GRACEFUL_PERIOD, dl);
		if (IS_ERR(dl->fw_reporter)) {
		DP_NOTICE(dl->cdev, "Failed to create fw reporter, err = %ld\n",
		PTR_ERR(dl->fw_reporter));
		dl->fw_reporter = NULL;
		}
		}

		void qed_fw_reporters_destroy(struct devlink *devlink)
		{
		struct qed_devlink *dl = devlink_priv(devlink);
		struct devlink_health_reporter *rep;

		rep = dl->fw_reporter;

		if (!IS_ERR_OR_NULL(rep))
		devlink_health_reporter_destroy(rep);
		}

		static int qed_dl_param_get(struct devlink *dl, u32 id,
		struct devlink_param_gset_ctx *ctx)
		{
		struct qed_devlink *qed_dl = devlink_priv(dl);
		struct qed_dev *cdev;

		cdev = qed_dl->cdev;
		ctx->val.vbool = cdev->iwarp_cmt;

		return 0;
		}

		static int qed_dl_param_set(struct devlink *dl, u32 id,
		struct devlink_param_gset_ctx *ctx)
		{
		struct qed_devlink *qed_dl = devlink_priv(dl);
		struct qed_dev *cdev;

		cdev = qed_dl->cdev;
		cdev->iwarp_cmt = ctx->val.vbool;

		return 0;
		}

		static const struct devlink_param qed_devlink_params[] = {
		DEVLINK_PARAM_DRIVER(QED_DEVLINK_PARAM_ID_IWARP_CMT,
		"iwarp_cmt", DEVLINK_PARAM_TYPE_BOOL,
		BIT(DEVLINK_PARAM_CMODE_RUNTIME),
		qed_dl_param_get, qed_dl_param_set, NULL),
		};

		static int qed_devlink_info_get(struct devlink *devlink,
		struct devlink_info_req *req,
		struct netlink_ext_ack *extack)
		{
		struct qed_devlink *qed_dl = devlink_priv(devlink);
		struct qed_dev *cdev = qed_dl->cdev;
		struct qed_dev_info *dev_info;
		char buf[100];
		int err;

		dev_info = &cdev->common_dev_info;

		err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
		if (err)
		return err;

		memcpy(buf, cdev->hwfns[0].hw_info.part_num, sizeof(cdev->hwfns[0].hw_info.part_num));
		buf[sizeof(cdev->hwfns[0].hw_info.part_num)] = 0;

		if (buf[0]) {
		err = devlink_info_board_serial_number_put(req, buf);
		if (err)
		return err;
		}

		snprintf(buf, sizeof(buf), "%d.%d.%d.%d",
		GET_MFW_FIELD(dev_info->mfw_rev, QED_MFW_VERSION_3),
		GET_MFW_FIELD(dev_info->mfw_rev, QED_MFW_VERSION_2),
		GET_MFW_FIELD(dev_info->mfw_rev, QED_MFW_VERSION_1),
		GET_MFW_FIELD(dev_info->mfw_rev, QED_MFW_VERSION_0));

		err = devlink_info_version_stored_put(req,
		DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, buf);
		if (err)
		return err;

		snprintf(buf, sizeof(buf), "%d.%d.%d.%d",
		dev_info->fw_major,
		dev_info->fw_minor,
		dev_info->fw_rev,
		dev_info->fw_eng);

		return devlink_info_version_running_put(req,
		DEVLINK_INFO_VERSION_GENERIC_FW_APP, buf);
		}

		static const struct devlink_ops qed_dl_ops = {
		.info_get = qed_devlink_info_get,
		};

		struct devlink qed_devlink_register(struct qed_dev cdev)
		{
		union devlink_param_value value;
		struct qed_devlink *qdevlink;
		struct devlink *dl;
		int rc;

		dl = devlink_alloc(&qed_dl_ops, sizeof(struct qed_devlink));
		if (!dl)
		return ERR_PTR(-ENOMEM);

		qdevlink = devlink_priv(dl);
		qdevlink->cdev = cdev;

		rc = devlink_register(dl, &cdev->pdev->dev);
		if (rc)
		goto err_free;

		rc = devlink_params_register(dl, qed_devlink_params,
		ARRAY_SIZE(qed_devlink_params));
		if (rc)
		goto err_unregister;

		value.vbool = false;
		devlink_param_driverinit_value_set(dl,
		QED_DEVLINK_PARAM_ID_IWARP_CMT,
		value);

		devlink_params_publish(dl);
		cdev->iwarp_cmt = false;

		qed_fw_reporters_create(dl);

		return dl;

		err_unregister:
		devlink_unregister(dl);

		err_free:
		devlink_free(dl);

		return ERR_PTR(rc);
		}

		void qed_devlink_unregister(struct devlink *devlink)
		{
		if (!devlink)
		return;

		qed_fw_reporters_destroy(devlink);

		devlink_params_unregister(devlink, qed_devlink_params,
		ARRAY_SIZE(qed_devlink_params));

		devlink_unregister(devlink);
		devlink_free(devlink);
		}

Admin message