553 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Copyright (C) 2017 IBM Corp.4 */5 6#include <linux/delay.h>7#include <linux/kernel.h>8#include <linux/module.h>9#include <linux/init.h>10#include <linux/err.h>11#include <linux/i2c.h>12#include "pmbus.h"13 14enum max31785_regs {15 MFR_REVISION = 0x9b,16 MFR_FAN_CONFIG = 0xf1,17};18 19#define MAX31785 0x303020#define MAX31785A 0x304021#define MAX31785B 0x306122 23#define MFR_FAN_CONFIG_DUAL_TACH BIT(12)24 25#define MAX31785_NR_PAGES 2326#define MAX31785_NR_FAN_PAGES 627#define MAX31785_WAIT_DELAY_US 25028 29struct max31785_data {30 ktime_t access; /* Chip access time */31 struct pmbus_driver_info info;32};33 34#define to_max31785_data(x) container_of(x, struct max31785_data, info)35 36/*37 * MAX31785 Driver Workaround38 *39 * The MAX31785 fan controller occasionally exhibits communication issues.40 * These issues are not indicated by the device itself, except for occasional41 * NACK responses during master transactions. No error bits are set in STATUS_BYTE.42 *43 * To address this, we introduce a delay of 250us between consecutive accesses44 * to the fan controller. This delay helps mitigate communication problems by45 * allowing sufficient time between accesses.46 */47static inline void max31785_wait(const struct max31785_data *data)48{49 s64 delta = ktime_us_delta(ktime_get(), data->access);50 51 if (delta < MAX31785_WAIT_DELAY_US)52 usleep_range(MAX31785_WAIT_DELAY_US - delta,53 MAX31785_WAIT_DELAY_US);54}55 56static int max31785_i2c_write_byte_data(struct i2c_client *client,57 struct max31785_data *driver_data,58 int command, u16 data)59{60 int rc;61 62 max31785_wait(driver_data);63 rc = i2c_smbus_write_byte_data(client, command, data);64 driver_data->access = ktime_get();65 return rc;66}67 68static int max31785_i2c_read_word_data(struct i2c_client *client,69 struct max31785_data *driver_data,70 int command)71{72 int rc;73 74 max31785_wait(driver_data);75 rc = i2c_smbus_read_word_data(client, command);76 driver_data->access = ktime_get();77 return rc;78}79 80static int _max31785_read_byte_data(struct i2c_client *client,81 struct max31785_data *driver_data,82 int page, int command)83{84 int rc;85 86 max31785_wait(driver_data);87 rc = pmbus_read_byte_data(client, page, command);88 driver_data->access = ktime_get();89 return rc;90}91 92static int _max31785_write_byte_data(struct i2c_client *client,93 struct max31785_data *driver_data,94 int page, int command, u16 data)95{96 int rc;97 98 max31785_wait(driver_data);99 rc = pmbus_write_byte_data(client, page, command, data);100 driver_data->access = ktime_get();101 return rc;102}103 104static int _max31785_read_word_data(struct i2c_client *client,105 struct max31785_data *driver_data,106 int page, int phase, int command)107{108 int rc;109 110 max31785_wait(driver_data);111 rc = pmbus_read_word_data(client, page, phase, command);112 driver_data->access = ktime_get();113 return rc;114}115 116static int _max31785_write_word_data(struct i2c_client *client,117 struct max31785_data *driver_data,118 int page, int command, u16 data)119{120 int rc;121 122 max31785_wait(driver_data);123 rc = pmbus_write_word_data(client, page, command, data);124 driver_data->access = ktime_get();125 return rc;126}127 128static int max31785_read_byte_data(struct i2c_client *client, int page, int reg)129{130 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);131 struct max31785_data *driver_data = to_max31785_data(info);132 133 switch (reg) {134 case PMBUS_VOUT_MODE:135 return -ENOTSUPP;136 case PMBUS_FAN_CONFIG_12:137 return _max31785_read_byte_data(client, driver_data,138 page - MAX31785_NR_PAGES,139 reg);140 }141 142 return -ENODATA;143}144 145static int max31785_write_byte(struct i2c_client *client, int page, u8 value)146{147 if (page < MAX31785_NR_PAGES)148 return -ENODATA;149 150 return -ENOTSUPP;151}152 153static int max31785_read_long_data(struct i2c_client *client, int page,154 int reg, u32 *data)155{156 unsigned char cmdbuf[1];157 unsigned char rspbuf[4];158 int rc;159 160 struct i2c_msg msg[2] = {161 {162 .addr = client->addr,163 .flags = 0,164 .len = sizeof(cmdbuf),165 .buf = cmdbuf,166 },167 {168 .addr = client->addr,169 .flags = I2C_M_RD,170 .len = sizeof(rspbuf),171 .buf = rspbuf,172 },173 };174 175 cmdbuf[0] = reg;176 177 rc = pmbus_set_page(client, page, 0xff);178 if (rc < 0)179 return rc;180 181 rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));182 if (rc < 0)183 return rc;184 185 *data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) |186 (rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8));187 188 return rc;189}190 191static int max31785_get_pwm(struct i2c_client *client, int page)192{193 int rv;194 195 rv = pmbus_get_fan_rate_device(client, page, 0, percent);196 if (rv < 0)197 return rv;198 else if (rv >= 0x8000)199 return 0;200 else if (rv >= 0x2711)201 return 0x2710;202 203 return rv;204}205 206static int max31785_get_pwm_mode(struct i2c_client *client,207 struct max31785_data *driver_data, int page)208{209 int config;210 int command;211 212 config = _max31785_read_byte_data(client, driver_data, page,213 PMBUS_FAN_CONFIG_12);214 if (config < 0)215 return config;216 217 command = _max31785_read_word_data(client, driver_data, page, 0xff,218 PMBUS_FAN_COMMAND_1);219 if (command < 0)220 return command;221 222 if (config & PB_FAN_1_RPM)223 return (command >= 0x8000) ? 3 : 2;224 225 if (command >= 0x8000)226 return 3;227 else if (command >= 0x2711)228 return 0;229 230 return 1;231}232 233static int max31785_read_word_data(struct i2c_client *client, int page,234 int phase, int reg)235{236 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);237 struct max31785_data *driver_data = to_max31785_data(info);238 u32 val;239 int rv;240 241 switch (reg) {242 case PMBUS_READ_FAN_SPEED_1:243 if (page < MAX31785_NR_PAGES)244 return -ENODATA;245 246 rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES,247 reg, &val);248 if (rv < 0)249 return rv;250 251 rv = (val >> 16) & 0xffff;252 break;253 case PMBUS_FAN_COMMAND_1:254 /*255 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to256 * expose fan control registers.257 *258 * Don't expose fan_target attribute for virtual pages.259 */260 rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA;261 break;262 case PMBUS_VIRT_PWM_1:263 rv = max31785_get_pwm(client, page);264 break;265 case PMBUS_VIRT_PWM_ENABLE_1:266 rv = max31785_get_pwm_mode(client, driver_data, page);267 break;268 default:269 rv = -ENODATA;270 break;271 }272 273 return rv;274}275 276static inline u32 max31785_scale_pwm(u32 sensor_val)277{278 /*279 * The datasheet describes the accepted value range for manual PWM as280 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in281 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND282 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The283 * important observation here is that 0x2710 == 10000 == 100 * 100.284 *285 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the286 * sysfs interface into the required hardware resolution, but it does287 * not yet yield a value that we can write to the device (this initial288 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below289 * translates the parameter value into the percentage units required by290 * PMBus, and then we scale back by 255 as required by the hwmon pwmX291 * interface to yield the percentage value at the appropriate292 * resolution for hardware.293 */294 return (sensor_val * 100) / 255;295}296 297static int max31785_update_fan(struct i2c_client *client,298 struct max31785_data *driver_data, int page,299 u8 config, u8 mask, u16 command)300{301 int from, rv;302 u8 to;303 304 from = _max31785_read_byte_data(client, driver_data, page,305 PMBUS_FAN_CONFIG_12);306 if (from < 0)307 return from;308 309 to = (from & ~mask) | (config & mask);310 311 if (to != from) {312 rv = _max31785_write_byte_data(client, driver_data, page,313 PMBUS_FAN_CONFIG_12, to);314 if (rv < 0)315 return rv;316 }317 318 rv = _max31785_write_word_data(client, driver_data, page,319 PMBUS_FAN_COMMAND_1, command);320 321 return rv;322}323 324static int max31785_pwm_enable(struct i2c_client *client,325 struct max31785_data *driver_data, int page,326 u16 word)327{328 int config = 0;329 int rate;330 331 switch (word) {332 case 0:333 rate = 0x7fff;334 break;335 case 1:336 rate = pmbus_get_fan_rate_cached(client, page, 0, percent);337 if (rate < 0)338 return rate;339 rate = max31785_scale_pwm(rate);340 break;341 case 2:342 config = PB_FAN_1_RPM;343 rate = pmbus_get_fan_rate_cached(client, page, 0, rpm);344 if (rate < 0)345 return rate;346 break;347 case 3:348 rate = 0xffff;349 break;350 default:351 return -EINVAL;352 }353 354 return max31785_update_fan(client, driver_data, page, config,355 PB_FAN_1_RPM, rate);356}357 358static int max31785_write_word_data(struct i2c_client *client, int page,359 int reg, u16 word)360{361 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);362 struct max31785_data *driver_data = to_max31785_data(info);363 364 switch (reg) {365 case PMBUS_VIRT_PWM_1:366 return max31785_update_fan(client, driver_data, page, 0,367 PB_FAN_1_RPM,368 max31785_scale_pwm(word));369 case PMBUS_VIRT_PWM_ENABLE_1:370 return max31785_pwm_enable(client, driver_data, page, word);371 default:372 break;373 }374 375 return -ENODATA;376}377 378#define MAX31785_FAN_FUNCS \379 (PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12)380 381#define MAX31785_TEMP_FUNCS \382 (PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP)383 384#define MAX31785_VOUT_FUNCS \385 (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT)386 387static const struct pmbus_driver_info max31785_info = {388 .pages = MAX31785_NR_PAGES,389 390 .write_word_data = max31785_write_word_data,391 .read_byte_data = max31785_read_byte_data,392 .read_word_data = max31785_read_word_data,393 .write_byte = max31785_write_byte,394 395 /* RPM */396 .format[PSC_FAN] = direct,397 .m[PSC_FAN] = 1,398 .b[PSC_FAN] = 0,399 .R[PSC_FAN] = 0,400 /* PWM */401 .format[PSC_PWM] = direct,402 .m[PSC_PWM] = 1,403 .b[PSC_PWM] = 0,404 .R[PSC_PWM] = 2,405 .func[0] = MAX31785_FAN_FUNCS,406 .func[1] = MAX31785_FAN_FUNCS,407 .func[2] = MAX31785_FAN_FUNCS,408 .func[3] = MAX31785_FAN_FUNCS,409 .func[4] = MAX31785_FAN_FUNCS,410 .func[5] = MAX31785_FAN_FUNCS,411 412 .format[PSC_TEMPERATURE] = direct,413 .m[PSC_TEMPERATURE] = 1,414 .b[PSC_TEMPERATURE] = 0,415 .R[PSC_TEMPERATURE] = 2,416 .func[6] = MAX31785_TEMP_FUNCS,417 .func[7] = MAX31785_TEMP_FUNCS,418 .func[8] = MAX31785_TEMP_FUNCS,419 .func[9] = MAX31785_TEMP_FUNCS,420 .func[10] = MAX31785_TEMP_FUNCS,421 .func[11] = MAX31785_TEMP_FUNCS,422 .func[12] = MAX31785_TEMP_FUNCS,423 .func[13] = MAX31785_TEMP_FUNCS,424 .func[14] = MAX31785_TEMP_FUNCS,425 .func[15] = MAX31785_TEMP_FUNCS,426 .func[16] = MAX31785_TEMP_FUNCS,427 428 .format[PSC_VOLTAGE_OUT] = direct,429 .m[PSC_VOLTAGE_OUT] = 1,430 .b[PSC_VOLTAGE_OUT] = 0,431 .R[PSC_VOLTAGE_OUT] = 0,432 .func[17] = MAX31785_VOUT_FUNCS,433 .func[18] = MAX31785_VOUT_FUNCS,434 .func[19] = MAX31785_VOUT_FUNCS,435 .func[20] = MAX31785_VOUT_FUNCS,436 .func[21] = MAX31785_VOUT_FUNCS,437 .func[22] = MAX31785_VOUT_FUNCS,438};439 440static int max31785_configure_dual_tach(struct i2c_client *client,441 struct pmbus_driver_info *info)442{443 int ret;444 int i;445 struct max31785_data *driver_data = to_max31785_data(info);446 447 for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) {448 ret = max31785_i2c_write_byte_data(client, driver_data,449 PMBUS_PAGE, i);450 if (ret < 0)451 return ret;452 453 ret = max31785_i2c_read_word_data(client, driver_data,454 MFR_FAN_CONFIG);455 if (ret < 0)456 return ret;457 458 if (ret & MFR_FAN_CONFIG_DUAL_TACH) {459 int virtual = MAX31785_NR_PAGES + i;460 461 info->pages = virtual + 1;462 info->func[virtual] |= PMBUS_HAVE_FAN12;463 info->func[virtual] |= PMBUS_PAGE_VIRTUAL;464 }465 }466 467 return 0;468}469 470static int max31785_probe(struct i2c_client *client)471{472 struct device *dev = &client->dev;473 struct pmbus_driver_info *info;474 struct max31785_data *driver_data;475 bool dual_tach = false;476 int ret;477 478 if (!i2c_check_functionality(client->adapter,479 I2C_FUNC_SMBUS_BYTE_DATA |480 I2C_FUNC_SMBUS_WORD_DATA))481 return -ENODEV;482 483 driver_data = devm_kzalloc(dev, sizeof(struct max31785_data), GFP_KERNEL);484 if (!driver_data)485 return -ENOMEM;486 487 info = &driver_data->info;488 driver_data->access = ktime_get();489 *info = max31785_info;490 491 ret = max31785_i2c_write_byte_data(client, driver_data,492 PMBUS_PAGE, 255);493 if (ret < 0)494 return ret;495 496 ret = i2c_smbus_read_word_data(client, MFR_REVISION);497 if (ret < 0)498 return ret;499 500 if (ret == MAX31785A || ret == MAX31785B) {501 dual_tach = true;502 } else if (ret == MAX31785) {503 if (!strcmp("max31785a", client->name) ||504 !strcmp("max31785b", client->name))505 dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n");506 } else {507 dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret);508 return -ENODEV;509 }510 511 if (dual_tach) {512 ret = max31785_configure_dual_tach(client, info);513 if (ret < 0)514 return ret;515 }516 517 return pmbus_do_probe(client, info);518}519 520static const struct i2c_device_id max31785_id[] = {521 { "max31785" },522 { "max31785a" },523 { "max31785b" },524 { },525};526 527MODULE_DEVICE_TABLE(i2c, max31785_id);528 529static const struct of_device_id max31785_of_match[] = {530 { .compatible = "maxim,max31785" },531 { .compatible = "maxim,max31785a" },532 { .compatible = "maxim,max31785b" },533 { },534};535 536MODULE_DEVICE_TABLE(of, max31785_of_match);537 538static struct i2c_driver max31785_driver = {539 .driver = {540 .name = "max31785",541 .of_match_table = max31785_of_match,542 },543 .probe = max31785_probe,544 .id_table = max31785_id,545};546 547module_i2c_driver(max31785_driver);548 549MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");550MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785");551MODULE_LICENSE("GPL");552MODULE_IMPORT_NS(PMBUS);553