Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 52581961 authored by Jiri Pirko's avatar Jiri Pirko Committed by David S. Miller
Browse files

mlxsw: core: Implement fan control using hwmon 



ASIC provides access to fans. Implement their exposure to userspace
using hwmon.

Signed-off-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 5246f2e2

drivers/net/ethernet/mellanox/mlxsw/core_hwmon.c

+120 −1
Original line number Diff line number Diff line
@@ -42,7 +42,8 @@ 
#include "core.h"



#define MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT 127

#define MLXSW_HWMON_ATTR_COUNT (MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT * 4)

#define MLXSW_HWMON_ATTR_COUNT (MLXSW_HWMON_TEMP_SENSOR_MAX_COUNT * 4 + \

				MLXSW_MFCR_TACHOS_MAX + MLXSW_MFCR_PWMS_MAX)



struct mlxsw_hwmon_attr {

	struct device_attribute dev_attr;
@@ -106,9 +107,76 @@ static ssize_t mlxsw_hwmon_temp_max_show(struct device *dev, 
	return sprintf(buf, "%u\n", temp_max);

}



static ssize_t mlxsw_hwmon_fan_rpm_show(struct device *dev,

					struct device_attribute *attr,

					char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char mfsm_pl[MLXSW_REG_MFSM_LEN];

	int err;



	mlxsw_reg_mfsm_pack(mfsm_pl, mlwsw_hwmon_attr->type_index);

	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfsm), mfsm_pl);

	if (err) {

		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to query fan\n");

		return err;

	}

	return sprintf(buf, "%u\n", mlxsw_reg_mfsm_rpm_get(mfsm_pl));

}



static ssize_t mlxsw_hwmon_pwm_show(struct device *dev,

				    struct device_attribute *attr,

				    char *buf)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char mfsc_pl[MLXSW_REG_MFSC_LEN];

	int err;



	mlxsw_reg_mfsc_pack(mfsc_pl, mlwsw_hwmon_attr->type_index, 0);

	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfsc), mfsc_pl);

	if (err) {

		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to query PWM\n");

		return err;

	}

	return sprintf(buf, "%u\n",

		       mlxsw_reg_mfsc_pwm_duty_cycle_get(mfsc_pl));

}



static ssize_t mlxsw_hwmon_pwm_store(struct device *dev,

				     struct device_attribute *attr,

				     const char *buf, size_t len)

{

	struct mlxsw_hwmon_attr *mlwsw_hwmon_attr =

			container_of(attr, struct mlxsw_hwmon_attr, dev_attr);

	struct mlxsw_hwmon *mlxsw_hwmon = mlwsw_hwmon_attr->hwmon;

	char mfsc_pl[MLXSW_REG_MFSC_LEN];

	unsigned long val;

	int err;



	err = kstrtoul(buf, 10, &val);

	if (err)

		return err;

	if (val > 255)

		return -EINVAL;



	mlxsw_reg_mfsc_pack(mfsc_pl, mlwsw_hwmon_attr->type_index, val);

	err = mlxsw_reg_write(mlxsw_hwmon->core, MLXSW_REG(mfsc), mfsc_pl);

	if (err) {

		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to write PWM\n");

		return err;

	}

	return err ? err : len;

}



enum mlxsw_hwmon_attr_type {

	MLXSW_HWMON_ATTR_TYPE_TEMP,

	MLXSW_HWMON_ATTR_TYPE_TEMP_MAX,

	MLXSW_HWMON_ATTR_TYPE_FAN_RPM,

	MLXSW_HWMON_ATTR_TYPE_PWM,

};



static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon,
@@ -133,6 +201,19 @@ static void mlxsw_hwmon_attr_add(struct mlxsw_hwmon *mlxsw_hwmon, 
		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "temp%u_highest", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_FAN_RPM:

		mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_fan_rpm_show;

		mlxsw_hwmon_attr->dev_attr.attr.mode = S_IRUGO;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "fan%u_input", num + 1);

		break;

	case MLXSW_HWMON_ATTR_TYPE_PWM:

		mlxsw_hwmon_attr->dev_attr.show = mlxsw_hwmon_pwm_show;

		mlxsw_hwmon_attr->dev_attr.store = mlxsw_hwmon_pwm_store;

		mlxsw_hwmon_attr->dev_attr.attr.mode = S_IWUSR | S_IRUGO;

		snprintf(mlxsw_hwmon_attr->name, sizeof(mlxsw_hwmon_attr->name),

			 "pwm%u", num + 1);

		break;

	default:

		BUG();

	}
@@ -177,6 +258,39 @@ static int mlxsw_hwmon_temp_init(struct mlxsw_hwmon *mlxsw_hwmon) 
	return 0;

}



static int mlxsw_hwmon_fans_init(struct mlxsw_hwmon *mlxsw_hwmon)

{

	char mfcr_pl[MLXSW_REG_MFCR_LEN];

	enum mlxsw_reg_mfcr_pwm_frequency freq;

	unsigned int type_index;

	unsigned int num;

	u16 tacho_active;

	u8 pwm_active;

	int err;



	err = mlxsw_reg_query(mlxsw_hwmon->core, MLXSW_REG(mfcr), mfcr_pl);

	if (err) {

		dev_err(mlxsw_hwmon->bus_info->dev, "Failed to get to probe PWMs and Tachometers\n");

		return err;

	}

	mlxsw_reg_mfcr_unpack(mfcr_pl, &freq, &tacho_active, &pwm_active);

	num = 0;

	for (type_index = 0; type_index < MLXSW_MFCR_TACHOS_MAX; type_index++) {

		if (tacho_active & BIT(type_index))

			mlxsw_hwmon_attr_add(mlxsw_hwmon,

					     MLXSW_HWMON_ATTR_TYPE_FAN_RPM,

					     type_index, num++);

	}

	num = 0;

	for (type_index = 0; type_index < MLXSW_MFCR_PWMS_MAX; type_index++) {

		if (pwm_active & BIT(type_index))

			mlxsw_hwmon_attr_add(mlxsw_hwmon,

					     MLXSW_HWMON_ATTR_TYPE_PWM,

					     type_index, num++);

	}

	return 0;

}



int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core,

		     const struct mlxsw_bus_info *mlxsw_bus_info,

		     struct mlxsw_hwmon **p_hwmon)
@@ -195,6 +309,10 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core, 
	if (err)

		goto err_temp_init;



	err = mlxsw_hwmon_fans_init(mlxsw_hwmon);

	if (err)

		goto err_fans_init;



	mlxsw_hwmon->groups[0] = &mlxsw_hwmon->group;

	mlxsw_hwmon->group.attrs = mlxsw_hwmon->attrs;
@@ -212,6 +330,7 @@ int mlxsw_hwmon_init(struct mlxsw_core *mlxsw_core, 
	return 0;



err_hwmon_register:

err_fans_init:

err_temp_init:

	kfree(mlxsw_hwmon);

	return err;