1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2017 IBM Corp. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/err.h> 10 #include <linux/i2c.h> 11 #include "pmbus.h" 12 13 enum max31785_regs { 14 MFR_REVISION = 0x9b, 15 MFR_FAN_CONFIG = 0xf1, 16 }; 17 18 #define MAX31785 0x3030 19 #define MAX31785A 0x3040 20 #define MAX31785B 0x3061 21 22 #define MFR_FAN_CONFIG_DUAL_TACH BIT(12) 23 24 #define MAX31785_NR_PAGES 23 25 #define MAX31785_NR_FAN_PAGES 6 26 27 static int max31785_read_byte_data(struct i2c_client *client, int page, 28 int reg) 29 { 30 if (page < MAX31785_NR_PAGES) 31 return -ENODATA; 32 33 switch (reg) { 34 case PMBUS_VOUT_MODE: 35 return -ENOTSUPP; 36 case PMBUS_FAN_CONFIG_12: 37 return pmbus_read_byte_data(client, page - MAX31785_NR_PAGES, 38 reg); 39 } 40 41 return -ENODATA; 42 } 43 44 static int max31785_write_byte(struct i2c_client *client, int page, u8 value) 45 { 46 if (page < MAX31785_NR_PAGES) 47 return -ENODATA; 48 49 return -ENOTSUPP; 50 } 51 52 static int max31785_read_long_data(struct i2c_client *client, int page, 53 int reg, u32 *data) 54 { 55 unsigned char cmdbuf[1]; 56 unsigned char rspbuf[4]; 57 int rc; 58 59 struct i2c_msg msg[2] = { 60 { 61 .addr = client->addr, 62 .flags = 0, 63 .len = sizeof(cmdbuf), 64 .buf = cmdbuf, 65 }, 66 { 67 .addr = client->addr, 68 .flags = I2C_M_RD, 69 .len = sizeof(rspbuf), 70 .buf = rspbuf, 71 }, 72 }; 73 74 cmdbuf[0] = reg; 75 76 rc = pmbus_set_page(client, page, 0xff); 77 if (rc < 0) 78 return rc; 79 80 rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); 81 if (rc < 0) 82 return rc; 83 84 *data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) | 85 (rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8)); 86 87 return rc; 88 } 89 90 static int max31785_get_pwm(struct i2c_client *client, int page) 91 { 92 int rv; 93 94 rv = pmbus_get_fan_rate_device(client, page, 0, percent); 95 if (rv < 0) 96 return rv; 97 else if (rv >= 0x8000) 98 return 0; 99 else if (rv >= 0x2711) 100 return 0x2710; 101 102 return rv; 103 } 104 105 static int max31785_get_pwm_mode(struct i2c_client *client, int page) 106 { 107 int config; 108 int command; 109 110 config = pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12); 111 if (config < 0) 112 return config; 113 114 command = pmbus_read_word_data(client, page, 0xff, PMBUS_FAN_COMMAND_1); 115 if (command < 0) 116 return command; 117 118 if (config & PB_FAN_1_RPM) 119 return (command >= 0x8000) ? 3 : 2; 120 121 if (command >= 0x8000) 122 return 3; 123 else if (command >= 0x2711) 124 return 0; 125 126 return 1; 127 } 128 129 static int max31785_read_word_data(struct i2c_client *client, int page, 130 int phase, int reg) 131 { 132 u32 val; 133 int rv; 134 135 switch (reg) { 136 case PMBUS_READ_FAN_SPEED_1: 137 if (page < MAX31785_NR_PAGES) 138 return -ENODATA; 139 140 rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES, 141 reg, &val); 142 if (rv < 0) 143 return rv; 144 145 rv = (val >> 16) & 0xffff; 146 break; 147 case PMBUS_FAN_COMMAND_1: 148 /* 149 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to 150 * expose fan control registers. 151 * 152 * Don't expose fan_target attribute for virtual pages. 153 */ 154 rv = (page >= MAX31785_NR_PAGES) ? -ENOTSUPP : -ENODATA; 155 break; 156 case PMBUS_VIRT_PWM_1: 157 rv = max31785_get_pwm(client, page); 158 break; 159 case PMBUS_VIRT_PWM_ENABLE_1: 160 rv = max31785_get_pwm_mode(client, page); 161 break; 162 default: 163 rv = -ENODATA; 164 break; 165 } 166 167 return rv; 168 } 169 170 static inline u32 max31785_scale_pwm(u32 sensor_val) 171 { 172 /* 173 * The datasheet describes the accepted value range for manual PWM as 174 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in 175 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND 176 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The 177 * important observation here is that 0x2710 == 10000 == 100 * 100. 178 * 179 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the 180 * sysfs interface into the required hardware resolution, but it does 181 * not yet yield a value that we can write to the device (this initial 182 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below 183 * translates the parameter value into the percentage units required by 184 * PMBus, and then we scale back by 255 as required by the hwmon pwmX 185 * interface to yield the percentage value at the appropriate 186 * resolution for hardware. 187 */ 188 return (sensor_val * 100) / 255; 189 } 190 191 static int max31785_pwm_enable(struct i2c_client *client, int page, 192 u16 word) 193 { 194 int config = 0; 195 int rate; 196 197 switch (word) { 198 case 0: 199 rate = 0x7fff; 200 break; 201 case 1: 202 rate = pmbus_get_fan_rate_cached(client, page, 0, percent); 203 if (rate < 0) 204 return rate; 205 rate = max31785_scale_pwm(rate); 206 break; 207 case 2: 208 config = PB_FAN_1_RPM; 209 rate = pmbus_get_fan_rate_cached(client, page, 0, rpm); 210 if (rate < 0) 211 return rate; 212 break; 213 case 3: 214 rate = 0xffff; 215 break; 216 default: 217 return -EINVAL; 218 } 219 220 return pmbus_update_fan(client, page, 0, config, PB_FAN_1_RPM, rate); 221 } 222 223 static int max31785_write_word_data(struct i2c_client *client, int page, 224 int reg, u16 word) 225 { 226 switch (reg) { 227 case PMBUS_VIRT_PWM_1: 228 return pmbus_update_fan(client, page, 0, 0, PB_FAN_1_RPM, 229 max31785_scale_pwm(word)); 230 case PMBUS_VIRT_PWM_ENABLE_1: 231 return max31785_pwm_enable(client, page, word); 232 default: 233 break; 234 } 235 236 return -ENODATA; 237 } 238 239 #define MAX31785_FAN_FUNCS \ 240 (PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12) 241 242 #define MAX31785_TEMP_FUNCS \ 243 (PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP) 244 245 #define MAX31785_VOUT_FUNCS \ 246 (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT) 247 248 static const struct pmbus_driver_info max31785_info = { 249 .pages = MAX31785_NR_PAGES, 250 251 .write_word_data = max31785_write_word_data, 252 .read_byte_data = max31785_read_byte_data, 253 .read_word_data = max31785_read_word_data, 254 .write_byte = max31785_write_byte, 255 256 /* RPM */ 257 .format[PSC_FAN] = direct, 258 .m[PSC_FAN] = 1, 259 .b[PSC_FAN] = 0, 260 .R[PSC_FAN] = 0, 261 /* PWM */ 262 .format[PSC_PWM] = direct, 263 .m[PSC_PWM] = 1, 264 .b[PSC_PWM] = 0, 265 .R[PSC_PWM] = 2, 266 .func[0] = MAX31785_FAN_FUNCS, 267 .func[1] = MAX31785_FAN_FUNCS, 268 .func[2] = MAX31785_FAN_FUNCS, 269 .func[3] = MAX31785_FAN_FUNCS, 270 .func[4] = MAX31785_FAN_FUNCS, 271 .func[5] = MAX31785_FAN_FUNCS, 272 273 .format[PSC_TEMPERATURE] = direct, 274 .m[PSC_TEMPERATURE] = 1, 275 .b[PSC_TEMPERATURE] = 0, 276 .R[PSC_TEMPERATURE] = 2, 277 .func[6] = MAX31785_TEMP_FUNCS, 278 .func[7] = MAX31785_TEMP_FUNCS, 279 .func[8] = MAX31785_TEMP_FUNCS, 280 .func[9] = MAX31785_TEMP_FUNCS, 281 .func[10] = MAX31785_TEMP_FUNCS, 282 .func[11] = MAX31785_TEMP_FUNCS, 283 .func[12] = MAX31785_TEMP_FUNCS, 284 .func[13] = MAX31785_TEMP_FUNCS, 285 .func[14] = MAX31785_TEMP_FUNCS, 286 .func[15] = MAX31785_TEMP_FUNCS, 287 .func[16] = MAX31785_TEMP_FUNCS, 288 289 .format[PSC_VOLTAGE_OUT] = direct, 290 .m[PSC_VOLTAGE_OUT] = 1, 291 .b[PSC_VOLTAGE_OUT] = 0, 292 .R[PSC_VOLTAGE_OUT] = 0, 293 .func[17] = MAX31785_VOUT_FUNCS, 294 .func[18] = MAX31785_VOUT_FUNCS, 295 .func[19] = MAX31785_VOUT_FUNCS, 296 .func[20] = MAX31785_VOUT_FUNCS, 297 .func[21] = MAX31785_VOUT_FUNCS, 298 .func[22] = MAX31785_VOUT_FUNCS, 299 }; 300 301 static int max31785_configure_dual_tach(struct i2c_client *client, 302 struct pmbus_driver_info *info) 303 { 304 int ret; 305 int i; 306 307 for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) { 308 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); 309 if (ret < 0) 310 return ret; 311 312 ret = i2c_smbus_read_word_data(client, MFR_FAN_CONFIG); 313 if (ret < 0) 314 return ret; 315 316 if (ret & MFR_FAN_CONFIG_DUAL_TACH) { 317 int virtual = MAX31785_NR_PAGES + i; 318 319 info->pages = virtual + 1; 320 info->func[virtual] |= PMBUS_HAVE_FAN12; 321 info->func[virtual] |= PMBUS_PAGE_VIRTUAL; 322 } 323 } 324 325 return 0; 326 } 327 328 static int max31785_probe(struct i2c_client *client) 329 { 330 struct device *dev = &client->dev; 331 struct pmbus_driver_info *info; 332 bool dual_tach = false; 333 int ret; 334 335 if (!i2c_check_functionality(client->adapter, 336 I2C_FUNC_SMBUS_BYTE_DATA | 337 I2C_FUNC_SMBUS_WORD_DATA)) 338 return -ENODEV; 339 340 info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL); 341 if (!info) 342 return -ENOMEM; 343 344 *info = max31785_info; 345 346 ret = i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255); 347 if (ret < 0) 348 return ret; 349 350 ret = i2c_smbus_read_word_data(client, MFR_REVISION); 351 if (ret < 0) 352 return ret; 353 354 if (ret == MAX31785A || ret == MAX31785B) { 355 dual_tach = true; 356 } else if (ret == MAX31785) { 357 if (!strcmp("max31785a", client->name) || 358 !strcmp("max31785b", client->name)) 359 dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n"); 360 } else { 361 dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret); 362 return -ENODEV; 363 } 364 365 if (dual_tach) { 366 ret = max31785_configure_dual_tach(client, info); 367 if (ret < 0) 368 return ret; 369 } 370 371 return pmbus_do_probe(client, info); 372 } 373 374 static const struct i2c_device_id max31785_id[] = { 375 { "max31785", 0 }, 376 { "max31785a", 0 }, 377 { "max31785b", 0 }, 378 { }, 379 }; 380 381 MODULE_DEVICE_TABLE(i2c, max31785_id); 382 383 static const struct of_device_id max31785_of_match[] = { 384 { .compatible = "maxim,max31785" }, 385 { .compatible = "maxim,max31785a" }, 386 { .compatible = "maxim,max31785b" }, 387 { }, 388 }; 389 390 MODULE_DEVICE_TABLE(of, max31785_of_match); 391 392 static struct i2c_driver max31785_driver = { 393 .driver = { 394 .name = "max31785", 395 .of_match_table = max31785_of_match, 396 }, 397 .probe = max31785_probe, 398 .id_table = max31785_id, 399 }; 400 401 module_i2c_driver(max31785_driver); 402 403 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>"); 404 MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785"); 405 MODULE_LICENSE("GPL"); 406 MODULE_IMPORT_NS(PMBUS); 407