[GitHub/mt8127/android_kernel_alcatel_ttab.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:
	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, },
	{ "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;
}

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,
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:
	195	i2c_set_clientdata(client, NULL);
	196	kfree(data);
	197	return status;
	198	}
	199
	200	static int lm75_remove(struct i2c_client *client)
	201	{
	202	struct lm75_data *data = i2c_get_clientdata(client);
	203
	204	hwmon_device_unregister(data->hwmon_dev);
	205	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	206	lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
	207	i2c_set_clientdata(client, NULL);
	208	kfree(data);
	209	return 0;
	210	}
	211
	212	static const struct i2c_device_id lm75_ids[] = {
	213	{ "ds1775", ds1775, },
	214	{ "ds75", ds75, },
	215	{ "lm75", lm75, },
	216	{ "lm75a", lm75a, },
	217	{ "max6625", max6625, },
	218	{ "max6626", max6626, },
	219	{ "mcp980x", mcp980x, },
	220	{ "stds75", stds75, },
	221	{ "tcn75", tcn75, },
	222	{ "tmp100", tmp100, },
	223	{ "tmp101", tmp101, },
6d034059	224	{ "tmp105", tmp105, },
9ebd3d82 DB	225	{ "tmp175", tmp175, },
	226	{ "tmp275", tmp275, },
	227	{ "tmp75", tmp75, },
	228	{ /* LIST END */ }
	229	};
	230	MODULE_DEVICE_TABLE(i2c, lm75_ids);
	231
8ff69eeb	232	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	233	static int lm75_detect(struct i2c_client *new_client,
8ff69eeb	234	struct i2c_board_info *info)
1da177e4	235	{
8ff69eeb	236	struct i2c_adapter *adapter = new_client->adapter;
1da177e4	237	int i;
52df6440	238	int cur, conf, hyst, os;
1da177e4	239
1da177e4 LT	240	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA \|
1da177e4 LT	241	I2C_FUNC_SMBUS_WORD_DATA))
8ff69eeb	242	return -ENODEV;
1da177e4 LT	243
	244	/* Now, we do the remaining detection. There is no identification-
	245	dedicated register so we have to rely on several tricks:
	246	unused bits, registers cycling over 8-address boundaries,
	247	addresses 0x04-0x07 returning the last read value.
	248	The cycling+unused addresses combination is not tested,
	249	since it would significantly slow the detection down and would
	250	hardly add any value. */
1da177e4	251
52df6440 JD	252	/* Unused addresses */
	253	cur = i2c_smbus_read_word_data(new_client, 0);
	254	conf = i2c_smbus_read_byte_data(new_client, 1);
	255	hyst = i2c_smbus_read_word_data(new_client, 2);
	256	if (i2c_smbus_read_word_data(new_client, 4) != hyst
	257	\|\| i2c_smbus_read_word_data(new_client, 5) != hyst
	258	\|\| i2c_smbus_read_word_data(new_client, 6) != hyst
	259	\|\| i2c_smbus_read_word_data(new_client, 7) != hyst)
	260	return -ENODEV;
	261	os = i2c_smbus_read_word_data(new_client, 3);
	262	if (i2c_smbus_read_word_data(new_client, 4) != os
	263	\|\| i2c_smbus_read_word_data(new_client, 5) != os
	264	\|\| i2c_smbus_read_word_data(new_client, 6) != os
	265	\|\| i2c_smbus_read_word_data(new_client, 7) != os)
	266	return -ENODEV;
1da177e4	267
52df6440 JD	268	/* Unused bits */
	269	if (conf & 0xe0)
	270	return -ENODEV;
	271
	272	/* Addresses cycling */
	273	for (i = 8; i < 0xff; i += 8) {
	274	if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
	275	\|\| i2c_smbus_read_word_data(new_client, i + 2) != hyst
	276	\|\| i2c_smbus_read_word_data(new_client, i + 3) != os)
	277	return -ENODEV;
1da177e4 LT	278	}
1da177e4 LT	279
8ff69eeb	280	strlcpy(info->type, "lm75", I2C_NAME_SIZE);
c1685f61	281
1da177e4	282	return 0;
01a52397 DB	283	}
01a52397 DB	284
8ff69eeb JD	285	static struct i2c_driver lm75_driver = {
8ff69eeb JD	286	.class = I2C_CLASS_HWMON,
01a52397	287	.driver = {
8ff69eeb	288	.name = "lm75",
01a52397	289	},
8ff69eeb JD	290	.probe = lm75_probe,
	291	.remove = lm75_remove,
	292	.id_table = lm75_ids,
	293	.detect = lm75_detect,
c3813d6a	294	.address_list = normal_i2c,
01a52397 DB	295	};
	296
	297	/-----------------------------------------------------------------------/
	298
	299	/* register access */
	300
1da177e4 LT	301	/* All registers are word-sized, except for the configuration register.
1da177e4 LT	302	LM75 uses a high-byte first convention, which is exactly opposite to
ccd6befc	303	the SMBus standard. */
1da177e4 LT	304	static int lm75_read_value(struct i2c_client *client, u8 reg)
1da177e4 LT	305	{
bcccc3a2 DB	306	int value;
bcccc3a2 DB	307
1da177e4 LT	308	if (reg == LM75_REG_CONF)
1da177e4 LT	309	return i2c_smbus_read_byte_data(client, reg);
bcccc3a2 DB	310
	311	value = i2c_smbus_read_word_data(client, reg);
	312	return (value < 0) ? value : swab16(value);
1da177e4 LT	313	}
1da177e4 LT	314
1da177e4 LT	315	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
	316	{
	317	if (reg == LM75_REG_CONF)
	318	return i2c_smbus_write_byte_data(client, reg, value);
	319	else
	320	return i2c_smbus_write_word_data(client, reg, swab16(value));
	321	}
	322
1da177e4 LT	323	static struct lm75_data lm75_update_device(struct device dev)
	324	{
	325	struct i2c_client *client = to_i2c_client(dev);
	326	struct lm75_data *data = i2c_get_clientdata(client);
	327
9a61bf63	328	mutex_lock(&data->update_lock);
1da177e4 LT	329
	330	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	331	\|\| !data->valid) {
9ca8e40c	332	int i;
1da177e4 LT	333	dev_dbg(&client->dev, "Starting lm75 update\n");
1da177e4 LT	334
bcccc3a2 DB	335	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
	336	int status;
	337
	338	status = lm75_read_value(client, LM75_REG_TEMP[i]);
	339	if (status < 0)
	340	dev_dbg(&client->dev, "reg %d, err %d\n",
	341	LM75_REG_TEMP[i], status);
	342	else
	343	data->temp[i] = status;
	344	}
1da177e4 LT	345	data->last_updated = jiffies;
	346	data->valid = 1;
	347	}
	348
9a61bf63	349	mutex_unlock(&data->update_lock);
1da177e4 LT	350
	351	return data;
	352	}
	353
01a52397 DB	354	/-----------------------------------------------------------------------/
	355
	356	/* module glue */
	357
1da177e4 LT	358	static int __init sensors_lm75_init(void)
1da177e4 LT	359	{
8ff69eeb	360	return i2c_add_driver(&lm75_driver);
1da177e4 LT	361	}
	362
	363	static void __exit sensors_lm75_exit(void)
	364	{
	365	i2c_del_driver(&lm75_driver);
	366	}
	367
	368	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	369	MODULE_DESCRIPTION("LM75 driver");
	370	MODULE_LICENSE("GPL");
	371
	372	module_init(sensors_lm75_init);
	373	module_exit(sensors_lm75_exit);