[linux.git] / drivers / hwmon / mlxreg-fan.c

// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
//
// Copyright (c) 2018 Mellanox Technologies. All rights reserved.
// Copyright (c) 2018 Vadim Pasternak <[email protected]>

#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/hwmon.h>
#include <linux/module.h>
#include <linux/platform_data/mlxreg.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/thermal.h>

#define MLXREG_FAN_MAX_TACHO		12
#define MLXREG_FAN_MAX_STATE		10
#define MLXREG_FAN_MIN_DUTY		51	/* 20% */
#define MLXREG_FAN_MAX_DUTY		255	/* 100% */
/*
 * Minimum and maximum FAN allowed speed in percent: from 20% to 100%. Values
 * MLXREG_FAN_MAX_STATE + x, where x is between 2 and 10 are used for
 * setting FAN speed dynamic minimum. For example, if value is set to 14 (40%)
 * cooling levels vector will be set to 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10 to
 * introduce PWM speed in percent: 40, 40, 40, 40, 40, 50, 60. 70, 80, 90, 100.
 */
#define MLXREG_FAN_SPEED_MIN			(MLXREG_FAN_MAX_STATE + 2)
#define MLXREG_FAN_SPEED_MAX			(MLXREG_FAN_MAX_STATE * 2)
#define MLXREG_FAN_SPEED_MIN_LEVEL		2	/* 20 percent */
#define MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF	44
#define MLXREG_FAN_TACHO_DIVIDER_DEF		1132
/*
 * FAN datasheet defines the formula for RPM calculations as RPM = 15/t-high.
 * The logic in a programmable device measures the time t-high by sampling the
 * tachometer every t-sample (with the default value 11.32 uS) and increment
 * a counter (N) as long as the pulse has not change:
 * RPM = 15 / (t-sample * (K + Regval)), where:
 * Regval: is the value read from the programmable device register;
 *  - 0xff - represents tachometer fault;
 *  - 0xfe - represents tachometer minimum value , which is 4444 RPM;
 *  - 0x00 - represents tachometer maximum value , which is 300000 RPM;
 * K: is 44 and it represents the minimum allowed samples per pulse;
 * N: is equal K + Regval;
 * In order to calculate RPM from the register value the following formula is
 * used: RPM = 15 / ((Regval + K) * 11.32) * 10^(-6)), which in  the
 * default case is modified to:
 * RPM = 15000000 * 100 / ((Regval + 44) * 1132);
 * - for Regval 0x00, RPM will be 15000000 * 100 / (44 * 1132) = 30115;
 * - for Regval 0xfe, RPM will be 15000000 * 100 / ((254 + 44) * 1132) = 4446;
 * In common case the formula is modified to:
 * RPM = 15000000 * 100 / ((Regval + samples) * divider).
 */
#define MLXREG_FAN_GET_RPM(rval, d, s)	(DIV_ROUND_CLOSEST(15000000 * 100, \
					 ((rval) + (s)) * (d)))
#define MLXREG_FAN_GET_FAULT(val, mask) (!!((val) ^ (mask)))
#define MLXREG_FAN_PWM_DUTY2STATE(duty)	(DIV_ROUND_CLOSEST((duty) *	\
					 MLXREG_FAN_MAX_STATE,		\
					 MLXREG_FAN_MAX_DUTY))
#define MLXREG_FAN_PWM_STATE2DUTY(stat)	(DIV_ROUND_CLOSEST((stat) *	\
					 MLXREG_FAN_MAX_DUTY,		\
					 MLXREG_FAN_MAX_STATE))

/*
 * struct mlxreg_fan_tacho - tachometer data (internal use):
 *
 * @connected: indicates if tachometer is connected;
 * @reg: register offset;
 * @mask: fault mask;
 */
struct mlxreg_fan_tacho {
	bool connected;
	u32 reg;
	u32 mask;
};

/*
 * struct mlxreg_fan_pwm - PWM data (internal use):
 *
 * @connected: indicates if PWM is connected;
 * @reg: register offset;
 */
struct mlxreg_fan_pwm {
	bool connected;
	u32 reg;
};

/*
 * struct mlxreg_fan - private data (internal use):
 *
 * @dev: basic device;
 * @regmap: register map of parent device;
 * @tacho: tachometer data;
 * @pwm: PWM data;
 * @samples: minimum allowed samples per pulse;
 * @divider: divider value for tachometer RPM calculation;
 * @cooling: cooling device levels;
 * @cdev: cooling device;
 */
struct mlxreg_fan {
	struct device *dev;
	void *regmap;
	struct mlxreg_core_platform_data *pdata;
	struct mlxreg_fan_tacho tacho[MLXREG_FAN_MAX_TACHO];
	struct mlxreg_fan_pwm pwm;
	int samples;
	int divider;
	u8 cooling_levels[MLXREG_FAN_MAX_STATE + 1];
	struct thermal_cooling_device *cdev;
};

static int
mlxreg_fan_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
		int channel, long *val)
{
	struct mlxreg_fan *fan = dev_get_drvdata(dev);
	struct mlxreg_fan_tacho *tacho;
	u32 regval;
	int err;

	switch (type) {
	case hwmon_fan:
		tacho = &fan->tacho[channel];
		switch (attr) {
		case hwmon_fan_input:
			err = regmap_read(fan->regmap, tacho->reg, &regval);
			if (err)
				return err;

			*val = MLXREG_FAN_GET_RPM(regval, fan->divider,
						  fan->samples);
			break;

		case hwmon_fan_fault:
			err = regmap_read(fan->regmap, tacho->reg, &regval);
			if (err)
				return err;

			*val = MLXREG_FAN_GET_FAULT(regval, tacho->mask);
			break;

		default:
			return -EOPNOTSUPP;
		}
		break;

	case hwmon_pwm:
		switch (attr) {
		case hwmon_pwm_input:
			err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
			if (err)
				return err;

			*val = regval;
			break;

		default:
			return -EOPNOTSUPP;
		}
		break;

	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

static int
mlxreg_fan_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
		 int channel, long val)
{
	struct mlxreg_fan *fan = dev_get_drvdata(dev);

	switch (type) {
	case hwmon_pwm:
		switch (attr) {
		case hwmon_pwm_input:
			if (val < MLXREG_FAN_MIN_DUTY ||
			    val > MLXREG_FAN_MAX_DUTY)
				return -EINVAL;
			return regmap_write(fan->regmap, fan->pwm.reg, val);
		default:
			return -EOPNOTSUPP;
		}
		break;

	default:
		return -EOPNOTSUPP;
	}

	return -EOPNOTSUPP;
}

static umode_t
mlxreg_fan_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
		      int channel)
{
	switch (type) {
	case hwmon_fan:
		if (!(((struct mlxreg_fan *)data)->tacho[channel].connected))
			return 0;

		switch (attr) {
		case hwmon_fan_input:
		case hwmon_fan_fault:
			return 0444;
		default:
			break;
		}
		break;

	case hwmon_pwm:
		if (!(((struct mlxreg_fan *)data)->pwm.connected))
			return 0;

		switch (attr) {
		case hwmon_pwm_input:
			return 0644;
		default:
			break;
		}
		break;

	default:
		break;
	}

	return 0;
}

static const u32 mlxreg_fan_hwmon_fan_config[] = {
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	HWMON_F_INPUT | HWMON_F_FAULT,
	0
};

static const struct hwmon_channel_info mlxreg_fan_hwmon_fan = {
	.type = hwmon_fan,
	.config = mlxreg_fan_hwmon_fan_config,
};

static const u32 mlxreg_fan_hwmon_pwm_config[] = {
	HWMON_PWM_INPUT,
	0
};

static const struct hwmon_channel_info mlxreg_fan_hwmon_pwm = {
	.type = hwmon_pwm,
	.config = mlxreg_fan_hwmon_pwm_config,
};

static const struct hwmon_channel_info *mlxreg_fan_hwmon_info[] = {
	&mlxreg_fan_hwmon_fan,
	&mlxreg_fan_hwmon_pwm,
	NULL
};

static const struct hwmon_ops mlxreg_fan_hwmon_hwmon_ops = {
	.is_visible = mlxreg_fan_is_visible,
	.read = mlxreg_fan_read,
	.write = mlxreg_fan_write,
};

static const struct hwmon_chip_info mlxreg_fan_hwmon_chip_info = {
	.ops = &mlxreg_fan_hwmon_hwmon_ops,
	.info = mlxreg_fan_hwmon_info,
};

static int mlxreg_fan_get_max_state(struct thermal_cooling_device *cdev,
				    unsigned long *state)
{
	*state = MLXREG_FAN_MAX_STATE;
	return 0;
}

static int mlxreg_fan_get_cur_state(struct thermal_cooling_device *cdev,
				    unsigned long *state)

{
	struct mlxreg_fan *fan = cdev->devdata;
	u32 regval;
	int err;

	err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
	if (err) {
		dev_err(fan->dev, "Failed to query PWM duty\n");
		return err;
	}

	*state = MLXREG_FAN_PWM_DUTY2STATE(regval);

	return 0;
}

static int mlxreg_fan_set_cur_state(struct thermal_cooling_device *cdev,
				    unsigned long state)

{
	struct mlxreg_fan *fan = cdev->devdata;
	unsigned long cur_state;
	u32 regval;
	int i;
	int err;

	/*
	 * Verify if this request is for changing allowed FAN dynamical
	 * minimum. If it is - update cooling levels accordingly and update
	 * state, if current state is below the newly requested minimum state.
	 * For example, if current state is 5, and minimal state is to be
	 * changed from 4 to 6, fan->cooling_levels[0 to 5] will be changed all
	 * from 4 to 6. And state 5 (fan->cooling_levels[4]) should be
	 * overwritten.
	 */
	if (state >= MLXREG_FAN_SPEED_MIN && state <= MLXREG_FAN_SPEED_MAX) {
		state -= MLXREG_FAN_MAX_STATE;
		for (i = 0; i < state; i++)
			fan->cooling_levels[i] = state;
		for (i = state; i <= MLXREG_FAN_MAX_STATE; i++)
			fan->cooling_levels[i] = i;

		err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
		if (err) {
			dev_err(fan->dev, "Failed to query PWM duty\n");
			return err;
		}

		cur_state = MLXREG_FAN_PWM_DUTY2STATE(regval);
		if (state < cur_state)
			return 0;

		state = cur_state;
	}

	if (state > MLXREG_FAN_MAX_STATE)
		return -EINVAL;

	/* Normalize the state to the valid speed range. */
	state = fan->cooling_levels[state];
	err = regmap_write(fan->regmap, fan->pwm.reg,
			   MLXREG_FAN_PWM_STATE2DUTY(state));
	if (err) {
		dev_err(fan->dev, "Failed to write PWM duty\n");
		return err;
	}
	return 0;
}

static const struct thermal_cooling_device_ops mlxreg_fan_cooling_ops = {
	.get_max_state	= mlxreg_fan_get_max_state,
	.get_cur_state	= mlxreg_fan_get_cur_state,
	.set_cur_state	= mlxreg_fan_set_cur_state,
};

static int mlxreg_fan_config(struct mlxreg_fan *fan,
			     struct mlxreg_core_platform_data *pdata)
{
	struct mlxreg_core_data *data = pdata->data;
	bool configured = false;
	int tacho_num = 0, i;

	fan->samples = MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF;
	fan->divider = MLXREG_FAN_TACHO_DIVIDER_DEF;
	for (i = 0; i < pdata->counter; i++, data++) {
		if (strnstr(data->label, "tacho", sizeof(data->label))) {
			if (tacho_num == MLXREG_FAN_MAX_TACHO) {
				dev_err(fan->dev, "too many tacho entries: %s\n",
					data->label);
				return -EINVAL;
			}
			fan->tacho[tacho_num].reg = data->reg;
			fan->tacho[tacho_num].mask = data->mask;
			fan->tacho[tacho_num++].connected = true;
		} else if (strnstr(data->label, "pwm", sizeof(data->label))) {
			if (fan->pwm.connected) {
				dev_err(fan->dev, "duplicate pwm entry: %s\n",
					data->label);
				return -EINVAL;
			}
			fan->pwm.reg = data->reg;
			fan->pwm.connected = true;
		} else if (strnstr(data->label, "conf", sizeof(data->label))) {
			if (configured) {
				dev_err(fan->dev, "duplicate conf entry: %s\n",
					data->label);
				return -EINVAL;
			}
			/* Validate that conf parameters are not zeros. */
			if (!data->mask || !data->bit) {
				dev_err(fan->dev, "invalid conf entry params: %s\n",
					data->label);
				return -EINVAL;
			}
			fan->samples = data->mask;
			fan->divider = data->bit;
			configured = true;
		} else {
			dev_err(fan->dev, "invalid label: %s\n", data->label);
			return -EINVAL;
		}
	}

	/* Init cooling levels per PWM state. */
	for (i = 0; i < MLXREG_FAN_SPEED_MIN_LEVEL; i++)
		fan->cooling_levels[i] = MLXREG_FAN_SPEED_MIN_LEVEL;
	for (i = MLXREG_FAN_SPEED_MIN_LEVEL; i <= MLXREG_FAN_MAX_STATE; i++)
		fan->cooling_levels[i] = i;

	return 0;
}

static int mlxreg_fan_probe(struct platform_device *pdev)
{
	struct mlxreg_core_platform_data *pdata;
	struct mlxreg_fan *fan;
	struct device *hwm;
	int err;

	pdata = dev_get_platdata(&pdev->dev);
	if (!pdata) {
		dev_err(&pdev->dev, "Failed to get platform data.\n");
		return -EINVAL;
	}

	fan = devm_kzalloc(&pdev->dev, sizeof(*fan), GFP_KERNEL);
	if (!fan)
		return -ENOMEM;

	fan->dev = &pdev->dev;
	fan->regmap = pdata->regmap;
	platform_set_drvdata(pdev, fan);

	err = mlxreg_fan_config(fan, pdata);
	if (err)
		return err;

	hwm = devm_hwmon_device_register_with_info(&pdev->dev, "mlxreg_fan",
						   fan,
						   &mlxreg_fan_hwmon_chip_info,
						   NULL);
	if (IS_ERR(hwm)) {
		dev_err(&pdev->dev, "Failed to register hwmon device\n");
		return PTR_ERR(hwm);
	}

	if (IS_REACHABLE(CONFIG_THERMAL)) {
		fan->cdev = thermal_cooling_device_register("mlxreg_fan", fan,
						&mlxreg_fan_cooling_ops);
		if (IS_ERR(fan->cdev)) {
			dev_err(&pdev->dev, "Failed to register cooling device\n");
			return PTR_ERR(fan->cdev);
		}
	}

	return 0;
}

static int mlxreg_fan_remove(struct platform_device *pdev)
{
	struct mlxreg_fan *fan = platform_get_drvdata(pdev);

	if (IS_REACHABLE(CONFIG_THERMAL))
		thermal_cooling_device_unregister(fan->cdev);

	return 0;
}

static struct platform_driver mlxreg_fan_driver = {
	.driver = {
	    .name = "mlxreg-fan",
	},
	.probe = mlxreg_fan_probe,
	.remove = mlxreg_fan_remove,
};

module_platform_driver(mlxreg_fan_driver);

MODULE_AUTHOR("Vadim Pasternak <[email protected]>");
MODULE_DESCRIPTION("Mellanox FAN driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:mlxreg-fan");
Commit	Line	Data
65afb4c8 VP	1	// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
	2	//
	3	// Copyright (c) 2018 Mellanox Technologies. All rights reserved.
	4	// Copyright (c) 2018 Vadim Pasternak <[email protected]>
	5
	6	#include <linux/bitops.h>
	7	#include <linux/device.h>
	8	#include <linux/hwmon.h>
	9	#include <linux/module.h>
	10	#include <linux/platform_data/mlxreg.h>
	11	#include <linux/platform_device.h>
	12	#include <linux/regmap.h>
	13	#include <linux/thermal.h>
	14
	15	#define MLXREG_FAN_MAX_TACHO 12
	16	#define MLXREG_FAN_MAX_STATE 10
	17	#define MLXREG_FAN_MIN_DUTY 51 /* 20% */
	18	#define MLXREG_FAN_MAX_DUTY 255 /* 100% */
	19	/*
	20	* Minimum and maximum FAN allowed speed in percent: from 20% to 100%. Values
	21	* MLXREG_FAN_MAX_STATE + x, where x is between 2 and 10 are used for
	22	* setting FAN speed dynamic minimum. For example, if value is set to 14 (40%)
	23	* cooling levels vector will be set to 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10 to
	24	* introduce PWM speed in percent: 40, 40, 40, 40, 40, 50, 60. 70, 80, 90, 100.
	25	*/
	26	#define MLXREG_FAN_SPEED_MIN (MLXREG_FAN_MAX_STATE + 2)
	27	#define MLXREG_FAN_SPEED_MAX (MLXREG_FAN_MAX_STATE * 2)
	28	#define MLXREG_FAN_SPEED_MIN_LEVEL 2 /* 20 percent */
	29	#define MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF 44
	30	#define MLXREG_FAN_TACHO_DIVIDER_DEF 1132
	31	/*
	32	* FAN datasheet defines the formula for RPM calculations as RPM = 15/t-high.
	33	* The logic in a programmable device measures the time t-high by sampling the
	34	* tachometer every t-sample (with the default value 11.32 uS) and increment
	35	* a counter (N) as long as the pulse has not change:
	36	* RPM = 15 / (t-sample * (K + Regval)), where:
	37	* Regval: is the value read from the programmable device register;
	38	* - 0xff - represents tachometer fault;
	39	* - 0xfe - represents tachometer minimum value , which is 4444 RPM;
	40	* - 0x00 - represents tachometer maximum value , which is 300000 RPM;
	41	* K: is 44 and it represents the minimum allowed samples per pulse;
	42	* N: is equal K + Regval;
	43	* In order to calculate RPM from the register value the following formula is
	44	* used: RPM = 15 / ((Regval + K) * 11.32) * 10^(-6)), which in the
	45	* default case is modified to:
	46	* RPM = 15000000 * 100 / ((Regval + 44) * 1132);
	47	* - for Regval 0x00, RPM will be 15000000 * 100 / (44 * 1132) = 30115;
	48	* - for Regval 0xfe, RPM will be 15000000 * 100 / ((254 + 44) * 1132) = 4446;
	49	* In common case the formula is modified to:
	50	* RPM = 15000000 * 100 / ((Regval + samples) * divider).
	51	*/
	52	#define MLXREG_FAN_GET_RPM(rval, d, s) (DIV_ROUND_CLOSEST(15000000 * 100, \
	53	((rval) + (s)) * (d)))
	54	#define MLXREG_FAN_GET_FAULT(val, mask) (!!((val) ^ (mask)))
	55	#define MLXREG_FAN_PWM_DUTY2STATE(duty) (DIV_ROUND_CLOSEST((duty) * \
	56	MLXREG_FAN_MAX_STATE, \
	57	MLXREG_FAN_MAX_DUTY))
	58	#define MLXREG_FAN_PWM_STATE2DUTY(stat) (DIV_ROUND_CLOSEST((stat) * \
	59	MLXREG_FAN_MAX_DUTY, \
	60	MLXREG_FAN_MAX_STATE))
	61
	62	/*
	63	* struct mlxreg_fan_tacho - tachometer data (internal use):
	64	*
65	* @connected: indicates if tachometer is connected;
66	* @reg: register offset;
67	* @mask: fault mask;
68	*/
69	struct mlxreg_fan_tacho {
70	bool connected;
71	u32 reg;
72	u32 mask;
73	};
74
75	/*
76	* struct mlxreg_fan_pwm - PWM data (internal use):
77	*
78	* @connected: indicates if PWM is connected;
79	* @reg: register offset;
80	*/
81	struct mlxreg_fan_pwm {
82	bool connected;
83	u32 reg;
84	};
85
86	/*
87	* struct mlxreg_fan - private data (internal use):
88	*
89	* @dev: basic device;
90	* @regmap: register map of parent device;
91	* @tacho: tachometer data;
92	* @pwm: PWM data;
93	* @samples: minimum allowed samples per pulse;
94	* @divider: divider value for tachometer RPM calculation;
95	* @cooling: cooling device levels;
96	* @cdev: cooling device;
97	*/
98	struct mlxreg_fan {
99	struct device *dev;
100	void *regmap;
101	struct mlxreg_core_platform_data *pdata;
102	struct mlxreg_fan_tacho tacho[MLXREG_FAN_MAX_TACHO];
103	struct mlxreg_fan_pwm pwm;
104	int samples;
105	int divider;
106	u8 cooling_levels[MLXREG_FAN_MAX_STATE + 1];
107	struct thermal_cooling_device *cdev;
108	};
109
110	static int
111	mlxreg_fan_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
112	int channel, long *val)
113	{
114	struct mlxreg_fan *fan = dev_get_drvdata(dev);
115	struct mlxreg_fan_tacho *tacho;
116	u32 regval;
117	int err;
118
119	switch (type) {
120	case hwmon_fan:
121	tacho = &fan->tacho[channel];
122	switch (attr) {
123	case hwmon_fan_input:
124	err = regmap_read(fan->regmap, tacho->reg, &regval);
125	if (err)
126	return err;
127
128	*val = MLXREG_FAN_GET_RPM(regval, fan->divider,
129	fan->samples);
130	break;
131
132	case hwmon_fan_fault:
133	err = regmap_read(fan->regmap, tacho->reg, &regval);
134	if (err)
135	return err;
136
137	*val = MLXREG_FAN_GET_FAULT(regval, tacho->mask);
138	break;
139
140	default:
141	return -EOPNOTSUPP;
142	}
143	break;
144
145	case hwmon_pwm:
146	switch (attr) {
147	case hwmon_pwm_input:
148	err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
149	if (err)
150	return err;
151
152	*val = regval;
153	break;
154
155	default:
156	return -EOPNOTSUPP;
157	}
158	break;
159
160	default:
161	return -EOPNOTSUPP;
162	}
163
164	return 0;
165	}
166
167	static int
168	mlxreg_fan_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
169	int channel, long val)
170	{
171	struct mlxreg_fan *fan = dev_get_drvdata(dev);
172
173	switch (type) {
174	case hwmon_pwm:
175	switch (attr) {
176	case hwmon_pwm_input:
177	if (val < MLXREG_FAN_MIN_DUTY \|\|
178	val > MLXREG_FAN_MAX_DUTY)
179	return -EINVAL;
180	return regmap_write(fan->regmap, fan->pwm.reg, val);
181	default:
182	return -EOPNOTSUPP;
183	}
184	break;
185
186	default:
187	return -EOPNOTSUPP;
188	}
189
190	return -EOPNOTSUPP;
191	}
192
193	static umode_t
194	mlxreg_fan_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
195	int channel)
196	{
197	switch (type) {
198	case hwmon_fan:
199	if (!(((struct mlxreg_fan *)data)->tacho[channel].connected))
200	return 0;
201
202	switch (attr) {
203	case hwmon_fan_input:
204	case hwmon_fan_fault:
205	return 0444;
206	default:
207	break;
208	}
209	break;
210
211	case hwmon_pwm:
212	if (!(((struct mlxreg_fan *)data)->pwm.connected))
213	return 0;
214
215	switch (attr) {
216	case hwmon_pwm_input:
217	return 0644;
218	default:
219	break;
220	}
221	break;
222
223	default:
224	break;
225	}
226
227	return 0;
228	}
229
230	static const u32 mlxreg_fan_hwmon_fan_config[] = {
231	HWMON_F_INPUT \| HWMON_F_FAULT,
232	HWMON_F_INPUT \| HWMON_F_FAULT,
233	HWMON_F_INPUT \| HWMON_F_FAULT,
234	HWMON_F_INPUT \| HWMON_F_FAULT,
235	HWMON_F_INPUT \| HWMON_F_FAULT,
236	HWMON_F_INPUT \| HWMON_F_FAULT,
237	HWMON_F_INPUT \| HWMON_F_FAULT,
238	HWMON_F_INPUT \| HWMON_F_FAULT,
239	HWMON_F_INPUT \| HWMON_F_FAULT,
240	HWMON_F_INPUT \| HWMON_F_FAULT,
241	HWMON_F_INPUT \| HWMON_F_FAULT,
242	HWMON_F_INPUT \| HWMON_F_FAULT,
243	0
244	};
245
246	static const struct hwmon_channel_info mlxreg_fan_hwmon_fan = {
247	.type = hwmon_fan,
248	.config = mlxreg_fan_hwmon_fan_config,
249	};
250
251	static const u32 mlxreg_fan_hwmon_pwm_config[] = {
252	HWMON_PWM_INPUT,
253	0
254	};
255
256	static const struct hwmon_channel_info mlxreg_fan_hwmon_pwm = {
257	.type = hwmon_pwm,
258	.config = mlxreg_fan_hwmon_pwm_config,
259	};
260
261	static const struct hwmon_channel_info *mlxreg_fan_hwmon_info[] = {
262	&mlxreg_fan_hwmon_fan,
263	&mlxreg_fan_hwmon_pwm,
264	NULL
265	};
266
267	static const struct hwmon_ops mlxreg_fan_hwmon_hwmon_ops = {
268	.is_visible = mlxreg_fan_is_visible,
269	.read = mlxreg_fan_read,
270	.write = mlxreg_fan_write,
271	};
272
273	static const struct hwmon_chip_info mlxreg_fan_hwmon_chip_info = {
274	.ops = &mlxreg_fan_hwmon_hwmon_ops,
275	.info = mlxreg_fan_hwmon_info,
276	};
277
278	static int mlxreg_fan_get_max_state(struct thermal_cooling_device *cdev,
279	unsigned long *state)
280	{
281	*state = MLXREG_FAN_MAX_STATE;
282	return 0;
283	}
284
285	static int mlxreg_fan_get_cur_state(struct thermal_cooling_device *cdev,
286	unsigned long *state)
287
288	{
289	struct mlxreg_fan *fan = cdev->devdata;
290	u32 regval;
291	int err;
292
293	err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
294	if (err) {
295	dev_err(fan->dev, "Failed to query PWM duty\n");
296	return err;
297	}
298
299	*state = MLXREG_FAN_PWM_DUTY2STATE(regval);
300
301	return 0;
302	}
303
304	static int mlxreg_fan_set_cur_state(struct thermal_cooling_device *cdev,
305	unsigned long state)
306
307	{
308	struct mlxreg_fan *fan = cdev->devdata;
309	unsigned long cur_state;
310	u32 regval;
311	int i;
312	int err;
313
314	/*
315	* Verify if this request is for changing allowed FAN dynamical
316	* minimum. If it is - update cooling levels accordingly and update
317	* state, if current state is below the newly requested minimum state.
318	* For example, if current state is 5, and minimal state is to be
319	* changed from 4 to 6, fan->cooling_levels[0 to 5] will be changed all
320	* from 4 to 6. And state 5 (fan->cooling_levels[4]) should be
321	* overwritten.
322	*/
323	if (state >= MLXREG_FAN_SPEED_MIN && state <= MLXREG_FAN_SPEED_MAX) {
324	state -= MLXREG_FAN_MAX_STATE;
325	for (i = 0; i < state; i++)
326	fan->cooling_levels[i] = state;
327	for (i = state; i <= MLXREG_FAN_MAX_STATE; i++)
328	fan->cooling_levels[i] = i;
329
330	err = regmap_read(fan->regmap, fan->pwm.reg, &regval);
331	if (err) {
332	dev_err(fan->dev, "Failed to query PWM duty\n");
333	return err;
334	}
335
336	cur_state = MLXREG_FAN_PWM_DUTY2STATE(regval);
337	if (state < cur_state)
338	return 0;
339
340	state = cur_state;
341	}
342
343	if (state > MLXREG_FAN_MAX_STATE)
344	return -EINVAL;
345
346	/* Normalize the state to the valid speed range. */
347	state = fan->cooling_levels[state];
348	err = regmap_write(fan->regmap, fan->pwm.reg,
349	MLXREG_FAN_PWM_STATE2DUTY(state));
350	if (err) {
351	dev_err(fan->dev, "Failed to write PWM duty\n");
352	return err;
353	}
354	return 0;
355	}
356
357	static const struct thermal_cooling_device_ops mlxreg_fan_cooling_ops = {
358	.get_max_state = mlxreg_fan_get_max_state,
359	.get_cur_state = mlxreg_fan_get_cur_state,
360	.set_cur_state = mlxreg_fan_set_cur_state,
361	};
362
363	static int mlxreg_fan_config(struct mlxreg_fan *fan,
364	struct mlxreg_core_platform_data *pdata)
365	{
366	struct mlxreg_core_data *data = pdata->data;
367	bool configured = false;
368	int tacho_num = 0, i;
369
370	fan->samples = MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF;
371	fan->divider = MLXREG_FAN_TACHO_DIVIDER_DEF;
372	for (i = 0; i < pdata->counter; i++, data++) {
373	if (strnstr(data->label, "tacho", sizeof(data->label))) {
374	if (tacho_num == MLXREG_FAN_MAX_TACHO) {
375	dev_err(fan->dev, "too many tacho entries: %s\n",
376	data->label);
377	return -EINVAL;
378	}
379	fan->tacho[tacho_num].reg = data->reg;
380	fan->tacho[tacho_num].mask = data->mask;
381	fan->tacho[tacho_num++].connected = true;
382	} else if (strnstr(data->label, "pwm", sizeof(data->label))) {
383	if (fan->pwm.connected) {
384	dev_err(fan->dev, "duplicate pwm entry: %s\n",
385	data->label);
386	return -EINVAL;
387	}
388	fan->pwm.reg = data->reg;
389	fan->pwm.connected = true;
390	} else if (strnstr(data->label, "conf", sizeof(data->label))) {
391	if (configured) {
392	dev_err(fan->dev, "duplicate conf entry: %s\n",
393	data->label);
394	return -EINVAL;
395	}
396	/* Validate that conf parameters are not zeros. */
397	if (!data->mask \|\| !data->bit) {
398	dev_err(fan->dev, "invalid conf entry params: %s\n",
399	data->label);
400	return -EINVAL;
401	}
402	fan->samples = data->mask;
403	fan->divider = data->bit;
404	configured = true;
405	} else {
406	dev_err(fan->dev, "invalid label: %s\n", data->label);
407	return -EINVAL;
408	}
409	}
410
411	/* Init cooling levels per PWM state. */
412	for (i = 0; i < MLXREG_FAN_SPEED_MIN_LEVEL; i++)
413	fan->cooling_levels[i] = MLXREG_FAN_SPEED_MIN_LEVEL;
414	for (i = MLXREG_FAN_SPEED_MIN_LEVEL; i <= MLXREG_FAN_MAX_STATE; i++)
415	fan->cooling_levels[i] = i;
416
417	return 0;
418	}
419
420	static int mlxreg_fan_probe(struct platform_device *pdev)
421	{
422	struct mlxreg_core_platform_data *pdata;
423	struct mlxreg_fan *fan;
424	struct device *hwm;
425	int err;
426
427	pdata = dev_get_platdata(&pdev->dev);
428	if (!pdata) {
429	dev_err(&pdev->dev, "Failed to get platform data.\n");
430	return -EINVAL;
431	}
432
433	fan = devm_kzalloc(&pdev->dev, sizeof(*fan), GFP_KERNEL);
434	if (!fan)
435	return -ENOMEM;
436
437	fan->dev = &pdev->dev;
438	fan->regmap = pdata->regmap;
439	platform_set_drvdata(pdev, fan);
440
441	err = mlxreg_fan_config(fan, pdata);
442	if (err)
443	return err;
444
445	hwm = devm_hwmon_device_register_with_info(&pdev->dev, "mlxreg_fan",
446	fan,
447	&mlxreg_fan_hwmon_chip_info,
448	NULL);
449	if (IS_ERR(hwm)) {
450	dev_err(&pdev->dev, "Failed to register hwmon device\n");
451	return PTR_ERR(hwm);
452	}
453
454	if (IS_REACHABLE(CONFIG_THERMAL)) {
455	fan->cdev = thermal_cooling_device_register("mlxreg_fan", fan,
456	&mlxreg_fan_cooling_ops);
457	if (IS_ERR(fan->cdev)) {
458	dev_err(&pdev->dev, "Failed to register cooling device\n");
459	return PTR_ERR(fan->cdev);
460	}
461	}
462
463	return 0;
464	}
465
466	static int mlxreg_fan_remove(struct platform_device *pdev)
467	{
468	struct mlxreg_fan *fan = platform_get_drvdata(pdev);
469
470	if (IS_REACHABLE(CONFIG_THERMAL))
471	thermal_cooling_device_unregister(fan->cdev);
472
473	return 0;
474	}
475
476	static struct platform_driver mlxreg_fan_driver = {
477	.driver = {
478	.name = "mlxreg-fan",
479	},
480	.probe = mlxreg_fan_probe,
481	.remove = mlxreg_fan_remove,
482	};
483
484	module_platform_driver(mlxreg_fan_driver);
485
486	MODULE_AUTHOR("Vadim Pasternak <[email protected]>");
487	MODULE_DESCRIPTION("Mellanox FAN driver");
488	MODULE_LICENSE("GPL");
489	MODULE_ALIAS("platform:mlxreg-fan");