[linux-2.6-block.git] / drivers / hwmon / tc654.c

/*
 * tc654.c - Linux kernel modules for fan speed controller
 *
 * Copyright (C) 2016 Allied Telesis Labs NZ
 *
 * 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.
 */

#include <linux/bitops.h>
#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/util_macros.h>

enum tc654_regs {
	TC654_REG_RPM1 = 0x00,	/* RPM Output 1 */
	TC654_REG_RPM2 = 0x01,	/* RPM Output 2 */
	TC654_REG_FAN_FAULT1 = 0x02,	/* Fan Fault 1 Threshold */
	TC654_REG_FAN_FAULT2 = 0x03,	/* Fan Fault 2 Threshold */
	TC654_REG_CONFIG = 0x04,	/* Configuration */
	TC654_REG_STATUS = 0x05,	/* Status */
	TC654_REG_DUTY_CYCLE = 0x06,	/* Fan Speed Duty Cycle */
	TC654_REG_MFR_ID = 0x07,	/* Manufacturer Identification */
	TC654_REG_VER_ID = 0x08,	/* Version Identification */
};

/* Macros to easily index the registers */
#define TC654_REG_RPM(idx)		(TC654_REG_RPM1 + (idx))
#define TC654_REG_FAN_FAULT(idx)	(TC654_REG_FAN_FAULT1 + (idx))

/* Config register bits */
#define TC654_REG_CONFIG_RES		BIT(6)	/* Resolution Selection */
#define TC654_REG_CONFIG_DUTYC		BIT(5)	/* Duty Cycle Control */
#define TC654_REG_CONFIG_SDM		BIT(0)	/* Shutdown Mode */

/* Status register bits */
#define TC654_REG_STATUS_F2F		BIT(1)	/* Fan 2 Fault */
#define TC654_REG_STATUS_F1F		BIT(0)	/* Fan 1 Fault */

/* RPM resolution for RPM Output registers */
#define TC654_HIGH_RPM_RESOLUTION	25	/* 25 RPM resolution */
#define TC654_LOW_RPM_RESOLUTION	50	/* 50 RPM resolution */

/* Convert to the fan fault RPM threshold from register value */
#define TC654_FAN_FAULT_FROM_REG(val)	((val) * 50)	/* 50 RPM resolution */

/* Convert to register value from the fan fault RPM threshold */
#define TC654_FAN_FAULT_TO_REG(val)	(((val) / 50) & 0xff)

/* Register data is read (and cached) at most once per second. */
#define TC654_UPDATE_INTERVAL		HZ

struct tc654_data {
	struct i2c_client *client;

	/* update mutex */
	struct mutex update_lock;

	/* tc654 register cache */
	bool valid;
	unsigned long last_updated;	/* in jiffies */

	u8 rpm_output[2];	/* The fan RPM data for fans 1 and 2 is then
				 * written to registers RPM1 and RPM2
				 */
	u8 fan_fault[2];	/* The Fan Fault Threshold Registers are used to
				 * set the fan fault threshold levels for fan 1
				 * and fan 2
				 */
	u8 config;	/* The Configuration Register is an 8-bit read/
			 * writable multi-function control register
			 *   7: Fan Fault Clear
			 *      1 = Clear Fan Fault
			 *      0 = Normal Operation (default)
			 *   6: Resolution Selection for RPM Output Registers
			 *      RPM Output Registers (RPM1 and RPM2) will be
			 *      set for
			 *      1 = 25 RPM (9-bit) resolution
			 *      0 = 50 RPM (8-bit) resolution (default)
			 *   5: Duty Cycle Control Method
			 *      The V OUT duty cycle will be controlled via
			 *      1 = the SMBus interface.
			 *      0 = via the V IN analog input pin. (default)
			 * 4,3: Fan 2 Pulses Per Rotation
			 *      00 = 1
			 *      01 = 2 (default)
			 *      10 = 4
			 *      11 = 8
			 * 2,1: Fan 1 Pulses Per Rotation
			 *      00 = 1
			 *      01 = 2 (default)
			 *      10 = 4
			 *      11 = 8
			 *   0: Shutdown Mode
			 *      1 = Shutdown mode.
			 *      0 = Normal operation. (default)
			 */
	u8 status;	/* The Status register provides all the information
			 * about what is going on within the TC654/TC655
			 * devices.
			 * 7,6: Unimplemented, Read as '0'
			 *   5: Over-Temperature Fault Condition
			 *      1 = Over-Temperature condition has occurred
			 *      0 = Normal operation. V IN is less than 2.6V
			 *   4: RPM2 Counter Overflow
			 *      1 = Fault condition
			 *      0 = Normal operation
			 *   3: RPM1 Counter Overflow
			 *      1 = Fault condition
			 *      0 = Normal operation
			 *   2: V IN Input Status
			 *      1 = V IN is open
			 *      0 = Normal operation. voltage present at V IN
			 *   1: Fan 2 Fault
			 *      1 = Fault condition
			 *      0 = Normal operation
			 *   0: Fan 1 Fault
			 *      1 = Fault condition
			 *      0 = Normal operation
			 */
	u8 duty_cycle;	/* The DUTY_CYCLE register is a 4-bit read/
			 * writable register used to control the duty
			 * cycle of the V OUT output.
			 */
};

/* helper to grab and cache data, at most one time per second */
static struct tc654_data *tc654_update_client(struct device *dev)
{
	struct tc654_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int ret = 0;

	mutex_lock(&data->update_lock);
	if (time_before(jiffies, data->last_updated + TC654_UPDATE_INTERVAL) &&
	    likely(data->valid))
		goto out;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(0));
	if (ret < 0)
		goto out;
	data->rpm_output[0] = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(1));
	if (ret < 0)
		goto out;
	data->rpm_output[1] = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(0));
	if (ret < 0)
		goto out;
	data->fan_fault[0] = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(1));
	if (ret < 0)
		goto out;
	data->fan_fault[1] = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
	if (ret < 0)
		goto out;
	data->config = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_STATUS);
	if (ret < 0)
		goto out;
	data->status = ret;

	ret = i2c_smbus_read_byte_data(client, TC654_REG_DUTY_CYCLE);
	if (ret < 0)
		goto out;
	data->duty_cycle = ret & 0x0f;

	data->last_updated = jiffies;
	data->valid = true;
out:
	mutex_unlock(&data->update_lock);

	if (ret < 0)		/* upon error, encode it in return value */
		data = ERR_PTR(ret);

	return data;
}

/*
 * sysfs attributes
 */

static ssize_t fan_show(struct device *dev, struct device_attribute *da,
			char *buf)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = tc654_update_client(dev);
	int val;

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

	if (data->config & TC654_REG_CONFIG_RES)
		val = data->rpm_output[nr] * TC654_HIGH_RPM_RESOLUTION;
	else
		val = data->rpm_output[nr] * TC654_LOW_RPM_RESOLUTION;

	return sprintf(buf, "%d\n", val);
}

static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,
			    char *buf)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = tc654_update_client(dev);

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

	return sprintf(buf, "%d\n",
		       TC654_FAN_FAULT_FROM_REG(data->fan_fault[nr]));
}

static ssize_t fan_min_store(struct device *dev, struct device_attribute *da,
			     const char *buf, size_t count)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	unsigned long val;
	int ret;

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

	val = clamp_val(val, 0, 12750);

	mutex_lock(&data->update_lock);

	data->fan_fault[nr] = TC654_FAN_FAULT_TO_REG(val);
	ret = i2c_smbus_write_byte_data(client, TC654_REG_FAN_FAULT(nr),
					data->fan_fault[nr]);

	mutex_unlock(&data->update_lock);
	return ret < 0 ? ret : count;
}

static ssize_t fan_alarm_show(struct device *dev, struct device_attribute *da,
			      char *buf)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = tc654_update_client(dev);
	int val;

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

	if (nr == 0)
		val = !!(data->status & TC654_REG_STATUS_F1F);
	else
		val = !!(data->status & TC654_REG_STATUS_F2F);

	return sprintf(buf, "%d\n", val);
}

static const u8 TC654_FAN_PULSE_SHIFT[] = { 1, 3 };

static ssize_t fan_pulses_show(struct device *dev,
			       struct device_attribute *da, char *buf)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = tc654_update_client(dev);
	u8 val;

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

	val = BIT((data->config >> TC654_FAN_PULSE_SHIFT[nr]) & 0x03);
	return sprintf(buf, "%d\n", val);
}

static ssize_t fan_pulses_store(struct device *dev,
				struct device_attribute *da, const char *buf,
				size_t count)
{
	int nr = to_sensor_dev_attr(da)->index;
	struct tc654_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u8 config;
	unsigned long val;
	int ret;

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

	switch (val) {
	case 1:
		config = 0;
		break;
	case 2:
		config = 1;
		break;
	case 4:
		config = 2;
		break;
	case 8:
		config = 3;
		break;
	default:
		return -EINVAL;
	}

	mutex_lock(&data->update_lock);

	data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]);
	data->config |= (config << TC654_FAN_PULSE_SHIFT[nr]);
	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);

	mutex_unlock(&data->update_lock);
	return ret < 0 ? ret : count;
}

static ssize_t pwm_mode_show(struct device *dev, struct device_attribute *da,
			     char *buf)
{
	struct tc654_data *data = tc654_update_client(dev);

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

	return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC));
}

static ssize_t pwm_mode_store(struct device *dev, struct device_attribute *da,
			      const char *buf, size_t count)
{
	struct tc654_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	unsigned long val;
	int ret;

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

	if (val != 0 && val != 1)
		return -EINVAL;

	mutex_lock(&data->update_lock);

	if (val)
		data->config |= TC654_REG_CONFIG_DUTYC;
	else
		data->config &= ~TC654_REG_CONFIG_DUTYC;

	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);

	mutex_unlock(&data->update_lock);
	return ret < 0 ? ret : count;
}

static const int tc654_pwm_map[16] = { 77,  88, 102, 112, 124, 136, 148, 160,
				      172, 184, 196, 207, 219, 231, 243, 255};

static ssize_t pwm_show(struct device *dev, struct device_attribute *da,
			char *buf)
{
	struct tc654_data *data = tc654_update_client(dev);
	int pwm;

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

	if (data->config & TC654_REG_CONFIG_SDM)
		pwm = 0;
	else
		pwm = tc654_pwm_map[data->duty_cycle];

	return sprintf(buf, "%d\n", pwm);
}

static ssize_t pwm_store(struct device *dev, struct device_attribute *da,
			 const char *buf, size_t count)
{
	struct tc654_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	unsigned long val;
	int ret;

	if (kstrtoul(buf, 10, &val))
		return -EINVAL;
	if (val > 255)
		return -EINVAL;

	mutex_lock(&data->update_lock);

	if (val == 0)
		data->config |= TC654_REG_CONFIG_SDM;
	else
		data->config &= ~TC654_REG_CONFIG_SDM;

	data->duty_cycle = find_closest(val, tc654_pwm_map,
					ARRAY_SIZE(tc654_pwm_map));

	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
	if (ret < 0)
		goto out;

	ret = i2c_smbus_write_byte_data(client, TC654_REG_DUTY_CYCLE,
					data->duty_cycle);

out:
	mutex_unlock(&data->update_lock);
	return ret < 0 ? ret : count;
}

static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0);
static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1);
static SENSOR_DEVICE_ATTR_RW(fan1_pulses, fan_pulses, 0);
static SENSOR_DEVICE_ATTR_RW(fan2_pulses, fan_pulses, 1);
static SENSOR_DEVICE_ATTR_RW(pwm1_mode, pwm_mode, 0);
static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);

/* Driver data */
static struct attribute *tc654_attrs[] = {
	&sensor_dev_attr_fan1_input.dev_attr.attr,
	&sensor_dev_attr_fan2_input.dev_attr.attr,
	&sensor_dev_attr_fan1_min.dev_attr.attr,
	&sensor_dev_attr_fan2_min.dev_attr.attr,
	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
	&sensor_dev_attr_fan1_pulses.dev_attr.attr,
	&sensor_dev_attr_fan2_pulses.dev_attr.attr,
	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
	&sensor_dev_attr_pwm1.dev_attr.attr,
	NULL
};

ATTRIBUTE_GROUPS(tc654);

/*
 * device probe and removal
 */

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

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

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

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

	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
	if (ret < 0)
		return ret;

	data->config = ret;

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

static const struct i2c_device_id tc654_id[] = {
	{"tc654", 0},
	{"tc655", 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, tc654_id);

static struct i2c_driver tc654_driver = {
	.driver = {
		   .name = "tc654",
		   },
	.probe = tc654_probe,
	.id_table = tc654_id,
};

module_i2c_driver(tc654_driver);

MODULE_AUTHOR("Allied Telesis Labs");
MODULE_DESCRIPTION("Microchip TC654/TC655 driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
aaf6fabf CP	1	/*
	2	* tc654.c - Linux kernel modules for fan speed controller
	3	*
	4	* Copyright (C) 2016 Allied Telesis Labs NZ
	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
	17	#include <linux/bitops.h>
	18	#include <linux/err.h>
	19	#include <linux/hwmon.h>
	20	#include <linux/hwmon-sysfs.h>
	21	#include <linux/i2c.h>
	22	#include <linux/init.h>
	23	#include <linux/jiffies.h>
	24	#include <linux/module.h>
	25	#include <linux/mutex.h>
	26	#include <linux/slab.h>
	27	#include <linux/util_macros.h>
	28
	29	enum tc654_regs {
	30	TC654_REG_RPM1 = 0x00, /* RPM Output 1 */
	31	TC654_REG_RPM2 = 0x01, /* RPM Output 2 */
	32	TC654_REG_FAN_FAULT1 = 0x02, /* Fan Fault 1 Threshold */
	33	TC654_REG_FAN_FAULT2 = 0x03, /* Fan Fault 2 Threshold */
	34	TC654_REG_CONFIG = 0x04, /* Configuration */
	35	TC654_REG_STATUS = 0x05, /* Status */
	36	TC654_REG_DUTY_CYCLE = 0x06, /* Fan Speed Duty Cycle */
	37	TC654_REG_MFR_ID = 0x07, /* Manufacturer Identification */
	38	TC654_REG_VER_ID = 0x08, /* Version Identification */
	39	};
	40
	41	/* Macros to easily index the registers */
	42	#define TC654_REG_RPM(idx) (TC654_REG_RPM1 + (idx))
	43	#define TC654_REG_FAN_FAULT(idx) (TC654_REG_FAN_FAULT1 + (idx))
	44
	45	/* Config register bits */
	46	#define TC654_REG_CONFIG_RES BIT(6) /* Resolution Selection */
	47	#define TC654_REG_CONFIG_DUTYC BIT(5) /* Duty Cycle Control */
	48	#define TC654_REG_CONFIG_SDM BIT(0) /* Shutdown Mode */
	49
	50	/* Status register bits */
	51	#define TC654_REG_STATUS_F2F BIT(1) /* Fan 2 Fault */
	52	#define TC654_REG_STATUS_F1F BIT(0) /* Fan 1 Fault */
	53
	54	/* RPM resolution for RPM Output registers */
	55	#define TC654_HIGH_RPM_RESOLUTION 25 /* 25 RPM resolution */
	56	#define TC654_LOW_RPM_RESOLUTION 50 /* 50 RPM resolution */
	57
	58	/* Convert to the fan fault RPM threshold from register value */
	59	#define TC654_FAN_FAULT_FROM_REG(val) ((val) * 50) /* 50 RPM resolution */
	60
	61	/* Convert to register value from the fan fault RPM threshold */
	62	#define TC654_FAN_FAULT_TO_REG(val) (((val) / 50) & 0xff)
	63
	64	/* Register data is read (and cached) at most once per second. */
65	#define TC654_UPDATE_INTERVAL HZ
66
67	struct tc654_data {
68	struct i2c_client *client;
69
70	/* update mutex */
71	struct mutex update_lock;
72
73	/* tc654 register cache */
74	bool valid;
75	unsigned long last_updated; /* in jiffies */
76
77	u8 rpm_output[2]; /* The fan RPM data for fans 1 and 2 is then
78	* written to registers RPM1 and RPM2
79	*/
80	u8 fan_fault[2]; /* The Fan Fault Threshold Registers are used to
81	* set the fan fault threshold levels for fan 1
82	* and fan 2
83	*/
84	u8 config; /* The Configuration Register is an 8-bit read/
85	* writable multi-function control register
86	* 7: Fan Fault Clear
87	* 1 = Clear Fan Fault
88	* 0 = Normal Operation (default)
89	* 6: Resolution Selection for RPM Output Registers
90	* RPM Output Registers (RPM1 and RPM2) will be
91	* set for
92	* 1 = 25 RPM (9-bit) resolution
93	* 0 = 50 RPM (8-bit) resolution (default)
94	* 5: Duty Cycle Control Method
95	* The V OUT duty cycle will be controlled via
96	* 1 = the SMBus interface.
97	* 0 = via the V IN analog input pin. (default)
98	* 4,3: Fan 2 Pulses Per Rotation
99	* 00 = 1
100	* 01 = 2 (default)
101	* 10 = 4
102	* 11 = 8
103	* 2,1: Fan 1 Pulses Per Rotation
104	* 00 = 1
105	* 01 = 2 (default)
106	* 10 = 4
107	* 11 = 8
108	* 0: Shutdown Mode
109	* 1 = Shutdown mode.
110	* 0 = Normal operation. (default)
111	*/
112	u8 status; /* The Status register provides all the information
113	* about what is going on within the TC654/TC655
114	* devices.
115	* 7,6: Unimplemented, Read as '0'
116	* 5: Over-Temperature Fault Condition
117	* 1 = Over-Temperature condition has occurred
118	* 0 = Normal operation. V IN is less than 2.6V
119	* 4: RPM2 Counter Overflow
120	* 1 = Fault condition
121	* 0 = Normal operation
122	* 3: RPM1 Counter Overflow
123	* 1 = Fault condition
124	* 0 = Normal operation
125	* 2: V IN Input Status
126	* 1 = V IN is open
127	* 0 = Normal operation. voltage present at V IN
128	* 1: Fan 2 Fault
129	* 1 = Fault condition
130	* 0 = Normal operation
131	* 0: Fan 1 Fault
132	* 1 = Fault condition
133	* 0 = Normal operation
134	*/
135	u8 duty_cycle; /* The DUTY_CYCLE register is a 4-bit read/
136	* writable register used to control the duty
137	* cycle of the V OUT output.
138	*/
139	};
140
141	/* helper to grab and cache data, at most one time per second */
142	static struct tc654_data tc654_update_client(struct device dev)
143	{
144	struct tc654_data *data = dev_get_drvdata(dev);
145	struct i2c_client *client = data->client;
146	int ret = 0;
147
148	mutex_lock(&data->update_lock);
149	if (time_before(jiffies, data->last_updated + TC654_UPDATE_INTERVAL) &&
150	likely(data->valid))
151	goto out;
152
153	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(0));
154	if (ret < 0)
155	goto out;
156	data->rpm_output[0] = ret;
157
158	ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(1));
159	if (ret < 0)
160	goto out;
161	data->rpm_output[1] = ret;
162
163	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(0));
164	if (ret < 0)
165	goto out;
166	data->fan_fault[0] = ret;
167
168	ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(1));
169	if (ret < 0)
170	goto out;
171	data->fan_fault[1] = ret;
172
173	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
174	if (ret < 0)
175	goto out;
176	data->config = ret;
177
178	ret = i2c_smbus_read_byte_data(client, TC654_REG_STATUS);
179	if (ret < 0)
180	goto out;
181	data->status = ret;
182
183	ret = i2c_smbus_read_byte_data(client, TC654_REG_DUTY_CYCLE);
184	if (ret < 0)
185	goto out;
186	data->duty_cycle = ret & 0x0f;
187
188	data->last_updated = jiffies;
189	data->valid = true;
190	out:
191	mutex_unlock(&data->update_lock);
192
193	if (ret < 0) /* upon error, encode it in return value */
194	data = ERR_PTR(ret);
195
196	return data;
197	}
198
199	/*
200	* sysfs attributes
201	*/
202
1acd2e29	203	static ssize_t fan_show(struct device dev, struct device_attribute da,
aaf6fabf CP	204	char *buf)
	205	{
	206	int nr = to_sensor_dev_attr(da)->index;
	207	struct tc654_data *data = tc654_update_client(dev);
	208	int val;
	209
	210	if (IS_ERR(data))
	211	return PTR_ERR(data);
	212
	213	if (data->config & TC654_REG_CONFIG_RES)
	214	val = data->rpm_output[nr] * TC654_HIGH_RPM_RESOLUTION;
	215	else
	216	val = data->rpm_output[nr] * TC654_LOW_RPM_RESOLUTION;
	217
	218	return sprintf(buf, "%d\n", val);
	219	}
	220
1acd2e29	221	static ssize_t fan_min_show(struct device dev, struct device_attribute da,
aaf6fabf CP	222	char *buf)
	223	{
	224	int nr = to_sensor_dev_attr(da)->index;
	225	struct tc654_data *data = tc654_update_client(dev);
	226
	227	if (IS_ERR(data))
	228	return PTR_ERR(data);
	229
	230	return sprintf(buf, "%d\n",
	231	TC654_FAN_FAULT_FROM_REG(data->fan_fault[nr]));
	232	}
	233
1acd2e29 GR	234	static ssize_t fan_min_store(struct device dev, struct device_attribute da,
1acd2e29 GR	235	const char *buf, size_t count)
aaf6fabf CP	236	{
	237	int nr = to_sensor_dev_attr(da)->index;
	238	struct tc654_data *data = dev_get_drvdata(dev);
	239	struct i2c_client *client = data->client;
	240	unsigned long val;
	241	int ret;
	242
	243	if (kstrtoul(buf, 10, &val))
	244	return -EINVAL;
	245
	246	val = clamp_val(val, 0, 12750);
	247
	248	mutex_lock(&data->update_lock);
	249
	250	data->fan_fault[nr] = TC654_FAN_FAULT_TO_REG(val);
	251	ret = i2c_smbus_write_byte_data(client, TC654_REG_FAN_FAULT(nr),
	252	data->fan_fault[nr]);
	253
	254	mutex_unlock(&data->update_lock);
	255	return ret < 0 ? ret : count;
	256	}
	257
1acd2e29	258	static ssize_t fan_alarm_show(struct device dev, struct device_attribute da,
aaf6fabf CP	259	char *buf)
	260	{
	261	int nr = to_sensor_dev_attr(da)->index;
	262	struct tc654_data *data = tc654_update_client(dev);
	263	int val;
	264
	265	if (IS_ERR(data))
	266	return PTR_ERR(data);
	267
	268	if (nr == 0)
	269	val = !!(data->status & TC654_REG_STATUS_F1F);
	270	else
	271	val = !!(data->status & TC654_REG_STATUS_F2F);
	272
	273	return sprintf(buf, "%d\n", val);
	274	}
	275
	276	static const u8 TC654_FAN_PULSE_SHIFT[] = { 1, 3 };
	277
1acd2e29 GR	278	static ssize_t fan_pulses_show(struct device *dev,
1acd2e29 GR	279	struct device_attribute da, char buf)
aaf6fabf CP	280	{
	281	int nr = to_sensor_dev_attr(da)->index;
	282	struct tc654_data *data = tc654_update_client(dev);
	283	u8 val;
	284
	285	if (IS_ERR(data))
	286	return PTR_ERR(data);
	287
	288	val = BIT((data->config >> TC654_FAN_PULSE_SHIFT[nr]) & 0x03);
	289	return sprintf(buf, "%d\n", val);
	290	}
	291
1acd2e29 GR	292	static ssize_t fan_pulses_store(struct device *dev,
	293	struct device_attribute da, const char buf,
	294	size_t count)
aaf6fabf CP	295	{
	296	int nr = to_sensor_dev_attr(da)->index;
	297	struct tc654_data *data = dev_get_drvdata(dev);
	298	struct i2c_client *client = data->client;
	299	u8 config;
	300	unsigned long val;
	301	int ret;
	302
	303	if (kstrtoul(buf, 10, &val))
	304	return -EINVAL;
	305
	306	switch (val) {
	307	case 1:
	308	config = 0;
	309	break;
	310	case 2:
	311	config = 1;
	312	break;
	313	case 4:
	314	config = 2;
	315	break;
	316	case 8:
	317	config = 3;
	318	break;
	319	default:
	320	return -EINVAL;
	321	}
	322
	323	mutex_lock(&data->update_lock);
	324
	325	data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]);
	326	data->config \|= (config << TC654_FAN_PULSE_SHIFT[nr]);
	327	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
	328
	329	mutex_unlock(&data->update_lock);
	330	return ret < 0 ? ret : count;
	331	}
	332
1acd2e29 GR	333	static ssize_t pwm_mode_show(struct device dev, struct device_attribute da,
1acd2e29 GR	334	char *buf)
aaf6fabf CP	335	{
	336	struct tc654_data *data = tc654_update_client(dev);
	337
	338	if (IS_ERR(data))
	339	return PTR_ERR(data);
	340
	341	return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC));
	342	}
	343
1acd2e29 GR	344	static ssize_t pwm_mode_store(struct device dev, struct device_attribute da,
1acd2e29 GR	345	const char *buf, size_t count)
aaf6fabf CP	346	{
	347	struct tc654_data *data = dev_get_drvdata(dev);
	348	struct i2c_client *client = data->client;
	349	unsigned long val;
	350	int ret;
	351
	352	if (kstrtoul(buf, 10, &val))
	353	return -EINVAL;
	354
	355	if (val != 0 && val != 1)
	356	return -EINVAL;
	357
	358	mutex_lock(&data->update_lock);
	359
	360	if (val)
	361	data->config \|= TC654_REG_CONFIG_DUTYC;
	362	else
	363	data->config &= ~TC654_REG_CONFIG_DUTYC;
	364
	365	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
	366
	367	mutex_unlock(&data->update_lock);
	368	return ret < 0 ? ret : count;
	369	}
	370
	371	static const int tc654_pwm_map[16] = { 77, 88, 102, 112, 124, 136, 148, 160,
	372	172, 184, 196, 207, 219, 231, 243, 255};
	373
1acd2e29	374	static ssize_t pwm_show(struct device dev, struct device_attribute da,
aaf6fabf CP	375	char *buf)
	376	{
	377	struct tc654_data *data = tc654_update_client(dev);
	378	int pwm;
	379
	380	if (IS_ERR(data))
	381	return PTR_ERR(data);
	382
	383	if (data->config & TC654_REG_CONFIG_SDM)
	384	pwm = 0;
	385	else
	386	pwm = tc654_pwm_map[data->duty_cycle];
	387
	388	return sprintf(buf, "%d\n", pwm);
	389	}
	390
1acd2e29 GR	391	static ssize_t pwm_store(struct device dev, struct device_attribute da,
1acd2e29 GR	392	const char *buf, size_t count)
aaf6fabf CP	393	{
	394	struct tc654_data *data = dev_get_drvdata(dev);
	395	struct i2c_client *client = data->client;
	396	unsigned long val;
	397	int ret;
	398
	399	if (kstrtoul(buf, 10, &val))
	400	return -EINVAL;
	401	if (val > 255)
	402	return -EINVAL;
	403
	404	mutex_lock(&data->update_lock);
	405
	406	if (val == 0)
	407	data->config \|= TC654_REG_CONFIG_SDM;
	408	else
	409	data->config &= ~TC654_REG_CONFIG_SDM;
	410
	411	data->duty_cycle = find_closest(val, tc654_pwm_map,
	412	ARRAY_SIZE(tc654_pwm_map));
	413
	414	ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config);
	415	if (ret < 0)
	416	goto out;
	417
	418	ret = i2c_smbus_write_byte_data(client, TC654_REG_DUTY_CYCLE,
	419	data->duty_cycle);
	420
	421	out:
	422	mutex_unlock(&data->update_lock);
	423	return ret < 0 ? ret : count;
	424	}
	425
1acd2e29 GR	426	static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
	427	static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
	428	static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
	429	static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
	430	static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0);
	431	static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1);
	432	static SENSOR_DEVICE_ATTR_RW(fan1_pulses, fan_pulses, 0);
	433	static SENSOR_DEVICE_ATTR_RW(fan2_pulses, fan_pulses, 1);
	434	static SENSOR_DEVICE_ATTR_RW(pwm1_mode, pwm_mode, 0);
	435	static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
aaf6fabf CP	436
	437	/* Driver data */
	438	static struct attribute *tc654_attrs[] = {
	439	&sensor_dev_attr_fan1_input.dev_attr.attr,
	440	&sensor_dev_attr_fan2_input.dev_attr.attr,
	441	&sensor_dev_attr_fan1_min.dev_attr.attr,
	442	&sensor_dev_attr_fan2_min.dev_attr.attr,
	443	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
	444	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
	445	&sensor_dev_attr_fan1_pulses.dev_attr.attr,
	446	&sensor_dev_attr_fan2_pulses.dev_attr.attr,
	447	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
	448	&sensor_dev_attr_pwm1.dev_attr.attr,
	449	NULL
	450	};
	451
	452	ATTRIBUTE_GROUPS(tc654);
	453
	454	/*
	455	* device probe and removal
	456	*/
	457
	458	static int tc654_probe(struct i2c_client *client,
	459	const struct i2c_device_id *id)
	460	{
	461	struct device *dev = &client->dev;
	462	struct tc654_data *data;
	463	struct device *hwmon_dev;
	464	int ret;
	465
	466	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	467	return -ENODEV;
	468
	469	data = devm_kzalloc(dev, sizeof(struct tc654_data), GFP_KERNEL);
	470	if (!data)
	471	return -ENOMEM;
	472
	473	data->client = client;
	474	mutex_init(&data->update_lock);
	475
	476	ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG);
	477	if (ret < 0)
	478	return ret;
	479
	480	data->config = ret;
	481
	482	hwmon_dev =
	483	devm_hwmon_device_register_with_groups(dev, client->name, data,
	484	tc654_groups);
	485	return PTR_ERR_OR_ZERO(hwmon_dev);
	486	}
	487
	488	static const struct i2c_device_id tc654_id[] = {
	489	{"tc654", 0},
	490	{"tc655", 0},
	491	{}
	492	};
	493
	494	MODULE_DEVICE_TABLE(i2c, tc654_id);
	495
	496	static struct i2c_driver tc654_driver = {
	497	.driver = {
	498	.name = "tc654",
	499	},
500	.probe = tc654_probe,
501	.id_table = tc654_id,
502	};
503
504	module_i2c_driver(tc654_driver);
505
506	MODULE_AUTHOR("Allied Telesis Labs");
507	MODULE_DESCRIPTION("Microchip TC654/TC655 driver");
508	MODULE_LICENSE("GPL");