blob: 5d13bbfc8f476d055e13a549f0809a69a604e657 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright (C) 2017 IBM Corp.
*/
#include <linux/delay.h>
#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
#define MAX31785_WAIT_DELAY_US 250
struct max31785_data {
ktime_t access; /* Chip access time */
struct pmbus_driver_info info;
};
#define to_max31785_data(x) container_of(x, struct max31785_data, info)
/*
* MAX31785 Driver Workaround
*
* The MAX31785 fan controller occasionally exhibits communication issues.
* These issues are not indicated by the device itself, except for occasional
* NACK responses during master transactions. No error bits are set in STATUS_BYTE.
*
* To address this, we introduce a delay of 250us between consecutive accesses
* to the fan controller. This delay helps mitigate communication problems by
* allowing sufficient time between accesses.
*/
static inline void max31785_wait(const struct max31785_data *data)
{
s64 delta = ktime_us_delta(ktime_get(), data->access);
if (delta < MAX31785_WAIT_DELAY_US)
usleep_range(MAX31785_WAIT_DELAY_US - delta,
MAX31785_WAIT_DELAY_US);
}
static int max31785_i2c_write_byte_data(struct i2c_client *client,
struct max31785_data *driver_data,
int command, u16 data)
{
int rc;
max31785_wait(driver_data);
rc = i2c_smbus_write_byte_data(client, command, data);
driver_data->access = ktime_get();
return rc;
}
static int max31785_i2c_read_word_data(struct i2c_client *client,
struct max31785_data *driver_data,
int command)
{
int rc;
max31785_wait(driver_data);
rc = i2c_smbus_read_word_data(client, command);
driver_data->access = ktime_get();
return rc;
}
static int _max31785_read_byte_data(struct i2c_client *client,
struct max31785_data *driver_data,
int page, int command)
{
int rc;
max31785_wait(driver_data);
rc = pmbus_read_byte_data(client, page, command);
driver_data->access = ktime_get();
return rc;
}
static int _max31785_write_byte_data(struct i2c_client *client,
struct max31785_data *driver_data,
int page, int command, u16 data)
{
int rc;
max31785_wait(driver_data);
rc = pmbus_write_byte_data(client, page, command, data);
driver_data->access = ktime_get();
return rc;
}
static int _max31785_read_word_data(struct i2c_client *client,
struct max31785_data *driver_data,
int page, int phase, int command)
{
int rc;
max31785_wait(driver_data);
rc = pmbus_read_word_data(client, page, phase, command);
driver_data->access = ktime_get();
return rc;
}
static int _max31785_write_word_data(struct i2c_client *client,
struct max31785_data *driver_data,
int page, int command, u16 data)
{
int rc;
max31785_wait(driver_data);
rc = pmbus_write_word_data(client, page, command, data);
driver_data->access = ktime_get();
return rc;
}
static int max31785_read_byte_data(struct i2c_client *client, int page, int reg)
{
const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
struct max31785_data *driver_data = to_max31785_data(info);
switch (reg) {
case PMBUS_VOUT_MODE:
return -ENOTSUPP;
case PMBUS_FAN_CONFIG_12:
return _max31785_read_byte_data(client, driver_data,
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,
struct max31785_data *driver_data, int page)
{
int config;
int command;
config = _max31785_read_byte_data(client, driver_data, page,
PMBUS_FAN_CONFIG_12);
if (config < 0)
return config;
command = _max31785_read_word_data(client, driver_data, 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)
{
const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
struct max31785_data *driver_data = to_max31785_data(info);
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, driver_data, 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_update_fan(struct i2c_client *client,
struct max31785_data *driver_data, int page,
u8 config, u8 mask, u16 command)
{
int from, rv;
u8 to;
from = _max31785_read_byte_data(client, driver_data, page,
PMBUS_FAN_CONFIG_12);
if (from < 0)
return from;
to = (from & ~mask) | (config & mask);
if (to != from) {
rv = _max31785_write_byte_data(client, driver_data, page,
PMBUS_FAN_CONFIG_12, to);
if (rv < 0)
return rv;
}
rv = _max31785_write_word_data(client, driver_data, page,
PMBUS_FAN_COMMAND_1, command);
return rv;
}
static int max31785_pwm_enable(struct i2c_client *client,
struct max31785_data *driver_data, 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 max31785_update_fan(client, driver_data, page, config,
PB_FAN_1_RPM, rate);
}
static int max31785_write_word_data(struct i2c_client *client, int page,
int reg, u16 word)
{
const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
struct max31785_data *driver_data = to_max31785_data(info);
switch (reg) {
case PMBUS_VIRT_PWM_1:
return max31785_update_fan(client, driver_data, page, 0,
PB_FAN_1_RPM,
max31785_scale_pwm(word));
case PMBUS_VIRT_PWM_ENABLE_1:
return max31785_pwm_enable(client, driver_data, 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;
struct max31785_data *driver_data = to_max31785_data(info);
for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
ret = max31785_i2c_write_byte_data(client, driver_data,
PMBUS_PAGE, i);
if (ret < 0)
return ret;
ret = max31785_i2c_read_word_data(client, driver_data,
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;
struct max31785_data *driver_data;
bool dual_tach = false;
int ret;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_WORD_DATA))
return -ENODEV;
driver_data = devm_kzalloc(dev, sizeof(struct max31785_data), GFP_KERNEL);
if (!driver_data)
return -ENOMEM;
info = &driver_data->info;
driver_data->access = ktime_get();
*info = max31785_info;
ret = max31785_i2c_write_byte_data(client, driver_data,
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 = 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");
MODULE_IMPORT_NS(PMBUS);