drivers/hwmon/ina3221.c

   1 /*
   2  * INA3221 Triple Current/Voltage Monitor
   3  *
   4  * Copyright (C) 2016 Texas Instruments Incorporated - http://www.ti.com/
   5  *      Andrew F. Davis <afd@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  */
  16
  17 #include <linux/hwmon.h>
  18 #include <linux/hwmon-sysfs.h>
  19 #include <linux/i2c.h>
  20 #include <linux/module.h>
  21 #include <linux/of.h>
  22 #include <linux/regmap.h>
  23
  24 #define INA3221_DRIVER_NAME             "ina3221"
  25
  26 #define INA3221_CONFIG                  0x00
  27 #define INA3221_SHUNT1                  0x01
  28 #define INA3221_BUS1                    0x02
  29 #define INA3221_SHUNT2                  0x03
  30 #define INA3221_BUS2                    0x04
  31 #define INA3221_SHUNT3                  0x05
  32 #define INA3221_BUS3                    0x06
  33 #define INA3221_CRIT1                   0x07
  34 #define INA3221_WARN1                   0x08
  35 #define INA3221_CRIT2                   0x09
  36 #define INA3221_WARN2                   0x0a
  37 #define INA3221_CRIT3                   0x0b
  38 #define INA3221_WARN3                   0x0c
  39 #define INA3221_MASK_ENABLE             0x0f
  40
  41 #define INA3221_CONFIG_MODE_SHUNT       BIT(1)
  42 #define INA3221_CONFIG_MODE_BUS         BIT(2)
  43 #define INA3221_CONFIG_MODE_CONTINUOUS  BIT(3)
  44
  45 #define INA3221_RSHUNT_DEFAULT          10000
  46
  47 enum ina3221_fields {
  48         /* Configuration */
  49         F_RST,
  50
  51         /* Alert Flags */
  52         F_WF3, F_WF2, F_WF1,
  53         F_CF3, F_CF2, F_CF1,
  54
  55         /* sentinel */
  56         F_MAX_FIELDS
  57 };
  58
  59 static const struct reg_field ina3221_reg_fields[] = {
  60         [F_RST] = REG_FIELD(INA3221_CONFIG, 15, 15),
  61
  62         [F_WF3] = REG_FIELD(INA3221_MASK_ENABLE, 3, 3),
  63         [F_WF2] = REG_FIELD(INA3221_MASK_ENABLE, 4, 4),
  64         [F_WF1] = REG_FIELD(INA3221_MASK_ENABLE, 5, 5),
  65         [F_CF3] = REG_FIELD(INA3221_MASK_ENABLE, 7, 7),
  66         [F_CF2] = REG_FIELD(INA3221_MASK_ENABLE, 8, 8),
  67         [F_CF1] = REG_FIELD(INA3221_MASK_ENABLE, 9, 9),
  68 };
  69
  70 enum ina3221_channels {
  71         INA3221_CHANNEL1,
  72         INA3221_CHANNEL2,
  73         INA3221_CHANNEL3,
  74         INA3221_NUM_CHANNELS
  75 };
  76
  77 static const unsigned int register_channel[] = {
  78         [INA3221_SHUNT1] = INA3221_CHANNEL1,
  79         [INA3221_SHUNT2] = INA3221_CHANNEL2,
  80         [INA3221_SHUNT3] = INA3221_CHANNEL3,
  81         [INA3221_CRIT1] = INA3221_CHANNEL1,
  82         [INA3221_CRIT2] = INA3221_CHANNEL2,
  83         [INA3221_CRIT3] = INA3221_CHANNEL3,
  84         [INA3221_WARN1] = INA3221_CHANNEL1,
  85         [INA3221_WARN2] = INA3221_CHANNEL2,
  86         [INA3221_WARN3] = INA3221_CHANNEL3,
  87 };
  88
  89 /**
  90  * struct ina3221_data - device specific information
  91  * @regmap: Register map of the device
  92  * @fields: Register fields of the device
  93  * @shunt_resistors: Array of resistor values per channel
  94  */
  95 struct ina3221_data {
  96         struct regmap *regmap;
  97         struct regmap_field *fields[F_MAX_FIELDS];
  98         int shunt_resistors[INA3221_NUM_CHANNELS];
  99 };
 100
 101 static int ina3221_read_value(struct ina3221_data *ina, unsigned int reg,
 102                               int *val)
 103 {
 104         unsigned int regval;
 105         int ret;
 106
 107         ret = regmap_read(ina->regmap, reg, &regval);
 108         if (ret)
 109                 return ret;
 110
 111         *val = sign_extend32(regval >> 3, 12);
 112
 113         return 0;
 114 }
 115
 116 static ssize_t ina3221_show_bus_voltage(struct device *dev,
 117                                         struct device_attribute *attr,
 118                                         char *buf)
 119 {
 120         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 121         struct ina3221_data *ina = dev_get_drvdata(dev);
 122         unsigned int reg = sd_attr->index;
 123         int val, voltage_mv, ret;
 124
 125         ret = ina3221_read_value(ina, reg, &val);
 126         if (ret)
 127                 return ret;
 128
 129         voltage_mv = val * 8;
 130
 131         return snprintf(buf, PAGE_SIZE, "%d\n", voltage_mv);
 132 }
 133
 134 static ssize_t ina3221_show_shunt_voltage(struct device *dev,
 135                                           struct device_attribute *attr,
 136                                           char *buf)
 137 {
 138         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 139         struct ina3221_data *ina = dev_get_drvdata(dev);
 140         unsigned int reg = sd_attr->index;
 141         int val, voltage_uv, ret;
 142
 143         ret = ina3221_read_value(ina, reg, &val);
 144         if (ret)
 145                 return ret;
 146         voltage_uv = val * 40;
 147
 148         return snprintf(buf, PAGE_SIZE, "%d\n", voltage_uv);
 149 }
 150
 151 static ssize_t ina3221_show_current(struct device *dev,
 152                                     struct device_attribute *attr, char *buf)
 153 {
 154         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 155         struct ina3221_data *ina = dev_get_drvdata(dev);
 156         unsigned int reg = sd_attr->index;
 157         unsigned int channel = register_channel[reg];
 158         int resistance_uo = ina->shunt_resistors[channel];
 159         int val, current_ma, voltage_nv, ret;
 160
 161         ret = ina3221_read_value(ina, reg, &val);
 162         if (ret)
 163                 return ret;
 164         voltage_nv = val * 40000;
 165
 166         current_ma = DIV_ROUND_CLOSEST(voltage_nv, resistance_uo);
 167
 168         return snprintf(buf, PAGE_SIZE, "%d\n", current_ma);
 169 }
 170
 171 static ssize_t ina3221_set_current(struct device *dev,
 172                                    struct device_attribute *attr,
 173                                    const char *buf, size_t count)
 174 {
 175         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 176         struct ina3221_data *ina = dev_get_drvdata(dev);
 177         unsigned int reg = sd_attr->index;
 178         unsigned int channel = register_channel[reg];
 179         int resistance_uo = ina->shunt_resistors[channel];
 180         int val, current_ma, voltage_uv, ret;
 181
 182         ret = kstrtoint(buf, 0, &current_ma);
 183         if (ret)
 184                 return ret;
 185
 186         /* clamp current */
 187         current_ma = clamp_val(current_ma,
 188                                INT_MIN / resistance_uo,
 189                                INT_MAX / resistance_uo);
 190
 191         voltage_uv = DIV_ROUND_CLOSEST(current_ma * resistance_uo, 1000);
 192
 193         /* clamp voltage */
 194         voltage_uv = clamp_val(voltage_uv, -163800, 163800);
 195
 196         /* 1 / 40uV(scale) << 3(register shift) = 5 */
 197         val = DIV_ROUND_CLOSEST(voltage_uv, 5) & 0xfff8;
 198
 199         ret = regmap_write(ina->regmap, reg, val);
 200         if (ret)
 201                 return ret;
 202
 203         return count;
 204 }
 205
 206 static ssize_t ina3221_show_shunt(struct device *dev,
 207                                   struct device_attribute *attr, char *buf)
 208 {
 209         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 210         struct ina3221_data *ina = dev_get_drvdata(dev);
 211         unsigned int channel = sd_attr->index;
 212         unsigned int resistance_uo;
 213
 214         resistance_uo = ina->shunt_resistors[channel];
 215
 216         return snprintf(buf, PAGE_SIZE, "%d\n", resistance_uo);
 217 }
 218
 219 static ssize_t ina3221_set_shunt(struct device *dev,
 220                                  struct device_attribute *attr,
 221                                  const char *buf, size_t count)
 222 {
 223         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 224         struct ina3221_data *ina = dev_get_drvdata(dev);
 225         unsigned int channel = sd_attr->index;
 226         int val;
 227         int ret;
 228
 229         ret = kstrtoint(buf, 0, &val);
 230         if (ret)
 231                 return ret;
 232
 233         val = clamp_val(val, 1, INT_MAX);
 234
 235         ina->shunt_resistors[channel] = val;
 236
 237         return count;
 238 }
 239
 240 static ssize_t ina3221_show_alert(struct device *dev,
 241                                   struct device_attribute *attr, char *buf)
 242 {
 243         struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(attr);
 244         struct ina3221_data *ina = dev_get_drvdata(dev);
 245         unsigned int field = sd_attr->index;
 246         unsigned int regval;
 247         int ret;
 248
 249         ret = regmap_field_read(ina->fields[field], &regval);
 250         if (ret)
 251                 return ret;
 252
 253         return snprintf(buf, PAGE_SIZE, "%d\n", regval);
 254 }
 255
 256 /* bus voltage */
 257 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO,
 258                 ina3221_show_bus_voltage, NULL, INA3221_BUS1);
 259 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO,
 260                 ina3221_show_bus_voltage, NULL, INA3221_BUS2);
 261 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO,
 262                 ina3221_show_bus_voltage, NULL, INA3221_BUS3);
 263
 264 /* calculated current */
 265 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO,
 266                 ina3221_show_current, NULL, INA3221_SHUNT1);
 267 static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO,
 268                 ina3221_show_current, NULL, INA3221_SHUNT2);
 269 static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO,
 270                 ina3221_show_current, NULL, INA3221_SHUNT3);
 271
 272 /* shunt resistance */
 273 static SENSOR_DEVICE_ATTR(shunt1_resistor, S_IRUGO | S_IWUSR,
 274                 ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL1);
 275 static SENSOR_DEVICE_ATTR(shunt2_resistor, S_IRUGO | S_IWUSR,
 276                 ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL2);
 277 static SENSOR_DEVICE_ATTR(shunt3_resistor, S_IRUGO | S_IWUSR,
 278                 ina3221_show_shunt, ina3221_set_shunt, INA3221_CHANNEL3);
 279
 280 /* critical current */
 281 static SENSOR_DEVICE_ATTR(curr1_crit, S_IRUGO | S_IWUSR,
 282                 ina3221_show_current, ina3221_set_current, INA3221_CRIT1);
 283 static SENSOR_DEVICE_ATTR(curr2_crit, S_IRUGO | S_IWUSR,
 284                 ina3221_show_current, ina3221_set_current, INA3221_CRIT2);
 285 static SENSOR_DEVICE_ATTR(curr3_crit, S_IRUGO | S_IWUSR,
 286                 ina3221_show_current, ina3221_set_current, INA3221_CRIT3);
 287
 288 /* critical current alert */
 289 static SENSOR_DEVICE_ATTR(curr1_crit_alarm, S_IRUGO,
 290                 ina3221_show_alert, NULL, F_CF1);
 291 static SENSOR_DEVICE_ATTR(curr2_crit_alarm, S_IRUGO,
 292                 ina3221_show_alert, NULL, F_CF2);
 293 static SENSOR_DEVICE_ATTR(curr3_crit_alarm, S_IRUGO,
 294                 ina3221_show_alert, NULL, F_CF3);
 295
 296 /* warning current */
 297 static SENSOR_DEVICE_ATTR(curr1_max, S_IRUGO | S_IWUSR,
 298                 ina3221_show_current, ina3221_set_current, INA3221_WARN1);
 299 static SENSOR_DEVICE_ATTR(curr2_max, S_IRUGO | S_IWUSR,
 300                 ina3221_show_current, ina3221_set_current, INA3221_WARN2);
 301 static SENSOR_DEVICE_ATTR(curr3_max, S_IRUGO | S_IWUSR,
 302                 ina3221_show_current, ina3221_set_current, INA3221_WARN3);
 303
 304 /* warning current alert */
 305 static SENSOR_DEVICE_ATTR(curr1_max_alarm, S_IRUGO,
 306                 ina3221_show_alert, NULL, F_WF1);
 307 static SENSOR_DEVICE_ATTR(curr2_max_alarm, S_IRUGO,
 308                 ina3221_show_alert, NULL, F_WF2);
 309 static SENSOR_DEVICE_ATTR(curr3_max_alarm, S_IRUGO,
 310                 ina3221_show_alert, NULL, F_WF3);
 311
 312 /* shunt voltage */
 313 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO,
 314                 ina3221_show_shunt_voltage, NULL, INA3221_SHUNT1);
 315 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO,
 316                 ina3221_show_shunt_voltage, NULL, INA3221_SHUNT2);
 317 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO,
 318                 ina3221_show_shunt_voltage, NULL, INA3221_SHUNT3);
 319
 320 static struct attribute *ina3221_attrs[] = {
 321         /* channel 1 */
 322         &sensor_dev_attr_in1_input.dev_attr.attr,
 323         &sensor_dev_attr_curr1_input.dev_attr.attr,
 324         &sensor_dev_attr_shunt1_resistor.dev_attr.attr,
 325         &sensor_dev_attr_curr1_crit.dev_attr.attr,
 326         &sensor_dev_attr_curr1_crit_alarm.dev_attr.attr,
 327         &sensor_dev_attr_curr1_max.dev_attr.attr,
 328         &sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
 329         &sensor_dev_attr_in4_input.dev_attr.attr,
 330
 331         /* channel 2 */
 332         &sensor_dev_attr_in2_input.dev_attr.attr,
 333         &sensor_dev_attr_curr2_input.dev_attr.attr,
 334         &sensor_dev_attr_shunt2_resistor.dev_attr.attr,
 335         &sensor_dev_attr_curr2_crit.dev_attr.attr,
 336         &sensor_dev_attr_curr2_crit_alarm.dev_attr.attr,
 337         &sensor_dev_attr_curr2_max.dev_attr.attr,
 338         &sensor_dev_attr_curr2_max_alarm.dev_attr.attr,
 339         &sensor_dev_attr_in5_input.dev_attr.attr,
 340
 341         /* channel 3 */
 342         &sensor_dev_attr_in3_input.dev_attr.attr,
 343         &sensor_dev_attr_curr3_input.dev_attr.attr,
 344         &sensor_dev_attr_shunt3_resistor.dev_attr.attr,
 345         &sensor_dev_attr_curr3_crit.dev_attr.attr,
 346         &sensor_dev_attr_curr3_crit_alarm.dev_attr.attr,
 347         &sensor_dev_attr_curr3_max.dev_attr.attr,
 348         &sensor_dev_attr_curr3_max_alarm.dev_attr.attr,
 349         &sensor_dev_attr_in6_input.dev_attr.attr,
 350
 351         NULL,
 352 };
 353 ATTRIBUTE_GROUPS(ina3221);
 354
 355 static const struct regmap_range ina3221_yes_ranges[] = {
 356         regmap_reg_range(INA3221_SHUNT1, INA3221_BUS3),
 357         regmap_reg_range(INA3221_MASK_ENABLE, INA3221_MASK_ENABLE),
 358 };
 359
 360 static const struct regmap_access_table ina3221_volatile_table = {
 361         .yes_ranges = ina3221_yes_ranges,
 362         .n_yes_ranges = ARRAY_SIZE(ina3221_yes_ranges),
 363 };
 364
 365 static const struct regmap_config ina3221_regmap_config = {
 366         .reg_bits = 8,
 367         .val_bits = 16,
 368
 369         .cache_type = REGCACHE_RBTREE,
 370         .volatile_table = &ina3221_volatile_table,
 371 };
 372
 373 static int ina3221_probe(struct i2c_client *client,
 374                          const struct i2c_device_id *id)
 375 {
 376         struct device *dev = &client->dev;
 377         struct ina3221_data *ina;
 378         struct device *hwmon_dev;
 379         int i, ret;
 380
 381         ina = devm_kzalloc(dev, sizeof(*ina), GFP_KERNEL);
 382         if (!ina)
 383                 return -ENOMEM;
 384
 385         ina->regmap = devm_regmap_init_i2c(client, &ina3221_regmap_config);
 386         if (IS_ERR(ina->regmap)) {
 387                 dev_err(dev, "Unable to allocate register map\n");
 388                 return PTR_ERR(ina->regmap);
 389         }
 390
 391         for (i = 0; i < F_MAX_FIELDS; i++) {
 392                 ina->fields[i] = devm_regmap_field_alloc(dev,
 393                                                          ina->regmap,
 394                                                          ina3221_reg_fields[i]);
 395                 if (IS_ERR(ina->fields[i])) {
 396                         dev_err(dev, "Unable to allocate regmap fields\n");
 397                         return PTR_ERR(ina->fields[i]);
 398                 }
 399         }
 400
 401         for (i = 0; i < INA3221_NUM_CHANNELS; i++)
 402                 ina->shunt_resistors[i] = INA3221_RSHUNT_DEFAULT;
 403
 404         ret = regmap_field_write(ina->fields[F_RST], true);
 405         if (ret) {
 406                 dev_err(dev, "Unable to reset device\n");
 407                 return ret;
 408         }
 409
 410         hwmon_dev = devm_hwmon_device_register_with_groups(dev,
 411                                                            client->name,
 412                                                            ina, ina3221_groups);
 413         if (IS_ERR(hwmon_dev)) {
 414                 dev_err(dev, "Unable to register hwmon device\n");
 415                 return PTR_ERR(hwmon_dev);
 416         }
 417
 418         return 0;
 419 }
 420
 421 static const struct of_device_id ina3221_of_match_table[] = {
 422         { .compatible = "ti,ina3221", },
 423         { /* sentinel */ }
 424 };
 425 MODULE_DEVICE_TABLE(of, ina3221_of_match_table);
 426
 427 static const struct i2c_device_id ina3221_ids[] = {
 428         { "ina3221", 0 },
 429         { /* sentinel */ }
 430 };
 431 MODULE_DEVICE_TABLE(i2c, ina3221_ids);
 432
 433 static struct i2c_driver ina3221_i2c_driver = {
 434         .probe = ina3221_probe,
 435         .driver = {
 436                 .name = INA3221_DRIVER_NAME,
 437                 .of_match_table = ina3221_of_match_table,
 438         },
 439         .id_table = ina3221_ids,
 440 };
 441 module_i2c_driver(ina3221_i2c_driver);
 442
 443 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
 444 MODULE_DESCRIPTION("Texas Instruments INA3221 HWMon Driver");
 445 MODULE_LICENSE("GPL v2");