[mirror_ubuntu-bionic-kernel.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.
	 *
	 * 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)
{
	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	251
426343ef JD	252	/*
	253	* Now, we do the remaining detection. There is no identification-
	254	* dedicated register so we have to rely on several tricks:
	255	* unused bits, registers cycling over 8-address boundaries,
	256	* addresses 0x04-0x07 returning the last read value.
	257	* The cycling+unused addresses combination is not tested,
	258	* since it would significantly slow the detection down and would
	259	* hardly add any value.
	260	*
	261	* The National Semiconductor LM75A is different than earlier
	262	* LM75s. It has an ID byte of 0xaX (where X is the chip
	263	* revision, with 1 being the only revision in existence) in
	264	* register 7, and unused registers return 0xff rather than the
	265	* last read value.
	266	*
	267	* Note that this function only detects the original National
	268	* Semiconductor LM75 and the LM75A. Clones from other vendors
	269	* aren't detected, on purpose, because they are typically never
	270	* found on PC hardware. They are found on embedded designs where
	271	* they can be instantiated explicitly so detection is not needed.
	272	* The absence of identification registers on all these clones
	273	* would make their exhaustive detection very difficult and weak,
	274	* and odds are that the driver would bind to unsupported devices.
	275	*/
1da177e4	276
e76f67b5	277	/* Unused bits */
52df6440	278	conf = i2c_smbus_read_byte_data(new_client, 1);
e76f67b5 JD	279	if (conf & 0xe0)
e76f67b5 JD	280	return -ENODEV;
05e82fe4 LS	281
	282	/* First check for LM75A */
	283	if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
	284	/* LM75A returns 0xff on unused registers so
	285	just to be sure we check for that too. */
	286	if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
	287	\|\| i2c_smbus_read_byte_data(new_client, 5) != 0xff
	288	\|\| i2c_smbus_read_byte_data(new_client, 6) != 0xff)
	289	return -ENODEV;
	290	is_lm75a = 1;
e76f67b5 JD	291	hyst = i2c_smbus_read_byte_data(new_client, 2);
e76f67b5 JD	292	os = i2c_smbus_read_byte_data(new_client, 3);
05e82fe4 LS	293	} else { /* Traditional style LM75 detection */
05e82fe4 LS	294	/* Unused addresses */
e76f67b5 JD	295	hyst = i2c_smbus_read_byte_data(new_client, 2);
	296	if (i2c_smbus_read_byte_data(new_client, 4) != hyst
	297	\|\| i2c_smbus_read_byte_data(new_client, 5) != hyst
	298	\|\| i2c_smbus_read_byte_data(new_client, 6) != hyst
	299	\|\| i2c_smbus_read_byte_data(new_client, 7) != hyst)
05e82fe4	300	return -ENODEV;
e76f67b5 JD	301	os = i2c_smbus_read_byte_data(new_client, 3);
	302	if (i2c_smbus_read_byte_data(new_client, 4) != os
	303	\|\| i2c_smbus_read_byte_data(new_client, 5) != os
	304	\|\| i2c_smbus_read_byte_data(new_client, 6) != os
	305	\|\| i2c_smbus_read_byte_data(new_client, 7) != os)
05e82fe4 LS	306	return -ENODEV;
05e82fe4 LS	307	}
1da177e4	308
52df6440	309	/* Addresses cycling */
e76f67b5	310	for (i = 8; i <= 248; i += 40) {
52df6440	311	if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
e76f67b5 JD	312	\|\| i2c_smbus_read_byte_data(new_client, i + 2) != hyst
e76f67b5 JD	313	\|\| i2c_smbus_read_byte_data(new_client, i + 3) != os)
52df6440	314	return -ENODEV;
05e82fe4 LS	315	if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
	316	!= LM75A_ID)
	317	return -ENODEV;
1da177e4 LT	318	}
1da177e4 LT	319
05e82fe4	320	strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
c1685f61	321
1da177e4	322	return 0;
01a52397 DB	323	}
01a52397 DB	324
9914518e SD	325	#ifdef CONFIG_PM
	326	static int lm75_suspend(struct device *dev)
	327	{
	328	int status;
	329	struct i2c_client *client = to_i2c_client(dev);
	330	status = lm75_read_value(client, LM75_REG_CONF);
	331	if (status < 0) {
	332	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	333	return status;
	334	}
	335	status = status \| LM75_SHUTDOWN;
	336	lm75_write_value(client, LM75_REG_CONF, status);
	337	return 0;
	338	}
	339
	340	static int lm75_resume(struct device *dev)
	341	{
	342	int status;
	343	struct i2c_client *client = to_i2c_client(dev);
	344	status = lm75_read_value(client, LM75_REG_CONF);
	345	if (status < 0) {
	346	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	347	return status;
	348	}
	349	status = status & ~LM75_SHUTDOWN;
	350	lm75_write_value(client, LM75_REG_CONF, status);
	351	return 0;
	352	}
	353
	354	static const struct dev_pm_ops lm75_dev_pm_ops = {
	355	.suspend = lm75_suspend,
	356	.resume = lm75_resume,
	357	};
	358	#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
	359	#else
	360	#define LM75_DEV_PM_OPS NULL
	361	#endif /* CONFIG_PM */
	362
8ff69eeb JD	363	static struct i2c_driver lm75_driver = {
8ff69eeb JD	364	.class = I2C_CLASS_HWMON,
01a52397	365	.driver = {
8ff69eeb	366	.name = "lm75",
9914518e	367	.pm = LM75_DEV_PM_OPS,
01a52397	368	},
8ff69eeb JD	369	.probe = lm75_probe,
	370	.remove = lm75_remove,
	371	.id_table = lm75_ids,
	372	.detect = lm75_detect,
c3813d6a	373	.address_list = normal_i2c,
01a52397 DB	374	};
	375
	376	/-----------------------------------------------------------------------/
	377
	378	/* register access */
	379
caaa0f36 S	380	/*
	381	* All registers are word-sized, except for the configuration register.
	382	* LM75 uses a high-byte first convention, which is exactly opposite to
	383	* the SMBus standard.
	384	*/
1da177e4 LT	385	static int lm75_read_value(struct i2c_client *client, u8 reg)
1da177e4 LT	386	{
bcccc3a2 DB	387	int value;
bcccc3a2 DB	388
1da177e4 LT	389	if (reg == LM75_REG_CONF)
1da177e4 LT	390	return i2c_smbus_read_byte_data(client, reg);
bcccc3a2 DB	391
	392	value = i2c_smbus_read_word_data(client, reg);
	393	return (value < 0) ? value : swab16(value);
1da177e4 LT	394	}
1da177e4 LT	395
1da177e4 LT	396	static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
	397	{
	398	if (reg == LM75_REG_CONF)
	399	return i2c_smbus_write_byte_data(client, reg, value);
	400	else
	401	return i2c_smbus_write_word_data(client, reg, swab16(value));
	402	}
	403
1da177e4 LT	404	static struct lm75_data lm75_update_device(struct device dev)
	405	{
	406	struct i2c_client *client = to_i2c_client(dev);
	407	struct lm75_data *data = i2c_get_clientdata(client);
	408
9a61bf63	409	mutex_lock(&data->update_lock);
1da177e4 LT	410
	411	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	412	\|\| !data->valid) {
9ca8e40c	413	int i;
1da177e4 LT	414	dev_dbg(&client->dev, "Starting lm75 update\n");
1da177e4 LT	415
bcccc3a2 DB	416	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
	417	int status;
	418
	419	status = lm75_read_value(client, LM75_REG_TEMP[i]);
	420	if (status < 0)
	421	dev_dbg(&client->dev, "reg %d, err %d\n",
	422	LM75_REG_TEMP[i], status);
	423	else
	424	data->temp[i] = status;
	425	}
1da177e4 LT	426	data->last_updated = jiffies;
	427	data->valid = 1;
	428	}
	429
9a61bf63	430	mutex_unlock(&data->update_lock);
1da177e4 LT	431
	432	return data;
	433	}
	434
01a52397 DB	435	/-----------------------------------------------------------------------/
	436
	437	/* module glue */
	438
1da177e4 LT	439	static int __init sensors_lm75_init(void)
1da177e4 LT	440	{
8ff69eeb	441	return i2c_add_driver(&lm75_driver);
1da177e4 LT	442	}
	443
	444	static void __exit sensors_lm75_exit(void)
	445	{
	446	i2c_del_driver(&lm75_driver);
	447	}
	448
	449	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	450	MODULE_DESCRIPTION("LM75 driver");
	451	MODULE_LICENSE("GPL");
	452
	453	module_init(sensors_lm75_init);
	454	module_exit(sensors_lm75_exit);