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 	lt7170, lt7171, ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887,
27 	ltc3889, ltc7132, ltc7841, ltc7880,
28 	/* Modules */
29 	ltm2987, ltm4664, ltm4673, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680,
30 	ltm4686, ltm4700,
31 };
32 
33 /* Common for all chips */
34 #define LTC2978_MFR_VOUT_PEAK		0xdd
35 #define LTC2978_MFR_VIN_PEAK		0xde
36 #define LTC2978_MFR_TEMPERATURE_PEAK	0xdf
37 #define LTC2978_MFR_SPECIAL_ID		0xe7	/* Undocumented on LTC3882 */
38 #define LTC2978_MFR_COMMON		0xef
39 
40 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */
41 #define LTC2978_MFR_VOUT_MIN		0xfb
42 #define LTC2978_MFR_VIN_MIN		0xfc
43 #define LTC2978_MFR_TEMPERATURE_MIN	0xfd
44 
45 /* LTC2974, LTC2975 */
46 #define LTC2974_MFR_IOUT_PEAK		0xd7
47 #define LTC2974_MFR_IOUT_MIN		0xd8
48 
49 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, LTM4676, LTC7132 */
50 #define LTC3880_MFR_IOUT_PEAK		0xd7
51 #define LTC3880_MFR_CLEAR_PEAKS		0xe3
52 #define LTC3880_MFR_TEMPERATURE2_PEAK	0xf4
53 
54 /* LTC3883, LTC3884, LTC3886, LTC3889, LTC7132, LTC7841 and LTC7880 only */
55 #define LTC3883_MFR_IIN_PEAK		0xe1
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 LT7170_ID			0x1C10
66 #define LTC2972_ID			0x0310
67 #define LTC2974_ID			0x0210
68 #define LTC2975_ID			0x0220
69 #define LTC2977_ID			0x0130
70 #define LTC2978_ID_REV1			0x0110	/* Early revision */
71 #define LTC2978_ID_REV2			0x0120
72 #define LTC2979_ID_A			0x8060
73 #define LTC2979_ID_B			0x8070
74 #define LTC2980_ID_A			0x8030	/* A/B for two die IDs */
75 #define LTC2980_ID_B			0x8040
76 #define LTC3880_ID			0x4020
77 #define LTC3882_ID			0x4200
78 #define LTC3882_ID_D1			0x4240	/* Dash 1 */
79 #define LTC3883_ID			0x4300
80 #define LTC3884_ID			0x4C00
81 #define LTC3886_ID			0x4600
82 #define LTC3887_ID			0x4700
83 #define LTC3889_ID			0x4900
84 #define LTC7132_ID			0x4CE0
85 #define LTC7841_ID			0x40D0
86 #define LTC7880_ID			0x49E0
87 #define LTM2987_ID_A			0x8010	/* A/B for two die IDs */
88 #define LTM2987_ID_B			0x8020
89 #define LTM4664_ID			0x4120
90 #define LTM4673_ID_REV1			0x0230
91 #define LTM4673_ID			0x4480
92 #define LTM4675_ID			0x47a0
93 #define LTM4676_ID_REV1			0x4400
94 #define LTM4676_ID_REV2			0x4480
95 #define LTM4676A_ID			0x47e0
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
101 #define LTM4686_ID			0x4770
102 #define LTM4700_ID			0x4130
103 
104 #define LTC2972_NUM_PAGES		2
105 #define LTC2974_NUM_PAGES		4
106 #define LTC2978_NUM_PAGES		8
107 #define LTC3880_NUM_PAGES		2
108 #define LTC3883_NUM_PAGES		1
109 
110 #define LTC_POLL_TIMEOUT		100	/* in milli-seconds */
111 
112 #define LTC_NOT_BUSY			BIT(6)
113 #define LTC_NOT_PENDING			BIT(5)
114 
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  */
122 
123 struct ltc2978_data {
124 	enum chips id;
125 	u16 vin_min, vin_max;
126 	u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
127 	u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
128 	u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
129 	u16 iin_min, iin_max;
130 	u16 pin_min, pin_max;
131 	u16 temp2_max;
132 	struct pmbus_driver_info info;
133 	u32 features;
134 };
135 #define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)
136 
137 #define FEAT_CLEAR_PEAKS	BIT(0)
138 #define FEAT_NEEDS_POLLING	BIT(1)
139 
140 #define has_clear_peaks(d)	((d)->features & FEAT_CLEAR_PEAKS)
141 #define needs_polling(d)	((d)->features & FEAT_NEEDS_POLLING)
142 
ltc_wait_ready(struct i2c_client * client)143 static 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 
ltc_read_word_data(struct i2c_client * client,int page,int phase,int reg)181 static int ltc_read_word_data(struct i2c_client *client, int page, int phase,
182 			      int reg)
183 {
184 	int ret;
185 
186 	ret = ltc_wait_ready(client);
187 	if (ret < 0)
188 		return ret;
189 
190 	return pmbus_read_word_data(client, page, 0xff, reg);
191 }
192 
ltc_read_byte_data(struct i2c_client * client,int page,int reg)193 static 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 
ltc_write_byte_data(struct i2c_client * client,int page,int reg,u8 value)204 static 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 
ltc_write_byte(struct i2c_client * client,int page,u8 byte)215 static 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 }
225 
lin11_to_val(int data)226 static 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 
ltc_get_max(struct ltc2978_data * data,struct i2c_client * client,int page,int reg,u16 * pmax)239 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
240 		       int page, int reg, u16 *pmax)
241 {
242 	int ret;
243 
244 	ret = ltc_read_word_data(client, page, 0xff, reg);
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 
ltc_get_min(struct ltc2978_data * data,struct i2c_client * client,int page,int reg,u16 * pmin)253 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
254 		       int page, int reg, u16 *pmin)
255 {
256 	int ret;
257 
258 	ret = ltc_read_word_data(client, page, 0xff, reg);
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 
ltc2978_read_word_data_common(struct i2c_client * client,int page,int reg)267 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
268 					 int reg)
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:
276 		ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
277 				  &data->vin_max);
278 		break;
279 	case PMBUS_VIRT_READ_VOUT_MAX:
280 		ret = ltc_read_word_data(client, page, 0xff,
281 					 LTC2978_MFR_VOUT_PEAK);
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:
293 		ret = ltc_get_max(data, client, page,
294 				  LTC2978_MFR_TEMPERATURE_PEAK,
295 				  &data->temp_max[page]);
296 		break;
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:
303 		ret = ltc_wait_ready(client);
304 		if (ret < 0)
305 			return ret;
306 		ret = -ENODATA;
307 		break;
308 	}
309 	return ret;
310 }
311 
ltc2978_read_word_data(struct i2c_client * client,int page,int phase,int reg)312 static int ltc2978_read_word_data(struct i2c_client *client, int page,
313 				  int phase, int reg)
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) {
320 	case PMBUS_VIRT_READ_VIN_MIN:
321 		ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
322 				  &data->vin_min);
323 		break;
324 	case PMBUS_VIRT_READ_VOUT_MIN:
325 		ret = ltc_read_word_data(client, page, phase,
326 					 LTC2978_MFR_VOUT_MIN);
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:
342 		ret = ltc_get_min(data, client, page,
343 				  LTC2978_MFR_TEMPERATURE_MIN,
344 				  &data->temp_min[page]);
345 		break;
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 
ltc2974_read_word_data(struct i2c_client * client,int page,int phase,int reg)359 static int ltc2974_read_word_data(struct i2c_client *client, int page,
360 				  int phase, int reg)
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:
368 		ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
369 				  &data->iout_max[page]);
370 		break;
371 	case PMBUS_VIRT_READ_IOUT_MIN:
372 		ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
373 				  &data->iout_min[page]);
374 		break;
375 	case PMBUS_VIRT_RESET_IOUT_HISTORY:
376 		ret = 0;
377 		break;
378 	default:
379 		ret = ltc2978_read_word_data(client, page, phase, reg);
380 		break;
381 	}
382 	return ret;
383 }
384 
ltc2975_read_word_data(struct i2c_client * client,int page,int phase,int reg)385 static int ltc2975_read_word_data(struct i2c_client *client, int page,
386 				  int phase, int reg)
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:
394 		ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
395 				  &data->iin_max);
396 		break;
397 	case PMBUS_VIRT_READ_IIN_MIN:
398 		ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
399 				  &data->iin_min);
400 		break;
401 	case PMBUS_VIRT_READ_PIN_MAX:
402 		ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
403 				  &data->pin_max);
404 		break;
405 	case PMBUS_VIRT_READ_PIN_MIN:
406 		ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
407 				  &data->pin_min);
408 		break;
409 	case PMBUS_VIRT_RESET_IIN_HISTORY:
410 	case PMBUS_VIRT_RESET_PIN_HISTORY:
411 		ret = 0;
412 		break;
413 	default:
414 		ret = ltc2978_read_word_data(client, page, phase, reg);
415 		break;
416 	}
417 	return ret;
418 }
419 
ltc3880_read_word_data(struct i2c_client * client,int page,int phase,int reg)420 static int ltc3880_read_word_data(struct i2c_client *client, int page,
421 				  int phase, int reg)
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:
429 		ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
430 				  &data->iout_max[page]);
431 		break;
432 	case PMBUS_VIRT_READ_TEMP2_MAX:
433 		ret = ltc_get_max(data, client, page,
434 				  LTC3880_MFR_TEMPERATURE2_PEAK,
435 				  &data->temp2_max);
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:
444 		ret = 0;
445 		break;
446 	default:
447 		ret = ltc2978_read_word_data_common(client, page, reg);
448 		break;
449 	}
450 	return ret;
451 }
452 
ltc3883_read_word_data(struct i2c_client * client,int page,int phase,int reg)453 static int ltc3883_read_word_data(struct i2c_client *client, int page,
454 				  int phase, int reg)
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:
462 		ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
463 				  &data->iin_max);
464 		break;
465 	case PMBUS_VIRT_RESET_IIN_HISTORY:
466 		ret = 0;
467 		break;
468 	default:
469 		ret = ltc3880_read_word_data(client, page, phase, reg);
470 		break;
471 	}
472 	return ret;
473 }
474 
ltc2978_clear_peaks(struct ltc2978_data * data,struct i2c_client * client,int page)475 static int ltc2978_clear_peaks(struct ltc2978_data *data,
476 			       struct i2c_client *client, int page)
477 {
478 	int ret;
479 
480 	if (has_clear_peaks(data))
481 		ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
482 	else
483 		ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
484 
485 	return ret;
486 }
487 
ltc2978_write_word_data(struct i2c_client * client,int page,int reg,u16 word)488 static 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) {
496 	case PMBUS_VIRT_RESET_IIN_HISTORY:
497 		data->iin_max = 0x7c00;
498 		data->iin_min = 0x7bff;
499 		ret = ltc2978_clear_peaks(data, client, 0);
500 		break;
501 	case PMBUS_VIRT_RESET_PIN_HISTORY:
502 		data->pin_max = 0x7c00;
503 		data->pin_min = 0x7bff;
504 		ret = ltc2978_clear_peaks(data, client, 0);
505 		break;
506 	case PMBUS_VIRT_RESET_IOUT_HISTORY:
507 		data->iout_max[page] = 0x7c00;
508 		data->iout_min[page] = 0xfbff;
509 		ret = ltc2978_clear_peaks(data, client, page);
510 		break;
511 	case PMBUS_VIRT_RESET_TEMP2_HISTORY:
512 		data->temp2_max = 0x7c00;
513 		ret = ltc2978_clear_peaks(data, client, page);
514 		break;
515 	case PMBUS_VIRT_RESET_VOUT_HISTORY:
516 		data->vout_min[page] = 0xffff;
517 		data->vout_max[page] = 0;
518 		ret = ltc2978_clear_peaks(data, client, page);
519 		break;
520 	case PMBUS_VIRT_RESET_VIN_HISTORY:
521 		data->vin_min = 0x7bff;
522 		data->vin_max = 0x7c00;
523 		ret = ltc2978_clear_peaks(data, client, page);
524 		break;
525 	case PMBUS_VIRT_RESET_TEMP_HISTORY:
526 		data->temp_min[page] = 0x7bff;
527 		data->temp_max[page] = 0x7c00;
528 		ret = ltc2978_clear_peaks(data, client, page);
529 		break;
530 	default:
531 		ret = ltc_wait_ready(client);
532 		if (ret < 0)
533 			return ret;
534 		ret = -ENODATA;
535 		break;
536 	}
537 	return ret;
538 }
539 
540 static const struct i2c_device_id ltc2978_id[] = {
541 	{"lt7170", lt7170},
542 	{"lt7171", lt7171},
543 	{"ltc2972", ltc2972},
544 	{"ltc2974", ltc2974},
545 	{"ltc2975", ltc2975},
546 	{"ltc2977", ltc2977},
547 	{"ltc2978", ltc2978},
548 	{"ltc2979", ltc2979},
549 	{"ltc2980", ltc2980},
550 	{"ltc3880", ltc3880},
551 	{"ltc3882", ltc3882},
552 	{"ltc3883", ltc3883},
553 	{"ltc3884", ltc3884},
554 	{"ltc3886", ltc3886},
555 	{"ltc3887", ltc3887},
556 	{"ltc3889", ltc3889},
557 	{"ltc7132", ltc7132},
558 	{"ltc7841", ltc7841},
559 	{"ltc7880", ltc7880},
560 	{"ltm2987", ltm2987},
561 	{"ltm4664", ltm4664},
562 	{"ltm4673", ltm4673},
563 	{"ltm4675", ltm4675},
564 	{"ltm4676", ltm4676},
565 	{"ltm4677", ltm4677},
566 	{"ltm4678", ltm4678},
567 	{"ltm4680", ltm4680},
568 	{"ltm4686", ltm4686},
569 	{"ltm4700", ltm4700},
570 	{}
571 };
572 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
573 
574 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
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 
581 static const struct regulator_desc ltc2978_reg_desc[] = {
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),
590 };
591 
592 static const struct regulator_desc ltc2978_reg_desc_default[] = {
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 
ltc2978_get_id(struct i2c_client * client)604 static 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);
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;
621 		if (ret < 3 || (strncmp(buf, "LTC", 3) && strncmp(buf, "ADI", 3)))
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 	}
633 
634 	chip_id &= LTC2978_ID_MASK;
635 
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 
655 	if (chip_id == LTC2972_ID)
656 		return ltc2972;
657 	else if (chip_id == LTC2974_ID)
658 		return ltc2974;
659 	else if (chip_id == LTC2975_ID)
660 		return ltc2975;
661 	else if (chip_id == LTC2977_ID)
662 		return ltc2977;
663 	else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
664 		return ltc2978;
665 	else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
666 		return ltc2979;
667 	else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
668 		return ltc2980;
669 	else if (chip_id == LTC3880_ID)
670 		return ltc3880;
671 	else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
672 		return ltc3882;
673 	else if (chip_id == LTC3883_ID)
674 		return ltc3883;
675 	else if (chip_id == LTC3884_ID)
676 		return ltc3884;
677 	else if (chip_id == LTC3886_ID)
678 		return ltc3886;
679 	else if (chip_id == LTC3887_ID)
680 		return ltc3887;
681 	else if (chip_id == LTC3889_ID)
682 		return ltc3889;
683 	else if (chip_id == LTC7132_ID)
684 		return ltc7132;
685 	else if (chip_id == LTC7841_ID)
686 		return ltc7841;
687 	else if (chip_id == LTC7880_ID)
688 		return ltc7880;
689 	else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
690 		return ltm2987;
691 	else if (chip_id == LTM4664_ID)
692 		return ltm4664;
693 	else if (chip_id == LTM4673_ID || chip_id == LTM4673_ID_REV1)
694 		return ltm4673;
695 	else if (chip_id == LTM4675_ID)
696 		return ltm4675;
697 	else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
698 		 chip_id == LTM4676A_ID)
699 		return ltm4676;
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;
706 	else if (chip_id == LTM4686_ID)
707 		return ltm4686;
708 	else if (chip_id == LTM4700_ID)
709 		return ltm4700;
710 
711 	dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
712 	return -ENODEV;
713 }
714 
ltc2978_probe(struct i2c_client * client)715 static int ltc2978_probe(struct i2c_client *client)
716 {
717 	int i, chip_id;
718 	struct ltc2978_data *data;
719 	struct pmbus_driver_info *info;
720 	const struct i2c_device_id *id;
721 
722 	if (!i2c_check_functionality(client->adapter,
723 				     I2C_FUNC_SMBUS_READ_WORD_DATA))
724 		return -ENODEV;
725 
726 	data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
727 			    GFP_KERNEL);
728 	if (!data)
729 		return -ENOMEM;
730 
731 	chip_id = ltc2978_get_id(client);
732 	if (chip_id < 0)
733 		return chip_id;
734 
735 	data->id = chip_id;
736 	id = i2c_match_id(ltc2978_id, client);
737 	if (data->id != id->driver_data)
738 		dev_warn(&client->dev,
739 			 "Device mismatch: Configured %s (%d), detected %d\n",
740 			 id->name,
741 			 (int) id->driver_data,
742 			 chip_id);
743 
744 	info = &data->info;
745 	info->write_word_data = ltc2978_write_word_data;
746 	info->write_byte = ltc_write_byte;
747 	info->write_byte_data = ltc_write_byte_data;
748 	info->read_word_data = ltc_read_word_data;
749 	info->read_byte_data = ltc_read_byte_data;
750 
751 	data->vin_min = 0x7bff;
752 	data->vin_max = 0x7c00;
753 	for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
754 		data->vout_min[i] = 0xffff;
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;
761 	for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
762 		data->temp_max[i] = 0x7c00;
763 	data->temp2_max = 0x7c00;
764 
765 	switch (data->id) {
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;
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;
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;
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;
818 
819 	case ltc2977:
820 	case ltc2978:
821 	case ltc2979:
822 	case ltc2980:
823 	case ltm2987:
824 		info->read_word_data = ltc2978_read_word_data;
825 		info->pages = LTC2978_NUM_PAGES;
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;
829 		for (i = 1; i < LTC2978_NUM_PAGES; i++) {
830 			info->func[i] = PMBUS_HAVE_VOUT
831 			  | PMBUS_HAVE_STATUS_VOUT;
832 		}
833 		break;
834 	case ltc3880:
835 	case ltc3887:
836 	case ltm4675:
837 	case ltm4676:
838 	case ltm4677:
839 	case ltm4686:
840 		data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
841 		info->read_word_data = ltc3880_read_word_data;
842 		info->pages = LTC3880_NUM_PAGES;
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;
853 		break;
854 	case ltc3882:
855 		data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
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;
869 	case ltc3883:
870 		data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
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;
879 		break;
880 	case ltc3884:
881 	case ltc3886:
882 	case ltc3889:
883 	case ltc7132:
884 	case ltc7880:
885 	case ltm4664:
886 	case ltm4678:
887 	case ltm4680:
888 	case ltm4700:
889 		data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
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;
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;
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;
928 	default:
929 		return -ENODEV;
930 	}
931 
932 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
933 	info->num_regulators = info->pages;
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;
957 	}
958 #endif
959 
960 	return pmbus_do_probe(client, info);
961 }
962 
963 
964 #ifdef CONFIG_OF
965 static const struct of_device_id ltc2978_of_match[] = {
966 	{ .compatible = "lltc,lt7170" },
967 	{ .compatible = "lltc,lt7171" },
968 	{ .compatible = "lltc,ltc2972" },
969 	{ .compatible = "lltc,ltc2974" },
970 	{ .compatible = "lltc,ltc2975" },
971 	{ .compatible = "lltc,ltc2977" },
972 	{ .compatible = "lltc,ltc2978" },
973 	{ .compatible = "lltc,ltc2979" },
974 	{ .compatible = "lltc,ltc2980" },
975 	{ .compatible = "lltc,ltc3880" },
976 	{ .compatible = "lltc,ltc3882" },
977 	{ .compatible = "lltc,ltc3883" },
978 	{ .compatible = "lltc,ltc3884" },
979 	{ .compatible = "lltc,ltc3886" },
980 	{ .compatible = "lltc,ltc3887" },
981 	{ .compatible = "lltc,ltc3889" },
982 	{ .compatible = "lltc,ltc7132" },
983 	{ .compatible = "lltc,ltc7841" },
984 	{ .compatible = "lltc,ltc7880" },
985 	{ .compatible = "lltc,ltm2987" },
986 	{ .compatible = "lltc,ltm4664" },
987 	{ .compatible = "lltc,ltm4673" },
988 	{ .compatible = "lltc,ltm4675" },
989 	{ .compatible = "lltc,ltm4676" },
990 	{ .compatible = "lltc,ltm4677" },
991 	{ .compatible = "lltc,ltm4678" },
992 	{ .compatible = "lltc,ltm4680" },
993 	{ .compatible = "lltc,ltm4686" },
994 	{ .compatible = "lltc,ltm4700" },
995 	{ }
996 };
997 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
998 #endif
999 
1000 static struct i2c_driver ltc2978_driver = {
1001 	.driver = {
1002 		   .name = "ltc2978",
1003 		   .of_match_table = of_match_ptr(ltc2978_of_match),
1004 		   },
1005 	.probe = ltc2978_probe,
1006 	.id_table = ltc2978_id,
1007 };
1008 
1009 module_i2c_driver(ltc2978_driver);
1010 
1011 MODULE_AUTHOR("Guenter Roeck");
1012 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
1013 MODULE_LICENSE("GPL");
1014 MODULE_IMPORT_NS("PMBUS");
1015