drivers/hwmon/f75375s.c

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