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>
25 #include <linux/regulator/driver.h>
28 enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883, ltm4676 };
30 /* Common for all chips */
31 #define LTC2978_MFR_VOUT_PEAK 0xdd
32 #define LTC2978_MFR_VIN_PEAK 0xde
33 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf
34 #define LTC2978_MFR_SPECIAL_ID 0xe7
36 /* LTC2974, LCT2977, and LTC2978 */
37 #define LTC2978_MFR_VOUT_MIN 0xfb
38 #define LTC2978_MFR_VIN_MIN 0xfc
39 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
42 #define LTC2974_MFR_IOUT_PEAK 0xd7
43 #define LTC2974_MFR_IOUT_MIN 0xd8
45 /* LTC3880, LTC3883, and LTM4676 */
46 #define LTC3880_MFR_IOUT_PEAK 0xd7
47 #define LTC3880_MFR_CLEAR_PEAKS 0xe3
48 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4
51 #define LTC3883_MFR_IIN_PEAK 0xe1
53 #define LTC2974_ID_REV1 0x0212
54 #define LTC2974_ID_REV2 0x0213
55 #define LTC2977_ID 0x0130
56 #define LTC2978_ID_REV1 0x0121
57 #define LTC2978_ID_REV2 0x0122
58 #define LTC2978A_ID 0x0124
59 #define LTC3880_ID 0x4000
60 #define LTC3880_ID_MASK 0xff00
61 #define LTC3883_ID 0x4300
62 #define LTC3883_ID_MASK 0xff00
63 #define LTM4676_ID 0x4480 /* datasheet claims 0x440X */
64 #define LTM4676_ID_MASK 0xfff0
66 #define LTC2974_NUM_PAGES 4
67 #define LTC2978_NUM_PAGES 8
68 #define LTC3880_NUM_PAGES 2
69 #define LTC3883_NUM_PAGES 1
72 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
73 * happens pretty much each time chip data is updated. Raw peak data therefore
74 * does not provide much value. To be able to provide useful peak data, keep an
75 * internal cache of measured peak data, which is only cleared if an explicit
76 * "clear peak" command is executed for the sensor in question.
82 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
83 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
84 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
87 struct pmbus_driver_info info;
90 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
92 static inline int lin11_to_val(int data)
94 s16 e = ((s16)data) >> 11;
95 s32 m = (((s16)(data << 5)) >> 5);
98 * mantissa is 10 bit + sign, exponent adds up to 15 bit.
99 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
102 return (e < 0 ? m >> -e : m << e);
105 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
108 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
109 struct ltc2978_data *data = to_ltc2978_data(info);
113 case PMBUS_VIRT_READ_VIN_MAX:
114 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
116 if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
121 case PMBUS_VIRT_READ_VOUT_MAX:
122 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
125 * VOUT is 16 bit unsigned with fixed exponent,
126 * so we can compare it directly
128 if (ret > data->vout_max[page])
129 data->vout_max[page] = ret;
130 ret = data->vout_max[page];
133 case PMBUS_VIRT_READ_TEMP_MAX:
134 ret = pmbus_read_word_data(client, page,
135 LTC2978_MFR_TEMPERATURE_PEAK);
137 if (lin11_to_val(ret)
138 > lin11_to_val(data->temp_max[page]))
139 data->temp_max[page] = ret;
140 ret = data->temp_max[page];
143 case PMBUS_VIRT_RESET_VOUT_HISTORY:
144 case PMBUS_VIRT_RESET_VIN_HISTORY:
145 case PMBUS_VIRT_RESET_TEMP_HISTORY:
155 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
157 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
158 struct ltc2978_data *data = to_ltc2978_data(info);
162 case PMBUS_VIRT_READ_VIN_MIN:
163 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
165 if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
170 case PMBUS_VIRT_READ_VOUT_MIN:
171 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
174 * VOUT_MIN is known to not be supported on some lots
175 * of LTC2978 revision 1, and will return the maximum
176 * possible voltage if read. If VOUT_MAX is valid and
177 * lower than the reading of VOUT_MIN, use it instead.
179 if (data->vout_max[page] && ret > data->vout_max[page])
180 ret = data->vout_max[page];
181 if (ret < data->vout_min[page])
182 data->vout_min[page] = ret;
183 ret = data->vout_min[page];
186 case PMBUS_VIRT_READ_TEMP_MIN:
187 ret = pmbus_read_word_data(client, page,
188 LTC2978_MFR_TEMPERATURE_MIN);
190 if (lin11_to_val(ret)
191 < lin11_to_val(data->temp_min[page]))
192 data->temp_min[page] = ret;
193 ret = data->temp_min[page];
196 case PMBUS_VIRT_READ_IOUT_MAX:
197 case PMBUS_VIRT_RESET_IOUT_HISTORY:
198 case PMBUS_VIRT_READ_TEMP2_MAX:
199 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
203 ret = ltc2978_read_word_data_common(client, page, reg);
209 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
211 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
212 struct ltc2978_data *data = to_ltc2978_data(info);
216 case PMBUS_VIRT_READ_IOUT_MAX:
217 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
219 if (lin11_to_val(ret)
220 > lin11_to_val(data->iout_max[page]))
221 data->iout_max[page] = ret;
222 ret = data->iout_max[page];
225 case PMBUS_VIRT_READ_IOUT_MIN:
226 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
228 if (lin11_to_val(ret)
229 < lin11_to_val(data->iout_min[page]))
230 data->iout_min[page] = ret;
231 ret = data->iout_min[page];
234 case PMBUS_VIRT_RESET_IOUT_HISTORY:
238 ret = ltc2978_read_word_data(client, page, reg);
244 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
246 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
247 struct ltc2978_data *data = to_ltc2978_data(info);
251 case PMBUS_VIRT_READ_IOUT_MAX:
252 ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
254 if (lin11_to_val(ret)
255 > lin11_to_val(data->iout_max[page]))
256 data->iout_max[page] = ret;
257 ret = data->iout_max[page];
260 case PMBUS_VIRT_READ_TEMP2_MAX:
261 ret = pmbus_read_word_data(client, page,
262 LTC3880_MFR_TEMPERATURE2_PEAK);
264 if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
265 data->temp2_max = ret;
266 ret = data->temp2_max;
269 case PMBUS_VIRT_READ_VIN_MIN:
270 case PMBUS_VIRT_READ_VOUT_MIN:
271 case PMBUS_VIRT_READ_TEMP_MIN:
274 case PMBUS_VIRT_RESET_IOUT_HISTORY:
275 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
279 ret = ltc2978_read_word_data_common(client, page, reg);
285 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
287 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
288 struct ltc2978_data *data = to_ltc2978_data(info);
292 case PMBUS_VIRT_READ_IIN_MAX:
293 ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
295 if (lin11_to_val(ret)
296 > lin11_to_val(data->iin_max))
301 case PMBUS_VIRT_RESET_IIN_HISTORY:
305 ret = ltc3880_read_word_data(client, page, reg);
311 static int ltc2978_clear_peaks(struct i2c_client *client, int page,
316 if (id == ltc3880 || id == ltc3883)
317 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
319 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
324 static int ltc2978_write_word_data(struct i2c_client *client, int page,
327 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
328 struct ltc2978_data *data = to_ltc2978_data(info);
332 case PMBUS_VIRT_RESET_IIN_HISTORY:
333 data->iin_max = 0x7c00;
334 ret = ltc2978_clear_peaks(client, page, data->id);
336 case PMBUS_VIRT_RESET_IOUT_HISTORY:
337 data->iout_max[page] = 0x7c00;
338 data->iout_min[page] = 0xfbff;
339 ret = ltc2978_clear_peaks(client, page, data->id);
341 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
342 data->temp2_max = 0x7c00;
343 ret = ltc2978_clear_peaks(client, page, data->id);
345 case PMBUS_VIRT_RESET_VOUT_HISTORY:
346 data->vout_min[page] = 0xffff;
347 data->vout_max[page] = 0;
348 ret = ltc2978_clear_peaks(client, page, data->id);
350 case PMBUS_VIRT_RESET_VIN_HISTORY:
351 data->vin_min = 0x7bff;
352 data->vin_max = 0x7c00;
353 ret = ltc2978_clear_peaks(client, page, data->id);
355 case PMBUS_VIRT_RESET_TEMP_HISTORY:
356 data->temp_min[page] = 0x7bff;
357 data->temp_max[page] = 0x7c00;
358 ret = ltc2978_clear_peaks(client, page, data->id);
367 static const struct i2c_device_id ltc2978_id[] = {
368 {"ltc2974", ltc2974},
369 {"ltc2977", ltc2977},
370 {"ltc2978", ltc2978},
371 {"ltc3880", ltc3880},
372 {"ltc3883", ltc3883},
373 {"ltm4676", ltm4676},
376 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
378 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
379 static const struct regulator_desc ltc2978_reg_desc[] = {
380 PMBUS_REGULATOR("vout", 0),
381 PMBUS_REGULATOR("vout", 1),
382 PMBUS_REGULATOR("vout", 2),
383 PMBUS_REGULATOR("vout", 3),
384 PMBUS_REGULATOR("vout", 4),
385 PMBUS_REGULATOR("vout", 5),
386 PMBUS_REGULATOR("vout", 6),
387 PMBUS_REGULATOR("vout", 7),
389 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
391 static int ltc2978_probe(struct i2c_client *client,
392 const struct i2c_device_id *id)
395 struct ltc2978_data *data;
396 struct pmbus_driver_info *info;
398 if (!i2c_check_functionality(client->adapter,
399 I2C_FUNC_SMBUS_READ_WORD_DATA))
402 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
407 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
411 if (chip_id == LTC2974_ID_REV1 || chip_id == LTC2974_ID_REV2) {
413 } else if (chip_id == LTC2977_ID) {
415 } else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2 ||
416 chip_id == LTC2978A_ID) {
418 } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
420 } else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
422 } else if ((chip_id & LTM4676_ID_MASK) == LTM4676_ID) {
425 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
428 if (data->id != id->driver_data)
429 dev_warn(&client->dev,
430 "Device mismatch: Configured %s, detected %s\n",
432 ltc2978_id[data->id].name);
435 info->write_word_data = ltc2978_write_word_data;
437 data->vin_min = 0x7bff;
438 data->vin_max = 0x7c00;
439 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
440 data->vout_min[i] = 0xffff;
441 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
442 data->iout_min[i] = 0xfbff;
443 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
444 data->iout_max[i] = 0x7c00;
445 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
446 data->temp_min[i] = 0x7bff;
447 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
448 data->temp_max[i] = 0x7c00;
449 data->temp2_max = 0x7c00;
453 info->read_word_data = ltc2974_read_word_data;
454 info->pages = LTC2974_NUM_PAGES;
455 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
457 for (i = 0; i < info->pages; i++) {
458 info->func[i] |= PMBUS_HAVE_VOUT
459 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
460 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
461 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
466 info->read_word_data = ltc2978_read_word_data;
467 info->pages = LTC2978_NUM_PAGES;
468 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
469 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
470 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
471 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
472 info->func[i] = PMBUS_HAVE_VOUT
473 | PMBUS_HAVE_STATUS_VOUT;
478 info->read_word_data = ltc3880_read_word_data;
479 info->pages = LTC3880_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_POUT | PMBUS_HAVE_TEMP
485 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
486 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
487 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
489 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
492 info->read_word_data = ltc3883_read_word_data;
493 info->pages = LTC3883_NUM_PAGES;
494 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
495 | PMBUS_HAVE_STATUS_INPUT
496 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
497 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
498 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
499 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
505 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
506 info->num_regulators = info->pages;
507 info->reg_desc = ltc2978_reg_desc;
508 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
509 dev_err(&client->dev, "num_regulators too large!");
510 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
514 return pmbus_do_probe(client, id, info);
518 static const struct of_device_id ltc2978_of_match[] = {
519 { .compatible = "lltc,ltc2974" },
520 { .compatible = "lltc,ltc2977" },
521 { .compatible = "lltc,ltc2978" },
522 { .compatible = "lltc,ltc3880" },
523 { .compatible = "lltc,ltc3883" },
524 { .compatible = "lltc,ltm4676" },
527 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
530 static struct i2c_driver ltc2978_driver = {
533 .of_match_table = of_match_ptr(ltc2978_of_match),
535 .probe = ltc2978_probe,
536 .remove = pmbus_do_remove,
537 .id_table = ltc2978_id,
540 module_i2c_driver(ltc2978_driver);
542 MODULE_AUTHOR("Guenter Roeck");
543 MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, LTC3883, and LTM4676");
544 MODULE_LICENSE("GPL");