2 * Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880,
5 * Copyright (c) 2011 Ericsson AB.
6 * Copyright (c) 2013, 2014 Guenter Roeck
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.
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.
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>
27 enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
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
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
41 #define LTC2974_MFR_IOUT_PEAK 0xd7
42 #define LTC2974_MFR_IOUT_MIN 0xd8
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
50 #define LTC3883_MFR_IIN_PEAK 0xe1
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
65 #define LTC2974_NUM_PAGES 4
66 #define LTC2978_NUM_PAGES 8
67 #define LTC3880_NUM_PAGES 2
68 #define LTC3883_NUM_PAGES 1
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.
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];
86 struct pmbus_driver_info info;
89 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
91 static inline int lin11_to_val(int data)
93 s16 e = ((s16)data) >> 11;
94 s32 m = (((s16)(data << 5)) >> 5);
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).
101 return (e < 0 ? m >> -e : m << e);
104 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
107 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
108 struct ltc2978_data *data = to_ltc2978_data(info);
112 case PMBUS_VIRT_READ_VIN_MAX:
113 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
115 if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
120 case PMBUS_VIRT_READ_VOUT_MAX:
121 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
124 * VOUT is 16 bit unsigned with fixed exponent,
125 * so we can compare it directly
127 if (ret > data->vout_max[page])
128 data->vout_max[page] = ret;
129 ret = data->vout_max[page];
132 case PMBUS_VIRT_READ_TEMP_MAX:
133 ret = pmbus_read_word_data(client, page,
134 LTC2978_MFR_TEMPERATURE_PEAK);
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];
142 case PMBUS_VIRT_RESET_VOUT_HISTORY:
143 case PMBUS_VIRT_RESET_VIN_HISTORY:
144 case PMBUS_VIRT_RESET_TEMP_HISTORY:
154 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
156 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
157 struct ltc2978_data *data = to_ltc2978_data(info);
161 case PMBUS_VIRT_READ_VIN_MIN:
162 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
164 if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
169 case PMBUS_VIRT_READ_VOUT_MIN:
170 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
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.
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];
185 case PMBUS_VIRT_READ_TEMP_MIN:
186 ret = pmbus_read_word_data(client, page,
187 LTC2978_MFR_TEMPERATURE_MIN);
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];
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:
202 ret = ltc2978_read_word_data_common(client, page, reg);
208 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
210 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
211 struct ltc2978_data *data = to_ltc2978_data(info);
215 case PMBUS_VIRT_READ_IOUT_MAX:
216 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
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];
224 case PMBUS_VIRT_READ_IOUT_MIN:
225 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
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];
233 case PMBUS_VIRT_RESET_IOUT_HISTORY:
237 ret = ltc2978_read_word_data(client, page, reg);
243 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
245 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
246 struct ltc2978_data *data = to_ltc2978_data(info);
250 case PMBUS_VIRT_READ_IOUT_MAX:
251 ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
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];
259 case PMBUS_VIRT_READ_TEMP2_MAX:
260 ret = pmbus_read_word_data(client, page,
261 LTC3880_MFR_TEMPERATURE2_PEAK);
263 if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
264 data->temp2_max = ret;
265 ret = data->temp2_max;
268 case PMBUS_VIRT_READ_VIN_MIN:
269 case PMBUS_VIRT_READ_VOUT_MIN:
270 case PMBUS_VIRT_READ_TEMP_MIN:
273 case PMBUS_VIRT_RESET_IOUT_HISTORY:
274 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
278 ret = ltc2978_read_word_data_common(client, page, reg);
284 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
286 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
287 struct ltc2978_data *data = to_ltc2978_data(info);
291 case PMBUS_VIRT_READ_IIN_MAX:
292 ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
294 if (lin11_to_val(ret)
295 > lin11_to_val(data->iin_max))
300 case PMBUS_VIRT_RESET_IIN_HISTORY:
304 ret = ltc3880_read_word_data(client, page, reg);
310 static int ltc2978_clear_peaks(struct i2c_client *client, int page,
315 if (id == ltc3880 || id == ltc3883)
316 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
318 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
323 static int ltc2978_write_word_data(struct i2c_client *client, int page,
326 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
327 struct ltc2978_data *data = to_ltc2978_data(info);
331 case PMBUS_VIRT_RESET_IIN_HISTORY:
332 data->iin_max = 0x7c00;
333 ret = ltc2978_clear_peaks(client, page, data->id);
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);
340 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
341 data->temp2_max = 0x7c00;
342 ret = ltc2978_clear_peaks(client, page, data->id);
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);
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);
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);
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},
375 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
377 static int ltc2978_probe(struct i2c_client *client,
378 const struct i2c_device_id *id)
381 struct ltc2978_data *data;
382 struct pmbus_driver_info *info;
384 if (!i2c_check_functionality(client->adapter,
385 I2C_FUNC_SMBUS_READ_WORD_DATA))
388 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
393 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
397 if (chip_id == LTC2974_ID_REV1 || chip_id == LTC2974_ID_REV2) {
399 } else if (chip_id == LTC2977_ID) {
401 } else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2 ||
402 chip_id == LTC2978A_ID) {
404 } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
406 } else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
408 } else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
411 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
414 if (data->id != id->driver_data)
415 dev_warn(&client->dev,
416 "Device mismatch: Configured %s, detected %s\n",
418 ltc2978_id[data->id].name);
421 info->write_word_data = ltc2978_write_word_data;
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;
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
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;
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;
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
475 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
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;
490 return pmbus_do_probe(client, id, info);
493 /* This is the driver that will be inserted */
494 static struct i2c_driver ltc2978_driver = {
498 .probe = ltc2978_probe,
499 .remove = pmbus_do_remove,
500 .id_table = ltc2978_id,
503 module_i2c_driver(ltc2978_driver);
505 MODULE_AUTHOR("Guenter Roeck");
506 MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
507 MODULE_LICENSE("GPL");