// SPDX-License-Identifier: GPL-2.0-or-later
/*
* tc654.c - Linux kernel modules for fan speed controller
*
* Copyright (C) 2016 Allied Telesis Labs NZ
*/
#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)
{
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_new = 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");
