1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Hardware monitoring driver for Analog Devices ADM1275 Hot-Swap Controller
4 * and Digital Power Monitor
5 *
6 * Copyright (c) 2011 Ericsson AB.
7 * Copyright (c) 2018 Guenter Roeck
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/i2c.h>
16 #include <linux/bitops.h>
17 #include <linux/bitfield.h>
18 #include <linux/log2.h>
19 #include "pmbus.h"
20
21 enum chips { adm1075, adm1272, adm1273, adm1275, adm1276, adm1278, adm1281,
22 adm1293, adm1294, bd12780, bd12790, sq24905c };
23
24 #define ADM1275_MFR_STATUS_IOUT_WARN2 BIT(0)
25 #define ADM1293_MFR_STATUS_VAUX_UV_WARN BIT(5)
26 #define ADM1293_MFR_STATUS_VAUX_OV_WARN BIT(6)
27
28 #define ADM1275_PEAK_IOUT 0xd0
29 #define ADM1275_PEAK_VIN 0xd1
30 #define ADM1275_PEAK_VOUT 0xd2
31 #define ADM1275_PMON_CONTROL 0xd3
32 #define ADM1275_PMON_CONFIG 0xd4
33
34 #define ADM1275_CONVERT_EN BIT(0)
35
36 #define ADM1275_VIN_VOUT_SELECT BIT(6)
37 #define ADM1275_VRANGE BIT(5)
38 #define ADM1075_IRANGE_50 BIT(4)
39 #define ADM1075_IRANGE_25 BIT(3)
40 #define ADM1075_IRANGE_MASK (BIT(3) | BIT(4))
41
42 #define ADM1272_IRANGE BIT(0)
43
44 #define ADM1278_TSFILT BIT(15)
45 #define ADM1278_TEMP1_EN BIT(3)
46 #define ADM1278_VIN_EN BIT(2)
47 #define ADM1278_VOUT_EN BIT(1)
48
49 #define ADM1278_PMON_DEFCONFIG (ADM1278_VOUT_EN | ADM1278_TEMP1_EN | ADM1278_TSFILT)
50 /* The BD127[89]0 data sheets mark TSFILT bit as reserved. */
51 #define BD12780_PMON_DEFCONFIG (ADM1278_VOUT_EN | ADM1278_TEMP1_EN)
52
53 #define ADM1293_IRANGE_25 0
54 #define ADM1293_IRANGE_50 BIT(6)
55 #define ADM1293_IRANGE_100 BIT(7)
56 #define ADM1293_IRANGE_200 (BIT(6) | BIT(7))
57 #define ADM1293_IRANGE_MASK (BIT(6) | BIT(7))
58
59 #define ADM1293_VIN_SEL_012 BIT(2)
60 #define ADM1293_VIN_SEL_074 BIT(3)
61 #define ADM1293_VIN_SEL_210 (BIT(2) | BIT(3))
62 #define ADM1293_VIN_SEL_MASK (BIT(2) | BIT(3))
63
64 #define ADM1293_VAUX_EN BIT(1)
65
66 #define ADM1278_PEAK_TEMP 0xd7
67 #define ADM1275_IOUT_WARN2_LIMIT 0xd7
68 #define ADM1275_DEVICE_CONFIG 0xd8
69
70 #define ADM1275_IOUT_WARN2_SELECT BIT(4)
71
72 #define ADM1276_PEAK_PIN 0xda
73 #define ADM1075_READ_VAUX 0xdd
74 #define ADM1075_VAUX_OV_WARN_LIMIT 0xde
75 #define ADM1075_VAUX_UV_WARN_LIMIT 0xdf
76 #define ADM1293_IOUT_MIN 0xe3
77 #define ADM1293_PIN_MIN 0xe4
78 #define ADM1075_VAUX_STATUS 0xf6
79
80 #define ADM1075_VAUX_OV_WARN BIT(7)
81 #define ADM1075_VAUX_UV_WARN BIT(6)
82
83 #define ADM1275_VI_AVG_SHIFT 0
84 #define ADM1275_VI_AVG_MASK GENMASK(ADM1275_VI_AVG_SHIFT + 2, \
85 ADM1275_VI_AVG_SHIFT)
86 #define ADM1275_SAMPLES_AVG_MAX 128
87
88 #define ADM1278_PWR_AVG_SHIFT 11
89 #define ADM1278_PWR_AVG_MASK GENMASK(ADM1278_PWR_AVG_SHIFT + 2, \
90 ADM1278_PWR_AVG_SHIFT)
91 #define ADM1278_VI_AVG_SHIFT 8
92 #define ADM1278_VI_AVG_MASK GENMASK(ADM1278_VI_AVG_SHIFT + 2, \
93 ADM1278_VI_AVG_SHIFT)
94
95 struct adm1275_data {
96 int id;
97 bool have_oc_fault;
98 bool have_uc_fault;
99 bool have_vout;
100 bool have_vaux_status;
101 bool have_mfr_vaux_status;
102 bool have_iout_min;
103 bool have_pin_min;
104 bool have_pin_max;
105 bool have_temp_max;
106 bool have_power_sampling;
107 struct pmbus_driver_info info;
108 };
109
110 #define to_adm1275_data(x) container_of(x, struct adm1275_data, info)
111
112 struct coefficients {
113 s16 m;
114 s16 b;
115 s16 R;
116 };
117
118 static const struct coefficients adm1075_coefficients[] = {
119 [0] = { 27169, 0, -1 }, /* voltage */
120 [1] = { 806, 20475, -1 }, /* current, irange25 */
121 [2] = { 404, 20475, -1 }, /* current, irange50 */
122 [3] = { 8549, 0, -1 }, /* power, irange25 */
123 [4] = { 4279, 0, -1 }, /* power, irange50 */
124 };
125
126 static const struct coefficients adm1272_coefficients[] = {
127 [0] = { 6770, 0, -2 }, /* voltage, vrange 60V */
128 [1] = { 4062, 0, -2 }, /* voltage, vrange 100V */
129 [2] = { 1326, 20480, -1 }, /* current, vsense range 15mV */
130 [3] = { 663, 20480, -1 }, /* current, vsense range 30mV */
131 [4] = { 3512, 0, -2 }, /* power, vrange 60V, irange 15mV */
132 [5] = { 21071, 0, -3 }, /* power, vrange 100V, irange 15mV */
133 [6] = { 17561, 0, -3 }, /* power, vrange 60V, irange 30mV */
134 [7] = { 10535, 0, -3 }, /* power, vrange 100V, irange 30mV */
135 [8] = { 42, 31871, -1 }, /* temperature */
136
137 };
138
139 /*
140 * BD12790 coefficients derived from preliminary datasheet, Table 1 (p.18)
141 * and the PMBus direct-format relationship X = (Y * 10^(-R) - b) / m.
142 *
143 * Voltage: V[V] = 14.77e-3 * code (60V) / 24.62e-3 * code (100V)
144 * -> m = 6770, R=-2 / m = 4062, R=-2
145 * Current: code = I[A] * RS * 132802.1 + 2048 (15mV) / * 66401.06 + 2048 (30mV)
146 * -> m = 1328, b = 2048 * 10^(-R) = 20480, R=-1 / m = 664, same b and R
147 * Power: code = k * RS * PIN, k = 35119.94 / 17559.97 / 21071.44 / 10535.72
148 * -> m = round(k * 10^(-3-R)), R=-2 for 60V/15mV, R=-3 for the other three
149 * Temperature: code = 4.2 * T + 3188 -> m = 42, b = 3188 * 10 = 31880, R=-1
150 */
151 static const struct coefficients bd12790_coefficients[] = {
152 [0] = { 6770, 0, -2 }, /* voltage, vrange 60V */
153 [1] = { 4062, 0, -2 }, /* voltage, vrange 100V */
154 [2] = { 1328, 20480, -1 }, /* current, vsense range 15mV */
155 [3] = { 664, 20480, -1 }, /* current, vsense range 30mV */
156 [4] = { 3512, 0, -2 }, /* power, vrange 60V, irange 15mV */
157 [5] = { 21071, 0, -3 }, /* power, vrange 100V, irange 15mV */
158 [6] = { 17560, 0, -3 }, /* power, vrange 60V, irange 30mV */
159 [7] = { 10536, 0, -3 }, /* power, vrange 100V, irange 30mV */
160 [8] = { 42, 31880, -1 }, /* temperature */
161 };
162
163 static const struct coefficients adm1275_coefficients[] = {
164 [0] = { 19199, 0, -2 }, /* voltage, vrange set */
165 [1] = { 6720, 0, -1 }, /* voltage, vrange not set */
166 [2] = { 807, 20475, -1 }, /* current */
167 };
168
169 static const struct coefficients adm1276_coefficients[] = {
170 [0] = { 19199, 0, -2 }, /* voltage, vrange set */
171 [1] = { 6720, 0, -1 }, /* voltage, vrange not set */
172 [2] = { 807, 20475, -1 }, /* current */
173 [3] = { 6043, 0, -2 }, /* power, vrange set */
174 [4] = { 2115, 0, -1 }, /* power, vrange not set */
175 };
176
177 static const struct coefficients adm1278_coefficients[] = {
178 [0] = { 19599, 0, -2 }, /* voltage */
179 [1] = { 800, 20475, -1 }, /* current */
180 [2] = { 6123, 0, -2 }, /* power */
181 [3] = { 42, 31880, -1 }, /* temperature */
182 };
183
184 static const struct coefficients adm1293_coefficients[] = {
185 [0] = { 3333, -1, 0 }, /* voltage, vrange 1.2V */
186 [1] = { 5552, -5, -1 }, /* voltage, vrange 7.4V */
187 [2] = { 19604, -50, -2 }, /* voltage, vrange 21V */
188 [3] = { 8000, -100, -2 }, /* current, irange25 */
189 [4] = { 4000, -100, -2 }, /* current, irange50 */
190 [5] = { 20000, -1000, -3 }, /* current, irange100 */
191 [6] = { 10000, -1000, -3 }, /* current, irange200 */
192 [7] = { 10417, 0, -1 }, /* power, 1.2V, irange25 */
193 [8] = { 5208, 0, -1 }, /* power, 1.2V, irange50 */
194 [9] = { 26042, 0, -2 }, /* power, 1.2V, irange100 */
195 [10] = { 13021, 0, -2 }, /* power, 1.2V, irange200 */
196 [11] = { 17351, 0, -2 }, /* power, 7.4V, irange25 */
197 [12] = { 8676, 0, -2 }, /* power, 7.4V, irange50 */
198 [13] = { 4338, 0, -2 }, /* power, 7.4V, irange100 */
199 [14] = { 21689, 0, -3 }, /* power, 7.4V, irange200 */
200 [15] = { 6126, 0, -2 }, /* power, 21V, irange25 */
201 [16] = { 30631, 0, -3 }, /* power, 21V, irange50 */
202 [17] = { 15316, 0, -3 }, /* power, 21V, irange100 */
203 [18] = { 7658, 0, -3 }, /* power, 21V, irange200 */
204 };
205
adm1275_read_samples(const struct adm1275_data * data,struct i2c_client * client,bool is_power)206 static int adm1275_read_samples(const struct adm1275_data *data,
207 struct i2c_client *client, bool is_power)
208 {
209 int shift, ret;
210 u16 mask;
211
212 /*
213 * The PMON configuration register is a 16-bit register only on chips
214 * supporting power average sampling. On other chips it is an 8-bit
215 * register.
216 */
217 if (data->have_power_sampling) {
218 ret = i2c_smbus_read_word_data(client, ADM1275_PMON_CONFIG);
219 mask = is_power ? ADM1278_PWR_AVG_MASK : ADM1278_VI_AVG_MASK;
220 shift = is_power ? ADM1278_PWR_AVG_SHIFT : ADM1278_VI_AVG_SHIFT;
221 } else {
222 ret = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
223 mask = ADM1275_VI_AVG_MASK;
224 shift = ADM1275_VI_AVG_SHIFT;
225 }
226 if (ret < 0)
227 return ret;
228
229 return (ret & mask) >> shift;
230 }
231
adm1275_write_pmon_config(const struct adm1275_data * data,struct i2c_client * client,u16 word)232 static int adm1275_write_pmon_config(const struct adm1275_data *data,
233 struct i2c_client *client, u16 word)
234 {
235 int ret, ret2;
236
237 ret = i2c_smbus_write_byte_data(client, ADM1275_PMON_CONTROL, 0);
238 if (ret)
239 return ret;
240
241 if (data->have_power_sampling)
242 ret = i2c_smbus_write_word_data(client, ADM1275_PMON_CONFIG,
243 word);
244 else
245 ret = i2c_smbus_write_byte_data(client, ADM1275_PMON_CONFIG,
246 word);
247
248 /*
249 * We still want to re-enable conversions if writing into
250 * ADM1275_PMON_CONFIG failed.
251 */
252 ret2 = i2c_smbus_write_byte_data(client, ADM1275_PMON_CONTROL,
253 ADM1275_CONVERT_EN);
254 if (!ret)
255 ret = ret2;
256
257 return ret;
258 }
259
adm1275_write_samples(const struct adm1275_data * data,struct i2c_client * client,bool is_power,u16 word)260 static int adm1275_write_samples(const struct adm1275_data *data,
261 struct i2c_client *client,
262 bool is_power, u16 word)
263 {
264 int shift, ret;
265 u16 mask;
266
267 if (data->have_power_sampling) {
268 ret = i2c_smbus_read_word_data(client, ADM1275_PMON_CONFIG);
269 mask = is_power ? ADM1278_PWR_AVG_MASK : ADM1278_VI_AVG_MASK;
270 shift = is_power ? ADM1278_PWR_AVG_SHIFT : ADM1278_VI_AVG_SHIFT;
271 } else {
272 ret = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
273 mask = ADM1275_VI_AVG_MASK;
274 shift = ADM1275_VI_AVG_SHIFT;
275 }
276 if (ret < 0)
277 return ret;
278
279 word = (ret & ~mask) | ((word << shift) & mask);
280
281 return adm1275_write_pmon_config(data, client, word);
282 }
283
adm1275_read_word_data(struct i2c_client * client,int page,int phase,int reg)284 static int adm1275_read_word_data(struct i2c_client *client, int page,
285 int phase, int reg)
286 {
287 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
288 const struct adm1275_data *data = to_adm1275_data(info);
289 int ret = 0;
290
291 if (page > 0)
292 return -ENXIO;
293
294 switch (reg) {
295 case PMBUS_IOUT_UC_FAULT_LIMIT:
296 if (!data->have_uc_fault)
297 return -ENXIO;
298 ret = pmbus_read_word_data(client, 0, 0xff,
299 ADM1275_IOUT_WARN2_LIMIT);
300 break;
301 case PMBUS_IOUT_OC_FAULT_LIMIT:
302 if (!data->have_oc_fault)
303 return -ENXIO;
304 ret = pmbus_read_word_data(client, 0, 0xff,
305 ADM1275_IOUT_WARN2_LIMIT);
306 break;
307 case PMBUS_VOUT_OV_WARN_LIMIT:
308 if (data->have_vout)
309 return -ENODATA;
310 ret = pmbus_read_word_data(client, 0, 0xff,
311 ADM1075_VAUX_OV_WARN_LIMIT);
312 break;
313 case PMBUS_VOUT_UV_WARN_LIMIT:
314 if (data->have_vout)
315 return -ENODATA;
316 ret = pmbus_read_word_data(client, 0, 0xff,
317 ADM1075_VAUX_UV_WARN_LIMIT);
318 break;
319 case PMBUS_READ_VOUT:
320 if (data->have_vout)
321 return -ENODATA;
322 ret = pmbus_read_word_data(client, 0, 0xff,
323 ADM1075_READ_VAUX);
324 break;
325 case PMBUS_VIRT_READ_IOUT_MIN:
326 if (!data->have_iout_min)
327 return -ENXIO;
328 ret = pmbus_read_word_data(client, 0, 0xff,
329 ADM1293_IOUT_MIN);
330 break;
331 case PMBUS_VIRT_READ_IOUT_MAX:
332 ret = pmbus_read_word_data(client, 0, 0xff,
333 ADM1275_PEAK_IOUT);
334 break;
335 case PMBUS_VIRT_READ_VOUT_MAX:
336 ret = pmbus_read_word_data(client, 0, 0xff,
337 ADM1275_PEAK_VOUT);
338 break;
339 case PMBUS_VIRT_READ_VIN_MAX:
340 ret = pmbus_read_word_data(client, 0, 0xff,
341 ADM1275_PEAK_VIN);
342 break;
343 case PMBUS_VIRT_READ_PIN_MIN:
344 if (!data->have_pin_min)
345 return -ENXIO;
346 ret = pmbus_read_word_data(client, 0, 0xff,
347 ADM1293_PIN_MIN);
348 break;
349 case PMBUS_VIRT_READ_PIN_MAX:
350 if (!data->have_pin_max)
351 return -ENXIO;
352 ret = pmbus_read_word_data(client, 0, 0xff,
353 ADM1276_PEAK_PIN);
354 break;
355 case PMBUS_VIRT_READ_TEMP_MAX:
356 if (!data->have_temp_max)
357 return -ENXIO;
358 ret = pmbus_read_word_data(client, 0, 0xff,
359 ADM1278_PEAK_TEMP);
360 break;
361 case PMBUS_VIRT_RESET_IOUT_HISTORY:
362 case PMBUS_VIRT_RESET_VOUT_HISTORY:
363 case PMBUS_VIRT_RESET_VIN_HISTORY:
364 break;
365 case PMBUS_VIRT_RESET_PIN_HISTORY:
366 if (!data->have_pin_max)
367 return -ENXIO;
368 break;
369 case PMBUS_VIRT_RESET_TEMP_HISTORY:
370 if (!data->have_temp_max)
371 return -ENXIO;
372 break;
373 case PMBUS_VIRT_POWER_SAMPLES:
374 if (!data->have_power_sampling)
375 return -ENXIO;
376 ret = adm1275_read_samples(data, client, true);
377 if (ret < 0)
378 break;
379 ret = BIT(ret);
380 break;
381 case PMBUS_VIRT_IN_SAMPLES:
382 case PMBUS_VIRT_CURR_SAMPLES:
383 ret = adm1275_read_samples(data, client, false);
384 if (ret < 0)
385 break;
386 ret = BIT(ret);
387 break;
388 default:
389 ret = -ENODATA;
390 break;
391 }
392 return ret;
393 }
394
adm1275_write_word_data(struct i2c_client * client,int page,int reg,u16 word)395 static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
396 u16 word)
397 {
398 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
399 const struct adm1275_data *data = to_adm1275_data(info);
400 int ret;
401
402 if (page > 0)
403 return -ENXIO;
404
405 switch (reg) {
406 case PMBUS_IOUT_UC_FAULT_LIMIT:
407 case PMBUS_IOUT_OC_FAULT_LIMIT:
408 ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
409 word);
410 break;
411 case PMBUS_VIRT_RESET_IOUT_HISTORY:
412 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
413 if (!ret && data->have_iout_min)
414 ret = pmbus_write_word_data(client, 0,
415 ADM1293_IOUT_MIN, 0);
416 break;
417 case PMBUS_VIRT_RESET_VOUT_HISTORY:
418 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
419 break;
420 case PMBUS_VIRT_RESET_VIN_HISTORY:
421 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
422 break;
423 case PMBUS_VIRT_RESET_PIN_HISTORY:
424 ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
425 if (!ret && data->have_pin_min)
426 ret = pmbus_write_word_data(client, 0,
427 ADM1293_PIN_MIN, 0);
428 break;
429 case PMBUS_VIRT_RESET_TEMP_HISTORY:
430 ret = pmbus_write_word_data(client, 0, ADM1278_PEAK_TEMP, 0);
431 break;
432 case PMBUS_VIRT_POWER_SAMPLES:
433 if (!data->have_power_sampling)
434 return -ENXIO;
435 word = clamp_val(word, 1, ADM1275_SAMPLES_AVG_MAX);
436 ret = adm1275_write_samples(data, client, true, ilog2(word));
437 break;
438 case PMBUS_VIRT_IN_SAMPLES:
439 case PMBUS_VIRT_CURR_SAMPLES:
440 word = clamp_val(word, 1, ADM1275_SAMPLES_AVG_MAX);
441 ret = adm1275_write_samples(data, client, false, ilog2(word));
442 break;
443 default:
444 ret = -ENODATA;
445 break;
446 }
447 return ret;
448 }
449
adm1275_read_byte_data(struct i2c_client * client,int page,int reg)450 static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
451 {
452 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
453 const struct adm1275_data *data = to_adm1275_data(info);
454 int mfr_status, ret;
455
456 if (page > 0)
457 return -ENXIO;
458
459 switch (reg) {
460 case PMBUS_STATUS_IOUT:
461 ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
462 if (ret < 0)
463 break;
464 if (!data->have_oc_fault && !data->have_uc_fault)
465 break;
466 mfr_status = pmbus_read_byte_data(client, page,
467 PMBUS_STATUS_MFR_SPECIFIC);
468 if (mfr_status < 0)
469 return mfr_status;
470 if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
471 ret |= data->have_oc_fault ?
472 PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
473 }
474 break;
475 case PMBUS_STATUS_VOUT:
476 if (data->have_vout)
477 return -ENODATA;
478 ret = 0;
479 if (data->have_vaux_status) {
480 mfr_status = pmbus_read_byte_data(client, 0,
481 ADM1075_VAUX_STATUS);
482 if (mfr_status < 0)
483 return mfr_status;
484 if (mfr_status & ADM1075_VAUX_OV_WARN)
485 ret |= PB_VOLTAGE_OV_WARNING;
486 if (mfr_status & ADM1075_VAUX_UV_WARN)
487 ret |= PB_VOLTAGE_UV_WARNING;
488 } else if (data->have_mfr_vaux_status) {
489 mfr_status = pmbus_read_byte_data(client, page,
490 PMBUS_STATUS_MFR_SPECIFIC);
491 if (mfr_status < 0)
492 return mfr_status;
493 if (mfr_status & ADM1293_MFR_STATUS_VAUX_OV_WARN)
494 ret |= PB_VOLTAGE_OV_WARNING;
495 if (mfr_status & ADM1293_MFR_STATUS_VAUX_UV_WARN)
496 ret |= PB_VOLTAGE_UV_WARNING;
497 }
498 break;
499 default:
500 ret = -ENODATA;
501 break;
502 }
503 return ret;
504 }
505
506 static const struct i2c_device_id adm1275_id[] = {
507 { .name = "adm1075", .driver_data = adm1075 },
508 { .name = "adm1272", .driver_data = adm1272 },
509 { .name = "adm1273", .driver_data = adm1273 },
510 { .name = "adm1275", .driver_data = adm1275 },
511 { .name = "adm1276", .driver_data = adm1276 },
512 { .name = "adm1278", .driver_data = adm1278 },
513 { .name = "adm1281", .driver_data = adm1281 },
514 { .name = "adm1293", .driver_data = adm1293 },
515 { .name = "adm1294", .driver_data = adm1294 },
516 { .name = "bd12780", .driver_data = bd12780 },
517 { .name = "bd12790", .driver_data = bd12790 },
518 { .name = "mc09c", .driver_data = sq24905c },
519 { }
520 };
521 MODULE_DEVICE_TABLE(i2c, adm1275_id);
522
523 /* Enable VOUT & TEMP1 if not enabled (disabled by default) */
adm1275_enable_vout_temp(struct adm1275_data * data,struct i2c_client * client,int config,u16 defconfig)524 static int adm1275_enable_vout_temp(struct adm1275_data *data,
525 struct i2c_client *client, int config,
526 u16 defconfig)
527 {
528 int ret;
529
530 if ((config & defconfig) != defconfig) {
531 config |= defconfig;
532 ret = adm1275_write_pmon_config(data, client, config);
533 if (ret < 0) {
534 dev_err(&client->dev, "Failed to enable VOUT/TEMP1 monitoring\n");
535 return ret;
536 }
537 }
538 return 0;
539 }
540
adm1275_probe(struct i2c_client * client)541 static int adm1275_probe(struct i2c_client *client)
542 {
543 s32 (*config_read_fn)(const struct i2c_client *client, u8 reg);
544 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1] = {0};
545 int config, device_config;
546 int ret;
547 struct pmbus_driver_info *info;
548 struct adm1275_data *data;
549 const struct i2c_device_id *mid;
550 const struct coefficients *coefficients;
551 int vindex = -1, voindex = -1, cindex = -1, pindex = -1;
552 int tindex = -1;
553 u32 shunt;
554 u32 avg;
555
556 ret = pmbus_read_smbus_i2c_block_data(client, PMBUS_MFR_ID, block_buffer);
557 if (ret < 0) {
558 dev_err(&client->dev, "Failed to read Manufacturer ID\n");
559 return ret;
560 }
561 if ((ret != 3 || strncmp(block_buffer, "ADI", 3)) &&
562 (ret != 2 || strncmp(block_buffer, "SY", 2)) &&
563 (ret != 4 || strncmp(block_buffer, "ROHM", 4))) {
564 dev_err(&client->dev, "Unsupported Manufacturer ID\n");
565 return -ENODEV;
566 }
567
568 ret = pmbus_read_smbus_i2c_block_data(client, PMBUS_MFR_MODEL, block_buffer);
569 if (ret < 0) {
570 dev_err(&client->dev, "Failed to read Manufacturer Model\n");
571 return ret;
572 }
573 for (mid = adm1275_id; mid->name[0]; mid++) {
574 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
575 break;
576 }
577 if (!mid->name[0]) {
578 dev_err(&client->dev, "Unsupported device\n");
579 return -ENODEV;
580 }
581
582 if (strcmp(client->name, mid->name) != 0)
583 dev_notice(&client->dev,
584 "Device mismatch: Configured %s, detected %s\n",
585 client->name, mid->name);
586
587 if (mid->driver_data == adm1272 || mid->driver_data == adm1273 ||
588 mid->driver_data == adm1278 || mid->driver_data == adm1281 ||
589 mid->driver_data == adm1293 || mid->driver_data == adm1294 ||
590 mid->driver_data == bd12780 || mid->driver_data == bd12790 ||
591 mid->driver_data == sq24905c)
592 config_read_fn = i2c_smbus_read_word_data;
593 else
594 config_read_fn = i2c_smbus_read_byte_data;
595 config = config_read_fn(client, ADM1275_PMON_CONFIG);
596 if (config < 0)
597 return config;
598
599 device_config = config_read_fn(client, ADM1275_DEVICE_CONFIG);
600 if (device_config < 0)
601 return device_config;
602
603 data = devm_kzalloc(&client->dev, sizeof(struct adm1275_data),
604 GFP_KERNEL);
605 if (!data)
606 return -ENOMEM;
607
608 if (of_property_read_u32(client->dev.of_node,
609 "shunt-resistor-micro-ohms", &shunt))
610 shunt = 1000; /* 1 mOhm if not set via DT */
611
612 if (shunt == 0)
613 return -EINVAL;
614
615 data->id = mid->driver_data;
616
617 info = &data->info;
618
619 info->pages = 1;
620 info->format[PSC_VOLTAGE_IN] = direct;
621 info->format[PSC_VOLTAGE_OUT] = direct;
622 info->format[PSC_CURRENT_OUT] = direct;
623 info->format[PSC_POWER] = direct;
624 info->format[PSC_TEMPERATURE] = direct;
625 info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
626 PMBUS_HAVE_SAMPLES;
627
628 info->read_word_data = adm1275_read_word_data;
629 info->read_byte_data = adm1275_read_byte_data;
630 info->write_word_data = adm1275_write_word_data;
631
632 switch (data->id) {
633 case adm1075:
634 if (device_config & ADM1275_IOUT_WARN2_SELECT)
635 data->have_oc_fault = true;
636 else
637 data->have_uc_fault = true;
638 data->have_pin_max = true;
639 data->have_vaux_status = true;
640
641 coefficients = adm1075_coefficients;
642 vindex = 0;
643 switch (config & ADM1075_IRANGE_MASK) {
644 case ADM1075_IRANGE_25:
645 cindex = 1;
646 pindex = 3;
647 break;
648 case ADM1075_IRANGE_50:
649 cindex = 2;
650 pindex = 4;
651 break;
652 default:
653 dev_err(&client->dev, "Invalid input current range");
654 break;
655 }
656
657 info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
658 | PMBUS_HAVE_STATUS_INPUT;
659 if (config & ADM1275_VIN_VOUT_SELECT)
660 info->func[0] |=
661 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
662 break;
663 case adm1272:
664 case adm1273:
665 data->have_vout = true;
666 data->have_pin_max = true;
667 data->have_temp_max = true;
668 data->have_power_sampling = true;
669
670 coefficients = adm1272_coefficients;
671
672 vindex = (config & ADM1275_VRANGE) ? 1 : 0;
673 cindex = (config & ADM1272_IRANGE) ? 3 : 2;
674 /* pindex depends on the combination of the above */
675 switch (config & (ADM1275_VRANGE | ADM1272_IRANGE)) {
676 case 0:
677 default:
678 pindex = 4;
679 break;
680 case ADM1275_VRANGE:
681 pindex = 5;
682 break;
683 case ADM1272_IRANGE:
684 pindex = 6;
685 break;
686 case ADM1275_VRANGE | ADM1272_IRANGE:
687 pindex = 7;
688 break;
689 }
690 tindex = 8;
691
692 info->func[0] |= PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
693 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
694 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
695
696 ret = adm1275_enable_vout_temp(data, client, config,
697 ADM1278_PMON_DEFCONFIG);
698 if (ret)
699 return ret;
700
701 if (config & ADM1278_VIN_EN)
702 info->func[0] |= PMBUS_HAVE_VIN;
703 break;
704
705 /*
706 * The BD12790 is almost identical to the adm1272. Only the defconfig
707 * and coefficients have minor differences.
708 */
709 case bd12790:
710 data->have_vout = true;
711 data->have_pin_max = true;
712 data->have_temp_max = true;
713 data->have_power_sampling = true;
714
715 coefficients = bd12790_coefficients;
716
717 vindex = (config & ADM1275_VRANGE) ? 1 : 0;
718 cindex = (config & ADM1272_IRANGE) ? 3 : 2;
719 /* pindex depends on the combination of the above */
720 switch (config & (ADM1275_VRANGE | ADM1272_IRANGE)) {
721 case 0:
722 default:
723 pindex = 4;
724 break;
725 case ADM1275_VRANGE:
726 pindex = 5;
727 break;
728 case ADM1272_IRANGE:
729 pindex = 6;
730 break;
731 case ADM1275_VRANGE | ADM1272_IRANGE:
732 pindex = 7;
733 break;
734 }
735 tindex = 8;
736
737 info->func[0] |= PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
738 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
739 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
740
741 ret = adm1275_enable_vout_temp(data, client, config,
742 BD12780_PMON_DEFCONFIG);
743 if (ret)
744 return ret;
745
746 if (config & ADM1278_VIN_EN)
747 info->func[0] |= PMBUS_HAVE_VIN;
748 break;
749 case adm1275:
750 if (device_config & ADM1275_IOUT_WARN2_SELECT)
751 data->have_oc_fault = true;
752 else
753 data->have_uc_fault = true;
754 data->have_vout = true;
755
756 coefficients = adm1275_coefficients;
757 vindex = (config & ADM1275_VRANGE) ? 0 : 1;
758 cindex = 2;
759
760 if (config & ADM1275_VIN_VOUT_SELECT)
761 info->func[0] |=
762 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
763 else
764 info->func[0] |=
765 PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
766 break;
767 case adm1276:
768 if (device_config & ADM1275_IOUT_WARN2_SELECT)
769 data->have_oc_fault = true;
770 else
771 data->have_uc_fault = true;
772 data->have_vout = true;
773 data->have_pin_max = true;
774
775 coefficients = adm1276_coefficients;
776 vindex = (config & ADM1275_VRANGE) ? 0 : 1;
777 cindex = 2;
778 pindex = (config & ADM1275_VRANGE) ? 3 : 4;
779
780 info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
781 | PMBUS_HAVE_STATUS_INPUT;
782 if (config & ADM1275_VIN_VOUT_SELECT)
783 info->func[0] |=
784 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
785 break;
786 case adm1278:
787 case adm1281:
788 case sq24905c:
789 data->have_vout = true;
790 data->have_pin_max = true;
791 data->have_temp_max = true;
792 data->have_power_sampling = true;
793
794 coefficients = adm1278_coefficients;
795 vindex = 0;
796 cindex = 1;
797 pindex = 2;
798 tindex = 3;
799
800 info->func[0] |= PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
801 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
802 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
803
804 ret = adm1275_enable_vout_temp(data, client, config,
805 ADM1278_PMON_DEFCONFIG);
806 if (ret)
807 return ret;
808
809 if (config & ADM1278_VIN_EN)
810 info->func[0] |= PMBUS_HAVE_VIN;
811 break;
812
813 /*
814 * The BD12780 is almost functionally identical with the adm1278 above.
815 * Only differences visible to the driver are lack of TSFILT bits and
816 * different identification register contents.
817 */
818 case bd12780:
819 data->have_vout = true;
820 data->have_pin_max = true;
821 data->have_temp_max = true;
822 data->have_power_sampling = true;
823
824 coefficients = adm1278_coefficients;
825 vindex = 0;
826 cindex = 1;
827 pindex = 2;
828 tindex = 3;
829
830 info->func[0] |= PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
831 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
832 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
833
834 ret = adm1275_enable_vout_temp(data, client, config,
835 BD12780_PMON_DEFCONFIG);
836 if (ret)
837 return ret;
838
839 if (config & ADM1278_VIN_EN)
840 info->func[0] |= PMBUS_HAVE_VIN;
841
842 break;
843 case adm1293:
844 case adm1294:
845 data->have_iout_min = true;
846 data->have_pin_min = true;
847 data->have_pin_max = true;
848 data->have_mfr_vaux_status = true;
849 data->have_power_sampling = true;
850
851 coefficients = adm1293_coefficients;
852
853 voindex = 0;
854 switch (config & ADM1293_VIN_SEL_MASK) {
855 case ADM1293_VIN_SEL_012: /* 1.2V */
856 vindex = 0;
857 break;
858 case ADM1293_VIN_SEL_074: /* 7.4V */
859 vindex = 1;
860 break;
861 case ADM1293_VIN_SEL_210: /* 21V */
862 vindex = 2;
863 break;
864 default: /* disabled */
865 break;
866 }
867
868 switch (config & ADM1293_IRANGE_MASK) {
869 case ADM1293_IRANGE_25:
870 cindex = 3;
871 break;
872 case ADM1293_IRANGE_50:
873 cindex = 4;
874 break;
875 case ADM1293_IRANGE_100:
876 cindex = 5;
877 break;
878 case ADM1293_IRANGE_200:
879 cindex = 6;
880 break;
881 }
882
883 if (vindex >= 0)
884 pindex = 7 + vindex * 4 + (cindex - 3);
885
886 if (config & ADM1293_VAUX_EN)
887 info->func[0] |=
888 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
889
890 info->func[0] |= PMBUS_HAVE_PIN |
891 PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
892
893 break;
894 default:
895 dev_err(&client->dev, "Unsupported device\n");
896 return -ENODEV;
897 }
898
899 if (data->have_power_sampling &&
900 of_property_read_u32(client->dev.of_node,
901 "adi,power-sample-average", &avg) == 0) {
902 if (!avg || avg > ADM1275_SAMPLES_AVG_MAX ||
903 BIT(__fls(avg)) != avg) {
904 dev_err(&client->dev,
905 "Invalid number of power samples");
906 return -EINVAL;
907 }
908 ret = adm1275_write_samples(data, client, true, ilog2(avg));
909 if (ret < 0) {
910 dev_err(&client->dev,
911 "Setting power sample averaging failed with error %d",
912 ret);
913 return ret;
914 }
915 }
916
917 if (of_property_read_u32(client->dev.of_node,
918 "adi,volt-curr-sample-average", &avg) == 0) {
919 if (!avg || avg > ADM1275_SAMPLES_AVG_MAX ||
920 BIT(__fls(avg)) != avg) {
921 dev_err(&client->dev,
922 "Invalid number of voltage/current samples");
923 return -EINVAL;
924 }
925 ret = adm1275_write_samples(data, client, false, ilog2(avg));
926 if (ret < 0) {
927 dev_err(&client->dev,
928 "Setting voltage and current sample averaging failed with error %d",
929 ret);
930 return ret;
931 }
932 }
933
934 if (voindex < 0)
935 voindex = vindex;
936 if (vindex >= 0) {
937 info->m[PSC_VOLTAGE_IN] = coefficients[vindex].m;
938 info->b[PSC_VOLTAGE_IN] = coefficients[vindex].b;
939 info->R[PSC_VOLTAGE_IN] = coefficients[vindex].R;
940 }
941 if (voindex >= 0) {
942 info->m[PSC_VOLTAGE_OUT] = coefficients[voindex].m;
943 info->b[PSC_VOLTAGE_OUT] = coefficients[voindex].b;
944 info->R[PSC_VOLTAGE_OUT] = coefficients[voindex].R;
945 }
946 if (cindex >= 0) {
947 u32 m;
948
949 /* Scale current with sense resistor value */
950 if (unlikely(check_mul_overflow(coefficients[cindex].m, shunt, &m))) {
951 dev_err(&client->dev, "Current coefficient overflow\n");
952 return -EOVERFLOW;
953 }
954 info->m[PSC_CURRENT_OUT] = m / 1000;
955 info->b[PSC_CURRENT_OUT] = coefficients[cindex].b;
956 info->R[PSC_CURRENT_OUT] = coefficients[cindex].R;
957 }
958 if (pindex >= 0) {
959 u32 m;
960
961 if (unlikely(check_mul_overflow(coefficients[pindex].m, shunt, &m))) {
962 dev_err(&client->dev, "Power coefficient overflow\n");
963 return -EOVERFLOW;
964 }
965 info->m[PSC_POWER] = m / 1000;
966 info->b[PSC_POWER] = coefficients[pindex].b;
967 info->R[PSC_POWER] = coefficients[pindex].R;
968 }
969 if (tindex >= 0) {
970 info->m[PSC_TEMPERATURE] = coefficients[tindex].m;
971 info->b[PSC_TEMPERATURE] = coefficients[tindex].b;
972 info->R[PSC_TEMPERATURE] = coefficients[tindex].R;
973 }
974
975 return pmbus_do_probe(client, info);
976 }
977
978 static const struct of_device_id adm1275_of_match[] = {
979 { .compatible = "adi,adm1075", },
980 { .compatible = "adi,adm1272", },
981 { .compatible = "adi,adm1273", },
982 { .compatible = "adi,adm1275", },
983 { .compatible = "adi,adm1276", },
984 { .compatible = "adi,adm1278", },
985 { .compatible = "adi,adm1281", },
986 { .compatible = "adi,adm1293", },
987 { .compatible = "adi,adm1294", },
988 { .compatible = "rohm,bd12780", },
989 { .compatible = "rohm,bd12790", },
990 { .compatible = "silergy,mc09c", },
991 { }
992 };
993 MODULE_DEVICE_TABLE(of, adm1275_of_match);
994
995 static struct i2c_driver adm1275_driver = {
996 .driver = {
997 .name = "adm1275",
998 .of_match_table = adm1275_of_match,
999 },
1000 .probe = adm1275_probe,
1001 .id_table = adm1275_id,
1002 };
1003
1004 module_i2c_driver(adm1275_driver);
1005
1006 MODULE_AUTHOR("Guenter Roeck");
1007 MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
1008 MODULE_LICENSE("GPL");
1009 MODULE_IMPORT_NS("PMBUS");
1010