1 /*
2 * Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880,
3 * LTC3883, and LTM4676
4 *
5 * Copyright (c) 2011 Ericsson AB.
6 * Copyright (c) 2013, 2014 Guenter Roeck
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/err.h>
23 #include <linux/slab.h>
24 #include <linux/i2c.h>
25 #include "pmbus.h"
26
27 enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
28
29 /* Common for all chips */
30 #define LTC2978_MFR_VOUT_PEAK 0xdd
31 #define LTC2978_MFR_VIN_PEAK 0xde
32 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf
33 #define LTC2978_MFR_SPECIAL_ID 0xe7
34
35 /* LTC2974, LCT2977, and LTC2978 */
36 #define LTC2978_MFR_VOUT_MIN 0xfb
37 #define LTC2978_MFR_VIN_MIN 0xfc
38 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
39
40 /* LTC2974 only */
41 #define LTC2974_MFR_IOUT_PEAK 0xd7
42 #define LTC2974_MFR_IOUT_MIN 0xd8
43
44 /* LTC3880, LTC3883, and LTM4676 */
45 #define LTC3880_MFR_IOUT_PEAK 0xd7
46 #define LTC3880_MFR_CLEAR_PEAKS 0xe3
47 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4
48
49 /* LTC3883 only */
50 #define LTC3883_MFR_IIN_PEAK 0xe1
51
52 #define LTC2974_ID_REV1 0x0212
53 #define LTC2974_ID_REV2 0x0213
54 #define LTC2977_ID 0x0130
55 #define LTC2978_ID_REV1 0x0121
56 #define LTC2978_ID_REV2 0x0122
57 #define LTC2978A_ID 0x0124
58 #define LTC3880_ID 0x4000
59 #define LTC3880_ID_MASK 0xff00
60 #define LTC3883_ID 0x4300
61 #define LTC3883_ID_MASK 0xff00
62 #define LTM4676_ID 0x4480 /* datasheet claims 0x440X */
63 #define LTM4676_ID_MASK 0xfff0
64
65 #define LTC2974_NUM_PAGES 4
66 #define LTC2978_NUM_PAGES 8
67 #define LTC3880_NUM_PAGES 2
68 #define LTC3883_NUM_PAGES 1
69
70 /*
71 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
72 * happens pretty much each time chip data is updated. Raw peak data therefore
73 * does not provide much value. To be able to provide useful peak data, keep an
74 * internal cache of measured peak data, which is only cleared if an explicit
75 * "clear peak" command is executed for the sensor in question.
76 */
77
78 struct ltc2978_data {
79 enum chips id;
80 u16 vin_min, vin_max;
81 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
82 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
83 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
84 u16 iin_max;
85 u16 temp2_max;
86 struct pmbus_driver_info info;
87 };
88
89 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
90
lin11_to_val(int data)91 static inline int lin11_to_val(int data)
92 {
93 s16 e = ((s16)data) >> 11;
94 s32 m = (((s16)(data << 5)) >> 5);
95
96 /*
97 * mantissa is 10 bit + sign, exponent adds up to 15 bit.
98 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
99 */
100 e += 6;
101 return (e < 0 ? m >> -e : m << e);
102 }
103
ltc2978_read_word_data_common(struct i2c_client * client,int page,int reg)104 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
105 int reg)
106 {
107 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
108 struct ltc2978_data *data = to_ltc2978_data(info);
109 int ret;
110
111 switch (reg) {
112 case PMBUS_VIRT_READ_VIN_MAX:
113 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
114 if (ret >= 0) {
115 if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
116 data->vin_max = ret;
117 ret = data->vin_max;
118 }
119 break;
120 case PMBUS_VIRT_READ_VOUT_MAX:
121 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
122 if (ret >= 0) {
123 /*
124 * VOUT is 16 bit unsigned with fixed exponent,
125 * so we can compare it directly
126 */
127 if (ret > data->vout_max[page])
128 data->vout_max[page] = ret;
129 ret = data->vout_max[page];
130 }
131 break;
132 case PMBUS_VIRT_READ_TEMP_MAX:
133 ret = pmbus_read_word_data(client, page,
134 LTC2978_MFR_TEMPERATURE_PEAK);
135 if (ret >= 0) {
136 if (lin11_to_val(ret)
137 > lin11_to_val(data->temp_max[page]))
138 data->temp_max[page] = ret;
139 ret = data->temp_max[page];
140 }
141 break;
142 case PMBUS_VIRT_RESET_VOUT_HISTORY:
143 case PMBUS_VIRT_RESET_VIN_HISTORY:
144 case PMBUS_VIRT_RESET_TEMP_HISTORY:
145 ret = 0;
146 break;
147 default:
148 ret = -ENODATA;
149 break;
150 }
151 return ret;
152 }
153
ltc2978_read_word_data(struct i2c_client * client,int page,int reg)154 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
155 {
156 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
157 struct ltc2978_data *data = to_ltc2978_data(info);
158 int ret;
159
160 switch (reg) {
161 case PMBUS_VIRT_READ_VIN_MIN:
162 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
163 if (ret >= 0) {
164 if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
165 data->vin_min = ret;
166 ret = data->vin_min;
167 }
168 break;
169 case PMBUS_VIRT_READ_VOUT_MIN:
170 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
171 if (ret >= 0) {
172 /*
173 * VOUT_MIN is known to not be supported on some lots
174 * of LTC2978 revision 1, and will return the maximum
175 * possible voltage if read. If VOUT_MAX is valid and
176 * lower than the reading of VOUT_MIN, use it instead.
177 */
178 if (data->vout_max[page] && ret > data->vout_max[page])
179 ret = data->vout_max[page];
180 if (ret < data->vout_min[page])
181 data->vout_min[page] = ret;
182 ret = data->vout_min[page];
183 }
184 break;
185 case PMBUS_VIRT_READ_TEMP_MIN:
186 ret = pmbus_read_word_data(client, page,
187 LTC2978_MFR_TEMPERATURE_MIN);
188 if (ret >= 0) {
189 if (lin11_to_val(ret)
190 < lin11_to_val(data->temp_min[page]))
191 data->temp_min[page] = ret;
192 ret = data->temp_min[page];
193 }
194 break;
195 case PMBUS_VIRT_READ_IOUT_MAX:
196 case PMBUS_VIRT_RESET_IOUT_HISTORY:
197 case PMBUS_VIRT_READ_TEMP2_MAX:
198 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
199 ret = -ENXIO;
200 break;
201 default:
202 ret = ltc2978_read_word_data_common(client, page, reg);
203 break;
204 }
205 return ret;
206 }
207
ltc2974_read_word_data(struct i2c_client * client,int page,int reg)208 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
209 {
210 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
211 struct ltc2978_data *data = to_ltc2978_data(info);
212 int ret;
213
214 switch (reg) {
215 case PMBUS_VIRT_READ_IOUT_MAX:
216 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
217 if (ret >= 0) {
218 if (lin11_to_val(ret)
219 > lin11_to_val(data->iout_max[page]))
220 data->iout_max[page] = ret;
221 ret = data->iout_max[page];
222 }
223 break;
224 case PMBUS_VIRT_READ_IOUT_MIN:
225 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
226 if (ret >= 0) {
227 if (lin11_to_val(ret)
228 < lin11_to_val(data->iout_min[page]))
229 data->iout_min[page] = ret;
230 ret = data->iout_min[page];
231 }
232 break;
233 case PMBUS_VIRT_RESET_IOUT_HISTORY:
234 ret = 0;
235 break;
236 default:
237 ret = ltc2978_read_word_data(client, page, reg);
238 break;
239 }
240 return ret;
241 }
242
ltc3880_read_word_data(struct i2c_client * client,int page,int reg)243 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
244 {
245 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
246 struct ltc2978_data *data = to_ltc2978_data(info);
247 int ret;
248
249 switch (reg) {
250 case PMBUS_VIRT_READ_IOUT_MAX:
251 ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
252 if (ret >= 0) {
253 if (lin11_to_val(ret)
254 > lin11_to_val(data->iout_max[page]))
255 data->iout_max[page] = ret;
256 ret = data->iout_max[page];
257 }
258 break;
259 case PMBUS_VIRT_READ_TEMP2_MAX:
260 ret = pmbus_read_word_data(client, page,
261 LTC3880_MFR_TEMPERATURE2_PEAK);
262 if (ret >= 0) {
263 if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
264 data->temp2_max = ret;
265 ret = data->temp2_max;
266 }
267 break;
268 case PMBUS_VIRT_READ_VIN_MIN:
269 case PMBUS_VIRT_READ_VOUT_MIN:
270 case PMBUS_VIRT_READ_TEMP_MIN:
271 ret = -ENXIO;
272 break;
273 case PMBUS_VIRT_RESET_IOUT_HISTORY:
274 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
275 ret = 0;
276 break;
277 default:
278 ret = ltc2978_read_word_data_common(client, page, reg);
279 break;
280 }
281 return ret;
282 }
283
ltc3883_read_word_data(struct i2c_client * client,int page,int reg)284 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
285 {
286 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
287 struct ltc2978_data *data = to_ltc2978_data(info);
288 int ret;
289
290 switch (reg) {
291 case PMBUS_VIRT_READ_IIN_MAX:
292 ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
293 if (ret >= 0) {
294 if (lin11_to_val(ret)
295 > lin11_to_val(data->iin_max))
296 data->iin_max = ret;
297 ret = data->iin_max;
298 }
299 break;
300 case PMBUS_VIRT_RESET_IIN_HISTORY:
301 ret = 0;
302 break;
303 default:
304 ret = ltc3880_read_word_data(client, page, reg);
305 break;
306 }
307 return ret;
308 }
309
ltc2978_clear_peaks(struct i2c_client * client,int page,enum chips id)310 static int ltc2978_clear_peaks(struct i2c_client *client, int page,
311 enum chips id)
312 {
313 int ret;
314
315 if (id == ltc3880 || id == ltc3883)
316 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
317 else
318 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
319
320 return ret;
321 }
322
ltc2978_write_word_data(struct i2c_client * client,int page,int reg,u16 word)323 static int ltc2978_write_word_data(struct i2c_client *client, int page,
324 int reg, u16 word)
325 {
326 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
327 struct ltc2978_data *data = to_ltc2978_data(info);
328 int ret;
329
330 switch (reg) {
331 case PMBUS_VIRT_RESET_IIN_HISTORY:
332 data->iin_max = 0x7c00;
333 ret = ltc2978_clear_peaks(client, page, data->id);
334 break;
335 case PMBUS_VIRT_RESET_IOUT_HISTORY:
336 data->iout_max[page] = 0x7c00;
337 data->iout_min[page] = 0xfbff;
338 ret = ltc2978_clear_peaks(client, page, data->id);
339 break;
340 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
341 data->temp2_max = 0x7c00;
342 ret = ltc2978_clear_peaks(client, page, data->id);
343 break;
344 case PMBUS_VIRT_RESET_VOUT_HISTORY:
345 data->vout_min[page] = 0xffff;
346 data->vout_max[page] = 0;
347 ret = ltc2978_clear_peaks(client, page, data->id);
348 break;
349 case PMBUS_VIRT_RESET_VIN_HISTORY:
350 data->vin_min = 0x7bff;
351 data->vin_max = 0x7c00;
352 ret = ltc2978_clear_peaks(client, page, data->id);
353 break;
354 case PMBUS_VIRT_RESET_TEMP_HISTORY:
355 data->temp_min[page] = 0x7bff;
356 data->temp_max[page] = 0x7c00;
357 ret = ltc2978_clear_peaks(client, page, data->id);
358 break;
359 default:
360 ret = -ENODATA;
361 break;
362 }
363 return ret;
364 }
365
366 static const struct i2c_device_id ltc2978_id[] = {
367 {"ltc2974", ltc2974},
368 {"ltc2977", ltc2977},
369 {"ltc2978", ltc2978},
370 {"ltc3880", ltc3880},
371 {"ltc3883", ltc3883},
372 {"ltm4676", ltm4676},
373 {}
374 };
375 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
376
ltc2978_probe(struct i2c_client * client,const struct i2c_device_id * id)377 static int ltc2978_probe(struct i2c_client *client,
378 const struct i2c_device_id *id)
379 {
380 int chip_id, i;
381 struct ltc2978_data *data;
382 struct pmbus_driver_info *info;
383
384 if (!i2c_check_functionality(client->adapter,
385 I2C_FUNC_SMBUS_READ_WORD_DATA))
386 return -ENODEV;
387
388 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
389 GFP_KERNEL);
390 if (!data)
391 return -ENOMEM;
392
393 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
394 if (chip_id < 0)
395 return chip_id;
396
397 if (chip_id == LTC2974_ID_REV1 || chip_id == LTC2974_ID_REV2) {
398 data->id = ltc2974;
399 } else if (chip_id == LTC2977_ID) {
400 data->id = ltc2977;
401 } else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2 ||
402 chip_id == LTC2978A_ID) {
403 data->id = ltc2978;
404 } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
405 data->id = ltc3880;
406 } else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
407 data->id = ltc3883;
408 } else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
409 data->id = ltm4676;
410 } else {
411 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
412 return -ENODEV;
413 }
414 if (data->id != id->driver_data)
415 dev_warn(&client->dev,
416 "Device mismatch: Configured %s, detected %s\n",
417 id->name,
418 ltc2978_id[data->id].name);
419
420 info = &data->info;
421 info->write_word_data = ltc2978_write_word_data;
422
423 data->vin_min = 0x7bff;
424 data->vin_max = 0x7c00;
425 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
426 data->vout_min[i] = 0xffff;
427 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
428 data->iout_min[i] = 0xfbff;
429 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
430 data->iout_max[i] = 0x7c00;
431 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
432 data->temp_min[i] = 0x7bff;
433 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
434 data->temp_max[i] = 0x7c00;
435 data->temp2_max = 0x7c00;
436
437 switch (data->id) {
438 case ltc2974:
439 info->read_word_data = ltc2974_read_word_data;
440 info->pages = LTC2974_NUM_PAGES;
441 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
442 | PMBUS_HAVE_TEMP2;
443 for (i = 0; i < info->pages; i++) {
444 info->func[i] |= PMBUS_HAVE_VOUT
445 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
446 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
447 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
448 }
449 break;
450 case ltc2977:
451 case ltc2978:
452 info->read_word_data = ltc2978_read_word_data;
453 info->pages = LTC2978_NUM_PAGES;
454 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
455 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
456 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
457 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
458 info->func[i] = PMBUS_HAVE_VOUT
459 | PMBUS_HAVE_STATUS_VOUT;
460 }
461 break;
462 case ltc3880:
463 case ltm4676:
464 info->read_word_data = ltc3880_read_word_data;
465 info->pages = LTC3880_NUM_PAGES;
466 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
467 | PMBUS_HAVE_STATUS_INPUT
468 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
469 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
470 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
471 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
472 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
473 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
474 | PMBUS_HAVE_POUT
475 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
476 break;
477 case ltc3883:
478 info->read_word_data = ltc3883_read_word_data;
479 info->pages = LTC3883_NUM_PAGES;
480 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
481 | PMBUS_HAVE_STATUS_INPUT
482 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
483 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
484 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
485 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
486 break;
487 default:
488 return -ENODEV;
489 }
490 return pmbus_do_probe(client, id, info);
491 }
492
493 /* This is the driver that will be inserted */
494 static struct i2c_driver ltc2978_driver = {
495 .driver = {
496 .name = "ltc2978",
497 },
498 .probe = ltc2978_probe,
499 .remove = pmbus_do_remove,
500 .id_table = ltc2978_id,
501 };
502
503 module_i2c_driver(ltc2978_driver);
504
505 MODULE_AUTHOR("Guenter Roeck");
506 MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
507 MODULE_LICENSE("GPL");
508