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