Merge branch 'i2c/for-5.13' of git://git.kernel.org/pub/scm/linux/kernel/git/wsa...
[linux-2.6-microblaze.git] / drivers / hwmon / pmbus / ltc2978.c
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 = &ltc2978_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
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);