xref: /linux/drivers/hwmon/pmbus/max31785.c (revision c5288cda69ee2d8607f5026bd599a5cebf0ee783)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2017 IBM Corp.
4  */
5 
6 #include <linux/delay.h>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/err.h>
11 #include <linux/i2c.h>
12 #include "pmbus.h"
13 
14 enum max31785_regs {
15 	MFR_REVISION		= 0x9b,
16 	MFR_FAN_CONFIG		= 0xf1,
17 };
18 
19 #define MAX31785			0x3030
20 #define MAX31785A			0x3040
21 #define MAX31785B			0x3061
22 
23 #define MFR_FAN_CONFIG_DUAL_TACH	BIT(12)
24 
25 #define MAX31785_NR_PAGES		23
26 #define MAX31785_NR_FAN_PAGES		6
27 #define MAX31785_WAIT_DELAY_US		250
28 
29 struct max31785_data {
30 	ktime_t access;			/* Chip access time */
31 	struct pmbus_driver_info info;
32 };
33 
34 #define to_max31785_data(x)  container_of(x, struct max31785_data, info)
35 
36 /*
37  * MAX31785 Driver Workaround
38  *
39  * The MAX31785 fan controller occasionally exhibits communication issues.
40  * These issues are not indicated by the device itself, except for occasional
41  * NACK responses during master transactions. No error bits are set in STATUS_BYTE.
42  *
43  * To address this, we introduce a delay of 250us between consecutive accesses
44  * to the fan controller. This delay helps mitigate communication problems by
45  * allowing sufficient time between accesses.
46  */
47 static inline void max31785_wait(const struct max31785_data *data)
48 {
49 	s64 delta = ktime_us_delta(ktime_get(), data->access);
50 
51 	if (delta < MAX31785_WAIT_DELAY_US)
52 		usleep_range(MAX31785_WAIT_DELAY_US - delta,
53 			     MAX31785_WAIT_DELAY_US);
54 }
55 
56 static int max31785_i2c_write_byte_data(struct i2c_client *client,
57 					struct max31785_data *driver_data,
58 					int command, u16 data)
59 {
60 	int rc;
61 
62 	max31785_wait(driver_data);
63 	rc = i2c_smbus_write_byte_data(client, command, data);
64 	driver_data->access = ktime_get();
65 	return rc;
66 }
67 
68 static int max31785_i2c_read_word_data(struct i2c_client *client,
69 				       struct max31785_data *driver_data,
70 				       int command)
71 {
72 	int rc;
73 
74 	max31785_wait(driver_data);
75 	rc = i2c_smbus_read_word_data(client, command);
76 	driver_data->access = ktime_get();
77 	return rc;
78 }
79 
80 static int _max31785_read_byte_data(struct i2c_client *client,
81 				    struct max31785_data *driver_data,
82 				    int page, int command)
83 {
84 	int rc;
85 
86 	max31785_wait(driver_data);
87 	rc = pmbus_read_byte_data(client, page, command);
88 	driver_data->access = ktime_get();
89 	return rc;
90 }
91 
92 static int _max31785_write_byte_data(struct i2c_client *client,
93 				     struct max31785_data *driver_data,
94 				     int page, int command, u16 data)
95 {
96 	int rc;
97 
98 	max31785_wait(driver_data);
99 	rc = pmbus_write_byte_data(client, page, command, data);
100 	driver_data->access = ktime_get();
101 	return rc;
102 }
103 
104 static int _max31785_read_word_data(struct i2c_client *client,
105 				    struct max31785_data *driver_data,
106 				    int page, int phase, int command)
107 {
108 	int rc;
109 
110 	max31785_wait(driver_data);
111 	rc = pmbus_read_word_data(client, page, phase, command);
112 	driver_data->access = ktime_get();
113 	return rc;
114 }
115 
116 static int _max31785_write_word_data(struct i2c_client *client,
117 				     struct max31785_data *driver_data,
118 				     int page, int command, u16 data)
119 {
120 	int rc;
121 
122 	max31785_wait(driver_data);
123 	rc = pmbus_write_word_data(client, page, command, data);
124 	driver_data->access = ktime_get();
125 	return rc;
126 }
127 
128 static int max31785_read_byte_data(struct i2c_client *client, int page, int reg)
129 {
130 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
131 	struct max31785_data *driver_data = to_max31785_data(info);
132 
133 	switch (reg) {
134 	case PMBUS_VOUT_MODE:
135 		return -ENOTSUPP;
136 	case PMBUS_FAN_CONFIG_12:
137 		return _max31785_read_byte_data(client, driver_data,
138 						page - MAX31785_NR_PAGES,
139 						reg);
140 	}
141 
142 	return -ENODATA;
143 }
144 
145 static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
146 {
147 	if (page < MAX31785_NR_PAGES)
148 		return -ENODATA;
149 
150 	return -ENOTSUPP;
151 }
152 
153 static int max31785_read_long_data(struct i2c_client *client, int page,
154 				   int reg, u32 *data)
155 {
156 	unsigned char cmdbuf[1];
157 	unsigned char rspbuf[4];
158 	int rc;
159 
160 	struct i2c_msg msg[2] = {
161 		{
162 			.addr = client->addr,
163 			.flags = 0,
164 			.len = sizeof(cmdbuf),
165 			.buf = cmdbuf,
166 		},
167 		{
168 			.addr = client->addr,
169 			.flags = I2C_M_RD,
170 			.len = sizeof(rspbuf),
171 			.buf = rspbuf,
172 		},
173 	};
174 
175 	cmdbuf[0] = reg;
176 
177 	rc = pmbus_set_page(client, page, 0xff);
178 	if (rc < 0)
179 		return rc;
180 
181 	rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
182 	if (rc < 0)
183 		return rc;
184 
185 	*data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |
186 		(rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));
187 
188 	return rc;
189 }
190 
191 static int max31785_get_pwm(struct i2c_client *client, int page)
192 {
193 	int rv;
194 
195 	rv = pmbus_get_fan_rate_device(client, page, 0, percent);
196 	if (rv < 0)
197 		return rv;
198 	else if (rv >= 0x8000)
199 		return 0;
200 	else if (rv >= 0x2711)
201 		return 0x2710;
202 
203 	return rv;
204 }
205 
206 static int max31785_get_pwm_mode(struct i2c_client *client,
207 				 struct max31785_data *driver_data, int page)
208 {
209 	int config;
210 	int command;
211 
212 	config = _max31785_read_byte_data(client, driver_data, page,
213 					  PMBUS_FAN_CONFIG_12);
214 	if (config < 0)
215 		return config;
216 
217 	command = _max31785_read_word_data(client, driver_data, page, 0xff,
218 					   PMBUS_FAN_COMMAND_1);
219 	if (command < 0)
220 		return command;
221 
222 	if (config & PB_FAN_1_RPM)
223 		return (command >= 0x8000) ? 3 : 2;
224 
225 	if (command >= 0x8000)
226 		return 3;
227 	else if (command >= 0x2711)
228 		return 0;
229 
230 	return 1;
231 }
232 
233 static int max31785_read_word_data(struct i2c_client *client, int page,
234 				   int phase, int reg)
235 {
236 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
237 	struct max31785_data *driver_data = to_max31785_data(info);
238 	u32 val;
239 	int rv;
240 
241 	switch (reg) {
242 	case PMBUS_READ_FAN_SPEED_1:
243 		if (page < MAX31785_NR_PAGES)
244 			return -ENODATA;
245 
246 		rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
247 					     reg, &val);
248 		if (rv < 0)
249 			return rv;
250 
251 		rv = (val >> 16) & 0xffff;
252 		break;
253 	case PMBUS_FAN_COMMAND_1:
254 		/*
255 		 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to
256 		 * expose fan control registers.
257 		 *
258 		 * Don't expose fan_target attribute for virtual pages.
259 		 */
260 		rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
261 		break;
262 	case PMBUS_VIRT_PWM_1:
263 		rv = max31785_get_pwm(client, page);
264 		break;
265 	case PMBUS_VIRT_PWM_ENABLE_1:
266 		rv = max31785_get_pwm_mode(client, driver_data, page);
267 		break;
268 	default:
269 		rv = -ENODATA;
270 		break;
271 	}
272 
273 	return rv;
274 }
275 
276 static inline u32 max31785_scale_pwm(u32 sensor_val)
277 {
278 	/*
279 	 * The datasheet describes the accepted value range for manual PWM as
280 	 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
281 	 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
282 	 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The
283 	 * important observation here is that 0x2710 == 10000 == 100 * 100.
284 	 *
285 	 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the
286 	 * sysfs interface into the required hardware resolution, but it does
287 	 * not yet yield a value that we can write to the device (this initial
288 	 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below
289 	 * translates the parameter value into the percentage units required by
290 	 * PMBus, and then we scale back by 255 as required by the hwmon pwmX
291 	 * interface to yield the percentage value at the appropriate
292 	 * resolution for hardware.
293 	 */
294 	return (sensor_val * 100) / 255;
295 }
296 
297 static int max31785_update_fan(struct i2c_client *client,
298 			       struct max31785_data *driver_data, int page,
299 			       u8 config, u8 mask, u16 command)
300 {
301 	int from, rv;
302 	u8 to;
303 
304 	from = _max31785_read_byte_data(client, driver_data, page,
305 					PMBUS_FAN_CONFIG_12);
306 	if (from < 0)
307 		return from;
308 
309 	to = (from & ~mask) | (config & mask);
310 
311 	if (to != from) {
312 		rv = _max31785_write_byte_data(client, driver_data, page,
313 					       PMBUS_FAN_CONFIG_12, to);
314 		if (rv < 0)
315 			return rv;
316 	}
317 
318 	rv = _max31785_write_word_data(client, driver_data, page,
319 				       PMBUS_FAN_COMMAND_1, command);
320 
321 	return rv;
322 }
323 
324 static int max31785_pwm_enable(struct i2c_client *client,
325 			       struct max31785_data *driver_data, int page,
326 			       u16 word)
327 {
328 	int config = 0;
329 	int rate;
330 
331 	switch (word) {
332 	case 0:
333 		rate = 0x7fff;
334 		break;
335 	case 1:
336 		rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
337 		if (rate < 0)
338 			return rate;
339 		rate = max31785_scale_pwm(rate);
340 		break;
341 	case 2:
342 		config = PB_FAN_1_RPM;
343 		rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
344 		if (rate < 0)
345 			return rate;
346 		break;
347 	case 3:
348 		rate = 0xffff;
349 		break;
350 	default:
351 		return -EINVAL;
352 	}
353 
354 	return max31785_update_fan(client, driver_data, page, config,
355 				   PB_FAN_1_RPM, rate);
356 }
357 
358 static int max31785_write_word_data(struct i2c_client *client, int page,
359 				    int reg, u16 word)
360 {
361 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
362 	struct max31785_data *driver_data = to_max31785_data(info);
363 
364 	switch (reg) {
365 	case PMBUS_VIRT_PWM_1:
366 		return max31785_update_fan(client, driver_data, page, 0,
367 					   PB_FAN_1_RPM,
368 					   max31785_scale_pwm(word));
369 	case PMBUS_VIRT_PWM_ENABLE_1:
370 		return max31785_pwm_enable(client, driver_data, page, word);
371 	default:
372 		break;
373 	}
374 
375 	return -ENODATA;
376 }
377 
378 #define MAX31785_FAN_FUNCS \
379 	(PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)
380 
381 #define MAX31785_TEMP_FUNCS \
382 	(PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)
383 
384 #define MAX31785_VOUT_FUNCS \
385 	(PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)
386 
387 static const struct pmbus_driver_info max31785_info = {
388 	.pages = MAX31785_NR_PAGES,
389 
390 	.write_word_data = max31785_write_word_data,
391 	.read_byte_data = max31785_read_byte_data,
392 	.read_word_data = max31785_read_word_data,
393 	.write_byte = max31785_write_byte,
394 
395 	/* RPM */
396 	.format[PSC_FAN] = direct,
397 	.m[PSC_FAN] = 1,
398 	.b[PSC_FAN] = 0,
399 	.R[PSC_FAN] = 0,
400 	/* PWM */
401 	.format[PSC_PWM] = direct,
402 	.m[PSC_PWM] = 1,
403 	.b[PSC_PWM] = 0,
404 	.R[PSC_PWM] = 2,
405 	.func[0] = MAX31785_FAN_FUNCS,
406 	.func[1] = MAX31785_FAN_FUNCS,
407 	.func[2] = MAX31785_FAN_FUNCS,
408 	.func[3] = MAX31785_FAN_FUNCS,
409 	.func[4] = MAX31785_FAN_FUNCS,
410 	.func[5] = MAX31785_FAN_FUNCS,
411 
412 	.format[PSC_TEMPERATURE] = direct,
413 	.m[PSC_TEMPERATURE] = 1,
414 	.b[PSC_TEMPERATURE] = 0,
415 	.R[PSC_TEMPERATURE] = 2,
416 	.func[6]  = MAX31785_TEMP_FUNCS,
417 	.func[7]  = MAX31785_TEMP_FUNCS,
418 	.func[8]  = MAX31785_TEMP_FUNCS,
419 	.func[9]  = MAX31785_TEMP_FUNCS,
420 	.func[10] = MAX31785_TEMP_FUNCS,
421 	.func[11] = MAX31785_TEMP_FUNCS,
422 	.func[12] = MAX31785_TEMP_FUNCS,
423 	.func[13] = MAX31785_TEMP_FUNCS,
424 	.func[14] = MAX31785_TEMP_FUNCS,
425 	.func[15] = MAX31785_TEMP_FUNCS,
426 	.func[16] = MAX31785_TEMP_FUNCS,
427 
428 	.format[PSC_VOLTAGE_OUT] = direct,
429 	.m[PSC_VOLTAGE_OUT] = 1,
430 	.b[PSC_VOLTAGE_OUT] = 0,
431 	.R[PSC_VOLTAGE_OUT] = 0,
432 	.func[17] = MAX31785_VOUT_FUNCS,
433 	.func[18] = MAX31785_VOUT_FUNCS,
434 	.func[19] = MAX31785_VOUT_FUNCS,
435 	.func[20] = MAX31785_VOUT_FUNCS,
436 	.func[21] = MAX31785_VOUT_FUNCS,
437 	.func[22] = MAX31785_VOUT_FUNCS,
438 };
439 
440 static int max31785_configure_dual_tach(struct i2c_client *client,
441 					struct pmbus_driver_info *info)
442 {
443 	int ret;
444 	int i;
445 	struct max31785_data *driver_data = to_max31785_data(info);
446 
447 	for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
448 		ret = max31785_i2c_write_byte_data(client, driver_data,
449 						   PMBUS_PAGE, i);
450 		if (ret < 0)
451 			return ret;
452 
453 		ret = max31785_i2c_read_word_data(client, driver_data,
454 						  MFR_FAN_CONFIG);
455 		if (ret < 0)
456 			return ret;
457 
458 		if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
459 			int virtual = MAX31785_NR_PAGES + i;
460 
461 			info->pages = virtual + 1;
462 			info->func[virtual] |= PMBUS_HAVE_FAN12;
463 			info->func[virtual] |= PMBUS_PAGE_VIRTUAL;
464 		}
465 	}
466 
467 	return 0;
468 }
469 
470 static int max31785_probe(struct i2c_client *client)
471 {
472 	struct device *dev = &client->dev;
473 	struct pmbus_driver_info *info;
474 	struct max31785_data *driver_data;
475 	bool dual_tach = false;
476 	int ret;
477 
478 	if (!i2c_check_functionality(client->adapter,
479 				     I2C_FUNC_SMBUS_BYTE_DATA |
480 				     I2C_FUNC_SMBUS_WORD_DATA))
481 		return -ENODEV;
482 
483 	driver_data = devm_kzalloc(dev, sizeof(struct max31785_data), GFP_KERNEL);
484 	if (!driver_data)
485 		return -ENOMEM;
486 
487 	info = &driver_data->info;
488 	driver_data->access = ktime_get();
489 	*info = max31785_info;
490 
491 	ret = max31785_i2c_write_byte_data(client, driver_data,
492 					   PMBUS_PAGE, 255);
493 	if (ret < 0)
494 		return ret;
495 
496 	ret = i2c_smbus_read_word_data(client, MFR_REVISION);
497 	if (ret < 0)
498 		return ret;
499 
500 	if (ret == MAX31785A || ret == MAX31785B) {
501 		dual_tach = true;
502 	} else if (ret == MAX31785) {
503 		if (!strcmp("max31785a", client->name) ||
504 		    !strcmp("max31785b", client->name))
505 			dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
506 	} else {
507 		dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
508 		return -ENODEV;
509 	}
510 
511 	if (dual_tach) {
512 		ret = max31785_configure_dual_tach(client, info);
513 		if (ret < 0)
514 			return ret;
515 	}
516 
517 	return pmbus_do_probe(client, info);
518 }
519 
520 static const struct i2c_device_id max31785_id[] = {
521 	{ "max31785" },
522 	{ "max31785a" },
523 	{ "max31785b" },
524 	{ },
525 };
526 
527 MODULE_DEVICE_TABLE(i2c, max31785_id);
528 
529 static const struct of_device_id max31785_of_match[] = {
530 	{ .compatible = "maxim,max31785" },
531 	{ .compatible = "maxim,max31785a" },
532 	{ .compatible = "maxim,max31785b" },
533 	{ },
534 };
535 
536 MODULE_DEVICE_TABLE(of, max31785_of_match);
537 
538 static struct i2c_driver max31785_driver = {
539 	.driver = {
540 		.name = "max31785",
541 		.of_match_table = max31785_of_match,
542 	},
543 	.probe = max31785_probe,
544 	.id_table = max31785_id,
545 };
546 
547 module_i2c_driver(max31785_driver);
548 
549 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
550 MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
551 MODULE_LICENSE("GPL");
552 MODULE_IMPORT_NS(PMBUS);
553