1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Hardware monitoring driver for LTC2978 and compatible chips.
4 *
5 * Copyright (c) 2011 Ericsson AB.
6 * Copyright (c) 2013, 2014, 2015 Guenter Roeck
7 * Copyright (c) 2015 Linear Technology
8 * Copyright (c) 2018 Analog Devices Inc.
9 */
10
11 #include <linux/delay.h>
12 #include <linux/jiffies.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/err.h>
17 #include <linux/slab.h>
18 #include <linux/i2c.h>
19 #include <linux/regulator/driver.h>
20 #include "pmbus.h"
21
22 enum chips {
23 /* Managers */
24 ltc2972, ltc2974, ltc2975, ltc2977, ltc2978, ltc2979, ltc2980,
25 /* Controllers */
26 ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887, ltc3889, ltc7880,
27 /* Modules */
28 ltm2987, ltm4664, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680, ltm4686,
29 ltm4700,
30 };
31
32 /* Common for all chips */
33 #define LTC2978_MFR_VOUT_PEAK 0xdd
34 #define LTC2978_MFR_VIN_PEAK 0xde
35 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf
36 #define LTC2978_MFR_SPECIAL_ID 0xe7 /* Undocumented on LTC3882 */
37 #define LTC2978_MFR_COMMON 0xef
38
39 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */
40 #define LTC2978_MFR_VOUT_MIN 0xfb
41 #define LTC2978_MFR_VIN_MIN 0xfc
42 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd
43
44 /* LTC2974, LTC2975 */
45 #define LTC2974_MFR_IOUT_PEAK 0xd7
46 #define LTC2974_MFR_IOUT_MIN 0xd8
47
48 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, and LTM4676 */
49 #define LTC3880_MFR_IOUT_PEAK 0xd7
50 #define LTC3880_MFR_CLEAR_PEAKS 0xe3
51 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4
52
53 /* LTC3883, LTC3884, LTC3886, LTC3889 and LTC7880 only */
54 #define LTC3883_MFR_IIN_PEAK 0xe1
55
56
57 /* LTC2975 only */
58 #define LTC2975_MFR_IIN_PEAK 0xc4
59 #define LTC2975_MFR_IIN_MIN 0xc5
60 #define LTC2975_MFR_PIN_PEAK 0xc6
61 #define LTC2975_MFR_PIN_MIN 0xc7
62
63 #define LTC2978_ID_MASK 0xfff0
64
65 #define LTC2972_ID 0x0310
66 #define LTC2974_ID 0x0210
67 #define LTC2975_ID 0x0220
68 #define LTC2977_ID 0x0130
69 #define LTC2978_ID_REV1 0x0110 /* Early revision */
70 #define LTC2978_ID_REV2 0x0120
71 #define LTC2979_ID_A 0x8060
72 #define LTC2979_ID_B 0x8070
73 #define LTC2980_ID_A 0x8030 /* A/B for two die IDs */
74 #define LTC2980_ID_B 0x8040
75 #define LTC3880_ID 0x4020
76 #define LTC3882_ID 0x4200
77 #define LTC3882_ID_D1 0x4240 /* Dash 1 */
78 #define LTC3883_ID 0x4300
79 #define LTC3884_ID 0x4C00
80 #define LTC3886_ID 0x4600
81 #define LTC3887_ID 0x4700
82 #define LTM2987_ID_A 0x8010 /* A/B for two die IDs */
83 #define LTM2987_ID_B 0x8020
84 #define LTC3889_ID 0x4900
85 #define LTC7880_ID 0x49E0
86 #define LTM4664_ID 0x4120
87 #define LTM4675_ID 0x47a0
88 #define LTM4676_ID_REV1 0x4400
89 #define LTM4676_ID_REV2 0x4480
90 #define LTM4676A_ID 0x47e0
91 #define LTM4677_ID_REV1 0x47B0
92 #define LTM4677_ID_REV2 0x47D0
93 #define LTM4678_ID_REV1 0x4100
94 #define LTM4678_ID_REV2 0x4110
95 #define LTM4680_ID 0x4140
96 #define LTM4686_ID 0x4770
97 #define LTM4700_ID 0x4130
98
99 #define LTC2972_NUM_PAGES 2
100 #define LTC2974_NUM_PAGES 4
101 #define LTC2978_NUM_PAGES 8
102 #define LTC3880_NUM_PAGES 2
103 #define LTC3883_NUM_PAGES 1
104
105 #define LTC_POLL_TIMEOUT 100 /* in milli-seconds */
106
107 #define LTC_NOT_BUSY BIT(6)
108 #define LTC_NOT_PENDING BIT(5)
109
110 /*
111 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
112 * happens pretty much each time chip data is updated. Raw peak data therefore
113 * does not provide much value. To be able to provide useful peak data, keep an
114 * internal cache of measured peak data, which is only cleared if an explicit
115 * "clear peak" command is executed for the sensor in question.
116 */
117
118 struct ltc2978_data {
119 enum chips id;
120 u16 vin_min, vin_max;
121 u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
122 u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
123 u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
124 u16 iin_min, iin_max;
125 u16 pin_min, pin_max;
126 u16 temp2_max;
127 struct pmbus_driver_info info;
128 u32 features;
129 };
130 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info)
131
132 #define FEAT_CLEAR_PEAKS BIT(0)
133 #define FEAT_NEEDS_POLLING BIT(1)
134
135 #define has_clear_peaks(d) ((d)->features & FEAT_CLEAR_PEAKS)
136 #define needs_polling(d) ((d)->features & FEAT_NEEDS_POLLING)
137
ltc_wait_ready(struct i2c_client * client)138 static int ltc_wait_ready(struct i2c_client *client)
139 {
140 unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT);
141 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
142 struct ltc2978_data *data = to_ltc2978_data(info);
143 int status;
144 u8 mask;
145
146 if (!needs_polling(data))
147 return 0;
148
149 /*
150 * LTC3883 does not support LTC_NOT_PENDING, even though
151 * the datasheet claims that it does.
152 */
153 mask = LTC_NOT_BUSY;
154 if (data->id != ltc3883)
155 mask |= LTC_NOT_PENDING;
156
157 do {
158 status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON);
159 if (status == -EBADMSG || status == -ENXIO) {
160 /* PEC error or NACK: chip may be busy, try again */
161 usleep_range(50, 100);
162 continue;
163 }
164 if (status < 0)
165 return status;
166
167 if ((status & mask) == mask)
168 return 0;
169
170 usleep_range(50, 100);
171 } while (time_before(jiffies, timeout));
172
173 return -ETIMEDOUT;
174 }
175
ltc_read_word_data(struct i2c_client * client,int page,int phase,int reg)176 static int ltc_read_word_data(struct i2c_client *client, int page, int phase,
177 int reg)
178 {
179 int ret;
180
181 ret = ltc_wait_ready(client);
182 if (ret < 0)
183 return ret;
184
185 return pmbus_read_word_data(client, page, 0xff, reg);
186 }
187
ltc_read_byte_data(struct i2c_client * client,int page,int reg)188 static int ltc_read_byte_data(struct i2c_client *client, int page, int reg)
189 {
190 int ret;
191
192 ret = ltc_wait_ready(client);
193 if (ret < 0)
194 return ret;
195
196 return pmbus_read_byte_data(client, page, reg);
197 }
198
ltc_write_byte(struct i2c_client * client,int page,u8 byte)199 static int ltc_write_byte(struct i2c_client *client, int page, u8 byte)
200 {
201 int ret;
202
203 ret = ltc_wait_ready(client);
204 if (ret < 0)
205 return ret;
206
207 return pmbus_write_byte(client, page, byte);
208 }
209
lin11_to_val(int data)210 static inline int lin11_to_val(int data)
211 {
212 s16 e = ((s16)data) >> 11;
213 s32 m = (((s16)(data << 5)) >> 5);
214
215 /*
216 * mantissa is 10 bit + sign, exponent adds up to 15 bit.
217 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
218 */
219 e += 6;
220 return (e < 0 ? m >> -e : m << e);
221 }
222
ltc_get_max(struct ltc2978_data * data,struct i2c_client * client,int page,int reg,u16 * pmax)223 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
224 int page, int reg, u16 *pmax)
225 {
226 int ret;
227
228 ret = ltc_read_word_data(client, page, 0xff, reg);
229 if (ret >= 0) {
230 if (lin11_to_val(ret) > lin11_to_val(*pmax))
231 *pmax = ret;
232 ret = *pmax;
233 }
234 return ret;
235 }
236
ltc_get_min(struct ltc2978_data * data,struct i2c_client * client,int page,int reg,u16 * pmin)237 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
238 int page, int reg, u16 *pmin)
239 {
240 int ret;
241
242 ret = ltc_read_word_data(client, page, 0xff, reg);
243 if (ret >= 0) {
244 if (lin11_to_val(ret) < lin11_to_val(*pmin))
245 *pmin = ret;
246 ret = *pmin;
247 }
248 return ret;
249 }
250
ltc2978_read_word_data_common(struct i2c_client * client,int page,int reg)251 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
252 int reg)
253 {
254 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
255 struct ltc2978_data *data = to_ltc2978_data(info);
256 int ret;
257
258 switch (reg) {
259 case PMBUS_VIRT_READ_VIN_MAX:
260 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
261 &data->vin_max);
262 break;
263 case PMBUS_VIRT_READ_VOUT_MAX:
264 ret = ltc_read_word_data(client, page, 0xff,
265 LTC2978_MFR_VOUT_PEAK);
266 if (ret >= 0) {
267 /*
268 * VOUT is 16 bit unsigned with fixed exponent,
269 * so we can compare it directly
270 */
271 if (ret > data->vout_max[page])
272 data->vout_max[page] = ret;
273 ret = data->vout_max[page];
274 }
275 break;
276 case PMBUS_VIRT_READ_TEMP_MAX:
277 ret = ltc_get_max(data, client, page,
278 LTC2978_MFR_TEMPERATURE_PEAK,
279 &data->temp_max[page]);
280 break;
281 case PMBUS_VIRT_RESET_VOUT_HISTORY:
282 case PMBUS_VIRT_RESET_VIN_HISTORY:
283 case PMBUS_VIRT_RESET_TEMP_HISTORY:
284 ret = 0;
285 break;
286 default:
287 ret = ltc_wait_ready(client);
288 if (ret < 0)
289 return ret;
290 ret = -ENODATA;
291 break;
292 }
293 return ret;
294 }
295
ltc2978_read_word_data(struct i2c_client * client,int page,int phase,int reg)296 static int ltc2978_read_word_data(struct i2c_client *client, int page,
297 int phase, int reg)
298 {
299 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
300 struct ltc2978_data *data = to_ltc2978_data(info);
301 int ret;
302
303 switch (reg) {
304 case PMBUS_VIRT_READ_VIN_MIN:
305 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
306 &data->vin_min);
307 break;
308 case PMBUS_VIRT_READ_VOUT_MIN:
309 ret = ltc_read_word_data(client, page, phase,
310 LTC2978_MFR_VOUT_MIN);
311 if (ret >= 0) {
312 /*
313 * VOUT_MIN is known to not be supported on some lots
314 * of LTC2978 revision 1, and will return the maximum
315 * possible voltage if read. If VOUT_MAX is valid and
316 * lower than the reading of VOUT_MIN, use it instead.
317 */
318 if (data->vout_max[page] && ret > data->vout_max[page])
319 ret = data->vout_max[page];
320 if (ret < data->vout_min[page])
321 data->vout_min[page] = ret;
322 ret = data->vout_min[page];
323 }
324 break;
325 case PMBUS_VIRT_READ_TEMP_MIN:
326 ret = ltc_get_min(data, client, page,
327 LTC2978_MFR_TEMPERATURE_MIN,
328 &data->temp_min[page]);
329 break;
330 case PMBUS_VIRT_READ_IOUT_MAX:
331 case PMBUS_VIRT_RESET_IOUT_HISTORY:
332 case PMBUS_VIRT_READ_TEMP2_MAX:
333 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
334 ret = -ENXIO;
335 break;
336 default:
337 ret = ltc2978_read_word_data_common(client, page, reg);
338 break;
339 }
340 return ret;
341 }
342
ltc2974_read_word_data(struct i2c_client * client,int page,int phase,int reg)343 static int ltc2974_read_word_data(struct i2c_client *client, int page,
344 int phase, int reg)
345 {
346 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
347 struct ltc2978_data *data = to_ltc2978_data(info);
348 int ret;
349
350 switch (reg) {
351 case PMBUS_VIRT_READ_IOUT_MAX:
352 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
353 &data->iout_max[page]);
354 break;
355 case PMBUS_VIRT_READ_IOUT_MIN:
356 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
357 &data->iout_min[page]);
358 break;
359 case PMBUS_VIRT_RESET_IOUT_HISTORY:
360 ret = 0;
361 break;
362 default:
363 ret = ltc2978_read_word_data(client, page, phase, reg);
364 break;
365 }
366 return ret;
367 }
368
ltc2975_read_word_data(struct i2c_client * client,int page,int phase,int reg)369 static int ltc2975_read_word_data(struct i2c_client *client, int page,
370 int phase, int reg)
371 {
372 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
373 struct ltc2978_data *data = to_ltc2978_data(info);
374 int ret;
375
376 switch (reg) {
377 case PMBUS_VIRT_READ_IIN_MAX:
378 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
379 &data->iin_max);
380 break;
381 case PMBUS_VIRT_READ_IIN_MIN:
382 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
383 &data->iin_min);
384 break;
385 case PMBUS_VIRT_READ_PIN_MAX:
386 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
387 &data->pin_max);
388 break;
389 case PMBUS_VIRT_READ_PIN_MIN:
390 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
391 &data->pin_min);
392 break;
393 case PMBUS_VIRT_RESET_IIN_HISTORY:
394 case PMBUS_VIRT_RESET_PIN_HISTORY:
395 ret = 0;
396 break;
397 default:
398 ret = ltc2978_read_word_data(client, page, phase, reg);
399 break;
400 }
401 return ret;
402 }
403
ltc3880_read_word_data(struct i2c_client * client,int page,int phase,int reg)404 static int ltc3880_read_word_data(struct i2c_client *client, int page,
405 int phase, int reg)
406 {
407 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
408 struct ltc2978_data *data = to_ltc2978_data(info);
409 int ret;
410
411 switch (reg) {
412 case PMBUS_VIRT_READ_IOUT_MAX:
413 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
414 &data->iout_max[page]);
415 break;
416 case PMBUS_VIRT_READ_TEMP2_MAX:
417 ret = ltc_get_max(data, client, page,
418 LTC3880_MFR_TEMPERATURE2_PEAK,
419 &data->temp2_max);
420 break;
421 case PMBUS_VIRT_READ_VIN_MIN:
422 case PMBUS_VIRT_READ_VOUT_MIN:
423 case PMBUS_VIRT_READ_TEMP_MIN:
424 ret = -ENXIO;
425 break;
426 case PMBUS_VIRT_RESET_IOUT_HISTORY:
427 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
428 ret = 0;
429 break;
430 default:
431 ret = ltc2978_read_word_data_common(client, page, reg);
432 break;
433 }
434 return ret;
435 }
436
ltc3883_read_word_data(struct i2c_client * client,int page,int phase,int reg)437 static int ltc3883_read_word_data(struct i2c_client *client, int page,
438 int phase, int reg)
439 {
440 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
441 struct ltc2978_data *data = to_ltc2978_data(info);
442 int ret;
443
444 switch (reg) {
445 case PMBUS_VIRT_READ_IIN_MAX:
446 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
447 &data->iin_max);
448 break;
449 case PMBUS_VIRT_RESET_IIN_HISTORY:
450 ret = 0;
451 break;
452 default:
453 ret = ltc3880_read_word_data(client, page, phase, reg);
454 break;
455 }
456 return ret;
457 }
458
ltc2978_clear_peaks(struct ltc2978_data * data,struct i2c_client * client,int page)459 static int ltc2978_clear_peaks(struct ltc2978_data *data,
460 struct i2c_client *client, int page)
461 {
462 int ret;
463
464 if (has_clear_peaks(data))
465 ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
466 else
467 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
468
469 return ret;
470 }
471
ltc2978_write_word_data(struct i2c_client * client,int page,int reg,u16 word)472 static int ltc2978_write_word_data(struct i2c_client *client, int page,
473 int reg, u16 word)
474 {
475 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
476 struct ltc2978_data *data = to_ltc2978_data(info);
477 int ret;
478
479 switch (reg) {
480 case PMBUS_VIRT_RESET_IIN_HISTORY:
481 data->iin_max = 0x7c00;
482 data->iin_min = 0x7bff;
483 ret = ltc2978_clear_peaks(data, client, 0);
484 break;
485 case PMBUS_VIRT_RESET_PIN_HISTORY:
486 data->pin_max = 0x7c00;
487 data->pin_min = 0x7bff;
488 ret = ltc2978_clear_peaks(data, client, 0);
489 break;
490 case PMBUS_VIRT_RESET_IOUT_HISTORY:
491 data->iout_max[page] = 0x7c00;
492 data->iout_min[page] = 0xfbff;
493 ret = ltc2978_clear_peaks(data, client, page);
494 break;
495 case PMBUS_VIRT_RESET_TEMP2_HISTORY:
496 data->temp2_max = 0x7c00;
497 ret = ltc2978_clear_peaks(data, client, page);
498 break;
499 case PMBUS_VIRT_RESET_VOUT_HISTORY:
500 data->vout_min[page] = 0xffff;
501 data->vout_max[page] = 0;
502 ret = ltc2978_clear_peaks(data, client, page);
503 break;
504 case PMBUS_VIRT_RESET_VIN_HISTORY:
505 data->vin_min = 0x7bff;
506 data->vin_max = 0x7c00;
507 ret = ltc2978_clear_peaks(data, client, page);
508 break;
509 case PMBUS_VIRT_RESET_TEMP_HISTORY:
510 data->temp_min[page] = 0x7bff;
511 data->temp_max[page] = 0x7c00;
512 ret = ltc2978_clear_peaks(data, client, page);
513 break;
514 default:
515 ret = ltc_wait_ready(client);
516 if (ret < 0)
517 return ret;
518 ret = -ENODATA;
519 break;
520 }
521 return ret;
522 }
523
524 static const struct i2c_device_id ltc2978_id[] = {
525 {"ltc2972", ltc2972},
526 {"ltc2974", ltc2974},
527 {"ltc2975", ltc2975},
528 {"ltc2977", ltc2977},
529 {"ltc2978", ltc2978},
530 {"ltc2979", ltc2979},
531 {"ltc2980", ltc2980},
532 {"ltc3880", ltc3880},
533 {"ltc3882", ltc3882},
534 {"ltc3883", ltc3883},
535 {"ltc3884", ltc3884},
536 {"ltc3886", ltc3886},
537 {"ltc3887", ltc3887},
538 {"ltc3889", ltc3889},
539 {"ltc7880", ltc7880},
540 {"ltm2987", ltm2987},
541 {"ltm4664", ltm4664},
542 {"ltm4675", ltm4675},
543 {"ltm4676", ltm4676},
544 {"ltm4677", ltm4677},
545 {"ltm4678", ltm4678},
546 {"ltm4680", ltm4680},
547 {"ltm4686", ltm4686},
548 {"ltm4700", ltm4700},
549 {}
550 };
551 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
552
553 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
554 static const struct regulator_desc ltc2978_reg_desc[] = {
555 PMBUS_REGULATOR("vout", 0),
556 PMBUS_REGULATOR("vout", 1),
557 PMBUS_REGULATOR("vout", 2),
558 PMBUS_REGULATOR("vout", 3),
559 PMBUS_REGULATOR("vout", 4),
560 PMBUS_REGULATOR("vout", 5),
561 PMBUS_REGULATOR("vout", 6),
562 PMBUS_REGULATOR("vout", 7),
563 };
564 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
565
ltc2978_get_id(struct i2c_client * client)566 static int ltc2978_get_id(struct i2c_client *client)
567 {
568 int chip_id;
569
570 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
571 if (chip_id < 0) {
572 const struct i2c_device_id *id;
573 u8 buf[I2C_SMBUS_BLOCK_MAX];
574 int ret;
575
576 if (!i2c_check_functionality(client->adapter,
577 I2C_FUNC_SMBUS_READ_BLOCK_DATA))
578 return -ENODEV;
579
580 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
581 if (ret < 0)
582 return ret;
583 if (ret < 3 || strncmp(buf, "LTC", 3))
584 return -ENODEV;
585
586 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
587 if (ret < 0)
588 return ret;
589 for (id = <c2978_id[0]; strlen(id->name); id++) {
590 if (!strncasecmp(id->name, buf, strlen(id->name)))
591 return (int)id->driver_data;
592 }
593 return -ENODEV;
594 }
595
596 chip_id &= LTC2978_ID_MASK;
597
598 if (chip_id == LTC2972_ID)
599 return ltc2972;
600 else if (chip_id == LTC2974_ID)
601 return ltc2974;
602 else if (chip_id == LTC2975_ID)
603 return ltc2975;
604 else if (chip_id == LTC2977_ID)
605 return ltc2977;
606 else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
607 return ltc2978;
608 else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
609 return ltc2979;
610 else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
611 return ltc2980;
612 else if (chip_id == LTC3880_ID)
613 return ltc3880;
614 else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
615 return ltc3882;
616 else if (chip_id == LTC3883_ID)
617 return ltc3883;
618 else if (chip_id == LTC3884_ID)
619 return ltc3884;
620 else if (chip_id == LTC3886_ID)
621 return ltc3886;
622 else if (chip_id == LTC3887_ID)
623 return ltc3887;
624 else if (chip_id == LTC3889_ID)
625 return ltc3889;
626 else if (chip_id == LTC7880_ID)
627 return ltc7880;
628 else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
629 return ltm2987;
630 else if (chip_id == LTM4664_ID)
631 return ltm4664;
632 else if (chip_id == LTM4675_ID)
633 return ltm4675;
634 else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
635 chip_id == LTM4676A_ID)
636 return ltm4676;
637 else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2)
638 return ltm4677;
639 else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2)
640 return ltm4678;
641 else if (chip_id == LTM4680_ID)
642 return ltm4680;
643 else if (chip_id == LTM4686_ID)
644 return ltm4686;
645 else if (chip_id == LTM4700_ID)
646 return ltm4700;
647
648 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
649 return -ENODEV;
650 }
651
ltc2978_probe(struct i2c_client * client)652 static int ltc2978_probe(struct i2c_client *client)
653 {
654 int i, chip_id;
655 struct ltc2978_data *data;
656 struct pmbus_driver_info *info;
657 const struct i2c_device_id *id;
658
659 if (!i2c_check_functionality(client->adapter,
660 I2C_FUNC_SMBUS_READ_WORD_DATA))
661 return -ENODEV;
662
663 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
664 GFP_KERNEL);
665 if (!data)
666 return -ENOMEM;
667
668 chip_id = ltc2978_get_id(client);
669 if (chip_id < 0)
670 return chip_id;
671
672 data->id = chip_id;
673 id = i2c_match_id(ltc2978_id, client);
674 if (data->id != id->driver_data)
675 dev_warn(&client->dev,
676 "Device mismatch: Configured %s (%d), detected %d\n",
677 id->name,
678 (int) id->driver_data,
679 chip_id);
680
681 info = &data->info;
682 info->write_word_data = ltc2978_write_word_data;
683 info->write_byte = ltc_write_byte;
684 info->read_word_data = ltc_read_word_data;
685 info->read_byte_data = ltc_read_byte_data;
686
687 data->vin_min = 0x7bff;
688 data->vin_max = 0x7c00;
689 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
690 data->vout_min[i] = 0xffff;
691 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
692 data->iout_min[i] = 0xfbff;
693 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
694 data->iout_max[i] = 0x7c00;
695 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
696 data->temp_min[i] = 0x7bff;
697 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
698 data->temp_max[i] = 0x7c00;
699 data->temp2_max = 0x7c00;
700
701 switch (data->id) {
702 case ltc2972:
703 info->read_word_data = ltc2975_read_word_data;
704 info->pages = LTC2972_NUM_PAGES;
705 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
706 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
707 | PMBUS_HAVE_TEMP2;
708 for (i = 0; i < info->pages; i++) {
709 info->func[i] |= PMBUS_HAVE_VOUT
710 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
711 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
712 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
713 }
714 break;
715 case ltc2974:
716 info->read_word_data = ltc2974_read_word_data;
717 info->pages = LTC2974_NUM_PAGES;
718 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
719 | PMBUS_HAVE_TEMP2;
720 for (i = 0; i < info->pages; i++) {
721 info->func[i] |= PMBUS_HAVE_VOUT
722 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
723 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
724 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
725 }
726 break;
727 case ltc2975:
728 info->read_word_data = ltc2975_read_word_data;
729 info->pages = LTC2974_NUM_PAGES;
730 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
731 | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
732 | PMBUS_HAVE_TEMP2;
733 for (i = 0; i < info->pages; i++) {
734 info->func[i] |= PMBUS_HAVE_VOUT
735 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
736 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
737 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
738 }
739 break;
740
741 case ltc2977:
742 case ltc2978:
743 case ltc2979:
744 case ltc2980:
745 case ltm2987:
746 info->read_word_data = ltc2978_read_word_data;
747 info->pages = LTC2978_NUM_PAGES;
748 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
749 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
750 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
751 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
752 info->func[i] = PMBUS_HAVE_VOUT
753 | PMBUS_HAVE_STATUS_VOUT;
754 }
755 break;
756 case ltc3880:
757 case ltc3887:
758 case ltm4675:
759 case ltm4676:
760 case ltm4677:
761 case ltm4686:
762 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
763 info->read_word_data = ltc3880_read_word_data;
764 info->pages = LTC3880_NUM_PAGES;
765 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
766 | PMBUS_HAVE_STATUS_INPUT
767 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
768 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
769 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
770 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
771 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
772 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
773 | PMBUS_HAVE_POUT
774 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
775 break;
776 case ltc3882:
777 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
778 info->read_word_data = ltc3880_read_word_data;
779 info->pages = LTC3880_NUM_PAGES;
780 info->func[0] = PMBUS_HAVE_VIN
781 | PMBUS_HAVE_STATUS_INPUT
782 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
783 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
784 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
785 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
786 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
787 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
788 | PMBUS_HAVE_POUT
789 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
790 break;
791 case ltc3883:
792 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
793 info->read_word_data = ltc3883_read_word_data;
794 info->pages = LTC3883_NUM_PAGES;
795 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
796 | PMBUS_HAVE_STATUS_INPUT
797 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
798 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
799 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
800 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
801 break;
802 case ltc3884:
803 case ltc3886:
804 case ltc3889:
805 case ltc7880:
806 case ltm4664:
807 case ltm4678:
808 case ltm4680:
809 case ltm4700:
810 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
811 info->read_word_data = ltc3883_read_word_data;
812 info->pages = LTC3880_NUM_PAGES;
813 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
814 | PMBUS_HAVE_STATUS_INPUT
815 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
816 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
817 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
818 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
819 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
820 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
821 | PMBUS_HAVE_POUT
822 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
823 break;
824 default:
825 return -ENODEV;
826 }
827
828 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
829 info->num_regulators = info->pages;
830 info->reg_desc = ltc2978_reg_desc;
831 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
832 dev_err(&client->dev, "num_regulators too large!");
833 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
834 }
835 #endif
836
837 return pmbus_do_probe(client, info);
838 }
839
840
841 #ifdef CONFIG_OF
842 static const struct of_device_id ltc2978_of_match[] = {
843 { .compatible = "lltc,ltc2972" },
844 { .compatible = "lltc,ltc2974" },
845 { .compatible = "lltc,ltc2975" },
846 { .compatible = "lltc,ltc2977" },
847 { .compatible = "lltc,ltc2978" },
848 { .compatible = "lltc,ltc2979" },
849 { .compatible = "lltc,ltc2980" },
850 { .compatible = "lltc,ltc3880" },
851 { .compatible = "lltc,ltc3882" },
852 { .compatible = "lltc,ltc3883" },
853 { .compatible = "lltc,ltc3884" },
854 { .compatible = "lltc,ltc3886" },
855 { .compatible = "lltc,ltc3887" },
856 { .compatible = "lltc,ltc3889" },
857 { .compatible = "lltc,ltc7880" },
858 { .compatible = "lltc,ltm2987" },
859 { .compatible = "lltc,ltm4664" },
860 { .compatible = "lltc,ltm4675" },
861 { .compatible = "lltc,ltm4676" },
862 { .compatible = "lltc,ltm4677" },
863 { .compatible = "lltc,ltm4678" },
864 { .compatible = "lltc,ltm4680" },
865 { .compatible = "lltc,ltm4686" },
866 { .compatible = "lltc,ltm4700" },
867 { }
868 };
869 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
870 #endif
871
872 static struct i2c_driver ltc2978_driver = {
873 .driver = {
874 .name = "ltc2978",
875 .of_match_table = of_match_ptr(ltc2978_of_match),
876 },
877 .probe_new = ltc2978_probe,
878 .id_table = ltc2978_id,
879 };
880
881 module_i2c_driver(ltc2978_driver);
882
883 MODULE_AUTHOR("Guenter Roeck");
884 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
885 MODULE_LICENSE("GPL");
886 MODULE_IMPORT_NS(PMBUS);
887