From: Guenter Roeck <linux@roeck-us.net>
To: Heiko Schocher <hs@denx.de>, lm-sensors@lm-sensors.org
Cc: Jean Delvare <khali@linux-fr.org>, linux-kernel@vger.kernel.org
Subject: Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor
Date: Wed, 11 Jun 2014 17:11:29 +0000 [thread overview]
Message-ID: <53988DC1.7000203@roeck-us.net> (raw)
In-Reply-To: <1402468095-14678-1-git-send-email-hs@denx.de>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WARNING: multiple messages have this Message-ID (diff)
From: Guenter Roeck <linux@roeck-us.net>
To: Heiko Schocher <hs@denx.de>, lm-sensors@lm-sensors.org
Cc: Jean Delvare <khali@linux-fr.org>, linux-kernel@vger.kernel.org
Subject: Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor
Date: Wed, 11 Jun 2014 10:11:29 -0700 [thread overview]
Message-ID: <53988DC1.7000203@roeck-us.net> (raw)
In-Reply-To: <1402468095-14678-1-git-send-email-hs@denx.de>
On 06/10/2014 11:28 PM, Heiko Schocher wrote:
> Driver for the TI TMP103.
>
> The TI TMP103 is similar to the TMP102. It differs from the TMP102
> by having only 8 bit registers.
>
> Signed-off-by: Heiko Schocher <hs@denx.de>
> Cc: Jean Delvare <khali@linux-fr.org>
> Cc: Guenter Roeck <linux@roeck-us.net>
> Cc: linux-kernel@vger.kernel.org
Hi Heiko,
You don't need those Cc: in the header.
Why patch 09/13 ? I'd expect to see 12 more patches in this series,
but there is only one (even on kernel.org). If you sent those
other patches to various other mailing lists, everyone will wonder
where the remaining patches are. If there is just one patch,
it is just confusing.
> ---
> Documentation/devicetree/bindings/hwmon/tmp103 | 30 +++
> drivers/hwmon/Kconfig | 10 +
> drivers/hwmon/Makefile | 1 +
> drivers/hwmon/tmp103.c | 281 +++++++++++++++++++++++++
> 4 files changed, 322 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/hwmon/tmp103
> create mode 100644 drivers/hwmon/tmp103.c
>
> diff --git a/Documentation/devicetree/bindings/hwmon/tmp103 b/Documentation/devicetree/bindings/hwmon/tmp103
> new file mode 100644
> index 0000000..36d7b36
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/hwmon/tmp103
Should be Documentation/hwmon/tmp103.
> @@ -0,0 +1,30 @@
> +Kernel driver tmp103
> +====================
> +
> +Supported chips:
> + * Texas Instruments TMP103
> + Prefix: 'tmp103'
> + Addresses scanned: none
> + Product info and datasheet: http://www.ti.com/product/tmp103
> +
> +Author:
> + Heiko Schocher <hs@denx.de>
> +
> +Description
> +-----------
> +
> +The TMP103 is a digital output temperature sensor in a four-ball
> +wafer chip-scale package (WCSP). The TMP103 is capable of reading
> +temperatures to a resolution of 1°C. The TMP103 is specified for
> +operation over a temperature range of –40°C to +125°C.
> +
> +Resolution: 8 Bits
> +Accuracy: ±1°C Typ (–10°C to +100°C)
> +
> +The driver provides the common sysfs-interface for temperatures (see
> +Documentation/hwmon/sysfs-interface under Temperatures).
> +
> +Required node properties:
> +- compatible: manufacturer and chip name
> + "ti,tmp103"
> +- reg: I2C bus address of the device
You don't need this part, and it is not really correct (there are
other ways to instantiate the device, devicetree is just one of them).
I would suggest to refer to Documentation/i2c/instantiating-devices
instead. It might also make sense to update
Documentation/devicetree/bindings/i2c/trivial-devices.txt.
Also, whenever you touch any of the the dt files, you need to copy
the DT maintainers. scripts/get_maintainer.pl will tell you who needs
to be copied.
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 0034316..0f44dbb 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1381,6 +1381,16 @@ config SENSORS_TMP102
> This driver can also be built as a module. If so, the module
> will be called tmp102.
>
> +config SENSORS_TMP103
> + tristate "Texas Instruments TMP103"
> + depends on I2C
> + help
> + If you say yes here you get support for Texas Instruments TMP103
> + sensor chips.
> +
> + This driver can also be built as a module. If so, the module
> + will be called tmp103.
> +
> config SENSORS_TMP401
> tristate "Texas Instruments TMP401 and compatibles"
> depends on I2C
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 11798ad..8e2f6a2 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -134,6 +134,7 @@ obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o
> obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o
> obj-$(CONFIG_SENSORS_THMC50) += thmc50.o
> 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_TWL4030_MADC)+= twl4030-madc-hwmon.o
> diff --git a/drivers/hwmon/tmp103.c b/drivers/hwmon/tmp103.c
> new file mode 100644
> index 0000000..0bd33d6
> --- /dev/null
> +++ b/drivers/hwmon/tmp103.c
> @@ -0,0 +1,281 @@
> +/*
> + * Texas Instruments TMP103 SMBus temperature sensor driver
> + * Copyright (C) 2014 Heiko Schocher <hs@denx.de>
> + *
> + * Based on:
> + * Texas Instruments TMP102 SMBus temperature sensor driver
> + *
> + * Copyright (C) 2010 Steven King <sfking@fdwdc.com>
> + *
> + * 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; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + */
> +
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/i2c.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/err.h>
> +#include <linux/mutex.h>
> +#include <linux/device.h>
> +#include <linux/jiffies.h>
> +
> +#define DRIVER_NAME "tmp103"
> +
> +#define TMP103_TEMP_REG 0x00
> +#define TMP103_CONF_REG 0x01
> +#define TMP103_TLOW_REG 0x02
> +#define TMP103_THIGH_REG 0x03
> +
> +#define TMP103_CONF_M0 0x01
> +#define TMP103_CONF_M1 0x02
> +#define TMP103_CONF_LC 0x04
> +#define TMP103_CONF_FL 0x08
> +#define TMP103_CONF_FH 0x10
> +#define TMP103_CONF_CR0 0x20
> +#define TMP103_CONF_CR1 0x40
> +#define TMP103_CONF_ID 0x80
> +#define TMP103_CONF_SD (TMP103_CONF_M0 | TMP103_CONF_M1)
> +
> +struct tmp103 {
> + struct device *hwmon_dev;
> + struct mutex lock;
> + u16 config_orig;
> + unsigned long last_update;
> + int temp[3];
> +};
> +
> +static inline int tmp103_reg_to_mC(s8 val)
> +{
> + return val * 1000;
> +}
> +
> +static inline u8 tmp103_mC_to_reg(int val)
> +{
> + return val / 1000;
DIV_ROUND_CLOSEST() ?
No camelCase, please.
> +}
> +
> +static const u8 tmp103_reg[] = {
> + TMP103_TEMP_REG,
> + TMP103_TLOW_REG,
> + TMP103_THIGH_REG,
> +};
> +
> +static struct tmp103 *tmp103_update_device(struct i2c_client *client)
> +{
> + struct tmp103 *tmp103 = i2c_get_clientdata(client);
> +
> + mutex_lock(&tmp103->lock);
> + if (time_after(jiffies, tmp103->last_update + HZ / 3)) {
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(tmp103->temp); ++i) {
> + int status = i2c_smbus_read_byte_data(client,
> + tmp103_reg[i]);
> + if (status > -1)
> + tmp103->temp[i] = tmp103_reg_to_mC(status);
I understand this is from the tmp102 driver, but it is kind of unusual
because it does not report the error back to the user. Please consider
doing that, ie return PTR_ERR(status) on error and check/return the error
from the calling functions. Irrelevant if you use regmap (see below).
> + }
> + tmp103->last_update = jiffies;
> + }
> + mutex_unlock(&tmp103->lock);
> + return tmp103;
> +}
Overall you might consider dropping the update function and using regmap instead.
It would be an excellent fit for this driver; while it doesn't do timed caching
it supports per-register caching which is ultimately more useful anyway.
Some of the drivers in the hwmon directory use it, so you could use that
as example. Not mandatory, though; just a suggestion.
> +
> +static ssize_t tmp103_show_temp(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
> + struct tmp103 *tmp103 = tmp103_update_device(to_i2c_client(dev));
> +
> + return sprintf(buf, "%d\n", tmp103->temp[sda->index]);
> +}
> +
> +static ssize_t tmp103_set_temp(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t count)
> +{
> + struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
> + struct i2c_client *client = to_i2c_client(dev);
> + struct tmp103 *tmp103 = i2c_get_clientdata(client);
> + long val;
> + int status;
> +
> + if (kstrtol(buf, 10, &val) < 0)
> + return -EINVAL;
> + val = clamp_val(val, -55000, 128000);
Max should be 127000.
> +
> + mutex_lock(&tmp103->lock);
> + tmp103->temp[sda->index] = val;
You can not do that since it is the non-rounded value. You have to convert to
the register value, then convert back to the display value.
If you use regmap, the problem goes away, since you would not cache converted
data but convert in the show function. Alternatively, you could store register
values and convert in the show function.
> + status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index],
> + tmp103_mC_to_reg(val));
Please make sure that continuation lines match the '(' in the line above.
Alignments are inconsistent, otherwise I would not mention it.
checkpatch --strict tells you which ones are misaligned.
> + mutex_unlock(&tmp103->lock);
> + return status ? : count;
> +}
> +
> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0);
> +
If you use regmap you can store the register directly here and you would not
need tmp103_reg[].
> +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp,
> + tmp103_set_temp, 1);
> +
Per the datasheet this should be temp1_min. The register definition is different to TMP102.
> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp103_show_temp,
> + tmp103_set_temp, 2);
> +
> +static struct attribute *tmp103_attributes[] = {
> + &sensor_dev_attr_temp1_input.dev_attr.attr,
> + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
> + &sensor_dev_attr_temp1_max.dev_attr.attr,
You might also consider adding temp1_min_alarm and temp1_max_alarm to inform
user space if limits are exceeded. The status is reported with the FL and FH
bits in the configuration register.
> + NULL
> +};
> +
> +static const struct attribute_group tmp103_attr_group = {
> + .attrs = tmp103_attributes,
> +};
> +
Please use the ATTRIBUTE_GROUPS() macro.
> +#define TMP103_CONFIG (TMP103_CONF_CR1 | TMP103_CONF_M1)
> +#define TMP103_CONFIG_RD_ONLY (TMP103_CONF_CR1 | TMP103_CONF_M1)
Latter define is not used as far as I can see. Since it is the same
it is unnecessary anyway.
> +
> +static int tmp103_probe(struct i2c_client *client,
> + const struct i2c_device_id *id)
> +{
> + struct tmp103 *tmp103;
> + int status;
> +
> + if (!i2c_check_functionality(client->adapter,
> + I2C_FUNC_SMBUS_WORD_DATA)) {
> + dev_err(&client->dev,
> + "adapter doesn't support SMBus word transactions\n");
Good that the chip doesn't support any ;-). Check for byte transactions instead.
> + return -ENODEV;
> + }
> +
> + tmp103 = devm_kzalloc(&client->dev, sizeof(*tmp103), GFP_KERNEL);
> + if (!tmp103)
> + return -ENOMEM;
> +
> + i2c_set_clientdata(client, tmp103);
> +
> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG);
> + if (status < 0) {
> + dev_err(&client->dev, "error reading config register\n");
> + return status;
> + }
> + tmp103->config_orig = status;
You don't use config_orig outside the probe function,
so storing it in private data doesn't add any value.
Alternatively, you could restore the original configuration on exit.
> + status = i2c_smbus_write_byte_data(client, TMP103_CONF_REG,
> + TMP103_CONFIG);
> + if (status < 0) {
> + dev_err(&client->dev, "error writing config register\n");
> + goto fail_restore_config;
> + }
> + status = i2c_smbus_read_byte_data(client, TMP103_CONF_REG);
> + if (status < 0) {
> + dev_err(&client->dev, "error reading config register\n");
> + goto fail_restore_config;
> + }
> + if (status != TMP103_CONFIG) {
> + dev_err(&client->dev, "config settings did not stick\n");
> + status = -ENODEV;
> + goto fail_restore_config;
> + }
> + tmp103->last_update = jiffies - HZ;
> + mutex_init(&tmp103->lock);
> +
> + status = sysfs_create_group(&client->dev.kobj, &tmp103_attr_group);
> + if (status) {
> + dev_dbg(&client->dev, "could not create sysfs files\n");
> + goto fail_restore_config;
> + }
> + tmp103->hwmon_dev = hwmon_device_register(&client->dev);
> + if (IS_ERR(tmp103->hwmon_dev)) {
> + dev_dbg(&client->dev, "unable to register hwmon device\n");
> + status = PTR_ERR(tmp103->hwmon_dev);
> + goto fail_remove_sysfs;
> + }
Please use devm_hwmon_device_register_with_groups().
> +
> + dev_info(&client->dev, "initialized\n");
Please drop this message.
> +
> + return 0;
> +
> +fail_remove_sysfs:
> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group);
> +fail_restore_config:
> + i2c_smbus_write_word_swapped(client, TMP103_CONF_REG,
> + tmp103->config_orig);
i2c_smbus_write_byte_data() ?
> + return status;
> +}
> +
> +static int tmp103_remove(struct i2c_client *client)
> +{
> + struct tmp103 *tmp103 = i2c_get_clientdata(client);
> +
> + hwmon_device_unregister(tmp103->hwmon_dev);
> + sysfs_remove_group(&client->dev.kobj, &tmp103_attr_group);
> +
> + return 0;
> +}
> +
> +#ifdef CONFIG_PM
> +static int tmp103_suspend(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + int config;
> +
> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG);
byte
> + if (config < 0)
> + return config;
> +
> + config &= ~TMP103_CONF_SD;
> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);
byte
> +}
> +
> +static int tmp103_resume(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + int config;
> +
> + config = i2c_smbus_read_word_swapped(client, TMP103_CONF_REG);
byte
> + if (config < 0)
> + return config;
> +
> + config |= TMP103_CONF_SD;
> + return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);
byte
> +}
> +
> +static const struct dev_pm_ops tmp103_dev_pm_ops = {
> + .suspend = tmp103_suspend,
> + .resume = tmp103_resume,
> +};
> +
> +#define TMP103_DEV_PM_OPS (&tmp103_dev_pm_ops)
> +#else
> +#define TMP103_DEV_PM_OPS NULL
> +#endif /* CONFIG_PM */
> +
> +static const struct i2c_device_id tmp103_id[] = {
> + { DRIVER_NAME, 0 },
> + { }
> +};
> +MODULE_DEVICE_TABLE(i2c, tmp103_id);
> +
> +static struct i2c_driver tmp103_driver = {
> + .driver.name = DRIVER_NAME,
> + .driver.pm = TMP103_DEV_PM_OPS,
.driver = {
.name = DRIVER_NAME,
.pm = TMP103_DEV_PM_OPS,
},
would be a bit nicer. I won't mandate it, though.
> + .probe = tmp103_probe,
> + .remove = tmp103_remove,
> + .id_table = tmp103_id,
> +};
> +
> +module_i2c_driver(tmp103_driver);
> +
> +MODULE_AUTHOR("Heiko Schocher <hs@denx.de>");
> +MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver");
> +MODULE_LICENSE("GPL");
>
next prev parent reply other threads:[~2014-06-11 17:11 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-06-11 6:28 [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor Heiko Schocher
2014-06-11 6:28 ` Heiko Schocher
2014-06-11 17:11 ` Guenter Roeck [this message]
2014-06-11 17:11 ` Guenter Roeck
2014-06-12 9:39 ` [lm-sensors] " Heiko Schocher
2014-06-12 9:39 ` Heiko Schocher
2014-06-12 12:06 ` [lm-sensors] " Guenter Roeck
2014-06-12 12:06 ` Guenter Roeck
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=53988DC1.7000203@roeck-us.net \
--to=linux@roeck-us.net \
--cc=hs@denx.de \
--cc=khali@linux-fr.org \
--cc=linux-kernel@vger.kernel.org \
--cc=lm-sensors@lm-sensors.org \
/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.