// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved

#include <linux/hwmon.h>
#include <linux/bitmap.h>
#include <linux/mlx5/device.h>
#include <linux/mlx5/mlx5_ifc.h>
#include <linux/mlx5/port.h>
#include "mlx5_core.h"
#include "hwmon.h"

#define CHANNELS_TYPE_NUM 2 /* chip channel and temp channel */
#define CHIP_CONFIG_NUM 1

/* module 0 is mapped to sensor_index 64 in MTMP register */
#define to_mtmp_module_sensor_idx(idx) (64 + (idx))

/* All temperatures retrieved in units of 0.125C. hwmon framework expect
 * it in units of millidegrees C. Hence multiply values by 125.
 */
#define mtmp_temp_to_mdeg(temp) ((temp) * 125)

struct temp_channel_desc {
	u32 sensor_index;
	char sensor_name[32];
};

/* chip_channel_config and channel_info arrays must be 0-terminated, hence + 1 */
struct mlx5_hwmon {
	struct mlx5_core_dev *mdev;
	struct device *hwmon_dev;
	struct hwmon_channel_info chip_info;
	u32 chip_channel_config[CHIP_CONFIG_NUM + 1];
	struct hwmon_channel_info temp_info;
	u32 *temp_channel_config;
	const struct hwmon_channel_info *channel_info[CHANNELS_TYPE_NUM + 1];
	struct hwmon_chip_info chip;
	struct temp_channel_desc *temp_channel_desc;
	u32 asic_platform_scount;
	u32 module_scount;
};

static int mlx5_hwmon_query_mtmp(struct mlx5_core_dev *mdev, u32 sensor_index, u32 *mtmp_out)
{
	u32 mtmp_in[MLX5_ST_SZ_DW(mtmp_reg)] = {};

	MLX5_SET(mtmp_reg, mtmp_in, sensor_index, sensor_index);

	return mlx5_core_access_reg(mdev, mtmp_in,  sizeof(mtmp_in),
				    mtmp_out, MLX5_ST_SZ_BYTES(mtmp_reg),
				    MLX5_REG_MTMP, 0, 0);
}

static int mlx5_hwmon_reset_max_temp(struct mlx5_core_dev *mdev, int sensor_index)
{
	u32 mtmp_out[MLX5_ST_SZ_DW(mtmp_reg)] = {};
	u32 mtmp_in[MLX5_ST_SZ_DW(mtmp_reg)] = {};

	MLX5_SET(mtmp_reg, mtmp_in, sensor_index, sensor_index);
	MLX5_SET(mtmp_reg, mtmp_in, mtr, 1);

	return mlx5_core_access_reg(mdev, mtmp_in,  sizeof(mtmp_in),
				    mtmp_out, sizeof(mtmp_out),
				    MLX5_REG_MTMP, 0, 0);
}

static int mlx5_hwmon_enable_max_temp(struct mlx5_core_dev *mdev, int sensor_index)
{
	u32 mtmp_out[MLX5_ST_SZ_DW(mtmp_reg)] = {};
	u32 mtmp_in[MLX5_ST_SZ_DW(mtmp_reg)] = {};
	int err;

	err = mlx5_hwmon_query_mtmp(mdev, sensor_index, mtmp_in);
	if (err)
		return err;

	MLX5_SET(mtmp_reg, mtmp_in, mte, 1);
	return mlx5_core_access_reg(mdev, mtmp_in,  sizeof(mtmp_in),
				    mtmp_out, sizeof(mtmp_out),
				    MLX5_REG_MTMP, 0, 1);
}

static int mlx5_hwmon_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
			   int channel, long *val)
{
	struct mlx5_hwmon *hwmon = dev_get_drvdata(dev);
	u32 mtmp_out[MLX5_ST_SZ_DW(mtmp_reg)] = {};
	int err;

	if (type != hwmon_temp)
		return -EOPNOTSUPP;

	err = mlx5_hwmon_query_mtmp(hwmon->mdev, hwmon->temp_channel_desc[channel].sensor_index,
				    mtmp_out);
	if (err)
		return err;

	switch (attr) {
	case hwmon_temp_input:
		*val = mtmp_temp_to_mdeg(MLX5_GET(mtmp_reg, mtmp_out, temperature));
		return 0;
	case hwmon_temp_highest:
		*val = mtmp_temp_to_mdeg(MLX5_GET(mtmp_reg, mtmp_out, max_temperature));
		return 0;
	case hwmon_temp_crit:
		*val = mtmp_temp_to_mdeg(MLX5_GET(mtmp_reg, mtmp_out, temp_threshold_hi));
		return 0;
	default:
		return -EOPNOTSUPP;
	}
}

static int mlx5_hwmon_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
			    int channel, long val)
{
	struct mlx5_hwmon *hwmon = dev_get_drvdata(dev);

	if (type != hwmon_temp || attr != hwmon_temp_reset_history)
		return -EOPNOTSUPP;

	return mlx5_hwmon_reset_max_temp(hwmon->mdev,
				hwmon->temp_channel_desc[channel].sensor_index);
}

static umode_t mlx5_hwmon_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
				     int channel)
{
	if (type != hwmon_temp)
		return 0;

	switch (attr) {
	case hwmon_temp_input:
	case hwmon_temp_highest:
	case hwmon_temp_crit:
	case hwmon_temp_label:
		return 0444;
	case hwmon_temp_reset_history:
		return 0200;
	default:
		return 0;
	}
}

static int mlx5_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
				  int channel, const char **str)
{
	struct mlx5_hwmon *hwmon = dev_get_drvdata(dev);

	if (type != hwmon_temp || attr != hwmon_temp_label)
		return -EOPNOTSUPP;

	*str = (const char *)hwmon->temp_channel_desc[channel].sensor_name;
	return 0;
}

static const struct hwmon_ops mlx5_hwmon_ops = {
	.read = mlx5_hwmon_read,
	.read_string = mlx5_hwmon_read_string,
	.is_visible = mlx5_hwmon_is_visible,
	.write = mlx5_hwmon_write,
};

static int mlx5_hwmon_init_channels_names(struct mlx5_hwmon *hwmon)
{
	u32 i;

	for (i = 0; i < hwmon->asic_platform_scount + hwmon->module_scount; i++) {
		u32 mtmp_out[MLX5_ST_SZ_DW(mtmp_reg)] = {};
		char *sensor_name;
		int err;

		err = mlx5_hwmon_query_mtmp(hwmon->mdev, hwmon->temp_channel_desc[i].sensor_index,
					    mtmp_out);
		if (err)
			return err;

		sensor_name = MLX5_ADDR_OF(mtmp_reg, mtmp_out, sensor_name_hi);
		if (!*sensor_name) {
			snprintf(hwmon->temp_channel_desc[i].sensor_name,
				 sizeof(hwmon->temp_channel_desc[i].sensor_name), "sensor%u",
				 hwmon->temp_channel_desc[i].sensor_index);
			continue;
		}

		memcpy(&hwmon->temp_channel_desc[i].sensor_name, sensor_name,
		       MLX5_FLD_SZ_BYTES(mtmp_reg, sensor_name_hi) +
		       MLX5_FLD_SZ_BYTES(mtmp_reg, sensor_name_lo));
	}

	return 0;
}

static int mlx5_hwmon_get_module_sensor_index(struct mlx5_core_dev *mdev, u32 *module_index)
{
	int module_num;
	int err;

	err = mlx5_query_module_num(mdev, &module_num);
	if (err)
		return err;

	*module_index = to_mtmp_module_sensor_idx(module_num);

	return 0;
}

static int mlx5_hwmon_init_sensors_indexes(struct mlx5_hwmon *hwmon, u64 sensor_map)
{
	DECLARE_BITMAP(smap, BITS_PER_TYPE(sensor_map));
	unsigned long bit_pos;
	int err = 0;
	int i = 0;

	bitmap_from_u64(smap, sensor_map);

	for_each_set_bit(bit_pos, smap, BITS_PER_TYPE(sensor_map)) {
		hwmon->temp_channel_desc[i].sensor_index = bit_pos;
		i++;
	}

	if (hwmon->module_scount)
		err = mlx5_hwmon_get_module_sensor_index(hwmon->mdev,
							 &hwmon->temp_channel_desc[i].sensor_index);

	return err;
}

static void mlx5_hwmon_channel_info_init(struct mlx5_hwmon *hwmon)
{
	int i;

	hwmon->channel_info[0] = &hwmon->chip_info;
	hwmon->channel_info[1] = &hwmon->temp_info;

	hwmon->chip_channel_config[0] = HWMON_C_REGISTER_TZ;
	hwmon->chip_info.config = (const u32 *)hwmon->chip_channel_config;
	hwmon->chip_info.type = hwmon_chip;

	for (i = 0; i < hwmon->asic_platform_scount + hwmon->module_scount; i++)
		hwmon->temp_channel_config[i] = HWMON_T_INPUT | HWMON_T_HIGHEST | HWMON_T_CRIT |
					     HWMON_T_RESET_HISTORY | HWMON_T_LABEL;

	hwmon->temp_info.config = (const u32 *)hwmon->temp_channel_config;
	hwmon->temp_info.type = hwmon_temp;
}

static int mlx5_hwmon_is_module_mon_cap(struct mlx5_core_dev *mdev, bool *mon_cap)
{
	u32 mtmp_out[MLX5_ST_SZ_DW(mtmp_reg)];
	u32 module_index;
	int err;

	err = mlx5_hwmon_get_module_sensor_index(mdev, &module_index);
	if (err)
		return err;

	err = mlx5_hwmon_query_mtmp(mdev, module_index, mtmp_out);
	if (err)
		return err;

	if (MLX5_GET(mtmp_reg, mtmp_out, temperature))
		*mon_cap = true;

	return 0;
}

static int mlx5_hwmon_get_sensors_count(struct mlx5_core_dev *mdev, u32 *asic_platform_scount)
{
	u32 mtcap_out[MLX5_ST_SZ_DW(mtcap_reg)] = {};
	u32 mtcap_in[MLX5_ST_SZ_DW(mtcap_reg)] = {};
	int err;

	err = mlx5_core_access_reg(mdev, mtcap_in,  sizeof(mtcap_in),
				   mtcap_out, sizeof(mtcap_out),
				   MLX5_REG_MTCAP, 0, 0);
	if (err)
		return err;

	*asic_platform_scount = MLX5_GET(mtcap_reg, mtcap_out, sensor_count);

	return 0;
}

static void mlx5_hwmon_free(struct mlx5_hwmon *hwmon)
{
	if (!hwmon)
		return;

	kfree(hwmon->temp_channel_config);
	kfree(hwmon->temp_channel_desc);
	kfree(hwmon);
}

static struct mlx5_hwmon *mlx5_hwmon_alloc(struct mlx5_core_dev *mdev)
{
	struct mlx5_hwmon *hwmon;
	bool mon_cap = false;
	u32 sensors_count;
	int err;

	hwmon = kzalloc(sizeof(*mdev->hwmon), GFP_KERNEL);
	if (!hwmon)
		return ERR_PTR(-ENOMEM);

	err = mlx5_hwmon_get_sensors_count(mdev, &hwmon->asic_platform_scount);
	if (err)
		goto err_free_hwmon;

	/* check if module sensor has thermal mon cap. if yes, allocate channel desc for it */
	err = mlx5_hwmon_is_module_mon_cap(mdev, &mon_cap);
	if (err)
		goto err_free_hwmon;

	hwmon->module_scount = mon_cap ? 1 : 0;
	sensors_count = hwmon->asic_platform_scount + hwmon->module_scount;
	hwmon->temp_channel_desc = kcalloc(sensors_count, sizeof(*hwmon->temp_channel_desc),
					   GFP_KERNEL);
	if (!hwmon->temp_channel_desc) {
		err = -ENOMEM;
		goto err_free_hwmon;
	}

	/* sensors configuration values array, must be 0-terminated hence, + 1 */
	hwmon->temp_channel_config = kcalloc(sensors_count + 1, sizeof(*hwmon->temp_channel_config),
					     GFP_KERNEL);
	if (!hwmon->temp_channel_config) {
		err = -ENOMEM;
		goto err_free_temp_channel_desc;
	}

	hwmon->mdev = mdev;

	return hwmon;

err_free_temp_channel_desc:
	kfree(hwmon->temp_channel_desc);
err_free_hwmon:
	kfree(hwmon);
	return ERR_PTR(err);
}

static int mlx5_hwmon_dev_init(struct mlx5_hwmon *hwmon)
{
	u32 mtcap_out[MLX5_ST_SZ_DW(mtcap_reg)] = {};
	u32 mtcap_in[MLX5_ST_SZ_DW(mtcap_reg)] = {};
	int err;
	int i;

	err =  mlx5_core_access_reg(hwmon->mdev, mtcap_in,  sizeof(mtcap_in),
				    mtcap_out, sizeof(mtcap_out),
				    MLX5_REG_MTCAP, 0, 0);
	if (err)
		return err;

	mlx5_hwmon_channel_info_init(hwmon);
	mlx5_hwmon_init_sensors_indexes(hwmon, MLX5_GET64(mtcap_reg, mtcap_out, sensor_map));
	err = mlx5_hwmon_init_channels_names(hwmon);
	if (err)
		return err;

	for (i = 0; i < hwmon->asic_platform_scount + hwmon->module_scount; i++) {
		err = mlx5_hwmon_enable_max_temp(hwmon->mdev,
						 hwmon->temp_channel_desc[i].sensor_index);
		if (err)
			return err;
	}

	hwmon->chip.ops = &mlx5_hwmon_ops;
	hwmon->chip.info = (const struct hwmon_channel_info **)hwmon->channel_info;

	return 0;
}

int mlx5_hwmon_dev_register(struct mlx5_core_dev *mdev)
{
	struct device *dev = mdev->device;
	struct mlx5_hwmon *hwmon;
	int err;

	if (!MLX5_CAP_MCAM_REG(mdev, mtmp))
		return 0;

	hwmon = mlx5_hwmon_alloc(mdev);
	if (IS_ERR(hwmon))
		return PTR_ERR(hwmon);

	err = mlx5_hwmon_dev_init(hwmon);
	if (err)
		goto err_free_hwmon;

	hwmon->hwmon_dev = hwmon_device_register_with_info(dev, "mlx5",
							   hwmon,
							   &hwmon->chip,
							   NULL);
	if (IS_ERR(hwmon->hwmon_dev)) {
		err = PTR_ERR(hwmon->hwmon_dev);
		goto err_free_hwmon;
	}

	mdev->hwmon = hwmon;
	return 0;

err_free_hwmon:
	mlx5_hwmon_free(hwmon);
	return err;
}

void mlx5_hwmon_dev_unregister(struct mlx5_core_dev *mdev)
{
	struct mlx5_hwmon *hwmon = mdev->hwmon;

	if (!hwmon)
		return;

	hwmon_device_unregister(hwmon->hwmon_dev);
	mlx5_hwmon_free(hwmon);
	mdev->hwmon = NULL;
}

const char *hwmon_get_sensor_name(struct mlx5_hwmon *hwmon, int channel)
{
	return hwmon->temp_channel_desc[channel].sensor_name;
}