761 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Driver for Texas Instruments TMP512, TMP513 power monitor chips4 *5 * TMP513:6 * Thermal/Power Management with Triple Remote and7 * Local Temperature Sensor and Current Shunt Monitor8 * Datasheet: https://www.ti.com/lit/gpn/tmp5139 *10 * TMP512:11 * Thermal/Power Management with Dual Remote12 * and Local Temperature Sensor and Current Shunt Monitor13 * Datasheet: https://www.ti.com/lit/gpn/tmp51214 *15 * Copyright (C) 2019 Eric Tremblay <etremblay@distech-controls.com>16 *17 * This program is free software; you can redistribute it and/or modify18 * it under the terms of the GNU General Public License as published by19 * 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 definition38#define TMP51X_SHUNT_CONFIG 0x0039#define TMP51X_TEMP_CONFIG 0x0140#define TMP51X_STATUS 0x0241#define TMP51X_SMBUS_ALERT 0x0342#define TMP51X_SHUNT_CURRENT_RESULT 0x0443#define TMP51X_BUS_VOLTAGE_RESULT 0x0544#define TMP51X_POWER_RESULT 0x0645#define TMP51X_BUS_CURRENT_RESULT 0x0746#define TMP51X_LOCAL_TEMP_RESULT 0x0847#define TMP51X_REMOTE_TEMP_RESULT_1 0x0948#define TMP51X_REMOTE_TEMP_RESULT_2 0x0A49#define TMP51X_SHUNT_CURRENT_H_LIMIT 0x0C50#define TMP51X_SHUNT_CURRENT_L_LIMIT 0x0D51#define TMP51X_BUS_VOLTAGE_H_LIMIT 0x0E52#define TMP51X_BUS_VOLTAGE_L_LIMIT 0x0F53#define TMP51X_POWER_LIMIT 0x1054#define TMP51X_LOCAL_TEMP_LIMIT 0x1155#define TMP51X_REMOTE_TEMP_LIMIT_1 0x1256#define TMP51X_REMOTE_TEMP_LIMIT_2 0x1357#define TMP51X_SHUNT_CALIBRATION 0x1558#define TMP51X_N_FACTOR_AND_HYST_1 0x1659#define TMP51X_N_FACTOR_2 0x1760#define TMP51X_MAN_ID_REG 0xFE61#define TMP51X_DEVICE_ID_REG 0xFF62 63// TMP513 specific register definition64#define TMP513_REMOTE_TEMP_RESULT_3 0x0B65#define TMP513_REMOTE_TEMP_LIMIT_3 0x1466#define TMP513_N_FACTOR_3 0x1867 68// Common attrs, and NULL69#define TMP51X_MANUFACTURER_ID 0x55FF70 71#define TMP512_DEVICE_ID 0x22FF72#define TMP513_DEVICE_ID 0x23FF73 74// Default config75#define TMP51X_SHUNT_CONFIG_DEFAULT 0x399F76#define TMP51X_SHUNT_VALUE_DEFAULT 100077#define TMP51X_VBUS_RANGE_DEFAULT TMP51X_VBUS_RANGE_32V78#define TMP51X_PGA_DEFAULT 879#define TMP51X_MAX_REGISTER_ADDR 0xFF80 81// Mask and shift82#define CURRENT_SENSE_VOLTAGE_320_MASK 0x180083#define CURRENT_SENSE_VOLTAGE_160_MASK 0x100084#define CURRENT_SENSE_VOLTAGE_80_MASK 0x080085#define CURRENT_SENSE_VOLTAGE_40_MASK 086 87#define TMP51X_BUS_VOLTAGE_MASK 0x200088#define TMP51X_NFACTOR_MASK 0xFF0089#define TMP51X_HYST_MASK 0x00FF90 91#define TMP51X_BUS_VOLTAGE_SHIFT 392#define TMP51X_TEMP_SHIFT 393 94// Alarms95#define TMP51X_SHUNT_CURRENT_H_LIMIT_POS 1596#define TMP51X_SHUNT_CURRENT_L_LIMIT_POS 1497#define TMP51X_BUS_VOLTAGE_H_LIMIT_POS 1398#define TMP51X_BUS_VOLTAGE_L_LIMIT_POS 1299#define TMP51X_POWER_LIMIT_POS 11100#define TMP51X_LOCAL_TEMP_LIMIT_POS 10101#define TMP51X_REMOTE_TEMP_LIMIT_1_POS 9102#define TMP51X_REMOTE_TEMP_LIMIT_2_POS 8103#define TMP513_REMOTE_TEMP_LIMIT_3_POS 7104 105#define TMP51X_VBUS_RANGE_32V (32 * MICRO)106#define TMP51X_VBUS_RANGE_16V (16 * MICRO)107 108// Max and Min value109#define MAX_BUS_VOLTAGE_32_LIMIT 32764110#define MAX_BUS_VOLTAGE_16_LIMIT 16382111 112// Max possible value is -256 to +256 but datasheet indicated -40 to 125.113#define MAX_TEMP_LIMIT 125000114#define MIN_TEMP_LIMIT -40000115 116#define MAX_TEMP_HYST 127500117 118#define TMP512_MAX_CHANNELS 3119#define TMP513_MAX_CHANNELS 4120 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 129static 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_3134};135 136static 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_3141};142 143static 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_POS148};149 150static 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_1155};156 157static const u8 TMP51X_CURR_INPUT[2] = {158 TMP51X_SHUNT_CURRENT_RESULT,159 TMP51X_BUS_CURRENT_RESULT160};161 162static const struct regmap_config tmp51x_regmap_config = {163 .reg_bits = 8,164 .val_bits = 16,165 .max_register = TMP51X_MAX_REGISTER_ADDR,166};167 168struct 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=4, 4=3, 2=2, 1=1186static inline u8 tmp51x_get_pga_shift(struct tmp51x_data *data)187{188 return 5 - ffs(data->pga_gain);189}190 191static 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 as203 * current to the user.204 * 2's complement number shifted by one to four depending205 * on the pga gain setting. 1lsb = 10uV206 */207 *val = sign_extend32(regval, 17 - tmp51x_get_pga_shift(data));208 *val = DIV_ROUND_CLOSEST(*val * 10 * MILLI, data->shunt_uohms);209 break;210 case TMP51X_BUS_VOLTAGE_RESULT:211 case TMP51X_BUS_VOLTAGE_H_LIMIT:212 case TMP51X_BUS_VOLTAGE_L_LIMIT:213 // 1lsb = 4mV214 *val = (regval >> TMP51X_BUS_VOLTAGE_SHIFT) * 4;215 break;216 case TMP51X_POWER_RESULT:217 case TMP51X_POWER_LIMIT:218 // Power = (current * BusVoltage) / 5000219 *val = regval * data->pwr_lsb_uw;220 break;221 case TMP51X_BUS_CURRENT_RESULT:222 // Current = (ShuntVoltage * CalibrationRegister) / 4096223 *val = sign_extend32(regval, 16) * data->curr_lsb_ua;224 *val = DIV_ROUND_CLOSEST(*val, MILLI);225 break;226 case TMP51X_LOCAL_TEMP_RESULT:227 case TMP51X_REMOTE_TEMP_RESULT_1:228 case TMP51X_REMOTE_TEMP_RESULT_2:229 case TMP513_REMOTE_TEMP_RESULT_3:230 case TMP51X_LOCAL_TEMP_LIMIT:231 case TMP51X_REMOTE_TEMP_LIMIT_1:232 case TMP51X_REMOTE_TEMP_LIMIT_2:233 case TMP513_REMOTE_TEMP_LIMIT_3:234 // 1lsb = 0.0625 degrees centigrade235 *val = sign_extend32(regval, 16) >> TMP51X_TEMP_SHIFT;236 *val = DIV_ROUND_CLOSEST(*val * 625, 10);237 break;238 case TMP51X_N_FACTOR_AND_HYST_1:239 // 1lsb = 0.5 degrees centigrade240 *val = (regval & TMP51X_HYST_MASK) * 500;241 break;242 default:243 // Programmer goofed244 WARN_ON_ONCE(1);245 *val = 0;246 return -EOPNOTSUPP;247 }248 249 return 0;250}251 252static int tmp51x_set_value(struct tmp51x_data *data, u8 reg, long val)253{254 int regval, max_val;255 u32 mask = 0;256 257 switch (reg) {258 case TMP51X_SHUNT_CURRENT_H_LIMIT:259 case TMP51X_SHUNT_CURRENT_L_LIMIT:260 /*261 * The user enter current value and we convert it to262 * voltage. 1lsb = 10uV263 */264 val = DIV_ROUND_CLOSEST(val * data->shunt_uohms, 10 * MILLI);265 max_val = U16_MAX >> tmp51x_get_pga_shift(data);266 regval = clamp_val(val, -max_val, max_val);267 break;268 case TMP51X_BUS_VOLTAGE_H_LIMIT:269 case TMP51X_BUS_VOLTAGE_L_LIMIT:270 // 1lsb = 4mV271 max_val = (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) ?272 MAX_BUS_VOLTAGE_32_LIMIT : MAX_BUS_VOLTAGE_16_LIMIT;273 274 val = clamp_val(DIV_ROUND_CLOSEST(val, 4), 0, max_val);275 regval = val << TMP51X_BUS_VOLTAGE_SHIFT;276 break;277 case TMP51X_POWER_LIMIT:278 regval = clamp_val(DIV_ROUND_CLOSEST(val, data->pwr_lsb_uw), 0,279 U16_MAX);280 break;281 case TMP51X_LOCAL_TEMP_LIMIT:282 case TMP51X_REMOTE_TEMP_LIMIT_1:283 case TMP51X_REMOTE_TEMP_LIMIT_2:284 case TMP513_REMOTE_TEMP_LIMIT_3:285 // 1lsb = 0.0625 degrees centigrade286 val = clamp_val(val, MIN_TEMP_LIMIT, MAX_TEMP_LIMIT);287 regval = DIV_ROUND_CLOSEST(val * 10, 625) << TMP51X_TEMP_SHIFT;288 break;289 case TMP51X_N_FACTOR_AND_HYST_1:290 // 1lsb = 0.5 degrees centigrade291 val = clamp_val(val, 0, MAX_TEMP_HYST);292 regval = DIV_ROUND_CLOSEST(val, 500);293 mask = TMP51X_HYST_MASK;294 break;295 default:296 // Programmer goofed297 WARN_ON_ONCE(1);298 return -EOPNOTSUPP;299 }300 301 if (mask == 0)302 return regmap_write(data->regmap, reg, regval);303 else304 return regmap_update_bits(data->regmap, reg, mask, regval);305}306 307static u8 tmp51x_get_reg(enum hwmon_sensor_types type, u32 attr, int channel)308{309 switch (type) {310 case hwmon_temp:311 switch (attr) {312 case hwmon_temp_input:313 return TMP51X_TEMP_INPUT[channel];314 case hwmon_temp_crit_alarm:315 return TMP51X_STATUS;316 case hwmon_temp_crit:317 return TMP51X_TEMP_CRIT[channel];318 case hwmon_temp_crit_hyst:319 return TMP51X_TEMP_CRIT_HYST[channel];320 }321 break;322 case hwmon_in:323 switch (attr) {324 case hwmon_in_input:325 return TMP51X_BUS_VOLTAGE_RESULT;326 case hwmon_in_lcrit_alarm:327 case hwmon_in_crit_alarm:328 return TMP51X_STATUS;329 case hwmon_in_lcrit:330 return TMP51X_BUS_VOLTAGE_L_LIMIT;331 case hwmon_in_crit:332 return TMP51X_BUS_VOLTAGE_H_LIMIT;333 }334 break;335 case hwmon_curr:336 switch (attr) {337 case hwmon_curr_input:338 return TMP51X_CURR_INPUT[channel];339 case hwmon_curr_lcrit_alarm:340 case hwmon_curr_crit_alarm:341 return TMP51X_STATUS;342 case hwmon_curr_lcrit:343 return TMP51X_SHUNT_CURRENT_L_LIMIT;344 case hwmon_curr_crit:345 return TMP51X_SHUNT_CURRENT_H_LIMIT;346 }347 break;348 case hwmon_power:349 switch (attr) {350 case hwmon_power_input:351 return TMP51X_POWER_RESULT;352 case hwmon_power_crit_alarm:353 return TMP51X_STATUS;354 case hwmon_power_crit:355 return TMP51X_POWER_LIMIT;356 }357 break;358 default:359 break;360 }361 362 return 0;363}364 365static u8 tmp51x_get_status_pos(enum hwmon_sensor_types type, u32 attr,366 int channel)367{368 switch (type) {369 case hwmon_temp:370 switch (attr) {371 case hwmon_temp_crit_alarm:372 return TMP51X_TEMP_CRIT_ALARM[channel];373 }374 break;375 case hwmon_in:376 switch (attr) {377 case hwmon_in_lcrit_alarm:378 return TMP51X_BUS_VOLTAGE_L_LIMIT_POS;379 case hwmon_in_crit_alarm:380 return TMP51X_BUS_VOLTAGE_H_LIMIT_POS;381 }382 break;383 case hwmon_curr:384 switch (attr) {385 case hwmon_curr_lcrit_alarm:386 return TMP51X_SHUNT_CURRENT_L_LIMIT_POS;387 case hwmon_curr_crit_alarm:388 return TMP51X_SHUNT_CURRENT_H_LIMIT_POS;389 }390 break;391 case hwmon_power:392 switch (attr) {393 case hwmon_power_crit_alarm:394 return TMP51X_POWER_LIMIT_POS;395 }396 break;397 default:398 break;399 }400 401 return 0;402}403 404static int tmp51x_read(struct device *dev, enum hwmon_sensor_types type,405 u32 attr, int channel, long *val)406{407 struct tmp51x_data *data = dev_get_drvdata(dev);408 int ret;409 u32 regval;410 u8 pos = 0, reg = 0;411 412 reg = tmp51x_get_reg(type, attr, channel);413 if (reg == 0)414 return -EOPNOTSUPP;415 416 if (reg == TMP51X_STATUS)417 pos = tmp51x_get_status_pos(type, attr, channel);418 419 ret = regmap_read(data->regmap, reg, ®val);420 if (ret < 0)421 return ret;422 423 return tmp51x_get_value(data, reg, pos, regval, val);424}425 426static int tmp51x_write(struct device *dev, enum hwmon_sensor_types type,427 u32 attr, int channel, long val)428{429 u8 reg = 0;430 431 reg = tmp51x_get_reg(type, attr, channel);432 if (reg == 0)433 return -EOPNOTSUPP;434 435 return tmp51x_set_value(dev_get_drvdata(dev), reg, val);436}437 438static umode_t tmp51x_is_visible(const void *_data,439 enum hwmon_sensor_types type, u32 attr,440 int channel)441{442 const struct tmp51x_data *data = _data;443 444 switch (type) {445 case hwmon_temp:446 if (channel >= data->max_channels)447 return 0;448 switch (attr) {449 case hwmon_temp_input:450 case hwmon_temp_crit_alarm:451 return 0444;452 case hwmon_temp_crit:453 return 0644;454 case hwmon_temp_crit_hyst:455 if (channel == 0)456 return 0644;457 return 0444;458 }459 break;460 case hwmon_in:461 switch (attr) {462 case hwmon_in_input:463 case hwmon_in_lcrit_alarm:464 case hwmon_in_crit_alarm:465 return 0444;466 case hwmon_in_lcrit:467 case hwmon_in_crit:468 return 0644;469 }470 break;471 case hwmon_curr:472 if (!data->shunt_uohms)473 return 0;474 475 switch (attr) {476 case hwmon_curr_input:477 case hwmon_curr_lcrit_alarm:478 case hwmon_curr_crit_alarm:479 return 0444;480 case hwmon_curr_lcrit:481 case hwmon_curr_crit:482 return 0644;483 }484 break;485 case hwmon_power:486 if (!data->shunt_uohms)487 return 0;488 489 switch (attr) {490 case hwmon_power_input:491 case hwmon_power_crit_alarm:492 return 0444;493 case hwmon_power_crit:494 return 0644;495 }496 break;497 default:498 break;499 }500 return 0;501}502 503static const struct hwmon_channel_info * const tmp51x_info[] = {504 HWMON_CHANNEL_INFO(temp,505 HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |506 HWMON_T_CRIT_HYST,507 HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |508 HWMON_T_CRIT_HYST,509 HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |510 HWMON_T_CRIT_HYST,511 HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM |512 HWMON_T_CRIT_HYST),513 HWMON_CHANNEL_INFO(in,514 HWMON_I_INPUT | HWMON_I_LCRIT | HWMON_I_LCRIT_ALARM |515 HWMON_I_CRIT | HWMON_I_CRIT_ALARM),516 HWMON_CHANNEL_INFO(curr,517 HWMON_C_INPUT | HWMON_C_LCRIT | HWMON_C_LCRIT_ALARM |518 HWMON_C_CRIT | HWMON_C_CRIT_ALARM,519 HWMON_C_INPUT),520 HWMON_CHANNEL_INFO(power,521 HWMON_P_INPUT | HWMON_P_CRIT | HWMON_P_CRIT_ALARM),522 NULL523};524 525static const struct hwmon_ops tmp51x_hwmon_ops = {526 .is_visible = tmp51x_is_visible,527 .read = tmp51x_read,528 .write = tmp51x_write,529};530 531static const struct hwmon_chip_info tmp51x_chip_info = {532 .ops = &tmp51x_hwmon_ops,533 .info = tmp51x_info,534};535 536/*537 * Calibrate the tmp51x following the datasheet method538 */539static int tmp51x_calibrate(struct tmp51x_data *data)540{541 int vshunt_max = data->pga_gain * 40;542 u64 max_curr_ma;543 u32 div;544 545 /*546 * If shunt_uohms is equal to 0, the calibration should be set to 0.547 * The consequence will be that the current and power measurement engine548 * of the sensor will not work. Temperature and voltage sensing will549 * continue to work.550 */551 if (data->shunt_uohms == 0)552 return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION, 0);553 554 max_curr_ma = DIV_ROUND_CLOSEST_ULL(vshunt_max * MICRO, data->shunt_uohms);555 556 /*557 * Calculate the minimal bit resolution for the current and the power.558 * Those values will be used during register interpretation.559 */560 data->curr_lsb_ua = DIV_ROUND_CLOSEST_ULL(max_curr_ma * MILLI, 32767);561 data->pwr_lsb_uw = 20 * data->curr_lsb_ua;562 563 div = DIV_ROUND_CLOSEST_ULL(data->curr_lsb_ua * data->shunt_uohms, MICRO);564 565 return regmap_write(data->regmap, TMP51X_SHUNT_CALIBRATION,566 DIV_ROUND_CLOSEST(40960, div));567}568 569/*570 * Initialize the configuration and calibration registers.571 */572static int tmp51x_init(struct tmp51x_data *data)573{574 unsigned int regval;575 int ret = regmap_write(data->regmap, TMP51X_SHUNT_CONFIG,576 data->shunt_config);577 if (ret < 0)578 return ret;579 580 ret = regmap_write(data->regmap, TMP51X_TEMP_CONFIG, data->temp_config);581 if (ret < 0)582 return ret;583 584 // nFactor configuration585 ret = regmap_update_bits(data->regmap, TMP51X_N_FACTOR_AND_HYST_1,586 TMP51X_NFACTOR_MASK, data->nfactor[0] << 8);587 if (ret < 0)588 return ret;589 590 ret = regmap_write(data->regmap, TMP51X_N_FACTOR_2,591 data->nfactor[1] << 8);592 if (ret < 0)593 return ret;594 595 if (data->max_channels == TMP513_MAX_CHANNELS) {596 ret = regmap_write(data->regmap, TMP513_N_FACTOR_3,597 data->nfactor[2] << 8);598 if (ret < 0)599 return ret;600 }601 602 ret = tmp51x_calibrate(data);603 if (ret < 0)604 return ret;605 606 // Read the status register before using as the datasheet propose607 return regmap_read(data->regmap, TMP51X_STATUS, ®val);608}609 610static const struct i2c_device_id tmp51x_id[] = {611 { "tmp512", TMP512_MAX_CHANNELS },612 { "tmp513", TMP513_MAX_CHANNELS },613 { }614};615MODULE_DEVICE_TABLE(i2c, tmp51x_id);616 617static const struct of_device_id tmp51x_of_match[] = {618 { .compatible = "ti,tmp512", .data = (void *)TMP512_MAX_CHANNELS },619 { .compatible = "ti,tmp513", .data = (void *)TMP513_MAX_CHANNELS },620 { }621};622MODULE_DEVICE_TABLE(of, tmp51x_of_match);623 624static int tmp51x_vbus_range_to_reg(struct device *dev,625 struct tmp51x_data *data)626{627 if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_32V) {628 data->shunt_config |= TMP51X_BUS_VOLTAGE_MASK;629 } else if (data->vbus_range_uvolt == TMP51X_VBUS_RANGE_16V) {630 data->shunt_config &= ~TMP51X_BUS_VOLTAGE_MASK;631 } else {632 return dev_err_probe(dev, -EINVAL,633 "ti,bus-range-microvolt is invalid: %u\n",634 data->vbus_range_uvolt);635 }636 return 0;637}638 639static int tmp51x_pga_gain_to_reg(struct device *dev, struct tmp51x_data *data)640{641 if (data->pga_gain == 8) {642 data->shunt_config |= CURRENT_SENSE_VOLTAGE_320_MASK;643 } else if (data->pga_gain == 4) {644 data->shunt_config |= CURRENT_SENSE_VOLTAGE_160_MASK;645 } else if (data->pga_gain == 2) {646 data->shunt_config |= CURRENT_SENSE_VOLTAGE_80_MASK;647 } else if (data->pga_gain == 1) {648 data->shunt_config |= CURRENT_SENSE_VOLTAGE_40_MASK;649 } else {650 return dev_err_probe(dev, -EINVAL,651 "ti,pga-gain is invalid: %u\n", data->pga_gain);652 }653 return 0;654}655 656static int tmp51x_read_properties(struct device *dev, struct tmp51x_data *data)657{658 int ret;659 u32 val;660 661 ret = device_property_read_u32(dev, "shunt-resistor-micro-ohms", &val);662 data->shunt_uohms = (ret >= 0) ? val : TMP51X_SHUNT_VALUE_DEFAULT;663 664 ret = device_property_read_u32(dev, "ti,bus-range-microvolt", &val);665 data->vbus_range_uvolt = (ret >= 0) ? val : TMP51X_VBUS_RANGE_DEFAULT;666 ret = tmp51x_vbus_range_to_reg(dev, data);667 if (ret < 0)668 return ret;669 670 ret = device_property_read_u32(dev, "ti,pga-gain", &val);671 data->pga_gain = (ret >= 0) ? val : TMP51X_PGA_DEFAULT;672 ret = tmp51x_pga_gain_to_reg(dev, data);673 if (ret < 0)674 return ret;675 676 device_property_read_u32_array(dev, "ti,nfactor", data->nfactor,677 data->max_channels - 1);678 679 // Check if shunt value is compatible with pga-gain680 if (data->shunt_uohms > data->pga_gain * 40 * MICRO) {681 return dev_err_probe(dev, -EINVAL,682 "shunt-resistor: %u too big for pga_gain: %u\n",683 data->shunt_uohms, data->pga_gain);684 }685 686 return 0;687}688 689static void tmp51x_use_default(struct tmp51x_data *data)690{691 data->vbus_range_uvolt = TMP51X_VBUS_RANGE_DEFAULT;692 data->pga_gain = TMP51X_PGA_DEFAULT;693 data->shunt_uohms = TMP51X_SHUNT_VALUE_DEFAULT;694}695 696static int tmp51x_configure(struct device *dev, struct tmp51x_data *data)697{698 data->shunt_config = TMP51X_SHUNT_CONFIG_DEFAULT;699 data->temp_config = TMP51X_TEMP_CONFIG_DEFAULT(data->max_channels);700 701 if (dev->of_node)702 return tmp51x_read_properties(dev, data);703 704 tmp51x_use_default(data);705 706 return 0;707}708 709static int tmp51x_probe(struct i2c_client *client)710{711 struct device *dev = &client->dev;712 struct tmp51x_data *data;713 struct device *hwmon_dev;714 int ret;715 716 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);717 if (!data)718 return -ENOMEM;719 720 data->max_channels = (uintptr_t)i2c_get_match_data(client);721 722 ret = tmp51x_configure(dev, data);723 if (ret < 0)724 return dev_err_probe(dev, ret, "error configuring the device\n");725 726 data->regmap = devm_regmap_init_i2c(client, &tmp51x_regmap_config);727 if (IS_ERR(data->regmap))728 return dev_err_probe(dev, PTR_ERR(data->regmap),729 "failed to allocate register map\n");730 731 ret = tmp51x_init(data);732 if (ret < 0)733 return dev_err_probe(dev, ret, "error configuring the device\n");734 735 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,736 data,737 &tmp51x_chip_info,738 NULL);739 if (IS_ERR(hwmon_dev))740 return PTR_ERR(hwmon_dev);741 742 dev_dbg(dev, "power monitor %s\n", client->name);743 744 return 0;745}746 747static struct i2c_driver tmp51x_driver = {748 .driver = {749 .name = "tmp51x",750 .of_match_table = tmp51x_of_match,751 },752 .probe = tmp51x_probe,753 .id_table = tmp51x_id,754};755 756module_i2c_driver(tmp51x_driver);757 758MODULE_AUTHOR("Eric Tremblay <etremblay@distechcontrols.com>");759MODULE_DESCRIPTION("tmp51x driver");760MODULE_LICENSE("GPL");761