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