hwmon: Driver for Texas Instruments INA209

Add support for the TI / Burr-Brown INA209 voltage / current / power
monitor.

Cc: Paul Hays <haysp@magma.net>
Cc: Ira W. Snyder <iws@ovro.caltech.edu>
Tested-by: Ira W. Snyder <iws@ovro.caltech.edu>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
This commit is contained in:
Guenter Roeck 2009-08-20 14:49:25 -07:00
parent 2bf9233a10
commit ceeadc5c51
5 changed files with 758 additions and 0 deletions

View file

@ -0,0 +1,18 @@
ina209 properties
Required properties:
- compatible: Must be "ti,ina209"
- reg: I2C address
Optional properties:
- shunt-resistor
Shunt resistor value in micro-Ohm
Example:
temp-sensor@4c {
compatible = "ti,ina209";
reg = <0x4c>;
shunt-resistor = <5000>;
};

View file

@ -0,0 +1,93 @@
Kernel driver ina209
=====================
Supported chips:
* Burr-Brown / Texas Instruments INA209
Prefix: 'ina209'
Addresses scanned: -
Datasheet:
http://www.ti.com/lit/gpn/ina209
Author: Paul Hays <Paul.Hays@cattail.ca>
Author: Ira W. Snyder <iws@ovro.caltech.edu>
Author: Guenter Roeck <linux@roeck-us.net>
Description
-----------
The TI / Burr-Brown INA209 monitors voltage, current, and power on the high side
of a D.C. power supply. It can perform measurements and calculations in the
background to supply readings at any time. It includes a programmable
calibration multiplier to scale the displayed current and power values.
Sysfs entries
-------------
The INA209 chip is highly configurable both via hardwiring and via
the I2C bus. See the datasheet for details.
This tries to expose most monitoring features of the hardware via
sysfs. It does not support every feature of this chip.
in0_input shunt voltage (mV)
in0_input_highest shunt voltage historical maximum reading (mV)
in0_input_lowest shunt voltage historical minimum reading (mV)
in0_reset_history reset shunt voltage history
in0_max shunt voltage max alarm limit (mV)
in0_min shunt voltage min alarm limit (mV)
in0_crit_max shunt voltage crit max alarm limit (mV)
in0_crit_min shunt voltage crit min alarm limit (mV)
in0_max_alarm shunt voltage max alarm limit exceeded
in0_min_alarm shunt voltage min alarm limit exceeded
in0_crit_max_alarm shunt voltage crit max alarm limit exceeded
in0_crit_min_alarm shunt voltage crit min alarm limit exceeded
in1_input bus voltage (mV)
in1_input_highest bus voltage historical maximum reading (mV)
in1_input_lowest bus voltage historical minimum reading (mV)
in1_reset_history reset bus voltage history
in1_max bus voltage max alarm limit (mV)
in1_min bus voltage min alarm limit (mV)
in1_crit_max bus voltage crit max alarm limit (mV)
in1_crit_min bus voltage crit min alarm limit (mV)
in1_max_alarm bus voltage max alarm limit exceeded
in1_min_alarm bus voltage min alarm limit exceeded
in1_crit_max_alarm bus voltage crit max alarm limit exceeded
in1_crit_min_alarm bus voltage crit min alarm limit exceeded
power1_input power measurement (uW)
power1_input_highest power historical maximum reading (uW)
power1_reset_history reset power history
power1_max power max alarm limit (uW)
power1_crit power crit alarm limit (uW)
power1_max_alarm power max alarm limit exceeded
power1_crit_alarm power crit alarm limit exceeded
curr1_input current measurement (mA)
update_interval data conversion time; affects number of samples used
to average results for shunt and bus voltages.
General Remarks
---------------
The power and current registers in this chip require that the calibration
register is programmed correctly before they are used. Normally this is expected
to be done in the BIOS. In the absence of BIOS programming, the shunt resistor
voltage can be provided using platform data. The driver uses platform data from
the ina2xx driver for this purpose. If calibration register data is not provided
via platform data, the driver checks if the calibration register has been
programmed (ie has a value not equal to zero). If so, this value is retained.
Otherwise, a default value reflecting a shunt resistor value of 10 mOhm is
programmed into the calibration register.
Output Pins
-----------
Output pin programming is a board feature which depends on the BIOS. It is
outside the scope of a hardware monitoring driver to enable or disable output
pins.

View file

@ -1157,6 +1157,16 @@ config SENSORS_AMC6821
This driver can also be build as a module. If so, the module
will be called amc6821.
config SENSORS_INA209
tristate "TI / Burr Brown INA209"
depends on I2C
help
If you say yes here you get support for the TI / Burr Brown INA209
voltage / current / power monitor I2C interface.
This driver can also be built as a module. If so, the module will
be called ina209.
config SENSORS_INA2XX
tristate "Texas Instruments INA219 and compatibles"
depends on I2C

View file

@ -65,6 +65,7 @@ obj-$(CONFIG_SENSORS_ULTRA45) += ultra45_env.o
obj-$(CONFIG_SENSORS_I5K_AMB) += i5k_amb.o
obj-$(CONFIG_SENSORS_IBMAEM) += ibmaem.o
obj-$(CONFIG_SENSORS_IBMPEX) += ibmpex.o
obj-$(CONFIG_SENSORS_INA209) += ina209.o
obj-$(CONFIG_SENSORS_INA2XX) += ina2xx.o
obj-$(CONFIG_SENSORS_IT87) += it87.o
obj-$(CONFIG_SENSORS_JC42) += jc42.o

636
drivers/hwmon/ina209.c Normal file
View file

@ -0,0 +1,636 @@
/*
* 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 device *hwmon_dev;
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 i2c_client *client = to_i2c_client(dev);
struct ina209_data *data = i2c_get_clientdata(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(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 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 i2c_client *client = to_i2c_client(dev);
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(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 i2c_client *client = to_i2c_client(dev);
struct ina209_data *data = i2c_get_clientdata(client);
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 i2c_client *client = to_i2c_client(dev);
struct ina209_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
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 i2c_client *client = to_i2c_client(dev);
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(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_attributes[] = {
&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,
};
static const struct attribute_group ina209_group = {
.attrs = ina209_attributes,
};
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;
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);
mutex_init(&data->update_lock);
ret = ina209_init_client(client, data);
if (ret)
return ret;
/* Register sysfs hooks */
ret = sysfs_create_group(&client->dev.kobj, &ina209_group);
if (ret)
goto out_restore_conf;
data->hwmon_dev = hwmon_device_register(&client->dev);
if (IS_ERR(data->hwmon_dev)) {
ret = PTR_ERR(data->hwmon_dev);
goto out_hwmon_device_register;
}
return 0;
out_hwmon_device_register:
sysfs_remove_group(&client->dev.kobj, &ina209_group);
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);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &ina209_group);
ina209_restore_conf(client, data);
return 0;
}
static const struct i2c_device_id ina209_id[] = {
{ "ina209", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, ina209_id);
/* This is the driver that will be inserted */
static struct i2c_driver ina209_driver = {
.class = I2C_CLASS_HWMON,
.driver = {
.name = "ina209",
},
.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");