From: Guenter Roeck <linux@roeck-us.net>
To: Mike Looijmans <mike.looijmans@topic.nl>, lm-sensors@lm-sensors.org
Cc: jdelvare@suse.com, linux-kernel@vger.kernel.org
Subject: Re: [lm-sensors] [PATCH v2] hwmon: Add LTC2990 sensor driver
Date: Wed, 13 Jan 2016 13:24:30 +0000 [thread overview]
Message-ID: <5696500E.4090905@roeck-us.net> (raw)
In-Reply-To: <1452683150-27747-1-git-send-email-mike.looijmans@topic.nl>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: multiple messages have this Message-ID (diff)
From: Guenter Roeck <linux@roeck-us.net>
To: Mike Looijmans <mike.looijmans@topic.nl>, lm-sensors@lm-sensors.org
Cc: jdelvare@suse.com, linux-kernel@vger.kernel.org
Subject: Re: [PATCH v2] hwmon: Add LTC2990 sensor driver
Date: Wed, 13 Jan 2016 05:24:30 -0800 [thread overview]
Message-ID: <5696500E.4090905@roeck-us.net> (raw)
In-Reply-To: <1452683150-27747-1-git-send-email-mike.looijmans@topic.nl>
On 01/13/2016 03:05 AM, Mike Looijmans wrote:
> This adds support for the Linear Technology LTC2990 I2C System Monitor.
> The LTC2990 supports a combination of voltage, current and temperature
> monitoring. This driver currently only supports reading two currents
> by measuring two differential voltages across series resistors, in
> addition to the Vcc supply voltage and internal temperature.
>
> This is sufficient to support the Topic Miami SOM which uses this chip
> to monitor the currents flowing into the FPGA and the CPU parts.
>
> Signed-off-by: Mike Looijmans <mike.looijmans@topic.nl>
Mike,
That looks much better. Can you send me the output of i2cdump for the chip ?
That would help me writing module test code for it.
Thanks,
Guenter
> ---
> v2: Processed all review comments.
> Put chip into continuous measurement mode.
> Added ducumentation.
> Use standard hwmon interfaces and macros.
>
> Documentation/hwmon/ltc2990 | 44 ++++++++++++
> drivers/hwmon/Kconfig | 14 ++++
> drivers/hwmon/Makefile | 1 +
> drivers/hwmon/ltc2990.c | 160 ++++++++++++++++++++++++++++++++++++++++++++
> 4 files changed, 219 insertions(+)
> create mode 100644 Documentation/hwmon/ltc2990
> create mode 100644 drivers/hwmon/ltc2990.c
>
> diff --git a/Documentation/hwmon/ltc2990 b/Documentation/hwmon/ltc2990
> new file mode 100644
> index 0000000..838b74e
> --- /dev/null
> +++ b/Documentation/hwmon/ltc2990
> @@ -0,0 +1,44 @@
> +Kernel driver ltc2990
> +=====================
> +
> +Supported chips:
> + * Linear Technology LTC2990
> + Prefix: 'ltc2990'
> + Addresses scanned: -
> + Datasheet: http://www.linear.com/product/ltc2990
> +
> +Author: Mike Looijmans <mike.looijmans@topic.nl>
> +
> +
> +Description
> +-----------
> +
> +LTC2990 is a Quad I2C Voltage, Current and Temperature Monitor.
> +The chip's inputs can measure 4 voltages, or two inputs together (1+2 and 3+4)
> +can be combined to measure a differential voltage, which is typically used to
> +measure current through a series resistor, or a temperature.
> +
> +This driver currently uses the 2x differential mode only. In order to support
> +other modes, the driver will need to be expanded.
> +
> +
> +Usage Notes
> +-----------
> +
> +This driver does not probe for PMBus devices. You will have to instantiate
> +devices explicitly.
> +
> +
> +Sysfs attributes
> +----------------
> +
> +The "curr*_input" measurements actually report the voltage drop across the
> +input pins in microvolts. This is equivalent to the current through a 1mOhm
> +sense resistor. Divide the reported value by the actual sense resistor value
> +in mOhm to get the actual value.
> +
> +in0_input Voltage at Vcc pin in millivolt (range 2.5V to 5V)
> +temp1_input Internal chip temperature in millidegrees Celcius
> +curr1_input Current in mA across v1-v2 assuming a 1mOhm sense resistor.
> +curr2_input Current in mA across v3-v4 assuming a 1mOhm sense resistor.
> +
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 80a73bf..8a31d64 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -685,6 +685,20 @@ config SENSORS_LTC2945
> This driver can also be built as a module. If so, the module will
> be called ltc2945.
>
> +config SENSORS_LTC2990
> + tristate "Linear Technology LTC2990 (current monitoring mode only)"
> + depends on I2C
> + help
> + If you say yes here you get support for Linear Technology LTC2990
> + I2C System Monitor. The LTC2990 supports a combination of voltage,
> + current and temperature monitoring, but in addition to the Vcc supply
> + voltage and chip temperature, this driver currently only supports
> + reading two currents by measuring two differential voltages across
> + series resistors.
> +
> + This driver can also be built as a module. If so, the module will
> + be called ltc2990.
> +
> config SENSORS_LTC4151
> tristate "Linear Technology LTC4151"
> depends on I2C
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 12a3239..e4bd15b 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -101,6 +101,7 @@ obj-$(CONFIG_SENSORS_LM95234) += lm95234.o
> obj-$(CONFIG_SENSORS_LM95241) += lm95241.o
> obj-$(CONFIG_SENSORS_LM95245) += lm95245.o
> obj-$(CONFIG_SENSORS_LTC2945) += ltc2945.o
> +obj-$(CONFIG_SENSORS_LTC2990) += ltc2990.o
> obj-$(CONFIG_SENSORS_LTC4151) += ltc4151.o
> obj-$(CONFIG_SENSORS_LTC4215) += ltc4215.o
> obj-$(CONFIG_SENSORS_LTC4222) += ltc4222.o
> diff --git a/drivers/hwmon/ltc2990.c b/drivers/hwmon/ltc2990.c
> new file mode 100644
> index 0000000..3720ff7
> --- /dev/null
> +++ b/drivers/hwmon/ltc2990.c
> @@ -0,0 +1,160 @@
> +/*
> + * Driver for Linear Technology LTC2990 power monitor
> + *
> + * Copyright (C) 2014 Topic Embedded Products
> + * Author: Mike Looijmans <mike.looijmans@topic.nl>
> + *
> + * License: GPLv2
> + *
> + * This driver assumes the chip is wired as a dual current monitor, and
> + * reports the voltage drop across two series resistors. It also reports
> + * the chip's internal temperature and Vcc power supply voltage.
> + */
> +
> +#include <linux/delay.h>
> +#include <linux/err.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/i2c.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +
> +#define LTC2990_STATUS 0x00
> +#define LTC2990_CONTROL 0x01
> +#define LTC2990_TRIGGER 0x02
> +#define LTC2990_TINT_MSB 0x04
> +#define LTC2990_TINT_LSB 0x05
> +#define LTC2990_V1_MSB 0x06
> +#define LTC2990_V1_LSB 0x07
> +#define LTC2990_V2_MSB 0x08
> +#define LTC2990_V2_LSB 0x09
> +#define LTC2990_V3_MSB 0x0A
> +#define LTC2990_V3_LSB 0x0B
> +#define LTC2990_V4_MSB 0x0C
> +#define LTC2990_V4_LSB 0x0D
> +#define LTC2990_VCC_MSB 0x0E
> +#define LTC2990_VCC_LSB 0x0F
> +
LSB not used.
> +#define LTC2990_STATUS_BUSY BIT(0)
> +#define LTC2990_STATUS_TINT BIT(1)
> +#define LTC2990_STATUS_V1 BIT(2)
> +#define LTC2990_STATUS_V2 BIT(3)
> +#define LTC2990_STATUS_V3 BIT(4)
> +#define LTC2990_STATUS_V4 BIT(5)
> +#define LTC2990_STATUS_VCC BIT(6)
> +
No longer used ?
> +/* Only define control settings we actually use */
Hmmm ... but not all are used.
> +#define LTC2990_CONTROL_KELVIN BIT(7)
> +#define LTC2990_CONTROL_SINGLE BIT(6)
> +#define LTC2990_CONTROL_MEASURE_ALL (0x3 << 3)
> +#define LTC2990_CONTROL_MODE_CURRENT 0x06
> +#define LTC2990_CONTROL_MODE_VOLTAGE 0x07
> +
> +/* convert raw register value to sign-extended integer in 16-bit range */
> +static int ltc2990_voltage_to_int(int raw)
> +{
> + if (raw & BIT(14)) {
> + return -(0x4000 - (raw & 0x3FFF)) << 2;
> + } else {
> + return (raw & 0x3FFF) << 2;
> + }
> +}
> +
> +/* Return the converted value from the given register in uV or mC */
> +static int ltc2990_get_value(struct i2c_client *i2c, u8 index)
> +{
> + int val;
> + int result;
> +
> + val = i2c_smbus_read_word_swapped(i2c, (index << 1) + LTC2990_TINT_MSB);
> + if (unlikely(val < 0))
> + return val;
> +
> + if (index == 0) { /* internal temp, 0.0625 degrees/LSB, 13-bit */
> + val = (val & 0x1FFF) << 3;
> + result = (val * 1000) >> 7;
> + } else if (index < 5) { /* Vx-Vy, 19.42uV/LSB */
> + result = ltc2990_voltage_to_int(val) * 1942 / (4 * 100);
> + } else { /* Vcc, 305.18μV/LSB, 2.5V offset */
> + result = ltc2990_voltage_to_int(val) * 30518 / (4 * 100 * 1000);
> + result += 2500;
> + }
> +
With the register in index (see below) this could be
val = i2c_smbus_read_word_swapped(i2c, index);
switch (index) {
case LTC2990_TINT_MSB:
val = (val & 0x1FFF) << 3;
result = (val * 1000) >> 7;
break;
case LTC2990_V1_MSB:
case LTC2990_V2_MSB:
...
result = ltc2990_voltage_to_int(val) * 1942 / (4 * 100);
break;
case LTC2990_VCC_MSB:
result = ltc2990_voltage_to_int(val) * 30518 / (4 * 100 * 1000);
result += 2500;
break;
default:
result = 0; /* won't happen, makes compiler happy */
break;
}
which I think would be easier to understand.
> + return result;
> +}
> +
> +static ssize_t ltc2990_show_value(struct device *dev,
> + struct device_attribute *da, char *buf)
> +{
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
> + int value;
> +
> + value = ltc2990_get_value(dev_get_drvdata(dev), attr->index);
> + return snprintf(buf, PAGE_SIZE, "%d\n", value);
> +}
> +
> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ltc2990_show_value, NULL, 0);
> +static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc2990_show_value, NULL, 1);
> +static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc2990_show_value, NULL, 3);
> +static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ltc2990_show_value, NULL, 5);
Consider providing the register MSB in index.
Example:
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ltc2990_show_value, NULL, LTC2990_TINT_MSB);
> +
> +static struct attribute *ltc2990_attrs[] = {
> + &sensor_dev_attr_temp1_input.dev_attr.attr,
> + &sensor_dev_attr_curr1_input.dev_attr.attr,
> + &sensor_dev_attr_curr2_input.dev_attr.attr,
> + &sensor_dev_attr_in0_input.dev_attr.attr,
> + NULL,
> +};
> +ATTRIBUTE_GROUPS(ltc2990);
> +
> +static int ltc2990_i2c_probe(struct i2c_client *i2c,
> + const struct i2c_device_id *id)
Please align continuation lines with '('.
> +{
> + int ret;
> + struct device *hwmon_dev;
> +
> + if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
Also need capability to read words.
> + return -ENODEV;
> +
> + /* Setup continuous mode, current monitor */
> + ret = i2c_smbus_write_byte_data(i2c, LTC2990_CONTROL,
> + LTC2990_CONTROL_MEASURE_ALL | LTC2990_CONTROL_MODE_CURRENT);
> + if (ret < 0) {
> + dev_err(&i2c->dev, "Error: Failed to set control mode.\n");
> + return ret;
> + }
> + /* Trigger once to start continuous conversion */
> + ret = i2c_smbus_write_byte_data(i2c, LTC2990_TRIGGER, 1);
> + if (ret < 0) {
> + dev_err(&i2c->dev, "Error: Failed to start aquisition.\n");
s/aquisition/acquisition/
> + return ret;
> + }
> +
> + hwmon_dev = devm_hwmon_device_register_with_groups(&i2c->dev,
> + i2c->name,
> + i2c,
> + ltc2990_groups);
> +
> + return PTR_ERR_OR_ZERO(hwmon_dev);
> +}
> +
> +static const struct i2c_device_id ltc2990_i2c_id[] = {
> + { "ltc2990", 0 },
> + {}
> +};
> +MODULE_DEVICE_TABLE(i2c, ltc2990_i2c_id);
> +
> +static struct i2c_driver ltc2990_i2c_driver = {
> + .driver = {
> + .name = "ltc2990",
> + },
> + .probe = ltc2990_i2c_probe,
> + .id_table = ltc2990_i2c_id,
> +};
> +
> +module_i2c_driver(ltc2990_i2c_driver);
> +
> +MODULE_DESCRIPTION("LTC2990 Sensor Driver");
> +MODULE_AUTHOR("Topic Embedded Products");
> +MODULE_LICENSE("GPL v2");
>
next prev parent reply other threads:[~2016-01-13 13:24 UTC|newest]
Thread overview: 29+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-01-06 8:07 [lm-sensors] [PATCH] hwmon: Add LTC2990 sensor driver Mike Looijmans
2016-01-06 8:07 ` Mike Looijmans
2016-01-06 15:22 ` Guenter Roeck
2016-01-07 18:59 ` [lm-sensors] " Mike Looijmans
2016-01-07 18:59 ` Mike Looijmans
2016-01-08 15:09 ` [lm-sensors] " Guenter Roeck
2016-01-08 15:09 ` Guenter Roeck
2016-01-13 11:05 ` [lm-sensors] [PATCH v2] " Mike Looijmans
2016-01-13 11:05 ` Mike Looijmans
2016-01-13 13:24 ` Guenter Roeck [this message]
2016-01-13 13:24 ` Guenter Roeck
2016-01-13 13:51 ` [lm-sensors] " Mike Looijmans
2016-01-13 13:51 ` Mike Looijmans
2016-01-13 13:57 ` [lm-sensors] " Guenter Roeck
2016-01-13 13:57 ` Guenter Roeck
2016-01-13 14:03 ` [lm-sensors] " Mike Looijmans
2016-01-13 14:03 ` Mike Looijmans
2016-01-13 14:45 ` [lm-sensors] [PATCH v3] " Mike Looijmans
2016-01-13 14:45 ` Mike Looijmans
2016-01-14 19:14 ` [lm-sensors] " Guenter Roeck
2016-01-14 19:14 ` Guenter Roeck
2016-01-15 9:54 ` [lm-sensors] " Mike Looijmans
2016-01-15 9:54 ` Mike Looijmans
2016-01-15 9:54 ` [lm-sensors] [PATCH v4] " Mike Looijmans
2016-01-15 9:54 ` Mike Looijmans
2016-01-15 15:40 ` [lm-sensors] " Guenter Roeck
2016-01-15 15:40 ` Guenter Roeck
2016-01-13 11:22 ` [lm-sensors] [PATCH] " Mike Looijmans
2016-01-13 11:22 ` Mike Looijmans
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=5696500E.4090905@roeck-us.net \
--to=linux@roeck-us.net \
--cc=jdelvare@suse.com \
--cc=linux-kernel@vger.kernel.org \
--cc=lm-sensors@lm-sensors.org \
--cc=mike.looijmans@topic.nl \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.