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