[lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Heiko Schocher]
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[PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Heiko Schocher]

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
---
 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
@@ -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
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;
+}
+
+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);
+		}
+		tmp103->last_update = jiffies;
+	}
+	mutex_unlock(&tmp103->lock);
+	return tmp103;
+}
+
+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);
+
+	mutex_lock(&tmp103->lock);
+	tmp103->temp[sda->index] = val;
+	status = i2c_smbus_write_byte_data(client, tmp103_reg[sda->index],
+					      tmp103_mC_to_reg(val));
+	mutex_unlock(&tmp103->lock);
+	return status ? : count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp103_show_temp, NULL , 0);
+
+static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp103_show_temp,
+			  tmp103_set_temp, 1);
+
+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,
+	NULL
+};
+
+static const struct attribute_group tmp103_attr_group = {
+	.attrs = tmp103_attributes,
+};
+
+#define TMP103_CONFIG		(TMP103_CONF_CR1 | TMP103_CONF_M1)
+#define TMP103_CONFIG_RD_ONLY	(TMP103_CONF_CR1 | TMP103_CONF_M1)
+
+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");
+		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;
+	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;
+	}
+
+	dev_info(&client->dev, "initialized\n");
+
+	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);
+	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);
+	if (config < 0)
+		return config;
+
+	config &= ~TMP103_CONF_SD;
+	return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);
+}
+
+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);
+	if (config < 0)
+		return config;
+
+	config |= TMP103_CONF_SD;
+	return i2c_smbus_write_word_swapped(client, TMP103_CONF_REG, config);
+}
+
+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,
+	.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");
-- 
1.8.3.1

Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Guenter Roeck]
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Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Guenter Roeck]

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");
>

Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Heiko Schocher]

SGVsbG8gR3VlbnRlciwKCkFtIDExLjA2LjIwMTQgMTk6MTEsIHNjaHJpZWIgR3VlbnRlciBSb2Vj
azoKPiBPbiAwNi8xMC8yMDE0IDExOjI4IFBNLCBIZWlrbyBTY2hvY2hlciB3cm90ZToKPj4gRHJp
dmVyIGZvciB0aGUgVEkgVE1QMTAzLgo+Pgo+PiBUaGUgVEkgVE1QMTAzIGlzIHNpbWlsYXIgdG8g
dGhlIFRNUDEwMi4gSXQgZGlmZmVycyBmcm9tIHRoZSBUTVAxMDIKPj4gYnkgaGF2aW5nIG9ubHkg
OCBiaXQgcmVnaXN0ZXJzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTY2hvY2hlciA8aHNA
ZGVueC5kZT4KPj4gQ2M6IEplYW4gRGVsdmFyZSA8a2hhbGlAbGludXgtZnIub3JnPgo+PiBDYzog
R3VlbnRlciBSb2VjayA8bGludXhAcm9lY2stdXMubmV0Pgo+PiBDYzogbGludXgta2VybmVsQHZn
ZXIua2VybmVsLm9yZwo+Cj4gSGkgSGVpa28sCj4KPiBZb3UgZG9uJ3QgbmVlZCB0aG9zZSBDYzog
aW4gdGhlIGhlYWRlci4KCk9rLCBJIHJlbW92ZSB0aGVtLgoKPiBXaHkgcGF0Y2ggMDkvMTMgPyBJ
J2QgZXhwZWN0IHRvIHNlZSAxMiBtb3JlIHBhdGNoZXMgaW4gdGhpcyBzZXJpZXMsCgpIdXBzLCBz
b3JyeSwgbXkgbWlzdGFrZSwgdGhlcmUgaXMganVzdCB0aGlzIHBhdGNoLi4uCgo+IGJ1dCB0aGVy
ZSBpcyBvbmx5IG9uZSAoZXZlbiBvbiBrZXJuZWwub3JnKS4gSWYgeW91IHNlbnQgdGhvc2UKPiBv
dGhlciBwYXRjaGVzIHRvIHZhcmlvdXMgb3RoZXIgbWFpbGluZyBsaXN0cywgZXZlcnlvbmUgd2ls
bCB3b25kZXIKPiB3aGVyZSB0aGUgcmVtYWluaW5nIHBhdGNoZXMgYXJlLiBJZiB0aGVyZSBpcyBq
dXN0IG9uZSBwYXRjaCwKPiBpdCBpcyBqdXN0IGNvbmZ1c2luZy4KPgo+PiAtLS0KPj4gRG9jdW1l
bnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2h3bW9uL3RtcDEwMyB8IDMwICsrKwo+PiBkcml2
ZXJzL2h3bW9uL0tjb25maWcgfCAxMCArCj4+IGRyaXZlcnMvaHdtb24vTWFrZWZpbGUgfCAxICsK
Pj4gZHJpdmVycy9od21vbi90bXAxMDMuYyB8IDI4MSArKysrKysrKysrKysrKysrKysrKysrKysr
Cj4+IDQgZmlsZXMgY2hhbmdlZCwgMzIyIGluc2VydGlvbnMoKykKPj4gY3JlYXRlIG1vZGUgMTAw
NjQ0IERvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMKPj4gY3Jl
YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaHdtb24vdG1wMTAzLmMKPj4KPj4gZGlmZiAtLWdpdCBh
L0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9od21vbi90bXAxMDMgYi9Eb2N1bWVu
dGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4+IG5ldyBmaWxlIG1vZGUg
MTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjM2ZDdiMzYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysg
Yi9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaHdtb24vdG1wMTAzCj4KPiBTaG91
bGQgYmUgRG9jdW1lbnRhdGlvbi9od21vbi90bXAxMDMuCgpIbW0uLiBJIGRpZCB0aGlzIGZpcnN0
IHRoZXJlLCBidXQgInNjcmlwdHMvY2hlY2twYXRjaC5wbCIKd2FybnMgKGlmIHVzaW5nIGEgRFQg
YmFzZWQgYm9hcmQgd2l0aCBjb21wYXRpYmxlID0gInRpLHRtcDEwMyIpOgoKV0FSTklORzogRFQg
Y29tcGF0aWJsZSBzdHJpbmcgInRpLHRtcDEwMyIgYXBwZWFycyB1bi1kb2N1bWVudGVkIC0tIGNo
ZWNrIC4vRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzLwojMzI0OiBGSUxFOiBhcmNo
L2FybS9ib290L2R0cy9pbXg2cWRsLWFyaXN0YWluZXRvcy5kdHNpOjEwNzoKKyAgICAgICAgICAg
ICAgIGNvbXBhdGlibGUgPSAidGksdG1wMTAzIjsKCj4+IEBAIC0wLDAgKzEsMzAgQEAKPj4gK0tl
cm5lbCBkcml2ZXIgdG1wMTAzCj4+ICs9PT09PT09PT09PT09PT09PT09PQo+PiArCj4+ICtTdXBw
b3J0ZWQgY2hpcHM6Cj4+ICsgKiBUZXhhcyBJbnN0cnVtZW50cyBUTVAxMDMKPj4gKyBQcmVmaXg6
ICd0bXAxMDMnCj4+ICsgQWRkcmVzc2VzIHNjYW5uZWQ6IG5vbmUKPj4gKyBQcm9kdWN0IGluZm8g
YW5kIGRhdGFzaGVldDogaHR0cDovL3d3dy50aS5jb20vcHJvZHVjdC90bXAxMDMKPj4gKwo+PiAr
QXV0aG9yOgo+PiArIEhlaWtvIFNjaG9jaGVyIDxoc0BkZW54LmRlPgo+PiArCj4+ICtEZXNjcmlw
dGlvbgo+PiArLS0tLS0tLS0tLS0KPj4gKwo+PiArVGhlIFRNUDEwMyBpcyBhIGRpZ2l0YWwgb3V0
cHV0IHRlbXBlcmF0dXJlIHNlbnNvciBpbiBhIGZvdXItYmFsbAo+PiArd2FmZXIgY2hpcC1zY2Fs
ZSBwYWNrYWdlIChXQ1NQKS4gVGhlIFRNUDEwMyBpcyBjYXBhYmxlIG9mIHJlYWRpbmcKPj4gK3Rl
bXBlcmF0dXJlcyB0byBhIHJlc29sdXRpb24gb2YgMcKwQy4gVGhlIFRNUDEwMyBpcyBzcGVjaWZp
ZWQgZm9yCj4+ICtvcGVyYXRpb24gb3ZlciBhIHRlbXBlcmF0dXJlIHJhbmdlIG9mIOKAkzQwwrBD
IHRvICsxMjXCsEMuCj4+ICsKPj4gK1Jlc29sdXRpb246IDggQml0cwo+PiArQWNjdXJhY3k6IMKx
McKwQyBUeXAgKOKAkzEwwrBDIHRvICsxMDDCsEMpCj4+ICsKPj4gK1RoZSBkcml2ZXIgcHJvdmlk
ZXMgdGhlIGNvbW1vbiBzeXNmcy1pbnRlcmZhY2UgZm9yIHRlbXBlcmF0dXJlcyAoc2VlCj4+ICtE
b2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZSB1bmRlciBUZW1wZXJhdHVyZXMpLgo+
PiArCj4+ICtSZXF1aXJlZCBub2RlIHByb3BlcnRpZXM6Cj4+ICstIGNvbXBhdGlibGU6IG1hbnVm
YWN0dXJlciBhbmQgY2hpcCBuYW1lCj4+ICsgInRpLHRtcDEwMyIKPj4gKy0gcmVnOiBJMkMgYnVz
IGFkZHJlc3Mgb2YgdGhlIGRldmljZQo+Cj4gWW91IGRvbid0IG5lZWQgdGhpcyBwYXJ0LCBhbmQg
aXQgaXMgbm90IHJlYWxseSBjb3JyZWN0ICh0aGVyZSBhcmUKPiBvdGhlciB3YXlzIHRvIGluc3Rh
bnRpYXRlIHRoZSBkZXZpY2UsIGRldmljZXRyZWUgaXMganVzdCBvbmUgb2YgdGhlbSkuCgpPay4K
Cj4gSSB3b3VsZCBzdWdnZXN0IHRvIHJlZmVyIHRvIERvY3VtZW50YXRpb24vaTJjL2luc3RhbnRp
YXRpbmctZGV2aWNlcwo+IGluc3RlYWQuIEl0IG1pZ2h0IGFsc28gbWFrZSBzZW5zZSB0byB1cGRh
dGUKPiBEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3MvaTJjL3RyaXZpYWwtZGV2aWNl
cy50eHQuCgpBaCwgb2ssIGdvb2QgaWRlYSwgdGhpcyByZW1vdmVzIGFsc28gdGhlIGNoZWNrcGF0
Y2ggd2FybmluZywgdGhhbmtzIQpDaGFuZ2VkLgoKPiBBbHNvLCB3aGVuZXZlciB5b3UgdG91Y2gg
YW55IG9mIHRoZSB0aGUgZHQgZmlsZXMsIHlvdSBuZWVkIHRvIGNvcHkKPiB0aGUgRFQgbWFpbnRh
aW5lcnMuIHNjcmlwdHMvZ2V0X21haW50YWluZXIucGwgd2lsbCB0ZWxsIHlvdSB3aG8gbmVlZHMK
PiB0byBiZSBjb3BpZWQuCgpPay4KClsuLi5dCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9u
L01ha2VmaWxlIGIvZHJpdmVycy9od21vbi9NYWtlZmlsZQo+PiBpbmRleCAxMTc5OGFkLi44ZTJm
NmEyIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2h3bW9uL01ha2VmaWxlCj4+ICsrKyBiL2RyaXZl
cnMvaHdtb24vTWFrZWZpbGUKPj4gQEAgLTEzNCw2ICsxMzQsNyBAQCBvYmotJChDT05GSUdfU0VO
U09SU19TTVNDNDdNMTkyKSs9IHNtc2M0N20xOTIubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19B
TUM2ODIxKSArPSBhbWM2ODIxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVEhNQzUwKSArPSB0
aG1jNTAubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UTVAxMDIpICs9IHRtcDEwMi5vCj4+ICtv
YmotJChDT05GSUdfU0VOU09SU19UTVAxMDMpICs9IHRtcDEwMy5vCj4+IG9iai0kKENPTkZJR19T
RU5TT1JTX1RNUDQwMSkgKz0gdG1wNDAxLm8KPj4gb2JqLSQoQ09ORklHX1NFTlNPUlNfVE1QNDIx
KSArPSB0bXA0MjEubwo+PiBvYmotJChDT05GSUdfU0VOU09SU19UV0w0MDMwX01BREMpKz0gdHds
NDAzMC1tYWRjLWh3bW9uLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vdG1wMTAzLmMg
Yi9kcml2ZXJzL2h3bW9uL3RtcDEwMy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4
IDAwMDAwMDAuLjBiZDMzZDYKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2h3bW9u
L3RtcDEwMy5jCj4+IEBAIC0wLDAgKzEsMjgxIEBACj4+ICsvKgo+PiArICogVGV4YXMgSW5zdHJ1
bWVudHMgVE1QMTAzIFNNQnVzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2ZXIKPj4gKyAqIENvcHly
aWdodCAoQykgMjAxNCBIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4KPj4gKyAqCj4+ICsgKiBC
YXNlZCBvbjoKPj4gKyAqIFRleGFzIEluc3RydW1lbnRzIFRNUDEwMiBTTUJ1cyB0ZW1wZXJhdHVy
ZSBzZW5zb3IgZHJpdmVyCj4+ICsgKgo+PiArICogQ29weXJpZ2h0IChDKSAyMDEwIFN0ZXZlbiBL
aW5nIDxzZmtpbmdAZmR3ZGMuY29tPgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl
IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4+ICsgKiBp
dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1
Ymxpc2hlZCBieQo+PiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl
cnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKPj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxh
dGVyIHZlcnNpb24uCj4+ICsgKgo+PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu
IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkg
V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+PiArICogTUVS
Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhl
Cj4+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+PiAr
ICoKPj4gKyAqLwo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4+ICsjaW5jbHVk
ZSA8bGludXgvaW5pdC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPj4gKyNpbmNsdWRl
IDxsaW51eC9pMmMuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9od21vbi5oPgo+PiArI2luY2x1ZGUg
PGxpbnV4L2h3bW9uLXN5c2ZzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvZXJyLmg+Cj4+ICsjaW5j
bHVkZSA8bGludXgvbXV0ZXguaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPj4gKyNp
bmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+Cj4+ICsKPj4gKyNkZWZpbmUgRFJJVkVSX05BTUUgInRt
cDEwMyIKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfVEVNUF9SRUcgMHgwMAo+PiArI2RlZmluZSBU
TVAxMDNfQ09ORl9SRUcgMHgwMQo+PiArI2RlZmluZSBUTVAxMDNfVExPV19SRUcgMHgwMgo+PiAr
I2RlZmluZSBUTVAxMDNfVEhJR0hfUkVHIDB4MDMKPj4gKwo+PiArI2RlZmluZSBUTVAxMDNfQ09O
Rl9NMCAweDAxCj4+ICsjZGVmaW5lIFRNUDEwM19DT05GX00xIDB4MDIKPj4gKyNkZWZpbmUgVE1Q
MTAzX0NPTkZfTEMgMHgwNAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9GTCAweDA4Cj4+ICsjZGVm
aW5lIFRNUDEwM19DT05GX0ZIIDB4MTAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IwIDB4MjAK
Pj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZfQ1IxIDB4NDAKPj4gKyNkZWZpbmUgVE1QMTAzX0NPTkZf
SUQgMHg4MAo+PiArI2RlZmluZSBUTVAxMDNfQ09ORl9TRCAoVE1QMTAzX0NPTkZfTTAgfCBUTVAx
MDNfQ09ORl9NMSkKPj4gKwo+PiArc3RydWN0IHRtcDEwMyB7Cj4+ICsgc3RydWN0IGRldmljZSAq
aHdtb25fZGV2Owo+PiArIHN0cnVjdCBtdXRleCBsb2NrOwo+PiArIHUxNiBjb25maWdfb3JpZzsK
Pj4gKyB1bnNpZ25lZCBsb25nIGxhc3RfdXBkYXRlOwo+PiArIGludCB0ZW1wWzNdOwo+PiArfTsK
Pj4gKwo+PiArc3RhdGljIGlubGluZSBpbnQgdG1wMTAzX3JlZ190b19tQyhzOCB2YWwpCj4+ICt7
Cj4+ICsgcmV0dXJuIHZhbCAqIDEwMDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbmxpbmUgdTgg
dG1wMTAzX21DX3RvX3JlZyhpbnQgdmFsKQo+PiArewo+PiArIHJldHVybiB2YWwgLyAxMDAwOwo+
Cj4gRElWX1JPVU5EX0NMT1NFU1QoKSA/Cj4KPiBObyBjYW1lbENhc2UsIHBsZWFzZS4KCk9rIC4u
LiBobW0sIHdvbmRlcmluZyB0aGF0IGNoZWNrcGF0Y2gucGwgbm90IGNsYWltZWQgdGhpcy4KcmVt
b3ZlZC4KCj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBjb25zdCB1OCB0bXAxMDNfcmVnW10gPSB7Cj4+
ICsgVE1QMTAzX1RFTVBfUkVHLAo+PiArIFRNUDEwM19UTE9XX1JFRywKPj4gKyBUTVAxMDNfVEhJ
R0hfUkVHLAo+PiArfTsKPj4gKwo+PiArc3RhdGljIHN0cnVjdCB0bXAxMDMgKnRtcDEwM191cGRh
dGVfZGV2aWNlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4+ICt7Cj4+ICsgc3RydWN0IHRt
cDEwMyAqdG1wMTAzID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsKPj4gKyBtdXRl
eF9sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIGlmICh0aW1lX2FmdGVyKGppZmZpZXMsIHRtcDEw
My0+bGFzdF91cGRhdGUgKyBIWiAvIDMpKSB7Cj4+ICsgaW50IGk7Cj4+ICsKPj4gKyBmb3IgKGkg
PSAwOyBpIDwgQVJSQVlfU0laRSh0bXAxMDMtPnRlbXApOyArK2kpIHsKPj4gKyBpbnQgc3RhdHVz
ID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwKPj4gKyB0bXAxMDNfcmVnW2ldKTsK
Pj4gKyBpZiAoc3RhdHVzID4gLTEpCj4+ICsgdG1wMTAzLT50ZW1wW2ldID0gdG1wMTAzX3JlZ190
b19tQyhzdGF0dXMpOwo+Cj4gSSB1bmRlcnN0YW5kIHRoaXMgaXMgZnJvbSB0aGUgdG1wMTAyIGRy
aXZlciwgYnV0IGl0IGlzIGtpbmQgb2YgdW51c3VhbAo+IGJlY2F1c2UgaXQgZG9lcyBub3QgcmVw
b3J0IHRoZSBlcnJvciBiYWNrIHRvIHRoZSB1c2VyLiBQbGVhc2UgY29uc2lkZXIKPiBkb2luZyB0
aGF0LCBpZSByZXR1cm4gUFRSX0VSUihzdGF0dXMpIG9uIGVycm9yIGFuZCBjaGVjay9yZXR1cm4g
dGhlIGVycm9yCj4gZnJvbSB0aGUgY2FsbGluZyBmdW5jdGlvbnMuIElycmVsZXZhbnQgaWYgeW91
IHVzZSByZWdtYXAgKHNlZSBiZWxvdykuCgp5b3UgbWVhbiBFUlJfUFRSKCkgPwpPaywgYWRkIHRo
aXMuCgo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllczsKPj4gKyB9Cj4+
ICsgbXV0ZXhfdW5sb2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHJldHVybiB0bXAxMDM7Cj4+ICt9
Cj4KPiBPdmVyYWxsIHlvdSBtaWdodCBjb25zaWRlciBkcm9wcGluZyB0aGUgdXBkYXRlIGZ1bmN0
aW9uIGFuZCB1c2luZyByZWdtYXAgaW5zdGVhZC4KPiBJdCB3b3VsZCBiZSBhbiBleGNlbGxlbnQg
Zml0IGZvciB0aGlzIGRyaXZlcjsgd2hpbGUgaXQgZG9lc24ndCBkbyB0aW1lZCBjYWNoaW5nCj4g
aXQgc3VwcG9ydHMgcGVyLXJlZ2lzdGVyIGNhY2hpbmcgd2hpY2ggaXMgdWx0aW1hdGVseSBtb3Jl
IHVzZWZ1bCBhbnl3YXkuCj4gU29tZSBvZiB0aGUgZHJpdmVycyBpbiB0aGUgaHdtb24gZGlyZWN0
b3J5IHVzZSBpdCwgc28geW91IGNvdWxkIHVzZSB0aGF0Cj4gYXMgZXhhbXBsZS4gTm90IG1hbmRh
dG9yeSwgdGhvdWdoOyBqdXN0IGEgc3VnZ2VzdGlvbi4KCkNvdWxkIHlvdSBnaXZlIG1lIGFuIGV4
YW1wbGU/Cgo+PiArCj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2hvd190ZW1wKHN0cnVjdCBk
ZXZpY2UgKmRldiwKPj4gKyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKPj4gKyBjaGFy
ICpidWYpCj4+ICt7Cj4+ICsgc3RydWN0IHNlbnNvcl9kZXZpY2VfYXR0cmlidXRlICpzZGEgPSB0
b19zZW5zb3JfZGV2X2F0dHIoYXR0cik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0gdG1w
MTAzX3VwZGF0ZV9kZXZpY2UodG9faTJjX2NsaWVudChkZXYpKTsKPj4gKwo+PiArIHJldHVybiBz
cHJpbnRmKGJ1ZiwgIiVkXG4iLCB0bXAxMDMtPnRlbXBbc2RhLT5pbmRleF0pOwo+PiArfQo+PiAr
Cj4+ICtzdGF0aWMgc3NpemVfdCB0bXAxMDNfc2V0X3RlbXAoc3RydWN0IGRldmljZSAqZGV2LAo+
PiArIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAo+PiArIGNvbnN0IGNoYXIgKmJ1Ziwg
c2l6ZV90IGNvdW50KQo+PiArewo+PiArIHN0cnVjdCBzZW5zb3JfZGV2aWNlX2F0dHJpYnV0ZSAq
c2RhID0gdG9fc2Vuc29yX2Rldl9hdHRyKGF0dHIpOwo+PiArIHN0cnVjdCBpMmNfY2xpZW50ICpj
bGllbnQgPSB0b19pMmNfY2xpZW50KGRldik7Cj4+ICsgc3RydWN0IHRtcDEwMyAqdG1wMTAzID0g
aTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4+ICsgbG9uZyB2YWw7Cj4+ICsgaW50IHN0YXR1
czsKPj4gKwo+PiArIGlmIChrc3RydG9sKGJ1ZiwgMTAsICZ2YWwpIDwgMCkKPj4gKyByZXR1cm4g
LUVJTlZBTDsKPj4gKyB2YWwgPSBjbGFtcF92YWwodmFsLCAtNTUwMDAsIDEyODAwMCk7Cj4KPiBN
YXggc2hvdWxkIGJlIDEyNzAwMC4KCk9rLCBjaGFuZ2UgdGhpcy4KCj4+ICsKPj4gKyBtdXRleF9s
b2NrKCZ0bXAxMDMtPmxvY2spOwo+PiArIHRtcDEwMy0+dGVtcFtzZGEtPmluZGV4XSA9IHZhbDsK
Pgo+IFlvdSBjYW4gbm90IGRvIHRoYXQgc2luY2UgaXQgaXMgdGhlIG5vbi1yb3VuZGVkIHZhbHVl
LiBZb3UgaGF2ZSB0byBjb252ZXJ0IHRvCj4gdGhlIHJlZ2lzdGVyIHZhbHVlLCB0aGVuIGNvbnZl
cnQgYmFjayB0byB0aGUgZGlzcGxheSB2YWx1ZS4KPgo+IElmIHlvdSB1c2UgcmVnbWFwLCB0aGUg
cHJvYmxlbSBnb2VzIGF3YXksIHNpbmNlIHlvdSB3b3VsZCBub3QgY2FjaGUgY29udmVydGVkCj4g
ZGF0YSBidXQgY29udmVydCBpbiB0aGUgc2hvdyBmdW5jdGlvbi4gQWx0ZXJuYXRpdmVseSwgeW91
IGNvdWxkIHN0b3JlIHJlZ2lzdGVyCj4gdmFsdWVzIGFuZCBjb252ZXJ0IGluIHRoZSBzaG93IGZ1
bmN0aW9uLgoKSSB0YWtlIGEgbG9vayBhdCB0aGlzLgoKPj4gKyBzdGF0dXMgPSBpMmNfc21idXNf
d3JpdGVfYnl0ZV9kYXRhKGNsaWVudCwgdG1wMTAzX3JlZ1tzZGEtPmluZGV4XSwKPj4gKyB0bXAx
MDNfbUNfdG9fcmVnKHZhbCkpOwo+Cj4gUGxlYXNlIG1ha2Ugc3VyZSB0aGF0IGNvbnRpbnVhdGlv
biBsaW5lcyBtYXRjaCB0aGUgJygnIGluIHRoZSBsaW5lIGFib3ZlLgo+IEFsaWdubWVudHMgYXJl
IGluY29uc2lzdGVudCwgb3RoZXJ3aXNlIEkgd291bGQgbm90IG1lbnRpb24gaXQuCj4gY2hlY2tw
YXRjaCAtLXN0cmljdCB0ZWxscyB5b3Ugd2hpY2ggb25lcyBhcmUgbWlzYWxpZ25lZC4KCkFoLCBk
aWQgYSBjaGVja3BhdGNoIGJ1dCB3aXRob3V0IHRoZSAiLS1zdHJpY3QiIG9wdGlvbiAhCgpJIGZp
eCB0aGlzIGdsb2JhbGx5LgoKPj4gKyBtdXRleF91bmxvY2soJnRtcDEwMy0+bG9jayk7Cj4+ICsg
cmV0dXJuIHN0YXR1cyA/IDogY291bnQ7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBTRU5TT1JfREVW
SUNFX0FUVFIodGVtcDFfaW5wdXQsIFNfSVJVR08sIHRtcDEwM19zaG93X3RlbXAsIE5VTEwgLCAw
KTsKPj4gKwo+IElmIHlvdSB1c2UgcmVnbWFwIHlvdSBjYW4gc3RvcmUgdGhlIHJlZ2lzdGVyIGRp
cmVjdGx5IGhlcmUgYW5kIHlvdSB3b3VsZCBub3QKPiBuZWVkIHRtcDEwM19yZWdbXS4KCk9rLgoK
Pj4gK3N0YXRpYyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4X2h5c3QsIFNfSVdVU1IgfCBT
X0lSVUdPLCB0bXAxMDNfc2hvd190ZW1wLAo+PiArIHRtcDEwM19zZXRfdGVtcCwgMSk7Cj4+ICsK
PiBQZXIgdGhlIGRhdGFzaGVldCB0aGlzIHNob3VsZCBiZSB0ZW1wMV9taW4uIFRoZSByZWdpc3Rl
ciBkZWZpbml0aW9uIGlzIGRpZmZlcmVudCB0byBUTVAxMDIuCgpjaGFuZ2VkLgoKPj4gK3N0YXRp
YyBTRU5TT1JfREVWSUNFX0FUVFIodGVtcDFfbWF4LCBTX0lXVVNSIHwgU19JUlVHTywgdG1wMTAz
X3Nob3dfdGVtcCwKPj4gKyB0bXAxMDNfc2V0X3RlbXAsIDIpOwo+PiArCj4+ICtzdGF0aWMgc3Ry
dWN0IGF0dHJpYnV0ZSAqdG1wMTAzX2F0dHJpYnV0ZXNbXSA9IHsKPj4gKyAmc2Vuc29yX2Rldl9h
dHRyX3RlbXAxX2lucHV0LmRldl9hdHRyLmF0dHIsCj4+ICsgJnNlbnNvcl9kZXZfYXR0cl90ZW1w
MV9tYXhfaHlzdC5kZXZfYXR0ci5hdHRyLAo+PiArICZzZW5zb3JfZGV2X2F0dHJfdGVtcDFfbWF4
LmRldl9hdHRyLmF0dHIsCj4KPiBZb3UgbWlnaHQgYWxzbyBjb25zaWRlciBhZGRpbmcgdGVtcDFf
bWluX2FsYXJtIGFuZCB0ZW1wMV9tYXhfYWxhcm0gdG8gaW5mb3JtCj4gdXNlciBzcGFjZSBpZiBs
aW1pdHMgYXJlIGV4Y2VlZGVkLiBUaGUgc3RhdHVzIGlzIHJlcG9ydGVkIHdpdGggdGhlIEZMIGFu
ZCBGSAo+IGJpdHMgaW4gdGhlIGNvbmZpZ3VyYXRpb24gcmVnaXN0ZXIuCgpBZGQgdGhpcyBpZiBJ
IGZpbmQgdGltZSwgb3IgaW4gYW4gYW5vdGhlciBwYXRjaC4uLgoKPj4gKyBOVUxMCj4+ICt9Owo+
PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCB0bXAxMDNfYXR0cl9n
cm91cCA9IHsKPj4gKyAuYXR0cnMgPSB0bXAxMDNfYXR0cmlidXRlcywKPj4gK307Cj4+ICsKPiBQ
bGVhc2UgdXNlIHRoZSBBVFRSSUJVVEVfR1JPVVBTKCkgbWFjcm8uCgpPay4KCj4+ICsjZGVmaW5l
IFRNUDEwM19DT05GSUcgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05GX00xKQo+PiArI2Rl
ZmluZSBUTVAxMDNfQ09ORklHX1JEX09OTFkgKFRNUDEwM19DT05GX0NSMSB8IFRNUDEwM19DT05G
X00xKQo+Cj4gTGF0dGVyIGRlZmluZSBpcyBub3QgdXNlZCBhcyBmYXIgYXMgSSBjYW4gc2VlLiBT
aW5jZSBpdCBpcyB0aGUgc2FtZQo+IGl0IGlzIHVubmVjZXNzYXJ5IGFueXdheS4KCnJlbW92ZWQu
Cgo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xp
ZW50LAo+PiArIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkICppZCkKPj4gK3sKPj4gKyBzdHJ1
Y3QgdG1wMTAzICp0bXAxMDM7Cj4+ICsgaW50IHN0YXR1czsKPj4gKwo+PiArIGlmICghaTJjX2No
ZWNrX2Z1bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+PiArIEkyQ19GVU5DX1NNQlVTX1dP
UkRfREFUQSkpIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwKPj4gKyAiYWRhcHRlciBkb2Vz
bid0IHN1cHBvcnQgU01CdXMgd29yZCB0cmFuc2FjdGlvbnNcbiIpOwo+Cj4gR29vZCB0aGF0IHRo
ZSBjaGlwIGRvZXNuJ3Qgc3VwcG9ydCBhbnkgOy0pLiBDaGVjayBmb3IgYnl0ZSB0cmFuc2FjdGlv
bnMgaW5zdGVhZC4KCkhlaC4uLiBjaGFuZ2VkLgoKPj4gKyByZXR1cm4gLUVOT0RFVjsKPj4gKyB9
Cj4+ICsKPj4gKyB0bXAxMDMgPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ZGV2LCBzaXplb2YoKnRt
cDEwMyksIEdGUF9LRVJORUwpOwo+PiArIGlmICghdG1wMTAzKQo+PiArIHJldHVybiAtRU5PTUVN
Owo+PiArCj4+ICsgaTJjX3NldF9jbGllbnRkYXRhKGNsaWVudCwgdG1wMTAzKTsKPj4gKwo+PiAr
IHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRNUDEwM19DT05GX1JF
Ryk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVy
cm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyByZXR1cm4gc3RhdHVzOwo+PiAr
IH0KPj4gKyB0bXAxMDMtPmNvbmZpZ19vcmlnID0gc3RhdHVzOwo+Cj4gWW91IGRvbid0IHVzZSBj
b25maWdfb3JpZyBvdXRzaWRlIHRoZSBwcm9iZSBmdW5jdGlvbiwKPiBzbyBzdG9yaW5nIGl0IGlu
IHByaXZhdGUgZGF0YSBkb2Vzbid0IGFkZCBhbnkgdmFsdWUuCj4gQWx0ZXJuYXRpdmVseSwgeW91
IGNvdWxkIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGNvbmZpZ3VyYXRpb24gb24gZXhpdC4KCkkgYWRk
ICJyZXN0b3JpbmcgaXQgb24gZXhpdC4iCgo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c193cml0ZV9i
eXRlX2RhdGEoY2xpZW50LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgVE1QMTAzX0NPTkZJRyk7Cj4+
ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGllbnQtPmRldiwgImVycm9yIHdy
aXRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZhaWxfcmVzdG9yZV9jb25maWc7
Cj4+ICsgfQo+PiArIHN0YXR1cyA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIFRN
UDEwM19DT05GX1JFRyk7Cj4+ICsgaWYgKHN0YXR1cyA8IDApIHsKPj4gKyBkZXZfZXJyKCZjbGll
bnQtPmRldiwgImVycm9yIHJlYWRpbmcgY29uZmlnIHJlZ2lzdGVyXG4iKTsKPj4gKyBnb3RvIGZh
aWxfcmVzdG9yZV9jb25maWc7Cj4+ICsgfQo+PiArIGlmIChzdGF0dXMgIT0gVE1QMTAzX0NPTkZJ
Rykgewo+PiArIGRldl9lcnIoJmNsaWVudC0+ZGV2LCAiY29uZmlnIHNldHRpbmdzIGRpZCBub3Qg
c3RpY2tcbiIpOwo+PiArIHN0YXR1cyA9IC1FTk9ERVY7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVf
Y29uZmlnOwo+PiArIH0KPj4gKyB0bXAxMDMtPmxhc3RfdXBkYXRlID0gamlmZmllcyAtIEhaOwo+
PiArIG11dGV4X2luaXQoJnRtcDEwMy0+bG9jayk7Cj4+ICsKPj4gKyBzdGF0dXMgPSBzeXNmc19j
cmVhdGVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsg
aWYgKHN0YXR1cykgewo+PiArIGRldl9kYmcoJmNsaWVudC0+ZGV2LCAiY291bGQgbm90IGNyZWF0
ZSBzeXNmcyBmaWxlc1xuIik7Cj4+ICsgZ290byBmYWlsX3Jlc3RvcmVfY29uZmlnOwo+PiArIH0K
Pj4gKyB0bXAxMDMtPmh3bW9uX2RldiA9IGh3bW9uX2RldmljZV9yZWdpc3RlcigmY2xpZW50LT5k
ZXYpOwo+PiArIGlmIChJU19FUlIodG1wMTAzLT5od21vbl9kZXYpKSB7Cj4+ICsgZGV2X2RiZygm
Y2xpZW50LT5kZXYsICJ1bmFibGUgdG8gcmVnaXN0ZXIgaHdtb24gZGV2aWNlXG4iKTsKPj4gKyBz
dGF0dXMgPSBQVFJfRVJSKHRtcDEwMy0+aHdtb25fZGV2KTsKPj4gKyBnb3RvIGZhaWxfcmVtb3Zl
X3N5c2ZzOwo+PiArIH0KPgo+IFBsZWFzZSB1c2UgZGV2bV9od21vbl9kZXZpY2VfcmVnaXN0ZXJf
d2l0aF9ncm91cHMoKS4KCk9rLgoKPj4gKwo+PiArIGRldl9pbmZvKCZjbGllbnQtPmRldiwgImlu
aXRpYWxpemVkXG4iKTsKPgo+IFBsZWFzZSBkcm9wIHRoaXMgbWVzc2FnZS4KCk9rLgoKPj4gKwo+
PiArIHJldHVybiAwOwo+PiArCj4+ICtmYWlsX3JlbW92ZV9zeXNmczoKPj4gKyBzeXNmc19yZW1v
dmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmosICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICtmYWls
X3Jlc3RvcmVfY29uZmlnOgo+PiArIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50
LCBUTVAxMDNfQ09ORl9SRUcsCj4+ICsgdG1wMTAzLT5jb25maWdfb3JpZyk7Cj4KPiBpMmNfc21i
dXNfd3JpdGVfYnl0ZV9kYXRhKCkgPwoKWWVzLCBjaGFuZ2VkIQoKPj4gKyByZXR1cm4gc3RhdHVz
Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHRtcDEwM19yZW1vdmUoc3RydWN0IGkyY19jbGll
bnQgKmNsaWVudCkKPj4gK3sKPj4gKyBzdHJ1Y3QgdG1wMTAzICp0bXAxMDMgPSBpMmNfZ2V0X2Ns
aWVudGRhdGEoY2xpZW50KTsKPj4gKwo+PiArIGh3bW9uX2RldmljZV91bnJlZ2lzdGVyKHRtcDEw
My0+aHdtb25fZGV2KTsKPj4gKyBzeXNmc19yZW1vdmVfZ3JvdXAoJmNsaWVudC0+ZGV2LmtvYmos
ICZ0bXAxMDNfYXR0cl9ncm91cCk7Cj4+ICsKPj4gKyByZXR1cm4gMDsKPj4gK30KPj4gKwo+PiAr
I2lmZGVmIENPTkZJR19QTQo+PiArc3RhdGljIGludCB0bXAxMDNfc3VzcGVuZChzdHJ1Y3QgZGV2
aWNlICpkZXYpCj4+ICt7Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19j
bGllbnQoZGV2KTsKPj4gKyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVz
X3JlYWRfd29yZF9zd2FwcGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+
PiArIGlmIChjb25maWcgPCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcg
Jj0gflRNUDEwM19DT05GX1NEOwo+PiArIHJldHVybiBpMmNfc21idXNfd3JpdGVfd29yZF9zd2Fw
cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHLCBjb25maWcpOwo+Cj4gYnl0ZQo+Cj4+ICt9Cj4+
ICsKPj4gK3N0YXRpYyBpbnQgdG1wMTAzX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7
Cj4+ICsgc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCA9IHRvX2kyY19jbGllbnQoZGV2KTsKPj4g
KyBpbnQgY29uZmlnOwo+PiArCj4+ICsgY29uZmlnID0gaTJjX3NtYnVzX3JlYWRfd29yZF9zd2Fw
cGVkKGNsaWVudCwgVE1QMTAzX0NPTkZfUkVHKTsKPgo+IGJ5dGUKPgo+PiArIGlmIChjb25maWcg
PCAwKQo+PiArIHJldHVybiBjb25maWc7Cj4+ICsKPj4gKyBjb25maWcgfD0gVE1QMTAzX0NPTkZf
U0Q7Cj4+ICsgcmV0dXJuIGkyY19zbWJ1c193cml0ZV93b3JkX3N3YXBwZWQoY2xpZW50LCBUTVAx
MDNfQ09ORl9SRUcsIGNvbmZpZyk7Cj4KPiBieXRlCgpjaGFuZ2VkLgoKPj4gK30KPj4gKwo+PiAr
c3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIHRtcDEwM19kZXZfcG1fb3BzID0gewo+PiAr
IC5zdXNwZW5kID0gdG1wMTAzX3N1c3BlbmQsCj4+ICsgLnJlc3VtZSA9IHRtcDEwM19yZXN1bWUs
Cj4+ICt9Owo+PiArCj4+ICsjZGVmaW5lIFRNUDEwM19ERVZfUE1fT1BTICgmdG1wMTAzX2Rldl9w
bV9vcHMpCj4+ICsjZWxzZQo+PiArI2RlZmluZSBUTVAxMDNfREVWX1BNX09QUyBOVUxMCj4+ICsj
ZW5kaWYgLyogQ09ORklHX1BNICovCj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaTJjX2Rl
dmljZV9pZCB0bXAxMDNfaWRbXSA9IHsKPj4gKyB7IERSSVZFUl9OQU1FLCAwIH0sCj4+ICsgeyB9
Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklDRV9UQUJMRShpMmMsIHRtcDEwM19pZCk7Cj4+ICsKPj4g
K3N0YXRpYyBzdHJ1Y3QgaTJjX2RyaXZlciB0bXAxMDNfZHJpdmVyID0gewo+PiArIC5kcml2ZXIu
bmFtZSA9IERSSVZFUl9OQU1FLAo+PiArIC5kcml2ZXIucG0gPSBUTVAxMDNfREVWX1BNX09QUywK
Pgo+IC5kcml2ZXIgPSB7Cj4gLm5hbWUgPSBEUklWRVJfTkFNRSwKPiAucG0gPSBUTVAxMDNfREVW
X1BNX09QUywKPiB9LAo+Cj4gd291bGQgYmUgYSBiaXQgbmljZXIuIEkgd29uJ3QgbWFuZGF0ZSBp
dCwgdGhvdWdoLgoKY2hhbmdlZC4KCj4+ICsgLnByb2JlID0gdG1wMTAzX3Byb2JlLAo+PiArIC5y
ZW1vdmUgPSB0bXAxMDNfcmVtb3ZlLAo+PiArIC5pZF90YWJsZSA9IHRtcDEwM19pZCwKPj4gK307
Cj4+ICsKPj4gK21vZHVsZV9pMmNfZHJpdmVyKHRtcDEwM19kcml2ZXIpOwo+PiArCj4+ICtNT0RV
TEVfQVVUSE9SKCJIZWlrbyBTY2hvY2hlciA8aHNAZGVueC5kZT4iKTsKPj4gK01PRFVMRV9ERVND
UklQVElPTigiVGV4YXMgSW5zdHJ1bWVudHMgVE1QMTAzIHRlbXBlcmF0dXJlIHNlbnNvciBkcml2
ZXIiKTsKPj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKClRoYW5rcyBmb3IgdGhpcyBncmVhdCBy
ZXZpZXchCgpieWUsCkhlaWtvCi0tIApERU5YIFNvZnR3YXJlIEVuZ2luZWVyaW5nIEdtYkgsICAg
ICBNRDogV29sZmdhbmcgRGVuayAmIERldGxldiBadW5kZWwKSFJCIDE2NTIzNSBNdW5pY2gsIE9m
ZmljZTogS2lyY2hlbnN0ci41LCBELTgyMTk0IEdyb2ViZW56ZWxsLCBHZXJtYW55CgpfX19fX19f
X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsbS1zZW5zb3JzIG1haWxp
bmcgbGlzdApsbS1zZW5zb3JzQGxtLXNlbnNvcnMub3JnCmh0dHA6Ly9saXN0cy5sbS1zZW5zb3Jz
Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xtLXNlbnNvcnM

Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Heiko Schocher]

Hello Guenter,

Am 11.06.2014 19:11, schrieb Guenter Roeck:
> 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.

Ok, I remove them.

> Why patch 09/13 ? I'd expect to see 12 more patches in this series,

Hups, sorry, my mistake, there is just this patch...

> 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.

Hmm.. I did this first there, but "scripts/checkpatch.pl"
warns (if using a DT based board with compatible = "ti,tmp103"):

WARNING: DT compatible string "ti,tmp103" appears un-documented -- check ./Documentation/devicetree/bindings/
#324: FILE: arch/arm/boot/dts/imx6qdl-aristainetos.dtsi:107:
+               compatible = "ti,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).

Ok.

> 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.

Ah, ok, good idea, this removes also the checkpatch warning, thanks!
Changed.

> 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.

Ok.

[...]
>> 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.

Ok ... hmm, wondering that checkpatch.pl not claimed this.
removed.

>> +}
>> +
>> +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).

you mean ERR_PTR() ?
Ok, add this.

>> + }
>> + 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.

Could you give me an example?

>> +
>> +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.

Ok, change this.

>> +
>> + 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.

I take a look at this.

>> + 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.

Ah, did a checkpatch but without the "--strict" option !

I fix this globally.

>> + 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[].

Ok.

>> +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.

changed.

>> +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.

Add this if I find time, or in an another patch...

>> + NULL
>> +};
>> +
>> +static const struct attribute_group tmp103_attr_group = {
>> + .attrs = tmp103_attributes,
>> +};
>> +
> Please use the ATTRIBUTE_GROUPS() macro.

Ok.

>> +#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.

removed.

>> +
>> +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.

Heh... changed.

>> + 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.

I add "restoring it 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().

Ok.

>> +
>> + dev_info(&client->dev, "initialized\n");
>
> Please drop this message.

Ok.

>> +
>> + 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() ?

Yes, changed!

>> + 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

changed.

>> +}
>> +
>> +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.

changed.

>> + .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");

Thanks for this great review!

bye,
Heiko
-- 
DENX Software Engineering GmbH,     MD: Wolfgang Denk & Detlev Zundel
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany

Re: [lm-sensors] [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Guenter Roeck]

On 06/12/2014 02:39 AM, Heiko Schocher wrote:
> Hello Guenter,
[ ... ]
>>
>> 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.
>
> Could you give me an example?
>
Hello Heiko,

check for the use of regmap in drivers/hwmon. Any of the drivers using it can serve
as example.

Guenter


_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

Re: [PATCH 09/13] hwmon: Driver for TI TMP103 temperature sensor

[Guenter Roeck]

On 06/12/2014 02:39 AM, Heiko Schocher wrote:
> Hello Guenter,
[ ... ]
>>
>> 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.
>
> Could you give me an example?
>
Hello Heiko,

check for the use of regmap in drivers/hwmon. Any of the drivers using it can serve
as example.

Guenter