hwmon: New driver for Texas Instruments TPS2480/TPS2481

Attached is a patch which adds hwmon support for Texas Instruments TPS2480/TPS2481 current sensor. The code follows the same architecture found in other hwmon drivers and should be pretty easy to understand.

The chip reports measured current as the voltage drop across a shunt resistor. This value is reported in the curr1_input attribute as 10 uV steps. It is then the responsibility of the user to convert back this value in amperes to have the correct value (for instance using sensors.conf file).

Many parameters affecting the chip operation are exported through sysfs interface and thus are available for configuration from userland. Even if it is not necessary to configure the chip before usage, there might be cases where a user needs to do so.

To apply the patch on the latest kernel, simply type (assuming filename <patch>):
git apply --check <patch>

To use the driver, enable the option "SENSORS_TPS2480", in your kernel configuration file. I2C/SMBus support is required in your kernel. The code has been written in an architecture-independent way, but have only been tested on PowerPC architecture (big-endian).

As this is my first patch submitted for the Linux kernel, it is possible that the approach I used is not correct, notably the way the driver reports current/voltage information and the exported chip parameters. I don't know if it is necessary to export that much information/configuration for a simple chip like this one, or if I should keep it simple, and use the chip in the default configuration.

Please let me know any feedback you have on this patch.

Best regards,
Hadrien Copponnex
R&D Engineer

AppearTV AS
www.appeartv.com

---
  drivers/hwmon/Kconfig   |   10 ++
  drivers/hwmon/Makefile  |    1 +
  drivers/hwmon/tps2480.c |  386 
+++++++++++++++++++++++++++++++++++++++++++++++
  3 files changed, 397 insertions(+)

create mode 100644 drivers/hwmon/tps2480.c

index 25d9e72..7919e7d 100644
@@ -1504,6 +1504,16 @@ config SENSORS_TMP421
  	  This driver can also be built as a module.  If so, the module
  	  will be called tmp421.
 
+config SENSORS_TPS2480
+	tristate "Texas Instruments TPS2480/2481 (EXPERIMENTAL)"
+	depends on I2C
+	help
+	  If you say yes here you get support for Texas Instruments TPS2480
+	  and TPS2481 sensor chips.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called tps2480.
+
  config SENSORS_TWL4030_MADC
  	tristate "Texas Instruments TWL4030 MADC Hwmon"
  	depends on TWL4030_MADC

index b4a40f1..b640247 100644
@@ -145,6 +145,7 @@ obj-$(CONFIG_SENSORS_TMP102)	+= tmp102.o
  obj-$(CONFIG_SENSORS_TMP103)	+= tmp103.o
  obj-$(CONFIG_SENSORS_TMP401)	+= tmp401.o
  obj-$(CONFIG_SENSORS_TMP421)	+= tmp421.o
+obj-$(CONFIG_SENSORS_TPS2480)   += tps2480.o
  obj-$(CONFIG_SENSORS_TWL4030_MADC)+= twl4030-madc-hwmon.o
  obj-$(CONFIG_SENSORS_VEXPRESS)	+= vexpress.o
  obj-$(CONFIG_SENSORS_VIA_CPUTEMP)+= via-cputemp.o

const u16
+*p, const char *fmt)
+{
+ struct tps2480_data *data = tps2480_update_device(dev);
+ u16 value = data->registers[reg];
+ u8 valid = data->valid;
+
+ mutex_unlock(&data->lock);
+ if (!valid)
+ return -EIO;
+ value = (value >> p[1]) & p[0];
+ return snprintf(buf, PAGE_SIZE, fmt, value);
+}
+
+static ssize_t perform_store(struct device *dev, const char *buf, size_t count,
+u8 reg, const u16 *p)
+{
+ struct tps2480_data *data = tps2480_update_device(dev);
+ struct i2c_client *client = to_i2c_client(dev);
+ unsigned long val = 0;
+ ssize_t result = count;
+ s32 err;
+
+ if (kstrtoul(buf, 10, &val) || val > p[0]) {
+ result = -EINVAL;
+ goto finish;
+ }
+
+ data->registers[reg] = (val & p[0]) << p[1];
+
+ err = write_register(client, reg, data->registers[reg]);
+ if (err)
+ result = err;
+
+finish:
+ mutex_unlock(&data->lock);
+
+ return result;
+}
+
+/* Variable parameters
+ [0]: mask
+ [1]: shift */
+static const u16 in0[2] = {0xfff8, 0x01};
+static const u16 cu1[2] = {0xffff, 0x00};
+static const u16 cu2[2] = {0xffff, 0x00};
+static const u16 pow[2] = {0xffff, 0x00};
+static const u16 bvr[2] = {0x0001, 0x0d};
+static const u16 pga[2] = {0x0003, 0x0b};
+static const u16 bad[2] = {0x000f, 0x07};
+static const u16 sad[2] = {0x000f, 0x03};
+static const u16 mod[2] = {0x0007, 0x00};
+static const u16 cal[2] = {0xffff, 0x00};
+
+static ssize_t show_in0(struct device *dev, struct device_attribute *attr, char
+*buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_BUS_VOLTAGE, in0, "%hu\n");
+}
+
+static ssize_t show_curr1(struct device *dev, struct device_attribute *attr,
+char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_SHUNT_VOLTAGE, cu1, "%hd\n");
+}
+
+static ssize_t show_curr2(struct device *dev, struct device_attribute *attr,
+char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CURRENT, cu2, "%hd\n");
+}
+
+static ssize_t show_power(struct device *dev, struct device_attribute *attr,
+char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_POWER, pow, "%hu\n");
+}
+
+static ssize_t store_reset(struct device *dev, struct device_attribute *attr,
+const char *buf, size_t count)
+{
+ s32 err = reset_chip(dev);
+
+ return err ? err : count;
+}
+
+static ssize_t show_bus_voltage_range(struct device *dev, struct +device_attribute *attr, char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CONFIG, bvr, "%hu\n");
+}
+
+static ssize_t store_bus_voltage_range(struct device *dev, struct +device_attribute *attr, const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CONFIG, bvr);
+}
+
+static ssize_t show_pga(struct device *dev, struct device_attribute *attr, char
+*buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CONFIG, pga, "%hu\n");
+}
+
+static ssize_t store_pga(struct device *dev, struct device_attribute *attr, +const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CONFIG, pga);
+}
+
+static ssize_t show_badc(struct device *dev, struct device_attribute *attr, +char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CONFIG, bad, "%hu\n");
+}
+
+static ssize_t store_badc(struct device *dev, struct device_attribute *attr,
+const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CONFIG, bad);
+}
+
+static ssize_t show_sadc(struct device *dev, struct device_attribute *attr, +char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CONFIG, sad, "%hu\n");
+}
+
+static ssize_t store_sadc(struct device *dev, struct device_attribute *attr,
+const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CONFIG, sad);
+}
+
+static ssize_t show_mode(struct device *dev, struct device_attribute *attr, +char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CONFIG, mod, "%hu\n");
+}
+
+static ssize_t store_mode(struct device *dev, struct device_attribute *attr,
+const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CONFIG, mod);
+}
+
+static ssize_t show_calibration(struct device *dev, struct device_attribute +*attr, char *buf)
+{
+ return perform_show(dev, buf, TPS2480_REG_CALIBRATION, cal, "%hu\n");
+}
+
+static ssize_t store_calibration(struct device *dev, struct device_attribute
+*attr, const char *buf, size_t count)
+{
+ return perform_store(dev, buf, count, TPS2480_REG_CALIBRATION, cal);
+}
+
+static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL, 0); /* Bus +voltage */
+static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, show_curr1, NULL, 1); /* Shunt
+voltage */
+static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, show_curr2, NULL, 1); /* +Current */
+static SENSOR_DEVICE_ATTR(power_input, S_IRUGO, show_power, NULL, 1); /* +Power */
+static SENSOR_DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset, 0); /* Reset */
+static SENSOR_DEVICE_ATTR(bus_voltage_range, S_IRUGO | S_IWUSR, +show_bus_voltage_range, store_bus_voltage_range, 0); /* Bus voltage range */
+static SENSOR_DEVICE_ATTR(pga, S_IRUGO | S_IWUSR, show_pga, store_pga, 0); /*
+PGA */
+static SENSOR_DEVICE_ATTR(badc, S_IRUGO | S_IWUSR, show_badc, store_badc, 0);
+/* BADC */
+static SENSOR_DEVICE_ATTR(sadc, S_IRUGO | S_IWUSR, show_sadc, store_sadc, 0);
+/* SADC */
+static SENSOR_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, show_mode, store_mode, 0);
+/* Mode */
+static SENSOR_DEVICE_ATTR(calibration, S_IRUGO | S_IWUSR, show_calibration, +store_calibration, 0); /* Calibration */
+
+static struct attribute *tps2480_attrs[] = {
+ &sensor_dev_attr_in0_input.dev_attr.attr,
+ &sensor_dev_attr_curr1_input.dev_attr.attr,
+ &sensor_dev_attr_curr2_input.dev_attr.attr,
+ &sensor_dev_attr_power_input.dev_attr.attr,
+ &sensor_dev_attr_reset.dev_attr.attr,
+ &sensor_dev_attr_bus_voltage_range.dev_attr.attr,
+ &sensor_dev_attr_pga.dev_attr.attr,
+ &sensor_dev_attr_badc.dev_attr.attr,
+ &sensor_dev_attr_sadc.dev_attr.attr,
+ &sensor_dev_attr_mode.dev_attr.attr,
+ &sensor_dev_attr_calibration.dev_attr.attr,
+ NULL
+};
+
+static struct attribute_group tps2480_attr_grp = {
+ .attrs = tps2480_attrs,
+};
+
+/*
+ * Driver interface functions
+ */
+
+static int tps2480_probe(struct i2c_client *client, const struct i2c_device_id
+*id)
+{
+ struct tps2480_data *data;
+ int err;
+
+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+I2C_FUNC_SMBUS_WORD_DATA)) {
+ dev_err(&client->dev, "i2c adapter doesn't support smbus");
+ return -EOPNOTSUPP;
+ }
+
+ data = devm_kzalloc(&client->dev,
+ sizeof(struct tps2480_data),
+ GFP_KERNEL);
+ if (data = NULL) {
+ dev_err(&client->dev, "cannot allocate memory");
+ return -ENOMEM;
+ }
+ i2c_set_clientdata(client, data);
+
+ mutex_init(&data->lock);
+
+ err = sysfs_create_group(&client->dev.kobj, &tps2480_attr_grp);
+ if (err) {
+ dev_err(&client->dev, "error creating sysfs attribute group");
+ return err;
+ }
+
+ data->hwmon_dev = hwmon_device_register(&client->dev);
+ if (IS_ERR(data->hwmon_dev)) {
+ err = PTR_ERR(data->hwmon_dev);
+ dev_err(&client->dev, "error registering hwmon device");
+ sysfs_remove_group(&client->dev.kobj, &tps2480_attr_grp);
+ return err;
+ }
+
+ return 0;
+}
+
+static int tps2480_remove(struct i2c_client *client)
+{
+ struct tps2480_data *data = i2c_get_clientdata(client);
+
+ hwmon_device_unregister(data->hwmon_dev);
+ sysfs_remove_group(&client->dev.kobj, &tps2480_attr_grp);
+
+ return 0;
+}
+
+static const struct i2c_device_id tps2480_id[] = {
+ {"tps2480", 0},
+ {}
+};
+
+MODULE_DEVICE_TABLE(i2c, tps2480_id);
+
+static struct i2c_driver tps2480_driver = {
+ .class = I2C_CLASS_HWMON,
+ .driver = {
+ .name = "tps2480",
+ },
+ .probe = tps2480_probe,
+ .remove = tps2480_remove,
+ .id_table = tps2480_id,
+};
+
+module_i2c_driver(tps2480_driver);
+
+MODULE_AUTHOR("Hadrien Copponnex <[email protected]>"); +MODULE_DESCRIPTION("I2C/SMBus Driver for TI TPS2480/TPS2481"); +MODULE_LICENSE("GPL");

1.7.9.5



_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Hi Hadrien,

The current is really reported in the current register. The voltage drop is just that, a voltage drop, and should be reported as voltage.

Please read and follow Documentation/hwmon/submitting-patches, and consider what it says as overall feedback. For the most part, I won't comment on items covered by this document. Some more comments inline.

Thanks,
Guenter

Please also provide Documentation/hwmon/tps2480.