1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Driver for Texas Instruments INA219, INA226 power monitor chips 4 * 5 * INA219: 6 * Zero Drift Bi-Directional Current/Power Monitor with I2C Interface 7 * Datasheet: https://www.ti.com/product/ina219 8 * 9 * INA220: 10 * Bi-Directional Current/Power Monitor with I2C Interface 11 * Datasheet: https://www.ti.com/product/ina220 12 * 13 * INA226: 14 * Bi-Directional Current/Power Monitor with I2C Interface 15 * Datasheet: https://www.ti.com/product/ina226 16 * 17 * INA230: 18 * Bi-directional Current/Power Monitor with I2C Interface 19 * Datasheet: https://www.ti.com/product/ina230 20 * 21 * Copyright (C) 2012 Lothar Felten <lothar.felten@gmail.com> 22 * Thanks to Jan Volkering 23 */ 24 25#include <linux/kernel.h> 26#include <linux/module.h> 27#include <linux/init.h> 28#include <linux/err.h> 29#include <linux/slab.h> 30#include <linux/i2c.h> 31#include <linux/hwmon.h> 32#include <linux/hwmon-sysfs.h> 33#include <linux/jiffies.h> 34#include <linux/of.h> 35#include <linux/delay.h> 36#include <linux/util_macros.h> 37#include <linux/regmap.h> 38 39#include <linux/platform_data/ina2xx.h> 40 41/* common register definitions */ 42#define INA2XX_CONFIG 0x00 43#define INA2XX_SHUNT_VOLTAGE 0x01 /* readonly */ 44#define INA2XX_BUS_VOLTAGE 0x02 /* readonly */ 45#define INA2XX_POWER 0x03 /* readonly */ 46#define INA2XX_CURRENT 0x04 /* readonly */ 47#define INA2XX_CALIBRATION 0x05 48 49/* INA226 register definitions */ 50#define INA226_MASK_ENABLE 0x06 51#define INA226_ALERT_LIMIT 0x07 52#define INA226_DIE_ID 0xFF 53 54/* register count */ 55#define INA219_REGISTERS 6 56#define INA226_REGISTERS 8 57 58#define INA2XX_MAX_REGISTERS 8 59 60/* settings - depend on use case */ 61#define INA219_CONFIG_DEFAULT 0x399F /* PGA=8 */ 62#define INA226_CONFIG_DEFAULT 0x4527 /* averages=16 */ 63 64/* worst case is 68.10 ms (~14.6Hz, ina219) */ 65#define INA2XX_CONVERSION_RATE 15 66#define INA2XX_MAX_DELAY 69 /* worst case delay in ms */ 67 68#define INA2XX_RSHUNT_DEFAULT 10000 69 70/* bit mask for reading the averaging setting in the configuration register */ 71#define INA226_AVG_RD_MASK 0x0E00 72 73#define INA226_READ_AVG(reg) (((reg) & INA226_AVG_RD_MASK) >> 9) 74#define INA226_SHIFT_AVG(val) ((val) << 9) 75 76/* bit number of alert functions in Mask/Enable Register */ 77#define INA226_SHUNT_OVER_VOLTAGE_BIT 15 78#define INA226_SHUNT_UNDER_VOLTAGE_BIT 14 79#define INA226_BUS_OVER_VOLTAGE_BIT 13 80#define INA226_BUS_UNDER_VOLTAGE_BIT 12 81#define INA226_POWER_OVER_LIMIT_BIT 11 82 83/* bit mask for alert config bits of Mask/Enable Register */ 84#define INA226_ALERT_CONFIG_MASK 0xFC00 85#define INA226_ALERT_FUNCTION_FLAG BIT(4) 86 87/* common attrs, ina226 attrs and NULL */ 88#define INA2XX_MAX_ATTRIBUTE_GROUPS 3 89 90/* 91 * Both bus voltage and shunt voltage conversion times for ina226 are set 92 * to 0b0100 on POR, which translates to 2200 microseconds in total. 93 */ 94#define INA226_TOTAL_CONV_TIME_DEFAULT 2200 95 96static struct regmap_config ina2xx_regmap_config = { 97 .reg_bits = 8, 98 .val_bits = 16, 99}; 100 101enum ina2xx_ids { ina219, ina226 }; 102 103struct ina2xx_config { 104 u16 config_default; 105 int calibration_value; 106 int registers; 107 int shunt_div; 108 int bus_voltage_shift; 109 int bus_voltage_lsb; /* uV */ 110 int power_lsb_factor; 111}; 112 113struct ina2xx_data { 114 const struct ina2xx_config *config; 115 116 long rshunt; 117 long current_lsb_uA; 118 long power_lsb_uW; 119 struct mutex config_lock; 120 struct regmap *regmap; 121 122 const struct attribute_group *groups[INA2XX_MAX_ATTRIBUTE_GROUPS]; 123}; 124 125static const struct ina2xx_config ina2xx_config[] = { 126 [ina219] = { 127 .config_default = INA219_CONFIG_DEFAULT, 128 .calibration_value = 4096, 129 .registers = INA219_REGISTERS, 130 .shunt_div = 100, 131 .bus_voltage_shift = 3, 132 .bus_voltage_lsb = 4000, 133 .power_lsb_factor = 20, 134 }, 135 [ina226] = { 136 .config_default = INA226_CONFIG_DEFAULT, 137 .calibration_value = 2048, 138 .registers = INA226_REGISTERS, 139 .shunt_div = 400, 140 .bus_voltage_shift = 0, 141 .bus_voltage_lsb = 1250, 142 .power_lsb_factor = 25, 143 }, 144}; 145 146/* 147 * Available averaging rates for ina226. The indices correspond with 148 * the bit values expected by the chip (according to the ina226 datasheet, 149 * table 3 AVG bit settings, found at 150 * https://www.ti.com/lit/ds/symlink/ina226.pdf. 151 */ 152static const int ina226_avg_tab[] = { 1, 4, 16, 64, 128, 256, 512, 1024 }; 153 154static int ina226_reg_to_interval(u16 config) 155{ 156 int avg = ina226_avg_tab[INA226_READ_AVG(config)]; 157 158 /* 159 * Multiply the total conversion time by the number of averages. 160 * Return the result in milliseconds. 161 */ 162 return DIV_ROUND_CLOSEST(avg * INA226_TOTAL_CONV_TIME_DEFAULT, 1000); 163} 164 165/* 166 * Return the new, shifted AVG field value of CONFIG register, 167 * to use with regmap_update_bits 168 */ 169static u16 ina226_interval_to_reg(int interval) 170{ 171 int avg, avg_bits; 172 173 avg = DIV_ROUND_CLOSEST(interval * 1000, 174 INA226_TOTAL_CONV_TIME_DEFAULT); 175 avg_bits = find_closest(avg, ina226_avg_tab, 176 ARRAY_SIZE(ina226_avg_tab)); 177 178 return INA226_SHIFT_AVG(avg_bits); 179} 180 181/* 182 * Calibration register is set to the best value, which eliminates 183 * truncation errors on calculating current register in hardware. 184 * According to datasheet (eq. 3) the best values are 2048 for 185 * ina226 and 4096 for ina219. They are hardcoded as calibration_value. 186 */ 187static int ina2xx_calibrate(struct ina2xx_data *data) 188{ 189 return regmap_write(data->regmap, INA2XX_CALIBRATION, 190 data->config->calibration_value); 191} 192 193/* 194 * Initialize the configuration and calibration registers. 195 */ 196static int ina2xx_init(struct ina2xx_data *data) 197{ 198 int ret = regmap_write(data->regmap, INA2XX_CONFIG, 199 data->config->config_default); 200 if (ret < 0) 201 return ret; 202 203 return ina2xx_calibrate(data); 204} 205 206static int ina2xx_read_reg(struct device *dev, int reg, unsigned int *regval) 207{ 208 struct ina2xx_data *data = dev_get_drvdata(dev); 209 int ret, retry; 210 211 dev_dbg(dev, "Starting register %d read\n", reg); 212 213 for (retry = 5; retry; retry--) { 214 215 ret = regmap_read(data->regmap, reg, regval); 216 if (ret < 0) 217 return ret; 218 219 dev_dbg(dev, "read %d, val = 0x%04x\n", reg, *regval); 220 221 /* 222 * If the current value in the calibration register is 0, the 223 * power and current registers will also remain at 0. In case 224 * the chip has been reset let's check the calibration 225 * register and reinitialize if needed. 226 * We do that extra read of the calibration register if there 227 * is some hint of a chip reset. 228 */ 229 if (*regval == 0) { 230 unsigned int cal; 231 232 ret = regmap_read(data->regmap, INA2XX_CALIBRATION, 233 &cal); 234 if (ret < 0) 235 return ret; 236 237 if (cal == 0) { 238 dev_warn(dev, "chip not calibrated, reinitializing\n"); 239 240 ret = ina2xx_init(data); 241 if (ret < 0) 242 return ret; 243 /* 244 * Let's make sure the power and current 245 * registers have been updated before trying 246 * again. 247 */ 248 msleep(INA2XX_MAX_DELAY); 249 continue; 250 } 251 } 252 return 0; 253 } 254 255 /* 256 * If we're here then although all write operations succeeded, the 257 * chip still returns 0 in the calibration register. Nothing more we 258 * can do here. 259 */ 260 dev_err(dev, "unable to reinitialize the chip\n"); 261 return -ENODEV; 262} 263 264static int ina2xx_get_value(struct ina2xx_data *data, u8 reg, 265 unsigned int regval) 266{ 267 int val; 268 269 switch (reg) { 270 case INA2XX_SHUNT_VOLTAGE: 271 /* signed register */ 272 val = DIV_ROUND_CLOSEST((s16)regval, data->config->shunt_div); 273 break; 274 case INA2XX_BUS_VOLTAGE: 275 val = (regval >> data->config->bus_voltage_shift) 276 * data->config->bus_voltage_lsb; 277 val = DIV_ROUND_CLOSEST(val, 1000); 278 break; 279 case INA2XX_POWER: 280 val = regval * data->power_lsb_uW; 281 break; 282 case INA2XX_CURRENT: 283 /* signed register, result in mA */ 284 val = (s16)regval * data->current_lsb_uA; 285 val = DIV_ROUND_CLOSEST(val, 1000); 286 break; 287 case INA2XX_CALIBRATION: 288 val = regval; 289 break; 290 default: 291 /* programmer goofed */ 292 WARN_ON_ONCE(1); 293 val = 0; 294 break; 295 } 296 297 return val; 298} 299 300static ssize_t ina2xx_value_show(struct device *dev, 301 struct device_attribute *da, char *buf) 302{ 303 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 304 struct ina2xx_data *data = dev_get_drvdata(dev); 305 unsigned int regval; 306 307 int err = ina2xx_read_reg(dev, attr->index, ®val); 308 309 if (err < 0) 310 return err; 311 312 return sysfs_emit(buf, "%d\n", ina2xx_get_value(data, attr->index, regval)); 313} 314 315static int ina226_reg_to_alert(struct ina2xx_data *data, u8 bit, u16 regval) 316{ 317 int reg; 318 319 switch (bit) { 320 case INA226_SHUNT_OVER_VOLTAGE_BIT: 321 case INA226_SHUNT_UNDER_VOLTAGE_BIT: 322 reg = INA2XX_SHUNT_VOLTAGE; 323 break; 324 case INA226_BUS_OVER_VOLTAGE_BIT: 325 case INA226_BUS_UNDER_VOLTAGE_BIT: 326 reg = INA2XX_BUS_VOLTAGE; 327 break; 328 case INA226_POWER_OVER_LIMIT_BIT: 329 reg = INA2XX_POWER; 330 break; 331 default: 332 /* programmer goofed */ 333 WARN_ON_ONCE(1); 334 return 0; 335 } 336 337 return ina2xx_get_value(data, reg, regval); 338} 339 340/* 341 * Turns alert limit values into register values. 342 * Opposite of the formula in ina2xx_get_value(). 343 */ 344static s16 ina226_alert_to_reg(struct ina2xx_data *data, u8 bit, int val) 345{ 346 switch (bit) { 347 case INA226_SHUNT_OVER_VOLTAGE_BIT: 348 case INA226_SHUNT_UNDER_VOLTAGE_BIT: 349 val *= data->config->shunt_div; 350 return clamp_val(val, SHRT_MIN, SHRT_MAX); 351 case INA226_BUS_OVER_VOLTAGE_BIT: 352 case INA226_BUS_UNDER_VOLTAGE_BIT: 353 val = (val * 1000) << data->config->bus_voltage_shift; 354 val = DIV_ROUND_CLOSEST(val, data->config->bus_voltage_lsb); 355 return clamp_val(val, 0, SHRT_MAX); 356 case INA226_POWER_OVER_LIMIT_BIT: 357 val = DIV_ROUND_CLOSEST(val, data->power_lsb_uW); 358 return clamp_val(val, 0, USHRT_MAX); 359 default: 360 /* programmer goofed */ 361 WARN_ON_ONCE(1); 362 return 0; 363 } 364} 365 366static ssize_t ina226_alert_show(struct device *dev, 367 struct device_attribute *da, char *buf) 368{ 369 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 370 struct ina2xx_data *data = dev_get_drvdata(dev); 371 int regval; 372 int val = 0; 373 int ret; 374 375 mutex_lock(&data->config_lock); 376 ret = regmap_read(data->regmap, INA226_MASK_ENABLE, ®val); 377 if (ret) 378 goto abort; 379 380 if (regval & BIT(attr->index)) { 381 ret = regmap_read(data->regmap, INA226_ALERT_LIMIT, ®val); 382 if (ret) 383 goto abort; 384 val = ina226_reg_to_alert(data, attr->index, regval); 385 } 386 387 ret = sysfs_emit(buf, "%d\n", val); 388abort: 389 mutex_unlock(&data->config_lock); 390 return ret; 391} 392 393static ssize_t ina226_alert_store(struct device *dev, 394 struct device_attribute *da, 395 const char *buf, size_t count) 396{ 397 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 398 struct ina2xx_data *data = dev_get_drvdata(dev); 399 unsigned long val; 400 int ret; 401 402 ret = kstrtoul(buf, 10, &val); 403 if (ret < 0) 404 return ret; 405 406 /* 407 * Clear all alerts first to avoid accidentally triggering ALERT pin 408 * due to register write sequence. Then, only enable the alert 409 * if the value is non-zero. 410 */ 411 mutex_lock(&data->config_lock); 412 ret = regmap_update_bits(data->regmap, INA226_MASK_ENABLE, 413 INA226_ALERT_CONFIG_MASK, 0); 414 if (ret < 0) 415 goto abort; 416 417 ret = regmap_write(data->regmap, INA226_ALERT_LIMIT, 418 ina226_alert_to_reg(data, attr->index, val)); 419 if (ret < 0) 420 goto abort; 421 422 if (val != 0) { 423 ret = regmap_update_bits(data->regmap, INA226_MASK_ENABLE, 424 INA226_ALERT_CONFIG_MASK, 425 BIT(attr->index)); 426 if (ret < 0) 427 goto abort; 428 } 429 430 ret = count; 431abort: 432 mutex_unlock(&data->config_lock); 433 return ret; 434} 435 436static ssize_t ina226_alarm_show(struct device *dev, 437 struct device_attribute *da, char *buf) 438{ 439 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 440 struct ina2xx_data *data = dev_get_drvdata(dev); 441 int regval; 442 int alarm = 0; 443 int ret; 444 445 ret = regmap_read(data->regmap, INA226_MASK_ENABLE, ®val); 446 if (ret) 447 return ret; 448 449 alarm = (regval & BIT(attr->index)) && 450 (regval & INA226_ALERT_FUNCTION_FLAG); 451 return sysfs_emit(buf, "%d\n", alarm); 452} 453 454/* 455 * In order to keep calibration register value fixed, the product 456 * of current_lsb and shunt_resistor should also be fixed and equal 457 * to shunt_voltage_lsb = 1 / shunt_div multiplied by 10^9 in order 458 * to keep the scale. 459 */ 460static int ina2xx_set_shunt(struct ina2xx_data *data, long val) 461{ 462 unsigned int dividend = DIV_ROUND_CLOSEST(1000000000, 463 data->config->shunt_div); 464 if (val <= 0 || val > dividend) 465 return -EINVAL; 466 467 mutex_lock(&data->config_lock); 468 data->rshunt = val; 469 data->current_lsb_uA = DIV_ROUND_CLOSEST(dividend, val); 470 data->power_lsb_uW = data->config->power_lsb_factor * 471 data->current_lsb_uA; 472 mutex_unlock(&data->config_lock); 473 474 return 0; 475} 476 477static ssize_t ina2xx_shunt_show(struct device *dev, 478 struct device_attribute *da, char *buf) 479{ 480 struct ina2xx_data *data = dev_get_drvdata(dev); 481 482 return sysfs_emit(buf, "%li\n", data->rshunt); 483} 484 485static ssize_t ina2xx_shunt_store(struct device *dev, 486 struct device_attribute *da, 487 const char *buf, size_t count) 488{ 489 unsigned long val; 490 int status; 491 struct ina2xx_data *data = dev_get_drvdata(dev); 492 493 status = kstrtoul(buf, 10, &val); 494 if (status < 0) 495 return status; 496 497 status = ina2xx_set_shunt(data, val); 498 if (status < 0) 499 return status; 500 return count; 501} 502 503static ssize_t ina226_interval_store(struct device *dev, 504 struct device_attribute *da, 505 const char *buf, size_t count) 506{ 507 struct ina2xx_data *data = dev_get_drvdata(dev); 508 unsigned long val; 509 int status; 510 511 status = kstrtoul(buf, 10, &val); 512 if (status < 0) 513 return status; 514 515 if (val > INT_MAX || val == 0) 516 return -EINVAL; 517 518 status = regmap_update_bits(data->regmap, INA2XX_CONFIG, 519 INA226_AVG_RD_MASK, 520 ina226_interval_to_reg(val)); 521 if (status < 0) 522 return status; 523 524 return count; 525} 526 527static ssize_t ina226_interval_show(struct device *dev, 528 struct device_attribute *da, char *buf) 529{ 530 struct ina2xx_data *data = dev_get_drvdata(dev); 531 int status; 532 unsigned int regval; 533 534 status = regmap_read(data->regmap, INA2XX_CONFIG, ®val); 535 if (status) 536 return status; 537 538 return sysfs_emit(buf, "%d\n", ina226_reg_to_interval(regval)); 539} 540 541/* shunt voltage */ 542static SENSOR_DEVICE_ATTR_RO(in0_input, ina2xx_value, INA2XX_SHUNT_VOLTAGE); 543/* shunt voltage over/under voltage alert setting and alarm */ 544static SENSOR_DEVICE_ATTR_RW(in0_crit, ina226_alert, 545 INA226_SHUNT_OVER_VOLTAGE_BIT); 546static SENSOR_DEVICE_ATTR_RW(in0_lcrit, ina226_alert, 547 INA226_SHUNT_UNDER_VOLTAGE_BIT); 548static SENSOR_DEVICE_ATTR_RO(in0_crit_alarm, ina226_alarm, 549 INA226_SHUNT_OVER_VOLTAGE_BIT); 550static SENSOR_DEVICE_ATTR_RO(in0_lcrit_alarm, ina226_alarm, 551 INA226_SHUNT_UNDER_VOLTAGE_BIT); 552 553/* bus voltage */ 554static SENSOR_DEVICE_ATTR_RO(in1_input, ina2xx_value, INA2XX_BUS_VOLTAGE); 555/* bus voltage over/under voltage alert setting and alarm */ 556static SENSOR_DEVICE_ATTR_RW(in1_crit, ina226_alert, 557 INA226_BUS_OVER_VOLTAGE_BIT); 558static SENSOR_DEVICE_ATTR_RW(in1_lcrit, ina226_alert, 559 INA226_BUS_UNDER_VOLTAGE_BIT); 560static SENSOR_DEVICE_ATTR_RO(in1_crit_alarm, ina226_alarm, 561 INA226_BUS_OVER_VOLTAGE_BIT); 562static SENSOR_DEVICE_ATTR_RO(in1_lcrit_alarm, ina226_alarm, 563 INA226_BUS_UNDER_VOLTAGE_BIT); 564 565/* calculated current */ 566static SENSOR_DEVICE_ATTR_RO(curr1_input, ina2xx_value, INA2XX_CURRENT); 567 568/* calculated power */ 569static SENSOR_DEVICE_ATTR_RO(power1_input, ina2xx_value, INA2XX_POWER); 570/* over-limit power alert setting and alarm */ 571static SENSOR_DEVICE_ATTR_RW(power1_crit, ina226_alert, 572 INA226_POWER_OVER_LIMIT_BIT); 573static SENSOR_DEVICE_ATTR_RO(power1_crit_alarm, ina226_alarm, 574 INA226_POWER_OVER_LIMIT_BIT); 575 576/* shunt resistance */ 577static SENSOR_DEVICE_ATTR_RW(shunt_resistor, ina2xx_shunt, INA2XX_CALIBRATION); 578 579/* update interval (ina226 only) */ 580static SENSOR_DEVICE_ATTR_RW(update_interval, ina226_interval, 0); 581 582/* pointers to created device attributes */ 583static struct attribute *ina2xx_attrs[] = { 584 &sensor_dev_attr_in0_input.dev_attr.attr, 585 &sensor_dev_attr_in1_input.dev_attr.attr, 586 &sensor_dev_attr_curr1_input.dev_attr.attr, 587 &sensor_dev_attr_power1_input.dev_attr.attr, 588 &sensor_dev_attr_shunt_resistor.dev_attr.attr, 589 NULL, 590}; 591 592static const struct attribute_group ina2xx_group = { 593 .attrs = ina2xx_attrs, 594}; 595 596static struct attribute *ina226_attrs[] = { 597 &sensor_dev_attr_in0_crit.dev_attr.attr, 598 &sensor_dev_attr_in0_lcrit.dev_attr.attr, 599 &sensor_dev_attr_in0_crit_alarm.dev_attr.attr, 600 &sensor_dev_attr_in0_lcrit_alarm.dev_attr.attr, 601 &sensor_dev_attr_in1_crit.dev_attr.attr, 602 &sensor_dev_attr_in1_lcrit.dev_attr.attr, 603 &sensor_dev_attr_in1_crit_alarm.dev_attr.attr, 604 &sensor_dev_attr_in1_lcrit_alarm.dev_attr.attr, 605 &sensor_dev_attr_power1_crit.dev_attr.attr, 606 &sensor_dev_attr_power1_crit_alarm.dev_attr.attr, 607 &sensor_dev_attr_update_interval.dev_attr.attr, 608 NULL, 609}; 610 611static const struct attribute_group ina226_group = { 612 .attrs = ina226_attrs, 613}; 614 615static const struct i2c_device_id ina2xx_id[]; 616 617static int ina2xx_probe(struct i2c_client *client) 618{ 619 struct device *dev = &client->dev; 620 struct ina2xx_data *data; 621 struct device *hwmon_dev; 622 u32 val; 623 int ret, group = 0; 624 enum ina2xx_ids chip; 625 626 if (client->dev.of_node) 627 chip = (uintptr_t)of_device_get_match_data(&client->dev); 628 else 629 chip = i2c_match_id(ina2xx_id, client)->driver_data; 630 631 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 632 if (!data) 633 return -ENOMEM; 634 635 /* set the device type */ 636 data->config = &ina2xx_config[chip]; 637 mutex_init(&data->config_lock); 638 639 if (of_property_read_u32(dev->of_node, "shunt-resistor", &val) < 0) { 640 struct ina2xx_platform_data *pdata = dev_get_platdata(dev); 641 642 if (pdata) 643 val = pdata->shunt_uohms; 644 else 645 val = INA2XX_RSHUNT_DEFAULT; 646 } 647 648 ina2xx_set_shunt(data, val); 649 650 ina2xx_regmap_config.max_register = data->config->registers; 651 652 data->regmap = devm_regmap_init_i2c(client, &ina2xx_regmap_config); 653 if (IS_ERR(data->regmap)) { 654 dev_err(dev, "failed to allocate register map\n"); 655 return PTR_ERR(data->regmap); 656 } 657 658 ret = devm_regulator_get_enable(dev, "vs"); 659 if (ret) 660 return dev_err_probe(dev, ret, "failed to enable vs regulator\n"); 661 662 ret = ina2xx_init(data); 663 if (ret < 0) { 664 dev_err(dev, "error configuring the device: %d\n", ret); 665 return -ENODEV; 666 } 667 668 data->groups[group++] = &ina2xx_group; 669 if (chip == ina226) 670 data->groups[group++] = &ina226_group; 671 672 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 673 data, data->groups); 674 if (IS_ERR(hwmon_dev)) 675 return PTR_ERR(hwmon_dev); 676 677 dev_info(dev, "power monitor %s (Rshunt = %li uOhm)\n", 678 client->name, data->rshunt); 679 680 return 0; 681} 682 683static const struct i2c_device_id ina2xx_id[] = { 684 { "ina219", ina219 }, 685 { "ina220", ina219 }, 686 { "ina226", ina226 }, 687 { "ina230", ina226 }, 688 { "ina231", ina226 }, 689 { } 690}; 691MODULE_DEVICE_TABLE(i2c, ina2xx_id); 692 693static const struct of_device_id __maybe_unused ina2xx_of_match[] = { 694 { 695 .compatible = "ti,ina219", 696 .data = (void *)ina219 697 }, 698 { 699 .compatible = "ti,ina220", 700 .data = (void *)ina219 701 }, 702 { 703 .compatible = "ti,ina226", 704 .data = (void *)ina226 705 }, 706 { 707 .compatible = "ti,ina230", 708 .data = (void *)ina226 709 }, 710 { 711 .compatible = "ti,ina231", 712 .data = (void *)ina226 713 }, 714 { }, 715}; 716MODULE_DEVICE_TABLE(of, ina2xx_of_match); 717 718static struct i2c_driver ina2xx_driver = { 719 .driver = { 720 .name = "ina2xx", 721 .of_match_table = of_match_ptr(ina2xx_of_match), 722 }, 723 .probe = ina2xx_probe, 724 .id_table = ina2xx_id, 725}; 726 727module_i2c_driver(ina2xx_driver); 728 729MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>"); 730MODULE_DESCRIPTION("ina2xx driver"); 731MODULE_LICENSE("GPL"); 732