1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Hardware monitoring driver for LM25056 / LM25066 / LM5064 / LM5066
4 *
5 * Copyright (c) 2011 Ericsson AB.
6 * Copyright (c) 2013 Guenter Roeck
7 */
8
9 #include <linux/bitops.h>
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/log2.h>
17 #include <linux/of_device.h>
18 #include "pmbus.h"
19
20 enum chips { lm25056, lm25066, lm5064, lm5066, lm5066i };
21
22 #define LM25066_READ_VAUX 0xd0
23 #define LM25066_MFR_READ_IIN 0xd1
24 #define LM25066_MFR_READ_PIN 0xd2
25 #define LM25066_MFR_IIN_OC_WARN_LIMIT 0xd3
26 #define LM25066_MFR_PIN_OP_WARN_LIMIT 0xd4
27 #define LM25066_READ_PIN_PEAK 0xd5
28 #define LM25066_CLEAR_PIN_PEAK 0xd6
29 #define LM25066_DEVICE_SETUP 0xd9
30 #define LM25066_READ_AVG_VIN 0xdc
31 #define LM25066_SAMPLES_FOR_AVG 0xdb
32 #define LM25066_READ_AVG_VOUT 0xdd
33 #define LM25066_READ_AVG_IIN 0xde
34 #define LM25066_READ_AVG_PIN 0xdf
35
36 #define LM25066_DEV_SETUP_CL BIT(4) /* Current limit */
37
38 #define LM25066_SAMPLES_FOR_AVG_MAX 4096
39
40 /* LM25056 only */
41
42 #define LM25056_VAUX_OV_WARN_LIMIT 0xe3
43 #define LM25056_VAUX_UV_WARN_LIMIT 0xe4
44
45 #define LM25056_MFR_STS_VAUX_OV_WARN BIT(1)
46 #define LM25056_MFR_STS_VAUX_UV_WARN BIT(0)
47
48 struct __coeff {
49 short m, b, R;
50 };
51
52 #define PSC_CURRENT_IN_L (PSC_NUM_CLASSES)
53 #define PSC_POWER_L (PSC_NUM_CLASSES + 1)
54
55 static const struct __coeff lm25066_coeff[][PSC_NUM_CLASSES + 2] = {
56 [lm25056] = {
57 [PSC_VOLTAGE_IN] = {
58 .m = 16296,
59 .b = 1343,
60 .R = -2,
61 },
62 [PSC_CURRENT_IN] = {
63 .m = 13797,
64 .b = -1833,
65 .R = -2,
66 },
67 [PSC_CURRENT_IN_L] = {
68 .m = 6726,
69 .b = -537,
70 .R = -2,
71 },
72 [PSC_POWER] = {
73 .m = 5501,
74 .b = -2908,
75 .R = -3,
76 },
77 [PSC_POWER_L] = {
78 .m = 26882,
79 .b = -5646,
80 .R = -4,
81 },
82 [PSC_TEMPERATURE] = {
83 .m = 1580,
84 .b = -14500,
85 .R = -2,
86 },
87 },
88 [lm25066] = {
89 [PSC_VOLTAGE_IN] = {
90 .m = 22070,
91 .b = -1800,
92 .R = -2,
93 },
94 [PSC_VOLTAGE_OUT] = {
95 .m = 22070,
96 .b = -1800,
97 .R = -2,
98 },
99 [PSC_CURRENT_IN] = {
100 .m = 13661,
101 .b = -5200,
102 .R = -2,
103 },
104 [PSC_CURRENT_IN_L] = {
105 .m = 6854,
106 .b = -3100,
107 .R = -2,
108 },
109 [PSC_POWER] = {
110 .m = 736,
111 .b = -3300,
112 .R = -2,
113 },
114 [PSC_POWER_L] = {
115 .m = 369,
116 .b = -1900,
117 .R = -2,
118 },
119 [PSC_TEMPERATURE] = {
120 .m = 16,
121 },
122 },
123 [lm5064] = {
124 [PSC_VOLTAGE_IN] = {
125 .m = 4611,
126 .b = -642,
127 .R = -2,
128 },
129 [PSC_VOLTAGE_OUT] = {
130 .m = 4621,
131 .b = 423,
132 .R = -2,
133 },
134 [PSC_CURRENT_IN] = {
135 .m = 10742,
136 .b = 1552,
137 .R = -2,
138 },
139 [PSC_CURRENT_IN_L] = {
140 .m = 5456,
141 .b = 2118,
142 .R = -2,
143 },
144 [PSC_POWER] = {
145 .m = 1204,
146 .b = 8524,
147 .R = -3,
148 },
149 [PSC_POWER_L] = {
150 .m = 612,
151 .b = 11202,
152 .R = -3,
153 },
154 [PSC_TEMPERATURE] = {
155 .m = 16,
156 },
157 },
158 [lm5066] = {
159 [PSC_VOLTAGE_IN] = {
160 .m = 4587,
161 .b = -1200,
162 .R = -2,
163 },
164 [PSC_VOLTAGE_OUT] = {
165 .m = 4587,
166 .b = -2400,
167 .R = -2,
168 },
169 [PSC_CURRENT_IN] = {
170 .m = 10753,
171 .b = -1200,
172 .R = -2,
173 },
174 [PSC_CURRENT_IN_L] = {
175 .m = 5405,
176 .b = -600,
177 .R = -2,
178 },
179 [PSC_POWER] = {
180 .m = 1204,
181 .b = -6000,
182 .R = -3,
183 },
184 [PSC_POWER_L] = {
185 .m = 605,
186 .b = -8000,
187 .R = -3,
188 },
189 [PSC_TEMPERATURE] = {
190 .m = 16,
191 },
192 },
193 [lm5066i] = {
194 [PSC_VOLTAGE_IN] = {
195 .m = 4617,
196 .b = -140,
197 .R = -2,
198 },
199 [PSC_VOLTAGE_OUT] = {
200 .m = 4602,
201 .b = 500,
202 .R = -2,
203 },
204 [PSC_CURRENT_IN] = {
205 .m = 15076,
206 .b = -504,
207 .R = -2,
208 },
209 [PSC_CURRENT_IN_L] = {
210 .m = 7645,
211 .b = 100,
212 .R = -2,
213 },
214 [PSC_POWER] = {
215 .m = 1701,
216 .b = -4000,
217 .R = -3,
218 },
219 [PSC_POWER_L] = {
220 .m = 861,
221 .b = -965,
222 .R = -3,
223 },
224 [PSC_TEMPERATURE] = {
225 .m = 16,
226 },
227 },
228 };
229
230 struct lm25066_data {
231 int id;
232 u16 rlimit; /* Maximum register value */
233 struct pmbus_driver_info info;
234 };
235
236 #define to_lm25066_data(x) container_of(x, struct lm25066_data, info)
237
lm25066_read_word_data(struct i2c_client * client,int page,int phase,int reg)238 static int lm25066_read_word_data(struct i2c_client *client, int page,
239 int phase, int reg)
240 {
241 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
242 const struct lm25066_data *data = to_lm25066_data(info);
243 int ret;
244
245 switch (reg) {
246 case PMBUS_VIRT_READ_VMON:
247 ret = pmbus_read_word_data(client, 0, 0xff, LM25066_READ_VAUX);
248 if (ret < 0)
249 break;
250 /* Adjust returned value to match VIN coefficients */
251 switch (data->id) {
252 case lm25056:
253 /* VIN: 6.14 mV VAUX: 293 uV LSB */
254 ret = DIV_ROUND_CLOSEST(ret * 293, 6140);
255 break;
256 case lm25066:
257 /* VIN: 4.54 mV VAUX: 283.2 uV LSB */
258 ret = DIV_ROUND_CLOSEST(ret * 2832, 45400);
259 break;
260 case lm5064:
261 /* VIN: 4.53 mV VAUX: 700 uV LSB */
262 ret = DIV_ROUND_CLOSEST(ret * 70, 453);
263 break;
264 case lm5066:
265 case lm5066i:
266 /* VIN: 2.18 mV VAUX: 725 uV LSB */
267 ret = DIV_ROUND_CLOSEST(ret * 725, 2180);
268 break;
269 }
270 break;
271 case PMBUS_READ_IIN:
272 ret = pmbus_read_word_data(client, 0, 0xff,
273 LM25066_MFR_READ_IIN);
274 break;
275 case PMBUS_READ_PIN:
276 ret = pmbus_read_word_data(client, 0, 0xff,
277 LM25066_MFR_READ_PIN);
278 break;
279 case PMBUS_IIN_OC_WARN_LIMIT:
280 ret = pmbus_read_word_data(client, 0, 0xff,
281 LM25066_MFR_IIN_OC_WARN_LIMIT);
282 break;
283 case PMBUS_PIN_OP_WARN_LIMIT:
284 ret = pmbus_read_word_data(client, 0, 0xff,
285 LM25066_MFR_PIN_OP_WARN_LIMIT);
286 break;
287 case PMBUS_VIRT_READ_VIN_AVG:
288 ret = pmbus_read_word_data(client, 0, 0xff,
289 LM25066_READ_AVG_VIN);
290 break;
291 case PMBUS_VIRT_READ_VOUT_AVG:
292 ret = pmbus_read_word_data(client, 0, 0xff,
293 LM25066_READ_AVG_VOUT);
294 break;
295 case PMBUS_VIRT_READ_IIN_AVG:
296 ret = pmbus_read_word_data(client, 0, 0xff,
297 LM25066_READ_AVG_IIN);
298 break;
299 case PMBUS_VIRT_READ_PIN_AVG:
300 ret = pmbus_read_word_data(client, 0, 0xff,
301 LM25066_READ_AVG_PIN);
302 break;
303 case PMBUS_VIRT_READ_PIN_MAX:
304 ret = pmbus_read_word_data(client, 0, 0xff,
305 LM25066_READ_PIN_PEAK);
306 break;
307 case PMBUS_VIRT_RESET_PIN_HISTORY:
308 ret = 0;
309 break;
310 case PMBUS_VIRT_SAMPLES:
311 ret = pmbus_read_byte_data(client, 0, LM25066_SAMPLES_FOR_AVG);
312 if (ret < 0)
313 break;
314 ret = 1 << ret;
315 break;
316 default:
317 ret = -ENODATA;
318 break;
319 }
320 return ret;
321 }
322
lm25056_read_word_data(struct i2c_client * client,int page,int phase,int reg)323 static int lm25056_read_word_data(struct i2c_client *client, int page,
324 int phase, int reg)
325 {
326 int ret;
327
328 switch (reg) {
329 case PMBUS_VIRT_VMON_UV_WARN_LIMIT:
330 ret = pmbus_read_word_data(client, 0, 0xff,
331 LM25056_VAUX_UV_WARN_LIMIT);
332 if (ret < 0)
333 break;
334 /* Adjust returned value to match VIN coefficients */
335 ret = DIV_ROUND_CLOSEST(ret * 293, 6140);
336 break;
337 case PMBUS_VIRT_VMON_OV_WARN_LIMIT:
338 ret = pmbus_read_word_data(client, 0, 0xff,
339 LM25056_VAUX_OV_WARN_LIMIT);
340 if (ret < 0)
341 break;
342 /* Adjust returned value to match VIN coefficients */
343 ret = DIV_ROUND_CLOSEST(ret * 293, 6140);
344 break;
345 default:
346 ret = lm25066_read_word_data(client, page, phase, reg);
347 break;
348 }
349 return ret;
350 }
351
lm25056_read_byte_data(struct i2c_client * client,int page,int reg)352 static int lm25056_read_byte_data(struct i2c_client *client, int page, int reg)
353 {
354 int ret, s;
355
356 switch (reg) {
357 case PMBUS_VIRT_STATUS_VMON:
358 ret = pmbus_read_byte_data(client, 0,
359 PMBUS_STATUS_MFR_SPECIFIC);
360 if (ret < 0)
361 break;
362 s = 0;
363 if (ret & LM25056_MFR_STS_VAUX_UV_WARN)
364 s |= PB_VOLTAGE_UV_WARNING;
365 if (ret & LM25056_MFR_STS_VAUX_OV_WARN)
366 s |= PB_VOLTAGE_OV_WARNING;
367 ret = s;
368 break;
369 default:
370 ret = -ENODATA;
371 break;
372 }
373 return ret;
374 }
375
lm25066_write_word_data(struct i2c_client * client,int page,int reg,u16 word)376 static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
377 u16 word)
378 {
379 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
380 const struct lm25066_data *data = to_lm25066_data(info);
381 int ret;
382
383 switch (reg) {
384 case PMBUS_POUT_OP_FAULT_LIMIT:
385 case PMBUS_POUT_OP_WARN_LIMIT:
386 case PMBUS_VOUT_UV_WARN_LIMIT:
387 case PMBUS_OT_FAULT_LIMIT:
388 case PMBUS_OT_WARN_LIMIT:
389 case PMBUS_IIN_OC_FAULT_LIMIT:
390 case PMBUS_VIN_UV_WARN_LIMIT:
391 case PMBUS_VIN_UV_FAULT_LIMIT:
392 case PMBUS_VIN_OV_FAULT_LIMIT:
393 case PMBUS_VIN_OV_WARN_LIMIT:
394 word = ((s16)word < 0) ? 0 : clamp_val(word, 0, data->rlimit);
395 ret = pmbus_write_word_data(client, 0, reg, word);
396 break;
397 case PMBUS_IIN_OC_WARN_LIMIT:
398 word = ((s16)word < 0) ? 0 : clamp_val(word, 0, data->rlimit);
399 ret = pmbus_write_word_data(client, 0,
400 LM25066_MFR_IIN_OC_WARN_LIMIT,
401 word);
402 break;
403 case PMBUS_PIN_OP_WARN_LIMIT:
404 word = ((s16)word < 0) ? 0 : clamp_val(word, 0, data->rlimit);
405 ret = pmbus_write_word_data(client, 0,
406 LM25066_MFR_PIN_OP_WARN_LIMIT,
407 word);
408 break;
409 case PMBUS_VIRT_VMON_UV_WARN_LIMIT:
410 /* Adjust from VIN coefficients (for LM25056) */
411 word = DIV_ROUND_CLOSEST((int)word * 6140, 293);
412 word = ((s16)word < 0) ? 0 : clamp_val(word, 0, data->rlimit);
413 ret = pmbus_write_word_data(client, 0,
414 LM25056_VAUX_UV_WARN_LIMIT, word);
415 break;
416 case PMBUS_VIRT_VMON_OV_WARN_LIMIT:
417 /* Adjust from VIN coefficients (for LM25056) */
418 word = DIV_ROUND_CLOSEST((int)word * 6140, 293);
419 word = ((s16)word < 0) ? 0 : clamp_val(word, 0, data->rlimit);
420 ret = pmbus_write_word_data(client, 0,
421 LM25056_VAUX_OV_WARN_LIMIT, word);
422 break;
423 case PMBUS_VIRT_RESET_PIN_HISTORY:
424 ret = pmbus_write_byte(client, 0, LM25066_CLEAR_PIN_PEAK);
425 break;
426 case PMBUS_VIRT_SAMPLES:
427 word = clamp_val(word, 1, LM25066_SAMPLES_FOR_AVG_MAX);
428 ret = pmbus_write_byte_data(client, 0, LM25066_SAMPLES_FOR_AVG,
429 ilog2(word));
430 break;
431 default:
432 ret = -ENODATA;
433 break;
434 }
435 return ret;
436 }
437
438 #if IS_ENABLED(CONFIG_SENSORS_LM25066_REGULATOR)
439 static const struct regulator_desc lm25066_reg_desc[] = {
440 PMBUS_REGULATOR("vout", 0),
441 };
442 #endif
443
444 static const struct i2c_device_id lm25066_id[] = {
445 {"lm25056", lm25056},
446 {"lm25066", lm25066},
447 {"lm5064", lm5064},
448 {"lm5066", lm5066},
449 {"lm5066i", lm5066i},
450 { }
451 };
452 MODULE_DEVICE_TABLE(i2c, lm25066_id);
453
454 static const struct of_device_id __maybe_unused lm25066_of_match[] = {
455 { .compatible = "ti,lm25056", .data = (void *)lm25056, },
456 { .compatible = "ti,lm25066", .data = (void *)lm25066, },
457 { .compatible = "ti,lm5064", .data = (void *)lm5064, },
458 { .compatible = "ti,lm5066", .data = (void *)lm5066, },
459 { .compatible = "ti,lm5066i", .data = (void *)lm5066i, },
460 { },
461 };
462 MODULE_DEVICE_TABLE(of, lm25066_of_match);
463
lm25066_probe(struct i2c_client * client)464 static int lm25066_probe(struct i2c_client *client)
465 {
466 int config;
467 u32 shunt;
468 struct lm25066_data *data;
469 struct pmbus_driver_info *info;
470 const struct __coeff *coeff;
471 const struct of_device_id *of_id;
472 const struct i2c_device_id *i2c_id;
473
474 if (!i2c_check_functionality(client->adapter,
475 I2C_FUNC_SMBUS_READ_BYTE_DATA))
476 return -ENODEV;
477
478 data = devm_kzalloc(&client->dev, sizeof(struct lm25066_data),
479 GFP_KERNEL);
480 if (!data)
481 return -ENOMEM;
482
483 config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP);
484 if (config < 0)
485 return config;
486
487 i2c_id = i2c_match_id(lm25066_id, client);
488
489 of_id = of_match_device(lm25066_of_match, &client->dev);
490 if (of_id && (unsigned long)of_id->data != i2c_id->driver_data)
491 dev_notice(&client->dev, "Device mismatch: %s in device tree, %s detected\n",
492 of_id->name, i2c_id->name);
493
494 data->id = i2c_id->driver_data;
495 info = &data->info;
496
497 info->pages = 1;
498 info->format[PSC_VOLTAGE_IN] = direct;
499 info->format[PSC_VOLTAGE_OUT] = direct;
500 info->format[PSC_CURRENT_IN] = direct;
501 info->format[PSC_TEMPERATURE] = direct;
502 info->format[PSC_POWER] = direct;
503
504 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VMON
505 | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT
506 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_SAMPLES;
507
508 if (data->id == lm25056) {
509 info->func[0] |= PMBUS_HAVE_STATUS_VMON;
510 info->read_word_data = lm25056_read_word_data;
511 info->read_byte_data = lm25056_read_byte_data;
512 data->rlimit = 0x0fff;
513 } else {
514 info->func[0] |= PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
515 info->read_word_data = lm25066_read_word_data;
516 data->rlimit = 0x0fff;
517 }
518 info->write_word_data = lm25066_write_word_data;
519
520 coeff = &lm25066_coeff[data->id][0];
521 info->m[PSC_TEMPERATURE] = coeff[PSC_TEMPERATURE].m;
522 info->b[PSC_TEMPERATURE] = coeff[PSC_TEMPERATURE].b;
523 info->R[PSC_TEMPERATURE] = coeff[PSC_TEMPERATURE].R;
524 info->m[PSC_VOLTAGE_IN] = coeff[PSC_VOLTAGE_IN].m;
525 info->b[PSC_VOLTAGE_IN] = coeff[PSC_VOLTAGE_IN].b;
526 info->R[PSC_VOLTAGE_IN] = coeff[PSC_VOLTAGE_IN].R;
527 info->m[PSC_VOLTAGE_OUT] = coeff[PSC_VOLTAGE_OUT].m;
528 info->b[PSC_VOLTAGE_OUT] = coeff[PSC_VOLTAGE_OUT].b;
529 info->R[PSC_VOLTAGE_OUT] = coeff[PSC_VOLTAGE_OUT].R;
530 info->R[PSC_CURRENT_IN] = coeff[PSC_CURRENT_IN].R;
531 info->R[PSC_POWER] = coeff[PSC_POWER].R;
532 if (config & LM25066_DEV_SETUP_CL) {
533 info->m[PSC_CURRENT_IN] = coeff[PSC_CURRENT_IN_L].m;
534 info->b[PSC_CURRENT_IN] = coeff[PSC_CURRENT_IN_L].b;
535 info->m[PSC_POWER] = coeff[PSC_POWER_L].m;
536 info->b[PSC_POWER] = coeff[PSC_POWER_L].b;
537 } else {
538 info->m[PSC_CURRENT_IN] = coeff[PSC_CURRENT_IN].m;
539 info->b[PSC_CURRENT_IN] = coeff[PSC_CURRENT_IN].b;
540 info->m[PSC_POWER] = coeff[PSC_POWER].m;
541 info->b[PSC_POWER] = coeff[PSC_POWER].b;
542 }
543
544 /*
545 * Values in the TI datasheets are normalized for a 1mOhm sense
546 * resistor; assume that unless DT specifies a value explicitly.
547 */
548 if (of_property_read_u32(client->dev.of_node, "shunt-resistor-micro-ohms", &shunt))
549 shunt = 1000;
550
551 info->m[PSC_CURRENT_IN] = info->m[PSC_CURRENT_IN] * shunt / 1000;
552 info->m[PSC_POWER] = info->m[PSC_POWER] * shunt / 1000;
553
554 #if IS_ENABLED(CONFIG_SENSORS_LM25066_REGULATOR)
555 /* LM25056 doesn't support OPERATION */
556 if (data->id != lm25056) {
557 info->num_regulators = ARRAY_SIZE(lm25066_reg_desc);
558 info->reg_desc = lm25066_reg_desc;
559 }
560 #endif
561
562 return pmbus_do_probe(client, info);
563 }
564
565 /* This is the driver that will be inserted */
566 static struct i2c_driver lm25066_driver = {
567 .driver = {
568 .name = "lm25066",
569 .of_match_table = of_match_ptr(lm25066_of_match),
570 },
571 .probe_new = lm25066_probe,
572 .id_table = lm25066_id,
573 };
574
575 module_i2c_driver(lm25066_driver);
576
577 MODULE_AUTHOR("Guenter Roeck");
578 MODULE_DESCRIPTION("PMBus driver for LM25066 and compatible chips");
579 MODULE_LICENSE("GPL");
580 MODULE_IMPORT_NS(PMBUS);
581
