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

/*
    lm75.c - Part of lm_sensors, Linux kernel modules for hardware
             monitoring
    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>

    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/err.h>
#include <linux/mutex.h>
#include "lm75.h"


/*
 * This driver handles the LM75 and compatible digital temperature sensors.
 */

enum lm75_type {		/* keep sorted in alphabetical order */
	ds1775,
	ds75,
	lm75,
	lm75a,
	max6625,
	max6626,
	mcp980x,
	stds75,
	tcn75,
	tmp100,
	tmp101,
	tmp175,
	tmp275,
	tmp75,
};

/* Addresses scanned */
static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
					0x4d, 0x4e, 0x4f, I2C_CLIENT_END };


/* The LM75 registers */
#define LM75_REG_CONF		0x01
static const u8 LM75_REG_TEMP[3] = {
	0x00,		/* input */
	0x03,		/* max */
	0x02,		/* hyst */
};

/* Each client has this additional data */
struct lm75_data {
	struct device		*hwmon_dev;
	struct mutex		update_lock;
	u8			orig_conf;
	char			valid;		/* !=0 if registers are valid */
	unsigned long		last_updated;	/* In jiffies */
	u16			temp[3];	/* Register values,
						   0 = input
						   1 = max
						   2 = hyst */
};

static int lm75_read_value(struct i2c_client *client, u8 reg);
static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
static struct lm75_data *lm75_update_device(struct device *dev);


/*-----------------------------------------------------------------------*/

/* sysfs attributes for hwmon */

static ssize_t show_temp(struct device *dev, struct device_attribute *da,
			 char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct lm75_data *data = lm75_update_device(dev);
	return sprintf(buf, "%d\n",
		       LM75_TEMP_FROM_REG(data->temp[attr->index]));
}

static ssize_t set_temp(struct device *dev, struct device_attribute *da,
			const char *buf, size_t count)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct i2c_client *client = to_i2c_client(dev);
	struct lm75_data *data = i2c_get_clientdata(client);
	int nr = attr->index;
	long temp = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	data->temp[nr] = LM75_TEMP_TO_REG(temp);
	lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
	mutex_unlock(&data->update_lock);
	return count;
}

static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
			show_temp, set_temp, 1);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
			show_temp, set_temp, 2);
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);

static struct attribute *lm75_attributes[] = {
	&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,

	NULL
};

static const struct attribute_group lm75_group = {
	.attrs = lm75_attributes,
};

/*-----------------------------------------------------------------------*/

/* device probe and removal */

static int
lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct lm75_data *data;
	int status;
	u8 set_mask, clr_mask;
	int new;

	if (!i2c_check_functionality(client->adapter,
			I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
		return -EIO;

	data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

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

	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
	 * Then tweak to be more precise when appropriate.
	 */
	set_mask = 0;
	clr_mask = (1 << 0)			/* continuous conversions */
		| (1 << 6) | (1 << 5);		/* 9-bit mode */

	/* configure as specified */
	status = lm75_read_value(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(&client->dev, "Can't read config? %d\n", status);
		goto exit_free;
	}
	data->orig_conf = status;
	new = status & ~clr_mask;
	new |= set_mask;
	if (status != new)
		lm75_write_value(client, LM75_REG_CONF, new);
	dev_dbg(&client->dev, "Config %02x\n", new);

	/* Register sysfs hooks */
	status = sysfs_create_group(&client->dev.kobj, &lm75_group);
	if (status)
		goto exit_free;

	data->hwmon_dev = hwmon_device_register(&client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		status = PTR_ERR(data->hwmon_dev);
		goto exit_remove;
	}

	dev_info(&client->dev, "%s: sensor '%s'\n",
		 dev_name(data->hwmon_dev), client->name);

	return 0;

exit_remove:
	sysfs_remove_group(&client->dev.kobj, &lm75_group);
exit_free:
	i2c_set_clientdata(client, NULL);
	kfree(data);
	return status;
}

static int lm75_remove(struct i2c_client *client)
{
	struct lm75_data *data = i2c_get_clientdata(client);

	hwmon_device_unregister(data->hwmon_dev);
	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
	i2c_set_clientdata(client, NULL);
	kfree(data);
	return 0;
}

static const struct i2c_device_id lm75_ids[] = {
	{ "ds1775", ds1775, },
	{ "ds75", ds75, },
	{ "lm75", lm75, },
	{ "lm75a", lm75a, },
	{ "max6625", max6625, },
	{ "max6626", max6626, },
	{ "mcp980x", mcp980x, },
	{ "stds75", stds75, },
	{ "tcn75", tcn75, },
	{ "tmp100", tmp100, },
	{ "tmp101", tmp101, },
	{ "tmp175", tmp175, },
	{ "tmp275", tmp275, },
	{ "tmp75", tmp75, },
	{ /* LIST END */ }
};
MODULE_DEVICE_TABLE(i2c, lm75_ids);

/* Return 0 if detection is successful, -ENODEV otherwise */
static int lm75_detect(struct i2c_client *new_client,
		       struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = new_client->adapter;
	int i;
	int cur, conf, hyst, os;

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

	/* Now, we do the remaining detection. There is no identification-
	   dedicated register so we have to rely on several tricks:
	   unused bits, registers cycling over 8-address boundaries,
	   addresses 0x04-0x07 returning the last read value.
	   The cycling+unused addresses combination is not tested,
	   since it would significantly slow the detection down and would
	   hardly add any value. */

	/* Unused addresses */
	cur = i2c_smbus_read_word_data(new_client, 0);
	conf = i2c_smbus_read_byte_data(new_client, 1);
	hyst = i2c_smbus_read_word_data(new_client, 2);
	if (i2c_smbus_read_word_data(new_client, 4) != hyst
	 || i2c_smbus_read_word_data(new_client, 5) != hyst
	 || i2c_smbus_read_word_data(new_client, 6) != hyst
	 || i2c_smbus_read_word_data(new_client, 7) != hyst)
		return -ENODEV;
	os = i2c_smbus_read_word_data(new_client, 3);
	if (i2c_smbus_read_word_data(new_client, 4) != os
	 || i2c_smbus_read_word_data(new_client, 5) != os
	 || i2c_smbus_read_word_data(new_client, 6) != os
	 || i2c_smbus_read_word_data(new_client, 7) != os)
		return -ENODEV;

	/* Unused bits */
	if (conf & 0xe0)
		return -ENODEV;

	/* Addresses cycling */
	for (i = 8; i < 0xff; i += 8) {
		if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
		 || i2c_smbus_read_word_data(new_client, i + 2) != hyst
		 || i2c_smbus_read_word_data(new_client, i + 3) != os)
			return -ENODEV;
	}

	strlcpy(info->type, "lm75", I2C_NAME_SIZE);

	return 0;
}

static struct i2c_driver lm75_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name	= "lm75",
	},
	.probe		= lm75_probe,
	.remove		= lm75_remove,
	.id_table	= lm75_ids,
	.detect		= lm75_detect,
	.address_list	= normal_i2c,
};

/*-----------------------------------------------------------------------*/

/* register access */

/* All registers are word-sized, except for the configuration register.
   LM75 uses a high-byte first convention, which is exactly opposite to
   the SMBus standard. */
static int lm75_read_value(struct i2c_client *client, u8 reg)
{
	int value;

	if (reg == LM75_REG_CONF)
		return i2c_smbus_read_byte_data(client, reg);

	value = i2c_smbus_read_word_data(client, reg);
	return (value < 0) ? value : swab16(value);
}

static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
{
	if (reg == LM75_REG_CONF)
		return i2c_smbus_write_byte_data(client, reg, value);
	else
		return i2c_smbus_write_word_data(client, reg, swab16(value));
}

static struct lm75_data *lm75_update_device(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm75_data *data = i2c_get_clientdata(client);

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	    || !data->valid) {
		int i;
		dev_dbg(&client->dev, "Starting lm75 update\n");

		for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
			int status;

			status = lm75_read_value(client, LM75_REG_TEMP[i]);
			if (status < 0)
				dev_dbg(&client->dev, "reg %d, err %d\n",
						LM75_REG_TEMP[i], status);
			else
				data->temp[i] = status;
		}
		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/*-----------------------------------------------------------------------*/

/* module glue */

static int __init sensors_lm75_init(void)
{
	return i2c_add_driver(&lm75_driver);
}

static void __exit sensors_lm75_exit(void)
{
	i2c_del_driver(&lm75_driver);
}

MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
MODULE_DESCRIPTION("LM75 driver");
MODULE_LICENSE("GPL");

module_init(sensors_lm75_init);
module_exit(sensors_lm75_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	lm75.c - Part of lm_sensors, Linux kernel modules for hardware
	3	monitoring
	4	Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20
1da177e4 LT	21	#include <linux/module.h>
	22	#include <linux/init.h>
	23	#include <linux/slab.h>
	24	#include <linux/jiffies.h>
	25	#include <linux/i2c.h>
943b0830	26	#include <linux/hwmon.h>
9ca8e40c	27	#include <linux/hwmon-sysfs.h>
943b0830	28	#include <linux/err.h>
9a61bf63	29	#include <linux/mutex.h>
1da177e4 LT	30	#include "lm75.h"
	31
	32
01a52397 DB	33	/*
01a52397 DB	34	* This driver handles the LM75 and compatible digital temperature sensors.
01a52397 DB	35	*/
01a52397 DB	36
9ebd3d82	37	enum lm75_type { /* keep sorted in alphabetical order */
1f86df49	38	ds1775,
9ebd3d82	39	ds75,
1f86df49	40	lm75,
9ebd3d82 DB	41	lm75a,
	42	max6625,
	43	max6626,
	44	mcp980x,
	45	stds75,
	46	tcn75,
	47	tmp100,
	48	tmp101,
	49	tmp175,
	50	tmp275,
	51	tmp75,
	52	};
	53
8ff69eeb	54	/* Addresses scanned */
25e9c86d	55	static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
1da177e4	56	0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
1da177e4	57
1da177e4 LT	58
1da177e4 LT	59	/* The LM75 registers */
1da177e4	60	#define LM75_REG_CONF 0x01
9ca8e40c JD	61	static const u8 LM75_REG_TEMP[3] = {
	62	0x00, /* input */
	63	0x03, /* max */
	64	0x02, /* hyst */
	65	};
1da177e4 LT	66
	67	/* Each client has this additional data */
	68	struct lm75_data {
01a52397	69	struct device *hwmon_dev;
9a61bf63	70	struct mutex update_lock;
9ebd3d82	71	u8 orig_conf;
01a52397	72	char valid; /* !=0 if registers are valid */
1da177e4	73	unsigned long last_updated; /* In jiffies */
9ca8e40c JD	74	u16 temp[3]; /* Register values,
	75	0 = input
	76	1 = max
	77	2 = hyst */
1da177e4 LT	78	};
1da177e4 LT	79
1da177e4 LT	80	static int lm75_read_value(struct i2c_client *client, u8 reg);
	81	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
	82	static struct lm75_data lm75_update_device(struct device dev);
	83
	84
01a52397 DB	85	/-----------------------------------------------------------------------/
	86
	87	/* sysfs attributes for hwmon */
1da177e4	88
9ca8e40c JD	89	static ssize_t show_temp(struct device dev, struct device_attribute da,
	90	char *buf)
	91	{
	92	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	93	struct lm75_data *data = lm75_update_device(dev);
	94	return sprintf(buf, "%d\n",
	95	LM75_TEMP_FROM_REG(data->temp[attr->index]));
1da177e4	96	}
9ca8e40c JD	97
	98	static ssize_t set_temp(struct device dev, struct device_attribute da,
	99	const char *buf, size_t count)
	100	{
	101	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	102	struct i2c_client *client = to_i2c_client(dev);
	103	struct lm75_data *data = i2c_get_clientdata(client);
	104	int nr = attr->index;
5bfedac0	105	long temp = simple_strtol(buf, NULL, 10);
9ca8e40c JD	106
	107	mutex_lock(&data->update_lock);
	108	data->temp[nr] = LM75_TEMP_TO_REG(temp);
	109	lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
	110	mutex_unlock(&data->update_lock);
	111	return count;
1da177e4	112	}
1da177e4	113
9ca8e40c JD	114	static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR \| S_IRUGO,
	115	show_temp, set_temp, 1);
	116	static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR \| S_IRUGO,
	117	show_temp, set_temp, 2);
	118	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1da177e4	119
c1685f61	120	static struct attribute *lm75_attributes[] = {
9ca8e40c JD	121	&sensor_dev_attr_temp1_input.dev_attr.attr,
	122	&sensor_dev_attr_temp1_max.dev_attr.attr,
	123	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
c1685f61 MH	124
	125	NULL
	126	};
	127
	128	static const struct attribute_group lm75_group = {
	129	.attrs = lm75_attributes,
	130	};
	131
01a52397 DB	132	/-----------------------------------------------------------------------/
01a52397 DB	133
8ff69eeb	134	/* device probe and removal */
9ebd3d82 DB	135
	136	static int
	137	lm75_probe(struct i2c_client client, const struct i2c_device_id id)
	138	{
	139	struct lm75_data *data;
	140	int status;
	141	u8 set_mask, clr_mask;
	142	int new;
	143
	144	if (!i2c_check_functionality(client->adapter,
	145	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA))
	146	return -EIO;
	147
	148	data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
	149	if (!data)
	150	return -ENOMEM;
	151
	152	i2c_set_clientdata(client, data);
9ebd3d82 DB	153	mutex_init(&data->update_lock);
	154
	155	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
	156	* Then tweak to be more precise when appropriate.
	157	*/
	158	set_mask = 0;
	159	clr_mask = (1 << 0) /* continuous conversions */
	160	\| (1 << 6) \| (1 << 5); /* 9-bit mode */
	161
	162	/* configure as specified */
	163	status = lm75_read_value(client, LM75_REG_CONF);
	164	if (status < 0) {
	165	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	166	goto exit_free;
	167	}
	168	data->orig_conf = status;
	169	new = status & ~clr_mask;
	170	new \|= set_mask;
	171	if (status != new)
	172	lm75_write_value(client, LM75_REG_CONF, new);
	173	dev_dbg(&client->dev, "Config %02x\n", new);
	174
	175	/* Register sysfs hooks */
	176	status = sysfs_create_group(&client->dev.kobj, &lm75_group);
	177	if (status)
	178	goto exit_free;
	179
	180	data->hwmon_dev = hwmon_device_register(&client->dev);
	181	if (IS_ERR(data->hwmon_dev)) {
	182	status = PTR_ERR(data->hwmon_dev);
	183	goto exit_remove;
	184	}
	185
	186	dev_info(&client->dev, "%s: sensor '%s'\n",
739cf3a2	187	dev_name(data->hwmon_dev), client->name);
9ebd3d82 DB	188
	189	return 0;
	190
	191	exit_remove:
	192	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	193	exit_free:
	194	i2c_set_clientdata(client, NULL);
	195	kfree(data);
	196	return status;
	197	}
	198
	199	static int lm75_remove(struct i2c_client *client)
	200	{
	201	struct lm75_data *data = i2c_get_clientdata(client);
	202
	203	hwmon_device_unregister(data->hwmon_dev);
	204	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	205	lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
	206	i2c_set_clientdata(client, NULL);
	207	kfree(data);
	208	return 0;
	209	}
	210
	211	static const struct i2c_device_id lm75_ids[] = {
	212	{ "ds1775", ds1775, },
	213	{ "ds75", ds75, },
	214	{ "lm75", lm75, },
	215	{ "lm75a", lm75a, },
	216	{ "max6625", max6625, },
	217	{ "max6626", max6626, },
	218	{ "mcp980x", mcp980x, },
	219	{ "stds75", stds75, },
	220	{ "tcn75", tcn75, },
	221	{ "tmp100", tmp100, },
	222	{ "tmp101", tmp101, },
	223	{ "tmp175", tmp175, },
	224	{ "tmp275", tmp275, },
	225	{ "tmp75", tmp75, },
	226	{ /* LIST END */ }
	227	};
	228	MODULE_DEVICE_TABLE(i2c, lm75_ids);
	229
8ff69eeb	230	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	231	static int lm75_detect(struct i2c_client *new_client,
8ff69eeb	232	struct i2c_board_info *info)
1da177e4	233	{
8ff69eeb	234	struct i2c_adapter *adapter = new_client->adapter;
1da177e4	235	int i;
52df6440	236	int cur, conf, hyst, os;
1da177e4	237
1da177e4 LT	238	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA \|
1da177e4 LT	239	I2C_FUNC_SMBUS_WORD_DATA))
8ff69eeb	240	return -ENODEV;
1da177e4 LT	241
	242	/* Now, we do the remaining detection. There is no identification-
	243	dedicated register so we have to rely on several tricks:
	244	unused bits, registers cycling over 8-address boundaries,
	245	addresses 0x04-0x07 returning the last read value.
	246	The cycling+unused addresses combination is not tested,
	247	since it would significantly slow the detection down and would
	248	hardly add any value. */
1da177e4	249
52df6440 JD	250	/* Unused addresses */
	251	cur = i2c_smbus_read_word_data(new_client, 0);
	252	conf = i2c_smbus_read_byte_data(new_client, 1);
	253	hyst = i2c_smbus_read_word_data(new_client, 2);
	254	if (i2c_smbus_read_word_data(new_client, 4) != hyst
	255	\|\| i2c_smbus_read_word_data(new_client, 5) != hyst
	256	\|\| i2c_smbus_read_word_data(new_client, 6) != hyst
	257	\|\| i2c_smbus_read_word_data(new_client, 7) != hyst)
	258	return -ENODEV;
	259	os = i2c_smbus_read_word_data(new_client, 3);
	260	if (i2c_smbus_read_word_data(new_client, 4) != os
	261	\|\| i2c_smbus_read_word_data(new_client, 5) != os
	262	\|\| i2c_smbus_read_word_data(new_client, 6) != os
	263	\|\| i2c_smbus_read_word_data(new_client, 7) != os)
	264	return -ENODEV;
1da177e4	265
52df6440 JD	266	/* Unused bits */
	267	if (conf & 0xe0)
	268	return -ENODEV;
	269
	270	/* Addresses cycling */
	271	for (i = 8; i < 0xff; i += 8) {
	272	if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
	273	\|\| i2c_smbus_read_word_data(new_client, i + 2) != hyst
	274	\|\| i2c_smbus_read_word_data(new_client, i + 3) != os)
	275	return -ENODEV;
1da177e4 LT	276	}
1da177e4 LT	277
8ff69eeb	278	strlcpy(info->type, "lm75", I2C_NAME_SIZE);
c1685f61	279
1da177e4	280	return 0;
01a52397 DB	281	}
01a52397 DB	282
8ff69eeb JD	283	static struct i2c_driver lm75_driver = {
8ff69eeb JD	284	.class = I2C_CLASS_HWMON,
01a52397	285	.driver = {
8ff69eeb	286	.name = "lm75",
01a52397	287	},
8ff69eeb JD	288	.probe = lm75_probe,
	289	.remove = lm75_remove,
	290	.id_table = lm75_ids,
	291	.detect = lm75_detect,
c3813d6a	292	.address_list = normal_i2c,
01a52397 DB	293	};
	294
	295	/-----------------------------------------------------------------------/
	296
	297	/* register access */
	298
1da177e4 LT	299	/* All registers are word-sized, except for the configuration register.
1da177e4 LT	300	LM75 uses a high-byte first convention, which is exactly opposite to
ccd6befc	301	the SMBus standard. */
1da177e4 LT	302	static int lm75_read_value(struct i2c_client *client, u8 reg)
1da177e4 LT	303	{
bcccc3a2 DB	304	int value;
bcccc3a2 DB	305
1da177e4 LT	306	if (reg == LM75_REG_CONF)
1da177e4 LT	307	return i2c_smbus_read_byte_data(client, reg);
bcccc3a2 DB	308
	309	value = i2c_smbus_read_word_data(client, reg);
	310	return (value < 0) ? value : swab16(value);
1da177e4 LT	311	}
1da177e4 LT	312
1da177e4 LT	313	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
	314	{
	315	if (reg == LM75_REG_CONF)
	316	return i2c_smbus_write_byte_data(client, reg, value);
	317	else
	318	return i2c_smbus_write_word_data(client, reg, swab16(value));
	319	}
	320
1da177e4 LT	321	static struct lm75_data lm75_update_device(struct device dev)
	322	{
	323	struct i2c_client *client = to_i2c_client(dev);
	324	struct lm75_data *data = i2c_get_clientdata(client);
	325
9a61bf63	326	mutex_lock(&data->update_lock);
1da177e4 LT	327
	328	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	329	\|\| !data->valid) {
9ca8e40c	330	int i;
1da177e4 LT	331	dev_dbg(&client->dev, "Starting lm75 update\n");
1da177e4 LT	332
bcccc3a2 DB	333	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
	334	int status;
	335
	336	status = lm75_read_value(client, LM75_REG_TEMP[i]);
	337	if (status < 0)
	338	dev_dbg(&client->dev, "reg %d, err %d\n",
	339	LM75_REG_TEMP[i], status);
	340	else
	341	data->temp[i] = status;
	342	}
1da177e4 LT	343	data->last_updated = jiffies;
	344	data->valid = 1;
	345	}
	346
9a61bf63	347	mutex_unlock(&data->update_lock);
1da177e4 LT	348
	349	return data;
	350	}
	351
01a52397 DB	352	/-----------------------------------------------------------------------/
	353
	354	/* module glue */
	355
1da177e4 LT	356	static int __init sensors_lm75_init(void)
1da177e4 LT	357	{
8ff69eeb	358	return i2c_add_driver(&lm75_driver);
1da177e4 LT	359	}
	360
	361	static void __exit sensors_lm75_exit(void)
	362	{
	363	i2c_del_driver(&lm75_driver);
	364	}
	365
	366	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	367	MODULE_DESCRIPTION("LM75 driver");
	368	MODULE_LICENSE("GPL");
	369
	370	module_init(sensors_lm75_init);
	371	module_exit(sensors_lm75_exit);