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