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 96 static struct regmap_config ina2xx_regmap_config = { 97 .reg_bits = 8, 98 .val_bits = 16, 99 }; 100 101 enum ina2xx_ids { ina219, ina226 }; 102 103 struct 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 113 struct 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 125 static 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 */ 152 static const int ina226_avg_tab[] = { 1, 4, 16, 64, 128, 256, 512, 1024 }; 153 154 static 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 */ 169 static 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 */ 187 static 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 */ 196 static 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 206 static 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 264 static 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 300 static 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 315 static 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 */ 344 static 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 366 static 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); 388 abort: 389 mutex_unlock(&data->config_lock); 390 return ret; 391 } 392 393 static 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; 431 abort: 432 mutex_unlock(&data->config_lock); 433 return ret; 434 } 435 436 static 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 */ 460 static 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 477 static 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 485 static 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 503 static 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 527 static 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 */ 542 static SENSOR_DEVICE_ATTR_RO(in0_input, ina2xx_value, INA2XX_SHUNT_VOLTAGE); 543 /* shunt voltage over/under voltage alert setting and alarm */ 544 static SENSOR_DEVICE_ATTR_RW(in0_crit, ina226_alert, 545 INA226_SHUNT_OVER_VOLTAGE_BIT); 546 static SENSOR_DEVICE_ATTR_RW(in0_lcrit, ina226_alert, 547 INA226_SHUNT_UNDER_VOLTAGE_BIT); 548 static SENSOR_DEVICE_ATTR_RO(in0_crit_alarm, ina226_alarm, 549 INA226_SHUNT_OVER_VOLTAGE_BIT); 550 static SENSOR_DEVICE_ATTR_RO(in0_lcrit_alarm, ina226_alarm, 551 INA226_SHUNT_UNDER_VOLTAGE_BIT); 552 553 /* bus voltage */ 554 static SENSOR_DEVICE_ATTR_RO(in1_input, ina2xx_value, INA2XX_BUS_VOLTAGE); 555 /* bus voltage over/under voltage alert setting and alarm */ 556 static SENSOR_DEVICE_ATTR_RW(in1_crit, ina226_alert, 557 INA226_BUS_OVER_VOLTAGE_BIT); 558 static SENSOR_DEVICE_ATTR_RW(in1_lcrit, ina226_alert, 559 INA226_BUS_UNDER_VOLTAGE_BIT); 560 static SENSOR_DEVICE_ATTR_RO(in1_crit_alarm, ina226_alarm, 561 INA226_BUS_OVER_VOLTAGE_BIT); 562 static SENSOR_DEVICE_ATTR_RO(in1_lcrit_alarm, ina226_alarm, 563 INA226_BUS_UNDER_VOLTAGE_BIT); 564 565 /* calculated current */ 566 static SENSOR_DEVICE_ATTR_RO(curr1_input, ina2xx_value, INA2XX_CURRENT); 567 568 /* calculated power */ 569 static SENSOR_DEVICE_ATTR_RO(power1_input, ina2xx_value, INA2XX_POWER); 570 /* over-limit power alert setting and alarm */ 571 static SENSOR_DEVICE_ATTR_RW(power1_crit, ina226_alert, 572 INA226_POWER_OVER_LIMIT_BIT); 573 static SENSOR_DEVICE_ATTR_RO(power1_crit_alarm, ina226_alarm, 574 INA226_POWER_OVER_LIMIT_BIT); 575 576 /* shunt resistance */ 577 static SENSOR_DEVICE_ATTR_RW(shunt_resistor, ina2xx_shunt, INA2XX_CALIBRATION); 578 579 /* update interval (ina226 only) */ 580 static SENSOR_DEVICE_ATTR_RW(update_interval, ina226_interval, 0); 581 582 /* pointers to created device attributes */ 583 static 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 592 static const struct attribute_group ina2xx_group = { 593 .attrs = ina2xx_attrs, 594 }; 595 596 static 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 611 static const struct attribute_group ina226_group = { 612 .attrs = ina226_attrs, 613 }; 614 615 static const struct i2c_device_id ina2xx_id[]; 616 617 static 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 683 static const struct i2c_device_id ina2xx_id[] = { 684 { "ina219", ina219 }, 685 { "ina220", ina219 }, 686 { "ina226", ina226 }, 687 { "ina230", ina226 }, 688 { "ina231", ina226 }, 689 { } 690 }; 691 MODULE_DEVICE_TABLE(i2c, ina2xx_id); 692 693 static 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 }; 716 MODULE_DEVICE_TABLE(of, ina2xx_of_match); 717 718 static 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 727 module_i2c_driver(ina2xx_driver); 728 729 MODULE_AUTHOR("Lothar Felten <l-felten@ti.com>"); 730 MODULE_DESCRIPTION("ina2xx driver"); 731 MODULE_LICENSE("GPL"); 732