hwmon/pmbus/max31785.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2017 IBM Corp.
0004  */
0005
0006 #include <linux/kernel.h>
0007 #include <linux/module.h>
0008 #include <linux/init.h>
0009 #include <linux/err.h>
0010 #include <linux/i2c.h>
0011 #include "pmbus.h"
0012
0013 enum max31785_regs {
0014     MFR_REVISION        = 0x9b,
0015     MFR_FAN_CONFIG      = 0xf1,
0016 };
0017
0018 #define MAX31785            0x3030
0019 #define MAX31785A           0x3040
0020 #define MAX31785B           0x3061
0021
0022 #define MFR_FAN_CONFIG_DUAL_TACH    BIT(12)
0023
0024 #define MAX31785_NR_PAGES       23
0025 #define MAX31785_NR_FAN_PAGES       6
0026
0027 static int max31785_read_byte_data(struct i2c_client *client, int page,
0028                    int reg)
0029 {
0030     if (page < MAX31785_NR_PAGES)
0031         return -ENODATA;
0032
0033     switch (reg) {
0034     case PMBUS_VOUT_MODE:
0035         return -ENOTSUPP;
0036     case PMBUS_FAN_CONFIG_12:
0037         return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES,
0038                         reg);
0039     }
0040
0041     return -ENODATA;
0042 }
0043
0044 static int max31785_write_byte(struct i2c_client *client, int page, u8 value)
0045 {
0046     if (page < MAX31785_NR_PAGES)
0047         return -ENODATA;
0048
0049     return -ENOTSUPP;
0050 }
0051
0052 static int max31785_read_long_data(struct i2c_client *client, int page,
0053                    int reg, u32 *data)
0054 {
0055     unsigned char cmdbuf[1];
0056     unsigned char rspbuf[4];
0057     int rc;
0058
0059     struct i2c_msg msg[2] = {
0060         {
0061             .addr = client->addr,
0062             .flags = 0,
0063             .len = sizeof(cmdbuf),
0064             .buf = cmdbuf,
0065         },
0066         {
0067             .addr = client->addr,
0068             .flags = I2C_M_RD,
0069             .len = sizeof(rspbuf),
0070             .buf = rspbuf,
0071         },
0072     };
0073
0074     cmdbuf[0] = reg;
0075
0076     rc = pmbus_set_page(client, page, 0xff);
0077     if (rc < 0)
0078         return rc;
0079
0080     rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
0081     if (rc < 0)
0082         return rc;
0083
0084     *data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |
0085         (rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));
0086
0087     return rc;
0088 }
0089
0090 static int max31785_get_pwm(struct i2c_client *client, int page)
0091 {
0092     int rv;
0093
0094     rv = pmbus_get_fan_rate_device(client, page, 0, percent);
0095     if (rv < 0)
0096         return rv;
0097     else if (rv >= 0x8000)
0098         return 0;
0099     else if (rv >= 0x2711)
0100         return 0x2710;
0101
0102     return rv;
0103 }
0104
0105 static int max31785_get_pwm_mode(struct i2c_client *client, int page)
0106 {
0107     int config;
0108     int command;
0109
0110     config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12);
0111     if (config < 0)
0112         return config;
0113
0114     command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1);
0115     if (command < 0)
0116         return command;
0117
0118     if (config & PB_FAN_1_RPM)
0119         return (command >= 0x8000) ? 3 : 2;
0120
0121     if (command >= 0x8000)
0122         return 3;
0123     else if (command >= 0x2711)
0124         return 0;
0125
0126     return 1;
0127 }
0128
0129 static int max31785_read_word_data(struct i2c_client *client, int page,
0130                    int phase, int reg)
0131 {
0132     u32 val;
0133     int rv;
0134
0135     switch (reg) {
0136     case PMBUS_READ_FAN_SPEED_1:
0137         if (page < MAX31785_NR_PAGES)
0138             return -ENODATA;
0139
0140         rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,
0141                          reg, &val);
0142         if (rv < 0)
0143             return rv;
0144
0145         rv = (val >> 16) & 0xffff;
0146         break;
0147     case PMBUS_FAN_COMMAND_1:
0148         /*
0149          * PMBUS_FAN_COMMAND_x is probed to judge whether or not to
0150          * expose fan control registers.
0151          *
0152          * Don't expose fan_target attribute for virtual pages.
0153          */
0154         rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;
0155         break;
0156     case PMBUS_VIRT_PWM_1:
0157         rv = max31785_get_pwm(client, page);
0158         break;
0159     case PMBUS_VIRT_PWM_ENABLE_1:
0160         rv = max31785_get_pwm_mode(client, page);
0161         break;
0162     default:
0163         rv = -ENODATA;
0164         break;
0165     }
0166
0167     return rv;
0168 }
0169
0170 static inline u32 max31785_scale_pwm(u32 sensor_val)
0171 {
0172     /*
0173      * The datasheet describes the accepted value range for manual PWM as
0174      * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in
0175      * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND
0176      * registers and in PWM mode the coefficients are m=1, b=0, R=2. The
0177      * important observation here is that 0x2710 == 10000 == 100 * 100.
0178      *
0179      * R=2 (== 10^2 == 100) accounts for scaling the value provided at the
0180      * sysfs interface into the required hardware resolution, but it does
0181      * not yet yield a value that we can write to the device (this initial
0182      * scaling is handled by pmbus_data2reg()). Multiplying by 100 below
0183      * translates the parameter value into the percentage units required by
0184      * PMBus, and then we scale back by 255 as required by the hwmon pwmX
0185      * interface to yield the percentage value at the appropriate
0186      * resolution for hardware.
0187      */
0188     return (sensor_val * 100) / 255;
0189 }
0190
0191 static int max31785_pwm_enable(struct i2c_client *client, int page,
0192                     u16 word)
0193 {
0194     int config = 0;
0195     int rate;
0196
0197     switch (word) {
0198     case 0:
0199         rate = 0x7fff;
0200         break;
0201     case 1:
0202         rate = pmbus_get_fan_rate_cached(client, page, 0, percent);
0203         if (rate < 0)
0204             return rate;
0205         rate = max31785_scale_pwm(rate);
0206         break;
0207     case 2:
0208         config = PB_FAN_1_RPM;
0209         rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);
0210         if (rate < 0)
0211             return rate;
0212         break;
0213     case 3:
0214         rate = 0xffff;
0215         break;
0216     default:
0217         return -EINVAL;
0218     }
0219
0220     return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate);
0221 }
0222
0223 static int max31785_write_word_data(struct i2c_client *client, int page,
0224                     int reg, u16 word)
0225 {
0226     switch (reg) {
0227     case PMBUS_VIRT_PWM_1:
0228         return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM,
0229                     max31785_scale_pwm(word));
0230     case PMBUS_VIRT_PWM_ENABLE_1:
0231         return max31785_pwm_enable(client, page, word);
0232     default:
0233         break;
0234     }
0235
0236     return -ENODATA;
0237 }
0238
0239 #define MAX31785_FAN_FUNCS \
0240     (PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)
0241
0242 #define MAX31785_TEMP_FUNCS \
0243     (PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)
0244
0245 #define MAX31785_VOUT_FUNCS \
0246     (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)
0247
0248 static const struct pmbus_driver_info max31785_info = {
0249     .pages = MAX31785_NR_PAGES,
0250
0251     .write_word_data = max31785_write_word_data,
0252     .read_byte_data = max31785_read_byte_data,
0253     .read_word_data = max31785_read_word_data,
0254     .write_byte = max31785_write_byte,
0255
0256     /* RPM */
0257     .format[PSC_FAN] = direct,
0258     .m[PSC_FAN] = 1,
0259     .b[PSC_FAN] = 0,
0260     .R[PSC_FAN] = 0,
0261     /* PWM */
0262     .format[PSC_PWM] = direct,
0263     .m[PSC_PWM] = 1,
0264     .b[PSC_PWM] = 0,
0265     .R[PSC_PWM] = 2,
0266     .func[0] = MAX31785_FAN_FUNCS,
0267     .func[1] = MAX31785_FAN_FUNCS,
0268     .func[2] = MAX31785_FAN_FUNCS,
0269     .func[3] = MAX31785_FAN_FUNCS,
0270     .func[4] = MAX31785_FAN_FUNCS,
0271     .func[5] = MAX31785_FAN_FUNCS,
0272
0273     .format[PSC_TEMPERATURE] = direct,
0274     .m[PSC_TEMPERATURE] = 1,
0275     .b[PSC_TEMPERATURE] = 0,
0276     .R[PSC_TEMPERATURE] = 2,
0277     .func[6]  = MAX31785_TEMP_FUNCS,
0278     .func[7]  = MAX31785_TEMP_FUNCS,
0279     .func[8]  = MAX31785_TEMP_FUNCS,
0280     .func[9]  = MAX31785_TEMP_FUNCS,
0281     .func[10] = MAX31785_TEMP_FUNCS,
0282     .func[11] = MAX31785_TEMP_FUNCS,
0283     .func[12] = MAX31785_TEMP_FUNCS,
0284     .func[13] = MAX31785_TEMP_FUNCS,
0285     .func[14] = MAX31785_TEMP_FUNCS,
0286     .func[15] = MAX31785_TEMP_FUNCS,
0287     .func[16] = MAX31785_TEMP_FUNCS,
0288
0289     .format[PSC_VOLTAGE_OUT] = direct,
0290     .m[PSC_VOLTAGE_OUT] = 1,
0291     .b[PSC_VOLTAGE_OUT] = 0,
0292     .R[PSC_VOLTAGE_OUT] = 0,
0293     .func[17] = MAX31785_VOUT_FUNCS,
0294     .func[18] = MAX31785_VOUT_FUNCS,
0295     .func[19] = MAX31785_VOUT_FUNCS,
0296     .func[20] = MAX31785_VOUT_FUNCS,
0297     .func[21] = MAX31785_VOUT_FUNCS,
0298     .func[22] = MAX31785_VOUT_FUNCS,
0299 };
0300
0301 static int max31785_configure_dual_tach(struct i2c_client *client,
0302                     struct pmbus_driver_info *info)
0303 {
0304     int ret;
0305     int i;
0306
0307     for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {
0308         ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i);
0309         if (ret < 0)
0310             return ret;
0311
0312         ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG);
0313         if (ret < 0)
0314             return ret;
0315
0316         if (ret & MFR_FAN_CONFIG_DUAL_TACH) {
0317             int virtual = MAX31785_NR_PAGES + i;
0318
0319             info->pages = virtual + 1;
0320             info->func[virtual] |= PMBUS_HAVE_FAN12;
0321             info->func[virtual] |= PMBUS_PAGE_VIRTUAL;
0322         }
0323     }
0324
0325     return 0;
0326 }
0327
0328 static int max31785_probe(struct i2c_client *client)
0329 {
0330     struct device *dev = &client->dev;
0331     struct pmbus_driver_info *info;
0332     bool dual_tach = false;
0333     int ret;
0334
0335     if (!i2c_check_functionality(client->adapter,
0336                      I2C_FUNC_SMBUS_BYTE_DATA |
0337                      I2C_FUNC_SMBUS_WORD_DATA))
0338         return -ENODEV;
0339
0340     info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
0341     if (!info)
0342         return -ENOMEM;
0343
0344     *info = max31785_info;
0345
0346     ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255);
0347     if (ret < 0)
0348         return ret;
0349
0350     ret = i2c_smbus_read_word_data(client, MFR_REVISION);
0351     if (ret < 0)
0352         return ret;
0353
0354     if (ret == MAX31785A || ret == MAX31785B) {
0355         dual_tach = true;
0356     } else if (ret == MAX31785) {
0357         if (!strcmp("max31785a", client->name) ||
0358             !strcmp("max31785b", client->name))
0359             dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");
0360     } else {
0361         dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);
0362         return -ENODEV;
0363     }
0364
0365     if (dual_tach) {
0366         ret = max31785_configure_dual_tach(client, info);
0367         if (ret < 0)
0368             return ret;
0369     }
0370
0371     return pmbus_do_probe(client, info);
0372 }
0373
0374 static const struct i2c_device_id max31785_id[] = {
0375     { "max31785", 0 },
0376     { "max31785a", 0 },
0377     { "max31785b", 0 },
0378     { },
0379 };
0380
0381 MODULE_DEVICE_TABLE(i2c, max31785_id);
0382
0383 static const struct of_device_id max31785_of_match[] = {
0384     { .compatible = "maxim,max31785" },
0385     { .compatible = "maxim,max31785a" },
0386     { .compatible = "maxim,max31785b" },
0387     { },
0388 };
0389
0390 MODULE_DEVICE_TABLE(of, max31785_of_match);
0391
0392 static struct i2c_driver max31785_driver = {
0393     .driver = {
0394         .name = "max31785",
0395         .of_match_table = max31785_of_match,
0396     },
0397     .probe_new = max31785_probe,
0398     .id_table = max31785_id,
0399 };
0400
0401 module_i2c_driver(max31785_driver);
0402
0403 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
0404 MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");
0405 MODULE_LICENSE("GPL");
0406 MODULE_IMPORT_NS(PMBUS);