xref: /openbmc/linux/drivers/hwmon/max31790.c (revision 1975d167)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * max31790.c - Part of lm_sensors, Linux kernel modules for hardware
4  *             monitoring.
5  *
6  * (C) 2015 by Il Han <corone.il.han@gmail.com>
7  */
8 
9 #include <linux/err.h>
10 #include <linux/hwmon.h>
11 #include <linux/i2c.h>
12 #include <linux/init.h>
13 #include <linux/jiffies.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 
17 /* MAX31790 registers */
18 #define MAX31790_REG_GLOBAL_CONFIG	0x00
19 #define MAX31790_REG_FAN_CONFIG(ch)	(0x02 + (ch))
20 #define MAX31790_REG_FAN_DYNAMICS(ch)	(0x08 + (ch))
21 #define MAX31790_REG_FAN_FAULT_STATUS2	0x10
22 #define MAX31790_REG_FAN_FAULT_STATUS1	0x11
23 #define MAX31790_REG_TACH_COUNT(ch)	(0x18 + (ch) * 2)
24 #define MAX31790_REG_PWM_DUTY_CYCLE(ch)	(0x30 + (ch) * 2)
25 #define MAX31790_REG_PWMOUT(ch)		(0x40 + (ch) * 2)
26 #define MAX31790_REG_TARGET_COUNT(ch)	(0x50 + (ch) * 2)
27 
28 /* Fan Config register bits */
29 #define MAX31790_FAN_CFG_RPM_MODE	0x80
30 #define MAX31790_FAN_CFG_CTRL_MON	0x10
31 #define MAX31790_FAN_CFG_TACH_INPUT_EN	0x08
32 #define MAX31790_FAN_CFG_TACH_INPUT	0x01
33 
34 /* Fan Dynamics register bits */
35 #define MAX31790_FAN_DYN_SR_SHIFT	5
36 #define MAX31790_FAN_DYN_SR_MASK	0xE0
37 #define SR_FROM_REG(reg)		(((reg) & MAX31790_FAN_DYN_SR_MASK) \
38 					 >> MAX31790_FAN_DYN_SR_SHIFT)
39 
40 #define FAN_RPM_MIN			120
41 #define FAN_RPM_MAX			7864320
42 
43 #define FAN_COUNT_REG_MAX		0xffe0
44 
45 #define RPM_FROM_REG(reg, sr)		(((reg) >> 4) ? \
46 					 ((60 * (sr) * 8192) / ((reg) >> 4)) : \
47 					 FAN_RPM_MAX)
48 #define RPM_TO_REG(rpm, sr)		((60 * (sr) * 8192) / ((rpm) * 2))
49 
50 #define NR_CHANNEL			6
51 
52 /*
53  * Client data (each client gets its own)
54  */
55 struct max31790_data {
56 	struct i2c_client *client;
57 	struct mutex update_lock;
58 	bool valid; /* zero until following fields are valid */
59 	unsigned long last_updated; /* in jiffies */
60 
61 	/* register values */
62 	u8 fan_config[NR_CHANNEL];
63 	u8 fan_dynamics[NR_CHANNEL];
64 	u16 fault_status;
65 	u16 tach[NR_CHANNEL * 2];
66 	u16 pwm[NR_CHANNEL];
67 	u16 target_count[NR_CHANNEL];
68 };
69 
max31790_update_device(struct device * dev)70 static struct max31790_data *max31790_update_device(struct device *dev)
71 {
72 	struct max31790_data *data = dev_get_drvdata(dev);
73 	struct i2c_client *client = data->client;
74 	struct max31790_data *ret = data;
75 	int i;
76 	int rv;
77 
78 	mutex_lock(&data->update_lock);
79 
80 	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
81 		rv = i2c_smbus_read_byte_data(client,
82 				MAX31790_REG_FAN_FAULT_STATUS1);
83 		if (rv < 0)
84 			goto abort;
85 		data->fault_status |= rv & 0x3F;
86 
87 		rv = i2c_smbus_read_byte_data(client,
88 				MAX31790_REG_FAN_FAULT_STATUS2);
89 		if (rv < 0)
90 			goto abort;
91 		data->fault_status |= (rv & 0x3F) << 6;
92 
93 		for (i = 0; i < NR_CHANNEL; i++) {
94 			rv = i2c_smbus_read_word_swapped(client,
95 					MAX31790_REG_TACH_COUNT(i));
96 			if (rv < 0)
97 				goto abort;
98 			data->tach[i] = rv;
99 
100 			if (data->fan_config[i]
101 			    & MAX31790_FAN_CFG_TACH_INPUT) {
102 				rv = i2c_smbus_read_word_swapped(client,
103 					MAX31790_REG_TACH_COUNT(NR_CHANNEL
104 								+ i));
105 				if (rv < 0)
106 					goto abort;
107 				data->tach[NR_CHANNEL + i] = rv;
108 			} else {
109 				rv = i2c_smbus_read_word_swapped(client,
110 						MAX31790_REG_PWM_DUTY_CYCLE(i));
111 				if (rv < 0)
112 					goto abort;
113 				data->pwm[i] = rv;
114 
115 				rv = i2c_smbus_read_word_swapped(client,
116 						MAX31790_REG_TARGET_COUNT(i));
117 				if (rv < 0)
118 					goto abort;
119 				data->target_count[i] = rv;
120 			}
121 		}
122 
123 		data->last_updated = jiffies;
124 		data->valid = true;
125 	}
126 	goto done;
127 
128 abort:
129 	data->valid = false;
130 	ret = ERR_PTR(rv);
131 
132 done:
133 	mutex_unlock(&data->update_lock);
134 
135 	return ret;
136 }
137 
138 static const u8 tach_period[8] = { 1, 2, 4, 8, 16, 32, 32, 32 };
139 
get_tach_period(u8 fan_dynamics)140 static u8 get_tach_period(u8 fan_dynamics)
141 {
142 	return tach_period[SR_FROM_REG(fan_dynamics)];
143 }
144 
bits_for_tach_period(int rpm)145 static u8 bits_for_tach_period(int rpm)
146 {
147 	u8 bits;
148 
149 	if (rpm < 500)
150 		bits = 0x0;
151 	else if (rpm < 1000)
152 		bits = 0x1;
153 	else if (rpm < 2000)
154 		bits = 0x2;
155 	else if (rpm < 4000)
156 		bits = 0x3;
157 	else if (rpm < 8000)
158 		bits = 0x4;
159 	else
160 		bits = 0x5;
161 
162 	return bits;
163 }
164 
max31790_read_fan(struct device * dev,u32 attr,int channel,long * val)165 static int max31790_read_fan(struct device *dev, u32 attr, int channel,
166 			     long *val)
167 {
168 	struct max31790_data *data = max31790_update_device(dev);
169 	int sr, rpm;
170 
171 	if (IS_ERR(data))
172 		return PTR_ERR(data);
173 
174 	switch (attr) {
175 	case hwmon_fan_input:
176 		sr = get_tach_period(data->fan_dynamics[channel % NR_CHANNEL]);
177 		if (data->tach[channel] == FAN_COUNT_REG_MAX)
178 			rpm = 0;
179 		else
180 			rpm = RPM_FROM_REG(data->tach[channel], sr);
181 		*val = rpm;
182 		return 0;
183 	case hwmon_fan_target:
184 		sr = get_tach_period(data->fan_dynamics[channel]);
185 		rpm = RPM_FROM_REG(data->target_count[channel], sr);
186 		*val = rpm;
187 		return 0;
188 	case hwmon_fan_fault:
189 		mutex_lock(&data->update_lock);
190 		*val = !!(data->fault_status & (1 << channel));
191 		data->fault_status &= ~(1 << channel);
192 		/*
193 		 * If a fault bit is set, we need to write into one of the fan
194 		 * configuration registers to clear it. Note that this also
195 		 * clears the fault for the companion channel if enabled.
196 		 */
197 		if (*val) {
198 			int reg = MAX31790_REG_TARGET_COUNT(channel % NR_CHANNEL);
199 
200 			i2c_smbus_write_byte_data(data->client, reg,
201 						  data->target_count[channel % NR_CHANNEL] >> 8);
202 		}
203 		mutex_unlock(&data->update_lock);
204 		return 0;
205 	case hwmon_fan_enable:
206 		*val = !!(data->fan_config[channel] & MAX31790_FAN_CFG_TACH_INPUT_EN);
207 		return 0;
208 	default:
209 		return -EOPNOTSUPP;
210 	}
211 }
212 
max31790_write_fan(struct device * dev,u32 attr,int channel,long val)213 static int max31790_write_fan(struct device *dev, u32 attr, int channel,
214 			      long val)
215 {
216 	struct max31790_data *data = dev_get_drvdata(dev);
217 	struct i2c_client *client = data->client;
218 	int target_count;
219 	int err = 0;
220 	u8 bits, fan_config;
221 	int sr;
222 
223 	mutex_lock(&data->update_lock);
224 
225 	switch (attr) {
226 	case hwmon_fan_target:
227 		val = clamp_val(val, FAN_RPM_MIN, FAN_RPM_MAX);
228 		bits = bits_for_tach_period(val);
229 		data->fan_dynamics[channel] =
230 			((data->fan_dynamics[channel] &
231 			  ~MAX31790_FAN_DYN_SR_MASK) |
232 			 (bits << MAX31790_FAN_DYN_SR_SHIFT));
233 		err = i2c_smbus_write_byte_data(client,
234 					MAX31790_REG_FAN_DYNAMICS(channel),
235 					data->fan_dynamics[channel]);
236 		if (err < 0)
237 			break;
238 
239 		sr = get_tach_period(data->fan_dynamics[channel]);
240 		target_count = RPM_TO_REG(val, sr);
241 		target_count = clamp_val(target_count, 0x1, 0x7FF);
242 
243 		data->target_count[channel] = target_count << 5;
244 
245 		err = i2c_smbus_write_word_swapped(client,
246 					MAX31790_REG_TARGET_COUNT(channel),
247 					data->target_count[channel]);
248 		break;
249 	case hwmon_fan_enable:
250 		fan_config = data->fan_config[channel];
251 		if (val == 0) {
252 			fan_config &= ~MAX31790_FAN_CFG_TACH_INPUT_EN;
253 		} else if (val == 1) {
254 			fan_config |= MAX31790_FAN_CFG_TACH_INPUT_EN;
255 		} else {
256 			err = -EINVAL;
257 			break;
258 		}
259 		if (fan_config != data->fan_config[channel]) {
260 			err = i2c_smbus_write_byte_data(client, MAX31790_REG_FAN_CONFIG(channel),
261 							fan_config);
262 			if (!err)
263 				data->fan_config[channel] = fan_config;
264 		}
265 		break;
266 	default:
267 		err = -EOPNOTSUPP;
268 		break;
269 	}
270 
271 	mutex_unlock(&data->update_lock);
272 
273 	return err;
274 }
275 
max31790_fan_is_visible(const void * _data,u32 attr,int channel)276 static umode_t max31790_fan_is_visible(const void *_data, u32 attr, int channel)
277 {
278 	const struct max31790_data *data = _data;
279 	u8 fan_config = data->fan_config[channel % NR_CHANNEL];
280 
281 	switch (attr) {
282 	case hwmon_fan_input:
283 	case hwmon_fan_fault:
284 		if (channel < NR_CHANNEL ||
285 		    (fan_config & MAX31790_FAN_CFG_TACH_INPUT))
286 			return 0444;
287 		return 0;
288 	case hwmon_fan_target:
289 		if (channel < NR_CHANNEL &&
290 		    !(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
291 			return 0644;
292 		return 0;
293 	case hwmon_fan_enable:
294 		if (channel < NR_CHANNEL)
295 			return 0644;
296 		return 0;
297 	default:
298 		return 0;
299 	}
300 }
301 
max31790_read_pwm(struct device * dev,u32 attr,int channel,long * val)302 static int max31790_read_pwm(struct device *dev, u32 attr, int channel,
303 			     long *val)
304 {
305 	struct max31790_data *data = max31790_update_device(dev);
306 	u8 fan_config;
307 
308 	if (IS_ERR(data))
309 		return PTR_ERR(data);
310 
311 	fan_config = data->fan_config[channel];
312 
313 	switch (attr) {
314 	case hwmon_pwm_input:
315 		*val = data->pwm[channel] >> 8;
316 		return 0;
317 	case hwmon_pwm_enable:
318 		if (fan_config & MAX31790_FAN_CFG_CTRL_MON)
319 			*val = 0;
320 		else if (fan_config & MAX31790_FAN_CFG_RPM_MODE)
321 			*val = 2;
322 		else
323 			*val = 1;
324 		return 0;
325 	default:
326 		return -EOPNOTSUPP;
327 	}
328 }
329 
max31790_write_pwm(struct device * dev,u32 attr,int channel,long val)330 static int max31790_write_pwm(struct device *dev, u32 attr, int channel,
331 			      long val)
332 {
333 	struct max31790_data *data = dev_get_drvdata(dev);
334 	struct i2c_client *client = data->client;
335 	u8 fan_config;
336 	int err = 0;
337 
338 	mutex_lock(&data->update_lock);
339 
340 	switch (attr) {
341 	case hwmon_pwm_input:
342 		if (val < 0 || val > 255) {
343 			err = -EINVAL;
344 			break;
345 		}
346 		data->valid = false;
347 		err = i2c_smbus_write_word_swapped(client,
348 						   MAX31790_REG_PWMOUT(channel),
349 						   val << 8);
350 		break;
351 	case hwmon_pwm_enable:
352 		fan_config = data->fan_config[channel];
353 		if (val == 0) {
354 			fan_config |= MAX31790_FAN_CFG_CTRL_MON;
355 			/*
356 			 * Disable RPM mode; otherwise disabling fan speed
357 			 * monitoring is not possible.
358 			 */
359 			fan_config &= ~MAX31790_FAN_CFG_RPM_MODE;
360 		} else if (val == 1) {
361 			fan_config &= ~(MAX31790_FAN_CFG_CTRL_MON | MAX31790_FAN_CFG_RPM_MODE);
362 		} else if (val == 2) {
363 			fan_config &= ~MAX31790_FAN_CFG_CTRL_MON;
364 			/*
365 			 * The chip sets MAX31790_FAN_CFG_TACH_INPUT_EN on its
366 			 * own if MAX31790_FAN_CFG_RPM_MODE is set.
367 			 * Do it here as well to reflect the actual register
368 			 * value in the cache.
369 			 */
370 			fan_config |= (MAX31790_FAN_CFG_RPM_MODE | MAX31790_FAN_CFG_TACH_INPUT_EN);
371 		} else {
372 			err = -EINVAL;
373 			break;
374 		}
375 		if (fan_config != data->fan_config[channel]) {
376 			err = i2c_smbus_write_byte_data(client, MAX31790_REG_FAN_CONFIG(channel),
377 							fan_config);
378 			if (!err)
379 				data->fan_config[channel] = fan_config;
380 		}
381 		break;
382 	default:
383 		err = -EOPNOTSUPP;
384 		break;
385 	}
386 
387 	mutex_unlock(&data->update_lock);
388 
389 	return err;
390 }
391 
max31790_pwm_is_visible(const void * _data,u32 attr,int channel)392 static umode_t max31790_pwm_is_visible(const void *_data, u32 attr, int channel)
393 {
394 	const struct max31790_data *data = _data;
395 	u8 fan_config = data->fan_config[channel];
396 
397 	switch (attr) {
398 	case hwmon_pwm_input:
399 	case hwmon_pwm_enable:
400 		if (!(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
401 			return 0644;
402 		return 0;
403 	default:
404 		return 0;
405 	}
406 }
407 
max31790_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)408 static int max31790_read(struct device *dev, enum hwmon_sensor_types type,
409 			 u32 attr, int channel, long *val)
410 {
411 	switch (type) {
412 	case hwmon_fan:
413 		return max31790_read_fan(dev, attr, channel, val);
414 	case hwmon_pwm:
415 		return max31790_read_pwm(dev, attr, channel, val);
416 	default:
417 		return -EOPNOTSUPP;
418 	}
419 }
420 
max31790_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)421 static int max31790_write(struct device *dev, enum hwmon_sensor_types type,
422 			  u32 attr, int channel, long val)
423 {
424 	switch (type) {
425 	case hwmon_fan:
426 		return max31790_write_fan(dev, attr, channel, val);
427 	case hwmon_pwm:
428 		return max31790_write_pwm(dev, attr, channel, val);
429 	default:
430 		return -EOPNOTSUPP;
431 	}
432 }
433 
max31790_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)434 static umode_t max31790_is_visible(const void *data,
435 				   enum hwmon_sensor_types type,
436 				   u32 attr, int channel)
437 {
438 	switch (type) {
439 	case hwmon_fan:
440 		return max31790_fan_is_visible(data, attr, channel);
441 	case hwmon_pwm:
442 		return max31790_pwm_is_visible(data, attr, channel);
443 	default:
444 		return 0;
445 	}
446 }
447 
448 static const struct hwmon_channel_info * const max31790_info[] = {
449 	HWMON_CHANNEL_INFO(fan,
450 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
451 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
452 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
453 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
454 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
455 			   HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT | HWMON_F_ENABLE,
456 			   HWMON_F_INPUT | HWMON_F_FAULT,
457 			   HWMON_F_INPUT | HWMON_F_FAULT,
458 			   HWMON_F_INPUT | HWMON_F_FAULT,
459 			   HWMON_F_INPUT | HWMON_F_FAULT,
460 			   HWMON_F_INPUT | HWMON_F_FAULT,
461 			   HWMON_F_INPUT | HWMON_F_FAULT),
462 	HWMON_CHANNEL_INFO(pwm,
463 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
464 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
465 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
466 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
467 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
468 			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
469 	NULL
470 };
471 
472 static const struct hwmon_ops max31790_hwmon_ops = {
473 	.is_visible = max31790_is_visible,
474 	.read = max31790_read,
475 	.write = max31790_write,
476 };
477 
478 static const struct hwmon_chip_info max31790_chip_info = {
479 	.ops = &max31790_hwmon_ops,
480 	.info = max31790_info,
481 };
482 
max31790_init_client(struct i2c_client * client,struct max31790_data * data)483 static int max31790_init_client(struct i2c_client *client,
484 				struct max31790_data *data)
485 {
486 	int i, rv;
487 
488 	for (i = 0; i < NR_CHANNEL; i++) {
489 		rv = i2c_smbus_read_byte_data(client,
490 				MAX31790_REG_FAN_CONFIG(i));
491 		if (rv < 0)
492 			return rv;
493 		data->fan_config[i] = rv;
494 
495 		rv = i2c_smbus_read_byte_data(client,
496 				MAX31790_REG_FAN_DYNAMICS(i));
497 		if (rv < 0)
498 			return rv;
499 		data->fan_dynamics[i] = rv;
500 	}
501 
502 	return 0;
503 }
504 
max31790_probe(struct i2c_client * client)505 static int max31790_probe(struct i2c_client *client)
506 {
507 	struct i2c_adapter *adapter = client->adapter;
508 	struct device *dev = &client->dev;
509 	struct max31790_data *data;
510 	struct device *hwmon_dev;
511 	int err;
512 
513 	if (!i2c_check_functionality(adapter,
514 			I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
515 		return -ENODEV;
516 
517 	data = devm_kzalloc(dev, sizeof(struct max31790_data), GFP_KERNEL);
518 	if (!data)
519 		return -ENOMEM;
520 
521 	data->client = client;
522 	mutex_init(&data->update_lock);
523 
524 	/*
525 	 * Initialize the max31790 chip
526 	 */
527 	err = max31790_init_client(client, data);
528 	if (err)
529 		return err;
530 
531 	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
532 							 data,
533 							 &max31790_chip_info,
534 							 NULL);
535 
536 	return PTR_ERR_OR_ZERO(hwmon_dev);
537 }
538 
539 static const struct i2c_device_id max31790_id[] = {
540 	{ "max31790", 0 },
541 	{ }
542 };
543 MODULE_DEVICE_TABLE(i2c, max31790_id);
544 
545 static struct i2c_driver max31790_driver = {
546 	.class		= I2C_CLASS_HWMON,
547 	.probe		= max31790_probe,
548 	.driver = {
549 		.name	= "max31790",
550 	},
551 	.id_table	= max31790_id,
552 };
553 
554 module_i2c_driver(max31790_driver);
555 
556 MODULE_AUTHOR("Il Han <corone.il.han@gmail.com>");
557 MODULE_DESCRIPTION("MAX31790 sensor driver");
558 MODULE_LICENSE("GPL");
559