Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2017 IBM Corp.
4 */
5
6#include <linux/kernel.h>
7#include <linux/module.h>
8#include <linux/init.h>
9#include <linux/err.h>
10#include <linux/i2c.h>
11#include "pmbus.h"
12
13enum max31785_regs {
14 MFR_REVISION = 0x9b,
15 MFR_FAN_CONFIG = 0xf1,
16};
17
18#define MAX31785 0x3030
19#define MAX31785A 0x3040
20#define MAX31785B 0x3061
21
22#define MFR_FAN_CONFIG_DUAL_TACH BIT(12)
23
24#define MAX31785_NR_PAGES 23
25#define MAX31785_NR_FAN_PAGES 6
26
27static int max31785_read_byte_data(struct i2c_client *client, int page,
28 int reg)
29{
30 if (page < MAX31785_NR_PAGES)
31 return -ENODATA;
32
33 switch (reg) {
34 case PMBUS_VOUT_MODE:
35 return -ENOTSUPP;
36 case PMBUS_FAN_CONFIG_12:
37 return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES,
38 reg);
39 }
40
41 return -ENODATA;
42}
43
44static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
45{
46 if (page < MAX31785_NR_PAGES)
47 return -ENODATA;
48
49 return -ENOTSUPP;
50}
51
52static int max31785_read_long_data(struct i2c_client *client, int page,
53 int reg, u32 *data)
54{
55 unsigned char cmdbuf[1];
56 unsigned char rspbuf[4];
57 int rc;
58
59 struct i2c_msg msg[2] = {
60 {
61 .addr = client->addr,
62 .flags = 0,
63 .len = sizeof(cmdbuf),
64 .buf = cmdbuf,
65 },
66 {
67 .addr = client->addr,
68 .flags = I2C_M_RD,
69 .len = sizeof(rspbuf),
70 .buf = rspbuf,
71 },
72 };
73
74 cmdbuf[0] = reg;
75
76 rc = pmbus_set_page(client, page, 0xff);
77 if (rc < 0)
78 return rc;
79
80 rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
81 if (rc < 0)
82 return rc;
83
84 *data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |
85 (rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));
86
87 return rc;
88}
89
90static int max31785_get_pwm(struct i2c_client *client, int page)
91{
92 int rv;
93
94 rv = pmbus_get_fan_rate_device(client, page, 0, percent);
95 if (rv < 0)
96 return rv;
97 else if (rv >= 0x8000)
98 return 0;
99 else if (rv >= 0x2711)
100 return 0x2710;
101
102 return rv;
103}
104
105static int max31785_get_pwm_mode(struct i2c_client *client, int page)
106{
107 int config;
108 int command;
109
110 config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12);
111 if (config < 0)
112 return config;
113
114 command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1);
115 if (command < 0)
116 return command;
117
118 if (config & PB_FAN_1_RPM)
119 return (command >= 0x8000) ? 3 : 2;
120
121 if (command >= 0x8000)
122 return 3;
123 else if (command >= 0x2711)
124 return 0;
125
126 return 1;
127}
128
129static int max31785_read_word_data(struct i2c_client *client, int page,
130 int phase, int reg)
131{
132 u32 val;
133 int rv;
134
135 switch (reg) {
136 case PMBUS_READ_FAN_SPEED_1:
137 if (page < MAX31785_NR_PAGES)
138 return -ENODATA;
139
140 rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
141 reg, &val);
142 if (rv < 0)
143 return rv;
144
145 rv = (val >> 16) & 0xffff;
146 break;
147 case PMBUS_FAN_COMMAND_1:
148 /*
149 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to
150 * expose fan control registers.
151 *
152 * Don't expose fan_target attribute for virtual pages.
153 */
154 rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
155 break;
156 case PMBUS_VIRT_PWM_1:
157 rv = max31785_get_pwm(client, page);
158 break;
159 case PMBUS_VIRT_PWM_ENABLE_1:
160 rv = max31785_get_pwm_mode(client, page);
161 break;
162 default:
163 rv = -ENODATA;
164 break;
165 }
166
167 return rv;
168}
169
170static inline u32 max31785_scale_pwm(u32 sensor_val)
171{
172 /*
173 * The datasheet describes the accepted value range for manual PWM as
174 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
175 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
176 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The
177 * important observation here is that 0x2710 == 10000 == 100 * 100.
178 *
179 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the
180 * sysfs interface into the required hardware resolution, but it does
181 * not yet yield a value that we can write to the device (this initial
182 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below
183 * translates the parameter value into the percentage units required by
184 * PMBus, and then we scale back by 255 as required by the hwmon pwmX
185 * interface to yield the percentage value at the appropriate
186 * resolution for hardware.
187 */
188 return (sensor_val * 100) / 255;
189}
190
191static int max31785_pwm_enable(struct i2c_client *client, int page,
192 u16 word)
193{
194 int config = 0;
195 int rate;
196
197 switch (word) {
198 case 0:
199 rate = 0x7fff;
200 break;
201 case 1:
202 rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
203 if (rate < 0)
204 return rate;
205 rate = max31785_scale_pwm(rate);
206 break;
207 case 2:
208 config = PB_FAN_1_RPM;
209 rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
210 if (rate < 0)
211 return rate;
212 break;
213 case 3:
214 rate = 0xffff;
215 break;
216 default:
217 return -EINVAL;
218 }
219
220 return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate);
221}
222
223static int max31785_write_word_data(struct i2c_client *client, int page,
224 int reg, u16 word)
225{
226 switch (reg) {
227 case PMBUS_VIRT_PWM_1:
228 return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM,
229 max31785_scale_pwm(word));
230 case PMBUS_VIRT_PWM_ENABLE_1:
231 return max31785_pwm_enable(client, page, word);
232 default:
233 break;
234 }
235
236 return -ENODATA;
237}
238
239#define MAX31785_FAN_FUNCS \
240 (PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)
241
242#define MAX31785_TEMP_FUNCS \
243 (PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)
244
245#define MAX31785_VOUT_FUNCS \
246 (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)
247
248static const struct pmbus_driver_info max31785_info = {
249 .pages = MAX31785_NR_PAGES,
250
251 .write_word_data = max31785_write_word_data,
252 .read_byte_data = max31785_read_byte_data,
253 .read_word_data = max31785_read_word_data,
254 .write_byte = max31785_write_byte,
255
256 /* RPM */
257 .format[PSC_FAN] = direct,
258 .m[PSC_FAN] = 1,
259 .b[PSC_FAN] = 0,
260 .R[PSC_FAN] = 0,
261 /* PWM */
262 .format[PSC_PWM] = direct,
263 .m[PSC_PWM] = 1,
264 .b[PSC_PWM] = 0,
265 .R[PSC_PWM] = 2,
266 .func[0] = MAX31785_FAN_FUNCS,
267 .func[1] = MAX31785_FAN_FUNCS,
268 .func[2] = MAX31785_FAN_FUNCS,
269 .func[3] = MAX31785_FAN_FUNCS,
270 .func[4] = MAX31785_FAN_FUNCS,
271 .func[5] = MAX31785_FAN_FUNCS,
272
273 .format[PSC_TEMPERATURE] = direct,
274 .m[PSC_TEMPERATURE] = 1,
275 .b[PSC_TEMPERATURE] = 0,
276 .R[PSC_TEMPERATURE] = 2,
277 .func[6] = MAX31785_TEMP_FUNCS,
278 .func[7] = MAX31785_TEMP_FUNCS,
279 .func[8] = MAX31785_TEMP_FUNCS,
280 .func[9] = MAX31785_TEMP_FUNCS,
281 .func[10] = MAX31785_TEMP_FUNCS,
282 .func[11] = MAX31785_TEMP_FUNCS,
283 .func[12] = MAX31785_TEMP_FUNCS,
284 .func[13] = MAX31785_TEMP_FUNCS,
285 .func[14] = MAX31785_TEMP_FUNCS,
286 .func[15] = MAX31785_TEMP_FUNCS,
287 .func[16] = MAX31785_TEMP_FUNCS,
288
289 .format[PSC_VOLTAGE_OUT] = direct,
290 .m[PSC_VOLTAGE_OUT] = 1,
291 .b[PSC_VOLTAGE_OUT] = 0,
292 .R[PSC_VOLTAGE_OUT] = 0,
293 .func[17] = MAX31785_VOUT_FUNCS,
294 .func[18] = MAX31785_VOUT_FUNCS,
295 .func[19] = MAX31785_VOUT_FUNCS,
296 .func[20] = MAX31785_VOUT_FUNCS,
297 .func[21] = MAX31785_VOUT_FUNCS,
298 .func[22] = MAX31785_VOUT_FUNCS,
299};
300
301static int max31785_configure_dual_tach(struct i2c_client *client,
302 struct pmbus_driver_info *info)
303{
304 int ret;
305 int i;
306
307 for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
308 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
309 if (ret < 0)
310 return ret;
311
312 ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG);
313 if (ret < 0)
314 return ret;
315
316 if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
317 int virtual = MAX31785_NR_PAGES + i;
318
319 info->pages = virtual + 1;
320 info->func[virtual] |= PMBUS_HAVE_FAN12;
321 info->func[virtual] |= PMBUS_PAGE_VIRTUAL;
322 }
323 }
324
325 return 0;
326}
327
328static int max31785_probe(struct i2c_client *client)
329{
330 struct device *dev = &client->dev;
331 struct pmbus_driver_info *info;
332 bool dual_tach = false;
333 int ret;
334
335 if (!i2c_check_functionality(client->adapter,
336 I2C_FUNC_SMBUS_BYTE_DATA |
337 I2C_FUNC_SMBUS_WORD_DATA))
338 return -ENODEV;
339
340 info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
341 if (!info)
342 return -ENOMEM;
343
344 *info = max31785_info;
345
346 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255);
347 if (ret < 0)
348 return ret;
349
350 ret = i2c_smbus_read_word_data(client, MFR_REVISION);
351 if (ret < 0)
352 return ret;
353
354 if (ret == MAX31785A || ret == MAX31785B) {
355 dual_tach = true;
356 } else if (ret == MAX31785) {
357 if (!strcmp("max31785a", client->name) ||
358 !strcmp("max31785b", client->name))
359 dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
360 } else {
361 dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
362 return -ENODEV;
363 }
364
365 if (dual_tach) {
366 ret = max31785_configure_dual_tach(client, info);
367 if (ret < 0)
368 return ret;
369 }
370
371 return pmbus_do_probe(client, info);
372}
373
374static const struct i2c_device_id max31785_id[] = {
375 { "max31785", 0 },
376 { "max31785a", 0 },
377 { "max31785b", 0 },
378 { },
379};
380
381MODULE_DEVICE_TABLE(i2c, max31785_id);
382
383static const struct of_device_id max31785_of_match[] = {
384 { .compatible = "maxim,max31785" },
385 { .compatible = "maxim,max31785a" },
386 { .compatible = "maxim,max31785b" },
387 { },
388};
389
390MODULE_DEVICE_TABLE(of, max31785_of_match);
391
392static struct i2c_driver max31785_driver = {
393 .driver = {
394 .name = "max31785",
395 .of_match_table = max31785_of_match,
396 },
397 .probe_new = max31785_probe,
398 .id_table = max31785_id,
399};
400
401module_i2c_driver(max31785_driver);
402
403MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
404MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
405MODULE_LICENSE("GPL");
406MODULE_IMPORT_NS(PMBUS);