[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/of.h>
#include <linux/regmap.h>
#include <linux/thermal.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,
	ds7505,
	g751,
	lm75,
	lm75a,
	lm75b,
	max6625,
	max6626,
	mcp980x,
	stds75,
	tcn75,
	tmp100,
	tmp101,
	tmp105,
	tmp112,
	tmp175,
	tmp275,
	tmp75,
	tmp75c,
};

/* 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_TEMP		0x00
#define LM75_REG_CONF		0x01
#define LM75_REG_HYST		0x02
#define LM75_REG_MAX		0x03

/* Each client has this additional data */
struct lm75_data {
	struct i2c_client	*client;
	struct regmap		*regmap;
	u8			orig_conf;
	u8			resolution;	/* In bits, between 9 and 12 */
	u8			resolution_limits;
	unsigned int		sample_time;	/* In ms */
};

/*-----------------------------------------------------------------------*/

static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
{
	return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
}

/* sysfs attributes for hwmon */

static int lm75_read_temp(void *dev, int *temp)
{
	struct lm75_data *data = dev_get_drvdata(dev);
	unsigned int _temp;
	int err;

	err = regmap_read(data->regmap, LM75_REG_TEMP, &_temp);
	if (err < 0)
		return err;

	*temp = lm75_reg_to_mc(_temp, data->resolution);

	return 0;
}

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 = dev_get_drvdata(dev);
	unsigned int temp = 0;
	int err;

	err = regmap_read(data->regmap, attr->index, &temp);
	if (err < 0)
		return err;

	return sprintf(buf, "%ld\n", lm75_reg_to_mc(temp, data->resolution));
}

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 lm75_data *data = dev_get_drvdata(dev);
	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;

	temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
	temp = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
				 1000) << (16 - resolution);
	error = regmap_write(data->regmap, attr->index, temp);
	if (error < 0)
		return error;

	return count;
}

static ssize_t show_update_interval(struct device *dev,
				    struct device_attribute *da, char *buf)
{
	struct lm75_data *data = dev_get_drvdata(dev);

	return sprintf(buf, "%u\n", data->sample_time);
}

static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
			show_temp, set_temp, LM75_REG_MAX);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
			show_temp, set_temp, LM75_REG_HYST);
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, LM75_REG_TEMP);
static DEVICE_ATTR(update_interval, S_IRUGO, show_update_interval, NULL);

static struct attribute *lm75_attrs[] = {
	&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,
	&dev_attr_update_interval.attr,

	NULL
};
ATTRIBUTE_GROUPS(lm75);

static const struct thermal_zone_of_device_ops lm75_of_thermal_ops = {
	.get_temp = lm75_read_temp,
};

/*-----------------------------------------------------------------------*/

/* device probe and removal */

static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
{
	return reg != LM75_REG_TEMP;
}

static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
{
	return reg == LM75_REG_TEMP;
}

static const struct regmap_config lm75_regmap_config = {
	.reg_bits = 8,
	.val_bits = 16,
	.max_register = LM75_REG_MAX,
	.writeable_reg = lm75_is_writeable_reg,
	.volatile_reg = lm75_is_volatile_reg,
	.val_format_endian = REGMAP_ENDIAN_BIG,
	.cache_type = REGCACHE_RBTREE,
	.use_single_rw = true,
};

static void lm75_remove(void *data)
{
	struct lm75_data *lm75 = data;
	struct i2c_client *client = lm75->client;

	i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
}

static int
lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device *hwmon_dev;
	struct lm75_data *data;
	int status, err;
	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(dev, sizeof(struct lm75_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;

	data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
	if (IS_ERR(data->regmap))
		return PTR_ERR(data->regmap);

	/* 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 = MSEC_PER_SEC / 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 = MSEC_PER_SEC;
		break;
	case ds7505:
		set_mask |= 3 << 5;		/* 12-bit mode */
		data->resolution = 12;
		data->sample_time = MSEC_PER_SEC / 4;
		break;
	case g751:
	case lm75:
	case lm75a:
		data->resolution = 9;
		data->sample_time = MSEC_PER_SEC / 2;
		break;
	case lm75b:
		data->resolution = 11;
		data->sample_time = MSEC_PER_SEC / 4;
		break;
	case max6625:
		data->resolution = 9;
		data->sample_time = MSEC_PER_SEC / 4;
		break;
	case max6626:
		data->resolution = 12;
		data->resolution_limits = 9;
		data->sample_time = MSEC_PER_SEC / 4;
		break;
	case tcn75:
		data->resolution = 9;
		data->sample_time = MSEC_PER_SEC / 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 = MSEC_PER_SEC;
		clr_mask |= 1 << 7;		/* not one-shot mode */
		break;
	case tmp112:
		set_mask |= 3 << 5;		/* 12-bit mode */
		clr_mask |= 1 << 7;		/* not one-shot mode */
		data->resolution = 12;
		data->sample_time = MSEC_PER_SEC / 4;
		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 = MSEC_PER_SEC / 2;
		break;
	case tmp75c:
		clr_mask |= 1 << 5;		/* not one-shot mode */
		data->resolution = 12;
		data->sample_time = MSEC_PER_SEC / 4;
		break;
	}

	/* configure as specified */
	status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(dev, "Can't read config? %d\n", status);
		return status;
	}
	data->orig_conf = status;
	new = status & ~clr_mask;
	new |= set_mask;
	if (status != new)
		i2c_smbus_write_byte_data(client, LM75_REG_CONF, new);

	err = devm_add_action_or_reset(dev, lm75_remove, data);
	if (err)
		return err;

	dev_dbg(dev, "Config %02x\n", new);

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   data, lm75_groups);
	if (IS_ERR(hwmon_dev))
		return PTR_ERR(hwmon_dev);

	devm_thermal_zone_of_sensor_register(hwmon_dev, 0,
					     hwmon_dev,
					     &lm75_of_thermal_ops);

	dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);

	return 0;
}

static const struct i2c_device_id lm75_ids[] = {
	{ "adt75", adt75, },
	{ "ds1775", ds1775, },
	{ "ds75", ds75, },
	{ "ds7505", ds7505, },
	{ "g751", g751, },
	{ "lm75", lm75, },
	{ "lm75a", lm75a, },
	{ "lm75b", lm75b, },
	{ "max6625", max6625, },
	{ "max6626", max6626, },
	{ "mcp980x", mcp980x, },
	{ "stds75", stds75, },
	{ "tcn75", tcn75, },
	{ "tmp100", tmp100, },
	{ "tmp101", tmp101, },
	{ "tmp105", tmp105, },
	{ "tmp112", tmp112, },
	{ "tmp175", tmp175, },
	{ "tmp275", tmp275, },
	{ "tmp75", tmp75, },
	{ "tmp75c", tmp75c, },
	{ /* 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;
	}
	/*
	 * It is very unlikely that this is a LM75 if both
	 * hysteresis and temperature limit registers are 0.
	 */
	if (hyst == 0 && os == 0)
		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 = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(&client->dev, "Can't read config? %d\n", status);
		return status;
	}
	status = status | LM75_SHUTDOWN;
	i2c_smbus_write_byte_data(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 = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
	if (status < 0) {
		dev_dbg(&client->dev, "Can't read config? %d\n", status);
		return status;
	}
	status = status & ~LM75_SHUTDOWN;
	i2c_smbus_write_byte_data(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,
	.id_table	= lm75_ids,
	.detect		= lm75_detect,
	.address_list	= normal_i2c,
};

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>
22e73183	29	#include <linux/of.h>
e65365fe	30	#include <linux/regmap.h>
22e73183	31	#include <linux/thermal.h>
1da177e4 LT	32	#include "lm75.h"
	33
	34
01a52397 DB	35	/*
01a52397 DB	36	* This driver handles the LM75 and compatible digital temperature sensors.
01a52397 DB	37	*/
01a52397 DB	38
9ebd3d82	39	enum lm75_type { /* keep sorted in alphabetical order */
e96f9d89	40	adt75,
1f86df49	41	ds1775,
9ebd3d82	42	ds75,
3fbc81e3	43	ds7505,
c98d6c65	44	g751,
1f86df49	45	lm75,
9ebd3d82	46	lm75a,
799fc602	47	lm75b,
9ebd3d82 DB	48	max6625,
	49	max6626,
	50	mcp980x,
	51	stds75,
	52	tcn75,
	53	tmp100,
	54	tmp101,
6d034059	55	tmp105,
c83959f8	56	tmp112,
9ebd3d82 DB	57	tmp175,
	58	tmp275,
	59	tmp75,
9c32e815	60	tmp75c,
9ebd3d82 DB	61	};
9ebd3d82 DB	62
8ff69eeb	63	/* Addresses scanned */
25e9c86d	64	static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
1da177e4	65	0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
1da177e4	66
1da177e4 LT	67
1da177e4 LT	68	/* The LM75 registers */
e65365fe	69	#define LM75_REG_TEMP 0x00
1da177e4	70	#define LM75_REG_CONF 0x01
e65365fe GR	71	#define LM75_REG_HYST 0x02
e65365fe GR	72	#define LM75_REG_MAX 0x03
1da177e4 LT	73
	74	/* Each client has this additional data */
	75	struct lm75_data {
d663ec49	76	struct i2c_client *client;
e65365fe	77	struct regmap *regmap;
9ebd3d82	78	u8 orig_conf;
87d0621a JD	79	u8 resolution; /* In bits, between 9 and 12 */
87d0621a JD	80	u8 resolution_limits;
e65365fe	81	unsigned int sample_time; /* In ms */
1da177e4 LT	82	};
1da177e4 LT	83
01a52397 DB	84	/-----------------------------------------------------------------------/
01a52397 DB	85
22e73183 EV	86	static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
	87	{
	88	return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
	89	}
	90
01a52397	91	/* sysfs attributes for hwmon */
1da177e4	92
17e8351a	93	static int lm75_read_temp(void dev, int temp)
22e73183	94	{
e65365fe GR	95	struct lm75_data *data = dev_get_drvdata(dev);
	96	unsigned int _temp;
	97	int err;
22e73183	98
e65365fe GR	99	err = regmap_read(data->regmap, LM75_REG_TEMP, &_temp);
	100	if (err < 0)
	101	return err;
22e73183	102
e65365fe	103	*temp = lm75_reg_to_mc(_temp, data->resolution);
22e73183 EV	104
	105	return 0;
	106	}
	107
9ca8e40c JD	108	static ssize_t show_temp(struct device dev, struct device_attribute da,
	109	char *buf)
	110	{
	111	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
e65365fe GR	112	struct lm75_data *data = dev_get_drvdata(dev);
	113	unsigned int temp = 0;
	114	int err;
1f962f36	115
e65365fe GR	116	err = regmap_read(data->regmap, attr->index, &temp);
	117	if (err < 0)
	118	return err;
1f962f36	119
e65365fe	120	return sprintf(buf, "%ld\n", lm75_reg_to_mc(temp, data->resolution));
1da177e4	121	}
9ca8e40c JD	122
	123	static ssize_t set_temp(struct device dev, struct device_attribute da,
	124	const char *buf, size_t count)
	125	{
	126	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
d663ec49	127	struct lm75_data *data = dev_get_drvdata(dev);
e3cd9528 S	128	long temp;
e3cd9528 S	129	int error;
87d0621a	130	u8 resolution;
e3cd9528	131
24edc0a7	132	error = kstrtol(buf, 10, &temp);
e3cd9528 S	133	if (error)
e3cd9528 S	134	return error;
9ca8e40c	135
87d0621a JD	136	/*
	137	* Resolution of limit registers is assumed to be the same as the
	138	* temperature input register resolution unless given explicitly.
	139	*/
	140	if (attr->index && data->resolution_limits)
	141	resolution = data->resolution_limits;
	142	else
	143	resolution = data->resolution;
	144
87d0621a	145	temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
e65365fe GR	146	temp = DIV_ROUND_CLOSEST(temp << (resolution - 8),
	147	1000) << (16 - resolution);
	148	error = regmap_write(data->regmap, attr->index, temp);
	149	if (error < 0)
	150	return error;
	151
9ca8e40c	152	return count;
1da177e4	153	}
1da177e4	154
5f7e5e29 GR	155	static ssize_t show_update_interval(struct device *dev,
	156	struct device_attribute da, char buf)
	157	{
e65365fe	158	struct lm75_data *data = dev_get_drvdata(dev);
5f7e5e29	159
e65365fe	160	return sprintf(buf, "%u\n", data->sample_time);
5f7e5e29 GR	161	}
5f7e5e29 GR	162
9ca8e40c	163	static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR \| S_IRUGO,
e65365fe	164	show_temp, set_temp, LM75_REG_MAX);
9ca8e40c	165	static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR \| S_IRUGO,
e65365fe GR	166	show_temp, set_temp, LM75_REG_HYST);
e65365fe GR	167	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, LM75_REG_TEMP);
5f7e5e29	168	static DEVICE_ATTR(update_interval, S_IRUGO, show_update_interval, NULL);
1da177e4	169
d663ec49	170	static struct attribute *lm75_attrs[] = {
9ca8e40c JD	171	&sensor_dev_attr_temp1_input.dev_attr.attr,
	172	&sensor_dev_attr_temp1_max.dev_attr.attr,
	173	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
5f7e5e29	174	&dev_attr_update_interval.attr,
c1685f61 MH	175
	176	NULL
	177	};
d663ec49	178	ATTRIBUTE_GROUPS(lm75);
c1685f61	179
2251aef6 EV	180	static const struct thermal_zone_of_device_ops lm75_of_thermal_ops = {
	181	.get_temp = lm75_read_temp,
	182	};
	183
01a52397 DB	184	/-----------------------------------------------------------------------/
01a52397 DB	185
8ff69eeb	186	/* device probe and removal */
9ebd3d82	187
e65365fe GR	188	static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
	189	{
	190	return reg != LM75_REG_TEMP;
	191	}
	192
	193	static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
	194	{
	195	return reg == LM75_REG_TEMP;
	196	}
	197
	198	static const struct regmap_config lm75_regmap_config = {
	199	.reg_bits = 8,
	200	.val_bits = 16,
	201	.max_register = LM75_REG_MAX,
	202	.writeable_reg = lm75_is_writeable_reg,
	203	.volatile_reg = lm75_is_volatile_reg,
	204	.val_format_endian = REGMAP_ENDIAN_BIG,
	205	.cache_type = REGCACHE_RBTREE,
	206	.use_single_rw = true,
	207	};
	208
9e37d3e2 GR	209	static void lm75_remove(void *data)
	210	{
	211	struct lm75_data *lm75 = data;
	212	struct i2c_client *client = lm75->client;
	213
	214	i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
	215	}
	216
9ebd3d82 DB	217	static int
	218	lm75_probe(struct i2c_client client, const struct i2c_device_id id)
	219	{
d663ec49	220	struct device *dev = &client->dev;
9e37d3e2	221	struct device *hwmon_dev;
9ebd3d82	222	struct lm75_data *data;
90e2b545	223	int status, err;
9ebd3d82 DB	224	u8 set_mask, clr_mask;
9ebd3d82 DB	225	int new;
0cd2c72d	226	enum lm75_type kind = id->driver_data;
9ebd3d82 DB	227
	228	if (!i2c_check_functionality(client->adapter,
	229	I2C_FUNC_SMBUS_BYTE_DATA \| I2C_FUNC_SMBUS_WORD_DATA))
	230	return -EIO;
	231
d663ec49	232	data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
9ebd3d82 DB	233	if (!data)
	234	return -ENOMEM;
	235
d663ec49	236	data->client = client;
e65365fe GR	237
	238	data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
	239	if (IS_ERR(data->regmap))
	240	return PTR_ERR(data->regmap);
9ebd3d82 DB	241
	242	/* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
	243	* Then tweak to be more precise when appropriate.
	244	*/
	245	set_mask = 0;
8a5c5cc6 JD	246	clr_mask = LM75_SHUTDOWN; /* continuous conversions */
8a5c5cc6 JD	247
0cd2c72d	248	switch (kind) {
8a5c5cc6 JD	249	case adt75:
8a5c5cc6 JD	250	clr_mask \|= 1 << 5; /* not one-shot mode */
0cd2c72d	251	data->resolution = 12;
e65365fe	252	data->sample_time = MSEC_PER_SEC / 8;
8a5c5cc6 JD	253	break;
	254	case ds1775:
	255	case ds75:
	256	case stds75:
0cd2c72d JD	257	clr_mask \|= 3 << 5;
	258	set_mask \|= 2 << 5; /* 11-bit mode */
	259	data->resolution = 11;
e65365fe	260	data->sample_time = MSEC_PER_SEC;
0cd2c72d	261	break;
3fbc81e3 JD	262	case ds7505:
	263	set_mask \|= 3 << 5; /* 12-bit mode */
	264	data->resolution = 12;
e65365fe	265	data->sample_time = MSEC_PER_SEC / 4;
3fbc81e3	266	break;
c98d6c65	267	case g751:
0cd2c72d JD	268	case lm75:
	269	case lm75a:
	270	data->resolution = 9;
e65365fe	271	data->sample_time = MSEC_PER_SEC / 2;
0cd2c72d	272	break;
799fc602 MT	273	case lm75b:
799fc602 MT	274	data->resolution = 11;
e65365fe	275	data->sample_time = MSEC_PER_SEC / 4;
799fc602	276	break;
0cd2c72d JD	277	case max6625:
0cd2c72d JD	278	data->resolution = 9;
e65365fe	279	data->sample_time = MSEC_PER_SEC / 4;
0cd2c72d JD	280	break;
	281	case max6626:
	282	data->resolution = 12;
	283	data->resolution_limits = 9;
e65365fe	284	data->sample_time = MSEC_PER_SEC / 4;
0cd2c72d JD	285	break;
	286	case tcn75:
	287	data->resolution = 9;
e65365fe	288	data->sample_time = MSEC_PER_SEC / 8;
8a5c5cc6 JD	289	break;
8a5c5cc6 JD	290	case mcp980x:
0cd2c72d JD	291	data->resolution_limits = 9;
0cd2c72d JD	292	/* fall through */
8a5c5cc6 JD	293	case tmp100:
8a5c5cc6 JD	294	case tmp101:
0cd2c72d JD	295	set_mask \|= 3 << 5; /* 12-bit mode */
0cd2c72d JD	296	data->resolution = 12;
e65365fe	297	data->sample_time = MSEC_PER_SEC;
0cd2c72d JD	298	clr_mask \|= 1 << 7; /* not one-shot mode */
0cd2c72d JD	299	break;
c83959f8 FK	300	case tmp112:
	301	set_mask \|= 3 << 5; /* 12-bit mode */
	302	clr_mask \|= 1 << 7; /* not one-shot mode */
	303	data->resolution = 12;
e65365fe	304	data->sample_time = MSEC_PER_SEC / 4;
c83959f8	305	break;
8a5c5cc6 JD	306	case tmp105:
	307	case tmp175:
	308	case tmp275:
	309	case tmp75:
0cd2c72d	310	set_mask \|= 3 << 5; /* 12-bit mode */
8a5c5cc6	311	clr_mask \|= 1 << 7; /* not one-shot mode */
0cd2c72d	312	data->resolution = 12;
e65365fe	313	data->sample_time = MSEC_PER_SEC / 2;
8a5c5cc6	314	break;
9c32e815 BG	315	case tmp75c:
	316	clr_mask \|= 1 << 5; /* not one-shot mode */
	317	data->resolution = 12;
e65365fe	318	data->sample_time = MSEC_PER_SEC / 4;
9c32e815	319	break;
8a5c5cc6	320	}
9ebd3d82 DB	321
9ebd3d82 DB	322	/* configure as specified */
38aefb41	323	status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
9ebd3d82	324	if (status < 0) {
d663ec49	325	dev_dbg(dev, "Can't read config? %d\n", status);
13ac7a01	326	return status;
9ebd3d82 DB	327	}
	328	data->orig_conf = status;
	329	new = status & ~clr_mask;
	330	new \|= set_mask;
	331	if (status != new)
38aefb41	332	i2c_smbus_write_byte_data(client, LM75_REG_CONF, new);
9ebd3d82	333
90e2b545 GR	334	err = devm_add_action_or_reset(dev, lm75_remove, data);
	335	if (err)
	336	return err;
9ebd3d82	337
9e37d3e2	338	dev_dbg(dev, "Config %02x\n", new);
22e73183	339
9e37d3e2 GR	340	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	341	data, lm75_groups);
	342	if (IS_ERR(hwmon_dev))
	343	return PTR_ERR(hwmon_dev);
9ebd3d82	344
9e37d3e2 GR	345	devm_thermal_zone_of_sensor_register(hwmon_dev, 0,
	346	hwmon_dev,
	347	&lm75_of_thermal_ops);
9ebd3d82	348
9e37d3e2	349	dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
9ebd3d82	350
9ebd3d82 DB	351	return 0;
	352	}
	353
	354	static const struct i2c_device_id lm75_ids[] = {
e96f9d89	355	{ "adt75", adt75, },
9ebd3d82 DB	356	{ "ds1775", ds1775, },
9ebd3d82 DB	357	{ "ds75", ds75, },
3fbc81e3	358	{ "ds7505", ds7505, },
c98d6c65	359	{ "g751", g751, },
9ebd3d82 DB	360	{ "lm75", lm75, },
9ebd3d82 DB	361	{ "lm75a", lm75a, },
799fc602	362	{ "lm75b", lm75b, },
9ebd3d82 DB	363	{ "max6625", max6625, },
	364	{ "max6626", max6626, },
	365	{ "mcp980x", mcp980x, },
	366	{ "stds75", stds75, },
	367	{ "tcn75", tcn75, },
	368	{ "tmp100", tmp100, },
	369	{ "tmp101", tmp101, },
6d034059	370	{ "tmp105", tmp105, },
c83959f8	371	{ "tmp112", tmp112, },
9ebd3d82 DB	372	{ "tmp175", tmp175, },
	373	{ "tmp275", tmp275, },
	374	{ "tmp75", tmp75, },
9c32e815	375	{ "tmp75c", tmp75c, },
9ebd3d82 DB	376	{ /* LIST END */ }
	377	};
	378	MODULE_DEVICE_TABLE(i2c, lm75_ids);
	379
05e82fe4 LS	380	#define LM75A_ID 0xA1
05e82fe4 LS	381
8ff69eeb	382	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	383	static int lm75_detect(struct i2c_client *new_client,
8ff69eeb	384	struct i2c_board_info *info)
1da177e4	385	{
8ff69eeb	386	struct i2c_adapter *adapter = new_client->adapter;
1da177e4	387	int i;
e76f67b5	388	int conf, hyst, os;
05e82fe4	389	bool is_lm75a = 0;
1da177e4	390
1da177e4 LT	391	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA \|
1da177e4 LT	392	I2C_FUNC_SMBUS_WORD_DATA))
8ff69eeb	393	return -ENODEV;
1da177e4	394
426343ef JD	395	/*
	396	* Now, we do the remaining detection. There is no identification-
	397	* dedicated register so we have to rely on several tricks:
	398	* unused bits, registers cycling over 8-address boundaries,
	399	* addresses 0x04-0x07 returning the last read value.
	400	* The cycling+unused addresses combination is not tested,
	401	* since it would significantly slow the detection down and would
	402	* hardly add any value.
	403	*
	404	* The National Semiconductor LM75A is different than earlier
	405	* LM75s. It has an ID byte of 0xaX (where X is the chip
	406	* revision, with 1 being the only revision in existence) in
	407	* register 7, and unused registers return 0xff rather than the
	408	* last read value.
	409	*
	410	* Note that this function only detects the original National
	411	* Semiconductor LM75 and the LM75A. Clones from other vendors
	412	* aren't detected, on purpose, because they are typically never
	413	* found on PC hardware. They are found on embedded designs where
	414	* they can be instantiated explicitly so detection is not needed.
	415	* The absence of identification registers on all these clones
	416	* would make their exhaustive detection very difficult and weak,
	417	* and odds are that the driver would bind to unsupported devices.
	418	*/
1da177e4	419
e76f67b5	420	/* Unused bits */
52df6440	421	conf = i2c_smbus_read_byte_data(new_client, 1);
e76f67b5 JD	422	if (conf & 0xe0)
e76f67b5 JD	423	return -ENODEV;
05e82fe4 LS	424
	425	/* First check for LM75A */
	426	if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
	427	/* LM75A returns 0xff on unused registers so
	428	just to be sure we check for that too. */
	429	if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
	430	\|\| i2c_smbus_read_byte_data(new_client, 5) != 0xff
	431	\|\| i2c_smbus_read_byte_data(new_client, 6) != 0xff)
	432	return -ENODEV;
	433	is_lm75a = 1;
e76f67b5 JD	434	hyst = i2c_smbus_read_byte_data(new_client, 2);
e76f67b5 JD	435	os = i2c_smbus_read_byte_data(new_client, 3);
05e82fe4 LS	436	} else { /* Traditional style LM75 detection */
05e82fe4 LS	437	/* Unused addresses */
e76f67b5 JD	438	hyst = i2c_smbus_read_byte_data(new_client, 2);
	439	if (i2c_smbus_read_byte_data(new_client, 4) != hyst
	440	\|\| i2c_smbus_read_byte_data(new_client, 5) != hyst
	441	\|\| i2c_smbus_read_byte_data(new_client, 6) != hyst
	442	\|\| i2c_smbus_read_byte_data(new_client, 7) != hyst)
05e82fe4	443	return -ENODEV;
e76f67b5 JD	444	os = i2c_smbus_read_byte_data(new_client, 3);
	445	if (i2c_smbus_read_byte_data(new_client, 4) != os
	446	\|\| i2c_smbus_read_byte_data(new_client, 5) != os
	447	\|\| i2c_smbus_read_byte_data(new_client, 6) != os
	448	\|\| i2c_smbus_read_byte_data(new_client, 7) != os)
05e82fe4 LS	449	return -ENODEV;
05e82fe4 LS	450	}
4ad40cc5 GR	451	/*
	452	* It is very unlikely that this is a LM75 if both
	453	* hysteresis and temperature limit registers are 0.
	454	*/
	455	if (hyst == 0 && os == 0)
	456	return -ENODEV;
1da177e4	457
52df6440	458	/* Addresses cycling */
e76f67b5	459	for (i = 8; i <= 248; i += 40) {
52df6440	460	if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
e76f67b5 JD	461	\|\| i2c_smbus_read_byte_data(new_client, i + 2) != hyst
e76f67b5 JD	462	\|\| i2c_smbus_read_byte_data(new_client, i + 3) != os)
52df6440	463	return -ENODEV;
05e82fe4 LS	464	if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
	465	!= LM75A_ID)
	466	return -ENODEV;
1da177e4 LT	467	}
1da177e4 LT	468
05e82fe4	469	strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
c1685f61	470
1da177e4	471	return 0;
01a52397 DB	472	}
01a52397 DB	473
9914518e SD	474	#ifdef CONFIG_PM
	475	static int lm75_suspend(struct device *dev)
	476	{
	477	int status;
	478	struct i2c_client *client = to_i2c_client(dev);
38aefb41	479	status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
9914518e SD	480	if (status < 0) {
	481	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	482	return status;
	483	}
	484	status = status \| LM75_SHUTDOWN;
38aefb41	485	i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
9914518e SD	486	return 0;
	487	}
	488
	489	static int lm75_resume(struct device *dev)
	490	{
	491	int status;
	492	struct i2c_client *client = to_i2c_client(dev);
38aefb41	493	status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
9914518e SD	494	if (status < 0) {
	495	dev_dbg(&client->dev, "Can't read config? %d\n", status);
	496	return status;
	497	}
	498	status = status & ~LM75_SHUTDOWN;
38aefb41	499	i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
9914518e SD	500	return 0;
	501	}
	502
	503	static const struct dev_pm_ops lm75_dev_pm_ops = {
	504	.suspend = lm75_suspend,
	505	.resume = lm75_resume,
	506	};
	507	#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
	508	#else
	509	#define LM75_DEV_PM_OPS NULL
	510	#endif /* CONFIG_PM */
	511
8ff69eeb JD	512	static struct i2c_driver lm75_driver = {
8ff69eeb JD	513	.class = I2C_CLASS_HWMON,
01a52397	514	.driver = {
8ff69eeb	515	.name = "lm75",
9914518e	516	.pm = LM75_DEV_PM_OPS,
01a52397	517	},
8ff69eeb	518	.probe = lm75_probe,
8ff69eeb JD	519	.id_table = lm75_ids,
8ff69eeb JD	520	.detect = lm75_detect,
c3813d6a	521	.address_list = normal_i2c,
01a52397 DB	522	};
01a52397 DB	523
f0967eea	524	module_i2c_driver(lm75_driver);
1da177e4 LT	525
	526	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
	527	MODULE_DESCRIPTION("LM75 driver");
	528	MODULE_LICENSE("GPL");