[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);

	if (IS_ERR(data))
		return PTR_ERR(data);

	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 = kstrtol(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 = devm_kzalloc(&client->dev, 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 = LM75_SHUTDOWN;		/* continuous conversions */

	switch (id->driver_data) {
	case adt75:
		clr_mask |= 1 << 5;		/* not one-shot mode */
		break;
	case ds1775:
	case ds75:
	case stds75:
		clr_mask |= 3 << 5;		/* 9-bit mode */
		break;
	case mcp980x:
	case tmp100:
	case tmp101:
	case tmp105:
	case tmp175:
	case tmp275:
	case tmp75:
		clr_mask |= 3 << 5;		/* 9-bit mode */
		clr_mask |= 1 << 7;		/* not one-shot mode */
		break;
	}

	/* 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);
		return status;
	}
	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)
		return status;

	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);
	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);
	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.
	 *
	 * Note that this function only detects the original National
	 * Semiconductor LM75 and the LM75A. Clones from other vendors
	 * aren't detected, on purpose, because they are typically never
	 * found on PC hardware. They are found on embedded designs where
	 * they can be instantiated explicitly so detection is not needed.
	 * The absence of identification registers on all these clones
	 * would make their exhaustive detection very difficult and weak,
	 * and odds are that the driver would bind to unsupported devices.
	 */

	/* 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)
{
	if (reg == LM75_REG_CONF)
		return i2c_smbus_read_byte_data(client, reg);
	else
		return i2c_smbus_read_word_swapped(client, reg);
}

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_swapped(client, reg, 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);
	struct lm75_data *ret = data;

	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 (unlikely(status < 0)) {
				dev_dbg(dev,
					"LM75: Failed to read value: reg %d, error %d\n",
					LM75_REG_TEMP[i], status);
				ret = ERR_PTR(status);
				data->valid = 0;
				goto abort;
			}
			data->temp[i] = status;
		}
		data->last_updated = jiffies;
		data->valid = 1;
	}

abort:
	mutex_unlock(&data->update_lock);
	return ret;
}

module_i2c_driver(lm75_driver);

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