hwmon: Driver for TI ADC128D818

ADC128D818 is a System Monitor with Temperature Sensor. It is similar to LM80 and LM96080, but has 16 bit wide sensor registers and no fan speed monitoring. Signed-off-by: Guenter Roeck <linux@roeck-us.net>

hwmon: Driver for TI ADC128D818
ADC128D818 is a System Monitor with Temperature Sensor. It is similar to LM80 and LM96080, but has 16 bit wide sensor registers and no fan speed monitoring. Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Guenter Roeck
1 parent ebf5e87791
Showing 4 changed files with 549 additions and 0 deletions Side-by-side Diff
Documentation/hwmon/adc128d818
drivers/hwmon/Kconfig
drivers/hwmon/Makefile
drivers/hwmon/adc128d818.c
+Kernel driver adc128d818
+========================
+
+Supported chips:
+  * Texas Instruments ADC818D818
+    Prefix: 'adc818d818'
+    Addresses scanned: I2C 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f
+    Datasheet: Publicly available at the TI website
+               http://www.ti.com/
+
+Author: Guenter Roeck
+
+Description
+-----------
+
+This driver implements support for the Texas Instruments ADC128D818.
+It is described as 'ADC System Monitor with Temperature Sensor'.
+
+The ADC128D818 implements one temperature sensor and seven voltage sensors.
+
+Temperatures are measured in degrees Celsius. There is one set of limits.
+When the HOT Temperature Limit is crossed, this will cause an alarm that will
+be reasserted until the temperature drops below the HOT Hysteresis.
+Measurements are guaranteed between -55 and +125 degrees. The temperature
+measurement has a resolution of 0.5 degrees; the limits have a resolution
+of 1 degree.
+
+Voltage sensors (also known as IN sensors) report their values in volts.
+An alarm is triggered if the voltage has crossed a programmable minimum
+or maximum limit. Note that minimum in this case always means 'closest to
+zero'; this is important for negative voltage measurements. All voltage
+inputs can measure voltages between 0 and 2.55 volts, with a resolution
+of 0.625 mV.
+
+If an alarm triggers, it will remain triggered until the hardware register
+is read at least once. This means that the cause for the alarm may
+already have disappeared by the time the alarm is read. The driver
+caches the alarm status for each sensor until it is at least reported
+once, to ensure that alarms are reported to user space.
+
+The ADC128D818 only updates its values approximately once per second;
+reading it more often will do no harm, but will return 'old' values.
+
+In addition to the scanned address list, the chip can also be configured for
+addresses 0x35 to 0x37. Those addresses are not scanned. You have to instantiate
+the driver explicitly if the chip is configured for any of those addresses in
+your system.
@@ -1277,6 +1277,16 @@
 	  This driver can also be built as a module. If so, the module will
 	  be called smm665.
  
+config SENSORS_ADC128D818
+	tristate "Texas Instruments ADC128D818"
+	depends on I2C
+	help
+	  If you say yes here you get support for the Texas Instruments
+	  ADC128D818 System Monitor with Temperature Sensor chip.
+
+	  This driver can also be built as a module. If so, the module
+	  will be called adc128d818.
+
 config SENSORS_ADS1015
 	tristate "Texas Instruments ADS1015"
 	depends on I2C
@@ -25,6 +25,7 @@
 obj-$(CONFIG_SENSORS_AD7314)	+= ad7314.o
 obj-$(CONFIG_SENSORS_AD7414)	+= ad7414.o
 obj-$(CONFIG_SENSORS_AD7418)	+= ad7418.o
+obj-$(CONFIG_SENSORS_ADC128D818) += adc128d818.o
 obj-$(CONFIG_SENSORS_ADCXX)	+= adcxx.o
 obj-$(CONFIG_SENSORS_ADM1021)	+= adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)	+= adm1025.o
+/*
+ * Driver for TI ADC128D818 System Monitor with Temperature Sensor
+ *
+ * Copyright (c) 2014 Guenter Roeck
+ *
+ * Derived from lm80.c
+ * Copyright (C) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+ *			     and Philip Edelbrock <phil@netroedge.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/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/regulator/consumer.h>
+#include <linux/mutex.h>
+
+/* Addresses to scan
+ * The chip also supports addresses 0x35..0x37. Don't scan those addresses
+ * since they are also used by some EEPROMs, which may result in false
+ * positives.
+ */
+static const unsigned short normal_i2c[] = {
+	0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
+
+/* registers */
+#define ADC128_REG_IN_MAX(nr)		(0x2a + (nr) * 2)
+#define ADC128_REG_IN_MIN(nr)		(0x2b + (nr) * 2)
+#define ADC128_REG_IN(nr)		(0x20 + (nr))
+
+#define ADC128_REG_TEMP			0x27
+#define ADC128_REG_TEMP_MAX		0x38
+#define ADC128_REG_TEMP_HYST		0x39
+
+#define ADC128_REG_CONFIG		0x00
+#define ADC128_REG_ALARM		0x01
+#define ADC128_REG_MASK			0x03
+#define ADC128_REG_CONV_RATE		0x07
+#define ADC128_REG_ONESHOT		0x09
+#define ADC128_REG_SHUTDOWN		0x0a
+#define ADC128_REG_CONFIG_ADV		0x0b
+#define ADC128_REG_BUSY_STATUS		0x0c
+
+#define ADC128_REG_MAN_ID		0x3e
+#define ADC128_REG_DEV_ID		0x3f
+
+struct adc128_data {
+	struct i2c_client *client;
+	struct regulator *regulator;
+	int vref;		/* Reference voltage in mV */
+	struct mutex update_lock;
+	bool valid;		/* true if following fields are valid */
+	unsigned long last_updated;	/* In jiffies */
+
+	u16 in[3][7];		/* Register value, normalized to 12 bit
+				 * 0: input voltage
+				 * 1: min limit
+				 * 2: max limit
+				 */
+	s16 temp[3];		/* Register value, normalized to 9 bit
+				 * 0: sensor 1: limit 2: hyst
+				 */
+	u8 alarms;		/* alarm register value */
+};
+
+static struct adc128_data *adc128_update_device(struct device *dev)
+{
+	struct adc128_data *data = dev_get_drvdata(dev);
+	struct i2c_client *client = data->client;
+	struct adc128_data *ret = data;
+	int i, rv;
+
+	mutex_lock(&data->update_lock);
+
+	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+		for (i = 0; i < 7; i++) {
+			rv = i2c_smbus_read_word_swapped(client,
+							 ADC128_REG_IN(i));
+			if (rv < 0)
+				goto abort;
+			data->in[0][i] = rv >> 4;
+
+			rv = i2c_smbus_read_byte_data(client,
+						      ADC128_REG_IN_MIN(i));
+			if (rv < 0)
+				goto abort;
+			data->in[1][i] = rv << 4;
+
+			rv = i2c_smbus_read_byte_data(client,
+						      ADC128_REG_IN_MAX(i));
+			if (rv < 0)
+				goto abort;
+			data->in[2][i] = rv << 4;
+		}
+
+		rv = i2c_smbus_read_word_swapped(client, ADC128_REG_TEMP);
+		if (rv < 0)
+			goto abort;
+		data->temp[0] = rv >> 7;
+
+		rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_MAX);
+		if (rv < 0)
+			goto abort;
+		data->temp[1] = rv << 1;
+
+		rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_HYST);
+		if (rv < 0)
+			goto abort;
+		data->temp[2] = rv << 1;
+
+		rv = i2c_smbus_read_byte_data(client, ADC128_REG_ALARM);
+		if (rv < 0)
+			goto abort;
+		data->alarms |= rv;
+
+		data->last_updated = jiffies;
+		data->valid = true;
+	}
+	goto done;
+
+abort:
+	ret = ERR_PTR(rv);
+	data->valid = false;
+done:
+	mutex_unlock(&data->update_lock);
+	return ret;
+}
+
+static ssize_t adc128_show_in(struct device *dev, struct device_attribute *attr,
+			      char *buf)
+{
+	struct adc128_data *data = adc128_update_device(dev);
+	int index = to_sensor_dev_attr_2(attr)->index;
+	int nr = to_sensor_dev_attr_2(attr)->nr;
+	int val;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	val = DIV_ROUND_CLOSEST(data->in[index][nr] * data->vref, 4095);
+	return sprintf(buf, "%d\n", val);
+}
+
+static ssize_t adc128_set_in(struct device *dev, struct device_attribute *attr,
+			     const char *buf, size_t count)
+{
+	struct adc128_data *data = dev_get_drvdata(dev);
+	int index = to_sensor_dev_attr_2(attr)->index;
+	int nr = to_sensor_dev_attr_2(attr)->nr;
+	u8 reg, regval;
+	long val;
+	int err;
+
+	err = kstrtol(buf, 10, &val);
+	if (err < 0)
+		return err;
+
+	mutex_lock(&data->update_lock);
+	/* 10 mV LSB on limit registers */
+	regval = clamp_val(DIV_ROUND_CLOSEST(val, 10), 0, 255);
+	data->in[index][nr] = regval << 4;
+	reg = index == 1 ? ADC128_REG_IN_MIN(nr) : ADC128_REG_IN_MAX(nr);
+	i2c_smbus_write_byte_data(data->client, reg, regval);
+	mutex_unlock(&data->update_lock);
+
+	return count;
+}
+
+static ssize_t adc128_show_temp(struct device *dev,
+				struct device_attribute *attr, char *buf)
+{
+	struct adc128_data *data = adc128_update_device(dev);
+	int index = to_sensor_dev_attr(attr)->index;
+	int temp;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	temp = (data->temp[index] << 7) >> 7;	/* sign extend */
+	return sprintf(buf, "%d\n", temp * 500);/* 0.5 degrees C resolution */
+}
+
+static ssize_t adc128_set_temp(struct device *dev,
+			       struct device_attribute *attr,
+			       const char *buf, size_t count)
+{
+	struct adc128_data *data = dev_get_drvdata(dev);
+	int index = to_sensor_dev_attr(attr)->index;
+	long val;
+	int err;
+	s8 regval;
+
+	err = kstrtol(buf, 10, &val);
+	if (err < 0)
+		return err;
+
+	mutex_lock(&data->update_lock);
+	regval = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
+	data->temp[index] = regval << 1;
+	i2c_smbus_write_byte_data(data->client,
+				  index == 1 ? ADC128_REG_TEMP_MAX
+					     : ADC128_REG_TEMP_HYST,
+				  regval);
+	mutex_unlock(&data->update_lock);
+
+	return count;
+}
+
+static ssize_t adc128_show_alarm(struct device *dev,
+				 struct device_attribute *attr, char *buf)
+{
+	struct adc128_data *data = adc128_update_device(dev);
+	int mask = 1 << to_sensor_dev_attr(attr)->index;
+	u8 alarms;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	/*
+	 * Clear an alarm after reporting it to user space. If it is still
+	 * active, the next update sequence will set the alarm bit again.
+	 */
+	alarms = data->alarms;
+	data->alarms &= ~mask;
+
+	return sprintf(buf, "%u\n", !!(alarms & mask));
+}
+
+static SENSOR_DEVICE_ATTR_2(in0_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 0, 0);
+static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 0, 1);
+static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 0, 2);
+
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 1, 0);
+static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 1, 1);
+static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 1, 2);
+
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 2, 0);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 2, 1);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 2, 2);
+
+static SENSOR_DEVICE_ATTR_2(in3_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 3, 0);
+static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 3, 1);
+static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 3, 2);
+
+static SENSOR_DEVICE_ATTR_2(in4_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 4, 0);
+static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 4, 1);
+static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 4, 2);
+
+static SENSOR_DEVICE_ATTR_2(in5_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 5, 0);
+static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 5, 1);
+static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 5, 2);
+
+static SENSOR_DEVICE_ATTR_2(in6_input, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 6, 0);
+static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 6, 1);
+static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR | S_IRUGO,
+			    adc128_show_in, adc128_set_in, 6, 2);
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, adc128_show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+			  adc128_show_temp, adc128_set_temp, 1);
+static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
+			  adc128_show_temp, adc128_set_temp, 2);
+
+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, adc128_show_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, adc128_show_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, adc128_show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, adc128_show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, adc128_show_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, adc128_show_alarm, NULL, 5);
+static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, adc128_show_alarm, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, adc128_show_alarm, NULL, 7);
+
+static struct attribute *adc128_attrs[] = {
+	&sensor_dev_attr_in0_min.dev_attr.attr,
+	&sensor_dev_attr_in1_min.dev_attr.attr,
+	&sensor_dev_attr_in2_min.dev_attr.attr,
+	&sensor_dev_attr_in3_min.dev_attr.attr,
+	&sensor_dev_attr_in4_min.dev_attr.attr,
+	&sensor_dev_attr_in5_min.dev_attr.attr,
+	&sensor_dev_attr_in6_min.dev_attr.attr,
+	&sensor_dev_attr_in0_max.dev_attr.attr,
+	&sensor_dev_attr_in1_max.dev_attr.attr,
+	&sensor_dev_attr_in2_max.dev_attr.attr,
+	&sensor_dev_attr_in3_max.dev_attr.attr,
+	&sensor_dev_attr_in4_max.dev_attr.attr,
+	&sensor_dev_attr_in5_max.dev_attr.attr,
+	&sensor_dev_attr_in6_max.dev_attr.attr,
+	&sensor_dev_attr_in0_input.dev_attr.attr,
+	&sensor_dev_attr_in1_input.dev_attr.attr,
+	&sensor_dev_attr_in2_input.dev_attr.attr,
+	&sensor_dev_attr_in3_input.dev_attr.attr,
+	&sensor_dev_attr_in4_input.dev_attr.attr,
+	&sensor_dev_attr_in5_input.dev_attr.attr,
+	&sensor_dev_attr_in6_input.dev_attr.attr,
+	&sensor_dev_attr_temp1_input.dev_attr.attr,
+	&sensor_dev_attr_temp1_max.dev_attr.attr,
+	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
+	&sensor_dev_attr_in0_alarm.dev_attr.attr,
+	&sensor_dev_attr_in1_alarm.dev_attr.attr,
+	&sensor_dev_attr_in2_alarm.dev_attr.attr,
+	&sensor_dev_attr_in3_alarm.dev_attr.attr,
+	&sensor_dev_attr_in4_alarm.dev_attr.attr,
+	&sensor_dev_attr_in5_alarm.dev_attr.attr,
+	&sensor_dev_attr_in6_alarm.dev_attr.attr,
+	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+	NULL
+};
+ATTRIBUTE_GROUPS(adc128);
+
+static int adc128_detect(struct i2c_client *client, struct i2c_board_info *info)
+{
+	int man_id, dev_id;
+
+	if (!i2c_check_functionality(client->adapter,
+				     I2C_FUNC_SMBUS_BYTE_DATA |
+				     I2C_FUNC_SMBUS_WORD_DATA))
+		return -ENODEV;
+
+	man_id = i2c_smbus_read_byte_data(client, ADC128_REG_MAN_ID);
+	dev_id = i2c_smbus_read_byte_data(client, ADC128_REG_DEV_ID);
+	if (man_id != 0x01 || dev_id != 0x09)
+		return -ENODEV;
+
+	/* Check unused bits for confirmation */
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG) & 0xf4)
+		return -ENODEV;
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_CONV_RATE) & 0xfe)
+		return -ENODEV;
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_ONESHOT) & 0xfe)
+		return -ENODEV;
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_SHUTDOWN) & 0xfe)
+		return -ENODEV;
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV) & 0xf8)
+		return -ENODEV;
+	if (i2c_smbus_read_byte_data(client, ADC128_REG_BUSY_STATUS) & 0xfc)
+		return -ENODEV;
+
+	strlcpy(info->type, "adc128d818", I2C_NAME_SIZE);
+
+	return 0;
+}
+
+static int adc128_init_client(struct adc128_data *data)
+{
+	struct i2c_client *client = data->client;
+	int err;
+
+	/*
+	 * Reset chip to defaults.
+	 * This makes most other initializations unnecessary.
+	 */
+	err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x80);
+	if (err)
+		return err;
+
+	/* Start monitoring */
+	err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x01);
+	if (err)
+		return err;
+
+	/* If external vref is selected, configure the chip to use it */
+	if (data->regulator) {
+		err = i2c_smbus_write_byte_data(client,
+						ADC128_REG_CONFIG_ADV, 0x01);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+static int adc128_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct device *dev = &client->dev;
+	struct regulator *regulator;
+	struct device *hwmon_dev;
+	struct adc128_data *data;
+	int err, vref;
+
+	data = devm_kzalloc(dev, sizeof(struct adc128_data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	/* vref is optional. If specified, is used as chip reference voltage */
+	regulator = devm_regulator_get_optional(dev, "vref");
+	if (!IS_ERR(regulator)) {
+		data->regulator = regulator;
+		err = regulator_enable(regulator);
+		if (err < 0)
+			return err;
+		vref = regulator_get_voltage(regulator);
+		if (vref < 0) {
+			err = vref;
+			goto error;
+		}
+		data->vref = DIV_ROUND_CLOSEST(vref, 1000);
+	} else {
+		data->vref = 2560;	/* 2.56V, in mV */
+	}
+
+	data->client = client;
+	i2c_set_clientdata(client, data);
+	mutex_init(&data->update_lock);
+
+	/* Initialize the chip */
+	err = adc128_init_client(data);
+	if (err < 0)
+		goto error;
+
+	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
+							   data, adc128_groups);
+	if (IS_ERR(hwmon_dev)) {
+		err = PTR_ERR(hwmon_dev);
+		goto error;
+	}
+
+	return 0;
+
+error:
+	if (data->regulator)
+		regulator_disable(data->regulator);
+	return err;
+}
+
+static int adc128_remove(struct i2c_client *client)
+{
+	struct adc128_data *data = i2c_get_clientdata(client);
+
+	if (data->regulator)
+		regulator_disable(data->regulator);
+
+	return 0;
+}
+
+static const struct i2c_device_id adc128_id[] = {
+	{ "adc128d818", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, adc128_id);
+
+static struct i2c_driver adc128_driver = {
+	.class		= I2C_CLASS_HWMON,
+	.driver = {
+		.name	= "adc128d818",
+	},
+	.probe		= adc128_probe,
+	.remove		= adc128_remove,
+	.id_table	= adc128_id,
+	.detect		= adc128_detect,
+	.address_list	= normal_i2c,
+};
+
+module_i2c_driver(adc128_driver);
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("Driver for ADC128D818");
+MODULE_LICENSE("GPL");
	1	+Kernel driver adc128d818
	2	+========================
	3	+
	4	+Supported chips:
	5	+ * Texas Instruments ADC818D818
	6	+ Prefix: 'adc818d818'
	7	+ Addresses scanned: I2C 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f
	8	+ Datasheet: Publicly available at the TI website
	9	+ http://www.ti.com/
	10	+
	11	+Author: Guenter Roeck
	12	+
	13	+Description
	14	+-----------
	15	+
	16	+This driver implements support for the Texas Instruments ADC128D818.
	17	+It is described as 'ADC System Monitor with Temperature Sensor'.
	18	+
	19	+The ADC128D818 implements one temperature sensor and seven voltage sensors.
	20	+
	21	+Temperatures are measured in degrees Celsius. There is one set of limits.
	22	+When the HOT Temperature Limit is crossed, this will cause an alarm that will
	23	+be reasserted until the temperature drops below the HOT Hysteresis.
	24	+Measurements are guaranteed between -55 and +125 degrees. The temperature
	25	+measurement has a resolution of 0.5 degrees; the limits have a resolution
	26	+of 1 degree.
	27	+
	28	+Voltage sensors (also known as IN sensors) report their values in volts.
	29	+An alarm is triggered if the voltage has crossed a programmable minimum
	30	+or maximum limit. Note that minimum in this case always means 'closest to
	31	+zero'; this is important for negative voltage measurements. All voltage
	32	+inputs can measure voltages between 0 and 2.55 volts, with a resolution
	33	+of 0.625 mV.
	34	+
	35	+If an alarm triggers, it will remain triggered until the hardware register
	36	+is read at least once. This means that the cause for the alarm may
	37	+already have disappeared by the time the alarm is read. The driver
	38	+caches the alarm status for each sensor until it is at least reported
	39	+once, to ensure that alarms are reported to user space.
	40	+
	41	+The ADC128D818 only updates its values approximately once per second;
	42	+reading it more often will do no harm, but will return 'old' values.
	43	+
	44	+In addition to the scanned address list, the chip can also be configured for
	45	+addresses 0x35 to 0x37. Those addresses are not scanned. You have to instantiate
	46	+the driver explicitly if the chip is configured for any of those addresses in
	47	+your system.
...	...	@@ -1277,6 +1277,16 @@
1277	1277	This driver can also be built as a module. If so, the module will
1278	1278	be called smm665.
1279	1279
	1280	+config SENSORS_ADC128D818
	1281	+ tristate "Texas Instruments ADC128D818"
	1282	+ depends on I2C
	1283	+ help
	1284	+ If you say yes here you get support for the Texas Instruments
	1285	+ ADC128D818 System Monitor with Temperature Sensor chip.
	1286	+
	1287	+ This driver can also be built as a module. If so, the module
	1288	+ will be called adc128d818.
	1289	+
1280	1290	config SENSORS_ADS1015
1281	1291	tristate "Texas Instruments ADS1015"
1282	1292	depends on I2C
...	...	@@ -25,6 +25,7 @@
25	25	obj-$(CONFIG_SENSORS_AD7314) += ad7314.o
26	26	obj-$(CONFIG_SENSORS_AD7414) += ad7414.o
27	27	obj-$(CONFIG_SENSORS_AD7418) += ad7418.o
	28	+obj-$(CONFIG_SENSORS_ADC128D818) += adc128d818.o
28	29	obj-$(CONFIG_SENSORS_ADCXX) += adcxx.o
29	30	obj-$(CONFIG_SENSORS_ADM1021) += adm1021.o
30	31	obj-$(CONFIG_SENSORS_ADM1025) += adm1025.o
	1	+/*
	2	+ * Driver for TI ADC128D818 System Monitor with Temperature Sensor
	3	+ *
	4	+ * Copyright (c) 2014 Guenter Roeck
	5	+ *
	6	+ * Derived from lm80.c
	7	+ * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
	8	+ * and Philip Edelbrock <phil@netroedge.com>
	9	+ *
	10	+ * This program is free software; you can redistribute it and/or modify
	11	+ * it under the terms of the GNU General Public License as published by
	12	+ * the Free Software Foundation; either version 2 of the License, or
	13	+ * (at your option) any later version.
	14	+ *
	15	+ * This program is distributed in the hope that it will be useful,
	16	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	+ * GNU General Public License for more details.
	19	+ */
	20	+
	21	+#include <linux/module.h>
	22	+#include <linux/slab.h>
	23	+#include <linux/jiffies.h>
	24	+#include <linux/i2c.h>
	25	+#include <linux/hwmon.h>
	26	+#include <linux/hwmon-sysfs.h>
	27	+#include <linux/err.h>
	28	+#include <linux/regulator/consumer.h>
	29	+#include <linux/mutex.h>
	30	+
	31	+/* Addresses to scan
	32	+ * The chip also supports addresses 0x35..0x37. Don't scan those addresses
	33	+ * since they are also used by some EEPROMs, which may result in false
	34	+ * positives.
	35	+ */
	36	+static const unsigned short normal_i2c[] = {
	37	+ 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
	38	+
	39	+/* registers */
	40	+#define ADC128_REG_IN_MAX(nr) (0x2a + (nr) * 2)
	41	+#define ADC128_REG_IN_MIN(nr) (0x2b + (nr) * 2)
	42	+#define ADC128_REG_IN(nr) (0x20 + (nr))
	43	+
	44	+#define ADC128_REG_TEMP 0x27
	45	+#define ADC128_REG_TEMP_MAX 0x38
	46	+#define ADC128_REG_TEMP_HYST 0x39
	47	+
	48	+#define ADC128_REG_CONFIG 0x00
	49	+#define ADC128_REG_ALARM 0x01
	50	+#define ADC128_REG_MASK 0x03
	51	+#define ADC128_REG_CONV_RATE 0x07
	52	+#define ADC128_REG_ONESHOT 0x09
	53	+#define ADC128_REG_SHUTDOWN 0x0a
	54	+#define ADC128_REG_CONFIG_ADV 0x0b
	55	+#define ADC128_REG_BUSY_STATUS 0x0c
	56	+
	57	+#define ADC128_REG_MAN_ID 0x3e
	58	+#define ADC128_REG_DEV_ID 0x3f
	59	+
	60	+struct adc128_data {
	61	+ struct i2c_client *client;
	62	+ struct regulator *regulator;
	63	+ int vref; /* Reference voltage in mV */
	64	+ struct mutex update_lock;
	65	+ bool valid; /* true if following fields are valid */
	66	+ unsigned long last_updated; /* In jiffies */
	67	+
	68	+ u16 in[3][7]; /* Register value, normalized to 12 bit
	69	+ * 0: input voltage
	70	+ * 1: min limit
	71	+ * 2: max limit
	72	+ */
	73	+ s16 temp[3]; /* Register value, normalized to 9 bit
	74	+ * 0: sensor 1: limit 2: hyst
	75	+ */
	76	+ u8 alarms; /* alarm register value */
	77	+};
	78	+
	79	+static struct adc128_data adc128_update_device(struct device dev)
	80	+{
	81	+ struct adc128_data *data = dev_get_drvdata(dev);
	82	+ struct i2c_client *client = data->client;
	83	+ struct adc128_data *ret = data;
	84	+ int i, rv;
	85	+
	86	+ mutex_lock(&data->update_lock);
	87	+
	88	+ if (time_after(jiffies, data->last_updated + HZ) \|\| !data->valid) {
	89	+ for (i = 0; i < 7; i++) {
	90	+ rv = i2c_smbus_read_word_swapped(client,
	91	+ ADC128_REG_IN(i));
	92	+ if (rv < 0)
	93	+ goto abort;
	94	+ data->in[0][i] = rv >> 4;
	95	+
	96	+ rv = i2c_smbus_read_byte_data(client,
	97	+ ADC128_REG_IN_MIN(i));
	98	+ if (rv < 0)
	99	+ goto abort;
	100	+ data->in[1][i] = rv << 4;
	101	+
	102	+ rv = i2c_smbus_read_byte_data(client,
	103	+ ADC128_REG_IN_MAX(i));
	104	+ if (rv < 0)
	105	+ goto abort;
	106	+ data->in[2][i] = rv << 4;
	107	+ }
	108	+
	109	+ rv = i2c_smbus_read_word_swapped(client, ADC128_REG_TEMP);
	110	+ if (rv < 0)
	111	+ goto abort;
	112	+ data->temp[0] = rv >> 7;
	113	+
	114	+ rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_MAX);
	115	+ if (rv < 0)
	116	+ goto abort;
	117	+ data->temp[1] = rv << 1;
	118	+
	119	+ rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_HYST);
	120	+ if (rv < 0)
	121	+ goto abort;
	122	+ data->temp[2] = rv << 1;
	123	+
	124	+ rv = i2c_smbus_read_byte_data(client, ADC128_REG_ALARM);
	125	+ if (rv < 0)
	126	+ goto abort;
	127	+ data->alarms \|= rv;
	128	+
	129	+ data->last_updated = jiffies;
	130	+ data->valid = true;
	131	+ }
	132	+ goto done;
	133	+
	134	+abort:
	135	+ ret = ERR_PTR(rv);
	136	+ data->valid = false;
	137	+done:
	138	+ mutex_unlock(&data->update_lock);
	139	+ return ret;
	140	+}
	141	+
	142	+static ssize_t adc128_show_in(struct device dev, struct device_attribute attr,
	143	+ char *buf)
	144	+{
	145	+ struct adc128_data *data = adc128_update_device(dev);
	146	+ int index = to_sensor_dev_attr_2(attr)->index;
	147	+ int nr = to_sensor_dev_attr_2(attr)->nr;
	148	+ int val;
	149	+
	150	+ if (IS_ERR(data))
	151	+ return PTR_ERR(data);
	152	+
	153	+ val = DIV_ROUND_CLOSEST(data->in[index][nr] * data->vref, 4095);
	154	+ return sprintf(buf, "%d\n", val);
	155	+}
	156	+
	157	+static ssize_t adc128_set_in(struct device dev, struct device_attribute attr,
	158	+ const char *buf, size_t count)
	159	+{
	160	+ struct adc128_data *data = dev_get_drvdata(dev);
	161	+ int index = to_sensor_dev_attr_2(attr)->index;
	162	+ int nr = to_sensor_dev_attr_2(attr)->nr;
	163	+ u8 reg, regval;
	164	+ long val;
	165	+ int err;
	166	+
	167	+ err = kstrtol(buf, 10, &val);
	168	+ if (err < 0)
	169	+ return err;
	170	+
	171	+ mutex_lock(&data->update_lock);
	172	+ /* 10 mV LSB on limit registers */
	173	+ regval = clamp_val(DIV_ROUND_CLOSEST(val, 10), 0, 255);
	174	+ data->in[index][nr] = regval << 4;
	175	+ reg = index == 1 ? ADC128_REG_IN_MIN(nr) : ADC128_REG_IN_MAX(nr);
	176	+ i2c_smbus_write_byte_data(data->client, reg, regval);
	177	+ mutex_unlock(&data->update_lock);
	178	+
	179	+ return count;
	180	+}
	181	+
	182	+static ssize_t adc128_show_temp(struct device *dev,
	183	+ struct device_attribute attr, char buf)
	184	+{
	185	+ struct adc128_data *data = adc128_update_device(dev);
	186	+ int index = to_sensor_dev_attr(attr)->index;
	187	+ int temp;
	188	+
	189	+ if (IS_ERR(data))
	190	+ return PTR_ERR(data);
	191	+
	192	+ temp = (data->temp[index] << 7) >> 7; /* sign extend */
	193	+ return sprintf(buf, "%d\n", temp * 500);/* 0.5 degrees C resolution */
	194	+}
	195	+
	196	+static ssize_t adc128_set_temp(struct device *dev,
	197	+ struct device_attribute *attr,
	198	+ const char *buf, size_t count)
	199	+{
	200	+ struct adc128_data *data = dev_get_drvdata(dev);
	201	+ int index = to_sensor_dev_attr(attr)->index;
	202	+ long val;
	203	+ int err;
	204	+ s8 regval;
	205	+
	206	+ err = kstrtol(buf, 10, &val);
	207	+ if (err < 0)
	208	+ return err;
	209	+
	210	+ mutex_lock(&data->update_lock);
	211	+ regval = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
	212	+ data->temp[index] = regval << 1;
	213	+ i2c_smbus_write_byte_data(data->client,
	214	+ index == 1 ? ADC128_REG_TEMP_MAX
	215	+ : ADC128_REG_TEMP_HYST,
	216	+ regval);
	217	+ mutex_unlock(&data->update_lock);
	218	+
	219	+ return count;
	220	+}
	221	+
	222	+static ssize_t adc128_show_alarm(struct device *dev,
	223	+ struct device_attribute attr, char buf)
	224	+{
	225	+ struct adc128_data *data = adc128_update_device(dev);
	226	+ int mask = 1 << to_sensor_dev_attr(attr)->index;
	227	+ u8 alarms;
	228	+
	229	+ if (IS_ERR(data))
	230	+ return PTR_ERR(data);
	231	+
	232	+ /*
	233	+ * Clear an alarm after reporting it to user space. If it is still
	234	+ * active, the next update sequence will set the alarm bit again.
	235	+ */
	236	+ alarms = data->alarms;
	237	+ data->alarms &= ~mask;
	238	+
	239	+ return sprintf(buf, "%u\n", !!(alarms & mask));
	240	+}
	241	+
	242	+static SENSOR_DEVICE_ATTR_2(in0_input, S_IWUSR \| S_IRUGO,
	243	+ adc128_show_in, adc128_set_in, 0, 0);
	244	+static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR \| S_IRUGO,
	245	+ adc128_show_in, adc128_set_in, 0, 1);
	246	+static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR \| S_IRUGO,
	247	+ adc128_show_in, adc128_set_in, 0, 2);
	248	+
	249	+static SENSOR_DEVICE_ATTR_2(in1_input, S_IWUSR \| S_IRUGO,
	250	+ adc128_show_in, adc128_set_in, 1, 0);
	251	+static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR \| S_IRUGO,
	252	+ adc128_show_in, adc128_set_in, 1, 1);
	253	+static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR \| S_IRUGO,
	254	+ adc128_show_in, adc128_set_in, 1, 2);
	255	+
	256	+static SENSOR_DEVICE_ATTR_2(in2_input, S_IWUSR \| S_IRUGO,
	257	+ adc128_show_in, adc128_set_in, 2, 0);
	258	+static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR \| S_IRUGO,
	259	+ adc128_show_in, adc128_set_in, 2, 1);
	260	+static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR \| S_IRUGO,
	261	+ adc128_show_in, adc128_set_in, 2, 2);
	262	+
	263	+static SENSOR_DEVICE_ATTR_2(in3_input, S_IWUSR \| S_IRUGO,
	264	+ adc128_show_in, adc128_set_in, 3, 0);
	265	+static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR \| S_IRUGO,
	266	+ adc128_show_in, adc128_set_in, 3, 1);
	267	+static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR \| S_IRUGO,
	268	+ adc128_show_in, adc128_set_in, 3, 2);
	269	+
	270	+static SENSOR_DEVICE_ATTR_2(in4_input, S_IWUSR \| S_IRUGO,
	271	+ adc128_show_in, adc128_set_in, 4, 0);
	272	+static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR \| S_IRUGO,
	273	+ adc128_show_in, adc128_set_in, 4, 1);
	274	+static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR \| S_IRUGO,
	275	+ adc128_show_in, adc128_set_in, 4, 2);
	276	+
	277	+static SENSOR_DEVICE_ATTR_2(in5_input, S_IWUSR \| S_IRUGO,
	278	+ adc128_show_in, adc128_set_in, 5, 0);
	279	+static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR \| S_IRUGO,
	280	+ adc128_show_in, adc128_set_in, 5, 1);
	281	+static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR \| S_IRUGO,
	282	+ adc128_show_in, adc128_set_in, 5, 2);
	283	+
	284	+static SENSOR_DEVICE_ATTR_2(in6_input, S_IWUSR \| S_IRUGO,
	285	+ adc128_show_in, adc128_set_in, 6, 0);
	286	+static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR \| S_IRUGO,
	287	+ adc128_show_in, adc128_set_in, 6, 1);
	288	+static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR \| S_IRUGO,
	289	+ adc128_show_in, adc128_set_in, 6, 2);
	290	+
	291	+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, adc128_show_temp, NULL, 0);
	292	+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR \| S_IRUGO,
	293	+ adc128_show_temp, adc128_set_temp, 1);
	294	+static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR \| S_IRUGO,
	295	+ adc128_show_temp, adc128_set_temp, 2);
	296	+
	297	+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, adc128_show_alarm, NULL, 0);
	298	+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, adc128_show_alarm, NULL, 1);
	299	+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, adc128_show_alarm, NULL, 2);
	300	+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, adc128_show_alarm, NULL, 3);
	301	+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, adc128_show_alarm, NULL, 4);
	302	+static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, adc128_show_alarm, NULL, 5);
	303	+static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, adc128_show_alarm, NULL, 6);
	304	+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, adc128_show_alarm, NULL, 7);
	305	+
	306	+static struct attribute *adc128_attrs[] = {
	307	+ &sensor_dev_attr_in0_min.dev_attr.attr,
	308	+ &sensor_dev_attr_in1_min.dev_attr.attr,
	309	+ &sensor_dev_attr_in2_min.dev_attr.attr,
	310	+ &sensor_dev_attr_in3_min.dev_attr.attr,
	311	+ &sensor_dev_attr_in4_min.dev_attr.attr,
	312	+ &sensor_dev_attr_in5_min.dev_attr.attr,
	313	+ &sensor_dev_attr_in6_min.dev_attr.attr,
	314	+ &sensor_dev_attr_in0_max.dev_attr.attr,
	315	+ &sensor_dev_attr_in1_max.dev_attr.attr,
	316	+ &sensor_dev_attr_in2_max.dev_attr.attr,
	317	+ &sensor_dev_attr_in3_max.dev_attr.attr,
	318	+ &sensor_dev_attr_in4_max.dev_attr.attr,
	319	+ &sensor_dev_attr_in5_max.dev_attr.attr,
	320	+ &sensor_dev_attr_in6_max.dev_attr.attr,
	321	+ &sensor_dev_attr_in0_input.dev_attr.attr,
	322	+ &sensor_dev_attr_in1_input.dev_attr.attr,
	323	+ &sensor_dev_attr_in2_input.dev_attr.attr,
	324	+ &sensor_dev_attr_in3_input.dev_attr.attr,
	325	+ &sensor_dev_attr_in4_input.dev_attr.attr,
	326	+ &sensor_dev_attr_in5_input.dev_attr.attr,
	327	+ &sensor_dev_attr_in6_input.dev_attr.attr,
	328	+ &sensor_dev_attr_temp1_input.dev_attr.attr,
	329	+ &sensor_dev_attr_temp1_max.dev_attr.attr,
	330	+ &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
	331	+ &sensor_dev_attr_in0_alarm.dev_attr.attr,
	332	+ &sensor_dev_attr_in1_alarm.dev_attr.attr,
	333	+ &sensor_dev_attr_in2_alarm.dev_attr.attr,
	334	+ &sensor_dev_attr_in3_alarm.dev_attr.attr,
	335	+ &sensor_dev_attr_in4_alarm.dev_attr.attr,
	336	+ &sensor_dev_attr_in5_alarm.dev_attr.attr,
	337	+ &sensor_dev_attr_in6_alarm.dev_attr.attr,
	338	+ &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
	339	+ NULL
	340	+};
	341	+ATTRIBUTE_GROUPS(adc128);
	342	+
	343	+static int adc128_detect(struct i2c_client client, struct i2c_board_info info)
	344	+{
	345	+ int man_id, dev_id;
	346	+
	347	+ if (!i2c_check_functionality(client->adapter,
	348	+ I2C_FUNC_SMBUS_BYTE_DATA \|
	349	+ I2C_FUNC_SMBUS_WORD_DATA))
	350	+ return -ENODEV;
	351	+
	352	+ man_id = i2c_smbus_read_byte_data(client, ADC128_REG_MAN_ID);
	353	+ dev_id = i2c_smbus_read_byte_data(client, ADC128_REG_DEV_ID);
	354	+ if (man_id != 0x01 \|\| dev_id != 0x09)
	355	+ return -ENODEV;
	356	+
	357	+ /* Check unused bits for confirmation */
	358	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG) & 0xf4)
	359	+ return -ENODEV;
	360	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_CONV_RATE) & 0xfe)
	361	+ return -ENODEV;
	362	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_ONESHOT) & 0xfe)
	363	+ return -ENODEV;
	364	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_SHUTDOWN) & 0xfe)
	365	+ return -ENODEV;
	366	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV) & 0xf8)
	367	+ return -ENODEV;
	368	+ if (i2c_smbus_read_byte_data(client, ADC128_REG_BUSY_STATUS) & 0xfc)
	369	+ return -ENODEV;
	370	+
	371	+ strlcpy(info->type, "adc128d818", I2C_NAME_SIZE);
	372	+
	373	+ return 0;
	374	+}
	375	+
	376	+static int adc128_init_client(struct adc128_data *data)
	377	+{
	378	+ struct i2c_client *client = data->client;
	379	+ int err;
	380	+
	381	+ /*
	382	+ * Reset chip to defaults.
	383	+ * This makes most other initializations unnecessary.
	384	+ */
	385	+ err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x80);
	386	+ if (err)
	387	+ return err;
	388	+
	389	+ /* Start monitoring */
	390	+ err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x01);
	391	+ if (err)
	392	+ return err;
	393	+
	394	+ /* If external vref is selected, configure the chip to use it */
	395	+ if (data->regulator) {
	396	+ err = i2c_smbus_write_byte_data(client,
	397	+ ADC128_REG_CONFIG_ADV, 0x01);
	398	+ if (err)
	399	+ return err;
	400	+ }
	401	+
	402	+ return 0;
	403	+}
	404	+
	405	+static int adc128_probe(struct i2c_client *client,
	406	+ const struct i2c_device_id *id)
	407	+{
	408	+ struct device *dev = &client->dev;
	409	+ struct regulator *regulator;
	410	+ struct device *hwmon_dev;
	411	+ struct adc128_data *data;
	412	+ int err, vref;
	413	+
	414	+ data = devm_kzalloc(dev, sizeof(struct adc128_data), GFP_KERNEL);
	415	+ if (!data)
	416	+ return -ENOMEM;
	417	+
	418	+ /* vref is optional. If specified, is used as chip reference voltage */
	419	+ regulator = devm_regulator_get_optional(dev, "vref");
	420	+ if (!IS_ERR(regulator)) {
	421	+ data->regulator = regulator;
	422	+ err = regulator_enable(regulator);
	423	+ if (err < 0)
	424	+ return err;
	425	+ vref = regulator_get_voltage(regulator);
	426	+ if (vref < 0) {
	427	+ err = vref;
	428	+ goto error;
	429	+ }
	430	+ data->vref = DIV_ROUND_CLOSEST(vref, 1000);
	431	+ } else {
	432	+ data->vref = 2560; /* 2.56V, in mV */
	433	+ }
	434	+
	435	+ data->client = client;
	436	+ i2c_set_clientdata(client, data);
	437	+ mutex_init(&data->update_lock);
	438	+
	439	+ /* Initialize the chip */
	440	+ err = adc128_init_client(data);
	441	+ if (err < 0)
	442	+ goto error;
	443	+
	444	+ hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	445	+ data, adc128_groups);
	446	+ if (IS_ERR(hwmon_dev)) {
	447	+ err = PTR_ERR(hwmon_dev);
	448	+ goto error;
	449	+ }
	450	+
	451	+ return 0;
	452	+
	453	+error:
	454	+ if (data->regulator)
	455	+ regulator_disable(data->regulator);
	456	+ return err;
	457	+}
	458	+
	459	+static int adc128_remove(struct i2c_client *client)
	460	+{
	461	+ struct adc128_data *data = i2c_get_clientdata(client);
	462	+
	463	+ if (data->regulator)
	464	+ regulator_disable(data->regulator);
	465	+
	466	+ return 0;
	467	+}
	468	+
	469	+static const struct i2c_device_id adc128_id[] = {
	470	+ { "adc128d818", 0 },
	471	+ { }
	472	+};
	473	+MODULE_DEVICE_TABLE(i2c, adc128_id);
	474	+
	475	+static struct i2c_driver adc128_driver = {
	476	+ .class = I2C_CLASS_HWMON,
	477	+ .driver = {
	478	+ .name = "adc128d818",
	479	+ },
	480	+ .probe = adc128_probe,
	481	+ .remove = adc128_remove,
	482	+ .id_table = adc128_id,
	483	+ .detect = adc128_detect,
	484	+ .address_list = normal_i2c,
	485	+};
	486	+
	487	+module_i2c_driver(adc128_driver);
	488	+
	489	+MODULE_AUTHOR("Guenter Roeck");
	490	+MODULE_DESCRIPTION("Driver for ADC128D818");
	491	+MODULE_LICENSE("GPL");