[mirror_ubuntu-bionic-kernel.git] / drivers / hwmon / ina209.c

/*
 * Driver for the Texas Instruments / Burr Brown INA209
 * Bidirectional Current/Power Monitor
 *
 * Copyright (C) 2012 Guenter Roeck <linux@roeck-us.net>
 *
 * Derived from Ira W. Snyder's original driver submission
 *	Copyright (C) 2008 Paul Hays <Paul.Hays@cattail.ca>
 *	Copyright (C) 2008-2009 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * Aligned with ina2xx driver
 *	Copyright (C) 2012 Lothar Felten <l-felten@ti.com>
 *	Thanks to Jan Volkering
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * Datasheet:
 * http://www.ti.com/lit/gpn/ina209
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/bug.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>

#include <linux/platform_data/ina2xx.h>

/* register definitions */
#define INA209_CONFIGURATION		0x00
#define INA209_STATUS			0x01
#define INA209_STATUS_MASK		0x02
#define INA209_SHUNT_VOLTAGE		0x03
#define INA209_BUS_VOLTAGE		0x04
#define INA209_POWER			0x05
#define INA209_CURRENT			0x06
#define INA209_SHUNT_VOLTAGE_POS_PEAK	0x07
#define INA209_SHUNT_VOLTAGE_NEG_PEAK	0x08
#define INA209_BUS_VOLTAGE_MAX_PEAK	0x09
#define INA209_BUS_VOLTAGE_MIN_PEAK	0x0a
#define INA209_POWER_PEAK		0x0b
#define INA209_SHUNT_VOLTAGE_POS_WARN	0x0c
#define INA209_SHUNT_VOLTAGE_NEG_WARN	0x0d
#define INA209_POWER_WARN		0x0e
#define INA209_BUS_VOLTAGE_OVER_WARN	0x0f
#define INA209_BUS_VOLTAGE_UNDER_WARN	0x10
#define INA209_POWER_OVER_LIMIT		0x11
#define INA209_BUS_VOLTAGE_OVER_LIMIT	0x12
#define INA209_BUS_VOLTAGE_UNDER_LIMIT	0x13
#define INA209_CRITICAL_DAC_POS		0x14
#define INA209_CRITICAL_DAC_NEG		0x15
#define INA209_CALIBRATION		0x16

#define INA209_REGISTERS		0x17

#define INA209_CONFIG_DEFAULT		0x3c47	/* PGA=8, full range */
#define INA209_SHUNT_DEFAULT		10000	/* uOhm */

struct ina209_data {
	struct i2c_client *client;

	struct mutex update_lock;
	bool valid;
	unsigned long last_updated;	/* in jiffies */

	u16 regs[INA209_REGISTERS];	/* All chip registers */

	u16 config_orig;		/* Original configuration */
	u16 calibration_orig;		/* Original calibration */
	u16 update_interval;
};

static struct ina209_data *ina209_update_device(struct device *dev)
{
	struct ina209_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	struct ina209_data *ret = data;
	s32 val;
	int i;

	mutex_lock(&data->update_lock);

	if (!data->valid ||
	    time_after(jiffies, data->last_updated + data->update_interval)) {
		for (i = 0; i < ARRAY_SIZE(data->regs); i++) {
			val = i2c_smbus_read_word_swapped(client, i);
			if (val < 0) {
				ret = ERR_PTR(val);
				goto abort;
			}
			data->regs[i] = val;
		}
		data->last_updated = jiffies;
		data->valid = true;
	}
abort:
	mutex_unlock(&data->update_lock);
	return ret;
}

/*
 * Read a value from a device register and convert it to the
 * appropriate sysfs units
 */
static long ina209_from_reg(const u8 reg, const u16 val)
{
	switch (reg) {
	case INA209_SHUNT_VOLTAGE:
	case INA209_SHUNT_VOLTAGE_POS_PEAK:
	case INA209_SHUNT_VOLTAGE_NEG_PEAK:
	case INA209_SHUNT_VOLTAGE_POS_WARN:
	case INA209_SHUNT_VOLTAGE_NEG_WARN:
		/* LSB=10 uV. Convert to mV. */
		return DIV_ROUND_CLOSEST((s16)val, 100);

	case INA209_BUS_VOLTAGE:
	case INA209_BUS_VOLTAGE_MAX_PEAK:
	case INA209_BUS_VOLTAGE_MIN_PEAK:
	case INA209_BUS_VOLTAGE_OVER_WARN:
	case INA209_BUS_VOLTAGE_UNDER_WARN:
	case INA209_BUS_VOLTAGE_OVER_LIMIT:
	case INA209_BUS_VOLTAGE_UNDER_LIMIT:
		/* LSB=4 mV, last 3 bits unused */
		return (val >> 3) * 4;

	case INA209_CRITICAL_DAC_POS:
		/* LSB=1 mV, in the upper 8 bits */
		return val >> 8;

	case INA209_CRITICAL_DAC_NEG:
		/* LSB=1 mV, in the upper 8 bits */
		return -1 * (val >> 8);

	case INA209_POWER:
	case INA209_POWER_PEAK:
	case INA209_POWER_WARN:
	case INA209_POWER_OVER_LIMIT:
		/* LSB=20 mW. Convert to uW */
		return val * 20 * 1000L;

	case INA209_CURRENT:
		/* LSB=1 mA (selected). Is in mA */
		return (s16)val;
	}

	/* programmer goofed */
	WARN_ON_ONCE(1);
	return 0;
}

/*
 * Take a value and convert it to register format, clamping the value
 * to the appropriate range.
 */
static int ina209_to_reg(u8 reg, u16 old, long val)
{
	switch (reg) {
	case INA209_SHUNT_VOLTAGE_POS_WARN:
	case INA209_SHUNT_VOLTAGE_NEG_WARN:
		/* Limit to +- 320 mV, 10 uV LSB */
		return clamp_val(val, -320, 320) * 100;

	case INA209_BUS_VOLTAGE_OVER_WARN:
	case INA209_BUS_VOLTAGE_UNDER_WARN:
	case INA209_BUS_VOLTAGE_OVER_LIMIT:
	case INA209_BUS_VOLTAGE_UNDER_LIMIT:
		/*
		 * Limit to 0-32000 mV, 4 mV LSB
		 *
		 * The last three bits aren't part of the value, but we'll
		 * preserve them in their original state.
		 */
		return (DIV_ROUND_CLOSEST(clamp_val(val, 0, 32000), 4) << 3)
		  | (old & 0x7);

	case INA209_CRITICAL_DAC_NEG:
		/*
		 * Limit to -255-0 mV, 1 mV LSB
		 * Convert the value to a positive value for the register
		 *
		 * The value lives in the top 8 bits only, be careful
		 * and keep original value of other bits.
		 */
		return (clamp_val(-val, 0, 255) << 8) | (old & 0xff);

	case INA209_CRITICAL_DAC_POS:
		/*
		 * Limit to 0-255 mV, 1 mV LSB
		 *
		 * The value lives in the top 8 bits only, be careful
		 * and keep original value of other bits.
		 */
		return (clamp_val(val, 0, 255) << 8) | (old & 0xff);

	case INA209_POWER_WARN:
	case INA209_POWER_OVER_LIMIT:
		/* 20 mW LSB */
		return DIV_ROUND_CLOSEST(val, 20 * 1000);
	}

	/* Other registers are read-only, return access error */
	return -EACCES;
}

static int ina209_interval_from_reg(u16 reg)
{
	return 68 >> (15 - ((reg >> 3) & 0x0f));
}

static u16 ina209_reg_from_interval(u16 config, long interval)
{
	int i, adc;

	if (interval <= 0) {
		adc = 8;
	} else {
		adc = 15;
		for (i = 34 + 34 / 2; i; i >>= 1) {
			if (i < interval)
				break;
			adc--;
		}
	}
	return (config & 0xf807) | (adc << 3) | (adc << 7);
}

static ssize_t ina209_set_interval(struct device *dev,
				   struct device_attribute *da,
				   const char *buf, size_t count)
{
	struct ina209_data *data = ina209_update_device(dev);
	long val;
	u16 regval;
	int ret;

	if (IS_ERR(data))
		return PTR_ERR(data);

	ret = kstrtol(buf, 10, &val);
	if (ret < 0)
		return ret;

	mutex_lock(&data->update_lock);
	regval = ina209_reg_from_interval(data->regs[INA209_CONFIGURATION],
					  val);
	i2c_smbus_write_word_swapped(data->client, INA209_CONFIGURATION,
				     regval);
	data->regs[INA209_CONFIGURATION] = regval;
	data->update_interval = ina209_interval_from_reg(regval);
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t ina209_show_interval(struct device *dev,
				    struct device_attribute *da, char *buf)
{
	struct ina209_data *data = dev_get_drvdata(dev);

	return snprintf(buf, PAGE_SIZE, "%d\n", data->update_interval);
}

/*
 * History is reset by writing 1 into bit 0 of the respective peak register.
 * Since more than one peak register may be affected by the scope of a
 * reset_history attribute write, use a bit mask in attr->index to identify
 * which registers are affected.
 */
static u16 ina209_reset_history_regs[] = {
	INA209_SHUNT_VOLTAGE_POS_PEAK,
	INA209_SHUNT_VOLTAGE_NEG_PEAK,
	INA209_BUS_VOLTAGE_MAX_PEAK,
	INA209_BUS_VOLTAGE_MIN_PEAK,
	INA209_POWER_PEAK
};

static ssize_t ina209_reset_history(struct device *dev,
				    struct device_attribute *da,
				    const char *buf,
				    size_t count)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ina209_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u32 mask = attr->index;
	long val;
	int i, ret;

	ret = kstrtol(buf, 10, &val);
	if (ret < 0)
		return ret;

	mutex_lock(&data->update_lock);
	for (i = 0; i < ARRAY_SIZE(ina209_reset_history_regs); i++) {
		if (mask & (1 << i))
			i2c_smbus_write_word_swapped(client,
					ina209_reset_history_regs[i], 1);
	}
	data->valid = false;
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t ina209_set_value(struct device *dev,
				struct device_attribute *da,
				const char *buf,
				size_t count)
{
	struct ina209_data *data = ina209_update_device(dev);
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	int reg = attr->index;
	long val;
	int ret;

	if (IS_ERR(data))
		return PTR_ERR(data);

	ret = kstrtol(buf, 10, &val);
	if (ret < 0)
		return ret;

	mutex_lock(&data->update_lock);
	ret = ina209_to_reg(reg, data->regs[reg], val);
	if (ret < 0) {
		count = ret;
		goto abort;
	}
	i2c_smbus_write_word_swapped(data->client, reg, ret);
	data->regs[reg] = ret;
abort:
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t ina209_show_value(struct device *dev,
				 struct device_attribute *da,
				 char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ina209_data *data = ina209_update_device(dev);
	long val;

	if (IS_ERR(data))
		return PTR_ERR(data);

	val = ina209_from_reg(attr->index, data->regs[attr->index]);
	return snprintf(buf, PAGE_SIZE, "%ld\n", val);
}

static ssize_t ina209_show_alarm(struct device *dev,
				 struct device_attribute *da,
				 char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ina209_data *data = ina209_update_device(dev);
	const unsigned int mask = attr->index;
	u16 status;

	if (IS_ERR(data))
		return PTR_ERR(data);

	status = data->regs[INA209_STATUS];

	/*
	 * All alarms are in the INA209_STATUS register. To avoid a long
	 * switch statement, the mask is passed in attr->index
	 */
	return snprintf(buf, PAGE_SIZE, "%u\n", !!(status & mask));
}

/* Shunt voltage, history, limits, alarms */
static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina209_show_value, NULL,
			  INA209_SHUNT_VOLTAGE);
static SENSOR_DEVICE_ATTR(in0_input_highest, S_IRUGO, ina209_show_value, NULL,
			  INA209_SHUNT_VOLTAGE_POS_PEAK);
static SENSOR_DEVICE_ATTR(in0_input_lowest, S_IRUGO, ina209_show_value, NULL,
			  INA209_SHUNT_VOLTAGE_NEG_PEAK);
static SENSOR_DEVICE_ATTR(in0_reset_history, S_IWUSR, NULL,
			  ina209_reset_history, (1 << 0) | (1 << 1));
static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_SHUNT_VOLTAGE_POS_WARN);
static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_SHUNT_VOLTAGE_NEG_WARN);
static SENSOR_DEVICE_ATTR(in0_crit_max, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_CRITICAL_DAC_POS);
static SENSOR_DEVICE_ATTR(in0_crit_min, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_CRITICAL_DAC_NEG);

static SENSOR_DEVICE_ATTR(in0_min_alarm,  S_IRUGO, ina209_show_alarm, NULL,
			  1 << 11);
static SENSOR_DEVICE_ATTR(in0_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 12);
static SENSOR_DEVICE_ATTR(in0_crit_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 6);
static SENSOR_DEVICE_ATTR(in0_crit_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 7);

/* Bus voltage, history, limits, alarms */
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina209_show_value, NULL,
			  INA209_BUS_VOLTAGE);
static SENSOR_DEVICE_ATTR(in1_input_highest, S_IRUGO, ina209_show_value, NULL,
			  INA209_BUS_VOLTAGE_MAX_PEAK);
static SENSOR_DEVICE_ATTR(in1_input_lowest, S_IRUGO, ina209_show_value, NULL,
			  INA209_BUS_VOLTAGE_MIN_PEAK);
static SENSOR_DEVICE_ATTR(in1_reset_history, S_IWUSR, NULL,
			  ina209_reset_history, (1 << 2) | (1 << 3));
static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_BUS_VOLTAGE_OVER_WARN);
static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_BUS_VOLTAGE_UNDER_WARN);
static SENSOR_DEVICE_ATTR(in1_crit_max, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_BUS_VOLTAGE_OVER_LIMIT);
static SENSOR_DEVICE_ATTR(in1_crit_min, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_BUS_VOLTAGE_UNDER_LIMIT);

static SENSOR_DEVICE_ATTR(in1_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 14);
static SENSOR_DEVICE_ATTR(in1_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 15);
static SENSOR_DEVICE_ATTR(in1_crit_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 9);
static SENSOR_DEVICE_ATTR(in1_crit_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 10);

/* Power */
static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina209_show_value, NULL,
			  INA209_POWER);
static SENSOR_DEVICE_ATTR(power1_input_highest, S_IRUGO, ina209_show_value,
			  NULL, INA209_POWER_PEAK);
static SENSOR_DEVICE_ATTR(power1_reset_history, S_IWUSR, NULL,
			  ina209_reset_history, 1 << 4);
static SENSOR_DEVICE_ATTR(power1_max, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_POWER_WARN);
static SENSOR_DEVICE_ATTR(power1_crit, S_IRUGO | S_IWUSR, ina209_show_value,
			  ina209_set_value, INA209_POWER_OVER_LIMIT);

static SENSOR_DEVICE_ATTR(power1_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 13);
static SENSOR_DEVICE_ATTR(power1_crit_alarm, S_IRUGO, ina209_show_alarm, NULL,
			  1 << 8);

/* Current */
static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina209_show_value, NULL,
			  INA209_CURRENT);

static SENSOR_DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR,
			  ina209_show_interval, ina209_set_interval, 0);

/*
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
static struct attribute *ina209_attrs[] = {
	&sensor_dev_attr_in0_input.dev_attr.attr,
	&sensor_dev_attr_in0_input_highest.dev_attr.attr,
	&sensor_dev_attr_in0_input_lowest.dev_attr.attr,
	&sensor_dev_attr_in0_reset_history.dev_attr.attr,
	&sensor_dev_attr_in0_max.dev_attr.attr,
	&sensor_dev_attr_in0_min.dev_attr.attr,
	&sensor_dev_attr_in0_crit_max.dev_attr.attr,
	&sensor_dev_attr_in0_crit_min.dev_attr.attr,
	&sensor_dev_attr_in0_max_alarm.dev_attr.attr,
	&sensor_dev_attr_in0_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in0_crit_max_alarm.dev_attr.attr,
	&sensor_dev_attr_in0_crit_min_alarm.dev_attr.attr,

	&sensor_dev_attr_in1_input.dev_attr.attr,
	&sensor_dev_attr_in1_input_highest.dev_attr.attr,
	&sensor_dev_attr_in1_input_lowest.dev_attr.attr,
	&sensor_dev_attr_in1_reset_history.dev_attr.attr,
	&sensor_dev_attr_in1_max.dev_attr.attr,
	&sensor_dev_attr_in1_min.dev_attr.attr,
	&sensor_dev_attr_in1_crit_max.dev_attr.attr,
	&sensor_dev_attr_in1_crit_min.dev_attr.attr,
	&sensor_dev_attr_in1_max_alarm.dev_attr.attr,
	&sensor_dev_attr_in1_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in1_crit_max_alarm.dev_attr.attr,
	&sensor_dev_attr_in1_crit_min_alarm.dev_attr.attr,

	&sensor_dev_attr_power1_input.dev_attr.attr,
	&sensor_dev_attr_power1_input_highest.dev_attr.attr,
	&sensor_dev_attr_power1_reset_history.dev_attr.attr,
	&sensor_dev_attr_power1_max.dev_attr.attr,
	&sensor_dev_attr_power1_crit.dev_attr.attr,
	&sensor_dev_attr_power1_max_alarm.dev_attr.attr,
	&sensor_dev_attr_power1_crit_alarm.dev_attr.attr,

	&sensor_dev_attr_curr1_input.dev_attr.attr,

	&sensor_dev_attr_update_interval.dev_attr.attr,

	NULL,
};
ATTRIBUTE_GROUPS(ina209);

static void ina209_restore_conf(struct i2c_client *client,
				struct ina209_data *data)
{
	/* Restore initial configuration */
	i2c_smbus_write_word_swapped(client, INA209_CONFIGURATION,
				     data->config_orig);
	i2c_smbus_write_word_swapped(client, INA209_CALIBRATION,
				     data->calibration_orig);
}

static int ina209_init_client(struct i2c_client *client,
			      struct ina209_data *data)
{
	struct ina2xx_platform_data *pdata = dev_get_platdata(&client->dev);
	u32 shunt;
	int reg;

	reg = i2c_smbus_read_word_swapped(client, INA209_CALIBRATION);
	if (reg < 0)
		return reg;
	data->calibration_orig = reg;

	reg = i2c_smbus_read_word_swapped(client, INA209_CONFIGURATION);
	if (reg < 0)
		return reg;
	data->config_orig = reg;

	if (pdata) {
		if (pdata->shunt_uohms <= 0)
			return -EINVAL;
		shunt = pdata->shunt_uohms;
	} else if (!of_property_read_u32(client->dev.of_node, "shunt-resistor",
					 &shunt)) {
		if (shunt == 0)
			return -EINVAL;
	} else {
		shunt = data->calibration_orig ?
		  40960000 / data->calibration_orig : INA209_SHUNT_DEFAULT;
	}

	i2c_smbus_write_word_swapped(client, INA209_CONFIGURATION,
				     INA209_CONFIG_DEFAULT);
	data->update_interval = ina209_interval_from_reg(INA209_CONFIG_DEFAULT);

	/*
	 * Calibrate current LSB to 1mA. Shunt is in uOhms.
	 * See equation 13 in datasheet.
	 */
	i2c_smbus_write_word_swapped(client, INA209_CALIBRATION,
				     clamp_val(40960000 / shunt, 1, 65535));

	/* Clear status register */
	i2c_smbus_read_word_swapped(client, INA209_STATUS);

	return 0;
}

static int ina209_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = client->adapter;
	struct ina209_data *data;
	struct device *hwmon_dev;
	int ret;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
		return -ENODEV;

	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	i2c_set_clientdata(client, data);
	data->client = client;
	mutex_init(&data->update_lock);

	ret = ina209_init_client(client, data);
	if (ret)
		return ret;

	hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
							   client->name,
							   data, ina209_groups);
	if (IS_ERR(hwmon_dev)) {
		ret = PTR_ERR(hwmon_dev);
		goto out_restore_conf;
	}

	return 0;

out_restore_conf:
	ina209_restore_conf(client, data);
	return ret;
}

static int ina209_remove(struct i2c_client *client)
{
	struct ina209_data *data = i2c_get_clientdata(client);

	ina209_restore_conf(client, data);

	return 0;
}

static const struct i2c_device_id ina209_id[] = {
	{ "ina209", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ina209_id);

static const struct of_device_id ina209_of_match[] = {
	{ .compatible = "ti,ina209" },
	{ },
};
MODULE_DEVICE_TABLE(of, ina209_of_match);

/* This is the driver that will be inserted */
static struct i2c_driver ina209_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name	= "ina209",
		.of_match_table = of_match_ptr(ina209_of_match),
	},
	.probe		= ina209_probe,
	.remove		= ina209_remove,
	.id_table	= ina209_id,
};

module_i2c_driver(ina209_driver);

MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>, Paul Hays <Paul.Hays@cattail.ca>, Guenter Roeck <linux@roeck-us.net>");
MODULE_DESCRIPTION("INA209 driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
ceeadc5c GR	1	/*
	2	* Driver for the Texas Instruments / Burr Brown INA209
	3	* Bidirectional Current/Power Monitor
	4	*
	5	* Copyright (C) 2012 Guenter Roeck <linux@roeck-us.net>
	6	*
	7	* Derived from Ira W. Snyder's original driver submission
	8	* Copyright (C) 2008 Paul Hays <Paul.Hays@cattail.ca>
	9	* Copyright (C) 2008-2009 Ira W. Snyder <iws@ovro.caltech.edu>
	10	*
	11	* Aligned with ina2xx driver
	12	* Copyright (C) 2012 Lothar Felten <l-felten@ti.com>
	13	* Thanks to Jan Volkering
	14	*
	15	* This program is free software; you can redistribute it and/or modify
	16	* it under the terms of the GNU General Public License as published by
	17	* the Free Software Foundation; version 2 of the License.
	18	*
	19	* Datasheet:
	20	* http://www.ti.com/lit/gpn/ina209
	21	*/
	22
	23	#include <linux/kernel.h>
	24	#include <linux/module.h>
	25	#include <linux/init.h>
	26	#include <linux/err.h>
	27	#include <linux/slab.h>
	28	#include <linux/bug.h>
	29	#include <linux/i2c.h>
	30	#include <linux/hwmon.h>
	31	#include <linux/hwmon-sysfs.h>
	32
	33	#include <linux/platform_data/ina2xx.h>
	34
	35	/* register definitions */
	36	#define INA209_CONFIGURATION 0x00
	37	#define INA209_STATUS 0x01
	38	#define INA209_STATUS_MASK 0x02
	39	#define INA209_SHUNT_VOLTAGE 0x03
	40	#define INA209_BUS_VOLTAGE 0x04
	41	#define INA209_POWER 0x05
	42	#define INA209_CURRENT 0x06
	43	#define INA209_SHUNT_VOLTAGE_POS_PEAK 0x07
	44	#define INA209_SHUNT_VOLTAGE_NEG_PEAK 0x08
	45	#define INA209_BUS_VOLTAGE_MAX_PEAK 0x09
	46	#define INA209_BUS_VOLTAGE_MIN_PEAK 0x0a
	47	#define INA209_POWER_PEAK 0x0b
	48	#define INA209_SHUNT_VOLTAGE_POS_WARN 0x0c
	49	#define INA209_SHUNT_VOLTAGE_NEG_WARN 0x0d
	50	#define INA209_POWER_WARN 0x0e
	51	#define INA209_BUS_VOLTAGE_OVER_WARN 0x0f
	52	#define INA209_BUS_VOLTAGE_UNDER_WARN 0x10
	53	#define INA209_POWER_OVER_LIMIT 0x11
	54	#define INA209_BUS_VOLTAGE_OVER_LIMIT 0x12
	55	#define INA209_BUS_VOLTAGE_UNDER_LIMIT 0x13
	56	#define INA209_CRITICAL_DAC_POS 0x14
	57	#define INA209_CRITICAL_DAC_NEG 0x15
	58	#define INA209_CALIBRATION 0x16
	59
	60	#define INA209_REGISTERS 0x17
	61
	62	#define INA209_CONFIG_DEFAULT 0x3c47 /* PGA=8, full range */
	63	#define INA209_SHUNT_DEFAULT 10000 /* uOhm */
	64
65	struct ina209_data {
89de7344	66	struct i2c_client *client;
ceeadc5c GR	67
	68	struct mutex update_lock;
	69	bool valid;
	70	unsigned long last_updated; /* in jiffies */
	71
	72	u16 regs[INA209_REGISTERS]; /* All chip registers */
	73
	74	u16 config_orig; /* Original configuration */
	75	u16 calibration_orig; /* Original calibration */
	76	u16 update_interval;
	77	};
	78
	79	static struct ina209_data ina209_update_device(struct device dev)
	80	{
89de7344 GR	81	struct ina209_data *data = dev_get_drvdata(dev);
89de7344 GR	82	struct i2c_client *client = data->client;
ceeadc5c GR	83	struct ina209_data *ret = data;
	84	s32 val;
	85	int i;
	86
	87	mutex_lock(&data->update_lock);
	88
	89	if (!data->valid \|\|
	90	time_after(jiffies, data->last_updated + data->update_interval)) {
	91	for (i = 0; i < ARRAY_SIZE(data->regs); i++) {
	92	val = i2c_smbus_read_word_swapped(client, i);
	93	if (val < 0) {
	94	ret = ERR_PTR(val);
	95	goto abort;
	96	}
	97	data->regs[i] = val;
	98	}
	99	data->last_updated = jiffies;
	100	data->valid = true;
	101	}
	102	abort:
	103	mutex_unlock(&data->update_lock);
	104	return ret;
	105	}
	106
	107	/*
	108	* Read a value from a device register and convert it to the
	109	* appropriate sysfs units
	110	*/
	111	static long ina209_from_reg(const u8 reg, const u16 val)
	112	{
	113	switch (reg) {
	114	case INA209_SHUNT_VOLTAGE:
	115	case INA209_SHUNT_VOLTAGE_POS_PEAK:
	116	case INA209_SHUNT_VOLTAGE_NEG_PEAK:
	117	case INA209_SHUNT_VOLTAGE_POS_WARN:
	118	case INA209_SHUNT_VOLTAGE_NEG_WARN:
	119	/* LSB=10 uV. Convert to mV. */
bdaf9c40	120	return DIV_ROUND_CLOSEST((s16)val, 100);
ceeadc5c GR	121
	122	case INA209_BUS_VOLTAGE:
	123	case INA209_BUS_VOLTAGE_MAX_PEAK:
	124	case INA209_BUS_VOLTAGE_MIN_PEAK:
	125	case INA209_BUS_VOLTAGE_OVER_WARN:
	126	case INA209_BUS_VOLTAGE_UNDER_WARN:
	127	case INA209_BUS_VOLTAGE_OVER_LIMIT:
	128	case INA209_BUS_VOLTAGE_UNDER_LIMIT:
	129	/* LSB=4 mV, last 3 bits unused */
	130	return (val >> 3) * 4;
	131
	132	case INA209_CRITICAL_DAC_POS:
	133	/* LSB=1 mV, in the upper 8 bits */
	134	return val >> 8;
	135
	136	case INA209_CRITICAL_DAC_NEG:
	137	/* LSB=1 mV, in the upper 8 bits */
	138	return -1 * (val >> 8);
	139
	140	case INA209_POWER:
	141	case INA209_POWER_PEAK:
	142	case INA209_POWER_WARN:
	143	case INA209_POWER_OVER_LIMIT:
	144	/* LSB=20 mW. Convert to uW */
	145	return val * 20 * 1000L;
	146
	147	case INA209_CURRENT:
	148	/* LSB=1 mA (selected). Is in mA */
bdaf9c40	149	return (s16)val;
ceeadc5c GR	150	}
	151
	152	/* programmer goofed */
	153	WARN_ON_ONCE(1);
	154	return 0;
	155	}
	156
	157	/*
	158	* Take a value and convert it to register format, clamping the value
	159	* to the appropriate range.
	160	*/
	161	static int ina209_to_reg(u8 reg, u16 old, long val)
	162	{
	163	switch (reg) {
	164	case INA209_SHUNT_VOLTAGE_POS_WARN:
	165	case INA209_SHUNT_VOLTAGE_NEG_WARN:
	166	/* Limit to +- 320 mV, 10 uV LSB */
	167	return clamp_val(val, -320, 320) * 100;
	168
	169	case INA209_BUS_VOLTAGE_OVER_WARN:
	170	case INA209_BUS_VOLTAGE_UNDER_WARN:
	171	case INA209_BUS_VOLTAGE_OVER_LIMIT:
	172	case INA209_BUS_VOLTAGE_UNDER_LIMIT:
	173	/*
	174	* Limit to 0-32000 mV, 4 mV LSB
	175	*
	176	* The last three bits aren't part of the value, but we'll
	177	* preserve them in their original state.
	178	*/
	179	return (DIV_ROUND_CLOSEST(clamp_val(val, 0, 32000), 4) << 3)
	180	\| (old & 0x7);
	181
	182	case INA209_CRITICAL_DAC_NEG:
	183	/*
	184	* Limit to -255-0 mV, 1 mV LSB
	185	* Convert the value to a positive value for the register
	186	*
	187	* The value lives in the top 8 bits only, be careful
	188	* and keep original value of other bits.
	189	*/
	190	return (clamp_val(-val, 0, 255) << 8) \| (old & 0xff);
	191
	192	case INA209_CRITICAL_DAC_POS:
	193	/*
	194	* Limit to 0-255 mV, 1 mV LSB
	195	*
	196	* The value lives in the top 8 bits only, be careful
	197	* and keep original value of other bits.
	198	*/
	199	return (clamp_val(val, 0, 255) << 8) \| (old & 0xff);
	200
	201	case INA209_POWER_WARN:
	202	case INA209_POWER_OVER_LIMIT:
	203	/* 20 mW LSB */
	204	return DIV_ROUND_CLOSEST(val, 20 * 1000);
	205	}
	206
	207	/* Other registers are read-only, return access error */
	208	return -EACCES;
	209	}
	210
	211	static int ina209_interval_from_reg(u16 reg)
	212	{
	213	return 68 >> (15 - ((reg >> 3) & 0x0f));
214	}
215
216	static u16 ina209_reg_from_interval(u16 config, long interval)
217	{
218	int i, adc;
219
220	if (interval <= 0) {
221	adc = 8;
222	} else {
223	adc = 15;
224	for (i = 34 + 34 / 2; i; i >>= 1) {
225	if (i < interval)
226	break;
227	adc--;
228	}
229	}
230	return (config & 0xf807) \| (adc << 3) \| (adc << 7);
231	}
232
233	static ssize_t ina209_set_interval(struct device *dev,
234	struct device_attribute *da,
235	const char *buf, size_t count)
236	{
ceeadc5c GR	237	struct ina209_data *data = ina209_update_device(dev);
	238	long val;
	239	u16 regval;
	240	int ret;
	241
	242	if (IS_ERR(data))
	243	return PTR_ERR(data);
	244
	245	ret = kstrtol(buf, 10, &val);
	246	if (ret < 0)
	247	return ret;
	248
	249	mutex_lock(&data->update_lock);
	250	regval = ina209_reg_from_interval(data->regs[INA209_CONFIGURATION],
	251	val);
89de7344 GR	252	i2c_smbus_write_word_swapped(data->client, INA209_CONFIGURATION,
89de7344 GR	253	regval);
ceeadc5c GR	254	data->regs[INA209_CONFIGURATION] = regval;
	255	data->update_interval = ina209_interval_from_reg(regval);
	256	mutex_unlock(&data->update_lock);
	257	return count;
	258	}
	259
	260	static ssize_t ina209_show_interval(struct device *dev,
	261	struct device_attribute da, char buf)
	262	{
89de7344	263	struct ina209_data *data = dev_get_drvdata(dev);
ceeadc5c GR	264
	265	return snprintf(buf, PAGE_SIZE, "%d\n", data->update_interval);
	266	}
	267
	268	/*
	269	* History is reset by writing 1 into bit 0 of the respective peak register.
	270	* Since more than one peak register may be affected by the scope of a
	271	* reset_history attribute write, use a bit mask in attr->index to identify
	272	* which registers are affected.
	273	*/
	274	static u16 ina209_reset_history_regs[] = {
	275	INA209_SHUNT_VOLTAGE_POS_PEAK,
	276	INA209_SHUNT_VOLTAGE_NEG_PEAK,
	277	INA209_BUS_VOLTAGE_MAX_PEAK,
	278	INA209_BUS_VOLTAGE_MIN_PEAK,
	279	INA209_POWER_PEAK
	280	};
	281
	282	static ssize_t ina209_reset_history(struct device *dev,
	283	struct device_attribute *da,
	284	const char *buf,
	285	size_t count)
	286	{
ceeadc5c	287	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
89de7344 GR	288	struct ina209_data *data = dev_get_drvdata(dev);
89de7344 GR	289	struct i2c_client *client = data->client;
ceeadc5c GR	290	u32 mask = attr->index;
	291	long val;
	292	int i, ret;
	293
	294	ret = kstrtol(buf, 10, &val);
	295	if (ret < 0)
	296	return ret;
	297
	298	mutex_lock(&data->update_lock);
	299	for (i = 0; i < ARRAY_SIZE(ina209_reset_history_regs); i++) {
	300	if (mask & (1 << i))
	301	i2c_smbus_write_word_swapped(client,
	302	ina209_reset_history_regs[i], 1);
	303	}
	304	data->valid = false;
	305	mutex_unlock(&data->update_lock);
	306	return count;
	307	}
	308
	309	static ssize_t ina209_set_value(struct device *dev,
	310	struct device_attribute *da,
	311	const char *buf,
	312	size_t count)
	313	{
ceeadc5c GR	314	struct ina209_data *data = ina209_update_device(dev);
	315	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	316	int reg = attr->index;
	317	long val;
	318	int ret;
	319
	320	if (IS_ERR(data))
	321	return PTR_ERR(data);
	322
	323	ret = kstrtol(buf, 10, &val);
	324	if (ret < 0)
	325	return ret;
	326
	327	mutex_lock(&data->update_lock);
	328	ret = ina209_to_reg(reg, data->regs[reg], val);
	329	if (ret < 0) {
	330	count = ret;
	331	goto abort;
	332	}
89de7344	333	i2c_smbus_write_word_swapped(data->client, reg, ret);
ceeadc5c GR	334	data->regs[reg] = ret;
	335	abort:
	336	mutex_unlock(&data->update_lock);
	337	return count;
	338	}
	339
	340	static ssize_t ina209_show_value(struct device *dev,
	341	struct device_attribute *da,
	342	char *buf)
	343	{
	344	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	345	struct ina209_data *data = ina209_update_device(dev);
	346	long val;
	347
	348	if (IS_ERR(data))
	349	return PTR_ERR(data);
	350
	351	val = ina209_from_reg(attr->index, data->regs[attr->index]);
	352	return snprintf(buf, PAGE_SIZE, "%ld\n", val);
	353	}
	354
	355	static ssize_t ina209_show_alarm(struct device *dev,
	356	struct device_attribute *da,
	357	char *buf)
	358	{
	359	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	360	struct ina209_data *data = ina209_update_device(dev);
	361	const unsigned int mask = attr->index;
	362	u16 status;
	363
	364	if (IS_ERR(data))
	365	return PTR_ERR(data);
	366
	367	status = data->regs[INA209_STATUS];
	368
	369	/*
	370	* All alarms are in the INA209_STATUS register. To avoid a long
	371	* switch statement, the mask is passed in attr->index
	372	*/
	373	return snprintf(buf, PAGE_SIZE, "%u\n", !!(status & mask));
	374	}
	375
	376	/* Shunt voltage, history, limits, alarms */
	377	static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ina209_show_value, NULL,
	378	INA209_SHUNT_VOLTAGE);
	379	static SENSOR_DEVICE_ATTR(in0_input_highest, S_IRUGO, ina209_show_value, NULL,
	380	INA209_SHUNT_VOLTAGE_POS_PEAK);
	381	static SENSOR_DEVICE_ATTR(in0_input_lowest, S_IRUGO, ina209_show_value, NULL,
	382	INA209_SHUNT_VOLTAGE_NEG_PEAK);
	383	static SENSOR_DEVICE_ATTR(in0_reset_history, S_IWUSR, NULL,
	384	ina209_reset_history, (1 << 0) \| (1 << 1));
	385	static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO \| S_IWUSR, ina209_show_value,
	386	ina209_set_value, INA209_SHUNT_VOLTAGE_POS_WARN);
	387	static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO \| S_IWUSR, ina209_show_value,
	388	ina209_set_value, INA209_SHUNT_VOLTAGE_NEG_WARN);
	389	static SENSOR_DEVICE_ATTR(in0_crit_max, S_IRUGO \| S_IWUSR, ina209_show_value,
	390	ina209_set_value, INA209_CRITICAL_DAC_POS);
	391	static SENSOR_DEVICE_ATTR(in0_crit_min, S_IRUGO \| S_IWUSR, ina209_show_value,
	392	ina209_set_value, INA209_CRITICAL_DAC_NEG);
	393
	394	static SENSOR_DEVICE_ATTR(in0_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
	395	1 << 11);
	396	static SENSOR_DEVICE_ATTR(in0_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
	397	1 << 12);
398	static SENSOR_DEVICE_ATTR(in0_crit_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
399	1 << 6);
400	static SENSOR_DEVICE_ATTR(in0_crit_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
401	1 << 7);
402
403	/* Bus voltage, history, limits, alarms */
404	static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ina209_show_value, NULL,
405	INA209_BUS_VOLTAGE);
406	static SENSOR_DEVICE_ATTR(in1_input_highest, S_IRUGO, ina209_show_value, NULL,
407	INA209_BUS_VOLTAGE_MAX_PEAK);
408	static SENSOR_DEVICE_ATTR(in1_input_lowest, S_IRUGO, ina209_show_value, NULL,
409	INA209_BUS_VOLTAGE_MIN_PEAK);
410	static SENSOR_DEVICE_ATTR(in1_reset_history, S_IWUSR, NULL,
411	ina209_reset_history, (1 << 2) \| (1 << 3));
412	static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO \| S_IWUSR, ina209_show_value,
413	ina209_set_value, INA209_BUS_VOLTAGE_OVER_WARN);
414	static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO \| S_IWUSR, ina209_show_value,
415	ina209_set_value, INA209_BUS_VOLTAGE_UNDER_WARN);
416	static SENSOR_DEVICE_ATTR(in1_crit_max, S_IRUGO \| S_IWUSR, ina209_show_value,
417	ina209_set_value, INA209_BUS_VOLTAGE_OVER_LIMIT);
418	static SENSOR_DEVICE_ATTR(in1_crit_min, S_IRUGO \| S_IWUSR, ina209_show_value,
419	ina209_set_value, INA209_BUS_VOLTAGE_UNDER_LIMIT);
420
421	static SENSOR_DEVICE_ATTR(in1_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
422	1 << 14);
423	static SENSOR_DEVICE_ATTR(in1_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
424	1 << 15);
425	static SENSOR_DEVICE_ATTR(in1_crit_min_alarm, S_IRUGO, ina209_show_alarm, NULL,
426	1 << 9);
427	static SENSOR_DEVICE_ATTR(in1_crit_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
428	1 << 10);
429
430	/* Power */
431	static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ina209_show_value, NULL,
432	INA209_POWER);
433	static SENSOR_DEVICE_ATTR(power1_input_highest, S_IRUGO, ina209_show_value,
434	NULL, INA209_POWER_PEAK);
435	static SENSOR_DEVICE_ATTR(power1_reset_history, S_IWUSR, NULL,
436	ina209_reset_history, 1 << 4);
437	static SENSOR_DEVICE_ATTR(power1_max, S_IRUGO \| S_IWUSR, ina209_show_value,
438	ina209_set_value, INA209_POWER_WARN);
439	static SENSOR_DEVICE_ATTR(power1_crit, S_IRUGO \| S_IWUSR, ina209_show_value,
440	ina209_set_value, INA209_POWER_OVER_LIMIT);
441
442	static SENSOR_DEVICE_ATTR(power1_max_alarm, S_IRUGO, ina209_show_alarm, NULL,
443	1 << 13);
444	static SENSOR_DEVICE_ATTR(power1_crit_alarm, S_IRUGO, ina209_show_alarm, NULL,
445	1 << 8);
446
447	/* Current */
448	static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ina209_show_value, NULL,
449	INA209_CURRENT);
450
451	static SENSOR_DEVICE_ATTR(update_interval, S_IRUGO \| S_IWUSR,
452	ina209_show_interval, ina209_set_interval, 0);
453
454	/*
455	* Finally, construct an array of pointers to members of the above objects,
456	* as required for sysfs_create_group()
457	*/
89de7344	458	static struct attribute *ina209_attrs[] = {
ceeadc5c GR	459	&sensor_dev_attr_in0_input.dev_attr.attr,
	460	&sensor_dev_attr_in0_input_highest.dev_attr.attr,
	461	&sensor_dev_attr_in0_input_lowest.dev_attr.attr,
	462	&sensor_dev_attr_in0_reset_history.dev_attr.attr,
	463	&sensor_dev_attr_in0_max.dev_attr.attr,
	464	&sensor_dev_attr_in0_min.dev_attr.attr,
	465	&sensor_dev_attr_in0_crit_max.dev_attr.attr,
	466	&sensor_dev_attr_in0_crit_min.dev_attr.attr,
	467	&sensor_dev_attr_in0_max_alarm.dev_attr.attr,
	468	&sensor_dev_attr_in0_min_alarm.dev_attr.attr,
	469	&sensor_dev_attr_in0_crit_max_alarm.dev_attr.attr,
	470	&sensor_dev_attr_in0_crit_min_alarm.dev_attr.attr,
	471
	472	&sensor_dev_attr_in1_input.dev_attr.attr,
	473	&sensor_dev_attr_in1_input_highest.dev_attr.attr,
	474	&sensor_dev_attr_in1_input_lowest.dev_attr.attr,
	475	&sensor_dev_attr_in1_reset_history.dev_attr.attr,
	476	&sensor_dev_attr_in1_max.dev_attr.attr,
	477	&sensor_dev_attr_in1_min.dev_attr.attr,
	478	&sensor_dev_attr_in1_crit_max.dev_attr.attr,
	479	&sensor_dev_attr_in1_crit_min.dev_attr.attr,
	480	&sensor_dev_attr_in1_max_alarm.dev_attr.attr,
	481	&sensor_dev_attr_in1_min_alarm.dev_attr.attr,
	482	&sensor_dev_attr_in1_crit_max_alarm.dev_attr.attr,
	483	&sensor_dev_attr_in1_crit_min_alarm.dev_attr.attr,
	484
	485	&sensor_dev_attr_power1_input.dev_attr.attr,
	486	&sensor_dev_attr_power1_input_highest.dev_attr.attr,
	487	&sensor_dev_attr_power1_reset_history.dev_attr.attr,
	488	&sensor_dev_attr_power1_max.dev_attr.attr,
	489	&sensor_dev_attr_power1_crit.dev_attr.attr,
	490	&sensor_dev_attr_power1_max_alarm.dev_attr.attr,
	491	&sensor_dev_attr_power1_crit_alarm.dev_attr.attr,
	492
	493	&sensor_dev_attr_curr1_input.dev_attr.attr,
	494
	495	&sensor_dev_attr_update_interval.dev_attr.attr,
	496
	497	NULL,
	498	};
89de7344	499	ATTRIBUTE_GROUPS(ina209);
ceeadc5c GR	500
	501	static void ina209_restore_conf(struct i2c_client *client,
	502	struct ina209_data *data)
	503	{
	504	/* Restore initial configuration */
	505	i2c_smbus_write_word_swapped(client, INA209_CONFIGURATION,
	506	data->config_orig);
	507	i2c_smbus_write_word_swapped(client, INA209_CALIBRATION,
	508	data->calibration_orig);
	509	}
	510
	511	static int ina209_init_client(struct i2c_client *client,
	512	struct ina209_data *data)
	513	{
	514	struct ina2xx_platform_data *pdata = dev_get_platdata(&client->dev);
	515	u32 shunt;
	516	int reg;
	517
	518	reg = i2c_smbus_read_word_swapped(client, INA209_CALIBRATION);
	519	if (reg < 0)
	520	return reg;
	521	data->calibration_orig = reg;
	522
	523	reg = i2c_smbus_read_word_swapped(client, INA209_CONFIGURATION);
	524	if (reg < 0)
	525	return reg;
	526	data->config_orig = reg;
	527
	528	if (pdata) {
	529	if (pdata->shunt_uohms <= 0)
	530	return -EINVAL;
	531	shunt = pdata->shunt_uohms;
	532	} else if (!of_property_read_u32(client->dev.of_node, "shunt-resistor",
	533	&shunt)) {
	534	if (shunt == 0)
	535	return -EINVAL;
	536	} else {
	537	shunt = data->calibration_orig ?
	538	40960000 / data->calibration_orig : INA209_SHUNT_DEFAULT;
	539	}
	540
	541	i2c_smbus_write_word_swapped(client, INA209_CONFIGURATION,
	542	INA209_CONFIG_DEFAULT);
	543	data->update_interval = ina209_interval_from_reg(INA209_CONFIG_DEFAULT);
	544
	545	/*
	546	* Calibrate current LSB to 1mA. Shunt is in uOhms.
	547	* See equation 13 in datasheet.
	548	*/
	549	i2c_smbus_write_word_swapped(client, INA209_CALIBRATION,
	550	clamp_val(40960000 / shunt, 1, 65535));
	551
	552	/* Clear status register */
	553	i2c_smbus_read_word_swapped(client, INA209_STATUS);
	554
	555	return 0;
	556	}
	557
	558	static int ina209_probe(struct i2c_client *client,
	559	const struct i2c_device_id *id)
	560	{
	561	struct i2c_adapter *adapter = client->adapter;
	562	struct ina209_data *data;
89de7344	563	struct device *hwmon_dev;
ceeadc5c GR	564	int ret;
	565
	566	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
	567	return -ENODEV;
	568
	569	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	570	if (!data)
	571	return -ENOMEM;
	572
	573	i2c_set_clientdata(client, data);
89de7344	574	data->client = client;
ceeadc5c GR	575	mutex_init(&data->update_lock);
	576
	577	ret = ina209_init_client(client, data);
	578	if (ret)
	579	return ret;
	580
89de7344 GR	581	hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
	582	client->name,
	583	data, ina209_groups);
	584	if (IS_ERR(hwmon_dev)) {
	585	ret = PTR_ERR(hwmon_dev);
ceeadc5c	586	goto out_restore_conf;
ceeadc5c GR	587	}
	588
	589	return 0;
	590
ceeadc5c GR	591	out_restore_conf:
	592	ina209_restore_conf(client, data);
	593	return ret;
	594	}
	595
	596	static int ina209_remove(struct i2c_client *client)
	597	{
	598	struct ina209_data *data = i2c_get_clientdata(client);
	599
ceeadc5c GR	600	ina209_restore_conf(client, data);
	601
	602	return 0;
	603	}
	604
	605	static const struct i2c_device_id ina209_id[] = {
	606	{ "ina209", 0 },
	607	{ }
	608	};
	609	MODULE_DEVICE_TABLE(i2c, ina209_id);
	610
0b7abe59 JMC	611	static const struct of_device_id ina209_of_match[] = {
	612	{ .compatible = "ti,ina209" },
	613	{ },
	614	};
	615	MODULE_DEVICE_TABLE(of, ina209_of_match);
	616
ceeadc5c GR	617	/* This is the driver that will be inserted */
	618	static struct i2c_driver ina209_driver = {
	619	.class = I2C_CLASS_HWMON,
	620	.driver = {
	621	.name = "ina209",
0b7abe59	622	.of_match_table = of_match_ptr(ina209_of_match),
ceeadc5c GR	623	},
	624	.probe = ina209_probe,
	625	.remove = ina209_remove,
	626	.id_table = ina209_id,
	627	};
	628
	629	module_i2c_driver(ina209_driver);
	630
	631	MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>, Paul Hays <Paul.Hays@cattail.ca>, Guenter Roeck <linux@roeck-us.net>");
	632	MODULE_DESCRIPTION("INA209 driver");
	633	MODULE_LICENSE("GPL");