2 * Hardware monitoring driver for LTC2978 and compatible chips.
4 * Copyright (c) 2011 Ericsson AB.
5 * Copyright (c) 2013, 2014, 2015 Guenter Roeck
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/err.h>
22 #include <linux/slab.h>
23 #include <linux/i2c.h>
24 #include <linux/regulator/driver.h>
27 enum chips { ltc2974, ltc2975, ltc2977, ltc2978, ltc3880, ltc3882, ltc3883,
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 /* Not on LTC3882 */
36 /* LTC2974, LTC2975, LCT2977, and LTC2978 */
37 #define LTC2978_MFR_VOUT_MIN 0xfb
38 #define LTC2978_MFR_VIN_MIN 0xfc
39 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
41 /* LTC2974, LTC2975 */
42 #define LTC2974_MFR_IOUT_PEAK 0xd7
43 #define LTC2974_MFR_IOUT_MIN 0xd8
45 /* LTC3880, LTC3882, LTC3883, LTC3887, 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
54 #define LTC2975_MFR_IIN_PEAK 0xc4
55 #define LTC2975_MFR_IIN_MIN 0xc5
56 #define LTC2975_MFR_PIN_PEAK 0xc6
57 #define LTC2975_MFR_PIN_MIN 0xc7
59 #define LTC2978_ID_MASK 0xfff0
61 #define LTC2974_ID 0x0210
62 #define LTC2975_ID 0x0220
63 #define LTC2977_ID 0x0130
64 #define LTC2978_ID 0x0120
65 #define LTC3880_ID 0x4020
66 #define LTC3883_ID 0x4300
67 #define LTC3887_ID 0x4700
68 #define LTM4676_ID_REV1 0x4400
69 #define LTM4676_ID_REV2 0x4480
70 #define LTM4676A_ID 0x47e0
72 #define LTC2974_NUM_PAGES 4
73 #define LTC2978_NUM_PAGES 8
74 #define LTC3880_NUM_PAGES 2
75 #define LTC3883_NUM_PAGES 1
78 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
79 * happens pretty much each time chip data is updated. Raw peak data therefore
80 * does not provide much value. To be able to provide useful peak data, keep an
81 * internal cache of measured peak data, which is only cleared if an explicit
82 * "clear peak" command is executed for the sensor in question.
88 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
89 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
90 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
94 struct pmbus_driver_info info;
97 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
99 #define FEAT_CLEAR_PEAKS BIT(0)
101 #define has_clear_peaks(d) ((d)->features & FEAT_CLEAR_PEAKS)
103 static inline int lin11_to_val(int data)
105 s16 e = ((s16)data) >> 11;
106 s32 m = (((s16)(data << 5)) >> 5);
109 * mantissa is 10 bit + sign, exponent adds up to 15 bit.
110 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
113 return (e < 0 ? m >> -e : m << e);
116 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
117 int page, int reg, u16 *pmax)
121 ret = pmbus_read_word_data(client, page, reg);
123 if (lin11_to_val(ret) > lin11_to_val(*pmax))
130 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
131 int page, int reg, u16 *pmin)
135 ret = pmbus_read_word_data(client, page, reg);
137 if (lin11_to_val(ret) < lin11_to_val(*pmin))
144 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
147 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
148 struct ltc2978_data *data = to_ltc2978_data(info);
152 case PMBUS_VIRT_READ_VIN_MAX:
153 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
156 case PMBUS_VIRT_READ_VOUT_MAX:
157 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
160 * VOUT is 16 bit unsigned with fixed exponent,
161 * so we can compare it directly
163 if (ret > data->vout_max[page])
164 data->vout_max[page] = ret;
165 ret = data->vout_max[page];
168 case PMBUS_VIRT_READ_TEMP_MAX:
169 ret = ltc_get_max(data, client, page,
170 LTC2978_MFR_TEMPERATURE_PEAK,
171 &data->temp_max[page]);
173 case PMBUS_VIRT_RESET_VOUT_HISTORY:
174 case PMBUS_VIRT_RESET_VIN_HISTORY:
175 case PMBUS_VIRT_RESET_TEMP_HISTORY:
185 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
187 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
188 struct ltc2978_data *data = to_ltc2978_data(info);
192 case PMBUS_VIRT_READ_VIN_MIN:
193 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
196 case PMBUS_VIRT_READ_VOUT_MIN:
197 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
200 * VOUT_MIN is known to not be supported on some lots
201 * of LTC2978 revision 1, and will return the maximum
202 * possible voltage if read. If VOUT_MAX is valid and
203 * lower than the reading of VOUT_MIN, use it instead.
205 if (data->vout_max[page] && ret > data->vout_max[page])
206 ret = data->vout_max[page];
207 if (ret < data->vout_min[page])
208 data->vout_min[page] = ret;
209 ret = data->vout_min[page];
212 case PMBUS_VIRT_READ_TEMP_MIN:
213 ret = ltc_get_min(data, client, page,
214 LTC2978_MFR_TEMPERATURE_MIN,
215 &data->temp_min[page]);
217 case PMBUS_VIRT_READ_IOUT_MAX:
218 case PMBUS_VIRT_RESET_IOUT_HISTORY:
219 case PMBUS_VIRT_READ_TEMP2_MAX:
220 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
224 ret = ltc2978_read_word_data_common(client, page, reg);
230 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
232 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
233 struct ltc2978_data *data = to_ltc2978_data(info);
237 case PMBUS_VIRT_READ_IOUT_MAX:
238 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
239 &data->iout_max[page]);
241 case PMBUS_VIRT_READ_IOUT_MIN:
242 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
243 &data->iout_min[page]);
245 case PMBUS_VIRT_RESET_IOUT_HISTORY:
249 ret = ltc2978_read_word_data(client, page, reg);
255 static int ltc2975_read_word_data(struct i2c_client *client, int page, int reg)
257 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
258 struct ltc2978_data *data = to_ltc2978_data(info);
262 case PMBUS_VIRT_READ_IIN_MAX:
263 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
266 case PMBUS_VIRT_READ_IIN_MIN:
267 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
270 case PMBUS_VIRT_READ_PIN_MAX:
271 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
274 case PMBUS_VIRT_READ_PIN_MIN:
275 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
278 case PMBUS_VIRT_RESET_IIN_HISTORY:
279 case PMBUS_VIRT_RESET_PIN_HISTORY:
283 ret = ltc2978_read_word_data(client, page, reg);
289 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
291 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
292 struct ltc2978_data *data = to_ltc2978_data(info);
296 case PMBUS_VIRT_READ_IOUT_MAX:
297 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
298 &data->iout_max[page]);
300 case PMBUS_VIRT_READ_TEMP2_MAX:
301 ret = ltc_get_max(data, client, page,
302 LTC3880_MFR_TEMPERATURE2_PEAK,
305 case PMBUS_VIRT_READ_VIN_MIN:
306 case PMBUS_VIRT_READ_VOUT_MIN:
307 case PMBUS_VIRT_READ_TEMP_MIN:
310 case PMBUS_VIRT_RESET_IOUT_HISTORY:
311 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
315 ret = ltc2978_read_word_data_common(client, page, reg);
321 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
323 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
324 struct ltc2978_data *data = to_ltc2978_data(info);
328 case PMBUS_VIRT_READ_IIN_MAX:
329 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
332 case PMBUS_VIRT_RESET_IIN_HISTORY:
336 ret = ltc3880_read_word_data(client, page, reg);
342 static int ltc2978_clear_peaks(struct ltc2978_data *data,
343 struct i2c_client *client, int page)
347 if (has_clear_peaks(data))
348 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
350 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
355 static int ltc2978_write_word_data(struct i2c_client *client, int page,
358 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
359 struct ltc2978_data *data = to_ltc2978_data(info);
363 case PMBUS_VIRT_RESET_IIN_HISTORY:
364 data->iin_max = 0x7c00;
365 data->iin_min = 0x7bff;
366 ret = ltc2978_clear_peaks(data, client, 0);
368 case PMBUS_VIRT_RESET_PIN_HISTORY:
369 data->pin_max = 0x7c00;
370 data->pin_min = 0x7bff;
371 ret = ltc2978_clear_peaks(data, client, 0);
373 case PMBUS_VIRT_RESET_IOUT_HISTORY:
374 data->iout_max[page] = 0x7c00;
375 data->iout_min[page] = 0xfbff;
376 ret = ltc2978_clear_peaks(data, client, page);
378 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
379 data->temp2_max = 0x7c00;
380 ret = ltc2978_clear_peaks(data, client, page);
382 case PMBUS_VIRT_RESET_VOUT_HISTORY:
383 data->vout_min[page] = 0xffff;
384 data->vout_max[page] = 0;
385 ret = ltc2978_clear_peaks(data, client, page);
387 case PMBUS_VIRT_RESET_VIN_HISTORY:
388 data->vin_min = 0x7bff;
389 data->vin_max = 0x7c00;
390 ret = ltc2978_clear_peaks(data, client, page);
392 case PMBUS_VIRT_RESET_TEMP_HISTORY:
393 data->temp_min[page] = 0x7bff;
394 data->temp_max[page] = 0x7c00;
395 ret = ltc2978_clear_peaks(data, client, page);
404 static const struct i2c_device_id ltc2978_id[] = {
405 {"ltc2974", ltc2974},
406 {"ltc2975", ltc2975},
407 {"ltc2977", ltc2977},
408 {"ltc2978", ltc2978},
409 {"ltc3880", ltc3880},
410 {"ltc3882", ltc3882},
411 {"ltc3883", ltc3883},
412 {"ltc3887", ltc3887},
413 {"ltm4676", ltm4676},
416 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
418 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
419 static const struct regulator_desc ltc2978_reg_desc[] = {
420 PMBUS_REGULATOR("vout", 0),
421 PMBUS_REGULATOR("vout", 1),
422 PMBUS_REGULATOR("vout", 2),
423 PMBUS_REGULATOR("vout", 3),
424 PMBUS_REGULATOR("vout", 4),
425 PMBUS_REGULATOR("vout", 5),
426 PMBUS_REGULATOR("vout", 6),
427 PMBUS_REGULATOR("vout", 7),
429 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
431 static int ltc2978_get_id(struct i2c_client *client)
435 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
437 const struct i2c_device_id *id;
438 u8 buf[I2C_SMBUS_BLOCK_MAX];
441 if (!i2c_check_functionality(client->adapter,
442 I2C_FUNC_SMBUS_READ_BLOCK_DATA))
445 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
448 if (ret < 3 || strncmp(buf, "LTC", 3))
451 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
454 for (id = <c2978_id[0]; strlen(id->name); id++) {
455 if (!strncasecmp(id->name, buf, strlen(id->name)))
456 return (int)id->driver_data;
461 chip_id &= LTC2978_ID_MASK;
463 if (chip_id == LTC2974_ID)
465 else if (chip_id == LTC2975_ID)
467 else if (chip_id == LTC2977_ID)
469 else if (chip_id == LTC2978_ID)
471 else if (chip_id == LTC3880_ID)
473 else if (chip_id == LTC3883_ID)
475 else if (chip_id == LTC3887_ID)
477 else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
478 chip_id == LTM4676A_ID)
481 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
485 static int ltc2978_probe(struct i2c_client *client,
486 const struct i2c_device_id *id)
489 struct ltc2978_data *data;
490 struct pmbus_driver_info *info;
492 if (!i2c_check_functionality(client->adapter,
493 I2C_FUNC_SMBUS_READ_WORD_DATA))
496 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
501 chip_id = ltc2978_get_id(client);
506 if (data->id != id->driver_data)
507 dev_warn(&client->dev,
508 "Device mismatch: Configured %s, detected %s\n",
510 ltc2978_id[data->id].name);
513 info->write_word_data = ltc2978_write_word_data;
515 data->vin_min = 0x7bff;
516 data->vin_max = 0x7c00;
517 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
518 data->vout_min[i] = 0xffff;
519 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
520 data->iout_min[i] = 0xfbff;
521 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
522 data->iout_max[i] = 0x7c00;
523 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
524 data->temp_min[i] = 0x7bff;
525 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
526 data->temp_max[i] = 0x7c00;
527 data->temp2_max = 0x7c00;
531 info->read_word_data = ltc2974_read_word_data;
532 info->pages = LTC2974_NUM_PAGES;
533 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
535 for (i = 0; i < info->pages; i++) {
536 info->func[i] |= PMBUS_HAVE_VOUT
537 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
538 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
539 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
543 info->read_word_data = ltc2975_read_word_data;
544 info->pages = LTC2974_NUM_PAGES;
545 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
546 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
548 for (i = 0; i < info->pages; i++) {
549 info->func[i] |= PMBUS_HAVE_VOUT
550 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
551 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
552 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
557 info->read_word_data = ltc2978_read_word_data;
558 info->pages = LTC2978_NUM_PAGES;
559 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
560 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
561 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
562 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
563 info->func[i] = PMBUS_HAVE_VOUT
564 | PMBUS_HAVE_STATUS_VOUT;
570 data->features |= FEAT_CLEAR_PEAKS;
571 info->read_word_data = ltc3880_read_word_data;
572 info->pages = LTC3880_NUM_PAGES;
573 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
574 | PMBUS_HAVE_STATUS_INPUT
575 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
576 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
577 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
578 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
579 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
580 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
582 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
585 data->features |= FEAT_CLEAR_PEAKS;
586 info->read_word_data = ltc3880_read_word_data;
587 info->pages = LTC3880_NUM_PAGES;
588 info->func[0] = PMBUS_HAVE_VIN
589 | PMBUS_HAVE_STATUS_INPUT
590 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
591 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
592 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
593 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
594 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
595 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
597 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
600 data->features |= FEAT_CLEAR_PEAKS;
601 info->read_word_data = ltc3883_read_word_data;
602 info->pages = LTC3883_NUM_PAGES;
603 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
604 | PMBUS_HAVE_STATUS_INPUT
605 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
606 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
607 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
608 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
614 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
615 info->num_regulators = info->pages;
616 info->reg_desc = ltc2978_reg_desc;
617 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
618 dev_err(&client->dev, "num_regulators too large!");
619 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
623 return pmbus_do_probe(client, id, info);
627 static const struct of_device_id ltc2978_of_match[] = {
628 { .compatible = "lltc,ltc2974" },
629 { .compatible = "lltc,ltc2975" },
630 { .compatible = "lltc,ltc2977" },
631 { .compatible = "lltc,ltc2978" },
632 { .compatible = "lltc,ltc3880" },
633 { .compatible = "lltc,ltc3882" },
634 { .compatible = "lltc,ltc3883" },
635 { .compatible = "lltc,ltc3887" },
636 { .compatible = "lltc,ltm4676" },
639 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
642 static struct i2c_driver ltc2978_driver = {
645 .of_match_table = of_match_ptr(ltc2978_of_match),
647 .probe = ltc2978_probe,
648 .remove = pmbus_do_remove,
649 .id_table = ltc2978_id,
652 module_i2c_driver(ltc2978_driver);
654 MODULE_AUTHOR("Guenter Roeck");
655 MODULE_DESCRIPTION("PMBus driver for LTC2978 and comppatible chips");
656 MODULE_LICENSE("GPL");