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(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 | |
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(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 | |
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(data: 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(data: driver_data); |
87 | rc = pmbus_read_byte_data(client, page, reg: 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(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 | |
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(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 | |
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(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 | |
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: page - MAX31785_NR_PAGES, |
139 | command: 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, 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 | |
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, 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 | |
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 | 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 | |
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: 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 | |
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 | 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 | |
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, 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 | |
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, 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 | |
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 | 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 | |
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(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 | |
520 | static const struct i2c_device_id max31785_id[] = { |
521 | { "max31785" , 0 }, |
522 | { "max31785a" , 0 }, |
523 | { "max31785b" , 0 }, |
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 | |