linux/drivers/hwmon/adm1031.c
<<
>>
Prefs
   1/*
   2 * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *             monitoring
   4 * Based on lm75.c and lm85.c
   5 * Supports adm1030 / adm1031
   6 * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
   7 * Reworked by Jean Delvare <khali@linux-fr.org>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2 of the License, or
  12 * (at your option) any later version.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with this program; if not, write to the Free Software
  21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24#include <linux/module.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/jiffies.h>
  28#include <linux/i2c.h>
  29#include <linux/hwmon.h>
  30#include <linux/hwmon-sysfs.h>
  31#include <linux/err.h>
  32#include <linux/mutex.h>
  33
  34/* Following macros takes channel parameter starting from 0 to 2 */
  35#define ADM1031_REG_FAN_SPEED(nr)       (0x08 + (nr))
  36#define ADM1031_REG_FAN_DIV(nr)         (0x20 + (nr))
  37#define ADM1031_REG_PWM                 (0x22)
  38#define ADM1031_REG_FAN_MIN(nr)         (0x10 + (nr))
  39#define ADM1031_REG_FAN_FILTER          (0x23)
  40
  41#define ADM1031_REG_TEMP_OFFSET(nr)     (0x0d + (nr))
  42#define ADM1031_REG_TEMP_MAX(nr)        (0x14 + 4 * (nr))
  43#define ADM1031_REG_TEMP_MIN(nr)        (0x15 + 4 * (nr))
  44#define ADM1031_REG_TEMP_CRIT(nr)       (0x16 + 4 * (nr))
  45
  46#define ADM1031_REG_TEMP(nr)            (0x0a + (nr))
  47#define ADM1031_REG_AUTO_TEMP(nr)       (0x24 + (nr))
  48
  49#define ADM1031_REG_STATUS(nr)          (0x2 + (nr))
  50
  51#define ADM1031_REG_CONF1               0x00
  52#define ADM1031_REG_CONF2               0x01
  53#define ADM1031_REG_EXT_TEMP            0x06
  54
  55#define ADM1031_CONF1_MONITOR_ENABLE    0x01    /* Monitoring enable */
  56#define ADM1031_CONF1_PWM_INVERT        0x08    /* PWM Invert */
  57#define ADM1031_CONF1_AUTO_MODE         0x80    /* Auto FAN */
  58
  59#define ADM1031_CONF2_PWM1_ENABLE       0x01
  60#define ADM1031_CONF2_PWM2_ENABLE       0x02
  61#define ADM1031_CONF2_TACH1_ENABLE      0x04
  62#define ADM1031_CONF2_TACH2_ENABLE      0x08
  63#define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
  64
  65#define ADM1031_UPDATE_RATE_MASK        0x1c
  66#define ADM1031_UPDATE_RATE_SHIFT       2
  67
  68/* Addresses to scan */
  69static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
  70
  71enum chips { adm1030, adm1031 };
  72
  73typedef u8 auto_chan_table_t[8][2];
  74
  75/* Each client has this additional data */
  76struct adm1031_data {
  77        struct device *hwmon_dev;
  78        struct mutex update_lock;
  79        int chip_type;
  80        char valid;             /* !=0 if following fields are valid */
  81        unsigned long last_updated;     /* In jiffies */
  82        unsigned int update_interval;   /* In milliseconds */
  83        /*
  84         * The chan_select_table contains the possible configurations for
  85         * auto fan control.
  86         */
  87        const auto_chan_table_t *chan_select_table;
  88        u16 alarm;
  89        u8 conf1;
  90        u8 conf2;
  91        u8 fan[2];
  92        u8 fan_div[2];
  93        u8 fan_min[2];
  94        u8 pwm[2];
  95        u8 old_pwm[2];
  96        s8 temp[3];
  97        u8 ext_temp[3];
  98        u8 auto_temp[3];
  99        u8 auto_temp_min[3];
 100        u8 auto_temp_off[3];
 101        u8 auto_temp_max[3];
 102        s8 temp_offset[3];
 103        s8 temp_min[3];
 104        s8 temp_max[3];
 105        s8 temp_crit[3];
 106};
 107
 108static int adm1031_probe(struct i2c_client *client,
 109                         const struct i2c_device_id *id);
 110static int adm1031_detect(struct i2c_client *client,
 111                          struct i2c_board_info *info);
 112static void adm1031_init_client(struct i2c_client *client);
 113static int adm1031_remove(struct i2c_client *client);
 114static struct adm1031_data *adm1031_update_device(struct device *dev);
 115
 116static const struct i2c_device_id adm1031_id[] = {
 117        { "adm1030", adm1030 },
 118        { "adm1031", adm1031 },
 119        { }
 120};
 121MODULE_DEVICE_TABLE(i2c, adm1031_id);
 122
 123/* This is the driver that will be inserted */
 124static struct i2c_driver adm1031_driver = {
 125        .class          = I2C_CLASS_HWMON,
 126        .driver = {
 127                .name = "adm1031",
 128        },
 129        .probe          = adm1031_probe,
 130        .remove         = adm1031_remove,
 131        .id_table       = adm1031_id,
 132        .detect         = adm1031_detect,
 133        .address_list   = normal_i2c,
 134};
 135
 136static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
 137{
 138        return i2c_smbus_read_byte_data(client, reg);
 139}
 140
 141static inline int
 142adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
 143{
 144        return i2c_smbus_write_byte_data(client, reg, value);
 145}
 146
 147
 148#define TEMP_TO_REG(val)                (((val) < 0 ? ((val - 500) / 1000) : \
 149                                        ((val + 500) / 1000)))
 150
 151#define TEMP_FROM_REG(val)              ((val) * 1000)
 152
 153#define TEMP_FROM_REG_EXT(val, ext)     (TEMP_FROM_REG(val) + (ext) * 125)
 154
 155#define TEMP_OFFSET_TO_REG(val)         (TEMP_TO_REG(val) & 0x8f)
 156#define TEMP_OFFSET_FROM_REG(val)       TEMP_FROM_REG((val) < 0 ? \
 157                                                      (val) | 0x70 : (val))
 158
 159#define FAN_FROM_REG(reg, div)          ((reg) ? \
 160                                         (11250 * 60) / ((reg) * (div)) : 0)
 161
 162static int FAN_TO_REG(int reg, int div)
 163{
 164        int tmp;
 165        tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
 166        return tmp > 255 ? 255 : tmp;
 167}
 168
 169#define FAN_DIV_FROM_REG(reg)           (1<<(((reg)&0xc0)>>6))
 170
 171#define PWM_TO_REG(val)                 (SENSORS_LIMIT((val), 0, 255) >> 4)
 172#define PWM_FROM_REG(val)               ((val) << 4)
 173
 174#define FAN_CHAN_FROM_REG(reg)          (((reg) >> 5) & 7)
 175#define FAN_CHAN_TO_REG(val, reg)       \
 176        (((reg) & 0x1F) | (((val) << 5) & 0xe0))
 177
 178#define AUTO_TEMP_MIN_TO_REG(val, reg)  \
 179        ((((val) / 500) & 0xf8) | ((reg) & 0x7))
 180#define AUTO_TEMP_RANGE_FROM_REG(reg)   (5000 * (1 << ((reg) & 0x7)))
 181#define AUTO_TEMP_MIN_FROM_REG(reg)     (1000 * ((((reg) >> 3) & 0x1f) << 2))
 182
 183#define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
 184
 185#define AUTO_TEMP_OFF_FROM_REG(reg)             \
 186        (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
 187
 188#define AUTO_TEMP_MAX_FROM_REG(reg)             \
 189        (AUTO_TEMP_RANGE_FROM_REG(reg) +        \
 190        AUTO_TEMP_MIN_FROM_REG(reg))
 191
 192static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
 193{
 194        int ret;
 195        int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
 196
 197        range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
 198        ret = ((reg & 0xf8) |
 199               (range < 10000 ? 0 :
 200                range < 20000 ? 1 :
 201                range < 40000 ? 2 : range < 80000 ? 3 : 4));
 202        return ret;
 203}
 204
 205/* FAN auto control */
 206#define GET_FAN_AUTO_BITFIELD(data, idx)        \
 207        (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
 208
 209/*
 210 * The tables below contains the possible values for the auto fan
 211 * control bitfields. the index in the table is the register value.
 212 * MSb is the auto fan control enable bit, so the four first entries
 213 * in the table disables auto fan control when both bitfields are zero.
 214 */
 215static const auto_chan_table_t auto_channel_select_table_adm1031 = {
 216        { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
 217        { 2 /* 0b010 */ , 4 /* 0b100 */ },
 218        { 2 /* 0b010 */ , 2 /* 0b010 */ },
 219        { 4 /* 0b100 */ , 4 /* 0b100 */ },
 220        { 7 /* 0b111 */ , 7 /* 0b111 */ },
 221};
 222
 223static const auto_chan_table_t auto_channel_select_table_adm1030 = {
 224        { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
 225        { 2 /* 0b10 */          , 0 },
 226        { 0xff /* invalid */    , 0 },
 227        { 0xff /* invalid */    , 0 },
 228        { 3 /* 0b11 */          , 0 },
 229};
 230
 231/*
 232 * That function checks if a bitfield is valid and returns the other bitfield
 233 * nearest match if no exact match where found.
 234 */
 235static int
 236get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
 237{
 238        int i;
 239        int first_match = -1, exact_match = -1;
 240        u8 other_reg_val =
 241            (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
 242
 243        if (val == 0)
 244                return 0;
 245
 246        for (i = 0; i < 8; i++) {
 247                if ((val == (*data->chan_select_table)[i][chan]) &&
 248                    ((*data->chan_select_table)[i][chan ? 0 : 1] ==
 249                     other_reg_val)) {
 250                        /* We found an exact match */
 251                        exact_match = i;
 252                        break;
 253                } else if (val == (*data->chan_select_table)[i][chan] &&
 254                           first_match == -1) {
 255                        /*
 256                         * Save the first match in case of an exact match has
 257                         * not been found
 258                         */
 259                        first_match = i;
 260                }
 261        }
 262
 263        if (exact_match >= 0)
 264                return exact_match;
 265        else if (first_match >= 0)
 266                return first_match;
 267
 268        return -EINVAL;
 269}
 270
 271static ssize_t show_fan_auto_channel(struct device *dev,
 272                                     struct device_attribute *attr, char *buf)
 273{
 274        int nr = to_sensor_dev_attr(attr)->index;
 275        struct adm1031_data *data = adm1031_update_device(dev);
 276        return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
 277}
 278
 279static ssize_t
 280set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
 281                     const char *buf, size_t count)
 282{
 283        struct i2c_client *client = to_i2c_client(dev);
 284        struct adm1031_data *data = i2c_get_clientdata(client);
 285        int nr = to_sensor_dev_attr(attr)->index;
 286        long val;
 287        u8 reg;
 288        int ret;
 289        u8 old_fan_mode;
 290
 291        ret = kstrtol(buf, 10, &val);
 292        if (ret)
 293                return ret;
 294
 295        old_fan_mode = data->conf1;
 296
 297        mutex_lock(&data->update_lock);
 298
 299        ret = get_fan_auto_nearest(data, nr, val, data->conf1);
 300        if (ret < 0) {
 301                mutex_unlock(&data->update_lock);
 302                return ret;
 303        }
 304        reg = ret;
 305        data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
 306        if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
 307            (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
 308                if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
 309                        /*
 310                         * Switch to Auto Fan Mode
 311                         * Save PWM registers
 312                         * Set PWM registers to 33% Both
 313                         */
 314                        data->old_pwm[0] = data->pwm[0];
 315                        data->old_pwm[1] = data->pwm[1];
 316                        adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
 317                } else {
 318                        /* Switch to Manual Mode */
 319                        data->pwm[0] = data->old_pwm[0];
 320                        data->pwm[1] = data->old_pwm[1];
 321                        /* Restore PWM registers */
 322                        adm1031_write_value(client, ADM1031_REG_PWM,
 323                                            data->pwm[0] | (data->pwm[1] << 4));
 324                }
 325        }
 326        data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
 327        adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
 328        mutex_unlock(&data->update_lock);
 329        return count;
 330}
 331
 332static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
 333                show_fan_auto_channel, set_fan_auto_channel, 0);
 334static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
 335                show_fan_auto_channel, set_fan_auto_channel, 1);
 336
 337/* Auto Temps */
 338static ssize_t show_auto_temp_off(struct device *dev,
 339                                  struct device_attribute *attr, char *buf)
 340{
 341        int nr = to_sensor_dev_attr(attr)->index;
 342        struct adm1031_data *data = adm1031_update_device(dev);
 343        return sprintf(buf, "%d\n",
 344                       AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
 345}
 346static ssize_t show_auto_temp_min(struct device *dev,
 347                                  struct device_attribute *attr, char *buf)
 348{
 349        int nr = to_sensor_dev_attr(attr)->index;
 350        struct adm1031_data *data = adm1031_update_device(dev);
 351        return sprintf(buf, "%d\n",
 352                       AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
 353}
 354static ssize_t
 355set_auto_temp_min(struct device *dev, struct device_attribute *attr,
 356                  const char *buf, size_t count)
 357{
 358        struct i2c_client *client = to_i2c_client(dev);
 359        struct adm1031_data *data = i2c_get_clientdata(client);
 360        int nr = to_sensor_dev_attr(attr)->index;
 361        long val;
 362        int ret;
 363
 364        ret = kstrtol(buf, 10, &val);
 365        if (ret)
 366                return ret;
 367
 368        mutex_lock(&data->update_lock);
 369        data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
 370        adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
 371                            data->auto_temp[nr]);
 372        mutex_unlock(&data->update_lock);
 373        return count;
 374}
 375static ssize_t show_auto_temp_max(struct device *dev,
 376                                  struct device_attribute *attr, char *buf)
 377{
 378        int nr = to_sensor_dev_attr(attr)->index;
 379        struct adm1031_data *data = adm1031_update_device(dev);
 380        return sprintf(buf, "%d\n",
 381                       AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
 382}
 383static ssize_t
 384set_auto_temp_max(struct device *dev, struct device_attribute *attr,
 385                  const char *buf, size_t count)
 386{
 387        struct i2c_client *client = to_i2c_client(dev);
 388        struct adm1031_data *data = i2c_get_clientdata(client);
 389        int nr = to_sensor_dev_attr(attr)->index;
 390        long val;
 391        int ret;
 392
 393        ret = kstrtol(buf, 10, &val);
 394        if (ret)
 395                return ret;
 396
 397        mutex_lock(&data->update_lock);
 398        data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
 399                                                  data->pwm[nr]);
 400        adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
 401                            data->temp_max[nr]);
 402        mutex_unlock(&data->update_lock);
 403        return count;
 404}
 405
 406#define auto_temp_reg(offset)                                           \
 407static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO,             \
 408                show_auto_temp_off, NULL, offset - 1);                  \
 409static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR,   \
 410                show_auto_temp_min, set_auto_temp_min, offset - 1);     \
 411static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR,   \
 412                show_auto_temp_max, set_auto_temp_max, offset - 1)
 413
 414auto_temp_reg(1);
 415auto_temp_reg(2);
 416auto_temp_reg(3);
 417
 418/* pwm */
 419static ssize_t show_pwm(struct device *dev,
 420                        struct device_attribute *attr, char *buf)
 421{
 422        int nr = to_sensor_dev_attr(attr)->index;
 423        struct adm1031_data *data = adm1031_update_device(dev);
 424        return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 425}
 426static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 427                       const char *buf, size_t count)
 428{
 429        struct i2c_client *client = to_i2c_client(dev);
 430        struct adm1031_data *data = i2c_get_clientdata(client);
 431        int nr = to_sensor_dev_attr(attr)->index;
 432        long val;
 433        int ret, reg;
 434
 435        ret = kstrtol(buf, 10, &val);
 436        if (ret)
 437                return ret;
 438
 439        mutex_lock(&data->update_lock);
 440        if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
 441            (((val>>4) & 0xf) != 5)) {
 442                /* In automatic mode, the only PWM accepted is 33% */
 443                mutex_unlock(&data->update_lock);
 444                return -EINVAL;
 445        }
 446        data->pwm[nr] = PWM_TO_REG(val);
 447        reg = adm1031_read_value(client, ADM1031_REG_PWM);
 448        adm1031_write_value(client, ADM1031_REG_PWM,
 449                            nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
 450                            : (data->pwm[nr] & 0xf) | (reg & 0xf0));
 451        mutex_unlock(&data->update_lock);
 452        return count;
 453}
 454
 455static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
 456static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
 457static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
 458                show_pwm, set_pwm, 0);
 459static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
 460                show_pwm, set_pwm, 1);
 461
 462/* Fans */
 463
 464/*
 465 * That function checks the cases where the fan reading is not
 466 * relevant.  It is used to provide 0 as fan reading when the fan is
 467 * not supposed to run
 468 */
 469static int trust_fan_readings(struct adm1031_data *data, int chan)
 470{
 471        int res = 0;
 472
 473        if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
 474                switch (data->conf1 & 0x60) {
 475                case 0x00:
 476                        /*
 477                         * remote temp1 controls fan1,
 478                         * remote temp2 controls fan2
 479                         */
 480                        res = data->temp[chan+1] >=
 481                            AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
 482                        break;
 483                case 0x20:      /* remote temp1 controls both fans */
 484                        res =
 485                            data->temp[1] >=
 486                            AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
 487                        break;
 488                case 0x40:      /* remote temp2 controls both fans */
 489                        res =
 490                            data->temp[2] >=
 491                            AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
 492                        break;
 493                case 0x60:      /* max controls both fans */
 494                        res =
 495                            data->temp[0] >=
 496                            AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
 497                            || data->temp[1] >=
 498                            AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
 499                            || (data->chip_type == adm1031
 500                                && data->temp[2] >=
 501                                AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
 502                        break;
 503                }
 504        } else {
 505                res = data->pwm[chan] > 0;
 506        }
 507        return res;
 508}
 509
 510
 511static ssize_t show_fan(struct device *dev,
 512                        struct device_attribute *attr, char *buf)
 513{
 514        int nr = to_sensor_dev_attr(attr)->index;
 515        struct adm1031_data *data = adm1031_update_device(dev);
 516        int value;
 517
 518        value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
 519                                 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
 520        return sprintf(buf, "%d\n", value);
 521}
 522
 523static ssize_t show_fan_div(struct device *dev,
 524                            struct device_attribute *attr, char *buf)
 525{
 526        int nr = to_sensor_dev_attr(attr)->index;
 527        struct adm1031_data *data = adm1031_update_device(dev);
 528        return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
 529}
 530static ssize_t show_fan_min(struct device *dev,
 531                            struct device_attribute *attr, char *buf)
 532{
 533        int nr = to_sensor_dev_attr(attr)->index;
 534        struct adm1031_data *data = adm1031_update_device(dev);
 535        return sprintf(buf, "%d\n",
 536                       FAN_FROM_REG(data->fan_min[nr],
 537                                    FAN_DIV_FROM_REG(data->fan_div[nr])));
 538}
 539static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 540                           const char *buf, size_t count)
 541{
 542        struct i2c_client *client = to_i2c_client(dev);
 543        struct adm1031_data *data = i2c_get_clientdata(client);
 544        int nr = to_sensor_dev_attr(attr)->index;
 545        long val;
 546        int ret;
 547
 548        ret = kstrtol(buf, 10, &val);
 549        if (ret)
 550                return ret;
 551
 552        mutex_lock(&data->update_lock);
 553        if (val) {
 554                data->fan_min[nr] =
 555                        FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
 556        } else {
 557                data->fan_min[nr] = 0xff;
 558        }
 559        adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
 560        mutex_unlock(&data->update_lock);
 561        return count;
 562}
 563static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 564                           const char *buf, size_t count)
 565{
 566        struct i2c_client *client = to_i2c_client(dev);
 567        struct adm1031_data *data = i2c_get_clientdata(client);
 568        int nr = to_sensor_dev_attr(attr)->index;
 569        long val;
 570        u8 tmp;
 571        int old_div;
 572        int new_min;
 573        int ret;
 574
 575        ret = kstrtol(buf, 10, &val);
 576        if (ret)
 577                return ret;
 578
 579        tmp = val == 8 ? 0xc0 :
 580              val == 4 ? 0x80 :
 581              val == 2 ? 0x40 :
 582              val == 1 ? 0x00 :
 583              0xff;
 584        if (tmp == 0xff)
 585                return -EINVAL;
 586
 587        mutex_lock(&data->update_lock);
 588        /* Get fresh readings */
 589        data->fan_div[nr] = adm1031_read_value(client,
 590                                               ADM1031_REG_FAN_DIV(nr));
 591        data->fan_min[nr] = adm1031_read_value(client,
 592                                               ADM1031_REG_FAN_MIN(nr));
 593
 594        /* Write the new clock divider and fan min */
 595        old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
 596        data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
 597        new_min = data->fan_min[nr] * old_div / val;
 598        data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
 599
 600        adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
 601                            data->fan_div[nr]);
 602        adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
 603                            data->fan_min[nr]);
 604
 605        /* Invalidate the cache: fan speed is no longer valid */
 606        data->valid = 0;
 607        mutex_unlock(&data->update_lock);
 608        return count;
 609}
 610
 611#define fan_offset(offset)                                              \
 612static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
 613                show_fan, NULL, offset - 1);                            \
 614static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 615                show_fan_min, set_fan_min, offset - 1);                 \
 616static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
 617                show_fan_div, set_fan_div, offset - 1)
 618
 619fan_offset(1);
 620fan_offset(2);
 621
 622
 623/* Temps */
 624static ssize_t show_temp(struct device *dev,
 625                         struct device_attribute *attr, char *buf)
 626{
 627        int nr = to_sensor_dev_attr(attr)->index;
 628        struct adm1031_data *data = adm1031_update_device(dev);
 629        int ext;
 630        ext = nr == 0 ?
 631            ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
 632            (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
 633        return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
 634}
 635static ssize_t show_temp_offset(struct device *dev,
 636                                struct device_attribute *attr, char *buf)
 637{
 638        int nr = to_sensor_dev_attr(attr)->index;
 639        struct adm1031_data *data = adm1031_update_device(dev);
 640        return sprintf(buf, "%d\n",
 641                       TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
 642}
 643static ssize_t show_temp_min(struct device *dev,
 644                             struct device_attribute *attr, char *buf)
 645{
 646        int nr = to_sensor_dev_attr(attr)->index;
 647        struct adm1031_data *data = adm1031_update_device(dev);
 648        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 649}
 650static ssize_t show_temp_max(struct device *dev,
 651                             struct device_attribute *attr, char *buf)
 652{
 653        int nr = to_sensor_dev_attr(attr)->index;
 654        struct adm1031_data *data = adm1031_update_device(dev);
 655        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 656}
 657static ssize_t show_temp_crit(struct device *dev,
 658                              struct device_attribute *attr, char *buf)
 659{
 660        int nr = to_sensor_dev_attr(attr)->index;
 661        struct adm1031_data *data = adm1031_update_device(dev);
 662        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
 663}
 664static ssize_t set_temp_offset(struct device *dev,
 665                               struct device_attribute *attr, const char *buf,
 666                               size_t count)
 667{
 668        struct i2c_client *client = to_i2c_client(dev);
 669        struct adm1031_data *data = i2c_get_clientdata(client);
 670        int nr = to_sensor_dev_attr(attr)->index;
 671        long val;
 672        int ret;
 673
 674        ret = kstrtol(buf, 10, &val);
 675        if (ret)
 676                return ret;
 677
 678        val = SENSORS_LIMIT(val, -15000, 15000);
 679        mutex_lock(&data->update_lock);
 680        data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
 681        adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
 682                            data->temp_offset[nr]);
 683        mutex_unlock(&data->update_lock);
 684        return count;
 685}
 686static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 687                            const char *buf, size_t count)
 688{
 689        struct i2c_client *client = to_i2c_client(dev);
 690        struct adm1031_data *data = i2c_get_clientdata(client);
 691        int nr = to_sensor_dev_attr(attr)->index;
 692        long val;
 693        int ret;
 694
 695        ret = kstrtol(buf, 10, &val);
 696        if (ret)
 697                return ret;
 698
 699        val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
 700        mutex_lock(&data->update_lock);
 701        data->temp_min[nr] = TEMP_TO_REG(val);
 702        adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
 703                            data->temp_min[nr]);
 704        mutex_unlock(&data->update_lock);
 705        return count;
 706}
 707static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 708                            const char *buf, size_t count)
 709{
 710        struct i2c_client *client = to_i2c_client(dev);
 711        struct adm1031_data *data = i2c_get_clientdata(client);
 712        int nr = to_sensor_dev_attr(attr)->index;
 713        long val;
 714        int ret;
 715
 716        ret = kstrtol(buf, 10, &val);
 717        if (ret)
 718                return ret;
 719
 720        val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
 721        mutex_lock(&data->update_lock);
 722        data->temp_max[nr] = TEMP_TO_REG(val);
 723        adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
 724                            data->temp_max[nr]);
 725        mutex_unlock(&data->update_lock);
 726        return count;
 727}
 728static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
 729                             const char *buf, size_t count)
 730{
 731        struct i2c_client *client = to_i2c_client(dev);
 732        struct adm1031_data *data = i2c_get_clientdata(client);
 733        int nr = to_sensor_dev_attr(attr)->index;
 734        long val;
 735        int ret;
 736
 737        ret = kstrtol(buf, 10, &val);
 738        if (ret)
 739                return ret;
 740
 741        val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
 742        mutex_lock(&data->update_lock);
 743        data->temp_crit[nr] = TEMP_TO_REG(val);
 744        adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
 745                            data->temp_crit[nr]);
 746        mutex_unlock(&data->update_lock);
 747        return count;
 748}
 749
 750#define temp_reg(offset)                                                \
 751static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 752                show_temp, NULL, offset - 1);                           \
 753static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR,     \
 754                show_temp_offset, set_temp_offset, offset - 1);         \
 755static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
 756                show_temp_min, set_temp_min, offset - 1);               \
 757static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 758                show_temp_max, set_temp_max, offset - 1);               \
 759static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR,       \
 760                show_temp_crit, set_temp_crit, offset - 1)
 761
 762temp_reg(1);
 763temp_reg(2);
 764temp_reg(3);
 765
 766/* Alarms */
 767static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
 768                           char *buf)
 769{
 770        struct adm1031_data *data = adm1031_update_device(dev);
 771        return sprintf(buf, "%d\n", data->alarm);
 772}
 773
 774static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 775
 776static ssize_t show_alarm(struct device *dev,
 777                          struct device_attribute *attr, char *buf)
 778{
 779        int bitnr = to_sensor_dev_attr(attr)->index;
 780        struct adm1031_data *data = adm1031_update_device(dev);
 781        return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
 782}
 783
 784static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
 785static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
 786static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
 787static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 788static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
 789static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
 790static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 791static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
 792static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
 793static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
 794static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
 795static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
 796static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
 797static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
 798static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
 799
 800/* Update Interval */
 801static const unsigned int update_intervals[] = {
 802        16000, 8000, 4000, 2000, 1000, 500, 250, 125,
 803};
 804
 805static ssize_t show_update_interval(struct device *dev,
 806                                    struct device_attribute *attr, char *buf)
 807{
 808        struct i2c_client *client = to_i2c_client(dev);
 809        struct adm1031_data *data = i2c_get_clientdata(client);
 810
 811        return sprintf(buf, "%u\n", data->update_interval);
 812}
 813
 814static ssize_t set_update_interval(struct device *dev,
 815                                   struct device_attribute *attr,
 816                                   const char *buf, size_t count)
 817{
 818        struct i2c_client *client = to_i2c_client(dev);
 819        struct adm1031_data *data = i2c_get_clientdata(client);
 820        unsigned long val;
 821        int i, err;
 822        u8 reg;
 823
 824        err = kstrtoul(buf, 10, &val);
 825        if (err)
 826                return err;
 827
 828        /*
 829         * Find the nearest update interval from the table.
 830         * Use it to determine the matching update rate.
 831         */
 832        for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
 833                if (val >= update_intervals[i])
 834                        break;
 835        }
 836        /* if not found, we point to the last entry (lowest update interval) */
 837
 838        /* set the new update rate while preserving other settings */
 839        reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
 840        reg &= ~ADM1031_UPDATE_RATE_MASK;
 841        reg |= i << ADM1031_UPDATE_RATE_SHIFT;
 842        adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
 843
 844        mutex_lock(&data->update_lock);
 845        data->update_interval = update_intervals[i];
 846        mutex_unlock(&data->update_lock);
 847
 848        return count;
 849}
 850
 851static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
 852                   set_update_interval);
 853
 854static struct attribute *adm1031_attributes[] = {
 855        &sensor_dev_attr_fan1_input.dev_attr.attr,
 856        &sensor_dev_attr_fan1_div.dev_attr.attr,
 857        &sensor_dev_attr_fan1_min.dev_attr.attr,
 858        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 859        &sensor_dev_attr_fan1_fault.dev_attr.attr,
 860        &sensor_dev_attr_pwm1.dev_attr.attr,
 861        &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
 862        &sensor_dev_attr_temp1_input.dev_attr.attr,
 863        &sensor_dev_attr_temp1_offset.dev_attr.attr,
 864        &sensor_dev_attr_temp1_min.dev_attr.attr,
 865        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 866        &sensor_dev_attr_temp1_max.dev_attr.attr,
 867        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 868        &sensor_dev_attr_temp1_crit.dev_attr.attr,
 869        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 870        &sensor_dev_attr_temp2_input.dev_attr.attr,
 871        &sensor_dev_attr_temp2_offset.dev_attr.attr,
 872        &sensor_dev_attr_temp2_min.dev_attr.attr,
 873        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 874        &sensor_dev_attr_temp2_max.dev_attr.attr,
 875        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 876        &sensor_dev_attr_temp2_crit.dev_attr.attr,
 877        &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 878        &sensor_dev_attr_temp2_fault.dev_attr.attr,
 879
 880        &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
 881        &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
 882        &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
 883
 884        &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
 885        &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
 886        &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
 887
 888        &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
 889
 890        &dev_attr_update_interval.attr,
 891        &dev_attr_alarms.attr,
 892
 893        NULL
 894};
 895
 896static const struct attribute_group adm1031_group = {
 897        .attrs = adm1031_attributes,
 898};
 899
 900static struct attribute *adm1031_attributes_opt[] = {
 901        &sensor_dev_attr_fan2_input.dev_attr.attr,
 902        &sensor_dev_attr_fan2_div.dev_attr.attr,
 903        &sensor_dev_attr_fan2_min.dev_attr.attr,
 904        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 905        &sensor_dev_attr_fan2_fault.dev_attr.attr,
 906        &sensor_dev_attr_pwm2.dev_attr.attr,
 907        &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
 908        &sensor_dev_attr_temp3_input.dev_attr.attr,
 909        &sensor_dev_attr_temp3_offset.dev_attr.attr,
 910        &sensor_dev_attr_temp3_min.dev_attr.attr,
 911        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 912        &sensor_dev_attr_temp3_max.dev_attr.attr,
 913        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 914        &sensor_dev_attr_temp3_crit.dev_attr.attr,
 915        &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
 916        &sensor_dev_attr_temp3_fault.dev_attr.attr,
 917        &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
 918        &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
 919        &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
 920        &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
 921        NULL
 922};
 923
 924static const struct attribute_group adm1031_group_opt = {
 925        .attrs = adm1031_attributes_opt,
 926};
 927
 928/* Return 0 if detection is successful, -ENODEV otherwise */
 929static int adm1031_detect(struct i2c_client *client,
 930                          struct i2c_board_info *info)
 931{
 932        struct i2c_adapter *adapter = client->adapter;
 933        const char *name;
 934        int id, co;
 935
 936        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 937                return -ENODEV;
 938
 939        id = i2c_smbus_read_byte_data(client, 0x3d);
 940        co = i2c_smbus_read_byte_data(client, 0x3e);
 941
 942        if (!((id == 0x31 || id == 0x30) && co == 0x41))
 943                return -ENODEV;
 944        name = (id == 0x30) ? "adm1030" : "adm1031";
 945
 946        strlcpy(info->type, name, I2C_NAME_SIZE);
 947
 948        return 0;
 949}
 950
 951static int adm1031_probe(struct i2c_client *client,
 952                         const struct i2c_device_id *id)
 953{
 954        struct adm1031_data *data;
 955        int err;
 956
 957        data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data),
 958                            GFP_KERNEL);
 959        if (!data)
 960                return -ENOMEM;
 961
 962        i2c_set_clientdata(client, data);
 963        data->chip_type = id->driver_data;
 964        mutex_init(&data->update_lock);
 965
 966        if (data->chip_type == adm1030)
 967                data->chan_select_table = &auto_channel_select_table_adm1030;
 968        else
 969                data->chan_select_table = &auto_channel_select_table_adm1031;
 970
 971        /* Initialize the ADM1031 chip */
 972        adm1031_init_client(client);
 973
 974        /* Register sysfs hooks */
 975        err = sysfs_create_group(&client->dev.kobj, &adm1031_group);
 976        if (err)
 977                return err;
 978
 979        if (data->chip_type == adm1031) {
 980                err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt);
 981                if (err)
 982                        goto exit_remove;
 983        }
 984
 985        data->hwmon_dev = hwmon_device_register(&client->dev);
 986        if (IS_ERR(data->hwmon_dev)) {
 987                err = PTR_ERR(data->hwmon_dev);
 988                goto exit_remove;
 989        }
 990
 991        return 0;
 992
 993exit_remove:
 994        sysfs_remove_group(&client->dev.kobj, &adm1031_group);
 995        sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
 996        return err;
 997}
 998
 999static int adm1031_remove(struct i2c_client *client)
1000{
1001        struct adm1031_data *data = i2c_get_clientdata(client);
1002
1003        hwmon_device_unregister(data->hwmon_dev);
1004        sysfs_remove_group(&client->dev.kobj, &adm1031_group);
1005        sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
1006        return 0;
1007}
1008
1009static void adm1031_init_client(struct i2c_client *client)
1010{
1011        unsigned int read_val;
1012        unsigned int mask;
1013        int i;
1014        struct adm1031_data *data = i2c_get_clientdata(client);
1015
1016        mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1017        if (data->chip_type == adm1031) {
1018                mask |= (ADM1031_CONF2_PWM2_ENABLE |
1019                        ADM1031_CONF2_TACH2_ENABLE);
1020        }
1021        /* Initialize the ADM1031 chip (enables fan speed reading ) */
1022        read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1023        if ((read_val | mask) != read_val)
1024                adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1025
1026        read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1027        if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1028                adm1031_write_value(client, ADM1031_REG_CONF1,
1029                                    read_val | ADM1031_CONF1_MONITOR_ENABLE);
1030        }
1031
1032        /* Read the chip's update rate */
1033        mask = ADM1031_UPDATE_RATE_MASK;
1034        read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1035        i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1036        /* Save it as update interval */
1037        data->update_interval = update_intervals[i];
1038}
1039
1040static struct adm1031_data *adm1031_update_device(struct device *dev)
1041{
1042        struct i2c_client *client = to_i2c_client(dev);
1043        struct adm1031_data *data = i2c_get_clientdata(client);
1044        unsigned long next_update;
1045        int chan;
1046
1047        mutex_lock(&data->update_lock);
1048
1049        next_update = data->last_updated
1050          + msecs_to_jiffies(data->update_interval);
1051        if (time_after(jiffies, next_update) || !data->valid) {
1052
1053                dev_dbg(&client->dev, "Starting adm1031 update\n");
1054                for (chan = 0;
1055                     chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1056                        u8 oldh, newh;
1057
1058                        oldh =
1059                            adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1060                        data->ext_temp[chan] =
1061                            adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1062                        newh =
1063                            adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1064                        if (newh != oldh) {
1065                                data->ext_temp[chan] =
1066                                    adm1031_read_value(client,
1067                                                       ADM1031_REG_EXT_TEMP);
1068#ifdef DEBUG
1069                                oldh =
1070                                    adm1031_read_value(client,
1071                                                       ADM1031_REG_TEMP(chan));
1072
1073                                /* oldh is actually newer */
1074                                if (newh != oldh)
1075                                        dev_warn(&client->dev,
1076                                          "Remote temperature may be wrong.\n");
1077#endif
1078                        }
1079                        data->temp[chan] = newh;
1080
1081                        data->temp_offset[chan] =
1082                            adm1031_read_value(client,
1083                                               ADM1031_REG_TEMP_OFFSET(chan));
1084                        data->temp_min[chan] =
1085                            adm1031_read_value(client,
1086                                               ADM1031_REG_TEMP_MIN(chan));
1087                        data->temp_max[chan] =
1088                            adm1031_read_value(client,
1089                                               ADM1031_REG_TEMP_MAX(chan));
1090                        data->temp_crit[chan] =
1091                            adm1031_read_value(client,
1092                                               ADM1031_REG_TEMP_CRIT(chan));
1093                        data->auto_temp[chan] =
1094                            adm1031_read_value(client,
1095                                               ADM1031_REG_AUTO_TEMP(chan));
1096
1097                }
1098
1099                data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1100                data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1101
1102                data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1103                    | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
1104                if (data->chip_type == adm1030)
1105                        data->alarm &= 0xc0ff;
1106
1107                for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
1108                     chan++) {
1109                        data->fan_div[chan] =
1110                            adm1031_read_value(client,
1111                                               ADM1031_REG_FAN_DIV(chan));
1112                        data->fan_min[chan] =
1113                            adm1031_read_value(client,
1114                                               ADM1031_REG_FAN_MIN(chan));
1115                        data->fan[chan] =
1116                            adm1031_read_value(client,
1117                                               ADM1031_REG_FAN_SPEED(chan));
1118                        data->pwm[chan] =
1119                          (adm1031_read_value(client,
1120                                        ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
1121                }
1122                data->last_updated = jiffies;
1123                data->valid = 1;
1124        }
1125
1126        mutex_unlock(&data->update_lock);
1127
1128        return data;
1129}
1130
1131module_i2c_driver(adm1031_driver);
1132
1133MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1134MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1135MODULE_LICENSE("GPL");
1136
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.