[linux-2.6-block.git] / drivers / hwmon / adm1025.c

/*
 * adm1025.c
 *
 * Copyright (C) 2000       Chen-Yuan Wu <gwu@esoft.com>
 * Copyright (C) 2003-2009  Jean Delvare <jdelvare@suse.de>
 *
 * The ADM1025 is a sensor chip made by Analog Devices. It reports up to 6
 * voltages (including its own power source) and up to two temperatures
 * (its own plus up to one external one). Voltages are scaled internally
 * (which is not the common way) with ratios such that the nominal value
 * of each voltage correspond to a register value of 192 (which means a
 * resolution of about 0.5% of the nominal value). Temperature values are
 * reported with a 1 deg resolution and a 3 deg accuracy. Complete
 * datasheet can be obtained from Analog's website at:
 *   http://www.onsemi.com/PowerSolutions/product.do?id=ADM1025
 *
 * This driver also supports the ADM1025A, which differs from the ADM1025
 * only in that it has "open-drain VID inputs while the ADM1025 has
 * on-chip 100k pull-ups on the VID inputs". It doesn't make any
 * difference for us.
 *
 * This driver also supports the NE1619, a sensor chip made by Philips.
 * That chip is similar to the ADM1025A, with a few differences. The only
 * difference that matters to us is that the NE1619 has only two possible
 * addresses while the ADM1025A has a third one. Complete datasheet can be
 * obtained from Philips's website at:
 *   http://www.semiconductors.philips.com/pip/NE1619DS.html
 *
 * Since the ADM1025 was the first chipset supported by this driver, most
 * comments will refer to this chipset, but are actually general and
 * concern all supported chipsets, unless mentioned otherwise.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/hwmon-vid.h>
#include <linux/err.h>
#include <linux/mutex.h>

/*
 * Addresses to scan
 * ADM1025 and ADM1025A have three possible addresses: 0x2c, 0x2d and 0x2e.
 * NE1619 has two possible addresses: 0x2c and 0x2d.
 */

static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };

enum chips { adm1025, ne1619 };

/*
 * The ADM1025 registers
 */

#define ADM1025_REG_MAN_ID		0x3E
#define ADM1025_REG_CHIP_ID		0x3F
#define ADM1025_REG_CONFIG		0x40
#define ADM1025_REG_STATUS1		0x41
#define ADM1025_REG_STATUS2		0x42
#define ADM1025_REG_IN(nr)		(0x20 + (nr))
#define ADM1025_REG_IN_MAX(nr)		(0x2B + (nr) * 2)
#define ADM1025_REG_IN_MIN(nr)		(0x2C + (nr) * 2)
#define ADM1025_REG_TEMP(nr)		(0x26 + (nr))
#define ADM1025_REG_TEMP_HIGH(nr)	(0x37 + (nr) * 2)
#define ADM1025_REG_TEMP_LOW(nr)	(0x38 + (nr) * 2)
#define ADM1025_REG_VID			0x47
#define ADM1025_REG_VID4		0x49

/*
 * Conversions and various macros
 * The ADM1025 uses signed 8-bit values for temperatures.
 */

static const int in_scale[6] = { 2500, 2250, 3300, 5000, 12000, 3300 };

#define IN_FROM_REG(reg, scale)	(((reg) * (scale) + 96) / 192)
#define IN_TO_REG(val, scale)	((val) <= 0 ? 0 : \
				 (val) * 192 >= (scale) * 255 ? 255 : \
				 ((val) * 192 + (scale) / 2) / (scale))

#define TEMP_FROM_REG(reg)	((reg) * 1000)
#define TEMP_TO_REG(val)	((val) <= -127500 ? -128 : \
				 (val) >= 126500 ? 127 : \
				 (((val) < 0 ? (val) - 500 : \
				   (val) + 500) / 1000))

/*
 * Client data (each client gets its own)
 */

struct adm1025_data {
	struct i2c_client *client;
	const struct attribute_group *groups[3];
	struct mutex update_lock;
	char valid; /* zero until following fields are valid */
	unsigned long last_updated; /* in jiffies */

	u8 in[6];		/* register value */
	u8 in_max[6];		/* register value */
	u8 in_min[6];		/* register value */
	s8 temp[2];		/* register value */
	s8 temp_min[2];		/* register value */
	s8 temp_max[2];		/* register value */
	u16 alarms;		/* register values, combined */
	u8 vid;			/* register values, combined */
	u8 vrm;
};

static struct adm1025_data *adm1025_update_device(struct device *dev)
{
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
		int i;

		dev_dbg(&client->dev, "Updating data.\n");
		for (i = 0; i < 6; i++) {
			data->in[i] = i2c_smbus_read_byte_data(client,
				      ADM1025_REG_IN(i));
			data->in_min[i] = i2c_smbus_read_byte_data(client,
					  ADM1025_REG_IN_MIN(i));
			data->in_max[i] = i2c_smbus_read_byte_data(client,
					  ADM1025_REG_IN_MAX(i));
		}
		for (i = 0; i < 2; i++) {
			data->temp[i] = i2c_smbus_read_byte_data(client,
					ADM1025_REG_TEMP(i));
			data->temp_min[i] = i2c_smbus_read_byte_data(client,
					    ADM1025_REG_TEMP_LOW(i));
			data->temp_max[i] = i2c_smbus_read_byte_data(client,
					    ADM1025_REG_TEMP_HIGH(i));
		}
		data->alarms = i2c_smbus_read_byte_data(client,
			       ADM1025_REG_STATUS1)
			     | (i2c_smbus_read_byte_data(client,
				ADM1025_REG_STATUS2) << 8);
		data->vid = (i2c_smbus_read_byte_data(client,
			     ADM1025_REG_VID) & 0x0f)
			  | ((i2c_smbus_read_byte_data(client,
			      ADM1025_REG_VID4) & 0x01) << 4);

		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/*
 * Sysfs stuff
 */

static ssize_t
show_in(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", IN_FROM_REG(data->in[index],
		       in_scale[index]));
}

static ssize_t
show_in_min(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[index],
		       in_scale[index]));
}

static ssize_t
show_in_max(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[index],
		       in_scale[index]));
}

static ssize_t
show_temp(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[index]));
}

static ssize_t
show_temp_min(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[index]));
}

static ssize_t
show_temp_max(struct device *dev, struct device_attribute *attr, char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
}

static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

	err = kstrtol(buf, 10, &val);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->in_min[index] = IN_TO_REG(val, in_scale[index]);
	i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(index),
				  data->in_min[index]);
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

	err = kstrtol(buf, 10, &val);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->in_max[index] = IN_TO_REG(val, in_scale[index]);
	i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(index),
				  data->in_max[index]);
	mutex_unlock(&data->update_lock);
	return count;
}

#define set_in(offset) \
static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
	show_in, NULL, offset); \
static SENSOR_DEVICE_ATTR(in##offset##_min, S_IWUSR | S_IRUGO, \
	show_in_min, set_in_min, offset); \
static SENSOR_DEVICE_ATTR(in##offset##_max, S_IWUSR | S_IRUGO, \
	show_in_max, set_in_max, offset)
set_in(0);
set_in(1);
set_in(2);
set_in(3);
set_in(4);
set_in(5);

static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

	err = kstrtol(buf, 10, &val);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->temp_min[index] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(index),
				  data->temp_min[index]);
	mutex_unlock(&data->update_lock);
	return count;
}

static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
	const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

	err = kstrtol(buf, 10, &val);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->temp_max[index] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),
				  data->temp_max[index]);
	mutex_unlock(&data->update_lock);
	return count;
}

#define set_temp(offset) \
static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
	show_temp, NULL, offset - 1); \
static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IWUSR | S_IRUGO, \
	show_temp_min, set_temp_min, offset - 1); \
static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IWUSR | S_IRUGO, \
	show_temp_max, set_temp_max, offset - 1)
set_temp(1);
set_temp(2);

static ssize_t
show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", data->alarms);
}
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

static ssize_t
show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
{
	int bitnr = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
}
static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_alarm, NULL, 14);

static ssize_t
show_vid(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct adm1025_data *data = adm1025_update_device(dev);
	return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
}
static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);

static ssize_t
show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct adm1025_data *data = dev_get_drvdata(dev);
	return sprintf(buf, "%u\n", data->vrm);
}
static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct adm1025_data *data = dev_get_drvdata(dev);
	unsigned long val;
	int err;

	err = kstrtoul(buf, 10, &val);
	if (err)
		return err;

	if (val > 255)
		return -EINVAL;

	data->vrm = val;
	return count;
}
static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);

/*
 * Real code
 */

static struct attribute *adm1025_attributes[] = {
	&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_in5_input.dev_attr.attr,
	&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_in5_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_in5_max.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_in5_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp2_input.dev_attr.attr,
	&sensor_dev_attr_temp1_min.dev_attr.attr,
	&sensor_dev_attr_temp2_min.dev_attr.attr,
	&sensor_dev_attr_temp1_max.dev_attr.attr,
	&sensor_dev_attr_temp2_max.dev_attr.attr,
	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_fault.dev_attr.attr,
	&dev_attr_alarms.attr,
	&dev_attr_cpu0_vid.attr,
	&dev_attr_vrm.attr,
	NULL
};

static const struct attribute_group adm1025_group = {
	.attrs = adm1025_attributes,
};

static struct attribute *adm1025_attributes_in4[] = {
	&sensor_dev_attr_in4_input.dev_attr.attr,
	&sensor_dev_attr_in4_min.dev_attr.attr,
	&sensor_dev_attr_in4_max.dev_attr.attr,
	&sensor_dev_attr_in4_alarm.dev_attr.attr,
	NULL
};

static const struct attribute_group adm1025_group_in4 = {
	.attrs = adm1025_attributes_in4,
};

/* Return 0 if detection is successful, -ENODEV otherwise */
static int adm1025_detect(struct i2c_client *client,
			  struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;
	const char *name;
	u8 man_id, chip_id;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

	/* Check for unused bits */
	if ((i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG) & 0x80)
	 || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS1) & 0xC0)
	 || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS2) & 0xBC)) {
		dev_dbg(&adapter->dev, "ADM1025 detection failed at 0x%02x\n",
			client->addr);
		return -ENODEV;
	}

	/* Identification */
	chip_id = i2c_smbus_read_byte_data(client, ADM1025_REG_CHIP_ID);
	if ((chip_id & 0xF0) != 0x20)
		return -ENODEV;

	man_id = i2c_smbus_read_byte_data(client, ADM1025_REG_MAN_ID);
	if (man_id == 0x41)
		name = "adm1025";
	else if (man_id == 0xA1 && client->addr != 0x2E)
		name = "ne1619";
	else
		return -ENODEV;

	strlcpy(info->type, name, I2C_NAME_SIZE);

	return 0;
}

static void adm1025_init_client(struct i2c_client *client)
{
	u8 reg;
	struct adm1025_data *data = i2c_get_clientdata(client);
	int i;

	data->vrm = vid_which_vrm();

	/*
	 * Set high limits
	 * Usually we avoid setting limits on driver init, but it happens
	 * that the ADM1025 comes with stupid default limits (all registers
	 * set to 0). In case the chip has not gone through any limit
	 * setting yet, we better set the high limits to the max so that
	 * no alarm triggers.
	 */
	for (i = 0; i < 6; i++) {
		reg = i2c_smbus_read_byte_data(client,
					       ADM1025_REG_IN_MAX(i));
		if (reg == 0)
			i2c_smbus_write_byte_data(client,
						  ADM1025_REG_IN_MAX(i),
						  0xFF);
	}
	for (i = 0; i < 2; i++) {
		reg = i2c_smbus_read_byte_data(client,
					       ADM1025_REG_TEMP_HIGH(i));
		if (reg == 0)
			i2c_smbus_write_byte_data(client,
						  ADM1025_REG_TEMP_HIGH(i),
						  0x7F);
	}

	/*
	 * Start the conversions
	 */
	reg = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
	if (!(reg & 0x01))
		i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG,
					  (reg&0x7E)|0x01);
}

static int adm1025_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device *hwmon_dev;
	struct adm1025_data *data;
	u8 config;

	data = devm_kzalloc(dev, sizeof(struct adm1025_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	i2c_set_clientdata(client, data);
	data->client = client;
	mutex_init(&data->update_lock);

	/* Initialize the ADM1025 chip */
	adm1025_init_client(client);

	/* sysfs hooks */
	data->groups[0] = &adm1025_group;
	/* Pin 11 is either in4 (+12V) or VID4 */
	config = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
	if (!(config & 0x20))
		data->groups[1] = &adm1025_group_in4;

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   data, data->groups);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

static const struct i2c_device_id adm1025_id[] = {
	{ "adm1025", adm1025 },
	{ "ne1619", ne1619 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, adm1025_id);

static struct i2c_driver adm1025_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name	= "adm1025",
	},
	.probe		= adm1025_probe,
	.id_table	= adm1025_id,
	.detect		= adm1025_detect,
	.address_list	= normal_i2c,
};

module_i2c_driver(adm1025_driver);

MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
MODULE_DESCRIPTION("ADM1025 driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* adm1025.c
	3	*
	4	* Copyright (C) 2000 Chen-Yuan Wu <gwu@esoft.com>
7c81c60f	5	* Copyright (C) 2003-2009 Jean Delvare <jdelvare@suse.de>
1da177e4 LT	6	*
	7	* The ADM1025 is a sensor chip made by Analog Devices. It reports up to 6
	8	* voltages (including its own power source) and up to two temperatures
	9	* (its own plus up to one external one). Voltages are scaled internally
	10	* (which is not the common way) with ratios such that the nominal value
	11	* of each voltage correspond to a register value of 192 (which means a
	12	* resolution of about 0.5% of the nominal value). Temperature values are
	13	* reported with a 1 deg resolution and a 3 deg accuracy. Complete
	14	* datasheet can be obtained from Analog's website at:
2b22de51	15	* http://www.onsemi.com/PowerSolutions/product.do?id=ADM1025
1da177e4 LT	16	*
	17	* This driver also supports the ADM1025A, which differs from the ADM1025
	18	* only in that it has "open-drain VID inputs while the ADM1025 has
	19	* on-chip 100k pull-ups on the VID inputs". It doesn't make any
	20	* difference for us.
	21	*
	22	* This driver also supports the NE1619, a sensor chip made by Philips.
	23	* That chip is similar to the ADM1025A, with a few differences. The only
	24	* difference that matters to us is that the NE1619 has only two possible
	25	* addresses while the ADM1025A has a third one. Complete datasheet can be
	26	* obtained from Philips's website at:
	27	* http://www.semiconductors.philips.com/pip/NE1619DS.html
	28	*
	29	* Since the ADM1025 was the first chipset supported by this driver, most
	30	* comments will refer to this chipset, but are actually general and
	31	* concern all supported chipsets, unless mentioned otherwise.
	32	*
	33	* This program is free software; you can redistribute it and/or modify
	34	* it under the terms of the GNU General Public License as published by
	35	* the Free Software Foundation; either version 2 of the License, or
	36	* (at your option) any later version.
	37	*
	38	* This program is distributed in the hope that it will be useful,
	39	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	41	* GNU General Public License for more details.
	42	*
	43	* You should have received a copy of the GNU General Public License
	44	* along with this program; if not, write to the Free Software
	45	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	46	*/
	47
1da177e4 LT	48	#include <linux/module.h>
	49	#include <linux/init.h>
	50	#include <linux/slab.h>
	51	#include <linux/jiffies.h>
	52	#include <linux/i2c.h>
943b0830	53	#include <linux/hwmon.h>
d8543e7f	54	#include <linux/hwmon-sysfs.h>
303760b4	55	#include <linux/hwmon-vid.h>
943b0830	56	#include <linux/err.h>
9a61bf63	57	#include <linux/mutex.h>
1da177e4 LT	58
	59	/*
	60	* Addresses to scan
	61	* ADM1025 and ADM1025A have three possible addresses: 0x2c, 0x2d and 0x2e.
	62	* NE1619 has two possible addresses: 0x2c and 0x2d.
	63	*/
	64
25e9c86d	65	static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
1da177e4	66
e5e9f44c	67	enum chips { adm1025, ne1619 };
1da177e4 LT	68
	69	/*
	70	* The ADM1025 registers
	71	*/
	72
	73	#define ADM1025_REG_MAN_ID 0x3E
4e952799	74	#define ADM1025_REG_CHIP_ID 0x3F
1da177e4 LT	75	#define ADM1025_REG_CONFIG 0x40
	76	#define ADM1025_REG_STATUS1 0x41
	77	#define ADM1025_REG_STATUS2 0x42
	78	#define ADM1025_REG_IN(nr) (0x20 + (nr))
	79	#define ADM1025_REG_IN_MAX(nr) (0x2B + (nr) * 2)
	80	#define ADM1025_REG_IN_MIN(nr) (0x2C + (nr) * 2)
	81	#define ADM1025_REG_TEMP(nr) (0x26 + (nr))
	82	#define ADM1025_REG_TEMP_HIGH(nr) (0x37 + (nr) * 2)
	83	#define ADM1025_REG_TEMP_LOW(nr) (0x38 + (nr) * 2)
	84	#define ADM1025_REG_VID 0x47
	85	#define ADM1025_REG_VID4 0x49
	86
	87	/*
	88	* Conversions and various macros
	89	* The ADM1025 uses signed 8-bit values for temperatures.
	90	*/
	91
4e952799	92	static const int in_scale[6] = { 2500, 2250, 3300, 5000, 12000, 3300 };
1da177e4	93
2b22de51 GR	94	#define IN_FROM_REG(reg, scale) (((reg) * (scale) + 96) / 192)
2b22de51 GR	95	#define IN_TO_REG(val, scale) ((val) <= 0 ? 0 : \
1da177e4	96	(val) * 192 >= (scale) * 255 ? 255 : \
2b22de51	97	((val) * 192 + (scale) / 2) / (scale))
1da177e4 LT	98
	99	#define TEMP_FROM_REG(reg) ((reg) * 1000)
	100	#define TEMP_TO_REG(val) ((val) <= -127500 ? -128 : \
	101	(val) >= 126500 ? 127 : \
2b22de51 GR	102	(((val) < 0 ? (val) - 500 : \
2b22de51 GR	103	(val) + 500) / 1000))
1da177e4	104
1da177e4 LT	105	/*
	106	* Client data (each client gets its own)
	107	*/
	108
	109	struct adm1025_data {
aab3f57a AL	110	struct i2c_client *client;
aab3f57a AL	111	const struct attribute_group *groups[3];
9a61bf63	112	struct mutex update_lock;
1da177e4 LT	113	char valid; /* zero until following fields are valid */
	114	unsigned long last_updated; /* in jiffies */
	115
	116	u8 in[6]; /* register value */
	117	u8 in_max[6]; /* register value */
	118	u8 in_min[6]; /* register value */
	119	s8 temp[2]; /* register value */
	120	s8 temp_min[2]; /* register value */
	121	s8 temp_max[2]; /* register value */
	122	u16 alarms; /* register values, combined */
	123	u8 vid; /* register values, combined */
	124	u8 vrm;
	125	};
	126
851a7afa AL	127	static struct adm1025_data adm1025_update_device(struct device dev)
851a7afa AL	128	{
aab3f57a AL	129	struct adm1025_data *data = dev_get_drvdata(dev);
aab3f57a AL	130	struct i2c_client *client = data->client;
851a7afa AL	131
	132	mutex_lock(&data->update_lock);
	133
	134	if (time_after(jiffies, data->last_updated + HZ * 2) \|\| !data->valid) {
	135	int i;
	136
	137	dev_dbg(&client->dev, "Updating data.\n");
	138	for (i = 0; i < 6; i++) {
	139	data->in[i] = i2c_smbus_read_byte_data(client,
	140	ADM1025_REG_IN(i));
	141	data->in_min[i] = i2c_smbus_read_byte_data(client,
	142	ADM1025_REG_IN_MIN(i));
	143	data->in_max[i] = i2c_smbus_read_byte_data(client,
	144	ADM1025_REG_IN_MAX(i));
	145	}
	146	for (i = 0; i < 2; i++) {
	147	data->temp[i] = i2c_smbus_read_byte_data(client,
	148	ADM1025_REG_TEMP(i));
	149	data->temp_min[i] = i2c_smbus_read_byte_data(client,
	150	ADM1025_REG_TEMP_LOW(i));
	151	data->temp_max[i] = i2c_smbus_read_byte_data(client,
	152	ADM1025_REG_TEMP_HIGH(i));
	153	}
	154	data->alarms = i2c_smbus_read_byte_data(client,
	155	ADM1025_REG_STATUS1)
	156	\| (i2c_smbus_read_byte_data(client,
	157	ADM1025_REG_STATUS2) << 8);
	158	data->vid = (i2c_smbus_read_byte_data(client,
	159	ADM1025_REG_VID) & 0x0f)
	160	\| ((i2c_smbus_read_byte_data(client,
	161	ADM1025_REG_VID4) & 0x01) << 4);
	162
	163	data->last_updated = jiffies;
	164	data->valid = 1;
	165	}
	166
	167	mutex_unlock(&data->update_lock);
	168
	169	return data;
	170	}
	171
1da177e4 LT	172	/*
	173	* Sysfs stuff
	174	*/
	175
d8543e7f JD	176	static ssize_t
	177	show_in(struct device dev, struct device_attribute attr, char *buf)
	178	{
	179	int index = to_sensor_dev_attr(attr)->index;
	180	struct adm1025_data *data = adm1025_update_device(dev);
	181	return sprintf(buf, "%u\n", IN_FROM_REG(data->in[index],
	182	in_scale[index]));
	183	}
	184
	185	static ssize_t
	186	show_in_min(struct device dev, struct device_attribute attr, char *buf)
	187	{
	188	int index = to_sensor_dev_attr(attr)->index;
	189	struct adm1025_data *data = adm1025_update_device(dev);
	190	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[index],
	191	in_scale[index]));
	192	}
	193
	194	static ssize_t
	195	show_in_max(struct device dev, struct device_attribute attr, char *buf)
	196	{
	197	int index = to_sensor_dev_attr(attr)->index;
	198	struct adm1025_data *data = adm1025_update_device(dev);
	199	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[index],
	200	in_scale[index]));
	201	}
	202
	203	static ssize_t
	204	show_temp(struct device dev, struct device_attribute attr, char *buf)
	205	{
	206	int index = to_sensor_dev_attr(attr)->index;
	207	struct adm1025_data *data = adm1025_update_device(dev);
	208	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[index]));
	209	}
	210
	211	static ssize_t
	212	show_temp_min(struct device dev, struct device_attribute attr, char *buf)
	213	{
	214	int index = to_sensor_dev_attr(attr)->index;
	215	struct adm1025_data *data = adm1025_update_device(dev);
	216	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[index]));
	217	}
	218
	219	static ssize_t
	220	show_temp_max(struct device dev, struct device_attribute attr, char *buf)
	221	{
	222	int index = to_sensor_dev_attr(attr)->index;
	223	struct adm1025_data *data = adm1025_update_device(dev);
	224	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
	225	}
	226
	227	static ssize_t set_in_min(struct device dev, struct device_attribute attr,
	228	const char *buf, size_t count)
	229	{
	230	int index = to_sensor_dev_attr(attr)->index;
aab3f57a AL	231	struct adm1025_data *data = dev_get_drvdata(dev);
aab3f57a AL	232	struct i2c_client *client = data->client;
2b22de51 GR	233	long val;
	234	int err;
	235
	236	err = kstrtol(buf, 10, &val);
	237	if (err)
	238	return err;
d8543e7f JD	239
	240	mutex_lock(&data->update_lock);
	241	data->in_min[index] = IN_TO_REG(val, in_scale[index]);
	242	i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(index),
	243	data->in_min[index]);
	244	mutex_unlock(&data->update_lock);
	245	return count;
	246	}
	247
	248	static ssize_t set_in_max(struct device dev, struct device_attribute attr,
	249	const char *buf, size_t count)
	250	{
	251	int index = to_sensor_dev_attr(attr)->index;
aab3f57a AL	252	struct adm1025_data *data = dev_get_drvdata(dev);
aab3f57a AL	253	struct i2c_client *client = data->client;
2b22de51 GR	254	long val;
	255	int err;
	256
	257	err = kstrtol(buf, 10, &val);
	258	if (err)
	259	return err;
d8543e7f JD	260
	261	mutex_lock(&data->update_lock);
	262	data->in_max[index] = IN_TO_REG(val, in_scale[index]);
	263	i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(index),
	264	data->in_max[index]);
	265	mutex_unlock(&data->update_lock);
	266	return count;
	267	}
1da177e4 LT	268
1da177e4 LT	269	#define set_in(offset) \
d8543e7f JD	270	static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
	271	show_in, NULL, offset); \
	272	static SENSOR_DEVICE_ATTR(in##offset##_min, S_IWUSR \| S_IRUGO, \
	273	show_in_min, set_in_min, offset); \
	274	static SENSOR_DEVICE_ATTR(in##offset##_max, S_IWUSR \| S_IRUGO, \
	275	show_in_max, set_in_max, offset)
1da177e4 LT	276	set_in(0);
	277	set_in(1);
	278	set_in(2);
	279	set_in(3);
	280	set_in(4);
	281	set_in(5);
	282
d8543e7f JD	283	static ssize_t set_temp_min(struct device dev, struct device_attribute attr,
	284	const char *buf, size_t count)
	285	{
	286	int index = to_sensor_dev_attr(attr)->index;
aab3f57a AL	287	struct adm1025_data *data = dev_get_drvdata(dev);
aab3f57a AL	288	struct i2c_client *client = data->client;
2b22de51 GR	289	long val;
	290	int err;
	291
	292	err = kstrtol(buf, 10, &val);
	293	if (err)
	294	return err;
d8543e7f JD	295
	296	mutex_lock(&data->update_lock);
	297	data->temp_min[index] = TEMP_TO_REG(val);
	298	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(index),
	299	data->temp_min[index]);
	300	mutex_unlock(&data->update_lock);
	301	return count;
	302	}
	303
	304	static ssize_t set_temp_max(struct device dev, struct device_attribute attr,
	305	const char *buf, size_t count)
	306	{
	307	int index = to_sensor_dev_attr(attr)->index;
aab3f57a AL	308	struct adm1025_data *data = dev_get_drvdata(dev);
aab3f57a AL	309	struct i2c_client *client = data->client;
2b22de51 GR	310	long val;
	311	int err;
	312
	313	err = kstrtol(buf, 10, &val);
	314	if (err)
	315	return err;
d8543e7f JD	316
	317	mutex_lock(&data->update_lock);
	318	data->temp_max[index] = TEMP_TO_REG(val);
	319	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),
	320	data->temp_max[index]);
	321	mutex_unlock(&data->update_lock);
	322	return count;
	323	}
	324
1da177e4	325	#define set_temp(offset) \
d8543e7f JD	326	static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
	327	show_temp, NULL, offset - 1); \
	328	static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IWUSR \| S_IRUGO, \
	329	show_temp_min, set_temp_min, offset - 1); \
	330	static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IWUSR \| S_IRUGO, \
	331	show_temp_max, set_temp_max, offset - 1)
1da177e4 LT	332	set_temp(1);
	333	set_temp(2);
	334
4e952799 JD	335	static ssize_t
4e952799 JD	336	show_alarms(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	337	{
	338	struct adm1025_data *data = adm1025_update_device(dev);
	339	return sprintf(buf, "%u\n", data->alarms);
	340	}
	341	static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
	342
bb081300 JD	343	static ssize_t
	344	show_alarm(struct device dev, struct device_attribute attr, char *buf)
	345	{
	346	int bitnr = to_sensor_dev_attr(attr)->index;
	347	struct adm1025_data *data = adm1025_update_device(dev);
	348	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
	349	}
	350	static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
	351	static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
	352	static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
	353	static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
	354	static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
	355	static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
	356	static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 5);
	357	static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 4);
	358	static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_alarm, NULL, 14);
	359
4e952799 JD	360	static ssize_t
4e952799 JD	361	show_vid(struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	362	{
	363	struct adm1025_data *data = adm1025_update_device(dev);
	364	return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
	365	}
937df8df	366	static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1da177e4	367
4e952799 JD	368	static ssize_t
4e952799 JD	369	show_vrm(struct device dev, struct device_attribute attr, char *buf)
1da177e4	370	{
90d6619a	371	struct adm1025_data *data = dev_get_drvdata(dev);
1da177e4 LT	372	return sprintf(buf, "%u\n", data->vrm);
1da177e4 LT	373	}
4e952799 JD	374	static ssize_t set_vrm(struct device dev, struct device_attribute attr,
4e952799 JD	375	const char *buf, size_t count)
1da177e4	376	{
8f74efe8	377	struct adm1025_data *data = dev_get_drvdata(dev);
2b22de51 GR	378	unsigned long val;
	379	int err;
	380
	381	err = kstrtoul(buf, 10, &val);
	382	if (err)
	383	return err;
	384
9c8ae728 AL	385	if (val > 255)
	386	return -EINVAL;
	387
2b22de51	388	data->vrm = val;
1da177e4 LT	389	return count;
	390	}
	391	static DEVICE_ATTR(vrm, S_IRUGO \| S_IWUSR, show_vrm, set_vrm);
	392
	393	/*
	394	* Real code
	395	*/
	396
681c6f7a	397	static struct attribute *adm1025_attributes[] = {
d8543e7f JD	398	&sensor_dev_attr_in0_input.dev_attr.attr,
	399	&sensor_dev_attr_in1_input.dev_attr.attr,
	400	&sensor_dev_attr_in2_input.dev_attr.attr,
	401	&sensor_dev_attr_in3_input.dev_attr.attr,
	402	&sensor_dev_attr_in5_input.dev_attr.attr,
	403	&sensor_dev_attr_in0_min.dev_attr.attr,
	404	&sensor_dev_attr_in1_min.dev_attr.attr,
	405	&sensor_dev_attr_in2_min.dev_attr.attr,
	406	&sensor_dev_attr_in3_min.dev_attr.attr,
	407	&sensor_dev_attr_in5_min.dev_attr.attr,
	408	&sensor_dev_attr_in0_max.dev_attr.attr,
	409	&sensor_dev_attr_in1_max.dev_attr.attr,
	410	&sensor_dev_attr_in2_max.dev_attr.attr,
	411	&sensor_dev_attr_in3_max.dev_attr.attr,
	412	&sensor_dev_attr_in5_max.dev_attr.attr,
bb081300 JD	413	&sensor_dev_attr_in0_alarm.dev_attr.attr,
	414	&sensor_dev_attr_in1_alarm.dev_attr.attr,
	415	&sensor_dev_attr_in2_alarm.dev_attr.attr,
	416	&sensor_dev_attr_in3_alarm.dev_attr.attr,
	417	&sensor_dev_attr_in5_alarm.dev_attr.attr,
d8543e7f JD	418	&sensor_dev_attr_temp1_input.dev_attr.attr,
	419	&sensor_dev_attr_temp2_input.dev_attr.attr,
	420	&sensor_dev_attr_temp1_min.dev_attr.attr,
	421	&sensor_dev_attr_temp2_min.dev_attr.attr,
	422	&sensor_dev_attr_temp1_max.dev_attr.attr,
	423	&sensor_dev_attr_temp2_max.dev_attr.attr,
bb081300 JD	424	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
	425	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
	426	&sensor_dev_attr_temp1_fault.dev_attr.attr,
681c6f7a MH	427	&dev_attr_alarms.attr,
	428	&dev_attr_cpu0_vid.attr,
	429	&dev_attr_vrm.attr,
	430	NULL
	431	};
	432
	433	static const struct attribute_group adm1025_group = {
	434	.attrs = adm1025_attributes,
	435	};
	436
4e952799	437	static struct attribute *adm1025_attributes_in4[] = {
d8543e7f JD	438	&sensor_dev_attr_in4_input.dev_attr.attr,
	439	&sensor_dev_attr_in4_min.dev_attr.attr,
	440	&sensor_dev_attr_in4_max.dev_attr.attr,
bb081300	441	&sensor_dev_attr_in4_alarm.dev_attr.attr,
681c6f7a MH	442	NULL
	443	};
	444
4e952799 JD	445	static const struct attribute_group adm1025_group_in4 = {
4e952799 JD	446	.attrs = adm1025_attributes_in4,
681c6f7a MH	447	};
681c6f7a MH	448
7dbafe02	449	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	450	static int adm1025_detect(struct i2c_client *client,
7dbafe02	451	struct i2c_board_info *info)
1da177e4	452	{
7dbafe02	453	struct i2c_adapter *adapter = client->adapter;
95606723 JD	454	const char *name;
95606723 JD	455	u8 man_id, chip_id;
1da177e4 LT	456
1da177e4 LT	457	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
7dbafe02	458	return -ENODEV;
1da177e4	459
95606723 JD	460	/* Check for unused bits */
	461	if ((i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG) & 0x80)
	462	\|\| (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS1) & 0xC0)
	463	\|\| (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS2) & 0xBC)) {
	464	dev_dbg(&adapter->dev, "ADM1025 detection failed at 0x%02x\n",
	465	client->addr);
	466	return -ENODEV;
1da177e4 LT	467	}
1da177e4 LT	468
95606723 JD	469	/* Identification */
	470	chip_id = i2c_smbus_read_byte_data(client, ADM1025_REG_CHIP_ID);
	471	if ((chip_id & 0xF0) != 0x20)
	472	return -ENODEV;
1da177e4	473
95606723 JD	474	man_id = i2c_smbus_read_byte_data(client, ADM1025_REG_MAN_ID);
95606723 JD	475	if (man_id == 0x41)
1da177e4	476	name = "adm1025";
95606723	477	else if (man_id == 0xA1 && client->addr != 0x2E)
1da177e4	478	name = "ne1619";
95606723 JD	479	else
	480	return -ENODEV;
	481
7dbafe02	482	strlcpy(info->type, name, I2C_NAME_SIZE);
1da177e4	483
7dbafe02 JD	484	return 0;
7dbafe02 JD	485	}
1da177e4	486
851a7afa AL	487	static void adm1025_init_client(struct i2c_client *client)
	488	{
	489	u8 reg;
	490	struct adm1025_data *data = i2c_get_clientdata(client);
	491	int i;
	492
	493	data->vrm = vid_which_vrm();
	494
	495	/*
	496	* Set high limits
	497	* Usually we avoid setting limits on driver init, but it happens
	498	* that the ADM1025 comes with stupid default limits (all registers
	499	* set to 0). In case the chip has not gone through any limit
	500	* setting yet, we better set the high limits to the max so that
	501	* no alarm triggers.
	502	*/
	503	for (i = 0; i < 6; i++) {
	504	reg = i2c_smbus_read_byte_data(client,
	505	ADM1025_REG_IN_MAX(i));
	506	if (reg == 0)
	507	i2c_smbus_write_byte_data(client,
	508	ADM1025_REG_IN_MAX(i),
	509	0xFF);
	510	}
	511	for (i = 0; i < 2; i++) {
	512	reg = i2c_smbus_read_byte_data(client,
	513	ADM1025_REG_TEMP_HIGH(i));
	514	if (reg == 0)
	515	i2c_smbus_write_byte_data(client,
	516	ADM1025_REG_TEMP_HIGH(i),
	517	0x7F);
	518	}
	519
	520	/*
	521	* Start the conversions
	522	*/
	523	reg = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
	524	if (!(reg & 0x01))
	525	i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG,
	526	(reg&0x7E)\|0x01);
	527	}
	528
7dbafe02 JD	529	static int adm1025_probe(struct i2c_client *client,
	530	const struct i2c_device_id *id)
	531	{
aab3f57a AL	532	struct device *dev = &client->dev;
aab3f57a AL	533	struct device *hwmon_dev;
7dbafe02	534	struct adm1025_data *data;
7dbafe02 JD	535	u8 config;
7dbafe02 JD	536
aab3f57a	537	data = devm_kzalloc(dev, sizeof(struct adm1025_data), GFP_KERNEL);
6702c998 GR	538	if (!data)
6702c998 GR	539	return -ENOMEM;
7dbafe02 JD	540
7dbafe02 JD	541	i2c_set_clientdata(client, data);
aab3f57a	542	data->client = client;
7dbafe02	543	mutex_init(&data->update_lock);
1da177e4 LT	544
1da177e4 LT	545	/* Initialize the ADM1025 chip */
4e952799	546	adm1025_init_client(client);
1da177e4	547
aab3f57a AL	548	/* sysfs hooks */
aab3f57a AL	549	data->groups[0] = &adm1025_group;
1da177e4	550	/* Pin 11 is either in4 (+12V) or VID4 */
7dbafe02	551	config = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
aab3f57a AL	552	if (!(config & 0x20))
aab3f57a AL	553	data->groups[1] = &adm1025_group_in4;
1da177e4	554
aab3f57a AL	555	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	556	data, data->groups);
	557	return PTR_ERR_OR_ZERO(hwmon_dev);
1da177e4 LT	558	}
1da177e4 LT	559
851a7afa AL	560	static const struct i2c_device_id adm1025_id[] = {
	561	{ "adm1025", adm1025 },
	562	{ "ne1619", ne1619 },
	563	{ }
	564	};
	565	MODULE_DEVICE_TABLE(i2c, adm1025_id);
1da177e4	566
851a7afa AL	567	static struct i2c_driver adm1025_driver = {
	568	.class = I2C_CLASS_HWMON,
	569	.driver = {
	570	.name = "adm1025",
	571	},
	572	.probe = adm1025_probe,
851a7afa AL	573	.id_table = adm1025_id,
	574	.detect = adm1025_detect,
	575	.address_list = normal_i2c,
	576	};
1da177e4	577
f0967eea	578	module_i2c_driver(adm1025_driver);
1da177e4	579
7c81c60f	580	MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1da177e4 LT	581	MODULE_DESCRIPTION("ADM1025 driver");
1da177e4 LT	582	MODULE_LICENSE("GPL");