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