// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2025 Broadcom.

#include <linux/unaligned.h>
#include <linux/pci.h>
#include <linux/types.h>
#include <net/devlink.h>

#include "bnge.h"
#include "bnge_devlink.h"
#include "bnge_hwrm_lib.h"

static int bnge_dl_info_put(struct bnge_dev *bd, struct devlink_info_req *req,
			    enum bnge_dl_version_type type, const char *key,
			    char *buf)
{
	if (!strlen(buf))
		return 0;

	if (!strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_NCSI) ||
	    !strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_ROCE))
		return 0;

	switch (type) {
	case BNGE_VERSION_FIXED:
		return devlink_info_version_fixed_put(req, key, buf);
	case BNGE_VERSION_RUNNING:
		return devlink_info_version_running_put(req, key, buf);
	case BNGE_VERSION_STORED:
		return devlink_info_version_stored_put(req, key, buf);
	}

	return 0;
}

static void bnge_vpd_read_info(struct bnge_dev *bd)
{
	struct pci_dev *pdev = bd->pdev;
	unsigned int vpd_size, kw_len;
	int pos, size;
	u8 *vpd_data;

	vpd_data = pci_vpd_alloc(pdev, &vpd_size);
	if (IS_ERR(vpd_data)) {
		pci_warn(pdev, "Unable to read VPD\n");
		return;
	}

	pos = pci_vpd_find_ro_info_keyword(vpd_data, vpd_size,
					   PCI_VPD_RO_KEYWORD_PARTNO, &kw_len);
	if (pos < 0)
		goto read_sn;

	size = min_t(int, kw_len, BNGE_VPD_FLD_LEN - 1);
	memcpy(bd->board_partno, &vpd_data[pos], size);

read_sn:
	pos = pci_vpd_find_ro_info_keyword(vpd_data, vpd_size,
					   PCI_VPD_RO_KEYWORD_SERIALNO,
					   &kw_len);
	if (pos < 0)
		goto exit;

	size = min_t(int, kw_len, BNGE_VPD_FLD_LEN - 1);
	memcpy(bd->board_serialno, &vpd_data[pos], size);

exit:
	kfree(vpd_data);
}

#define HWRM_FW_VER_STR_LEN	16

static int bnge_devlink_info_get(struct devlink *devlink,
				 struct devlink_info_req *req,
				 struct netlink_ext_ack *extack)
{
	struct hwrm_nvm_get_dev_info_output nvm_dev_info;
	struct bnge_dev *bd = devlink_priv(devlink);
	struct hwrm_ver_get_output *ver_resp;
	char mgmt_ver[FW_VER_STR_LEN];
	char roce_ver[FW_VER_STR_LEN];
	char ncsi_ver[FW_VER_STR_LEN];
	char buf[32];

	int rc;

	if (bd->dsn) {
		char buf[32];
		u8 dsn[8];
		int rc;

		put_unaligned_le64(bd->dsn, dsn);
		sprintf(buf, "%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X",
			dsn[7], dsn[6], dsn[5], dsn[4],
			dsn[3], dsn[2], dsn[1], dsn[0]);
		rc = devlink_info_serial_number_put(req, buf);
		if (rc) {
			NL_SET_ERR_MSG_MOD(extack, "Failed to set dsn");
			return rc;
		}
	}

	if (strlen(bd->board_serialno)) {
		rc = devlink_info_board_serial_number_put(req,
							  bd->board_serialno);
		if (rc) {
			NL_SET_ERR_MSG_MOD(extack,
					   "Failed to set board serial number");
			return rc;
		}
	}

	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_FIXED,
			      DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
			      bd->board_partno);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to set board part number");
		return rc;
	}

	/* More information from HWRM ver get command */
	sprintf(buf, "%X", bd->chip_num);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_FIXED,
			      DEVLINK_INFO_VERSION_GENERIC_ASIC_ID, buf);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to set asic id");
		return rc;
	}

	ver_resp = &bd->ver_resp;
	sprintf(buf, "%c%d", 'A' + ver_resp->chip_rev, ver_resp->chip_metal);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_FIXED,
			      DEVLINK_INFO_VERSION_GENERIC_ASIC_REV, buf);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to set asic info");
		return rc;
	}

	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
			      bd->nvm_cfg_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to set firmware version");
		return rc;
	}

	buf[0] = 0;
	strncat(buf, ver_resp->active_pkg_name, HWRM_FW_VER_STR_LEN);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW, buf);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set firmware generic version");
		return rc;
	}

	if (ver_resp->flags & VER_GET_RESP_FLAGS_EXT_VER_AVAIL) {
		snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->hwrm_fw_major, ver_resp->hwrm_fw_minor,
			 ver_resp->hwrm_fw_build, ver_resp->hwrm_fw_patch);

		snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->mgmt_fw_major, ver_resp->mgmt_fw_minor,
			 ver_resp->mgmt_fw_build, ver_resp->mgmt_fw_patch);

		snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->roce_fw_major, ver_resp->roce_fw_minor,
			 ver_resp->roce_fw_build, ver_resp->roce_fw_patch);
	} else {
		snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->hwrm_fw_maj_8b, ver_resp->hwrm_fw_min_8b,
			 ver_resp->hwrm_fw_bld_8b, ver_resp->hwrm_fw_rsvd_8b);

		snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->mgmt_fw_maj_8b, ver_resp->mgmt_fw_min_8b,
			 ver_resp->mgmt_fw_bld_8b, ver_resp->mgmt_fw_rsvd_8b);

		snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
			 ver_resp->roce_fw_maj_8b, ver_resp->roce_fw_min_8b,
			 ver_resp->roce_fw_bld_8b, ver_resp->roce_fw_rsvd_8b);
	}
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set firmware mgmt version");
		return rc;
	}

	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT_API,
			      bd->hwrm_ver_supp);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set firmware mgmt api version");
		return rc;
	}

	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set ncsi firmware version");
		return rc;
	}

	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_RUNNING,
			      DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to set roce firmware version");
		return rc;
	}

	rc = bnge_hwrm_nvm_dev_info(bd, &nvm_dev_info);
	if (!(nvm_dev_info.flags & NVM_GET_DEV_INFO_RESP_FLAGS_FW_VER_VALID))
		return 0;

	buf[0] = 0;
	strncat(buf, nvm_dev_info.pkg_name, HWRM_FW_VER_STR_LEN);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_STORED,
			      DEVLINK_INFO_VERSION_GENERIC_FW, buf);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set roce firmware version");
		return rc;
	}

	snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
		 nvm_dev_info.hwrm_fw_major, nvm_dev_info.hwrm_fw_minor,
		 nvm_dev_info.hwrm_fw_build, nvm_dev_info.hwrm_fw_patch);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_STORED,
			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set stored firmware version");
		return rc;
	}

	snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
		 nvm_dev_info.mgmt_fw_major, nvm_dev_info.mgmt_fw_minor,
		 nvm_dev_info.mgmt_fw_build, nvm_dev_info.mgmt_fw_patch);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_STORED,
			      DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
	if (rc) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set stored ncsi firmware version");
		return rc;
	}

	snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
		 nvm_dev_info.roce_fw_major, nvm_dev_info.roce_fw_minor,
		 nvm_dev_info.roce_fw_build, nvm_dev_info.roce_fw_patch);
	rc = bnge_dl_info_put(bd, req, BNGE_VERSION_STORED,
			      DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
	if (rc)
		NL_SET_ERR_MSG_MOD(extack,
				   "Failed to set stored roce firmware version");

	return rc;
}

static const struct devlink_ops bnge_devlink_ops = {
	.info_get = bnge_devlink_info_get,
};

void bnge_devlink_free(struct bnge_dev *bd)
{
	struct devlink *devlink = priv_to_devlink(bd);

	devlink_free(devlink);
}

struct bnge_dev *bnge_devlink_alloc(struct pci_dev *pdev)
{
	struct devlink *devlink;
	struct bnge_dev *bd;

	devlink = devlink_alloc(&bnge_devlink_ops, sizeof(*bd), &pdev->dev);
	if (!devlink)
		return NULL;

	bd = devlink_priv(devlink);
	pci_set_drvdata(pdev, bd);
	bd->dev = &pdev->dev;
	bd->pdev = pdev;

	bd->dsn = pci_get_dsn(pdev);
	if (!bd->dsn)
		pci_warn(pdev, "Failed to get DSN\n");

	bnge_vpd_read_info(bd);

	return bd;
}

void bnge_devlink_register(struct bnge_dev *bd)
{
	struct devlink *devlink = priv_to_devlink(bd);
	devlink_register(devlink);
}

void bnge_devlink_unregister(struct bnge_dev *bd)
{
	struct devlink *devlink = priv_to_devlink(bd);
	devlink_unregister(devlink);
}