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(later: ktime_get(), earlier: 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(data: driver_data);
63 rc = i2c_smbus_write_byte_data(client, command, value: 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(data: 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(data: driver_data);
87 rc = pmbus_read_byte_data(client, page, reg: 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(data: driver_data);
99 rc = pmbus_write_byte_data(client, page, reg: command, value: 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(data: driver_data);
111 rc = pmbus_read_word_data(client, page, phase, reg: 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(data: driver_data);
123 rc = pmbus_write_word_data(client, page, reg: command, word: 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: page - MAX31785_NR_PAGES,
139 command: 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, phase: 0xff);
178 if (rc < 0)
179 return rc;
180
181 rc = i2c_transfer(adap: client->adapter, msgs: 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, id: 0, mode: 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 command: PMBUS_FAN_CONFIG_12);
214 if (config < 0)
215 return config;
216
217 command = _max31785_read_word_data(client, driver_data, page, phase: 0xff,
218 command: 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: page - MAX31785_NR_PAGES,
247 reg, data: &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 command: 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 command: PMBUS_FAN_CONFIG_12, data: to);
314 if (rv < 0)
315 return rv;
316 }
317
318 rv = _max31785_write_word_data(client, driver_data, page,
319 command: PMBUS_FAN_COMMAND_1, data: 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, id: 0, mode: percent);
337 if (rate < 0)
338 return rate;
339 rate = max31785_scale_pwm(sensor_val: rate);
340 break;
341 case 2:
342 config = PB_FAN_1_RPM;
343 rate = pmbus_get_fan_rate_cached(client, page, id: 0, mode: 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, command: 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, config: 0,
367 PB_FAN_1_RPM,
368 command: max31785_scale_pwm(sensor_val: 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 command: PMBUS_PAGE, data: i);
450 if (ret < 0)
451 return ret;
452
453 ret = max31785_i2c_read_word_data(client, driver_data,
454 command: 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(adap: client->adapter,
479 I2C_FUNC_SMBUS_BYTE_DATA |
480 I2C_FUNC_SMBUS_WORD_DATA))
481 return -ENODEV;
482
483 driver_data = devm_kzalloc(dev, size: 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 command: PMBUS_PAGE, data: 255);
493 if (ret < 0)
494 return ret;
495
496 ret = i2c_smbus_read_word_data(client, command: 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

source code of linux/drivers/hwmon/pmbus/max31785.c