[deliverable/linux.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 */
	adt75,
	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;
	int error;

	error = strict_strtol(buf, 10, &temp);
	if (error)
		return error;

	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[] = {
	{ "adt75", adt75, },
	{ "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);

#define LM75A_ID 0xA1

/* 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 conf, hyst, os;
	bool is_lm75a = 0;

	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.

	   The National Semiconductor LM75A is different than earlier
	   LM75s.  It has an ID byte of 0xaX (where X is the chip
	   revision, with 1 being the only revision in existence) in
	   register 7, and unused registers return 0xff rather than the
	   last read value. */

	/* Unused bits */
	conf = i2c_smbus_read_byte_data(new_client, 1);
	if (conf & 0xe0)
		return -ENODEV;

	/* First check for LM75A */
	if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
		/* LM75A returns 0xff on unused registers so
		   just to be sure we check for that too. */
		if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
		 || i2c_smbus_read_byte_data(new_client, 5) != 0xff
		 || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
			return -ENODEV;
		is_lm75a = 1;
		hyst = i2c_smbus_read_byte_data(new_client, 2);
		os = i2c_smbus_read_byte_data(new_client, 3);
	} else { /* Traditional style LM75 detection */
		/* Unused addresses */
		hyst = i2c_smbus_read_byte_data(new_client, 2);
		if (i2c_smbus_read_byte_data(new_client, 4) != hyst
		 || i2c_smbus_read_byte_data(new_client, 5) != hyst
		 || i2c_smbus_read_byte_data(new_client, 6) != hyst
		 || i2c_smbus_read_byte_data(new_client, 7) != hyst)
			return -ENODEV;
		os = i2c_smbus_read_byte_data(new_client, 3);
		if (i2c_smbus_read_byte_data(new_client, 4) != os
		 || i2c_smbus_read_byte_data(new_client, 5) != os
		 || i2c_smbus_read_byte_data(new_client, 6) != os
		 || i2c_smbus_read_byte_data(new_client, 7) != os)
			return -ENODEV;
	}

	/* Addresses cycling */
	for (i = 8; i <= 248; i += 40) {
		if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
		 || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
		 || i2c_smbus_read_byte_data(new_client, i + 3) != os)
			return -ENODEV;
		if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
				!= LM75A_ID)
			return -ENODEV;
	}

	strlcpy(info->type, is_lm75a ? "lm75a" : "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	1	/*
caaa0f36 S	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	*/
1da177e4	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 */
e96f9d89	38	adt75,
1f86df49	39	ds1775,
9ebd3d82	40	ds75,
1f86df49	41	lm75,
9ebd3d82 DB	42	lm75a,
	43	max6625,
	44	max6626,
	45	mcp980x,
	46	stds75,
	47	tcn75,
	48	tmp100,
	49	tmp101,
6d034059	50	tmp105,
9ebd3d82 DB	51	tmp175,
	52	tmp275,
	53	tmp75,
	54	};
	55
8ff69eeb	56	/* Addresses scanned */
25e9c86d	57	static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
1da177e4	58	0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
1da177e4	59
1da177e4 LT	60
1da177e4 LT	61	/* The LM75 registers */
1da177e4	62	#define LM75_REG_CONF 0x01
9ca8e40c JD	63	static const u8 LM75_REG_TEMP[3] = {
	64	0x00, /* input */
	65	0x03, /* max */
	66	0x02, /* hyst */
	67	};
1da177e4 LT	68
	69	/* Each client has this additional data */
	70	struct lm75_data {
01a52397	71	struct device *hwmon_dev;
9a61bf63	72	struct mutex update_lock;
9ebd3d82	73	u8 orig_conf;
01a52397	74	char valid; /* !=0 if registers are valid */
1da177e4	75	unsigned long last_updated; /* In jiffies */
9ca8e40c JD	76	u16 temp[3]; /* Register values,
	77	0 = input
	78	1 = max
	79	2 = hyst */
1da177e4 LT	80	};
1da177e4 LT	81
1da177e4 LT	82	static int lm75_read_value(struct i2c_client *client, u8 reg);
	83	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
	84	static struct lm75_data lm75_update_device(struct device dev);
	85
	86
01a52397 DB	87	/-----------------------------------------------------------------------/
	88
	89	/* sysfs attributes for hwmon */
1da177e4	90
9ca8e40c JD	91	static ssize_t show_temp(struct device dev, struct device_attribute da,
	92	char *buf)
	93	{
	94	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	95	struct lm75_data *data = lm75_update_device(dev);
	96	return sprintf(buf, "%d\n",
	97	LM75_TEMP_FROM_REG(data->temp[attr->index]));
1da177e4	98	}
9ca8e40c JD	99
	100	static ssize_t set_temp(struct device dev, struct device_attribute da,
	101	const char *buf, size_t count)
	102	{
	103	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	104	struct i2c_client *client = to_i2c_client(dev);
	105	struct lm75_data *data = i2c_get_clientdata(client);
	106	int nr = attr->index;
e3cd9528 S	107	long temp;
	108	int error;
	109
	110	error = strict_strtol(buf, 10, &temp);
	111	if (error)
	112	return error;
9ca8e40c JD	113
	114	mutex_lock(&data->update_lock);
	115	data->temp[nr] = LM75_TEMP_TO_REG(temp);
	116	lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
	117	mutex_unlock(&data->update_lock);
	118	return count;
1da177e4	119	}
1da177e4	120
9ca8e40c JD	121	static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR \| S_IRUGO,
	122	show_temp, set_temp, 1);
	123	static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR \| S_IRUGO,
	124	show_temp, set_temp, 2);
	125	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1da177e4	126
c1685f61	127	static struct attribute *lm75_attributes[] = {
9ca8e40c JD	128	&sensor_dev_attr_temp1_input.dev_attr.attr,
	129	&sensor_dev_attr_temp1_max.dev_attr.attr,
	130	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
c1685f61 MH	131
	132	NULL
	133	};
	134
	135	static const struct attribute_group lm75_group = {
	136	.attrs = lm75_attributes,
	137	};
	138
01a52397 DB	139	/-----------------------------------------------------------------------/
01a52397 DB	140
8ff69eeb	141	/* device probe and removal */
9ebd3d82 DB	142
	143	static int
	144	lm75_probe(struct i2c_client client, const struct i2c_device_id id)
	145	{
	146	struct lm75_data *data;
	147	int status;
	148	u8 set_mask, clr_mask;
	149	int new;
	150
	151	if (!i2c_check_functionality(client->adapter,
	152	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA))
	153	return -EIO;
	154
	155	data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
	156	if (!data)
	157	return -ENOMEM;
	158
	159	i2c_set_clientdata(client, data);
9ebd3d82 DB	160	mutex_init(&data->update_lock);
	161
	162	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
	163	* Then tweak to be more precise when appropriate.
	164	*/
	165	set_mask = 0;
	166	clr_mask = (1 << 0) /* continuous conversions */
	167	\| (1 << 6) \| (1 << 5); /* 9-bit mode */
	168
	169	/* configure as specified */
	170	status = lm75_read_value(client, LM75_REG_CONF);
	171	if (status < 0) {
	172	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	173	goto exit_free;
	174	}
	175	data->orig_conf = status;
	176	new = status & ~clr_mask;
	177	new \|= set_mask;
	178	if (status != new)
	179	lm75_write_value(client, LM75_REG_CONF, new);
	180	dev_dbg(&client->dev, "Config %02x\n", new);
	181
	182	/* Register sysfs hooks */
	183	status = sysfs_create_group(&client->dev.kobj, &lm75_group);
	184	if (status)
	185	goto exit_free;
	186
	187	data->hwmon_dev = hwmon_device_register(&client->dev);
	188	if (IS_ERR(data->hwmon_dev)) {
	189	status = PTR_ERR(data->hwmon_dev);
	190	goto exit_remove;
	191	}
	192
	193	dev_info(&client->dev, "%s: sensor '%s'\n",
739cf3a2	194	dev_name(data->hwmon_dev), client->name);
9ebd3d82 DB	195
	196	return 0;
	197
	198	exit_remove:
	199	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	200	exit_free:
9ebd3d82 DB	201	kfree(data);
	202	return status;
	203	}
	204
	205	static int lm75_remove(struct i2c_client *client)
	206	{
	207	struct lm75_data *data = i2c_get_clientdata(client);
	208
	209	hwmon_device_unregister(data->hwmon_dev);
	210	sysfs_remove_group(&client->dev.kobj, &lm75_group);
	211	lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
9ebd3d82 DB	212	kfree(data);
	213	return 0;
	214	}
	215
	216	static const struct i2c_device_id lm75_ids[] = {
e96f9d89	217	{ "adt75", adt75, },
9ebd3d82 DB	218	{ "ds1775", ds1775, },
	219	{ "ds75", ds75, },
	220	{ "lm75", lm75, },
	221	{ "lm75a", lm75a, },
	222	{ "max6625", max6625, },
	223	{ "max6626", max6626, },
	224	{ "mcp980x", mcp980x, },
	225	{ "stds75", stds75, },
	226	{ "tcn75", tcn75, },
	227	{ "tmp100", tmp100, },
	228	{ "tmp101", tmp101, },
6d034059	229	{ "tmp105", tmp105, },
9ebd3d82 DB	230	{ "tmp175", tmp175, },
	231	{ "tmp275", tmp275, },
	232	{ "tmp75", tmp75, },
	233	{ /* LIST END */ }
	234	};
	235	MODULE_DEVICE_TABLE(i2c, lm75_ids);
	236
05e82fe4 LS	237	#define LM75A_ID 0xA1
05e82fe4 LS	238
8ff69eeb	239	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	240	static int lm75_detect(struct i2c_client *new_client,
8ff69eeb	241	struct i2c_board_info *info)
1da177e4	242	{
8ff69eeb	243	struct i2c_adapter *adapter = new_client->adapter;
1da177e4	244	int i;
e76f67b5	245	int conf, hyst, os;
05e82fe4	246	bool is_lm75a = 0;
1da177e4	247
1da177e4 LT	248	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA \|
1da177e4 LT	249	I2C_FUNC_SMBUS_WORD_DATA))
8ff69eeb	250	return -ENODEV;
1da177e4 LT	251
	252	/* Now, we do the remaining detection. There is no identification-
	253	dedicated register so we have to rely on several tricks:
	254	unused bits, registers cycling over 8-address boundaries,
	255	addresses 0x04-0x07 returning the last read value.
	256	The cycling+unused addresses combination is not tested,
	257	since it would significantly slow the detection down and would
05e82fe4 LS	258	hardly add any value.
	259
	260	The National Semiconductor LM75A is different than earlier
	261	LM75s. It has an ID byte of 0xaX (where X is the chip
	262	revision, with 1 being the only revision in existence) in
	263	register 7, and unused registers return 0xff rather than the
	264	last read value. */
1da177e4	265
e76f67b5	266	/* Unused bits */
52df6440	267	conf = i2c_smbus_read_byte_data(new_client, 1);
e76f67b5 JD	268	if (conf & 0xe0)
e76f67b5 JD	269	return -ENODEV;
05e82fe4 LS	270
	271	/* First check for LM75A */
	272	if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
	273	/* LM75A returns 0xff on unused registers so
	274	just to be sure we check for that too. */
	275	if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
	276	\|\| i2c_smbus_read_byte_data(new_client, 5) != 0xff
	277	\|\| i2c_smbus_read_byte_data(new_client, 6) != 0xff)
	278	return -ENODEV;
	279	is_lm75a = 1;
e76f67b5 JD	280	hyst = i2c_smbus_read_byte_data(new_client, 2);
e76f67b5 JD	281	os = i2c_smbus_read_byte_data(new_client, 3);
05e82fe4 LS	282	} else { /* Traditional style LM75 detection */
05e82fe4 LS	283	/* Unused addresses */
e76f67b5 JD	284	hyst = i2c_smbus_read_byte_data(new_client, 2);
	285	if (i2c_smbus_read_byte_data(new_client, 4) != hyst
	286	\|\| i2c_smbus_read_byte_data(new_client, 5) != hyst
	287	\|\| i2c_smbus_read_byte_data(new_client, 6) != hyst
	288	\|\| i2c_smbus_read_byte_data(new_client, 7) != hyst)
05e82fe4	289	return -ENODEV;
e76f67b5 JD	290	os = i2c_smbus_read_byte_data(new_client, 3);
	291	if (i2c_smbus_read_byte_data(new_client, 4) != os
	292	\|\| i2c_smbus_read_byte_data(new_client, 5) != os
	293	\|\| i2c_smbus_read_byte_data(new_client, 6) != os
	294	\|\| i2c_smbus_read_byte_data(new_client, 7) != os)
05e82fe4 LS	295	return -ENODEV;
05e82fe4 LS	296	}
1da177e4	297
52df6440	298	/* Addresses cycling */
e76f67b5	299	for (i = 8; i <= 248; i += 40) {
52df6440	300	if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
e76f67b5 JD	301	\|\| i2c_smbus_read_byte_data(new_client, i + 2) != hyst
e76f67b5 JD	302	\|\| i2c_smbus_read_byte_data(new_client, i + 3) != os)
52df6440	303	return -ENODEV;
05e82fe4 LS	304	if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
	305	!= LM75A_ID)
	306	return -ENODEV;
1da177e4 LT	307	}
1da177e4 LT	308
05e82fe4	309	strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
c1685f61	310
1da177e4	311	return 0;
01a52397 DB	312	}
01a52397 DB	313
9914518e SD	314	#ifdef CONFIG_PM
	315	static int lm75_suspend(struct device *dev)
	316	{
	317	int status;
	318	struct i2c_client *client = to_i2c_client(dev);
	319	status = lm75_read_value(client, LM75_REG_CONF);
	320	if (status < 0) {
	321	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	322	return status;
	323	}
	324	status = status \| LM75_SHUTDOWN;
	325	lm75_write_value(client, LM75_REG_CONF, status);
	326	return 0;
	327	}
	328
	329	static int lm75_resume(struct device *dev)
	330	{
	331	int status;
	332	struct i2c_client *client = to_i2c_client(dev);
	333	status = lm75_read_value(client, LM75_REG_CONF);
	334	if (status < 0) {
	335	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	336	return status;
	337	}
	338	status = status & ~LM75_SHUTDOWN;
	339	lm75_write_value(client, LM75_REG_CONF, status);
	340	return 0;
	341	}
	342
	343	static const struct dev_pm_ops lm75_dev_pm_ops = {
	344	.suspend = lm75_suspend,
	345	.resume = lm75_resume,
	346	};
	347	#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
	348	#else
	349	#define LM75_DEV_PM_OPS NULL
	350	#endif /* CONFIG_PM */
	351
8ff69eeb JD	352	static struct i2c_driver lm75_driver = {
8ff69eeb JD	353	.class = I2C_CLASS_HWMON,
01a52397	354	.driver = {
8ff69eeb	355	.name = "lm75",
9914518e	356	.pm = LM75_DEV_PM_OPS,
01a52397	357	},
8ff69eeb JD	358	.probe = lm75_probe,
	359	.remove = lm75_remove,
	360	.id_table = lm75_ids,
	361	.detect = lm75_detect,
c3813d6a	362	.address_list = normal_i2c,
01a52397 DB	363	};
	364
	365	/-----------------------------------------------------------------------/
	366
	367	/* register access */
	368
caaa0f36 S	369	/*
	370	* All registers are word-sized, except for the configuration register.
	371	* LM75 uses a high-byte first convention, which is exactly opposite to
	372	* the SMBus standard.
	373	*/
1da177e4 LT	374	static int lm75_read_value(struct i2c_client *client, u8 reg)
1da177e4 LT	375	{
bcccc3a2 DB	376	int value;
bcccc3a2 DB	377
1da177e4 LT	378	if (reg == LM75_REG_CONF)
1da177e4 LT	379	return i2c_smbus_read_byte_data(client, reg);
bcccc3a2 DB	380
	381	value = i2c_smbus_read_word_data(client, reg);
	382	return (value < 0) ? value : swab16(value);
1da177e4 LT	383	}
1da177e4 LT	384
1da177e4 LT	385	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
	386	{
	387	if (reg == LM75_REG_CONF)
	388	return i2c_smbus_write_byte_data(client, reg, value);
	389	else
	390	return i2c_smbus_write_word_data(client, reg, swab16(value));
	391	}
	392
1da177e4 LT	393	static struct lm75_data lm75_update_device(struct device dev)
	394	{
	395	struct i2c_client *client = to_i2c_client(dev);
	396	struct lm75_data *data = i2c_get_clientdata(client);
	397
9a61bf63	398	mutex_lock(&data->update_lock);
1da177e4 LT	399
	400	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	401	\|\| !data->valid) {
9ca8e40c	402	int i;
1da177e4 LT	403	dev_dbg(&client->dev, "Starting lm75 update\n");
1da177e4 LT	404
bcccc3a2 DB	405	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
	406	int status;
	407
	408	status = lm75_read_value(client, LM75_REG_TEMP[i]);
	409	if (status < 0)
	410	dev_dbg(&client->dev, "reg %d, err %d\n",
	411	LM75_REG_TEMP[i], status);
	412	else
	413	data->temp[i] = status;
	414	}
1da177e4 LT	415	data->last_updated = jiffies;
	416	data->valid = 1;
	417	}
	418
9a61bf63	419	mutex_unlock(&data->update_lock);
1da177e4 LT	420
	421	return data;
	422	}
	423
01a52397 DB	424	/-----------------------------------------------------------------------/
	425
	426	/* module glue */
	427
1da177e4 LT	428	static int __init sensors_lm75_init(void)
1da177e4 LT	429	{
8ff69eeb	430	return i2c_add_driver(&lm75_driver);
1da177e4 LT	431	}
	432
	433	static void __exit sensors_lm75_exit(void)
	434	{
	435	i2c_del_driver(&lm75_driver);
	436	}
	437
	438	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	439	MODULE_DESCRIPTION("LM75 driver");
	440	MODULE_LICENSE("GPL");
	441
	442	module_init(sensors_lm75_init);
	443	module_exit(sensors_lm75_exit);