mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Matthew Barth](/assets/img/avatar_default.png)
There was an issue in how the tach feedbacks of dual rotor fans were reported during any change in fan speeds with revision "A" of the MAX31785. When the fan speeds would transition to a new target speed, the rotor not wired to the TACH input when TACHSEL = 0 would report a speed of 0 until the new target was reached. This has been fixed, resulting in a revision "B" update where the MFR_REVISION of "B" is 0x3061. Signed-off-by: Matthew Barth <msbarth@linux.ibm.com> Link: https://lore.kernel.org/r/20210201212217.73721-1-msbarth@linux.ibm.com [groeck: Change 'ret' variable type to int] Signed-off-by: Guenter Roeck <linux@roeck-us.net>
405 lines
9.1 KiB
C
405 lines
9.1 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Copyright (C) 2017 IBM Corp.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/err.h>
|
|
#include <linux/i2c.h>
|
|
#include "pmbus.h"
|
|
|
|
enum max31785_regs {
|
|
MFR_REVISION = 0x9b,
|
|
MFR_FAN_CONFIG = 0xf1,
|
|
};
|
|
|
|
#define MAX31785 0x3030
|
|
#define MAX31785A 0x3040
|
|
#define MAX31785B 0x3061
|
|
|
|
#define MFR_FAN_CONFIG_DUAL_TACH BIT(12)
|
|
|
|
#define MAX31785_NR_PAGES 23
|
|
#define MAX31785_NR_FAN_PAGES 6
|
|
|
|
static int max31785_read_byte_data(struct i2c_client *client, int page,
|
|
int reg)
|
|
{
|
|
if (page < MAX31785_NR_PAGES)
|
|
return -ENODATA;
|
|
|
|
switch (reg) {
|
|
case PMBUS_VOUT_MODE:
|
|
return -ENOTSUPP;
|
|
case PMBUS_FAN_CONFIG_12:
|
|
return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES,
|
|
reg);
|
|
}
|
|
|
|
return -ENODATA;
|
|
}
|
|
|
|
static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
|
|
{
|
|
if (page < MAX31785_NR_PAGES)
|
|
return -ENODATA;
|
|
|
|
return -ENOTSUPP;
|
|
}
|
|
|
|
static int max31785_read_long_data(struct i2c_client *client, int page,
|
|
int reg, u32 *data)
|
|
{
|
|
unsigned char cmdbuf[1];
|
|
unsigned char rspbuf[4];
|
|
int rc;
|
|
|
|
struct i2c_msg msg[2] = {
|
|
{
|
|
.addr = client->addr,
|
|
.flags = 0,
|
|
.len = sizeof(cmdbuf),
|
|
.buf = cmdbuf,
|
|
},
|
|
{
|
|
.addr = client->addr,
|
|
.flags = I2C_M_RD,
|
|
.len = sizeof(rspbuf),
|
|
.buf = rspbuf,
|
|
},
|
|
};
|
|
|
|
cmdbuf[0] = reg;
|
|
|
|
rc = pmbus_set_page(client, page, 0xff);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
*data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |
|
|
(rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int max31785_get_pwm(struct i2c_client *client, int page)
|
|
{
|
|
int rv;
|
|
|
|
rv = pmbus_get_fan_rate_device(client, page, 0, percent);
|
|
if (rv < 0)
|
|
return rv;
|
|
else if (rv >= 0x8000)
|
|
return 0;
|
|
else if (rv >= 0x2711)
|
|
return 0x2710;
|
|
|
|
return rv;
|
|
}
|
|
|
|
static int max31785_get_pwm_mode(struct i2c_client *client, int page)
|
|
{
|
|
int config;
|
|
int command;
|
|
|
|
config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12);
|
|
if (config < 0)
|
|
return config;
|
|
|
|
command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1);
|
|
if (command < 0)
|
|
return command;
|
|
|
|
if (config & PB_FAN_1_RPM)
|
|
return (command >= 0x8000) ? 3 : 2;
|
|
|
|
if (command >= 0x8000)
|
|
return 3;
|
|
else if (command >= 0x2711)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int max31785_read_word_data(struct i2c_client *client, int page,
|
|
int phase, int reg)
|
|
{
|
|
u32 val;
|
|
int rv;
|
|
|
|
switch (reg) {
|
|
case PMBUS_READ_FAN_SPEED_1:
|
|
if (page < MAX31785_NR_PAGES)
|
|
return -ENODATA;
|
|
|
|
rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
|
|
reg, &val);
|
|
if (rv < 0)
|
|
return rv;
|
|
|
|
rv = (val >> 16) & 0xffff;
|
|
break;
|
|
case PMBUS_FAN_COMMAND_1:
|
|
/*
|
|
* PMBUS_FAN_COMMAND_x is probed to judge whether or not to
|
|
* expose fan control registers.
|
|
*
|
|
* Don't expose fan_target attribute for virtual pages.
|
|
*/
|
|
rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
|
|
break;
|
|
case PMBUS_VIRT_PWM_1:
|
|
rv = max31785_get_pwm(client, page);
|
|
break;
|
|
case PMBUS_VIRT_PWM_ENABLE_1:
|
|
rv = max31785_get_pwm_mode(client, page);
|
|
break;
|
|
default:
|
|
rv = -ENODATA;
|
|
break;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
static inline u32 max31785_scale_pwm(u32 sensor_val)
|
|
{
|
|
/*
|
|
* The datasheet describes the accepted value range for manual PWM as
|
|
* [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
|
|
* [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
|
|
* registers and in PWM mode the coefficients are m=1, b=0, R=2. The
|
|
* important observation here is that 0x2710 == 10000 == 100 * 100.
|
|
*
|
|
* R=2 (== 10^2 == 100) accounts for scaling the value provided at the
|
|
* sysfs interface into the required hardware resolution, but it does
|
|
* not yet yield a value that we can write to the device (this initial
|
|
* scaling is handled by pmbus_data2reg()). Multiplying by 100 below
|
|
* translates the parameter value into the percentage units required by
|
|
* PMBus, and then we scale back by 255 as required by the hwmon pwmX
|
|
* interface to yield the percentage value at the appropriate
|
|
* resolution for hardware.
|
|
*/
|
|
return (sensor_val * 100) / 255;
|
|
}
|
|
|
|
static int max31785_pwm_enable(struct i2c_client *client, int page,
|
|
u16 word)
|
|
{
|
|
int config = 0;
|
|
int rate;
|
|
|
|
switch (word) {
|
|
case 0:
|
|
rate = 0x7fff;
|
|
break;
|
|
case 1:
|
|
rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
|
|
if (rate < 0)
|
|
return rate;
|
|
rate = max31785_scale_pwm(rate);
|
|
break;
|
|
case 2:
|
|
config = PB_FAN_1_RPM;
|
|
rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
|
|
if (rate < 0)
|
|
return rate;
|
|
break;
|
|
case 3:
|
|
rate = 0xffff;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate);
|
|
}
|
|
|
|
static int max31785_write_word_data(struct i2c_client *client, int page,
|
|
int reg, u16 word)
|
|
{
|
|
switch (reg) {
|
|
case PMBUS_VIRT_PWM_1:
|
|
return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM,
|
|
max31785_scale_pwm(word));
|
|
case PMBUS_VIRT_PWM_ENABLE_1:
|
|
return max31785_pwm_enable(client, page, word);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return -ENODATA;
|
|
}
|
|
|
|
#define MAX31785_FAN_FUNCS \
|
|
(PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)
|
|
|
|
#define MAX31785_TEMP_FUNCS \
|
|
(PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)
|
|
|
|
#define MAX31785_VOUT_FUNCS \
|
|
(PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)
|
|
|
|
static const struct pmbus_driver_info max31785_info = {
|
|
.pages = MAX31785_NR_PAGES,
|
|
|
|
.write_word_data = max31785_write_word_data,
|
|
.read_byte_data = max31785_read_byte_data,
|
|
.read_word_data = max31785_read_word_data,
|
|
.write_byte = max31785_write_byte,
|
|
|
|
/* RPM */
|
|
.format[PSC_FAN] = direct,
|
|
.m[PSC_FAN] = 1,
|
|
.b[PSC_FAN] = 0,
|
|
.R[PSC_FAN] = 0,
|
|
/* PWM */
|
|
.format[PSC_PWM] = direct,
|
|
.m[PSC_PWM] = 1,
|
|
.b[PSC_PWM] = 0,
|
|
.R[PSC_PWM] = 2,
|
|
.func[0] = MAX31785_FAN_FUNCS,
|
|
.func[1] = MAX31785_FAN_FUNCS,
|
|
.func[2] = MAX31785_FAN_FUNCS,
|
|
.func[3] = MAX31785_FAN_FUNCS,
|
|
.func[4] = MAX31785_FAN_FUNCS,
|
|
.func[5] = MAX31785_FAN_FUNCS,
|
|
|
|
.format[PSC_TEMPERATURE] = direct,
|
|
.m[PSC_TEMPERATURE] = 1,
|
|
.b[PSC_TEMPERATURE] = 0,
|
|
.R[PSC_TEMPERATURE] = 2,
|
|
.func[6] = MAX31785_TEMP_FUNCS,
|
|
.func[7] = MAX31785_TEMP_FUNCS,
|
|
.func[8] = MAX31785_TEMP_FUNCS,
|
|
.func[9] = MAX31785_TEMP_FUNCS,
|
|
.func[10] = MAX31785_TEMP_FUNCS,
|
|
.func[11] = MAX31785_TEMP_FUNCS,
|
|
.func[12] = MAX31785_TEMP_FUNCS,
|
|
.func[13] = MAX31785_TEMP_FUNCS,
|
|
.func[14] = MAX31785_TEMP_FUNCS,
|
|
.func[15] = MAX31785_TEMP_FUNCS,
|
|
.func[16] = MAX31785_TEMP_FUNCS,
|
|
|
|
.format[PSC_VOLTAGE_OUT] = direct,
|
|
.m[PSC_VOLTAGE_OUT] = 1,
|
|
.b[PSC_VOLTAGE_OUT] = 0,
|
|
.R[PSC_VOLTAGE_OUT] = 0,
|
|
.func[17] = MAX31785_VOUT_FUNCS,
|
|
.func[18] = MAX31785_VOUT_FUNCS,
|
|
.func[19] = MAX31785_VOUT_FUNCS,
|
|
.func[20] = MAX31785_VOUT_FUNCS,
|
|
.func[21] = MAX31785_VOUT_FUNCS,
|
|
.func[22] = MAX31785_VOUT_FUNCS,
|
|
};
|
|
|
|
static int max31785_configure_dual_tach(struct i2c_client *client,
|
|
struct pmbus_driver_info *info)
|
|
{
|
|
int ret;
|
|
int i;
|
|
|
|
for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
|
|
ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
|
|
int virtual = MAX31785_NR_PAGES + i;
|
|
|
|
info->pages = virtual + 1;
|
|
info->func[virtual] |= PMBUS_HAVE_FAN12;
|
|
info->func[virtual] |= PMBUS_PAGE_VIRTUAL;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max31785_probe(struct i2c_client *client)
|
|
{
|
|
struct device *dev = &client->dev;
|
|
struct pmbus_driver_info *info;
|
|
bool dual_tach = false;
|
|
int ret;
|
|
|
|
if (!i2c_check_functionality(client->adapter,
|
|
I2C_FUNC_SMBUS_BYTE_DATA |
|
|
I2C_FUNC_SMBUS_WORD_DATA))
|
|
return -ENODEV;
|
|
|
|
info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
|
|
if (!info)
|
|
return -ENOMEM;
|
|
|
|
*info = max31785_info;
|
|
|
|
ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = i2c_smbus_read_word_data(client, MFR_REVISION);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
if (ret == MAX31785A || ret == MAX31785B) {
|
|
dual_tach = true;
|
|
} else if (ret == MAX31785) {
|
|
if (!strcmp("max31785a", client->name) ||
|
|
!strcmp("max31785b", client->name))
|
|
dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
|
|
} else {
|
|
dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (dual_tach) {
|
|
ret = max31785_configure_dual_tach(client, info);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
return pmbus_do_probe(client, info);
|
|
}
|
|
|
|
static const struct i2c_device_id max31785_id[] = {
|
|
{ "max31785", 0 },
|
|
{ "max31785a", 0 },
|
|
{ "max31785b", 0 },
|
|
{ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(i2c, max31785_id);
|
|
|
|
static const struct of_device_id max31785_of_match[] = {
|
|
{ .compatible = "maxim,max31785" },
|
|
{ .compatible = "maxim,max31785a" },
|
|
{ .compatible = "maxim,max31785b" },
|
|
{ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, max31785_of_match);
|
|
|
|
static struct i2c_driver max31785_driver = {
|
|
.driver = {
|
|
.name = "max31785",
|
|
.of_match_table = max31785_of_match,
|
|
},
|
|
.probe_new = max31785_probe,
|
|
.id_table = max31785_id,
|
|
};
|
|
|
|
module_i2c_driver(max31785_driver);
|
|
|
|
MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
|
|
MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
|
|
MODULE_LICENSE("GPL");
|