1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/module.h>
20#include <linux/init.h>
21#include <linux/err.h>
22#include <linux/slab.h>
23#include <linux/i2c.h>
24#include <linux/bitops.h>
25#include "pmbus.h"
26
27enum chips { adm1075, adm1275, adm1276, adm1278, adm1293, adm1294 };
28
29#define ADM1275_MFR_STATUS_IOUT_WARN2 BIT(0)
30#define ADM1293_MFR_STATUS_VAUX_UV_WARN BIT(5)
31#define ADM1293_MFR_STATUS_VAUX_OV_WARN BIT(6)
32
33#define ADM1275_PEAK_IOUT 0xd0
34#define ADM1275_PEAK_VIN 0xd1
35#define ADM1275_PEAK_VOUT 0xd2
36#define ADM1275_PMON_CONFIG 0xd4
37
38#define ADM1275_VIN_VOUT_SELECT BIT(6)
39#define ADM1275_VRANGE BIT(5)
40#define ADM1075_IRANGE_50 BIT(4)
41#define ADM1075_IRANGE_25 BIT(3)
42#define ADM1075_IRANGE_MASK (BIT(3) | BIT(4))
43
44#define ADM1278_TEMP1_EN BIT(3)
45#define ADM1278_VIN_EN BIT(2)
46#define ADM1278_VOUT_EN BIT(1)
47
48#define ADM1293_IRANGE_25 0
49#define ADM1293_IRANGE_50 BIT(6)
50#define ADM1293_IRANGE_100 BIT(7)
51#define ADM1293_IRANGE_200 (BIT(6) | BIT(7))
52#define ADM1293_IRANGE_MASK (BIT(6) | BIT(7))
53
54#define ADM1293_VIN_SEL_012 BIT(2)
55#define ADM1293_VIN_SEL_074 BIT(3)
56#define ADM1293_VIN_SEL_210 (BIT(2) | BIT(3))
57#define ADM1293_VIN_SEL_MASK (BIT(2) | BIT(3))
58
59#define ADM1293_VAUX_EN BIT(1)
60
61#define ADM1278_PEAK_TEMP 0xd7
62#define ADM1275_IOUT_WARN2_LIMIT 0xd7
63#define ADM1275_DEVICE_CONFIG 0xd8
64
65#define ADM1275_IOUT_WARN2_SELECT BIT(4)
66
67#define ADM1276_PEAK_PIN 0xda
68#define ADM1075_READ_VAUX 0xdd
69#define ADM1075_VAUX_OV_WARN_LIMIT 0xde
70#define ADM1075_VAUX_UV_WARN_LIMIT 0xdf
71#define ADM1293_IOUT_MIN 0xe3
72#define ADM1293_PIN_MIN 0xe4
73#define ADM1075_VAUX_STATUS 0xf6
74
75#define ADM1075_VAUX_OV_WARN BIT(7)
76#define ADM1075_VAUX_UV_WARN BIT(6)
77
78struct adm1275_data {
79 int id;
80 bool have_oc_fault;
81 bool have_uc_fault;
82 bool have_vout;
83 bool have_vaux_status;
84 bool have_mfr_vaux_status;
85 bool have_iout_min;
86 bool have_pin_min;
87 bool have_pin_max;
88 bool have_temp_max;
89 struct pmbus_driver_info info;
90};
91
92#define to_adm1275_data(x) container_of(x, struct adm1275_data, info)
93
94struct coefficients {
95 s16 m;
96 s16 b;
97 s16 R;
98};
99
100static const struct coefficients adm1075_coefficients[] = {
101 [0] = { 27169, 0, -1 },
102 [1] = { 806, 20475, -1 },
103 [2] = { 404, 20475, -1 },
104 [3] = { 8549, 0, -1 },
105 [4] = { 4279, 0, -1 },
106};
107
108static const struct coefficients adm1275_coefficients[] = {
109 [0] = { 19199, 0, -2 },
110 [1] = { 6720, 0, -1 },
111 [2] = { 807, 20475, -1 },
112};
113
114static const struct coefficients adm1276_coefficients[] = {
115 [0] = { 19199, 0, -2 },
116 [1] = { 6720, 0, -1 },
117 [2] = { 807, 20475, -1 },
118 [3] = { 6043, 0, -2 },
119 [4] = { 2115, 0, -1 },
120};
121
122static const struct coefficients adm1278_coefficients[] = {
123 [0] = { 19599, 0, -2 },
124 [1] = { 800, 20475, -1 },
125 [2] = { 6123, 0, -2 },
126 [3] = { 42, 31880, -1 },
127};
128
129static const struct coefficients adm1293_coefficients[] = {
130 [0] = { 3333, -1, 0 },
131 [1] = { 5552, -5, -1 },
132 [2] = { 19604, -50, -2 },
133 [3] = { 8000, -100, -2 },
134 [4] = { 4000, -100, -2 },
135 [5] = { 20000, -1000, -3 },
136 [6] = { 10000, -1000, -3 },
137 [7] = { 10417, 0, -1 },
138 [8] = { 5208, 0, -1 },
139 [9] = { 26042, 0, -2 },
140 [10] = { 13021, 0, -2 },
141 [11] = { 17351, 0, -2 },
142 [12] = { 8676, 0, -2 },
143 [13] = { 4338, 0, -2 },
144 [14] = { 21689, 0, -3 },
145 [15] = { 6126, 0, -2 },
146 [16] = { 30631, 0, -3 },
147 [17] = { 15316, 0, -3 },
148 [18] = { 7658, 0, -3 },
149};
150
151static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
152{
153 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
154 const struct adm1275_data *data = to_adm1275_data(info);
155 int ret = 0;
156
157 if (page)
158 return -ENXIO;
159
160 switch (reg) {
161 case PMBUS_IOUT_UC_FAULT_LIMIT:
162 if (!data->have_uc_fault)
163 return -ENXIO;
164 ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
165 break;
166 case PMBUS_IOUT_OC_FAULT_LIMIT:
167 if (!data->have_oc_fault)
168 return -ENXIO;
169 ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
170 break;
171 case PMBUS_VOUT_OV_WARN_LIMIT:
172 if (data->have_vout)
173 return -ENODATA;
174 ret = pmbus_read_word_data(client, 0,
175 ADM1075_VAUX_OV_WARN_LIMIT);
176 break;
177 case PMBUS_VOUT_UV_WARN_LIMIT:
178 if (data->have_vout)
179 return -ENODATA;
180 ret = pmbus_read_word_data(client, 0,
181 ADM1075_VAUX_UV_WARN_LIMIT);
182 break;
183 case PMBUS_READ_VOUT:
184 if (data->have_vout)
185 return -ENODATA;
186 ret = pmbus_read_word_data(client, 0, ADM1075_READ_VAUX);
187 break;
188 case PMBUS_VIRT_READ_IOUT_MIN:
189 if (!data->have_iout_min)
190 return -ENXIO;
191 ret = pmbus_read_word_data(client, 0, ADM1293_IOUT_MIN);
192 break;
193 case PMBUS_VIRT_READ_IOUT_MAX:
194 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
195 break;
196 case PMBUS_VIRT_READ_VOUT_MAX:
197 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT);
198 break;
199 case PMBUS_VIRT_READ_VIN_MAX:
200 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
201 break;
202 case PMBUS_VIRT_READ_PIN_MIN:
203 if (!data->have_pin_min)
204 return -ENXIO;
205 ret = pmbus_read_word_data(client, 0, ADM1293_PIN_MIN);
206 break;
207 case PMBUS_VIRT_READ_PIN_MAX:
208 if (!data->have_pin_max)
209 return -ENXIO;
210 ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN);
211 break;
212 case PMBUS_VIRT_READ_TEMP_MAX:
213 if (!data->have_temp_max)
214 return -ENXIO;
215 ret = pmbus_read_word_data(client, 0, ADM1278_PEAK_TEMP);
216 break;
217 case PMBUS_VIRT_RESET_IOUT_HISTORY:
218 case PMBUS_VIRT_RESET_VOUT_HISTORY:
219 case PMBUS_VIRT_RESET_VIN_HISTORY:
220 break;
221 case PMBUS_VIRT_RESET_PIN_HISTORY:
222 if (!data->have_pin_max)
223 return -ENXIO;
224 break;
225 case PMBUS_VIRT_RESET_TEMP_HISTORY:
226 if (!data->have_temp_max)
227 return -ENXIO;
228 break;
229 default:
230 ret = -ENODATA;
231 break;
232 }
233 return ret;
234}
235
236static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
237 u16 word)
238{
239 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
240 const struct adm1275_data *data = to_adm1275_data(info);
241 int ret;
242
243 if (page)
244 return -ENXIO;
245
246 switch (reg) {
247 case PMBUS_IOUT_UC_FAULT_LIMIT:
248 case PMBUS_IOUT_OC_FAULT_LIMIT:
249 ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
250 word);
251 break;
252 case PMBUS_VIRT_RESET_IOUT_HISTORY:
253 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
254 if (!ret && data->have_iout_min)
255 ret = pmbus_write_word_data(client, 0,
256 ADM1293_IOUT_MIN, 0);
257 break;
258 case PMBUS_VIRT_RESET_VOUT_HISTORY:
259 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
260 break;
261 case PMBUS_VIRT_RESET_VIN_HISTORY:
262 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
263 break;
264 case PMBUS_VIRT_RESET_PIN_HISTORY:
265 ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
266 if (!ret && data->have_pin_min)
267 ret = pmbus_write_word_data(client, 0,
268 ADM1293_PIN_MIN, 0);
269 break;
270 case PMBUS_VIRT_RESET_TEMP_HISTORY:
271 ret = pmbus_write_word_data(client, 0, ADM1278_PEAK_TEMP, 0);
272 break;
273 default:
274 ret = -ENODATA;
275 break;
276 }
277 return ret;
278}
279
280static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
281{
282 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
283 const struct adm1275_data *data = to_adm1275_data(info);
284 int mfr_status, ret;
285
286 if (page > 0)
287 return -ENXIO;
288
289 switch (reg) {
290 case PMBUS_STATUS_IOUT:
291 ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
292 if (ret < 0)
293 break;
294 if (!data->have_oc_fault && !data->have_uc_fault)
295 break;
296 mfr_status = pmbus_read_byte_data(client, page,
297 PMBUS_STATUS_MFR_SPECIFIC);
298 if (mfr_status < 0)
299 return mfr_status;
300 if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
301 ret |= data->have_oc_fault ?
302 PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
303 }
304 break;
305 case PMBUS_STATUS_VOUT:
306 if (data->have_vout)
307 return -ENODATA;
308 ret = 0;
309 if (data->have_vaux_status) {
310 mfr_status = pmbus_read_byte_data(client, 0,
311 ADM1075_VAUX_STATUS);
312 if (mfr_status < 0)
313 return mfr_status;
314 if (mfr_status & ADM1075_VAUX_OV_WARN)
315 ret |= PB_VOLTAGE_OV_WARNING;
316 if (mfr_status & ADM1075_VAUX_UV_WARN)
317 ret |= PB_VOLTAGE_UV_WARNING;
318 } else if (data->have_mfr_vaux_status) {
319 mfr_status = pmbus_read_byte_data(client, page,
320 PMBUS_STATUS_MFR_SPECIFIC);
321 if (mfr_status < 0)
322 return mfr_status;
323 if (mfr_status & ADM1293_MFR_STATUS_VAUX_OV_WARN)
324 ret |= PB_VOLTAGE_OV_WARNING;
325 if (mfr_status & ADM1293_MFR_STATUS_VAUX_UV_WARN)
326 ret |= PB_VOLTAGE_UV_WARNING;
327 }
328 break;
329 default:
330 ret = -ENODATA;
331 break;
332 }
333 return ret;
334}
335
336static const struct i2c_device_id adm1275_id[] = {
337 { "adm1075", adm1075 },
338 { "adm1275", adm1275 },
339 { "adm1276", adm1276 },
340 { "adm1278", adm1278 },
341 { "adm1293", adm1293 },
342 { "adm1294", adm1294 },
343 { }
344};
345MODULE_DEVICE_TABLE(i2c, adm1275_id);
346
347static int adm1275_probe(struct i2c_client *client,
348 const struct i2c_device_id *id)
349{
350 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
351 int config, device_config;
352 int ret;
353 struct pmbus_driver_info *info;
354 struct adm1275_data *data;
355 const struct i2c_device_id *mid;
356 const struct coefficients *coefficients;
357 int vindex = -1, voindex = -1, cindex = -1, pindex = -1;
358 int tindex = -1;
359
360 if (!i2c_check_functionality(client->adapter,
361 I2C_FUNC_SMBUS_READ_BYTE_DATA
362 | I2C_FUNC_SMBUS_BLOCK_DATA))
363 return -ENODEV;
364
365 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, block_buffer);
366 if (ret < 0) {
367 dev_err(&client->dev, "Failed to read Manufacturer ID\n");
368 return ret;
369 }
370 if (ret != 3 || strncmp(block_buffer, "ADI", 3)) {
371 dev_err(&client->dev, "Unsupported Manufacturer ID\n");
372 return -ENODEV;
373 }
374
375 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, block_buffer);
376 if (ret < 0) {
377 dev_err(&client->dev, "Failed to read Manufacturer Model\n");
378 return ret;
379 }
380 for (mid = adm1275_id; mid->name[0]; mid++) {
381 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
382 break;
383 }
384 if (!mid->name[0]) {
385 dev_err(&client->dev, "Unsupported device\n");
386 return -ENODEV;
387 }
388
389 if (id->driver_data != mid->driver_data)
390 dev_notice(&client->dev,
391 "Device mismatch: Configured %s, detected %s\n",
392 id->name, mid->name);
393
394 config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
395 if (config < 0)
396 return config;
397
398 device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG);
399 if (device_config < 0)
400 return device_config;
401
402 data = devm_kzalloc(&client->dev, sizeof(struct adm1275_data),
403 GFP_KERNEL);
404 if (!data)
405 return -ENOMEM;
406
407 data->id = mid->driver_data;
408
409 info = &data->info;
410
411 info->pages = 1;
412 info->format[PSC_VOLTAGE_IN] = direct;
413 info->format[PSC_VOLTAGE_OUT] = direct;
414 info->format[PSC_CURRENT_OUT] = direct;
415 info->format[PSC_POWER] = direct;
416 info->format[PSC_TEMPERATURE] = direct;
417 info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
418
419 info->read_word_data = adm1275_read_word_data;
420 info->read_byte_data = adm1275_read_byte_data;
421 info->write_word_data = adm1275_write_word_data;
422
423 switch (data->id) {
424 case adm1075:
425 if (device_config & ADM1275_IOUT_WARN2_SELECT)
426 data->have_oc_fault = true;
427 else
428 data->have_uc_fault = true;
429 data->have_pin_max = true;
430 data->have_vaux_status = true;
431
432 coefficients = adm1075_coefficients;
433 vindex = 0;
434 switch (config & ADM1075_IRANGE_MASK) {
435 case ADM1075_IRANGE_25:
436 cindex = 1;
437 pindex = 3;
438 break;
439 case ADM1075_IRANGE_50:
440 cindex = 2;
441 pindex = 4;
442 break;
443 default:
444 dev_err(&client->dev, "Invalid input current range");
445 break;
446 }
447
448 info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
449 | PMBUS_HAVE_STATUS_INPUT;
450 if (config & ADM1275_VIN_VOUT_SELECT)
451 info->func[0] |=
452 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
453 break;
454 case adm1275:
455 if (device_config & ADM1275_IOUT_WARN2_SELECT)
456 data->have_oc_fault = true;
457 else
458 data->have_uc_fault = true;
459 data->have_vout = true;
460
461 coefficients = adm1275_coefficients;
462 vindex = (config & ADM1275_VRANGE) ? 0 : 1;
463 cindex = 2;
464
465 if (config & ADM1275_VIN_VOUT_SELECT)
466 info->func[0] |=
467 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
468 else
469 info->func[0] |=
470 PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
471 break;
472 case adm1276:
473 if (device_config & ADM1275_IOUT_WARN2_SELECT)
474 data->have_oc_fault = true;
475 else
476 data->have_uc_fault = true;
477 data->have_vout = true;
478 data->have_pin_max = true;
479
480 coefficients = adm1276_coefficients;
481 vindex = (config & ADM1275_VRANGE) ? 0 : 1;
482 cindex = 2;
483 pindex = (config & ADM1275_VRANGE) ? 3 : 4;
484
485 info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
486 | PMBUS_HAVE_STATUS_INPUT;
487 if (config & ADM1275_VIN_VOUT_SELECT)
488 info->func[0] |=
489 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
490 break;
491 case adm1278:
492 data->have_vout = true;
493 data->have_pin_max = true;
494 data->have_temp_max = true;
495
496 coefficients = adm1278_coefficients;
497 vindex = 0;
498 cindex = 1;
499 pindex = 2;
500 tindex = 3;
501
502 info->func[0] |= PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT |
503 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
504
505
506 if (!(config & ADM1278_VOUT_EN)) {
507 config |= ADM1278_VOUT_EN;
508 ret = i2c_smbus_write_byte_data(client,
509 ADM1275_PMON_CONFIG,
510 config);
511 if (ret < 0) {
512 dev_err(&client->dev,
513 "Failed to enable VOUT monitoring\n");
514 return -ENODEV;
515 }
516 }
517
518 if (config & ADM1278_TEMP1_EN)
519 info->func[0] |=
520 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
521 if (config & ADM1278_VIN_EN)
522 info->func[0] |= PMBUS_HAVE_VIN;
523 break;
524 case adm1293:
525 case adm1294:
526 data->have_iout_min = true;
527 data->have_pin_min = true;
528 data->have_pin_max = true;
529 data->have_mfr_vaux_status = true;
530
531 coefficients = adm1293_coefficients;
532
533 voindex = 0;
534 switch (config & ADM1293_VIN_SEL_MASK) {
535 case ADM1293_VIN_SEL_012:
536 vindex = 0;
537 break;
538 case ADM1293_VIN_SEL_074:
539 vindex = 1;
540 break;
541 case ADM1293_VIN_SEL_210:
542 vindex = 2;
543 break;
544 default:
545 break;
546 }
547
548 switch (config & ADM1293_IRANGE_MASK) {
549 case ADM1293_IRANGE_25:
550 cindex = 3;
551 break;
552 case ADM1293_IRANGE_50:
553 cindex = 4;
554 break;
555 case ADM1293_IRANGE_100:
556 cindex = 5;
557 break;
558 case ADM1293_IRANGE_200:
559 cindex = 6;
560 break;
561 }
562
563 if (vindex >= 0)
564 pindex = 7 + vindex * 4 + (cindex - 3);
565
566 if (config & ADM1293_VAUX_EN)
567 info->func[0] |=
568 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
569
570 info->func[0] |= PMBUS_HAVE_PIN |
571 PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
572
573 break;
574 default:
575 dev_err(&client->dev, "Unsupported device\n");
576 return -ENODEV;
577 }
578
579 if (voindex < 0)
580 voindex = vindex;
581 if (vindex >= 0) {
582 info->m[PSC_VOLTAGE_IN] = coefficients[vindex].m;
583 info->b[PSC_VOLTAGE_IN] = coefficients[vindex].b;
584 info->R[PSC_VOLTAGE_IN] = coefficients[vindex].R;
585 }
586 if (voindex >= 0) {
587 info->m[PSC_VOLTAGE_OUT] = coefficients[voindex].m;
588 info->b[PSC_VOLTAGE_OUT] = coefficients[voindex].b;
589 info->R[PSC_VOLTAGE_OUT] = coefficients[voindex].R;
590 }
591 if (cindex >= 0) {
592 info->m[PSC_CURRENT_OUT] = coefficients[cindex].m;
593 info->b[PSC_CURRENT_OUT] = coefficients[cindex].b;
594 info->R[PSC_CURRENT_OUT] = coefficients[cindex].R;
595 }
596 if (pindex >= 0) {
597 info->m[PSC_POWER] = coefficients[pindex].m;
598 info->b[PSC_POWER] = coefficients[pindex].b;
599 info->R[PSC_POWER] = coefficients[pindex].R;
600 }
601 if (tindex >= 0) {
602 info->m[PSC_TEMPERATURE] = coefficients[tindex].m;
603 info->b[PSC_TEMPERATURE] = coefficients[tindex].b;
604 info->R[PSC_TEMPERATURE] = coefficients[tindex].R;
605 }
606
607 return pmbus_do_probe(client, id, info);
608}
609
610static struct i2c_driver adm1275_driver = {
611 .driver = {
612 .name = "adm1275",
613 },
614 .probe = adm1275_probe,
615 .remove = pmbus_do_remove,
616 .id_table = adm1275_id,
617};
618
619module_i2c_driver(adm1275_driver);
620
621MODULE_AUTHOR("Guenter Roeck");
622MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
623MODULE_LICENSE("GPL");
624
