linux/drivers/hwmon/f75375s.c
<<
>>
Prefs
   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 */
  44static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
  45
  46enum 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
  95struct 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
 128static int f75375_detect(struct i2c_client *client,
 129                         struct i2c_board_info *info);
 130static int f75375_probe(struct i2c_client *client,
 131                        const struct i2c_device_id *id);
 132static int f75375_remove(struct i2c_client *client);
 133
 134static const struct i2c_device_id f75375_id[] = {
 135        { "f75373", f75373 },
 136        { "f75375", f75375 },
 137        { "f75387", f75387 },
 138        { }
 139};
 140MODULE_DEVICE_TABLE(i2c, f75375_id);
 141
 142static 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
 154static 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 */
 160static 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
 166static 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
 172static 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
 181static 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
 191static 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
 253static inline u16 rpm_from_reg(u16 reg)
 254{
 255        if (reg == 0 || reg == 0xffff)
 256                return 0;
 257        return 1500000 / reg;
 258}
 259
 260static inline u16 rpm_to_reg(int rpm)
 261{
 262        if (rpm < 367 || rpm > 0xffff)
 263                return 0xffff;
 264        return 1500000 / rpm;
 265}
 266
 267static 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
 283static 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
 299static 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
 319static 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
 344static 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
 368static 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
 376static 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
 440static 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
 459static 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
 503static 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
 511static 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
 522static 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
 530static 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
 538static 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
 546static 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
 567static 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
 591static 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
 599static 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
 607static 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
 615static 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
 636static 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) \
 659static 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
 667show_fan(fan);
 668show_fan(fan_min);
 669show_fan(fan_max);
 670show_fan(fan_target);
 671
 672static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
 673static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
 674        show_in_max, set_in_max, 0);
 675static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
 676        show_in_min, set_in_min, 0);
 677static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
 678static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
 679        show_in_max, set_in_max, 1);
 680static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
 681        show_in_min, set_in_min, 1);
 682static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
 683static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
 684        show_in_max, set_in_max, 2);
 685static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
 686        show_in_min, set_in_min, 2);
 687static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
 688static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
 689        show_in_max, set_in_max, 3);
 690static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
 691        show_in_min, set_in_min, 3);
 692static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 0);
 693static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
 694        show_temp_max_hyst, set_temp_max_hyst, 0);
 695static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
 696        show_temp_max, set_temp_max, 0);
 697static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 1);
 698static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
 699        show_temp_max_hyst, set_temp_max_hyst, 1);
 700static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
 701        show_temp_max, set_temp_max, 1);
 702static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
 703static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, 0);
 704static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
 705        show_fan_min, set_fan_min, 0);
 706static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO|S_IWUSR,
 707        show_fan_target, set_fan_target, 0);
 708static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
 709static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max, NULL, 1);
 710static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
 711        show_fan_min, set_fan_min, 1);
 712static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO|S_IWUSR,
 713        show_fan_target, set_fan_target, 1);
 714static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
 715        show_pwm, set_pwm, 0);
 716static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
 717        show_pwm_enable, set_pwm_enable, 0);
 718static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO,
 719        show_pwm_mode, set_pwm_mode, 0);
 720static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
 721        show_pwm, set_pwm, 1);
 722static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
 723        show_pwm_enable, set_pwm_enable, 1);
 724static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO,
 725        show_pwm_mode, set_pwm_mode, 1);
 726
 727static 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
 763static const struct attribute_group f75375_group = {
 764        .attrs = f75375_attributes,
 765};
 766
 767static 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
 831static 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 = devm_kzalloc(&client->dev, sizeof(struct f75375_data),
 842                            GFP_KERNEL);
 843        if (!data)
 844                return -ENOMEM;
 845
 846        i2c_set_clientdata(client, data);
 847        mutex_init(&data->update_lock);
 848        data->kind = id->driver_data;
 849
 850        err = sysfs_create_group(&client->dev.kobj, &f75375_group);
 851        if (err)
 852                return err;
 853
 854        if (data->kind != f75373) {
 855                err = sysfs_chmod_file(&client->dev.kobj,
 856                        &sensor_dev_attr_pwm1_mode.dev_attr.attr,
 857                        S_IRUGO | S_IWUSR);
 858                if (err)
 859                        goto exit_remove;
 860                err = sysfs_chmod_file(&client->dev.kobj,
 861                        &sensor_dev_attr_pwm2_mode.dev_attr.attr,
 862                        S_IRUGO | S_IWUSR);
 863                if (err)
 864                        goto exit_remove;
 865        }
 866
 867        data->hwmon_dev = hwmon_device_register(&client->dev);
 868        if (IS_ERR(data->hwmon_dev)) {
 869                err = PTR_ERR(data->hwmon_dev);
 870                goto exit_remove;
 871        }
 872
 873        f75375_init(client, data, f75375s_pdata);
 874
 875        return 0;
 876
 877exit_remove:
 878        sysfs_remove_group(&client->dev.kobj, &f75375_group);
 879        return err;
 880}
 881
 882static int f75375_remove(struct i2c_client *client)
 883{
 884        struct f75375_data *data = i2c_get_clientdata(client);
 885        hwmon_device_unregister(data->hwmon_dev);
 886        sysfs_remove_group(&client->dev.kobj, &f75375_group);
 887        return 0;
 888}
 889
 890/* Return 0 if detection is successful, -ENODEV otherwise */
 891static int f75375_detect(struct i2c_client *client,
 892                         struct i2c_board_info *info)
 893{
 894        struct i2c_adapter *adapter = client->adapter;
 895        u16 vendid, chipid;
 896        u8 version;
 897        const char *name;
 898
 899        vendid = f75375_read16(client, F75375_REG_VENDOR);
 900        chipid = f75375_read16(client, F75375_CHIP_ID);
 901        if (vendid != 0x1934)
 902                return -ENODEV;
 903
 904        if (chipid == 0x0306)
 905                name = "f75375";
 906        else if (chipid == 0x0204)
 907                name = "f75373";
 908        else if (chipid == 0x0410)
 909                name = "f75387";
 910        else
 911                return -ENODEV;
 912
 913        version = f75375_read8(client, F75375_REG_VERSION);
 914        dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
 915        strlcpy(info->type, name, I2C_NAME_SIZE);
 916
 917        return 0;
 918}
 919
 920module_i2c_driver(f75375_driver);
 921
 922MODULE_AUTHOR("Riku Voipio");
 923MODULE_LICENSE("GPL");
 924MODULE_DESCRIPTION("F75373/F75375/F75387 hardware monitoring driver");
 925
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.