1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * tc654.c - Linux kernel modules for fan speed controller 4 * 5 * Copyright (C) 2016 Allied Telesis Labs NZ 6 */ 7 8 #include <linux/bitops.h> 9 #include <linux/err.h> 10 #include <linux/hwmon.h> 11 #include <linux/hwmon-sysfs.h> 12 #include <linux/i2c.h> 13 #include <linux/init.h> 14 #include <linux/jiffies.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/slab.h> 18 #include <linux/thermal.h> 19 #include <linux/util_macros.h> 20 21 enum tc654_regs { 22 TC654_REG_RPM1 = 0x00, /* RPM Output 1 */ 23 TC654_REG_RPM2 = 0x01, /* RPM Output 2 */ 24 TC654_REG_FAN_FAULT1 = 0x02, /* Fan Fault 1 Threshold */ 25 TC654_REG_FAN_FAULT2 = 0x03, /* Fan Fault 2 Threshold */ 26 TC654_REG_CONFIG = 0x04, /* Configuration */ 27 TC654_REG_STATUS = 0x05, /* Status */ 28 TC654_REG_DUTY_CYCLE = 0x06, /* Fan Speed Duty Cycle */ 29 TC654_REG_MFR_ID = 0x07, /* Manufacturer Identification */ 30 TC654_REG_VER_ID = 0x08, /* Version Identification */ 31 }; 32 33 /* Macros to easily index the registers */ 34 #define TC654_REG_RPM(idx) (TC654_REG_RPM1 + (idx)) 35 #define TC654_REG_FAN_FAULT(idx) (TC654_REG_FAN_FAULT1 + (idx)) 36 37 /* Config register bits */ 38 #define TC654_REG_CONFIG_RES BIT(6) /* Resolution Selection */ 39 #define TC654_REG_CONFIG_DUTYC BIT(5) /* Duty Cycle Control */ 40 #define TC654_REG_CONFIG_SDM BIT(0) /* Shutdown Mode */ 41 42 /* Status register bits */ 43 #define TC654_REG_STATUS_F2F BIT(1) /* Fan 2 Fault */ 44 #define TC654_REG_STATUS_F1F BIT(0) /* Fan 1 Fault */ 45 46 /* RPM resolution for RPM Output registers */ 47 #define TC654_HIGH_RPM_RESOLUTION 25 /* 25 RPM resolution */ 48 #define TC654_LOW_RPM_RESOLUTION 50 /* 50 RPM resolution */ 49 50 /* Convert to the fan fault RPM threshold from register value */ 51 #define TC654_FAN_FAULT_FROM_REG(val) ((val) * 50) /* 50 RPM resolution */ 52 53 /* Convert to register value from the fan fault RPM threshold */ 54 #define TC654_FAN_FAULT_TO_REG(val) (((val) / 50) & 0xff) 55 56 /* Register data is read (and cached) at most once per second. */ 57 #define TC654_UPDATE_INTERVAL HZ 58 59 struct tc654_data { 60 struct i2c_client *client; 61 62 /* update mutex */ 63 struct mutex update_lock; 64 65 /* tc654 register cache */ 66 bool valid; 67 unsigned long last_updated; /* in jiffies */ 68 69 u8 rpm_output[2]; /* The fan RPM data for fans 1 and 2 is then 70 * written to registers RPM1 and RPM2 71 */ 72 u8 fan_fault[2]; /* The Fan Fault Threshold Registers are used to 73 * set the fan fault threshold levels for fan 1 74 * and fan 2 75 */ 76 u8 config; /* The Configuration Register is an 8-bit read/ 77 * writable multi-function control register 78 * 7: Fan Fault Clear 79 * 1 = Clear Fan Fault 80 * 0 = Normal Operation (default) 81 * 6: Resolution Selection for RPM Output Registers 82 * RPM Output Registers (RPM1 and RPM2) will be 83 * set for 84 * 1 = 25 RPM (9-bit) resolution 85 * 0 = 50 RPM (8-bit) resolution (default) 86 * 5: Duty Cycle Control Method 87 * The V OUT duty cycle will be controlled via 88 * 1 = the SMBus interface. 89 * 0 = via the V IN analog input pin. (default) 90 * 4,3: Fan 2 Pulses Per Rotation 91 * 00 = 1 92 * 01 = 2 (default) 93 * 10 = 4 94 * 11 = 8 95 * 2,1: Fan 1 Pulses Per Rotation 96 * 00 = 1 97 * 01 = 2 (default) 98 * 10 = 4 99 * 11 = 8 100 * 0: Shutdown Mode 101 * 1 = Shutdown mode. 102 * 0 = Normal operation. (default) 103 */ 104 u8 status; /* The Status register provides all the information 105 * about what is going on within the TC654/TC655 106 * devices. 107 * 7,6: Unimplemented, Read as '0' 108 * 5: Over-Temperature Fault Condition 109 * 1 = Over-Temperature condition has occurred 110 * 0 = Normal operation. V IN is less than 2.6V 111 * 4: RPM2 Counter Overflow 112 * 1 = Fault condition 113 * 0 = Normal operation 114 * 3: RPM1 Counter Overflow 115 * 1 = Fault condition 116 * 0 = Normal operation 117 * 2: V IN Input Status 118 * 1 = V IN is open 119 * 0 = Normal operation. voltage present at V IN 120 * 1: Fan 2 Fault 121 * 1 = Fault condition 122 * 0 = Normal operation 123 * 0: Fan 1 Fault 124 * 1 = Fault condition 125 * 0 = Normal operation 126 */ 127 u8 duty_cycle; /* The DUTY_CYCLE register is a 4-bit read/ 128 * writable register used to control the duty 129 * cycle of the V OUT output. 130 */ 131 }; 132 133 /* helper to grab and cache data, at most one time per second */ 134 static struct tc654_data *tc654_update_client(struct device *dev) 135 { 136 struct tc654_data *data = dev_get_drvdata(dev); 137 struct i2c_client *client = data->client; 138 int ret = 0; 139 140 mutex_lock(&data->update_lock); 141 if (time_before(jiffies, data->last_updated + TC654_UPDATE_INTERVAL) && 142 likely(data->valid)) 143 goto out; 144 145 ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(0)); 146 if (ret < 0) 147 goto out; 148 data->rpm_output[0] = ret; 149 150 ret = i2c_smbus_read_byte_data(client, TC654_REG_RPM(1)); 151 if (ret < 0) 152 goto out; 153 data->rpm_output[1] = ret; 154 155 ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(0)); 156 if (ret < 0) 157 goto out; 158 data->fan_fault[0] = ret; 159 160 ret = i2c_smbus_read_byte_data(client, TC654_REG_FAN_FAULT(1)); 161 if (ret < 0) 162 goto out; 163 data->fan_fault[1] = ret; 164 165 ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG); 166 if (ret < 0) 167 goto out; 168 data->config = ret; 169 170 ret = i2c_smbus_read_byte_data(client, TC654_REG_STATUS); 171 if (ret < 0) 172 goto out; 173 data->status = ret; 174 175 ret = i2c_smbus_read_byte_data(client, TC654_REG_DUTY_CYCLE); 176 if (ret < 0) 177 goto out; 178 data->duty_cycle = ret & 0x0f; 179 180 data->last_updated = jiffies; 181 data->valid = true; 182 out: 183 mutex_unlock(&data->update_lock); 184 185 if (ret < 0) /* upon error, encode it in return value */ 186 data = ERR_PTR(ret); 187 188 return data; 189 } 190 191 /* 192 * sysfs attributes 193 */ 194 195 static ssize_t fan_show(struct device *dev, struct device_attribute *da, 196 char *buf) 197 { 198 int nr = to_sensor_dev_attr(da)->index; 199 struct tc654_data *data = tc654_update_client(dev); 200 int val; 201 202 if (IS_ERR(data)) 203 return PTR_ERR(data); 204 205 if (data->config & TC654_REG_CONFIG_RES) 206 val = data->rpm_output[nr] * TC654_HIGH_RPM_RESOLUTION; 207 else 208 val = data->rpm_output[nr] * TC654_LOW_RPM_RESOLUTION; 209 210 return sprintf(buf, "%d\n", val); 211 } 212 213 static ssize_t fan_min_show(struct device *dev, struct device_attribute *da, 214 char *buf) 215 { 216 int nr = to_sensor_dev_attr(da)->index; 217 struct tc654_data *data = tc654_update_client(dev); 218 219 if (IS_ERR(data)) 220 return PTR_ERR(data); 221 222 return sprintf(buf, "%d\n", 223 TC654_FAN_FAULT_FROM_REG(data->fan_fault[nr])); 224 } 225 226 static ssize_t fan_min_store(struct device *dev, struct device_attribute *da, 227 const char *buf, size_t count) 228 { 229 int nr = to_sensor_dev_attr(da)->index; 230 struct tc654_data *data = dev_get_drvdata(dev); 231 struct i2c_client *client = data->client; 232 unsigned long val; 233 int ret; 234 235 if (kstrtoul(buf, 10, &val)) 236 return -EINVAL; 237 238 val = clamp_val(val, 0, 12750); 239 240 mutex_lock(&data->update_lock); 241 242 data->fan_fault[nr] = TC654_FAN_FAULT_TO_REG(val); 243 ret = i2c_smbus_write_byte_data(client, TC654_REG_FAN_FAULT(nr), 244 data->fan_fault[nr]); 245 246 mutex_unlock(&data->update_lock); 247 return ret < 0 ? ret : count; 248 } 249 250 static ssize_t fan_alarm_show(struct device *dev, struct device_attribute *da, 251 char *buf) 252 { 253 int nr = to_sensor_dev_attr(da)->index; 254 struct tc654_data *data = tc654_update_client(dev); 255 int val; 256 257 if (IS_ERR(data)) 258 return PTR_ERR(data); 259 260 if (nr == 0) 261 val = !!(data->status & TC654_REG_STATUS_F1F); 262 else 263 val = !!(data->status & TC654_REG_STATUS_F2F); 264 265 return sprintf(buf, "%d\n", val); 266 } 267 268 static const u8 TC654_FAN_PULSE_SHIFT[] = { 1, 3 }; 269 270 static ssize_t fan_pulses_show(struct device *dev, 271 struct device_attribute *da, char *buf) 272 { 273 int nr = to_sensor_dev_attr(da)->index; 274 struct tc654_data *data = tc654_update_client(dev); 275 u8 val; 276 277 if (IS_ERR(data)) 278 return PTR_ERR(data); 279 280 val = BIT((data->config >> TC654_FAN_PULSE_SHIFT[nr]) & 0x03); 281 return sprintf(buf, "%d\n", val); 282 } 283 284 static ssize_t fan_pulses_store(struct device *dev, 285 struct device_attribute *da, const char *buf, 286 size_t count) 287 { 288 int nr = to_sensor_dev_attr(da)->index; 289 struct tc654_data *data = dev_get_drvdata(dev); 290 struct i2c_client *client = data->client; 291 u8 config; 292 unsigned long val; 293 int ret; 294 295 if (kstrtoul(buf, 10, &val)) 296 return -EINVAL; 297 298 switch (val) { 299 case 1: 300 config = 0; 301 break; 302 case 2: 303 config = 1; 304 break; 305 case 4: 306 config = 2; 307 break; 308 case 8: 309 config = 3; 310 break; 311 default: 312 return -EINVAL; 313 } 314 315 mutex_lock(&data->update_lock); 316 317 data->config &= ~(0x03 << TC654_FAN_PULSE_SHIFT[nr]); 318 data->config |= (config << TC654_FAN_PULSE_SHIFT[nr]); 319 ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config); 320 321 mutex_unlock(&data->update_lock); 322 return ret < 0 ? ret : count; 323 } 324 325 static ssize_t pwm_mode_show(struct device *dev, struct device_attribute *da, 326 char *buf) 327 { 328 struct tc654_data *data = tc654_update_client(dev); 329 330 if (IS_ERR(data)) 331 return PTR_ERR(data); 332 333 return sprintf(buf, "%d\n", !!(data->config & TC654_REG_CONFIG_DUTYC)); 334 } 335 336 static ssize_t pwm_mode_store(struct device *dev, struct device_attribute *da, 337 const char *buf, size_t count) 338 { 339 struct tc654_data *data = dev_get_drvdata(dev); 340 struct i2c_client *client = data->client; 341 unsigned long val; 342 int ret; 343 344 if (kstrtoul(buf, 10, &val)) 345 return -EINVAL; 346 347 if (val != 0 && val != 1) 348 return -EINVAL; 349 350 mutex_lock(&data->update_lock); 351 352 if (val) 353 data->config |= TC654_REG_CONFIG_DUTYC; 354 else 355 data->config &= ~TC654_REG_CONFIG_DUTYC; 356 357 ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config); 358 359 mutex_unlock(&data->update_lock); 360 return ret < 0 ? ret : count; 361 } 362 363 static const int tc654_pwm_map[16] = { 77, 88, 102, 112, 124, 136, 148, 160, 364 172, 184, 196, 207, 219, 231, 243, 255}; 365 366 static ssize_t pwm_show(struct device *dev, struct device_attribute *da, 367 char *buf) 368 { 369 struct tc654_data *data = tc654_update_client(dev); 370 int pwm; 371 372 if (IS_ERR(data)) 373 return PTR_ERR(data); 374 375 if (data->config & TC654_REG_CONFIG_SDM) 376 pwm = 0; 377 else 378 pwm = tc654_pwm_map[data->duty_cycle]; 379 380 return sprintf(buf, "%d\n", pwm); 381 } 382 383 static int _set_pwm(struct tc654_data *data, unsigned long val) 384 { 385 struct i2c_client *client = data->client; 386 int ret; 387 388 mutex_lock(&data->update_lock); 389 390 if (val == 0) { 391 data->config |= TC654_REG_CONFIG_SDM; 392 data->duty_cycle = 0; 393 } else { 394 data->config &= ~TC654_REG_CONFIG_SDM; 395 data->duty_cycle = val - 1; 396 } 397 398 ret = i2c_smbus_write_byte_data(client, TC654_REG_CONFIG, data->config); 399 if (ret < 0) 400 goto out; 401 402 ret = i2c_smbus_write_byte_data(client, TC654_REG_DUTY_CYCLE, 403 data->duty_cycle); 404 405 out: 406 mutex_unlock(&data->update_lock); 407 return ret; 408 } 409 410 static ssize_t pwm_store(struct device *dev, struct device_attribute *da, 411 const char *buf, size_t count) 412 { 413 struct tc654_data *data = dev_get_drvdata(dev); 414 unsigned long val; 415 int ret; 416 417 if (kstrtoul(buf, 10, &val)) 418 return -EINVAL; 419 if (val > 255) 420 return -EINVAL; 421 if (val > 0) 422 val = find_closest(val, tc654_pwm_map, ARRAY_SIZE(tc654_pwm_map)) + 1; 423 424 ret = _set_pwm(data, val); 425 return ret < 0 ? ret : count; 426 } 427 428 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0); 429 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1); 430 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0); 431 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1); 432 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, fan_alarm, 0); 433 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, fan_alarm, 1); 434 static SENSOR_DEVICE_ATTR_RW(fan1_pulses, fan_pulses, 0); 435 static SENSOR_DEVICE_ATTR_RW(fan2_pulses, fan_pulses, 1); 436 static SENSOR_DEVICE_ATTR_RW(pwm1_mode, pwm_mode, 0); 437 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0); 438 439 /* Driver data */ 440 static struct attribute *tc654_attrs[] = { 441 &sensor_dev_attr_fan1_input.dev_attr.attr, 442 &sensor_dev_attr_fan2_input.dev_attr.attr, 443 &sensor_dev_attr_fan1_min.dev_attr.attr, 444 &sensor_dev_attr_fan2_min.dev_attr.attr, 445 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 446 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 447 &sensor_dev_attr_fan1_pulses.dev_attr.attr, 448 &sensor_dev_attr_fan2_pulses.dev_attr.attr, 449 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 450 &sensor_dev_attr_pwm1.dev_attr.attr, 451 NULL 452 }; 453 454 ATTRIBUTE_GROUPS(tc654); 455 456 /* 457 * thermal cooling device functions 458 * 459 * Account for the "ShutDown Mode (SDM)" state by offsetting 460 * the 16 PWM duty cycle states by 1. 461 * 462 * State 0 = 0% PWM | Shutdown - Fan(s) are off 463 * State 1 = 30% PWM | duty_cycle = 0 464 * State 2 = ~35% PWM | duty_cycle = 1 465 * [...] 466 * State 15 = ~95% PWM | duty_cycle = 14 467 * State 16 = 100% PWM | duty_cycle = 15 468 */ 469 #define TC654_MAX_COOLING_STATE 16 470 471 static int tc654_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state) 472 { 473 *state = TC654_MAX_COOLING_STATE; 474 return 0; 475 } 476 477 static int tc654_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state) 478 { 479 struct tc654_data *data = tc654_update_client(cdev->devdata); 480 481 if (IS_ERR(data)) 482 return PTR_ERR(data); 483 484 if (data->config & TC654_REG_CONFIG_SDM) 485 *state = 0; /* FAN is off */ 486 else 487 *state = data->duty_cycle + 1; /* offset PWM States by 1 */ 488 489 return 0; 490 } 491 492 static int tc654_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state) 493 { 494 struct tc654_data *data = tc654_update_client(cdev->devdata); 495 496 if (IS_ERR(data)) 497 return PTR_ERR(data); 498 499 return _set_pwm(data, clamp_val(state, 0, TC654_MAX_COOLING_STATE)); 500 } 501 502 static const struct thermal_cooling_device_ops tc654_fan_cool_ops = { 503 .get_max_state = tc654_get_max_state, 504 .get_cur_state = tc654_get_cur_state, 505 .set_cur_state = tc654_set_cur_state, 506 }; 507 508 /* 509 * device probe and removal 510 */ 511 512 static int tc654_probe(struct i2c_client *client) 513 { 514 struct device *dev = &client->dev; 515 struct tc654_data *data; 516 struct device *hwmon_dev; 517 int ret; 518 519 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 520 return -ENODEV; 521 522 data = devm_kzalloc(dev, sizeof(struct tc654_data), GFP_KERNEL); 523 if (!data) 524 return -ENOMEM; 525 526 data->client = client; 527 mutex_init(&data->update_lock); 528 529 ret = i2c_smbus_read_byte_data(client, TC654_REG_CONFIG); 530 if (ret < 0) 531 return ret; 532 533 data->config = ret; 534 535 hwmon_dev = 536 devm_hwmon_device_register_with_groups(dev, client->name, data, 537 tc654_groups); 538 if (IS_ERR(hwmon_dev)) 539 return PTR_ERR(hwmon_dev); 540 541 if (IS_ENABLED(CONFIG_THERMAL)) { 542 struct thermal_cooling_device *cdev; 543 544 cdev = devm_thermal_of_cooling_device_register(dev, dev->of_node, client->name, 545 hwmon_dev, &tc654_fan_cool_ops); 546 return PTR_ERR_OR_ZERO(cdev); 547 } 548 549 return 0; 550 } 551 552 static const struct i2c_device_id tc654_id[] = { 553 {"tc654", 0}, 554 {"tc655", 0}, 555 {} 556 }; 557 558 MODULE_DEVICE_TABLE(i2c, tc654_id); 559 560 static struct i2c_driver tc654_driver = { 561 .driver = { 562 .name = "tc654", 563 }, 564 .probe_new = tc654_probe, 565 .id_table = tc654_id, 566 }; 567 568 module_i2c_driver(tc654_driver); 569 570 MODULE_AUTHOR("Allied Telesis Labs"); 571 MODULE_DESCRIPTION("Microchip TC654/TC655 driver"); 572 MODULE_LICENSE("GPL"); 573