xref: /linux/drivers/hwmon/tmp513.c (revision 07757eeb9657e6939475b3eac8b3936e7a72ba5f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for Texas Instruments TMP512, TMP513 power monitor chips
4  *
5  * TMP513:
6  * Thermal/Power Management with Triple Remote and
7  * Local Temperature Sensor and Current Shunt Monitor
8  * Datasheet: https://www.ti.com/lit/gpn/tmp513
9  *
10  * TMP512:
11  * Thermal/Power Management with Dual Remote
12  *	and Local Temperature Sensor and Current Shunt Monitor
13  * Datasheet: https://www.ti.com/lit/gpn/tmp512
14  *
15  * Copyright (C) 2019 Eric Tremblay <etremblay@distech-controls.com>
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation; version 2 of the License.
20  */
21 
22 #include <linux/bitops.h>
23 #include <linux/bug.h>
24 #include <linux/device.h>
25 #include <linux/err.h>
26 #include <linux/hwmon.h>
27 #include <linux/i2c.h>
28 #include <linux/init.h>
29 #include <linux/math.h>
30 #include <linux/module.h>
31 #include <linux/property.h>
32 #include <linux/regmap.h>
33 #include <linux/slab.h>
34 #include <linux/types.h>
35 #include <linux/units.h>
36 
37 // Common register definition
38 #define TMP51X_SHUNT_CONFIG		0x00
39 #define TMP51X_TEMP_CONFIG		0x01
40 #define TMP51X_STATUS			0x02
41 #define TMP51X_SMBUS_ALERT		0x03
42 #define TMP51X_SHUNT_CURRENT_RESULT	0x04
43 #define TMP51X_BUS_VOLTAGE_RESULT	0x05
44 #define TMP51X_POWER_RESULT		0x06
45 #define TMP51X_BUS_CURRENT_RESULT	0x07
46 #define TMP51X_LOCAL_TEMP_RESULT	0x08
47 #define TMP51X_REMOTE_TEMP_RESULT_1	0x09
48 #define TMP51X_REMOTE_TEMP_RESULT_2	0x0A
49 #define TMP51X_SHUNT_CURRENT_H_LIMIT	0x0C
50 #define TMP51X_SHUNT_CURRENT_L_LIMIT	0x0D
51 #define TMP51X_BUS_VOLTAGE_H_LIMIT	0x0E
52 #define TMP51X_BUS_VOLTAGE_L_LIMIT	0x0F
53 #define TMP51X_POWER_LIMIT		0x10
54 #define TMP51X_LOCAL_TEMP_LIMIT	0x11
55 #define TMP51X_REMOTE_TEMP_LIMIT_1	0x12
56 #define TMP51X_REMOTE_TEMP_LIMIT_2	0x13
57 #define TMP51X_SHUNT_CALIBRATION	0x15
58 #define TMP51X_N_FACTOR_AND_HYST_1	0x16
59 #define TMP51X_N_FACTOR_2		0x17
60 #define TMP51X_MAN_ID_REG		0xFE
61 #define TMP51X_DEVICE_ID_REG		0xFF
62 
63 // TMP513 specific register definition
64 #define TMP513_REMOTE_TEMP_RESULT_3	0x0B
65 #define TMP513_REMOTE_TEMP_LIMIT_3	0x14
66 #define TMP513_N_FACTOR_3		0x18
67 
68 // Common attrs, and NULL
69 #define TMP51X_MANUFACTURER_ID		0x55FF
70 
71 #define TMP512_DEVICE_ID		0x22FF
72 #define TMP513_DEVICE_ID		0x23FF
73 
74 // Default config
75 #define TMP51X_SHUNT_CONFIG_DEFAULT	0x399F
76 #define TMP51X_SHUNT_VALUE_DEFAULT	1000
77 #define TMP51X_VBUS_RANGE_DEFAULT	TMP51X_VBUS_RANGE_32V
78 #define TMP51X_PGA_DEFAULT		8
79 #define TMP51X_MAX_REGISTER_ADDR	0xFF
80 
81 // Mask and shift
82 #define CURRENT_SENSE_VOLTAGE_320_MASK	0x1800
83 #define CURRENT_SENSE_VOLTAGE_160_MASK	0x1000
84 #define CURRENT_SENSE_VOLTAGE_80_MASK	0x0800
85 #define CURRENT_SENSE_VOLTAGE_40_MASK	0
86 
87 #define TMP51X_BUS_VOLTAGE_MASK		0x2000
88 #define TMP51X_NFACTOR_MASK		0xFF00
89 #define TMP51X_HYST_MASK		0x00FF
90 
91 #define TMP51X_BUS_VOLTAGE_SHIFT	3
92 #define TMP51X_TEMP_SHIFT		3
93 
94 // Alarms
95 #define TMP51X_SHUNT_CURRENT_H_LIMIT_POS	15
96 #define TMP51X_SHUNT_CURRENT_L_LIMIT_POS	14
97 #define TMP51X_BUS_VOLTAGE_H_LIMIT_POS		13
98 #define TMP51X_BUS_VOLTAGE_L_LIMIT_POS		12
99 #define TMP51X_POWER_LIMIT_POS			11
100 #define TMP51X_LOCAL_TEMP_LIMIT_POS		10
101 #define TMP51X_REMOTE_TEMP_LIMIT_1_POS		9
102 #define TMP51X_REMOTE_TEMP_LIMIT_2_POS		8
103 #define TMP513_REMOTE_TEMP_LIMIT_3_POS		7
104 
105 #define TMP51X_VBUS_RANGE_32V		(32 * MICRO)
106 #define TMP51X_VBUS_RANGE_16V		(16 * MICRO)
107 
108 // Max and Min value
109 #define MAX_BUS_VOLTAGE_32_LIMIT	32764
110 #define MAX_BUS_VOLTAGE_16_LIMIT	16382
111 
112 // Max possible value is -256 to +256 but datasheet indicated -40 to 125.
113 #define MAX_TEMP_LIMIT			125000
114 #define MIN_TEMP_LIMIT			-40000
115 
116 #define MAX_TEMP_HYST			127500
117 
118 #define TMP512_MAX_CHANNELS		3
119 #define TMP513_MAX_CHANNELS		4
120 
121 #define TMP51X_TEMP_CONFIG_CONV_RATE	GENMASK(9, 7)
122 #define TMP51X_TEMP_CONFIG_RC		BIT(10)
123 #define TMP51X_TEMP_CHANNEL_MASK(n)	(GENMASK((n) - 1, 0) << 11)
124 #define TMP51X_TEMP_CONFIG_CONT		BIT(15)
125 #define TMP51X_TEMP_CONFIG_DEFAULT(n)					\
126 	(TMP51X_TEMP_CHANNEL_MASK(n) | TMP51X_TEMP_CONFIG_CONT |	\
127 	 TMP51X_TEMP_CONFIG_CONV_RATE | TMP51X_TEMP_CONFIG_RC)
128 
129 static const u8 TMP51X_TEMP_INPUT[4] = {
130 	TMP51X_LOCAL_TEMP_RESULT,
131 	TMP51X_REMOTE_TEMP_RESULT_1,
132 	TMP51X_REMOTE_TEMP_RESULT_2,
133 	TMP513_REMOTE_TEMP_RESULT_3
134 };
135 
136 static const u8 TMP51X_TEMP_CRIT[4] = {
137 	TMP51X_LOCAL_TEMP_LIMIT,
138 	TMP51X_REMOTE_TEMP_LIMIT_1,
139 	TMP51X_REMOTE_TEMP_LIMIT_2,
140 	TMP513_REMOTE_TEMP_LIMIT_3
141 };
142 
143 static const u8 TMP51X_TEMP_CRIT_ALARM[4] = {
144 	TMP51X_LOCAL_TEMP_LIMIT_POS,
145 	TMP51X_REMOTE_TEMP_LIMIT_1_POS,
146 	TMP51X_REMOTE_TEMP_LIMIT_2_POS,
147 	TMP513_REMOTE_TEMP_LIMIT_3_POS
148 };
149 
150 static const u8 TMP51X_TEMP_CRIT_HYST[4] = {
151 	TMP51X_N_FACTOR_AND_HYST_1,
152 	TMP51X_N_FACTOR_AND_HYST_1,
153 	TMP51X_N_FACTOR_AND_HYST_1,
154 	TMP51X_N_FACTOR_AND_HYST_1
155 };
156 
157 static const u8 TMP51X_CURR_INPUT[2] = {
158 	TMP51X_SHUNT_CURRENT_RESULT,
159 	TMP51X_BUS_CURRENT_RESULT
160 };
161 
162 static const struct regmap_config tmp51x_regmap_config = {
163 	.reg_bits = 8,
164 	.val_bits = 16,
165 	.max_register = TMP51X_MAX_REGISTER_ADDR,
166 };
167 
168 struct tmp51x_data {
169 	u16 shunt_config;
170 	u16 pga_gain;
171 	u32 vbus_range_uvolt;
172 
173 	u16 temp_config;
174 	u32 nfactor[3];
175 
176 	u32 shunt_uohms;
177 
178 	u32 curr_lsb_ua;
179 	u32 pwr_lsb_uw;
180 
181 	u8 max_channels;
182 	struct regmap *regmap;
183 };
184 
185 // Set the shift based on the gain: 8 -> 1, 4 -> 2, 2 -> 3, 1 -> 4
tmp51x_get_pga_shift(struct tmp51x_data * data)186 static inline u8 tmp51x_get_pga_shift(struct tmp51x_data *data)
187 {
188 	return 5 - ffs(data->pga_gain);
189 }
190 
tmp51x_get_value(struct tmp51x_data * data,u8 reg,u8 pos,unsigned int regval,long * val)191 static int tmp51x_get_value(struct tmp51x_data *data, u8 reg, u8 pos,
192 			    unsigned int regval, long *val)
193 {
194 	switch (reg) {
195 	case TMP51X_STATUS:
196 		*val = (regval >> pos) & 1;
197 		break;
198 	case TMP51X_SHUNT_CURRENT_RESULT:
199 	case TMP51X_SHUNT_CURRENT_H_LIMIT:
200 	case TMP51X_SHUNT_CURRENT_L_LIMIT:
201 		/*
202 		 * The valus is read in voltage in the chip but reported as
203 		 * current to the user.
204 		 * 2's complement number shifted by one to four depending
205 		 * on the pga gain setting. 1lsb = 10uV
206 		 */
207 		*val = sign_extend32(regval,
208 				     reg == TMP51X_SHUNT_CURRENT_RESULT ?
209 				     16 - tmp51x_get_pga_shift(data) : 15);
210 		*val = DIV_ROUND_CLOSEST(*val * 10 * (long)MILLI, (long)data->shunt_uohms);
211 
212 		break;
213 	case TMP51X_BUS_VOLTAGE_RESULT:
214 	case TMP51X_BUS_VOLTAGE_H_LIMIT:
215 	case TMP51X_BUS_VOLTAGE_L_LIMIT:
216 		// 1lsb = 4mV
217 		*val = (regval >> TMP51X_BUS_VOLTAGE_SHIFT) * 4;
218 		break;
219 	case TMP51X_POWER_RESULT:
220 	case TMP51X_POWER_LIMIT:
221 		// Power = (current * BusVoltage) / 5000
222 		*val = regval * data->pwr_lsb_uw;
223 		break;
224 	case TMP51X_BUS_CURRENT_RESULT:
225 		// Current = (ShuntVoltage * CalibrationRegister) / 4096
226 		*val = sign_extend32(regval, 15) * (long)data->curr_lsb_ua;
227 		*val = DIV_ROUND_CLOSEST(*val, (long)MILLI);
228 		break;
229 	case TMP51X_LOCAL_TEMP_RESULT:
230 	case TMP51X_REMOTE_TEMP_RESULT_1:
231 	case TMP51X_REMOTE_TEMP_RESULT_2:
232 	case TMP513_REMOTE_TEMP_RESULT_3:
233 	case TMP51X_LOCAL_TEMP_LIMIT:
234 	case TMP51X_REMOTE_TEMP_LIMIT_1:
235 	case TMP51X_REMOTE_TEMP_LIMIT_2:
236 	case TMP513_REMOTE_TEMP_LIMIT_3:
237 		// 1lsb = 0.0625 degrees centigrade
238 		*val = sign_extend32(regval, 15) >> TMP51X_TEMP_SHIFT;
239 		*val = DIV_ROUND_CLOSEST(*val * 625, 10);
240 		break;
241 	case TMP51X_N_FACTOR_AND_HYST_1:
242 		// 1lsb = 0.5 degrees centigrade
243 		*val = (regval & TMP51X_HYST_MASK) * 500;
244 		break;
245 	default:
246 		// Programmer goofed
247 		WARN_ON_ONCE(1);
248 		*val = 0;
249 		return -EOPNOTSUPP;
250 	}
251 
252 	return 0;
253 }
254 
tmp51x_set_value(struct tmp51x_data * data,u8 reg,long val)255 static int tmp51x_set_value(struct tmp51x_data *data, u8 reg, long val)
256 {
257 	int regval, max_val;
258 	u32 mask = 0;
259 
260 	switch (reg) {
261 	case TMP51X_SHUNT_CURRENT_H_LIMIT:
262 	case TMP51X_SHUNT_CURRENT_L_LIMIT:
263 		/*
264 		 * The user enter current value and we convert it to
265 		 * voltage. 1lsb = 10uV
266 		 */
267 		val = DIV_ROUND_CLOSEST(val * (long)data->shunt_uohms, 10 * (long)MILLI);
268 		max_val = U16_MAX >> tmp51x_get_pga_shift(data);
269 		regval = clamp_val(val, -max_val, max_val);
270 		break;
271 	case TMP51X_BUS_VOLTAGE_H_LIMIT:
272 	case TMP51X_BUS_VOLTAGE_L_LIMIT:
273 		// 1lsb = 4mV
274 		max_val = (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) ?
275 			MAX_BUS_VOLTAGE_32_LIMIT : MAX_BUS_VOLTAGE_16_LIMIT;
276 
277 		val = clamp_val(DIV_ROUND_CLOSEST(val, 4), 0, max_val);
278 		regval = val << TMP51X_BUS_VOLTAGE_SHIFT;
279 		break;
280 	case TMP51X_POWER_LIMIT:
281 		regval = clamp_val(DIV_ROUND_CLOSEST(val, data->pwr_lsb_uw), 0,
282 				   U16_MAX);
283 		break;
284 	case TMP51X_LOCAL_TEMP_LIMIT:
285 	case TMP51X_REMOTE_TEMP_LIMIT_1:
286 	case TMP51X_REMOTE_TEMP_LIMIT_2:
287 	case TMP513_REMOTE_TEMP_LIMIT_3:
288 		// 1lsb = 0.0625 degrees centigrade
289 		val = clamp_val(val, MIN_TEMP_LIMIT, MAX_TEMP_LIMIT);
290 		regval = DIV_ROUND_CLOSEST(val * 10, 625) << TMP51X_TEMP_SHIFT;
291 		break;
292 	case TMP51X_N_FACTOR_AND_HYST_1:
293 		// 1lsb = 0.5 degrees centigrade
294 		val = clamp_val(val, 0, MAX_TEMP_HYST);
295 		regval = DIV_ROUND_CLOSEST(val, 500);
296 		mask = TMP51X_HYST_MASK;
297 		break;
298 	default:
299 		// Programmer goofed
300 		WARN_ON_ONCE(1);
301 		return -EOPNOTSUPP;
302 	}
303 
304 	if (mask == 0)
305 		return regmap_write(data->regmap, reg, regval);
306 	else
307 		return regmap_update_bits(data->regmap, reg, mask, regval);
308 }
309 
tmp51x_get_reg(enum hwmon_sensor_types type,u32 attr,int channel)310 static u8 tmp51x_get_reg(enum hwmon_sensor_types type, u32 attr, int channel)
311 {
312 	switch (type) {
313 	case hwmon_temp:
314 		switch (attr) {
315 		case hwmon_temp_input:
316 			return TMP51X_TEMP_INPUT[channel];
317 		case hwmon_temp_crit_alarm:
318 			return TMP51X_STATUS;
319 		case hwmon_temp_crit:
320 			return TMP51X_TEMP_CRIT[channel];
321 		case hwmon_temp_crit_hyst:
322 			return TMP51X_TEMP_CRIT_HYST[channel];
323 		}
324 		break;
325 	case hwmon_in:
326 		switch (attr) {
327 		case hwmon_in_input:
328 			return TMP51X_BUS_VOLTAGE_RESULT;
329 		case hwmon_in_lcrit_alarm:
330 		case hwmon_in_crit_alarm:
331 			return TMP51X_STATUS;
332 		case hwmon_in_lcrit:
333 			return TMP51X_BUS_VOLTAGE_L_LIMIT;
334 		case hwmon_in_crit:
335 			return TMP51X_BUS_VOLTAGE_H_LIMIT;
336 		}
337 		break;
338 	case hwmon_curr:
339 		switch (attr) {
340 		case hwmon_curr_input:
341 			return TMP51X_CURR_INPUT[channel];
342 		case hwmon_curr_lcrit_alarm:
343 		case hwmon_curr_crit_alarm:
344 			return TMP51X_STATUS;
345 		case hwmon_curr_lcrit:
346 			return TMP51X_SHUNT_CURRENT_L_LIMIT;
347 		case hwmon_curr_crit:
348 			return TMP51X_SHUNT_CURRENT_H_LIMIT;
349 		}
350 		break;
351 	case hwmon_power:
352 		switch (attr) {
353 		case hwmon_power_input:
354 			return TMP51X_POWER_RESULT;
355 		case hwmon_power_crit_alarm:
356 			return TMP51X_STATUS;
357 		case hwmon_power_crit:
358 			return TMP51X_POWER_LIMIT;
359 		}
360 		break;
361 	default:
362 		break;
363 	}
364 
365 	return 0;
366 }
367 
tmp51x_get_status_pos(enum hwmon_sensor_types type,u32 attr,int channel)368 static u8 tmp51x_get_status_pos(enum hwmon_sensor_types type, u32 attr,
369 				int channel)
370 {
371 	switch (type) {
372 	case hwmon_temp:
373 		switch (attr) {
374 		case hwmon_temp_crit_alarm:
375 			return TMP51X_TEMP_CRIT_ALARM[channel];
376 		}
377 		break;
378 	case hwmon_in:
379 		switch (attr) {
380 		case hwmon_in_lcrit_alarm:
381 			return TMP51X_BUS_VOLTAGE_L_LIMIT_POS;
382 		case hwmon_in_crit_alarm:
383 			return TMP51X_BUS_VOLTAGE_H_LIMIT_POS;
384 		}
385 		break;
386 	case hwmon_curr:
387 		switch (attr) {
388 		case hwmon_curr_lcrit_alarm:
389 			return TMP51X_SHUNT_CURRENT_L_LIMIT_POS;
390 		case hwmon_curr_crit_alarm:
391 			return TMP51X_SHUNT_CURRENT_H_LIMIT_POS;
392 		}
393 		break;
394 	case hwmon_power:
395 		switch (attr) {
396 		case hwmon_power_crit_alarm:
397 			return TMP51X_POWER_LIMIT_POS;
398 		}
399 		break;
400 	default:
401 		break;
402 	}
403 
404 	return 0;
405 }
406 
tmp51x_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)407 static int tmp51x_read(struct device *dev, enum hwmon_sensor_types type,
408 		       u32 attr, int channel, long *val)
409 {
410 	struct tmp51x_data *data = dev_get_drvdata(dev);
411 	int ret;
412 	u32 regval;
413 	u8 pos = 0, reg = 0;
414 
415 	reg = tmp51x_get_reg(type, attr, channel);
416 	if (reg == 0)
417 		return -EOPNOTSUPP;
418 
419 	if (reg == TMP51X_STATUS)
420 		pos = tmp51x_get_status_pos(type, attr, channel);
421 
422 	ret = regmap_read(data->regmap, reg, &regval);
423 	if (ret < 0)
424 		return ret;
425 
426 	return tmp51x_get_value(data, reg, pos, regval, val);
427 }
428 
tmp51x_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)429 static int tmp51x_write(struct device *dev, enum hwmon_sensor_types type,
430 			u32 attr, int channel, long val)
431 {
432 	u8 reg = 0;
433 
434 	reg = tmp51x_get_reg(type, attr, channel);
435 	if (reg == 0)
436 		return -EOPNOTSUPP;
437 
438 	return tmp51x_set_value(dev_get_drvdata(dev), reg, val);
439 }
440 
tmp51x_is_visible(const void * _data,enum hwmon_sensor_types type,u32 attr,int channel)441 static umode_t tmp51x_is_visible(const void *_data,
442 				 enum hwmon_sensor_types type, u32 attr,
443 				 int channel)
444 {
445 	const struct tmp51x_data *data = _data;
446 
447 	switch (type) {
448 	case hwmon_temp:
449 		if (channel >= data->max_channels)
450 			return 0;
451 		switch (attr) {
452 		case hwmon_temp_input:
453 		case hwmon_temp_crit_alarm:
454 			return 0444;
455 		case hwmon_temp_crit:
456 			return 0644;
457 		case hwmon_temp_crit_hyst:
458 			if (channel == 0)
459 				return 0644;
460 			return 0444;
461 		}
462 		break;
463 	case hwmon_in:
464 		switch (attr) {
465 		case hwmon_in_input:
466 		case hwmon_in_lcrit_alarm:
467 		case hwmon_in_crit_alarm:
468 			return 0444;
469 		case hwmon_in_lcrit:
470 		case hwmon_in_crit:
471 			return 0644;
472 		}
473 		break;
474 	case hwmon_curr:
475 		if (!data->shunt_uohms)
476 			return 0;
477 
478 		switch (attr) {
479 		case hwmon_curr_input:
480 		case hwmon_curr_lcrit_alarm:
481 		case hwmon_curr_crit_alarm:
482 			return 0444;
483 		case hwmon_curr_lcrit:
484 		case hwmon_curr_crit:
485 			return 0644;
486 		}
487 		break;
488 	case hwmon_power:
489 		if (!data->shunt_uohms)
490 			return 0;
491 
492 		switch (attr) {
493 		case hwmon_power_input:
494 		case hwmon_power_crit_alarm:
495 			return 0444;
496 		case hwmon_power_crit:
497 			return 0644;
498 		}
499 		break;
500 	default:
501 		break;
502 	}
503 	return 0;
504 }
505 
506 static const struct hwmon_channel_info * const tmp51x_info[] = {
507 	HWMON_CHANNEL_INFO(temp,
508 			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
509 			   HWMON_T_CRIT_HYST,
510 			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
511 			   HWMON_T_CRIT_HYST,
512 			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
513 			   HWMON_T_CRIT_HYST,
514 			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |
515 			   HWMON_T_CRIT_HYST),
516 	HWMON_CHANNEL_INFO(in,
517 			   HWMON_I_INPUT | HWMON_I_LCRIT | HWMON_I_LCRIT_ALARM |
518 			   HWMON_I_CRIT | HWMON_I_CRIT_ALARM),
519 	HWMON_CHANNEL_INFO(curr,
520 			   HWMON_C_INPUT | HWMON_C_LCRIT | HWMON_C_LCRIT_ALARM |
521 			   HWMON_C_CRIT | HWMON_C_CRIT_ALARM,
522 			   HWMON_C_INPUT),
523 	HWMON_CHANNEL_INFO(power,
524 			   HWMON_P_INPUT | HWMON_P_CRIT | HWMON_P_CRIT_ALARM),
525 	NULL
526 };
527 
528 static const struct hwmon_ops tmp51x_hwmon_ops = {
529 	.is_visible = tmp51x_is_visible,
530 	.read = tmp51x_read,
531 	.write = tmp51x_write,
532 };
533 
534 static const struct hwmon_chip_info tmp51x_chip_info = {
535 	.ops = &tmp51x_hwmon_ops,
536 	.info = tmp51x_info,
537 };
538 
539 /*
540  * Calibrate the tmp51x following the datasheet method
541  */
tmp51x_calibrate(struct tmp51x_data * data)542 static int tmp51x_calibrate(struct tmp51x_data *data)
543 {
544 	int vshunt_max = data->pga_gain * 40;
545 	u64 max_curr_ma;
546 	u32 div;
547 
548 	/*
549 	 * If shunt_uohms is equal to 0, the calibration should be set to 0.
550 	 * The consequence will be that the current and power measurement engine
551 	 * of the sensor will not work. Temperature and voltage sensing will
552 	 * continue to work.
553 	 */
554 	if (data->shunt_uohms == 0)
555 		return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION, 0);
556 
557 	max_curr_ma = DIV_ROUND_CLOSEST_ULL(vshunt_max * MICRO, data->shunt_uohms);
558 
559 	/*
560 	 * Calculate the minimal bit resolution for the current and the power.
561 	 * Those values will be used during register interpretation.
562 	 */
563 	data->curr_lsb_ua = DIV_ROUND_CLOSEST_ULL(max_curr_ma * MILLI, 32767);
564 	data->pwr_lsb_uw = 20 * data->curr_lsb_ua;
565 
566 	div = DIV_ROUND_CLOSEST_ULL(data->curr_lsb_ua * data->shunt_uohms, MICRO);
567 
568 	return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION,
569 			    DIV_ROUND_CLOSEST(40960, div));
570 }
571 
572 /*
573  * Initialize the configuration and calibration registers.
574  */
tmp51x_init(struct tmp51x_data * data)575 static int tmp51x_init(struct tmp51x_data *data)
576 {
577 	unsigned int regval;
578 	int ret = regmap_write(data->regmap, TMP51X_SHUNT_CONFIG,
579 			       data->shunt_config);
580 	if (ret < 0)
581 		return ret;
582 
583 	ret = regmap_write(data->regmap, TMP51X_TEMP_CONFIG, data->temp_config);
584 	if (ret < 0)
585 		return ret;
586 
587 	// nFactor configuration
588 	ret = regmap_update_bits(data->regmap, TMP51X_N_FACTOR_AND_HYST_1,
589 				 TMP51X_NFACTOR_MASK, data->nfactor[0] << 8);
590 	if (ret < 0)
591 		return ret;
592 
593 	ret = regmap_write(data->regmap, TMP51X_N_FACTOR_2,
594 			   data->nfactor[1] << 8);
595 	if (ret < 0)
596 		return ret;
597 
598 	if (data->max_channels == TMP513_MAX_CHANNELS) {
599 		ret = regmap_write(data->regmap, TMP513_N_FACTOR_3,
600 				   data->nfactor[2] << 8);
601 		if (ret < 0)
602 			return ret;
603 	}
604 
605 	ret = tmp51x_calibrate(data);
606 	if (ret < 0)
607 		return ret;
608 
609 	// Read the status register before using as the datasheet propose
610 	return regmap_read(data->regmap, TMP51X_STATUS, &regval);
611 }
612 
613 static const struct i2c_device_id tmp51x_id[] = {
614 	{ "tmp512", TMP512_MAX_CHANNELS },
615 	{ "tmp513", TMP513_MAX_CHANNELS },
616 	{ }
617 };
618 MODULE_DEVICE_TABLE(i2c, tmp51x_id);
619 
620 static const struct of_device_id tmp51x_of_match[] = {
621 	{ .compatible = "ti,tmp512", .data = (void *)TMP512_MAX_CHANNELS },
622 	{ .compatible = "ti,tmp513", .data = (void *)TMP513_MAX_CHANNELS },
623 	{ }
624 };
625 MODULE_DEVICE_TABLE(of, tmp51x_of_match);
626 
tmp51x_vbus_range_to_reg(struct device * dev,struct tmp51x_data * data)627 static int tmp51x_vbus_range_to_reg(struct device *dev,
628 				    struct tmp51x_data *data)
629 {
630 	if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) {
631 		data->shunt_config |= TMP51X_BUS_VOLTAGE_MASK;
632 	} else if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_16V) {
633 		data->shunt_config &= ~TMP51X_BUS_VOLTAGE_MASK;
634 	} else {
635 		return dev_err_probe(dev, -EINVAL,
636 				     "ti,bus-range-microvolt is invalid: %u\n",
637 				     data->vbus_range_uvolt);
638 	}
639 	return 0;
640 }
641 
tmp51x_pga_gain_to_reg(struct device * dev,struct tmp51x_data * data)642 static int tmp51x_pga_gain_to_reg(struct device *dev, struct tmp51x_data *data)
643 {
644 	if (data->pga_gain == 8) {
645 		data->shunt_config |= CURRENT_SENSE_VOLTAGE_320_MASK;
646 	} else if (data->pga_gain == 4) {
647 		data->shunt_config |= CURRENT_SENSE_VOLTAGE_160_MASK;
648 	} else if (data->pga_gain == 2) {
649 		data->shunt_config |= CURRENT_SENSE_VOLTAGE_80_MASK;
650 	} else if (data->pga_gain == 1) {
651 		data->shunt_config |= CURRENT_SENSE_VOLTAGE_40_MASK;
652 	} else {
653 		return dev_err_probe(dev, -EINVAL,
654 				     "ti,pga-gain is invalid: %u\n", data->pga_gain);
655 	}
656 	return 0;
657 }
658 
tmp51x_read_properties(struct device * dev,struct tmp51x_data * data)659 static int tmp51x_read_properties(struct device *dev, struct tmp51x_data *data)
660 {
661 	int ret;
662 	u32 val;
663 
664 	ret = device_property_read_u32(dev, "shunt-resistor-micro-ohms", &val);
665 	data->shunt_uohms = (ret >= 0) ? val : TMP51X_SHUNT_VALUE_DEFAULT;
666 
667 	ret = device_property_read_u32(dev, "ti,bus-range-microvolt", &val);
668 	data->vbus_range_uvolt = (ret >= 0) ? val : TMP51X_VBUS_RANGE_DEFAULT;
669 	ret = tmp51x_vbus_range_to_reg(dev, data);
670 	if (ret < 0)
671 		return ret;
672 
673 	ret = device_property_read_u32(dev, "ti,pga-gain", &val);
674 	data->pga_gain = (ret >= 0) ? val : TMP51X_PGA_DEFAULT;
675 	ret = tmp51x_pga_gain_to_reg(dev, data);
676 	if (ret < 0)
677 		return ret;
678 
679 	device_property_read_u32_array(dev, "ti,nfactor", data->nfactor,
680 				       data->max_channels - 1);
681 
682 	// Check if shunt value is compatible with pga-gain
683 	if (data->shunt_uohms > data->pga_gain * 40 * MICRO) {
684 		return dev_err_probe(dev, -EINVAL,
685 				     "shunt-resistor: %u too big for pga_gain: %u\n",
686 				     data->shunt_uohms, data->pga_gain);
687 	}
688 
689 	return 0;
690 }
691 
tmp51x_use_default(struct tmp51x_data * data)692 static void tmp51x_use_default(struct tmp51x_data *data)
693 {
694 	data->vbus_range_uvolt = TMP51X_VBUS_RANGE_DEFAULT;
695 	data->pga_gain = TMP51X_PGA_DEFAULT;
696 	data->shunt_uohms = TMP51X_SHUNT_VALUE_DEFAULT;
697 }
698 
tmp51x_configure(struct device * dev,struct tmp51x_data * data)699 static int tmp51x_configure(struct device *dev, struct tmp51x_data *data)
700 {
701 	data->shunt_config = TMP51X_SHUNT_CONFIG_DEFAULT;
702 	data->temp_config = TMP51X_TEMP_CONFIG_DEFAULT(data->max_channels);
703 
704 	if (dev->of_node)
705 		return tmp51x_read_properties(dev, data);
706 
707 	tmp51x_use_default(data);
708 
709 	return 0;
710 }
711 
tmp51x_probe(struct i2c_client * client)712 static int tmp51x_probe(struct i2c_client *client)
713 {
714 	struct device *dev = &client->dev;
715 	struct tmp51x_data *data;
716 	struct device *hwmon_dev;
717 	int ret;
718 
719 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
720 	if (!data)
721 		return -ENOMEM;
722 
723 	data->max_channels = (uintptr_t)i2c_get_match_data(client);
724 
725 	ret = tmp51x_configure(dev, data);
726 	if (ret < 0)
727 		return dev_err_probe(dev, ret, "error configuring the device\n");
728 
729 	data->regmap = devm_regmap_init_i2c(client, &tmp51x_regmap_config);
730 	if (IS_ERR(data->regmap))
731 		return dev_err_probe(dev, PTR_ERR(data->regmap),
732 				     "failed to allocate register map\n");
733 
734 	ret = tmp51x_init(data);
735 	if (ret < 0)
736 		return dev_err_probe(dev, ret, "error configuring the device\n");
737 
738 	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
739 							 data,
740 							 &tmp51x_chip_info,
741 							 NULL);
742 	if (IS_ERR(hwmon_dev))
743 		return PTR_ERR(hwmon_dev);
744 
745 	dev_dbg(dev, "power monitor %s\n", client->name);
746 
747 	return 0;
748 }
749 
750 static struct i2c_driver tmp51x_driver = {
751 	.driver = {
752 		.name	= "tmp51x",
753 		.of_match_table = tmp51x_of_match,
754 	},
755 	.probe		= tmp51x_probe,
756 	.id_table	= tmp51x_id,
757 };
758 
759 module_i2c_driver(tmp51x_driver);
760 
761 MODULE_AUTHOR("Eric Tremblay <etremblay@distechcontrols.com>");
762 MODULE_DESCRIPTION("tmp51x driver");
763 MODULE_LICENSE("GPL");
764