![Guenter Roeck](/assets/img/avatar_default.png)
The HWMON_CHANNEL_INFO macro simplifies the code, reduces the likelihood of errors, and makes the code easier to read. The conversion was done automatically with coccinelle. The semantic patch used to make this change is as follows. @r@ initializer list elements; identifier i; @@ -u32 i[] = { - elements, - 0 -}; @s@ identifier r.i,j,ty; @@ -struct hwmon_channel_info j = { - .type = ty, - .config = i, -}; @script:ocaml t@ ty << s.ty; elements << r.elements; shorter; elems; @@ shorter := make_ident (List.hd(List.rev (Str.split (Str.regexp "_") ty))); elems := make_ident (String.concat "," (List.map (fun x -> Printf.sprintf "\n\t\t\t %s" x) (Str.split (Str.regexp " , ") elements))) @@ identifier s.j,t.shorter; identifier t.elems; @@ - &j + HWMON_CHANNEL_INFO(shorter,elems) This patch does not introduce functional changes. Many thanks to Julia Lawall for providing the semantic patch. Signed-off-by: Guenter Roeck <linux@roeck-us.net>
515 lines
12 KiB
C
515 lines
12 KiB
C
/*
|
|
* max31790.c - Part of lm_sensors, Linux kernel modules for hardware
|
|
* monitoring.
|
|
*
|
|
* (C) 2015 by Il Han <corone.il.han@gmail.com>
|
|
*
|
|
* 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/err.h>
|
|
#include <linux/hwmon.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/init.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
|
|
/* MAX31790 registers */
|
|
#define MAX31790_REG_GLOBAL_CONFIG 0x00
|
|
#define MAX31790_REG_FAN_CONFIG(ch) (0x02 + (ch))
|
|
#define MAX31790_REG_FAN_DYNAMICS(ch) (0x08 + (ch))
|
|
#define MAX31790_REG_FAN_FAULT_STATUS2 0x10
|
|
#define MAX31790_REG_FAN_FAULT_STATUS1 0x11
|
|
#define MAX31790_REG_TACH_COUNT(ch) (0x18 + (ch) * 2)
|
|
#define MAX31790_REG_PWM_DUTY_CYCLE(ch) (0x30 + (ch) * 2)
|
|
#define MAX31790_REG_PWMOUT(ch) (0x40 + (ch) * 2)
|
|
#define MAX31790_REG_TARGET_COUNT(ch) (0x50 + (ch) * 2)
|
|
|
|
/* Fan Config register bits */
|
|
#define MAX31790_FAN_CFG_RPM_MODE 0x80
|
|
#define MAX31790_FAN_CFG_TACH_INPUT_EN 0x08
|
|
#define MAX31790_FAN_CFG_TACH_INPUT 0x01
|
|
|
|
/* Fan Dynamics register bits */
|
|
#define MAX31790_FAN_DYN_SR_SHIFT 5
|
|
#define MAX31790_FAN_DYN_SR_MASK 0xE0
|
|
#define SR_FROM_REG(reg) (((reg) & MAX31790_FAN_DYN_SR_MASK) \
|
|
>> MAX31790_FAN_DYN_SR_SHIFT)
|
|
|
|
#define FAN_RPM_MIN 120
|
|
#define FAN_RPM_MAX 7864320
|
|
|
|
#define RPM_FROM_REG(reg, sr) (((reg) >> 4) ? \
|
|
((60 * (sr) * 8192) / ((reg) >> 4)) : \
|
|
FAN_RPM_MAX)
|
|
#define RPM_TO_REG(rpm, sr) ((60 * (sr) * 8192) / ((rpm) * 2))
|
|
|
|
#define NR_CHANNEL 6
|
|
|
|
/*
|
|
* Client data (each client gets its own)
|
|
*/
|
|
struct max31790_data {
|
|
struct i2c_client *client;
|
|
struct mutex update_lock;
|
|
bool valid; /* zero until following fields are valid */
|
|
unsigned long last_updated; /* in jiffies */
|
|
|
|
/* register values */
|
|
u8 fan_config[NR_CHANNEL];
|
|
u8 fan_dynamics[NR_CHANNEL];
|
|
u16 fault_status;
|
|
u16 tach[NR_CHANNEL * 2];
|
|
u16 pwm[NR_CHANNEL];
|
|
u16 target_count[NR_CHANNEL];
|
|
};
|
|
|
|
static struct max31790_data *max31790_update_device(struct device *dev)
|
|
{
|
|
struct max31790_data *data = dev_get_drvdata(dev);
|
|
struct i2c_client *client = data->client;
|
|
struct max31790_data *ret = data;
|
|
int i;
|
|
int rv;
|
|
|
|
mutex_lock(&data->update_lock);
|
|
|
|
if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
|
|
rv = i2c_smbus_read_byte_data(client,
|
|
MAX31790_REG_FAN_FAULT_STATUS1);
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->fault_status = rv & 0x3F;
|
|
|
|
rv = i2c_smbus_read_byte_data(client,
|
|
MAX31790_REG_FAN_FAULT_STATUS2);
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->fault_status |= (rv & 0x3F) << 6;
|
|
|
|
for (i = 0; i < NR_CHANNEL; i++) {
|
|
rv = i2c_smbus_read_word_swapped(client,
|
|
MAX31790_REG_TACH_COUNT(i));
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->tach[i] = rv;
|
|
|
|
if (data->fan_config[i]
|
|
& MAX31790_FAN_CFG_TACH_INPUT) {
|
|
rv = i2c_smbus_read_word_swapped(client,
|
|
MAX31790_REG_TACH_COUNT(NR_CHANNEL
|
|
+ i));
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->tach[NR_CHANNEL + i] = rv;
|
|
} else {
|
|
rv = i2c_smbus_read_word_swapped(client,
|
|
MAX31790_REG_PWMOUT(i));
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->pwm[i] = rv;
|
|
|
|
rv = i2c_smbus_read_word_swapped(client,
|
|
MAX31790_REG_TARGET_COUNT(i));
|
|
if (rv < 0)
|
|
goto abort;
|
|
data->target_count[i] = rv;
|
|
}
|
|
}
|
|
|
|
data->last_updated = jiffies;
|
|
data->valid = true;
|
|
}
|
|
goto done;
|
|
|
|
abort:
|
|
data->valid = false;
|
|
ret = ERR_PTR(rv);
|
|
|
|
done:
|
|
mutex_unlock(&data->update_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const u8 tach_period[8] = { 1, 2, 4, 8, 16, 32, 32, 32 };
|
|
|
|
static u8 get_tach_period(u8 fan_dynamics)
|
|
{
|
|
return tach_period[SR_FROM_REG(fan_dynamics)];
|
|
}
|
|
|
|
static u8 bits_for_tach_period(int rpm)
|
|
{
|
|
u8 bits;
|
|
|
|
if (rpm < 500)
|
|
bits = 0x0;
|
|
else if (rpm < 1000)
|
|
bits = 0x1;
|
|
else if (rpm < 2000)
|
|
bits = 0x2;
|
|
else if (rpm < 4000)
|
|
bits = 0x3;
|
|
else if (rpm < 8000)
|
|
bits = 0x4;
|
|
else
|
|
bits = 0x5;
|
|
|
|
return bits;
|
|
}
|
|
|
|
static int max31790_read_fan(struct device *dev, u32 attr, int channel,
|
|
long *val)
|
|
{
|
|
struct max31790_data *data = max31790_update_device(dev);
|
|
int sr, rpm;
|
|
|
|
if (IS_ERR(data))
|
|
return PTR_ERR(data);
|
|
|
|
switch (attr) {
|
|
case hwmon_fan_input:
|
|
sr = get_tach_period(data->fan_dynamics[channel]);
|
|
rpm = RPM_FROM_REG(data->tach[channel], sr);
|
|
*val = rpm;
|
|
return 0;
|
|
case hwmon_fan_target:
|
|
sr = get_tach_period(data->fan_dynamics[channel]);
|
|
rpm = RPM_FROM_REG(data->target_count[channel], sr);
|
|
*val = rpm;
|
|
return 0;
|
|
case hwmon_fan_fault:
|
|
*val = !!(data->fault_status & (1 << channel));
|
|
return 0;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int max31790_write_fan(struct device *dev, u32 attr, int channel,
|
|
long val)
|
|
{
|
|
struct max31790_data *data = dev_get_drvdata(dev);
|
|
struct i2c_client *client = data->client;
|
|
int target_count;
|
|
int err = 0;
|
|
u8 bits;
|
|
int sr;
|
|
|
|
mutex_lock(&data->update_lock);
|
|
|
|
switch (attr) {
|
|
case hwmon_fan_target:
|
|
val = clamp_val(val, FAN_RPM_MIN, FAN_RPM_MAX);
|
|
bits = bits_for_tach_period(val);
|
|
data->fan_dynamics[channel] =
|
|
((data->fan_dynamics[channel] &
|
|
~MAX31790_FAN_DYN_SR_MASK) |
|
|
(bits << MAX31790_FAN_DYN_SR_SHIFT));
|
|
err = i2c_smbus_write_byte_data(client,
|
|
MAX31790_REG_FAN_DYNAMICS(channel),
|
|
data->fan_dynamics[channel]);
|
|
if (err < 0)
|
|
break;
|
|
|
|
sr = get_tach_period(data->fan_dynamics[channel]);
|
|
target_count = RPM_TO_REG(val, sr);
|
|
target_count = clamp_val(target_count, 0x1, 0x7FF);
|
|
|
|
data->target_count[channel] = target_count << 5;
|
|
|
|
err = i2c_smbus_write_word_swapped(client,
|
|
MAX31790_REG_TARGET_COUNT(channel),
|
|
data->target_count[channel]);
|
|
break;
|
|
default:
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
mutex_unlock(&data->update_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static umode_t max31790_fan_is_visible(const void *_data, u32 attr, int channel)
|
|
{
|
|
const struct max31790_data *data = _data;
|
|
u8 fan_config = data->fan_config[channel % NR_CHANNEL];
|
|
|
|
switch (attr) {
|
|
case hwmon_fan_input:
|
|
case hwmon_fan_fault:
|
|
if (channel < NR_CHANNEL ||
|
|
(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
|
|
return 0444;
|
|
return 0;
|
|
case hwmon_fan_target:
|
|
if (channel < NR_CHANNEL &&
|
|
!(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
|
|
return 0644;
|
|
return 0;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int max31790_read_pwm(struct device *dev, u32 attr, int channel,
|
|
long *val)
|
|
{
|
|
struct max31790_data *data = max31790_update_device(dev);
|
|
u8 fan_config;
|
|
|
|
if (IS_ERR(data))
|
|
return PTR_ERR(data);
|
|
|
|
fan_config = data->fan_config[channel];
|
|
|
|
switch (attr) {
|
|
case hwmon_pwm_input:
|
|
*val = data->pwm[channel] >> 8;
|
|
return 0;
|
|
case hwmon_pwm_enable:
|
|
if (fan_config & MAX31790_FAN_CFG_RPM_MODE)
|
|
*val = 2;
|
|
else if (fan_config & MAX31790_FAN_CFG_TACH_INPUT_EN)
|
|
*val = 1;
|
|
else
|
|
*val = 0;
|
|
return 0;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int max31790_write_pwm(struct device *dev, u32 attr, int channel,
|
|
long val)
|
|
{
|
|
struct max31790_data *data = dev_get_drvdata(dev);
|
|
struct i2c_client *client = data->client;
|
|
u8 fan_config;
|
|
int err = 0;
|
|
|
|
mutex_lock(&data->update_lock);
|
|
|
|
switch (attr) {
|
|
case hwmon_pwm_input:
|
|
if (val < 0 || val > 255) {
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
data->pwm[channel] = val << 8;
|
|
err = i2c_smbus_write_word_swapped(client,
|
|
MAX31790_REG_PWMOUT(channel),
|
|
data->pwm[channel]);
|
|
break;
|
|
case hwmon_pwm_enable:
|
|
fan_config = data->fan_config[channel];
|
|
if (val == 0) {
|
|
fan_config &= ~(MAX31790_FAN_CFG_TACH_INPUT_EN |
|
|
MAX31790_FAN_CFG_RPM_MODE);
|
|
} else if (val == 1) {
|
|
fan_config = (fan_config |
|
|
MAX31790_FAN_CFG_TACH_INPUT_EN) &
|
|
~MAX31790_FAN_CFG_RPM_MODE;
|
|
} else if (val == 2) {
|
|
fan_config |= MAX31790_FAN_CFG_TACH_INPUT_EN |
|
|
MAX31790_FAN_CFG_RPM_MODE;
|
|
} else {
|
|
err = -EINVAL;
|
|
break;
|
|
}
|
|
data->fan_config[channel] = fan_config;
|
|
err = i2c_smbus_write_byte_data(client,
|
|
MAX31790_REG_FAN_CONFIG(channel),
|
|
fan_config);
|
|
break;
|
|
default:
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
mutex_unlock(&data->update_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static umode_t max31790_pwm_is_visible(const void *_data, u32 attr, int channel)
|
|
{
|
|
const struct max31790_data *data = _data;
|
|
u8 fan_config = data->fan_config[channel];
|
|
|
|
switch (attr) {
|
|
case hwmon_pwm_input:
|
|
case hwmon_pwm_enable:
|
|
if (!(fan_config & MAX31790_FAN_CFG_TACH_INPUT))
|
|
return 0644;
|
|
return 0;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int max31790_read(struct device *dev, enum hwmon_sensor_types type,
|
|
u32 attr, int channel, long *val)
|
|
{
|
|
switch (type) {
|
|
case hwmon_fan:
|
|
return max31790_read_fan(dev, attr, channel, val);
|
|
case hwmon_pwm:
|
|
return max31790_read_pwm(dev, attr, channel, val);
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static int max31790_write(struct device *dev, enum hwmon_sensor_types type,
|
|
u32 attr, int channel, long val)
|
|
{
|
|
switch (type) {
|
|
case hwmon_fan:
|
|
return max31790_write_fan(dev, attr, channel, val);
|
|
case hwmon_pwm:
|
|
return max31790_write_pwm(dev, attr, channel, val);
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
static umode_t max31790_is_visible(const void *data,
|
|
enum hwmon_sensor_types type,
|
|
u32 attr, int channel)
|
|
{
|
|
switch (type) {
|
|
case hwmon_fan:
|
|
return max31790_fan_is_visible(data, attr, channel);
|
|
case hwmon_pwm:
|
|
return max31790_pwm_is_visible(data, attr, channel);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static const struct hwmon_channel_info *max31790_info[] = {
|
|
HWMON_CHANNEL_INFO(fan,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT,
|
|
HWMON_F_INPUT | HWMON_F_FAULT),
|
|
HWMON_CHANNEL_INFO(pwm,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
|
|
HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
|
|
NULL
|
|
};
|
|
|
|
static const struct hwmon_ops max31790_hwmon_ops = {
|
|
.is_visible = max31790_is_visible,
|
|
.read = max31790_read,
|
|
.write = max31790_write,
|
|
};
|
|
|
|
static const struct hwmon_chip_info max31790_chip_info = {
|
|
.ops = &max31790_hwmon_ops,
|
|
.info = max31790_info,
|
|
};
|
|
|
|
static int max31790_init_client(struct i2c_client *client,
|
|
struct max31790_data *data)
|
|
{
|
|
int i, rv;
|
|
|
|
for (i = 0; i < NR_CHANNEL; i++) {
|
|
rv = i2c_smbus_read_byte_data(client,
|
|
MAX31790_REG_FAN_CONFIG(i));
|
|
if (rv < 0)
|
|
return rv;
|
|
data->fan_config[i] = rv;
|
|
|
|
rv = i2c_smbus_read_byte_data(client,
|
|
MAX31790_REG_FAN_DYNAMICS(i));
|
|
if (rv < 0)
|
|
return rv;
|
|
data->fan_dynamics[i] = rv;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max31790_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct i2c_adapter *adapter = client->adapter;
|
|
struct device *dev = &client->dev;
|
|
struct max31790_data *data;
|
|
struct device *hwmon_dev;
|
|
int err;
|
|
|
|
if (!i2c_check_functionality(adapter,
|
|
I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
|
|
return -ENODEV;
|
|
|
|
data = devm_kzalloc(dev, sizeof(struct max31790_data), GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
data->client = client;
|
|
mutex_init(&data->update_lock);
|
|
|
|
/*
|
|
* Initialize the max31790 chip
|
|
*/
|
|
err = max31790_init_client(client, data);
|
|
if (err)
|
|
return err;
|
|
|
|
hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
|
|
data,
|
|
&max31790_chip_info,
|
|
NULL);
|
|
|
|
return PTR_ERR_OR_ZERO(hwmon_dev);
|
|
}
|
|
|
|
static const struct i2c_device_id max31790_id[] = {
|
|
{ "max31790", 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, max31790_id);
|
|
|
|
static struct i2c_driver max31790_driver = {
|
|
.class = I2C_CLASS_HWMON,
|
|
.probe = max31790_probe,
|
|
.driver = {
|
|
.name = "max31790",
|
|
},
|
|
.id_table = max31790_id,
|
|
};
|
|
|
|
module_i2c_driver(max31790_driver);
|
|
|
|
MODULE_AUTHOR("Il Han <corone.il.han@gmail.com>");
|
|
MODULE_DESCRIPTION("MAX31790 sensor driver");
|
|
MODULE_LICENSE("GPL");
|