Release 4.11 drivers/hwmon/gl520sm.c

/*
 * gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
 *             monitoring
 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
 *                           Kyösti Mälkki <kmalkki@cc.hut.fi>
 * Copyright (c) 2005   Maarten Deprez <maartendeprez@users.sourceforge.net>
 *
 * 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/hwmon-vid.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>

/* Type of the extra sensor */

static unsigned short extra_sensor_type;
module_param(extra_sensor_type, ushort, 0);
MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");

/* Addresses to scan */

static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };

/*
 * Many GL520 constants specified below
 * One of the inputs can be configured as either temp or voltage.
 * That's why _TEMP2 and _IN4 access the same register
 */

/* The GL520 registers */

#define GL520_REG_CHIP_ID		0x00

#define GL520_REG_REVISION		0x01

#define GL520_REG_CONF			0x03

#define GL520_REG_MASK			0x11


#define GL520_REG_VID_INPUT		0x02


static const u8 GL520_REG_IN_INPUT[]	= { 0x15, 0x14, 0x13, 0x0d, 0x0e };

static const u8 GL520_REG_IN_LIMIT[]	= { 0x0c, 0x09, 0x0a, 0x0b };

static const u8 GL520_REG_IN_MIN[]	= { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };

static const u8 GL520_REG_IN_MAX[]	= { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };


static const u8 GL520_REG_TEMP_INPUT[]		= { 0x04, 0x0e };

static const u8 GL520_REG_TEMP_MAX[]		= { 0x05, 0x17 };

static const u8 GL520_REG_TEMP_MAX_HYST[]	= { 0x06, 0x18 };


#define GL520_REG_FAN_INPUT		0x07

#define GL520_REG_FAN_MIN		0x08

#define GL520_REG_FAN_DIV		0x0f

#define GL520_REG_FAN_OFF		GL520_REG_FAN_DIV


#define GL520_REG_ALARMS		0x12

#define GL520_REG_BEEP_MASK		0x10

#define GL520_REG_BEEP_ENABLE		GL520_REG_CONF

/* Client data */

struct gl520_data {
	
struct i2c_client *client;
	
const struct attribute_group *groups[3];
	
struct mutex update_lock;
	
char valid;		/* zero until the following fields are valid */
	
unsigned long last_updated;	/* in jiffies */

	
u8 vid;
	
u8 vrm;
	
u8 in_input[5];		/* [0] = VVD */
	
u8 in_min[5];		/* [0] = VDD */
	
u8 in_max[5];		/* [0] = VDD */
	
u8 fan_input[2];
	
u8 fan_min[2];
	
u8 fan_div[2];
	
u8 fan_off;
	
u8 temp_input[2];
	
u8 temp_max[2];
	
u8 temp_max_hyst[2];
	
u8 alarms;
	
u8 beep_enable;
	
u8 beep_mask;
	
u8 alarm_mask;
	
u8 two_temps;
};

/*
 * Registers 0x07 to 0x0c are word-sized, others are byte-sized
 * GL520 uses a high-byte first convention
 */


static int gl520_read_value(struct i2c_client *client, u8 reg)
{
	if ((reg >= 0x07) && (reg <= 0x0c))
		return i2c_smbus_read_word_swapped(client, reg);
	else
		return i2c_smbus_read_byte_data(client, reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
30
66.67%
1
33.33%
maartendeprez@scarlet.be
14
31.11%
1
33.33%
Jean Delvare
1
2.22%
1
33.33%
Total
45
100.00%
3
100.00%



static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
{
	if ((reg >= 0x07) && (reg <= 0x0c))
		return i2c_smbus_write_word_swapped(client, reg, value);
	else
		return i2c_smbus_write_byte_data(client, reg, value);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
27
51.92%
1
33.33%
maartendeprez@scarlet.be
23
44.23%
1
33.33%
Jean Delvare
2
3.85%
1
33.33%
Total
52
100.00%
3
100.00%



static struct gl520_data *gl520_update_device(struct device *dev)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int val, i;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {

		dev_dbg(&client->dev, "Starting gl520sm update\n");

		data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
		data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
		data->vid = gl520_read_value(client,
					     GL520_REG_VID_INPUT) & 0x1f;

		for (i = 0; i < 4; i++) {
			data->in_input[i] = gl520_read_value(client,
							GL520_REG_IN_INPUT[i]);
			val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
			data->in_min[i] = val & 0xff;
			data->in_max[i] = (val >> 8) & 0xff;
		}

		val = gl520_read_value(client, GL520_REG_FAN_INPUT);
		data->fan_input[0] = (val >> 8) & 0xff;
		data->fan_input[1] = val & 0xff;

		val = gl520_read_value(client, GL520_REG_FAN_MIN);
		data->fan_min[0] = (val >> 8) & 0xff;
		data->fan_min[1] = val & 0xff;

		data->temp_input[0] = gl520_read_value(client,
						GL520_REG_TEMP_INPUT[0]);
		data->temp_max[0] = gl520_read_value(client,
						GL520_REG_TEMP_MAX[0]);
		data->temp_max_hyst[0] = gl520_read_value(client,
						GL520_REG_TEMP_MAX_HYST[0]);

		val = gl520_read_value(client, GL520_REG_FAN_DIV);
		data->fan_div[0] = (val >> 6) & 0x03;
		data->fan_div[1] = (val >> 4) & 0x03;
		data->fan_off = (val >> 2) & 0x01;

		data->alarms &= data->alarm_mask;

		val = gl520_read_value(client, GL520_REG_CONF);
		data->beep_enable = !((val >> 2) & 1);

		/* Temp1 and Vin4 are the same input */
		if (data->two_temps) {
			data->temp_input[1] = gl520_read_value(client,
						GL520_REG_TEMP_INPUT[1]);
			data->temp_max[1] = gl520_read_value(client,
						GL520_REG_TEMP_MAX[1]);
			data->temp_max_hyst[1] = gl520_read_value(client,
						GL520_REG_TEMP_MAX_HYST[1]);
		} else {
			data->in_input[4] = gl520_read_value(client,
						GL520_REG_IN_INPUT[4]);
			data->in_min[4] = gl520_read_value(client,
						GL520_REG_IN_MIN[4]);
			data->in_max[4] = gl520_read_value(client,
						GL520_REG_IN_MAX[4]);
		}

		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
379
72.47%
2
33.33%
maartendeprez@scarlet.be
70
13.38%
1
16.67%
Jean Delvare
68
13.00%
2
33.33%
Guenter Roeck
6
1.15%
1
16.67%
Total
523
100.00%
6
100.00%

/*
 * Sysfs stuff
 */



static ssize_t cpu0_vid_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct gl520_data *data = gl520_update_device(dev);
	return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
38
77.55%
1
25.00%
Jean Delvare
9
18.37%
1
25.00%
maartendeprez@scarlet.be
1
2.04%
1
25.00%
Julia Lawall
1
2.04%
1
25.00%
Total
49
100.00%
4
100.00%

static DEVICE_ATTR_RO(cpu0_vid);


#define VDD_FROM_REG(val)	DIV_ROUND_CLOSEST((val) * 95, 4)

#define VDD_CLAMP(val)		clamp_val(val, 0, 255 * 95 / 4)

#define VDD_TO_REG(val)		DIV_ROUND_CLOSEST(VDD_CLAMP(val) * 4, 95)


#define IN_FROM_REG(val)	((val) * 19)

#define IN_CLAMP(val)		clamp_val(val, 0, 255 * 19)

#define IN_TO_REG(val)		DIV_ROUND_CLOSEST(IN_CLAMP(val), 19)



static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);
	u8 r = data->in_input[n];

	if (n == 0)
		return sprintf(buf, "%d\n", VDD_FROM_REG(r));
	else
		return sprintf(buf, "%d\n", IN_FROM_REG(r));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
46
55.42%
1
33.33%
Axel Lin
32
38.55%
1
33.33%
maartendeprez@scarlet.be
5
6.02%
1
33.33%
Total
83
100.00%
3
100.00%



static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);
	u8 r = data->in_min[n];

	if (n == 0)
		return sprintf(buf, "%d\n", VDD_FROM_REG(r));
	else
		return sprintf(buf, "%d\n", IN_FROM_REG(r));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
40
48.19%
1
33.33%
Axel Lin
32
38.55%
1
33.33%
maartendeprez@scarlet.be
11
13.25%
1
33.33%
Total
83
100.00%
3
100.00%



static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);
	u8 r = data->in_max[n];

	if (n == 0)
		return sprintf(buf, "%d\n", VDD_FROM_REG(r));
	else
		return sprintf(buf, "%d\n", IN_FROM_REG(r));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
36
43.37%
1
33.33%
Axel Lin
24
28.92%
1
33.33%
maartendeprez@scarlet.be
23
27.71%
1
33.33%
Total
83
100.00%
3
100.00%



static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	u8 r;
	long v;
	int err;

	err = kstrtol(buf, 10, &v);
	if (err)
		return err;

	mutex_lock(&data->update_lock);

	if (n == 0)
		r = VDD_TO_REG(v);
	else
		r = IN_TO_REG(v);

	data->in_min[n] = r;

	if (n < 4)
		gl520_write_value(client, GL520_REG_IN_MIN[n],
				  (gl520_read_value(client, GL520_REG_IN_MIN[n])
				   & ~0xff) | r);
	else
		gl520_write_value(client, GL520_REG_IN_MIN[n], r);

	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
73
41.48%
1
14.29%
Jean Delvare
43
24.43%
2
28.57%
Axel Lin
38
21.59%
2
28.57%
Guenter Roeck
20
11.36%
1
14.29%
Ingo Molnar
2
1.14%
1
14.29%
Total
176
100.00%
7
100.00%



static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	u8 r;
	long v;
	int err;

	err = kstrtol(buf, 10, &v);
	if (err)
		return err;

	if (n == 0)
		r = VDD_TO_REG(v);
	else
		r = IN_TO_REG(v);

	mutex_lock(&data->update_lock);

	data->in_max[n] = r;

	if (n < 4)
		gl520_write_value(client, GL520_REG_IN_MAX[n],
				  (gl520_read_value(client, GL520_REG_IN_MAX[n])
				   & ~0xff00) | (r << 8));
	else
		gl520_write_value(client, GL520_REG_IN_MAX[n], r);

	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
82
45.56%
1
14.29%
Jean Delvare
40
22.22%
2
28.57%
Axel Lin
36
20.00%
2
28.57%
Guenter Roeck
20
11.11%
1
14.29%
Ingo Molnar
2
1.11%
1
14.29%
Total
180
100.00%
7
100.00%

static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3);
static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4);
static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
		get_in_min, set_in_min, 0);
static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
		get_in_min, set_in_min, 1);
static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
		get_in_min, set_in_min, 2);
static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
		get_in_min, set_in_min, 3);
static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
		get_in_min, set_in_min, 4);
static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
		get_in_max, set_in_max, 0);
static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
		get_in_max, set_in_max, 1);
static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
		get_in_max, set_in_max, 2);
static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
		get_in_max, set_in_max, 3);
static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
		get_in_max, set_in_max, 4);


#define DIV_FROM_REG(val) (1 << (val))

#define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))


#define FAN_BASE(div)		(480000 >> (div))

#define FAN_CLAMP(val, div)	clamp_val(val, FAN_BASE(div) / 255, \
                                          FAN_BASE(div))

#define FAN_TO_REG(val, div)	((val) == 0 ? 0 : \
                                 DIV_ROUND_CLOSEST(480000, \
                                                FAN_CLAMP(val, div) << (div)))



static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
						 data->fan_div[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
28
43.08%
1
33.33%
Jean Delvare
27
41.54%
1
33.33%
Axel Lin
10
15.38%
1
33.33%
Total
65
100.00%
3
100.00%



static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
						 data->fan_div[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
28
43.08%
1
33.33%
Jean Delvare
27
41.54%
1
33.33%
Axel Lin
10
15.38%
1
33.33%
Total
65
100.00%
3
100.00%



static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
28
48.28%
1
33.33%
Jean Delvare
27
46.55%
1
33.33%
Axel Lin
3
5.17%
1
33.33%
Total
58
100.00%
3
100.00%



static ssize_t fan1_off_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct gl520_data *data = gl520_update_device(dev);
	return sprintf(buf, "%d\n", data->fan_off);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
39
92.86%
1
33.33%
maartendeprez@scarlet.be
2
4.76%
1
33.33%
Julia Lawall
1
2.38%
1
33.33%
Total
42
100.00%
3
100.00%



static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	u8 r;
	unsigned long v;
	int err;

	err = kstrtoul(buf, 10, &v);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	r = FAN_TO_REG(v, data->fan_div[n]);
	data->fan_min[n] = r;

	if (n == 0)
		gl520_write_value(client, GL520_REG_FAN_MIN,
				  (gl520_read_value(client, GL520_REG_FAN_MIN)
				   & ~0xff00) | (r << 8));
	else
		gl520_write_value(client, GL520_REG_FAN_MIN,
				  (gl520_read_value(client, GL520_REG_FAN_MIN)
				   & ~0xff) | r);

	data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
	if (data->fan_min[n] == 0)
		data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
	else
		data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
	data->beep_mask &= data->alarm_mask;
	gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);

	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
142
57.03%
2
28.57%
Jean Delvare
45
18.07%
2
28.57%
maartendeprez@scarlet.be
43
17.27%
1
14.29%
Guenter Roeck
17
6.83%
1
14.29%
Ingo Molnar
2
0.80%
1
14.29%
Total
249
100.00%
7
100.00%



static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	u8 r;
	unsigned long v;
	int err;

	err = kstrtoul(buf, 10, &v);
	if (err)
		return err;

	switch (v) {
	case 1:
		r = 0;
		break;
	case 2:
		r = 1;
		break;
	case 4:
		r = 2;
		break;
	case 8:
		r = 3;
		break;
	default:
		dev_err(&client->dev,
	"fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
		return -EINVAL;
	}

	mutex_lock(&data->update_lock);
	data->fan_div[n] = r;

	if (n == 0)
		gl520_write_value(client, GL520_REG_FAN_DIV,
				  (gl520_read_value(client, GL520_REG_FAN_DIV)
				   & ~0xc0) | (r << 6));
	else
		gl520_write_value(client, GL520_REG_FAN_DIV,
				  (gl520_read_value(client, GL520_REG_FAN_DIV)
				   & ~0x30) | (r << 4));

	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
114
51.35%
2
28.57%
Jean Delvare
48
21.62%
2
28.57%
maartendeprez@scarlet.be
42
18.92%
1
14.29%
Guenter Roeck
17
7.66%
1
14.29%
Ingo Molnar
1
0.45%
1
14.29%
Total
222
100.00%
7
100.00%



static ssize_t fan1_off_store(struct device *dev,
			      struct device_attribute *attr, const char *buf,
			      size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u8 r;
	unsigned long v;
	int err;

	err = kstrtoul(buf, 10, &v);
	if (err)
		return err;

	r = (v ? 1 : 0);

	mutex_lock(&data->update_lock);
	data->fan_off = r;
	gl520_write_value(client, GL520_REG_FAN_OFF,
			  (gl520_read_value(client, GL520_REG_FAN_OFF)
			   & ~0x0c) | (r << 2));
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
maartendeprez@scarlet.be
58
43.94%
1
12.50%
Jean Delvare
30
22.73%
2
25.00%
Guenter Roeck
28
21.21%
1
12.50%
Axel Lin
13
9.85%
2
25.00%
Ingo Molnar
2
1.52%
1
12.50%
Julia Lawall
1
0.76%
1
12.50%
Total
132
100.00%
8
100.00%

static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
		get_fan_min, set_fan_min, 0);
static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
		get_fan_min, set_fan_min, 1);
static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
		get_fan_div, set_fan_div, 0);
static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
		get_fan_div, set_fan_div, 1);
static DEVICE_ATTR_RW(fan1_off);


#define TEMP_FROM_REG(val)	(((val) - 130) * 1000)

#define TEMP_CLAMP(val)		clamp_val(val, -130000, 125000)

#define TEMP_TO_REG(val)	(DIV_ROUND_CLOSEST(TEMP_CLAMP(val), 1000) + 130)



static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
			      char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
49
84.48%
1
50.00%
Axel Lin
9
15.52%
1
50.00%
Total
58
100.00%
2
100.00%



static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
47
81.03%
1
50.00%
Jean Delvare
11
18.97%
1
50.00%
Total
58
100.00%
2
100.00%



static ssize_t get_temp_max_hyst(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	int n = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
49
84.48%
1
50.00%
Axel Lin
9
15.52%
1
50.00%
Total
58
100.00%
2
100.00%



static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	long v;
	int err;

	err = kstrtol(buf, 10, &v);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->temp_max[n] = TEMP_TO_REG(v);
	gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jean Delvare
89
70.63%
1
25.00%
Axel Lin
26
20.63%
2
50.00%
Guenter Roeck
11
8.73%
1
25.00%
Total
126
100.00%
4
100.00%



static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
				 *attr, const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int n = to_sensor_dev_attr(attr)->index;
	long v;
	int err;

	err = kstrtol(buf, 10, &v);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->temp_max_hyst[n] = TEMP_TO_REG(v);
	gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
			  data->temp_max_hyst[n]);
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
119
94.44%
2
66.67%
Jean Delvare
7
5.56%
1
33.33%
Total
126
100.00%
3
100.00%

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
		get_temp_max, set_temp_max, 0);
static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
		get_temp_max, set_temp_max, 1);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
		get_temp_max_hyst, set_temp_max_hyst, 0);
static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
		get_temp_max_hyst, set_temp_max_hyst, 1);



static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct gl520_data *data = gl520_update_device(dev);
	return sprintf(buf, "%d\n", data->alarms);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
36
85.71%
1
33.33%
Jean Delvare
5
11.90%
1
33.33%
Julia Lawall
1
2.38%
1
33.33%
Total
42
100.00%
3
100.00%



static ssize_t beep_enable_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct gl520_data *data = gl520_update_device(dev);
	return sprintf(buf, "%d\n", data->beep_enable);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
37
88.10%
1
33.33%
Jean Delvare
4
9.52%
1
33.33%
Julia Lawall
1
2.38%
1
33.33%
Total
42
100.00%
3
100.00%



static ssize_t beep_mask_show(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	struct gl520_data *data = gl520_update_device(dev);
	return sprintf(buf, "%d\n", data->beep_mask);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
41
97.62%
1
50.00%
Julia Lawall
1
2.38%
1
50.00%
Total
42
100.00%
2
100.00%



static ssize_t beep_enable_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u8 r;
	unsigned long v;
	int err;

	err = kstrtoul(buf, 10, &v);
	if (err)
		return err;

	r = (v ? 0 : 1);

	mutex_lock(&data->update_lock);
	data->beep_enable = !r;
	gl520_write_value(client, GL520_REG_BEEP_ENABLE,
			  (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
			   & ~0x04) | (r << 2));
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
132
99.25%
2
66.67%
Julia Lawall
1
0.75%
1
33.33%
Total
133
100.00%
3
100.00%



static ssize_t beep_mask_store(struct device *dev,
			       struct device_attribute *attr, const char *buf,
			       size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	unsigned long r;
	int err;

	err = kstrtoul(buf, 10, &r);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	r &= data->alarm_mask;
	data->beep_mask = r;
	gl520_write_value(client, GL520_REG_BEEP_MASK, r);
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
108
99.08%
2
66.67%
Julia Lawall
1
0.92%
1
33.33%
Total
109
100.00%
3
100.00%

static DEVICE_ATTR_RO(alarms);
static DEVICE_ATTR_RW(beep_enable);
static DEVICE_ATTR_RW(beep_mask);



static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	int bit_nr = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%

static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);



static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	int bitnr = to_sensor_dev_attr(attr)->index;
	struct gl520_data *data = gl520_update_device(dev);

	return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%



static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	struct gl520_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int bitnr = to_sensor_dev_attr(attr)->index;
	unsigned long bit;

	int err;

	err = kstrtoul(buf, 10, &bit);
	if (err)
		return err;
	if (bit & ~1)
		return -EINVAL;

	mutex_lock(&data->update_lock);
	data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
	if (bit)
		data->beep_mask |= (1 << bitnr);
	else
		data->beep_mask &= ~(1 << bitnr);
	gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
	mutex_unlock(&data->update_lock);
	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
157
100.00%
2
100.00%
Total
157
100.00%
2
100.00%

static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);


static struct attribute *gl520_attributes[] = {
	&dev_attr_cpu0_vid.attr,

	&sensor_dev_attr_in0_input.dev_attr.attr,
	&sensor_dev_attr_in0_min.dev_attr.attr,
	&sensor_dev_attr_in0_max.dev_attr.attr,
	&sensor_dev_attr_in0_alarm.dev_attr.attr,
	&sensor_dev_attr_in0_beep.dev_attr.attr,
	&sensor_dev_attr_in1_input.dev_attr.attr,
	&sensor_dev_attr_in1_min.dev_attr.attr,
	&sensor_dev_attr_in1_max.dev_attr.attr,
	&sensor_dev_attr_in1_alarm.dev_attr.attr,
	&sensor_dev_attr_in1_beep.dev_attr.attr,
	&sensor_dev_attr_in2_input.dev_attr.attr,
	&sensor_dev_attr_in2_min.dev_attr.attr,
	&sensor_dev_attr_in2_max.dev_attr.attr,
	&sensor_dev_attr_in2_alarm.dev_attr.attr,
	&sensor_dev_attr_in2_beep.dev_attr.attr,
	&sensor_dev_attr_in3_input.dev_attr.attr,
	&sensor_dev_attr_in3_min.dev_attr.attr,
	&sensor_dev_attr_in3_max.dev_attr.attr,
	&sensor_dev_attr_in3_alarm.dev_attr.attr,
	&sensor_dev_attr_in3_beep.dev_attr.attr,

	&sensor_dev_attr_fan1_input.dev_attr.attr,
	&sensor_dev_attr_fan1_min.dev_attr.attr,
	&sensor_dev_attr_fan1_div.dev_attr.attr,
	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
	&sensor_dev_attr_fan1_beep.dev_attr.attr,
	&dev_attr_fan1_off.attr,
	&sensor_dev_attr_fan2_input.dev_attr.attr,
	&sensor_dev_attr_fan2_min.dev_attr.attr,
	&sensor_dev_attr_fan2_div.dev_attr.attr,
	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
	&sensor_dev_attr_fan2_beep.dev_attr.attr,

	&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,
	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_beep.dev_attr.attr,

	&dev_attr_alarms.attr,
	&dev_attr_beep_enable.attr,
	&dev_attr_beep_mask.attr,
	NULL
};


static const struct attribute_group gl520_group = {
	.attrs = gl520_attributes,
};


static struct attribute *gl520_attributes_in4[] = {
	&sensor_dev_attr_in4_input.dev_attr.attr,
	&sensor_dev_attr_in4_min.dev_attr.attr,
	&sensor_dev_attr_in4_max.dev_attr.attr,
	&sensor_dev_attr_in4_alarm.dev_attr.attr,
	&sensor_dev_attr_in4_beep.dev_attr.attr,
	NULL
};


static struct attribute *gl520_attributes_temp2[] = {
	&sensor_dev_attr_temp2_input.dev_attr.attr,
	&sensor_dev_attr_temp2_max.dev_attr.attr,
	&sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_beep.dev_attr.attr,
	NULL
};


static const struct attribute_group gl520_group_in4 = {
	.attrs = gl520_attributes_in4,
};


static const struct attribute_group gl520_group_temp2 = {
	.attrs = gl520_attributes_temp2,
};


/*
 * Real code
 */

/* Return 0 if detection is successful, -ENODEV otherwise */


static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;

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

	/* Determine the chip type. */
	if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
	    ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
	    ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
		dev_dbg(&client->dev, "Unknown chip type, skipping\n");
		return -ENODEV;
	}

	strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
69
60.00%
1
33.33%
maartendeprez@scarlet.be
43
37.39%
1
33.33%
Jean Delvare
3
2.61%
1
33.33%
Total
115
100.00%
3
100.00%

/* Called when we have found a new GL520SM. */


static void gl520_init_client(struct i2c_client *client)
{
	struct gl520_data *data = i2c_get_clientdata(client);
	u8 oldconf, conf;

	conf = oldconf = gl520_read_value(client, GL520_REG_CONF);

	data->alarm_mask = 0xff;
	data->vrm = vid_which_vrm();

	if (extra_sensor_type == 1)
		conf &= ~0x10;
	else if (extra_sensor_type == 2)
		conf |= 0x10;
	data->two_temps = !(conf & 0x10);

	/* If IRQ# is disabled, we can safely force comparator mode */
	if (!(conf & 0x20))
		conf &= 0xf7;

	/* Enable monitoring if needed */
	conf |= 0x40;

	if (conf != oldconf)
		gl520_write_value(client, GL520_REG_CONF, conf);

	gl520_update_device(&(client->dev));

	if (data->fan_min[0] == 0)
		data->alarm_mask &= ~0x20;
	if (data->fan_min[1] == 0)
		data->alarm_mask &= ~0x40;

	data->beep_mask &= data->alarm_mask;
	gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
126
69.23%
1
33.33%
maartendeprez@scarlet.be
54
29.67%
1
33.33%
Jean Delvare
2
1.10%
1
33.33%
Total
182
100.00%
3
100.00%



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

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

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

	/* Initialize the GL520SM chip */
	gl520_init_client(client);

	/* sysfs hooks */
	data->groups[0] = &gl520_group;

	if (data->two_temps)
		data->groups[1] = &gl520_group_temp2;
	else
		data->groups[1] = &gl520_group_in4;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
109
73.15%
2
66.67%
maartendeprez@scarlet.be
40
26.85%
1
33.33%
Total
149
100.00%
3
100.00%


static const struct i2c_device_id gl520_id[] = {
	{ "gl520sm", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, gl520_id);


static struct i2c_driver gl520_driver = {
	.class		= I2C_CLASS_HWMON,
	.driver = {
		.name	= "gl520sm",
        },
	.probe		= gl520_probe,
	.id_table	= gl520_id,
	.detect		= gl520_detect,
	.address_list	= normal_i2c,
};


module_i2c_driver(gl520_driver);

MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
	"Kyösti Mälkki <kmalkki@cc.hut.fi>, "
	"Maarten Deprez <maartendeprez@users.sourceforge.net>");
MODULE_DESCRIPTION("GL520SM driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Axel Lin
2970
56.20%
3
14.29%
Jean Delvare
1179
22.31%
8
38.10%
maartendeprez@scarlet.be
923
17.46%
1
4.76%
Guenter Roeck
173
3.27%
4
19.05%
Ingo Molnar
13
0.25%
1
4.76%
Mark M. Hoffman
13
0.25%
2
9.52%
Julia Lawall
13
0.25%
1
4.76%
Jan Engelhardt
1
0.02%
1
4.76%
Total
5285
100.00%
21
100.00%
Directory: drivers/hwmon

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.