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
14enum 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
29struct 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 */
47static 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
56static 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
68static 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
80static 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
92static 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
104static 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
116static 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
128static 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
145static 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
153static 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
191static 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
206static 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
233static 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
276static 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
297static 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
324static 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
358static 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
387static 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
440static 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
470static 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
520static const struct i2c_device_id max31785_id[] = {
521	{ "max31785", 0 },
522	{ "max31785a", 0 },
523	{ "max31785b", 0 },
524	{ },
525};
526
527MODULE_DEVICE_TABLE(i2c, max31785_id);
528
529static const struct of_device_id max31785_of_match[] = {
530	{ .compatible = "maxim,max31785" },
531	{ .compatible = "maxim,max31785a" },
532	{ .compatible = "maxim,max31785b" },
533	{ },
534};
535
536MODULE_DEVICE_TABLE(of, max31785_of_match);
537
538static 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
547module_i2c_driver(max31785_driver);
548
549MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
550MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
551MODULE_LICENSE("GPL");
552MODULE_IMPORT_NS(PMBUS);
553