1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 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 14 enum max31785_regs { 15 MFR_REVISION = 0x9b, 16 MFR_FAN_CONFIG = 0xf1, 17 }; 18 19 #define MAX31785 0x3030 20 #define MAX31785A 0x3040 21 #define MAX31785B 0x3061 22 23 #define MFR_FAN_CONFIG_DUAL_TACH BIT(12) 24 25 #define MAX31785_NR_PAGES 23 26 #define MAX31785_NR_FAN_PAGES 6 27 #define MAX31785_WAIT_DELAY_US 250 28 29 struct 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 Workaround 38 * 39 * The MAX31785 fan controller occasionally exhibits communication issues. 40 * These issues are not indicated by the device itself, except for occasional 41 * 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 accesses 44 * to the fan controller. This delay helps mitigate communication problems by 45 * allowing sufficient time between accesses. 46 */ 47 static 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 56 static 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 68 static 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 80 static 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 92 static 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 104 static 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 116 static 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 128 static 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 145 static 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 153 static 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 191 static 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 206 static 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 233 static 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 to 256 * 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 276 static inline u32 max31785_scale_pwm(u32 sensor_val) 277 { 278 /* 279 * The datasheet describes the accepted value range for manual PWM as 280 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in 281 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND 282 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The 283 * important observation here is that 0x2710 == 10000 == 100 * 100. 284 * 285 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the 286 * sysfs interface into the required hardware resolution, but it does 287 * not yet yield a value that we can write to the device (this initial 288 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below 289 * translates the parameter value into the percentage units required by 290 * PMBus, and then we scale back by 255 as required by the hwmon pwmX 291 * interface to yield the percentage value at the appropriate 292 * resolution for hardware. 293 */ 294 return (sensor_val * 100) / 255; 295 } 296 297 static 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 324 static 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 358 static 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 387 static 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 440 static 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 470 static 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 520 static const struct i2c_device_id max31785_id[] = { 521 { "max31785", 0 }, 522 { "max31785a", 0 }, 523 { "max31785b", 0 }, 524 { }, 525 }; 526 527 MODULE_DEVICE_TABLE(i2c, max31785_id); 528 529 static const struct of_device_id max31785_of_match[] = { 530 { .compatible = "maxim,max31785" }, 531 { .compatible = "maxim,max31785a" }, 532 { .compatible = "maxim,max31785b" }, 533 { }, 534 }; 535 536 MODULE_DEVICE_TABLE(of, max31785_of_match); 537 538 static 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 547 module_i2c_driver(max31785_driver); 548 549 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>"); 550 MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785"); 551 MODULE_LICENSE("GPL"); 552 MODULE_IMPORT_NS(PMBUS); 553