[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;
	u8			resolution;	/* In bits, between 9 and 12 */
	u8			resolution_limits;
	char			valid;		/* !=0 if registers are valid */
	unsigned long		last_updated;	/* In jiffies */
	unsigned long		sample_time;	/* In jiffies */
	s16			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);
	long temp;

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

	temp = ((data->temp[attr->index] >> (16 - data->resolution)) * 1000)
	       >> (data->resolution - 8);

	return sprintf(buf, "%ld\n", temp);
}

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;
	u8 resolution;

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

	/*
	 * Resolution of limit registers is assumed to be the same as the
	 * temperature input register resolution unless given explicitly.
	 */
	if (attr->index && data->resolution_limits)
		resolution = data->resolution_limits;
	else
		resolution = data->resolution;

	mutex_lock(&data->update_lock);
	temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
	data->temp[nr] = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
					   1000) << (16 - resolution);
	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;
	enum lm75_type kind = id->driver_data;

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