Release 4.7 drivers/hwmon/lm95241.c

Directory: drivers/hwmon
/*
 * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com>
 *
 * 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>


#define DEVNAME "lm95241"


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 NATSEMI_MAN_ID	0x01

#define LM95231_CHIP_ID	0xA1

#define LM95241_CHIP_ID	0xA4


static const u8 lm95241_reg_address[] = {
	LM95241_REG_R_LOCAL_TEMPH,
	LM95241_REG_R_LOCAL_TEMPL,
	LM95241_REG_R_REMOTE1_TEMPH,
	LM95241_REG_R_REMOTE1_TEMPL,
	LM95241_REG_R_REMOTE2_TEMPH,
	LM95241_REG_R_REMOTE2_TEMPL
};

/* Client data (each client gets its own) */

struct lm95241_data {
	
struct i2c_client *client;
	
struct mutex update_lock;
	

unsigned long last_updated, interval;	/* in jiffies */
	
char valid;		/* zero until following fields are valid */
	/* registers values */
	
u8 temp[ARRAY_SIZE(lm95241_reg_address)];
	


u8 config, model, trutherm;
};

/* Conversions */


static int temp_from_reg_signed(u8 val_h, u8 val_l)
{
	s16 val_hl = (val_h << 8) | val_l;
	return val_hl * 1000 / 256;
}

Contributors
Person Tokens Prop Commits CommitProp
guenter roeck guenter roeck 16 53.33% 1 33.33%
davide rizzo davide rizzo 14 46.67% 2 66.67%
Total 30 100.00% 3 100.00%



static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
{
	u16 val_hl = (val_h << 8) | val_l;
	return val_hl * 1000 / 256;
}

Contributors
Person Tokens Prop Commits CommitProp
guenter roeck guenter roeck 23 76.67% 1 50.00%
davide rizzo davide rizzo 7 23.33% 1 50.00%
Total 30 100.00% 2 100.00%



static struct lm95241_data *lm95241_update_device(struct device *dev)
{
	struct lm95241_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + data->interval) ||
	    !data->valid) {
		int i;

		dev_dbg(dev, "Updating lm95241 data.\n");
		for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++)
			data->temp[i]
			  = i2c_smbus_read_byte_data(client,
						     lm95241_reg_address[i]);
		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 121 94.53% 2 66.67%
guenter roeck guenter roeck 7 5.47% 1 33.33%
Total 128 100.00% 3 100.00%

/* Sysfs stuff */


static ssize_t show_input(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct lm95241_data *data = lm95241_update_device(dev);
	int index = to_sensor_dev_attr(attr)->index;

	return snprintf(buf, PAGE_SIZE - 1, "%d\n",
			index == 0 || (data->config & (1 << (index / 2))) ?
		temp_from_reg_signed(data->temp[index], data->temp[index + 1]) :
		temp_from_reg_unsigned(data->temp[index],
				       data->temp[index + 1]));
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 62 56.36% 2 66.67%
guenter roeck guenter roeck 48 43.64% 1 33.33%
Total 110 100.00% 3 100.00%



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

	return snprintf(buf, PAGE_SIZE - 1,
		data->model & to_sensor_dev_attr(attr)->index ? "1\n" : "2\n");
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 53 96.36% 2 66.67%
guenter roeck guenter roeck 2 3.64% 1 33.33%
Total 55 100.00% 3 100.00%



static ssize_t set_type(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct lm95241_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	unsigned long val;
	int shift;
	u8 mask = to_sensor_dev_attr(attr)->index;

	if (kstrtoul(buf, 10, &val) < 0)
		return -EINVAL;
	if (val != 1 && val != 2)
		return -EINVAL;

	shift = mask == R1MS_MASK ? TT1_SHIFT : TT2_SHIFT;

	mutex_lock(&data->update_lock);

	data->trutherm &= ~(TT_MASK << shift);
	if (val == 1) {
		data->model |= mask;
		data->trutherm |= (TT_ON << shift);
	} else {
		data->model &= ~mask;
		data->trutherm |= (TT_OFF << 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;
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 196 96.08% 1 33.33%
guenter roeck guenter roeck 7 3.43% 1 33.33%
frans meulenbroeks frans meulenbroeks 1 0.49% 1 33.33%
Total 204 100.00% 3 100.00%



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

	return snprintf(buf, PAGE_SIZE - 1,
			data->config & to_sensor_dev_attr(attr)->index ?
			"-127000\n" : "0\n");
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 53 96.36% 1 50.00%
guenter roeck guenter roeck 2 3.64% 1 50.00%
Total 55 100.00% 2 100.00%



static ssize_t set_min(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct lm95241_data *data = dev_get_drvdata(dev);
	long val;

	if (kstrtol(buf, 10, &val) < 0)
		return -EINVAL;
	if (val < -128000)
		return -EINVAL;

	mutex_lock(&data->update_lock);

	if (val < 0)
		data->config |= to_sensor_dev_attr(attr)->index;
	else
		data->config &= ~to_sensor_dev_attr(attr)->index;
	data->valid = 0;

	i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
				  data->config);

	mutex_unlock(&data->update_lock);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 129 96.27% 1 33.33%
guenter roeck guenter roeck 4 2.99% 1 33.33%
frans meulenbroeks frans meulenbroeks 1 0.75% 1 33.33%
Total 134 100.00% 3 100.00%



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

	return snprintf(buf, PAGE_SIZE - 1,
			data->config & to_sensor_dev_attr(attr)->index ?
			"127000\n" : "255000\n");
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 53 96.36% 1 50.00%
guenter roeck guenter roeck 2 3.64% 1 50.00%
Total 55 100.00% 2 100.00%



static ssize_t set_max(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	struct lm95241_data *data = dev_get_drvdata(dev);
	long val;

	if (kstrtol(buf, 10, &val) < 0)
		return -EINVAL;
	if (val >= 256000)
		return -EINVAL;

	mutex_lock(&data->update_lock);

	if (val <= 127000)
		data->config |= to_sensor_dev_attr(attr)->index;
	else
		data->config &= ~to_sensor_dev_attr(attr)->index;
	data->valid = 0;

	i2c_smbus_write_byte_data(data->client, LM95241_REG_RW_CONFIG,
				  data->config);

	mutex_unlock(&data->update_lock);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 128 96.24% 1 33.33%
guenter roeck guenter roeck 4 3.01% 1 33.33%
frans meulenbroeks frans meulenbroeks 1 0.75% 1 33.33%
Total 133 100.00% 3 100.00%



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

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

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%



static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct lm95241_data *data = dev_get_drvdata(dev);
	unsigned long val;

	if (kstrtoul(buf, 10, &val) < 0)
		return -EINVAL;

	data->interval = val * HZ / 1000;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 56 81.16% 2 33.33%
jean delvare jean delvare 9 13.04% 1 16.67%
guenter roeck guenter roeck 3 4.35% 2 33.33%
frans meulenbroeks frans meulenbroeks 1 1.45% 1 16.67%
Total 69 100.00% 6 100.00%

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type,
			  R1MS_MASK);
static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type,
			  R2MS_MASK);
static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min,
			  R1DF_MASK);
static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min,
			  R2DF_MASK);
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max,
			  R1DF_MASK);
static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max,
			  R2DF_MASK);
static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
		   set_interval);


static struct attribute *lm95241_attrs[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp2_input.dev_attr.attr,
	&sensor_dev_attr_temp3_input.dev_attr.attr,
	&sensor_dev_attr_temp2_type.dev_attr.attr,
	&sensor_dev_attr_temp3_type.dev_attr.attr,
	&sensor_dev_attr_temp2_min.dev_attr.attr,
	&sensor_dev_attr_temp3_min.dev_attr.attr,
	&sensor_dev_attr_temp2_max.dev_attr.attr,
	&sensor_dev_attr_temp3_max.dev_attr.attr,
	&dev_attr_update_interval.attr,
	NULL
};

ATTRIBUTE_GROUPS(lm95241);

/* 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;
	const char *name;
	int mfg_id, chip_id;

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

	mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
	if (mfg_id != NATSEMI_MAN_ID)
		return -ENODEV;

	chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
	switch (chip_id) {
	case LM95231_CHIP_ID:
		name = "lm95231";
		break;
	case LM95241_CHIP_ID:
		name = "lm95241";
		break;
	default:
		return -ENODEV;
	}

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

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 57 47.90% 1 25.00%
guenter roeck guenter roeck 37 31.09% 1 25.00%
jean delvare jean delvare 25 21.01% 2 50.00%
Total 119 100.00% 4 100.00%



static void lm95241_init_client(struct i2c_client *client,
				struct lm95241_data *data)
{
	data->interval = HZ;	/* 1 sec default */
	data->config = CFG_CR0076;
	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);
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 73 82.02% 2 50.00%
jean delvare jean delvare 13 14.61% 1 25.00%
guenter roeck guenter roeck 3 3.37% 1 25.00%
Total 89 100.00% 4 100.00%



static int lm95241_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct lm95241_data *data;
	struct device *hwmon_dev;

	data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;
	mutex_init(&data->update_lock);

	/* Initialize the LM95241 chip */
	lm95241_init_client(client, data);

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   data,
							   lm95241_groups);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 71 68.27% 2 50.00%
guenter roeck guenter roeck 33 31.73% 2 50.00%
Total 104 100.00% 4 100.00%

/* Driver data (common to all clients) */

static const struct i2c_device_id lm95241_id[] = {
	{ "lm95231", 0 },
	{ "lm95241", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm95241_id);


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


module_i2c_driver(lm95241_driver);

MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>");
MODULE_DESCRIPTION("LM95241 sensor driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
davide rizzo davide rizzo 1627 82.93% 2 14.29%
guenter roeck guenter roeck 217 11.06% 5 35.71%
jean delvare jean delvare 113 5.76% 5 35.71%
frans meulenbroeks frans meulenbroeks 4 0.20% 1 7.14%
axel lin axel lin 1 0.05% 1 7.14%
Total 1962 100.00% 14 100.00%
  Directory: drivers/hwmon

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
guenter roeck	guenter roeck	16	53.33%	1	33.33%
davide rizzo	davide rizzo	14	46.67%	2	66.67%
	Total	30	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/hwmon/lm95241.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
