[net-next-2.6.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,
	tmp105,
	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:
	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);
	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, },
	{ "tmp105", tmp105, },
	{ "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;
}

#ifdef CONFIG_PM
static int lm75_suspend(struct device *dev)
{
	int status;
	struct i2c_client *client = to_i2c_client(dev);
	status = lm75_read_value(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(&client->dev, "Can't read config? %d\n", status);
		return status;
	}
	status = status | LM75_SHUTDOWN;
	lm75_write_value(client, LM75_REG_CONF, status);
	return 0;
}

static int lm75_resume(struct device *dev)
{
	int status;
	struct i2c_client *client = to_i2c_client(dev);
	status = lm75_read_value(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(&client->dev, "Can't read config? %d\n", status);
		return status;
	}
	status = status & ~LM75_SHUTDOWN;
	lm75_write_value(client, LM75_REG_CONF, status);
	return 0;
}

static const struct dev_pm_ops lm75_dev_pm_ops = {
	.suspend	= lm75_suspend,
	.resume		= lm75_resume,
};
#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
#else
#define LM75_DEV_PM_OPS NULL
#endif /* CONFIG_PM */

static struct i2c_driver lm75_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name	= "lm75",
		.pm	= LM75_DEV_PM_OPS,
	},
	.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,
6d034059	49	tmp105,
9ebd3d82 DB	50	tmp175,
	51	tmp275,
	52	tmp75,
	53	};
	54
8ff69eeb	55	/* Addresses scanned */
25e9c86d	56	static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
1da177e4	57	0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
1da177e4	58
1da177e4 LT	59
1da177e4 LT	60	/* The LM75 registers */
1da177e4	61	#define LM75_REG_CONF 0x01
9ca8e40c JD	62	static const u8 LM75_REG_TEMP[3] = {
	63	0x00, /* input */
	64	0x03, /* max */
	65	0x02, /* hyst */
	66	};
1da177e4 LT	67
	68	/* Each client has this additional data */
	69	struct lm75_data {
01a52397	70	struct device *hwmon_dev;
9a61bf63	71	struct mutex update_lock;
9ebd3d82	72	u8 orig_conf;
01a52397	73	char valid; /* !=0 if registers are valid */
1da177e4	74	unsigned long last_updated; /* In jiffies */
9ca8e40c JD	75	u16 temp[3]; /* Register values,
	76	0 = input
	77	1 = max
	78	2 = hyst */
1da177e4 LT	79	};
1da177e4 LT	80
1da177e4 LT	81	static int lm75_read_value(struct i2c_client *client, u8 reg);
	82	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
	83	static struct lm75_data lm75_update_device(struct device dev);
	84
	85
01a52397 DB	86	/-----------------------------------------------------------------------/
	87
	88	/* sysfs attributes for hwmon */
1da177e4	89
9ca8e40c JD	90	static ssize_t show_temp(struct device dev, struct device_attribute da,
	91	char *buf)
	92	{
	93	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	94	struct lm75_data *data = lm75_update_device(dev);
	95	return sprintf(buf, "%d\n",
	96	LM75_TEMP_FROM_REG(data->temp[attr->index]));
1da177e4	97	}
9ca8e40c JD	98
	99	static ssize_t set_temp(struct device dev, struct device_attribute da,
	100	const char *buf, size_t count)
	101	{
	102	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	103	struct i2c_client *client = to_i2c_client(dev);
	104	struct lm75_data *data = i2c_get_clientdata(client);
	105	int nr = attr->index;
5bfedac0	106	long temp = simple_strtol(buf, NULL, 10);
9ca8e40c JD	107
	108	mutex_lock(&data->update_lock);
	109	data->temp[nr] = LM75_TEMP_TO_REG(temp);
	110	lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
	111	mutex_unlock(&data->update_lock);
	112	return count;
1da177e4	113	}
1da177e4	114
9ca8e40c JD	115	static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR \| S_IRUGO,
	116	show_temp, set_temp, 1);
	117	static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR \| S_IRUGO,
	118	show_temp, set_temp, 2);
	119	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1da177e4	120
c1685f61	121	static struct attribute *lm75_attributes[] = {
9ca8e40c JD	122	&sensor_dev_attr_temp1_input.dev_attr.attr,
	123	&sensor_dev_attr_temp1_max.dev_attr.attr,
	124	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
c1685f61 MH	125
	126	NULL
	127	};
	128
	129	static const struct attribute_group lm75_group = {
	130	.attrs = lm75_attributes,
	131	};
	132
01a52397 DB	133	/-----------------------------------------------------------------------/
01a52397 DB	134
8ff69eeb	135	/* device probe and removal */
9ebd3d82 DB	136
	137	static int
	138	lm75_probe(struct i2c_client client, const struct i2c_device_id id)
	139	{
	140	struct lm75_data *data;
	141	int status;
	142	u8 set_mask, clr_mask;
	143	int new;
	144
	145	if (!i2c_check_functionality(client->adapter,
	146	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA))
	147	return -EIO;
	148
	149	data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
	150	if (!data)
	151	return -ENOMEM;
	152
	153	i2c_set_clientdata(client, data);
9ebd3d82 DB	154	mutex_init(&data->update_lock);
	155
	156	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
	157	* Then tweak to be more precise when appropriate.
	158	*/
	159	set_mask = 0;
	160	clr_mask = (1 << 0) /* continuous conversions */
	161	\| (1 << 6) \| (1 << 5); /* 9-bit mode */
	162
	163	/* configure as specified */
	164	status = lm75_read_value(client, LM75_REG_CONF);
	165	if (status < 0) {
	166	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	167	goto exit_free;
	168	}
	169	data->orig_conf = status;
	170	new = status & ~clr_mask;
	171	new \|= set_mask;
	172	if (status != new)
	173	lm75_write_value(client, LM75_REG_CONF, new);
	174	dev_dbg(&client->dev, "Config %02x\n", new);
	175
	176	/* Register sysfs hooks */
	177	status = sysfs_create_group(&client->dev.kobj, &lm75_group);
	178	if (status)
	179	goto exit_free;
	180
	181	data->hwmon_dev = hwmon_device_register(&client->dev);
	182	if (IS_ERR(data->hwmon_dev)) {
	183	status = PTR_ERR(data->hwmon_dev);
	184	goto exit_remove;
	185	}
	186
	187	dev_info(&client->dev, "%s: sensor '%s'\n",
739cf3a2	188	dev_name(data->hwmon_dev), client->name);
9ebd3d82 DB	189
	190	return 0;
	191
	192	exit_remove:
	193	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	194	exit_free:
9ebd3d82 DB	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);
9ebd3d82 DB	206	kfree(data);
	207	return 0;
	208	}
	209
	210	static const struct i2c_device_id lm75_ids[] = {
	211	{ "ds1775", ds1775, },
	212	{ "ds75", ds75, },
	213	{ "lm75", lm75, },
	214	{ "lm75a", lm75a, },
	215	{ "max6625", max6625, },
	216	{ "max6626", max6626, },
	217	{ "mcp980x", mcp980x, },
	218	{ "stds75", stds75, },
	219	{ "tcn75", tcn75, },
	220	{ "tmp100", tmp100, },
	221	{ "tmp101", tmp101, },
6d034059	222	{ "tmp105", tmp105, },
9ebd3d82 DB	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
9914518e SD	283	#ifdef CONFIG_PM
	284	static int lm75_suspend(struct device *dev)
	285	{
	286	int status;
	287	struct i2c_client *client = to_i2c_client(dev);
	288	status = lm75_read_value(client, LM75_REG_CONF);
	289	if (status < 0) {
	290	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	291	return status;
	292	}
	293	status = status \| LM75_SHUTDOWN;
	294	lm75_write_value(client, LM75_REG_CONF, status);
	295	return 0;
	296	}
	297
	298	static int lm75_resume(struct device *dev)
	299	{
	300	int status;
	301	struct i2c_client *client = to_i2c_client(dev);
	302	status = lm75_read_value(client, LM75_REG_CONF);
	303	if (status < 0) {
	304	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	305	return status;
	306	}
	307	status = status & ~LM75_SHUTDOWN;
	308	lm75_write_value(client, LM75_REG_CONF, status);
	309	return 0;
	310	}
	311
	312	static const struct dev_pm_ops lm75_dev_pm_ops = {
	313	.suspend = lm75_suspend,
	314	.resume = lm75_resume,
	315	};
	316	#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
	317	#else
	318	#define LM75_DEV_PM_OPS NULL
	319	#endif /* CONFIG_PM */
	320
8ff69eeb JD	321	static struct i2c_driver lm75_driver = {
8ff69eeb JD	322	.class = I2C_CLASS_HWMON,
01a52397	323	.driver = {
8ff69eeb	324	.name = "lm75",
9914518e	325	.pm = LM75_DEV_PM_OPS,
01a52397	326	},
8ff69eeb JD	327	.probe = lm75_probe,
	328	.remove = lm75_remove,
	329	.id_table = lm75_ids,
	330	.detect = lm75_detect,
c3813d6a	331	.address_list = normal_i2c,
01a52397 DB	332	};
	333
	334	/-----------------------------------------------------------------------/
	335
	336	/* register access */
	337
1da177e4 LT	338	/* All registers are word-sized, except for the configuration register.
1da177e4 LT	339	LM75 uses a high-byte first convention, which is exactly opposite to
ccd6befc	340	the SMBus standard. */
1da177e4 LT	341	static int lm75_read_value(struct i2c_client *client, u8 reg)
1da177e4 LT	342	{
bcccc3a2 DB	343	int value;
bcccc3a2 DB	344
1da177e4 LT	345	if (reg == LM75_REG_CONF)
1da177e4 LT	346	return i2c_smbus_read_byte_data(client, reg);
bcccc3a2 DB	347
	348	value = i2c_smbus_read_word_data(client, reg);
	349	return (value < 0) ? value : swab16(value);
1da177e4 LT	350	}
1da177e4 LT	351
1da177e4 LT	352	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
	353	{
	354	if (reg == LM75_REG_CONF)
	355	return i2c_smbus_write_byte_data(client, reg, value);
	356	else
	357	return i2c_smbus_write_word_data(client, reg, swab16(value));
	358	}
	359
1da177e4 LT	360	static struct lm75_data lm75_update_device(struct device dev)
	361	{
	362	struct i2c_client *client = to_i2c_client(dev);
	363	struct lm75_data *data = i2c_get_clientdata(client);
	364
9a61bf63	365	mutex_lock(&data->update_lock);
1da177e4 LT	366
	367	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	368	\|\| !data->valid) {
9ca8e40c	369	int i;
1da177e4 LT	370	dev_dbg(&client->dev, "Starting lm75 update\n");
1da177e4 LT	371
bcccc3a2 DB	372	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
	373	int status;
	374
	375	status = lm75_read_value(client, LM75_REG_TEMP[i]);
	376	if (status < 0)
	377	dev_dbg(&client->dev, "reg %d, err %d\n",
	378	LM75_REG_TEMP[i], status);
	379	else
	380	data->temp[i] = status;
	381	}
1da177e4 LT	382	data->last_updated = jiffies;
	383	data->valid = 1;
	384	}
	385
9a61bf63	386	mutex_unlock(&data->update_lock);
1da177e4 LT	387
	388	return data;
	389	}
	390
01a52397 DB	391	/-----------------------------------------------------------------------/
	392
	393	/* module glue */
	394
1da177e4 LT	395	static int __init sensors_lm75_init(void)
1da177e4 LT	396	{
8ff69eeb	397	return i2c_add_driver(&lm75_driver);
1da177e4 LT	398	}
	399
	400	static void __exit sensors_lm75_exit(void)
	401	{
	402	i2c_del_driver(&lm75_driver);
	403	}
	404
	405	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	406	MODULE_DESCRIPTION("LM75 driver");
	407	MODULE_LICENSE("GPL");
	408
	409	module_init(sensors_lm75_init);
	410	module_exit(sensors_lm75_exit);