1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * f75375s.c - driver for the Fintek F75375/SP, F75373 and 4 * F75387SG/RG hardware monitoring features 5 * Copyright (C) 2006-2007 Riku Voipio 6 * 7 * Datasheets available at: 8 * 9 * f75375: 10 * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf 11 * 12 * f75373: 13 * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf 14 * 15 * f75387: 16 * http://www.fintek.com.tw/files/productfiles/F75387_V027P.pdf 17 */ 18 19 #include <linux/module.h> 20 #include <linux/jiffies.h> 21 #include <linux/hwmon.h> 22 #include <linux/hwmon-sysfs.h> 23 #include <linux/i2c.h> 24 #include <linux/err.h> 25 #include <linux/mutex.h> 26 #include <linux/f75375s.h> 27 #include <linux/slab.h> 28 29 /* Addresses to scan */ 30 static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END }; 31 32 enum chips { f75373, f75375, f75387 }; 33 34 /* Fintek F75375 registers */ 35 #define F75375_REG_CONFIG0 0x0 36 #define F75375_REG_CONFIG1 0x1 37 #define F75375_REG_CONFIG2 0x2 38 #define F75375_REG_CONFIG3 0x3 39 #define F75375_REG_ADDR 0x4 40 #define F75375_REG_INTR 0x31 41 #define F75375_CHIP_ID 0x5A 42 #define F75375_REG_VERSION 0x5C 43 #define F75375_REG_VENDOR 0x5D 44 #define F75375_REG_FAN_TIMER 0x60 45 46 #define F75375_REG_VOLT(nr) (0x10 + (nr)) 47 #define F75375_REG_VOLT_HIGH(nr) (0x20 + (nr) * 2) 48 #define F75375_REG_VOLT_LOW(nr) (0x21 + (nr) * 2) 49 50 #define F75375_REG_TEMP(nr) (0x14 + (nr)) 51 #define F75387_REG_TEMP11_LSB(nr) (0x1a + (nr)) 52 #define F75375_REG_TEMP_HIGH(nr) (0x28 + (nr) * 2) 53 #define F75375_REG_TEMP_HYST(nr) (0x29 + (nr) * 2) 54 55 #define F75375_REG_FAN(nr) (0x16 + (nr) * 2) 56 #define F75375_REG_FAN_MIN(nr) (0x2C + (nr) * 2) 57 #define F75375_REG_FAN_FULL(nr) (0x70 + (nr) * 0x10) 58 #define F75375_REG_FAN_PWM_DUTY(nr) (0x76 + (nr) * 0x10) 59 #define F75375_REG_FAN_PWM_CLOCK(nr) (0x7D + (nr) * 0x10) 60 61 #define F75375_REG_FAN_EXP(nr) (0x74 + (nr) * 0x10) 62 #define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step)) 63 #define F75375_REG_FAN_B_SPEED(nr, step) \ 64 ((0xA5 + (nr) * 0x10) + (step) * 2) 65 66 #define F75375_REG_PWM1_RAISE_DUTY 0x69 67 #define F75375_REG_PWM2_RAISE_DUTY 0x6A 68 #define F75375_REG_PWM1_DROP_DUTY 0x6B 69 #define F75375_REG_PWM2_DROP_DUTY 0x6C 70 71 #define F75375_FAN_CTRL_LINEAR(nr) (4 + nr) 72 #define F75387_FAN_CTRL_LINEAR(nr) (1 + ((nr) * 4)) 73 #define FAN_CTRL_MODE(nr) (4 + ((nr) * 2)) 74 #define F75387_FAN_DUTY_MODE(nr) (2 + ((nr) * 4)) 75 #define F75387_FAN_MANU_MODE(nr) ((nr) * 4) 76 77 /* 78 * Data structures and manipulation thereof 79 */ 80 81 struct f75375_data { 82 unsigned short addr; 83 struct device *hwmon_dev; 84 85 const char *name; 86 int kind; 87 struct mutex update_lock; /* protect register access */ 88 bool valid; 89 unsigned long last_updated; /* In jiffies */ 90 unsigned long last_limits; /* In jiffies */ 91 92 /* Register values */ 93 u8 in[4]; 94 u8 in_max[4]; 95 u8 in_min[4]; 96 u16 fan[2]; 97 u16 fan_min[2]; 98 u16 fan_max[2]; 99 u16 fan_target[2]; 100 u8 fan_timer; 101 u8 pwm[2]; 102 u8 pwm_mode[2]; 103 u8 pwm_enable[2]; 104 /* 105 * f75387: For remote temperature reading, it uses signed 11-bit 106 * values with LSB = 0.125 degree Celsius, left-justified in 16-bit 107 * registers. For original 8-bit temp readings, the LSB just is 0. 108 */ 109 s16 temp11[2]; 110 s8 temp_high[2]; 111 s8 temp_max_hyst[2]; 112 }; 113 114 static inline int f75375_read8(struct i2c_client *client, u8 reg) 115 { 116 return i2c_smbus_read_byte_data(client, reg); 117 } 118 119 /* in most cases, should be called while holding update_lock */ 120 static inline u16 f75375_read16(struct i2c_client *client, u8 reg) 121 { 122 return (i2c_smbus_read_byte_data(client, reg) << 8) 123 | i2c_smbus_read_byte_data(client, reg + 1); 124 } 125 126 static inline void f75375_write8(struct i2c_client *client, u8 reg, 127 u8 value) 128 { 129 i2c_smbus_write_byte_data(client, reg, value); 130 } 131 132 static inline void f75375_write16(struct i2c_client *client, u8 reg, 133 u16 value) 134 { 135 int err = i2c_smbus_write_byte_data(client, reg, (value >> 8)); 136 if (err) 137 return; 138 i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF)); 139 } 140 141 static void f75375_write_pwm(struct i2c_client *client, int nr) 142 { 143 struct f75375_data *data = i2c_get_clientdata(client); 144 if (data->kind == f75387) 145 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->pwm[nr]); 146 else 147 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), 148 data->pwm[nr]); 149 } 150 151 static struct f75375_data *f75375_update_device(struct device *dev) 152 { 153 struct i2c_client *client = to_i2c_client(dev); 154 struct f75375_data *data = i2c_get_clientdata(client); 155 int nr; 156 157 mutex_lock(&data->update_lock); 158 159 /* Limit registers cache is refreshed after 60 seconds */ 160 if (time_after(jiffies, data->last_limits + 60 * HZ) 161 || !data->valid) { 162 for (nr = 0; nr < 2; nr++) { 163 data->temp_high[nr] = 164 f75375_read8(client, F75375_REG_TEMP_HIGH(nr)); 165 data->temp_max_hyst[nr] = 166 f75375_read8(client, F75375_REG_TEMP_HYST(nr)); 167 data->fan_max[nr] = 168 f75375_read16(client, F75375_REG_FAN_FULL(nr)); 169 data->fan_min[nr] = 170 f75375_read16(client, F75375_REG_FAN_MIN(nr)); 171 data->fan_target[nr] = 172 f75375_read16(client, F75375_REG_FAN_EXP(nr)); 173 } 174 for (nr = 0; nr < 4; nr++) { 175 data->in_max[nr] = 176 f75375_read8(client, F75375_REG_VOLT_HIGH(nr)); 177 data->in_min[nr] = 178 f75375_read8(client, F75375_REG_VOLT_LOW(nr)); 179 } 180 data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER); 181 data->last_limits = jiffies; 182 } 183 184 /* Measurement registers cache is refreshed after 2 second */ 185 if (time_after(jiffies, data->last_updated + 2 * HZ) 186 || !data->valid) { 187 for (nr = 0; nr < 2; nr++) { 188 data->pwm[nr] = f75375_read8(client, 189 F75375_REG_FAN_PWM_DUTY(nr)); 190 /* assign MSB, therefore shift it by 8 bits */ 191 data->temp11[nr] = 192 f75375_read8(client, F75375_REG_TEMP(nr)) << 8; 193 if (data->kind == f75387) 194 /* merge F75387's temperature LSB (11-bit) */ 195 data->temp11[nr] |= 196 f75375_read8(client, 197 F75387_REG_TEMP11_LSB(nr)); 198 data->fan[nr] = 199 f75375_read16(client, F75375_REG_FAN(nr)); 200 } 201 for (nr = 0; nr < 4; nr++) 202 data->in[nr] = 203 f75375_read8(client, F75375_REG_VOLT(nr)); 204 205 data->last_updated = jiffies; 206 data->valid = true; 207 } 208 209 mutex_unlock(&data->update_lock); 210 return data; 211 } 212 213 static inline u16 rpm_from_reg(u16 reg) 214 { 215 if (reg == 0 || reg == 0xffff) 216 return 0; 217 return 1500000 / reg; 218 } 219 220 static inline u16 rpm_to_reg(int rpm) 221 { 222 if (rpm < 367 || rpm > 0xffff) 223 return 0xffff; 224 return 1500000 / rpm; 225 } 226 227 static bool duty_mode_enabled(u8 pwm_enable) 228 { 229 switch (pwm_enable) { 230 case 0: /* Manual, duty mode (full speed) */ 231 case 1: /* Manual, duty mode */ 232 case 4: /* Auto, duty mode */ 233 return true; 234 case 2: /* Auto, speed mode */ 235 case 3: /* Manual, speed mode */ 236 return false; 237 default: 238 WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable); 239 return true; 240 } 241 } 242 243 static bool auto_mode_enabled(u8 pwm_enable) 244 { 245 switch (pwm_enable) { 246 case 0: /* Manual, duty mode (full speed) */ 247 case 1: /* Manual, duty mode */ 248 case 3: /* Manual, speed mode */ 249 return false; 250 case 2: /* Auto, speed mode */ 251 case 4: /* Auto, duty mode */ 252 return true; 253 default: 254 WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable); 255 return false; 256 } 257 } 258 259 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 260 const char *buf, size_t count) 261 { 262 int nr = to_sensor_dev_attr(attr)->index; 263 struct i2c_client *client = to_i2c_client(dev); 264 struct f75375_data *data = i2c_get_clientdata(client); 265 unsigned long val; 266 int err; 267 268 err = kstrtoul(buf, 10, &val); 269 if (err < 0) 270 return err; 271 272 mutex_lock(&data->update_lock); 273 data->fan_min[nr] = rpm_to_reg(val); 274 f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]); 275 mutex_unlock(&data->update_lock); 276 return count; 277 } 278 279 static ssize_t set_fan_target(struct device *dev, struct device_attribute *attr, 280 const char *buf, size_t count) 281 { 282 int nr = to_sensor_dev_attr(attr)->index; 283 struct i2c_client *client = to_i2c_client(dev); 284 struct f75375_data *data = i2c_get_clientdata(client); 285 unsigned long val; 286 int err; 287 288 err = kstrtoul(buf, 10, &val); 289 if (err < 0) 290 return err; 291 292 if (auto_mode_enabled(data->pwm_enable[nr])) 293 return -EINVAL; 294 if (data->kind == f75387 && duty_mode_enabled(data->pwm_enable[nr])) 295 return -EINVAL; 296 297 mutex_lock(&data->update_lock); 298 data->fan_target[nr] = rpm_to_reg(val); 299 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_target[nr]); 300 mutex_unlock(&data->update_lock); 301 return count; 302 } 303 304 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 305 const char *buf, size_t count) 306 { 307 int nr = to_sensor_dev_attr(attr)->index; 308 struct i2c_client *client = to_i2c_client(dev); 309 struct f75375_data *data = i2c_get_clientdata(client); 310 unsigned long val; 311 int err; 312 313 err = kstrtoul(buf, 10, &val); 314 if (err < 0) 315 return err; 316 317 if (auto_mode_enabled(data->pwm_enable[nr]) || 318 !duty_mode_enabled(data->pwm_enable[nr])) 319 return -EINVAL; 320 321 mutex_lock(&data->update_lock); 322 data->pwm[nr] = clamp_val(val, 0, 255); 323 f75375_write_pwm(client, nr); 324 mutex_unlock(&data->update_lock); 325 return count; 326 } 327 328 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute 329 *attr, char *buf) 330 { 331 int nr = to_sensor_dev_attr(attr)->index; 332 struct f75375_data *data = f75375_update_device(dev); 333 return sprintf(buf, "%d\n", data->pwm_enable[nr]); 334 } 335 336 static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val) 337 { 338 struct f75375_data *data = i2c_get_clientdata(client); 339 u8 fanmode; 340 341 if (val < 0 || val > 4) 342 return -EINVAL; 343 344 fanmode = f75375_read8(client, F75375_REG_FAN_TIMER); 345 if (data->kind == f75387) { 346 /* For now, deny dangerous toggling of duty mode */ 347 if (duty_mode_enabled(data->pwm_enable[nr]) != 348 duty_mode_enabled(val)) 349 return -EOPNOTSUPP; 350 /* clear each fanX_mode bit before setting them properly */ 351 fanmode &= ~(1 << F75387_FAN_DUTY_MODE(nr)); 352 fanmode &= ~(1 << F75387_FAN_MANU_MODE(nr)); 353 switch (val) { 354 case 0: /* full speed */ 355 fanmode |= (1 << F75387_FAN_MANU_MODE(nr)); 356 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr)); 357 data->pwm[nr] = 255; 358 break; 359 case 1: /* PWM */ 360 fanmode |= (1 << F75387_FAN_MANU_MODE(nr)); 361 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr)); 362 break; 363 case 2: /* Automatic, speed mode */ 364 break; 365 case 3: /* fan speed */ 366 fanmode |= (1 << F75387_FAN_MANU_MODE(nr)); 367 break; 368 case 4: /* Automatic, pwm */ 369 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr)); 370 break; 371 } 372 } else { 373 /* clear each fanX_mode bit before setting them properly */ 374 fanmode &= ~(3 << FAN_CTRL_MODE(nr)); 375 switch (val) { 376 case 0: /* full speed */ 377 fanmode |= (3 << FAN_CTRL_MODE(nr)); 378 data->pwm[nr] = 255; 379 break; 380 case 1: /* PWM */ 381 fanmode |= (3 << FAN_CTRL_MODE(nr)); 382 break; 383 case 2: /* AUTOMATIC*/ 384 fanmode |= (1 << FAN_CTRL_MODE(nr)); 385 break; 386 case 3: /* fan speed */ 387 break; 388 case 4: /* Automatic pwm */ 389 return -EINVAL; 390 } 391 } 392 393 f75375_write8(client, F75375_REG_FAN_TIMER, fanmode); 394 data->pwm_enable[nr] = val; 395 if (val == 0) 396 f75375_write_pwm(client, nr); 397 return 0; 398 } 399 400 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr, 401 const char *buf, size_t count) 402 { 403 int nr = to_sensor_dev_attr(attr)->index; 404 struct i2c_client *client = to_i2c_client(dev); 405 struct f75375_data *data = i2c_get_clientdata(client); 406 unsigned long val; 407 int err; 408 409 err = kstrtoul(buf, 10, &val); 410 if (err < 0) 411 return err; 412 413 mutex_lock(&data->update_lock); 414 err = set_pwm_enable_direct(client, nr, val); 415 mutex_unlock(&data->update_lock); 416 return err ? err : count; 417 } 418 419 static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr, 420 const char *buf, size_t count) 421 { 422 int nr = to_sensor_dev_attr(attr)->index; 423 struct i2c_client *client = to_i2c_client(dev); 424 struct f75375_data *data = i2c_get_clientdata(client); 425 unsigned long val; 426 int err; 427 u8 conf; 428 char reg, ctrl; 429 430 err = kstrtoul(buf, 10, &val); 431 if (err < 0) 432 return err; 433 434 if (!(val == 0 || val == 1)) 435 return -EINVAL; 436 437 /* F75373 does not support DC (linear voltage) fan control mode */ 438 if (data->kind == f75373 && val == 0) 439 return -EINVAL; 440 441 /* take care for different registers */ 442 if (data->kind == f75387) { 443 reg = F75375_REG_FAN_TIMER; 444 ctrl = F75387_FAN_CTRL_LINEAR(nr); 445 } else { 446 reg = F75375_REG_CONFIG1; 447 ctrl = F75375_FAN_CTRL_LINEAR(nr); 448 } 449 450 mutex_lock(&data->update_lock); 451 conf = f75375_read8(client, reg); 452 conf &= ~(1 << ctrl); 453 454 if (val == 0) 455 conf |= (1 << ctrl); 456 457 f75375_write8(client, reg, conf); 458 data->pwm_mode[nr] = val; 459 mutex_unlock(&data->update_lock); 460 return count; 461 } 462 463 static ssize_t show_pwm(struct device *dev, struct device_attribute 464 *attr, char *buf) 465 { 466 int nr = to_sensor_dev_attr(attr)->index; 467 struct f75375_data *data = f75375_update_device(dev); 468 return sprintf(buf, "%d\n", data->pwm[nr]); 469 } 470 471 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute 472 *attr, char *buf) 473 { 474 int nr = to_sensor_dev_attr(attr)->index; 475 struct f75375_data *data = f75375_update_device(dev); 476 return sprintf(buf, "%d\n", data->pwm_mode[nr]); 477 } 478 479 #define VOLT_FROM_REG(val) ((val) * 8) 480 #define VOLT_TO_REG(val) ((val) / 8) 481 482 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 483 char *buf) 484 { 485 int nr = to_sensor_dev_attr(attr)->index; 486 struct f75375_data *data = f75375_update_device(dev); 487 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr])); 488 } 489 490 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr, 491 char *buf) 492 { 493 int nr = to_sensor_dev_attr(attr)->index; 494 struct f75375_data *data = f75375_update_device(dev); 495 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr])); 496 } 497 498 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr, 499 char *buf) 500 { 501 int nr = to_sensor_dev_attr(attr)->index; 502 struct f75375_data *data = f75375_update_device(dev); 503 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr])); 504 } 505 506 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 507 const char *buf, size_t count) 508 { 509 int nr = to_sensor_dev_attr(attr)->index; 510 struct i2c_client *client = to_i2c_client(dev); 511 struct f75375_data *data = i2c_get_clientdata(client); 512 unsigned long val; 513 int err; 514 515 err = kstrtoul(buf, 10, &val); 516 if (err < 0) 517 return err; 518 519 val = clamp_val(VOLT_TO_REG(val), 0, 0xff); 520 mutex_lock(&data->update_lock); 521 data->in_max[nr] = val; 522 f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]); 523 mutex_unlock(&data->update_lock); 524 return count; 525 } 526 527 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 528 const char *buf, size_t count) 529 { 530 int nr = to_sensor_dev_attr(attr)->index; 531 struct i2c_client *client = to_i2c_client(dev); 532 struct f75375_data *data = i2c_get_clientdata(client); 533 unsigned long val; 534 int err; 535 536 err = kstrtoul(buf, 10, &val); 537 if (err < 0) 538 return err; 539 540 val = clamp_val(VOLT_TO_REG(val), 0, 0xff); 541 mutex_lock(&data->update_lock); 542 data->in_min[nr] = val; 543 f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]); 544 mutex_unlock(&data->update_lock); 545 return count; 546 } 547 #define TEMP_FROM_REG(val) ((val) * 1000) 548 #define TEMP_TO_REG(val) ((val) / 1000) 549 #define TEMP11_FROM_REG(reg) ((reg) / 32 * 125) 550 551 static ssize_t show_temp11(struct device *dev, struct device_attribute *attr, 552 char *buf) 553 { 554 int nr = to_sensor_dev_attr(attr)->index; 555 struct f75375_data *data = f75375_update_device(dev); 556 return sprintf(buf, "%d\n", TEMP11_FROM_REG(data->temp11[nr])); 557 } 558 559 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 560 char *buf) 561 { 562 int nr = to_sensor_dev_attr(attr)->index; 563 struct f75375_data *data = f75375_update_device(dev); 564 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr])); 565 } 566 567 static ssize_t show_temp_max_hyst(struct device *dev, 568 struct device_attribute *attr, char *buf) 569 { 570 int nr = to_sensor_dev_attr(attr)->index; 571 struct f75375_data *data = f75375_update_device(dev); 572 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr])); 573 } 574 575 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 576 const char *buf, size_t count) 577 { 578 int nr = to_sensor_dev_attr(attr)->index; 579 struct i2c_client *client = to_i2c_client(dev); 580 struct f75375_data *data = i2c_get_clientdata(client); 581 unsigned long val; 582 int err; 583 584 err = kstrtoul(buf, 10, &val); 585 if (err < 0) 586 return err; 587 588 val = clamp_val(TEMP_TO_REG(val), 0, 127); 589 mutex_lock(&data->update_lock); 590 data->temp_high[nr] = val; 591 f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]); 592 mutex_unlock(&data->update_lock); 593 return count; 594 } 595 596 static ssize_t set_temp_max_hyst(struct device *dev, 597 struct device_attribute *attr, const char *buf, size_t count) 598 { 599 int nr = to_sensor_dev_attr(attr)->index; 600 struct i2c_client *client = to_i2c_client(dev); 601 struct f75375_data *data = i2c_get_clientdata(client); 602 unsigned long val; 603 int err; 604 605 err = kstrtoul(buf, 10, &val); 606 if (err < 0) 607 return err; 608 609 val = clamp_val(TEMP_TO_REG(val), 0, 127); 610 mutex_lock(&data->update_lock); 611 data->temp_max_hyst[nr] = val; 612 f75375_write8(client, F75375_REG_TEMP_HYST(nr), 613 data->temp_max_hyst[nr]); 614 mutex_unlock(&data->update_lock); 615 return count; 616 } 617 618 #define show_fan(thing) \ 619 static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \ 620 char *buf)\ 621 {\ 622 int nr = to_sensor_dev_attr(attr)->index;\ 623 struct f75375_data *data = f75375_update_device(dev); \ 624 return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \ 625 } 626 627 show_fan(fan); 628 show_fan(fan_min); 629 show_fan(fan_max); 630 show_fan(fan_target); 631 632 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0); 633 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR, 634 show_in_max, set_in_max, 0); 635 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR, 636 show_in_min, set_in_min, 0); 637 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1); 638 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR, 639 show_in_max, set_in_max, 1); 640 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR, 641 show_in_min, set_in_min, 1); 642 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2); 643 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR, 644 show_in_max, set_in_max, 2); 645 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR, 646 show_in_min, set_in_min, 2); 647 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3); 648 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR, 649 show_in_max, set_in_max, 3); 650 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR, 651 show_in_min, set_in_min, 3); 652 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 0); 653 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR, 654 show_temp_max_hyst, set_temp_max_hyst, 0); 655 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR, 656 show_temp_max, set_temp_max, 0); 657 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 1); 658 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR, 659 show_temp_max_hyst, set_temp_max_hyst, 1); 660 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR, 661 show_temp_max, set_temp_max, 1); 662 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 663 static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, 0); 664 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR, 665 show_fan_min, set_fan_min, 0); 666 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO|S_IWUSR, 667 show_fan_target, set_fan_target, 0); 668 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 669 static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max, NULL, 1); 670 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR, 671 show_fan_min, set_fan_min, 1); 672 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO|S_IWUSR, 673 show_fan_target, set_fan_target, 1); 674 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR, 675 show_pwm, set_pwm, 0); 676 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR, 677 show_pwm_enable, set_pwm_enable, 0); 678 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, 679 show_pwm_mode, set_pwm_mode, 0); 680 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, 681 show_pwm, set_pwm, 1); 682 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR, 683 show_pwm_enable, set_pwm_enable, 1); 684 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO, 685 show_pwm_mode, set_pwm_mode, 1); 686 687 static struct attribute *f75375_attributes[] = { 688 &sensor_dev_attr_temp1_input.dev_attr.attr, 689 &sensor_dev_attr_temp1_max.dev_attr.attr, 690 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 691 &sensor_dev_attr_temp2_input.dev_attr.attr, 692 &sensor_dev_attr_temp2_max.dev_attr.attr, 693 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, 694 &sensor_dev_attr_fan1_input.dev_attr.attr, 695 &sensor_dev_attr_fan1_max.dev_attr.attr, 696 &sensor_dev_attr_fan1_min.dev_attr.attr, 697 &sensor_dev_attr_fan1_target.dev_attr.attr, 698 &sensor_dev_attr_fan2_input.dev_attr.attr, 699 &sensor_dev_attr_fan2_max.dev_attr.attr, 700 &sensor_dev_attr_fan2_min.dev_attr.attr, 701 &sensor_dev_attr_fan2_target.dev_attr.attr, 702 &sensor_dev_attr_pwm1.dev_attr.attr, 703 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 704 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 705 &sensor_dev_attr_pwm2.dev_attr.attr, 706 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 707 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 708 &sensor_dev_attr_in0_input.dev_attr.attr, 709 &sensor_dev_attr_in0_max.dev_attr.attr, 710 &sensor_dev_attr_in0_min.dev_attr.attr, 711 &sensor_dev_attr_in1_input.dev_attr.attr, 712 &sensor_dev_attr_in1_max.dev_attr.attr, 713 &sensor_dev_attr_in1_min.dev_attr.attr, 714 &sensor_dev_attr_in2_input.dev_attr.attr, 715 &sensor_dev_attr_in2_max.dev_attr.attr, 716 &sensor_dev_attr_in2_min.dev_attr.attr, 717 &sensor_dev_attr_in3_input.dev_attr.attr, 718 &sensor_dev_attr_in3_max.dev_attr.attr, 719 &sensor_dev_attr_in3_min.dev_attr.attr, 720 NULL 721 }; 722 723 static const struct attribute_group f75375_group = { 724 .attrs = f75375_attributes, 725 }; 726 727 static void f75375_init(struct i2c_client *client, struct f75375_data *data, 728 struct f75375s_platform_data *f75375s_pdata) 729 { 730 int nr; 731 732 if (!f75375s_pdata) { 733 u8 conf, mode; 734 int nr; 735 736 conf = f75375_read8(client, F75375_REG_CONFIG1); 737 mode = f75375_read8(client, F75375_REG_FAN_TIMER); 738 for (nr = 0; nr < 2; nr++) { 739 if (data->kind == f75387) { 740 bool manu, duty; 741 742 if (!(mode & (1 << F75387_FAN_CTRL_LINEAR(nr)))) 743 data->pwm_mode[nr] = 1; 744 745 manu = ((mode >> F75387_FAN_MANU_MODE(nr)) & 1); 746 duty = ((mode >> F75387_FAN_DUTY_MODE(nr)) & 1); 747 if (!manu && duty) 748 /* auto, pwm */ 749 data->pwm_enable[nr] = 4; 750 else if (manu && !duty) 751 /* manual, speed */ 752 data->pwm_enable[nr] = 3; 753 else if (!manu && !duty) 754 /* automatic, speed */ 755 data->pwm_enable[nr] = 2; 756 else 757 /* manual, pwm */ 758 data->pwm_enable[nr] = 1; 759 } else { 760 if (!(conf & (1 << F75375_FAN_CTRL_LINEAR(nr)))) 761 data->pwm_mode[nr] = 1; 762 763 switch ((mode >> FAN_CTRL_MODE(nr)) & 3) { 764 case 0: /* speed */ 765 data->pwm_enable[nr] = 3; 766 break; 767 case 1: /* automatic */ 768 data->pwm_enable[nr] = 2; 769 break; 770 default: /* manual */ 771 data->pwm_enable[nr] = 1; 772 break; 773 } 774 } 775 } 776 return; 777 } 778 779 set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]); 780 set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]); 781 for (nr = 0; nr < 2; nr++) { 782 if (auto_mode_enabled(f75375s_pdata->pwm_enable[nr]) || 783 !duty_mode_enabled(f75375s_pdata->pwm_enable[nr])) 784 continue; 785 data->pwm[nr] = clamp_val(f75375s_pdata->pwm[nr], 0, 255); 786 f75375_write_pwm(client, nr); 787 } 788 789 } 790 791 static int f75375_probe(struct i2c_client *client) 792 { 793 struct f75375_data *data; 794 struct f75375s_platform_data *f75375s_pdata = 795 dev_get_platdata(&client->dev); 796 int err; 797 798 if (!i2c_check_functionality(client->adapter, 799 I2C_FUNC_SMBUS_BYTE_DATA)) 800 return -EIO; 801 data = devm_kzalloc(&client->dev, sizeof(struct f75375_data), 802 GFP_KERNEL); 803 if (!data) 804 return -ENOMEM; 805 806 i2c_set_clientdata(client, data); 807 mutex_init(&data->update_lock); 808 data->kind = (uintptr_t)i2c_get_match_data(client); 809 810 err = sysfs_create_group(&client->dev.kobj, &f75375_group); 811 if (err) 812 return err; 813 814 if (data->kind != f75373) { 815 err = sysfs_chmod_file(&client->dev.kobj, 816 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 817 S_IRUGO | S_IWUSR); 818 if (err) 819 goto exit_remove; 820 err = sysfs_chmod_file(&client->dev.kobj, 821 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 822 S_IRUGO | S_IWUSR); 823 if (err) 824 goto exit_remove; 825 } 826 827 data->hwmon_dev = hwmon_device_register(&client->dev); 828 if (IS_ERR(data->hwmon_dev)) { 829 err = PTR_ERR(data->hwmon_dev); 830 goto exit_remove; 831 } 832 833 f75375_init(client, data, f75375s_pdata); 834 835 return 0; 836 837 exit_remove: 838 sysfs_remove_group(&client->dev.kobj, &f75375_group); 839 return err; 840 } 841 842 static void f75375_remove(struct i2c_client *client) 843 { 844 struct f75375_data *data = i2c_get_clientdata(client); 845 hwmon_device_unregister(data->hwmon_dev); 846 sysfs_remove_group(&client->dev.kobj, &f75375_group); 847 } 848 849 /* Return 0 if detection is successful, -ENODEV otherwise */ 850 static int f75375_detect(struct i2c_client *client, 851 struct i2c_board_info *info) 852 { 853 struct i2c_adapter *adapter = client->adapter; 854 u16 vendid, chipid; 855 u8 version; 856 const char *name; 857 858 vendid = f75375_read16(client, F75375_REG_VENDOR); 859 chipid = f75375_read16(client, F75375_CHIP_ID); 860 if (vendid != 0x1934) 861 return -ENODEV; 862 863 if (chipid == 0x0306) 864 name = "f75375"; 865 else if (chipid == 0x0204) 866 name = "f75373"; 867 else if (chipid == 0x0410) 868 name = "f75387"; 869 else 870 return -ENODEV; 871 872 version = f75375_read8(client, F75375_REG_VERSION); 873 dev_info(&adapter->dev, "found %s version: %02X\n", name, version); 874 strscpy(info->type, name, I2C_NAME_SIZE); 875 876 return 0; 877 } 878 879 static const struct i2c_device_id f75375_id[] = { 880 { "f75373", f75373 }, 881 { "f75375", f75375 }, 882 { "f75387", f75387 }, 883 { } 884 }; 885 MODULE_DEVICE_TABLE(i2c, f75375_id); 886 887 static struct i2c_driver f75375_driver = { 888 .class = I2C_CLASS_HWMON, 889 .driver = { 890 .name = "f75375", 891 }, 892 .probe = f75375_probe, 893 .remove = f75375_remove, 894 .id_table = f75375_id, 895 .detect = f75375_detect, 896 .address_list = normal_i2c, 897 }; 898 module_i2c_driver(f75375_driver); 899 900 MODULE_AUTHOR("Riku Voipio"); 901 MODULE_LICENSE("GPL"); 902 MODULE_DESCRIPTION("F75373/F75375/F75387 hardware monitoring driver"); 903