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 */
max31785_wait(const struct max31785_data * data)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
max31785_i2c_write_byte_data(struct i2c_client * client,struct max31785_data * driver_data,int command,u16 data)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
max31785_i2c_read_word_data(struct i2c_client * client,struct max31785_data * driver_data,int command)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
_max31785_read_byte_data(struct i2c_client * client,struct max31785_data * driver_data,int page,int command)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
_max31785_write_byte_data(struct i2c_client * client,struct max31785_data * driver_data,int page,int command,u16 data)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
_max31785_read_word_data(struct i2c_client * client,struct max31785_data * driver_data,int page,int phase,int command)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
_max31785_write_word_data(struct i2c_client * client,struct max31785_data * driver_data,int page,int command,u16 data)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
max31785_read_byte_data(struct i2c_client * client,int page,int reg)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
max31785_write_byte(struct i2c_client * client,int page,u8 value)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
max31785_read_long_data(struct i2c_client * client,int page,int reg,u32 * data)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
max31785_get_pwm(struct i2c_client * client,int page)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
max31785_get_pwm_mode(struct i2c_client * client,struct max31785_data * driver_data,int page)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
max31785_read_word_data(struct i2c_client * client,int page,int phase,int reg)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
max31785_scale_pwm(u32 sensor_val)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
max31785_update_fan(struct i2c_client * client,struct max31785_data * driver_data,int page,u8 config,u8 mask,u16 command)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
max31785_pwm_enable(struct i2c_client * client,struct max31785_data * driver_data,int page,u16 word)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
max31785_write_word_data(struct i2c_client * client,int page,int reg,u16 word)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
max31785_configure_dual_tach(struct i2c_client * client,struct pmbus_driver_info * info)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
max31785_probe(struct i2c_client * client)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