[net-next-2.6.git] / drivers / hwmon / lm95241.c

/*
 * lm95241.c - Part of lm_sensors, Linux kernel modules for hardware
 *             monitoring
 * Copyright (C) 2008 Davide Rizzo <elpa-rizzo@gmail.com>
 *
 * Based on the max1619 driver. The LM95241 is a sensor chip made by National
 *   Semiconductors.
 * It reports up to three temperatures (its own plus up to
 * two external ones). Complete datasheet can be
 * obtained from National's website at:
 *   http://www.national.com/ds.cgi/LM/LM95241.pdf
 *
 * 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 <linux/sysfs.h>

static const unsigned short normal_i2c[] = {
	0x19, 0x2a, 0x2b, I2C_CLIENT_END};

/* LM95241 registers */
#define LM95241_REG_R_MAN_ID		0xFE
#define LM95241_REG_R_CHIP_ID		0xFF
#define LM95241_REG_R_STATUS		0x02
#define LM95241_REG_RW_CONFIG		0x03
#define LM95241_REG_RW_REM_FILTER	0x06
#define LM95241_REG_RW_TRUTHERM		0x07
#define LM95241_REG_W_ONE_SHOT  	0x0F
#define LM95241_REG_R_LOCAL_TEMPH	0x10
#define LM95241_REG_R_REMOTE1_TEMPH	0x11
#define LM95241_REG_R_REMOTE2_TEMPH	0x12
#define LM95241_REG_R_LOCAL_TEMPL	0x20
#define LM95241_REG_R_REMOTE1_TEMPL	0x21
#define LM95241_REG_R_REMOTE2_TEMPL	0x22
#define LM95241_REG_RW_REMOTE_MODEL	0x30

/* LM95241 specific bitfields */
#define CFG_STOP 0x40
#define CFG_CR0076 0x00
#define CFG_CR0182 0x10
#define CFG_CR1000 0x20
#define CFG_CR2700 0x30
#define R1MS_SHIFT 0
#define R2MS_SHIFT 2
#define R1MS_MASK (0x01 << (R1MS_SHIFT))
#define R2MS_MASK (0x01 << (R2MS_SHIFT))
#define R1DF_SHIFT 1
#define R2DF_SHIFT 2
#define R1DF_MASK (0x01 << (R1DF_SHIFT))
#define R2DF_MASK (0x01 << (R2DF_SHIFT))
#define R1FE_MASK 0x01
#define R2FE_MASK 0x05
#define TT1_SHIFT 0
#define TT2_SHIFT 4
#define TT_OFF 0
#define TT_ON 1
#define TT_MASK 7
#define MANUFACTURER_ID 0x01
#define DEFAULT_REVISION 0xA4

/* Conversions and various macros */
#define TEMP_FROM_REG(val_h, val_l) (((val_h) & 0x80 ? (val_h) - 0x100 : \
    (val_h)) * 1000 + (val_l) * 1000 / 256)

/* Functions declaration */
static void lm95241_init_client(struct i2c_client *client);
static struct lm95241_data *lm95241_update_device(struct device *dev);

/* Client data (each client gets its own) */
struct lm95241_data {
	struct device *hwmon_dev;
	struct mutex update_lock;
	unsigned long last_updated, rate; /* in jiffies */
	char valid; /* zero until following fields are valid */
	/* registers values */
	u8 local_h, local_l; /* local */
	u8 remote1_h, remote1_l; /* remote1 */
	u8 remote2_h, remote2_l; /* remote2 */
	u8 config, model, trutherm;
};

/* Sysfs stuff */
#define show_temp(value) \
static ssize_t show_##value(struct device *dev, \
    struct device_attribute *attr, char *buf) \
{ \
	struct lm95241_data *data = lm95241_update_device(dev); \
	snprintf(buf, PAGE_SIZE - 1, "%d\n", \
		TEMP_FROM_REG(data->value##_h, data->value##_l)); \
	return strlen(buf); \
}
show_temp(local);
show_temp(remote1);
show_temp(remote2);

static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct lm95241_data *data = lm95241_update_device(dev);

	snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->rate / HZ);
	return strlen(buf);
}

static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm95241_data *data = i2c_get_clientdata(client);

	strict_strtol(buf, 10, &data->rate);
	data->rate = data->rate * HZ / 1000;

	return count;
}

#define show_type(flag) \
static ssize_t show_type##flag(struct device *dev, \
				   struct device_attribute *attr, char *buf) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	snprintf(buf, PAGE_SIZE - 1, \
		data->model & R##flag##MS_MASK ? "1\n" : "2\n"); \
	return strlen(buf); \
}
show_type(1);
show_type(2);

#define show_min(flag) \
static ssize_t show_min##flag(struct device *dev, \
    struct device_attribute *attr, char *buf) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	snprintf(buf, PAGE_SIZE - 1, \
		data->config & R##flag##DF_MASK ?	\
		"-127000\n" : "0\n"); \
	return strlen(buf); \
}
show_min(1);
show_min(2);

#define show_max(flag) \
static ssize_t show_max##flag(struct device *dev, \
    struct device_attribute *attr, char *buf) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	snprintf(buf, PAGE_SIZE - 1, \
		data->config & R##flag##DF_MASK ? \
		"127000\n" : "255000\n"); \
	return strlen(buf); \
}
show_max(1);
show_max(2);

#define set_type(flag) \
static ssize_t set_type##flag(struct device *dev, \
				  struct device_attribute *attr, \
				  const char *buf, size_t count) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	long val; \
	strict_strtol(buf, 10, &val); \
\
	if ((val == 1) || (val == 2)) { \
\
		mutex_lock(&data->update_lock); \
\
		data->trutherm &= ~(TT_MASK << TT##flag##_SHIFT); \
		if (val == 1) { \
			data->model |= R##flag##MS_MASK; \
			data->trutherm |= (TT_ON << TT##flag##_SHIFT); \
		} \
		else { \
			data->model &= ~R##flag##MS_MASK; \
			data->trutherm |= (TT_OFF << TT##flag##_SHIFT); \
		} \
\
		data->valid = 0; \
\
		i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, \
					  data->model); \
		i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, \
					  data->trutherm); \
\
		mutex_unlock(&data->update_lock); \
\
	} \
	return count; \
}
set_type(1);
set_type(2);

#define set_min(flag) \
static ssize_t set_min##flag(struct device *dev, \
	struct device_attribute *devattr, const char *buf, size_t count) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	long val; \
	strict_strtol(buf, 10, &val); \
\
	mutex_lock(&data->update_lock); \
\
	if (val < 0) \
		data->config |= R##flag##DF_MASK; \
	else \
		data->config &= ~R##flag##DF_MASK; \
\
	data->valid = 0; \
\
	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
		data->config); \
\
	mutex_unlock(&data->update_lock); \
\
	return count; \
}
set_min(1);
set_min(2);

#define set_max(flag) \
static ssize_t set_max##flag(struct device *dev, \
	struct device_attribute *devattr, const char *buf, size_t count) \
{ \
	struct i2c_client *client = to_i2c_client(dev); \
	struct lm95241_data *data = i2c_get_clientdata(client); \
\
	long val; \
	strict_strtol(buf, 10, &val); \
\
	mutex_lock(&data->update_lock); \
\
	if (val <= 127000) \
		data->config |= R##flag##DF_MASK; \
	else \
		data->config &= ~R##flag##DF_MASK; \
\
	data->valid = 0; \
\
	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
		data->config); \
\
	mutex_unlock(&data->update_lock); \
\
	return count; \
}
set_max(1);
set_max(2);

static DEVICE_ATTR(temp1_input, S_IRUGO, show_local, NULL);
static DEVICE_ATTR(temp2_input, S_IRUGO, show_remote1, NULL);
static DEVICE_ATTR(temp3_input, S_IRUGO, show_remote2, NULL);
static DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type1, set_type1);
static DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type2, set_type2);
static DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min1, set_min1);
static DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min2, set_min2);
static DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max1, set_max1);
static DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max2, set_max2);
static DEVICE_ATTR(rate, S_IWUSR | S_IRUGO, show_rate, set_rate);

static struct attribute *lm95241_attributes[] = {
	&dev_attr_temp1_input.attr,
	&dev_attr_temp2_input.attr,
	&dev_attr_temp3_input.attr,
	&dev_attr_temp2_type.attr,
	&dev_attr_temp3_type.attr,
	&dev_attr_temp2_min.attr,
	&dev_attr_temp3_min.attr,
	&dev_attr_temp2_max.attr,
	&dev_attr_temp3_max.attr,
	&dev_attr_rate.attr,
	NULL
};

static const struct attribute_group lm95241_group = {
	.attrs = lm95241_attributes,
};

/* Return 0 if detection is successful, -ENODEV otherwise */
static int lm95241_detect(struct i2c_client *new_client,
			  struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = new_client->adapter;
	int address = new_client->addr;
	const char *name;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

	if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
	     == MANUFACTURER_ID)
	 && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
	     >= DEFAULT_REVISION)) {
		name = "lm95241";
	} else {
		dev_dbg(&adapter->dev, "LM95241 detection failed at 0x%02x\n",
			address);
		return -ENODEV;
	}

	/* Fill the i2c board info */
	strlcpy(info->type, name, I2C_NAME_SIZE);
	return 0;
}

static int lm95241_probe(struct i2c_client *new_client,
			 const struct i2c_device_id *id)
{
	struct lm95241_data *data;
	int err;

	data = kzalloc(sizeof(struct lm95241_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}

	i2c_set_clientdata(new_client, data);
	mutex_init(&data->update_lock);

	/* Initialize the LM95241 chip */
	lm95241_init_client(new_client);

	/* Register sysfs hooks */
	err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
	if (err)
		goto exit_free;

	data->hwmon_dev = hwmon_device_register(&new_client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
		goto exit_remove_files;
	}

	return 0;

exit_remove_files:
	sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
exit_free:
	kfree(data);
exit:
	return err;
}

static void lm95241_init_client(struct i2c_client *client)
{
	struct lm95241_data *data = i2c_get_clientdata(client);

	data->rate = HZ;    /* 1 sec default */
	data->valid = 0;
	data->config = CFG_CR0076;
	data->model = 0;
	data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);

	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
				  data->config);
	i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
				  R1FE_MASK | R2FE_MASK);
	i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
				  data->trutherm);
	i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
				  data->model);
}

static int lm95241_remove(struct i2c_client *client)
{
	struct lm95241_data *data = i2c_get_clientdata(client);

	hwmon_device_unregister(data->hwmon_dev);
	sysfs_remove_group(&client->dev.kobj, &lm95241_group);

	kfree(data);
	return 0;
}

static struct lm95241_data *lm95241_update_device(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm95241_data *data = i2c_get_clientdata(client);

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + data->rate) ||
	    !data->valid) {
		dev_dbg(&client->dev, "Updating lm95241 data.\n");
		data->local_h =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_LOCAL_TEMPH);
		data->local_l =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_LOCAL_TEMPL);
		data->remote1_h =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_REMOTE1_TEMPH);
		data->remote1_l =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_REMOTE1_TEMPL);
		data->remote2_h =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_REMOTE2_TEMPH);
		data->remote2_l =
			i2c_smbus_read_byte_data(client,
						 LM95241_REG_R_REMOTE2_TEMPL);
		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/* Driver data (common to all clients) */
static const struct i2c_device_id lm95241_id[] = {
	{ "lm95241", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm95241_id);

static struct i2c_driver lm95241_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name   = "lm95241",
	},
	.probe		= lm95241_probe,
	.remove		= lm95241_remove,
	.id_table	= lm95241_id,
	.detect		= lm95241_detect,
	.address_list	= normal_i2c,
};

static int __init sensors_lm95241_init(void)
{
	return i2c_add_driver(&lm95241_driver);
}

static void __exit sensors_lm95241_exit(void)
{
	i2c_del_driver(&lm95241_driver);
}

MODULE_AUTHOR("Davide Rizzo <elpa-rizzo@gmail.com>");
MODULE_DESCRIPTION("LM95241 sensor driver");
MODULE_LICENSE("GPL");

module_init(sensors_lm95241_init);
module_exit(sensors_lm95241_exit);
Commit	Line	Data
06160327 DR	1	/*
	2	* lm95241.c - Part of lm_sensors, Linux kernel modules for hardware
	3	* monitoring
	4	* Copyright (C) 2008 Davide Rizzo <elpa-rizzo@gmail.com>
	5	*
	6	* Based on the max1619 driver. The LM95241 is a sensor chip made by National
	7	* Semiconductors.
	8	* It reports up to three temperatures (its own plus up to
	9	* two external ones). Complete datasheet can be
	10	* obtained from National's website at:
	11	* http://www.national.com/ds.cgi/LM/LM95241.pdf
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*/
	27
	28	#include <linux/module.h>
	29	#include <linux/init.h>
	30	#include <linux/slab.h>
	31	#include <linux/jiffies.h>
	32	#include <linux/i2c.h>
	33	#include <linux/hwmon.h>
	34	#include <linux/hwmon-sysfs.h>
	35	#include <linux/err.h>
	36	#include <linux/mutex.h>
	37	#include <linux/sysfs.h>
	38
	39	static const unsigned short normal_i2c[] = {
	40	0x19, 0x2a, 0x2b, I2C_CLIENT_END};
	41
06160327 DR	42	/* LM95241 registers */
	43	#define LM95241_REG_R_MAN_ID 0xFE
	44	#define LM95241_REG_R_CHIP_ID 0xFF
	45	#define LM95241_REG_R_STATUS 0x02
	46	#define LM95241_REG_RW_CONFIG 0x03
	47	#define LM95241_REG_RW_REM_FILTER 0x06
	48	#define LM95241_REG_RW_TRUTHERM 0x07
	49	#define LM95241_REG_W_ONE_SHOT 0x0F
	50	#define LM95241_REG_R_LOCAL_TEMPH 0x10
	51	#define LM95241_REG_R_REMOTE1_TEMPH 0x11
	52	#define LM95241_REG_R_REMOTE2_TEMPH 0x12
	53	#define LM95241_REG_R_LOCAL_TEMPL 0x20
	54	#define LM95241_REG_R_REMOTE1_TEMPL 0x21
	55	#define LM95241_REG_R_REMOTE2_TEMPL 0x22
	56	#define LM95241_REG_RW_REMOTE_MODEL 0x30
	57
	58	/* LM95241 specific bitfields */
	59	#define CFG_STOP 0x40
	60	#define CFG_CR0076 0x00
	61	#define CFG_CR0182 0x10
	62	#define CFG_CR1000 0x20
	63	#define CFG_CR2700 0x30
	64	#define R1MS_SHIFT 0
	65	#define R2MS_SHIFT 2
	66	#define R1MS_MASK (0x01 << (R1MS_SHIFT))
	67	#define R2MS_MASK (0x01 << (R2MS_SHIFT))
	68	#define R1DF_SHIFT 1
	69	#define R2DF_SHIFT 2
	70	#define R1DF_MASK (0x01 << (R1DF_SHIFT))
	71	#define R2DF_MASK (0x01 << (R2DF_SHIFT))
	72	#define R1FE_MASK 0x01
	73	#define R2FE_MASK 0x05
	74	#define TT1_SHIFT 0
	75	#define TT2_SHIFT 4
	76	#define TT_OFF 0
	77	#define TT_ON 1
	78	#define TT_MASK 7
	79	#define MANUFACTURER_ID 0x01
	80	#define DEFAULT_REVISION 0xA4
	81
	82	/* Conversions and various macros */
	83	#define TEMP_FROM_REG(val_h, val_l) (((val_h) & 0x80 ? (val_h) - 0x100 : \
	84	(val_h)) * 1000 + (val_l) * 1000 / 256)
	85
	86	/* Functions declaration */
06160327	87	static void lm95241_init_client(struct i2c_client *client);
06160327 DR	88	static struct lm95241_data lm95241_update_device(struct device dev);
06160327 DR	89
06160327 DR	90	/* Client data (each client gets its own) */
06160327 DR	91	struct lm95241_data {
06160327 DR	92	struct device *hwmon_dev;
	93	struct mutex update_lock;
	94	unsigned long last_updated, rate; /* in jiffies */
	95	char valid; /* zero until following fields are valid */
	96	/* registers values */
	97	u8 local_h, local_l; /* local */
	98	u8 remote1_h, remote1_l; /* remote1 */
	99	u8 remote2_h, remote2_l; /* remote2 */
	100	u8 config, model, trutherm;
	101	};
	102
	103	/* Sysfs stuff */
	104	#define show_temp(value) \
	105	static ssize_t show_##value(struct device *dev, \
	106	struct device_attribute attr, char buf) \
	107	{ \
	108	struct lm95241_data *data = lm95241_update_device(dev); \
	109	snprintf(buf, PAGE_SIZE - 1, "%d\n", \
	110	TEMP_FROM_REG(data->value##_h, data->value##_l)); \
	111	return strlen(buf); \
	112	}
	113	show_temp(local);
	114	show_temp(remote1);
	115	show_temp(remote2);
	116
	117	static ssize_t show_rate(struct device dev, struct device_attribute attr,
	118	char *buf)
	119	{
	120	struct lm95241_data *data = lm95241_update_device(dev);
	121
	122	snprintf(buf, PAGE_SIZE - 1, "%lu\n", 1000 * data->rate / HZ);
	123	return strlen(buf);
	124	}
	125
	126	static ssize_t set_rate(struct device dev, struct device_attribute attr,
	127	const char *buf, size_t count)
	128	{
	129	struct i2c_client *client = to_i2c_client(dev);
	130	struct lm95241_data *data = i2c_get_clientdata(client);
	131
	132	strict_strtol(buf, 10, &data->rate);
	133	data->rate = data->rate * HZ / 1000;
	134
	135	return count;
	136	}
	137
	138	#define show_type(flag) \
	139	static ssize_t show_type##flag(struct device *dev, \
	140	struct device_attribute attr, char buf) \
	141	{ \
	142	struct i2c_client *client = to_i2c_client(dev); \
	143	struct lm95241_data *data = i2c_get_clientdata(client); \
	144	\
	145	snprintf(buf, PAGE_SIZE - 1, \
	146	data->model & R##flag##MS_MASK ? "1\n" : "2\n"); \
	147	return strlen(buf); \
	148	}
	149	show_type(1);
	150	show_type(2);
	151
	152	#define show_min(flag) \
	153	static ssize_t show_min##flag(struct device *dev, \
	154	struct device_attribute attr, char buf) \
	155	{ \
156	struct i2c_client *client = to_i2c_client(dev); \
157	struct lm95241_data *data = i2c_get_clientdata(client); \
158	\
159	snprintf(buf, PAGE_SIZE - 1, \
160	data->config & R##flag##DF_MASK ? \
161	"-127000\n" : "0\n"); \
162	return strlen(buf); \
163	}
164	show_min(1);
165	show_min(2);
166
167	#define show_max(flag) \
168	static ssize_t show_max##flag(struct device *dev, \
169	struct device_attribute attr, char buf) \
170	{ \
171	struct i2c_client *client = to_i2c_client(dev); \
172	struct lm95241_data *data = i2c_get_clientdata(client); \
173	\
174	snprintf(buf, PAGE_SIZE - 1, \
175	data->config & R##flag##DF_MASK ? \
176	"127000\n" : "255000\n"); \
177	return strlen(buf); \
178	}
179	show_max(1);
180	show_max(2);
181
182	#define set_type(flag) \
183	static ssize_t set_type##flag(struct device *dev, \
184	struct device_attribute *attr, \
185	const char *buf, size_t count) \
186	{ \
187	struct i2c_client *client = to_i2c_client(dev); \
188	struct lm95241_data *data = i2c_get_clientdata(client); \
189	\
190	long val; \
191	strict_strtol(buf, 10, &val); \
192	\
193	if ((val == 1) \|\| (val == 2)) { \
194	\
195	mutex_lock(&data->update_lock); \
196	\
197	data->trutherm &= ~(TT_MASK << TT##flag##_SHIFT); \
198	if (val == 1) { \
199	data->model \|= R##flag##MS_MASK; \
200	data->trutherm \|= (TT_ON << TT##flag##_SHIFT); \
201	} \
202	else { \
203	data->model &= ~R##flag##MS_MASK; \
204	data->trutherm \|= (TT_OFF << TT##flag##_SHIFT); \
205	} \
206	\
207	data->valid = 0; \
208	\
209	i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, \
210	data->model); \
211	i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, \
212	data->trutherm); \
213	\
214	mutex_unlock(&data->update_lock); \
215	\
216	} \
217	return count; \
218	}
219	set_type(1);
220	set_type(2);
221
222	#define set_min(flag) \
223	static ssize_t set_min##flag(struct device *dev, \
224	struct device_attribute devattr, const char buf, size_t count) \
225	{ \
226	struct i2c_client *client = to_i2c_client(dev); \
227	struct lm95241_data *data = i2c_get_clientdata(client); \
228	\
229	long val; \
230	strict_strtol(buf, 10, &val); \
231	\
232	mutex_lock(&data->update_lock); \
233	\
234	if (val < 0) \
235	data->config \|= R##flag##DF_MASK; \
236	else \
237	data->config &= ~R##flag##DF_MASK; \
238	\
239	data->valid = 0; \
240	\
241	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
242	data->config); \
243	\
244	mutex_unlock(&data->update_lock); \
245	\
246	return count; \
247	}
248	set_min(1);
249	set_min(2);
250
251	#define set_max(flag) \
252	static ssize_t set_max##flag(struct device *dev, \
253	struct device_attribute devattr, const char buf, size_t count) \
254	{ \
255	struct i2c_client *client = to_i2c_client(dev); \
256	struct lm95241_data *data = i2c_get_clientdata(client); \
257	\
258	long val; \
259	strict_strtol(buf, 10, &val); \
260	\
261	mutex_lock(&data->update_lock); \
262	\
263	if (val <= 127000) \
264	data->config \|= R##flag##DF_MASK; \
265	else \
266	data->config &= ~R##flag##DF_MASK; \
267	\
268	data->valid = 0; \
269	\
270	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, \
271	data->config); \
272	\
273	mutex_unlock(&data->update_lock); \
274	\
275	return count; \
276	}
277	set_max(1);
278	set_max(2);
279
280	static DEVICE_ATTR(temp1_input, S_IRUGO, show_local, NULL);
281	static DEVICE_ATTR(temp2_input, S_IRUGO, show_remote1, NULL);
282	static DEVICE_ATTR(temp3_input, S_IRUGO, show_remote2, NULL);
283	static DEVICE_ATTR(temp2_type, S_IWUSR \| S_IRUGO, show_type1, set_type1);
284	static DEVICE_ATTR(temp3_type, S_IWUSR \| S_IRUGO, show_type2, set_type2);
285	static DEVICE_ATTR(temp2_min, S_IWUSR \| S_IRUGO, show_min1, set_min1);
286	static DEVICE_ATTR(temp3_min, S_IWUSR \| S_IRUGO, show_min2, set_min2);
287	static DEVICE_ATTR(temp2_max, S_IWUSR \| S_IRUGO, show_max1, set_max1);
288	static DEVICE_ATTR(temp3_max, S_IWUSR \| S_IRUGO, show_max2, set_max2);
289	static DEVICE_ATTR(rate, S_IWUSR \| S_IRUGO, show_rate, set_rate);
290
291	static struct attribute *lm95241_attributes[] = {
292	&dev_attr_temp1_input.attr,
293	&dev_attr_temp2_input.attr,
294	&dev_attr_temp3_input.attr,
295	&dev_attr_temp2_type.attr,
296	&dev_attr_temp3_type.attr,
297	&dev_attr_temp2_min.attr,
298	&dev_attr_temp3_min.attr,
299	&dev_attr_temp2_max.attr,
300	&dev_attr_temp3_max.attr,
301	&dev_attr_rate.attr,
302	NULL
303	};
304
305	static const struct attribute_group lm95241_group = {
306	.attrs = lm95241_attributes,
307	};
308
797eaa4b	309	/* Return 0 if detection is successful, -ENODEV otherwise */
310ec792	310	static int lm95241_detect(struct i2c_client *new_client,
797eaa4b	311	struct i2c_board_info *info)
06160327	312	{
797eaa4b JD	313	struct i2c_adapter *adapter = new_client->adapter;
797eaa4b JD	314	int address = new_client->addr;
52df6440	315	const char *name;
06160327 DR	316
06160327 DR	317	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
797eaa4b	318	return -ENODEV;
06160327	319
52df6440 JD	320	if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
	321	== MANUFACTURER_ID)
	322	&& (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
	323	>= DEFAULT_REVISION)) {
	324	name = "lm95241";
	325	} else {
	326	dev_dbg(&adapter->dev, "LM95241 detection failed at 0x%02x\n",
	327	address);
	328	return -ENODEV;
06160327 DR	329	}
06160327 DR	330
797eaa4b	331	/* Fill the i2c board info */
797eaa4b JD	332	strlcpy(info->type, name, I2C_NAME_SIZE);
	333	return 0;
	334	}
06160327	335
797eaa4b JD	336	static int lm95241_probe(struct i2c_client *new_client,
	337	const struct i2c_device_id *id)
	338	{
	339	struct lm95241_data *data;
	340	int err;
06160327	341
797eaa4b JD	342	data = kzalloc(sizeof(struct lm95241_data), GFP_KERNEL);
	343	if (!data) {
	344	err = -ENOMEM;
	345	goto exit;
	346	}
	347
	348	i2c_set_clientdata(new_client, data);
	349	mutex_init(&data->update_lock);
06160327 DR	350
	351	/* Initialize the LM95241 chip */
	352	lm95241_init_client(new_client);
	353
	354	/* Register sysfs hooks */
	355	err = sysfs_create_group(&new_client->dev.kobj, &lm95241_group);
	356	if (err)
797eaa4b	357	goto exit_free;
06160327 DR	358
	359	data->hwmon_dev = hwmon_device_register(&new_client->dev);
	360	if (IS_ERR(data->hwmon_dev)) {
	361	err = PTR_ERR(data->hwmon_dev);
	362	goto exit_remove_files;
	363	}
	364
	365	return 0;
	366
	367	exit_remove_files:
	368	sysfs_remove_group(&new_client->dev.kobj, &lm95241_group);
06160327 DR	369	exit_free:
	370	kfree(data);
	371	exit:
	372	return err;
	373	}
	374
	375	static void lm95241_init_client(struct i2c_client *client)
	376	{
	377	struct lm95241_data *data = i2c_get_clientdata(client);
	378
	379	data->rate = HZ; /* 1 sec default */
	380	data->valid = 0;
	381	data->config = CFG_CR0076;
	382	data->model = 0;
	383	data->trutherm = (TT_OFF << TT1_SHIFT) \| (TT_OFF << TT2_SHIFT);
	384
	385	i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
	386	data->config);
	387	i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
	388	R1FE_MASK \| R2FE_MASK);
	389	i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
	390	data->trutherm);
	391	i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
	392	data->model);
	393	}
	394
797eaa4b	395	static int lm95241_remove(struct i2c_client *client)
06160327 DR	396	{
06160327 DR	397	struct lm95241_data *data = i2c_get_clientdata(client);
06160327 DR	398
	399	hwmon_device_unregister(data->hwmon_dev);
	400	sysfs_remove_group(&client->dev.kobj, &lm95241_group);
	401
06160327 DR	402	kfree(data);
	403	return 0;
	404	}
	405
	406	static struct lm95241_data lm95241_update_device(struct device dev)
	407	{
	408	struct i2c_client *client = to_i2c_client(dev);
	409	struct lm95241_data *data = i2c_get_clientdata(client);
	410
	411	mutex_lock(&data->update_lock);
	412
	413	if (time_after(jiffies, data->last_updated + data->rate) \|\|
	414	!data->valid) {
	415	dev_dbg(&client->dev, "Updating lm95241 data.\n");
	416	data->local_h =
	417	i2c_smbus_read_byte_data(client,
	418	LM95241_REG_R_LOCAL_TEMPH);
	419	data->local_l =
	420	i2c_smbus_read_byte_data(client,
	421	LM95241_REG_R_LOCAL_TEMPL);
	422	data->remote1_h =
	423	i2c_smbus_read_byte_data(client,
	424	LM95241_REG_R_REMOTE1_TEMPH);
	425	data->remote1_l =
	426	i2c_smbus_read_byte_data(client,
	427	LM95241_REG_R_REMOTE1_TEMPL);
	428	data->remote2_h =
	429	i2c_smbus_read_byte_data(client,
	430	LM95241_REG_R_REMOTE2_TEMPH);
	431	data->remote2_l =
	432	i2c_smbus_read_byte_data(client,
	433	LM95241_REG_R_REMOTE2_TEMPL);
	434	data->last_updated = jiffies;
	435	data->valid = 1;
	436	}
	437
	438	mutex_unlock(&data->update_lock);
	439
	440	return data;
	441	}
	442
797eaa4b JD	443	/* Driver data (common to all clients) */
797eaa4b JD	444	static const struct i2c_device_id lm95241_id[] = {
1f86df49	445	{ "lm95241", 0 },
797eaa4b JD	446	{ }
	447	};
	448	MODULE_DEVICE_TABLE(i2c, lm95241_id);
	449
	450	static struct i2c_driver lm95241_driver = {
	451	.class = I2C_CLASS_HWMON,
	452	.driver = {
	453	.name = "lm95241",
	454	},
	455	.probe = lm95241_probe,
	456	.remove = lm95241_remove,
	457	.id_table = lm95241_id,
	458	.detect = lm95241_detect,
c3813d6a	459	.address_list = normal_i2c,
797eaa4b JD	460	};
797eaa4b JD	461
06160327 DR	462	static int __init sensors_lm95241_init(void)
	463	{
	464	return i2c_add_driver(&lm95241_driver);
	465	}
	466
	467	static void __exit sensors_lm95241_exit(void)
	468	{
	469	i2c_del_driver(&lm95241_driver);
	470	}
	471
	472	MODULE_AUTHOR("Davide Rizzo <elpa-rizzo@gmail.com>");
	473	MODULE_DESCRIPTION("LM95241 sensor driver");
	474	MODULE_LICENSE("GPL");
	475
	476	module_init(sensors_lm95241_init);
	477	module_exit(sensors_lm95241_exit);