drivers/hwmon/adm1031.c

   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 */
  69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
  70
  71 enum chips { adm1030, adm1031 };
  72
  73 typedef u8 auto_chan_table_t[8][2];
  74
  75 /* Each client has this additional data */
  76 struct 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
 108 static int adm1031_probe(struct i2c_client *client,
 109                          const struct i2c_device_id *id);
 110 static int adm1031_detect(struct i2c_client *client,
 111                           struct i2c_board_info *info);
 112 static void adm1031_init_client(struct i2c_client *client);
 113 static int adm1031_remove(struct i2c_client *client);
 114 static struct adm1031_data *adm1031_update_device(struct device *dev);
 115
 116 static const struct i2c_device_id adm1031_id[] = {
 117         { "adm1030", adm1030 },
 118         { "adm1031", adm1031 },
 119         { }
 120 };
 121 MODULE_DEVICE_TABLE(i2c, adm1031_id);
 122
 123 /* This is the driver that will be inserted */
 124 static 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
 136 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
 137 {
 138         return i2c_smbus_read_byte_data(client, reg);
 139 }
 140
 141 static inline int
 142 adm1031_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
 162 static int FAN_TO_REG(int reg, int div)
 163 {
 164         int tmp;
 165         tmp = FAN_FROM_REG(clamp_val(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)                 (clamp_val((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
 192 static 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  */
 215 static 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
 223 static 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  */
 235 static int
 236 get_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
 271 static 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
 279 static ssize_t
 280 set_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
 332 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
 333                 show_fan_auto_channel, set_fan_auto_channel, 0);
 334 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
 335                 show_fan_auto_channel, set_fan_auto_channel, 1);
 336
 337 /* Auto Temps */
 338 static 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 }
 346 static 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 }
 354 static ssize_t
 355 set_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         val = clamp_val(val, 0, 127000);
 369         mutex_lock(&data->update_lock);
 370         data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
 371         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
 372                             data->auto_temp[nr]);
 373         mutex_unlock(&data->update_lock);
 374         return count;
 375 }
 376 static ssize_t show_auto_temp_max(struct device *dev,
 377                                   struct device_attribute *attr, char *buf)
 378 {
 379         int nr = to_sensor_dev_attr(attr)->index;
 380         struct adm1031_data *data = adm1031_update_device(dev);
 381         return sprintf(buf, "%d\n",
 382                        AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
 383 }
 384 static ssize_t
 385 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
 386                   const char *buf, size_t count)
 387 {
 388         struct i2c_client *client = to_i2c_client(dev);
 389         struct adm1031_data *data = i2c_get_clientdata(client);
 390         int nr = to_sensor_dev_attr(attr)->index;
 391         long val;
 392         int ret;
 393
 394         ret = kstrtol(buf, 10, &val);
 395         if (ret)
 396                 return ret;
 397
 398         val = clamp_val(val, 0, 127000);
 399         mutex_lock(&data->update_lock);
 400         data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
 401                                                   data->pwm[nr]);
 402         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
 403                             data->temp_max[nr]);
 404         mutex_unlock(&data->update_lock);
 405         return count;
 406 }
 407
 408 #define auto_temp_reg(offset)                                           \
 409 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO,             \
 410                 show_auto_temp_off, NULL, offset - 1);                  \
 411 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR,   \
 412                 show_auto_temp_min, set_auto_temp_min, offset - 1);     \
 413 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR,   \
 414                 show_auto_temp_max, set_auto_temp_max, offset - 1)
 415
 416 auto_temp_reg(1);
 417 auto_temp_reg(2);
 418 auto_temp_reg(3);
 419
 420 /* pwm */
 421 static ssize_t show_pwm(struct device *dev,
 422                         struct device_attribute *attr, char *buf)
 423 {
 424         int nr = to_sensor_dev_attr(attr)->index;
 425         struct adm1031_data *data = adm1031_update_device(dev);
 426         return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 427 }
 428 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 429                        const char *buf, size_t count)
 430 {
 431         struct i2c_client *client = to_i2c_client(dev);
 432         struct adm1031_data *data = i2c_get_clientdata(client);
 433         int nr = to_sensor_dev_attr(attr)->index;
 434         long val;
 435         int ret, reg;
 436
 437         ret = kstrtol(buf, 10, &val);
 438         if (ret)
 439                 return ret;
 440
 441         mutex_lock(&data->update_lock);
 442         if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
 443             (((val>>4) & 0xf) != 5)) {
 444                 /* In automatic mode, the only PWM accepted is 33% */
 445                 mutex_unlock(&data->update_lock);
 446                 return -EINVAL;
 447         }
 448         data->pwm[nr] = PWM_TO_REG(val);
 449         reg = adm1031_read_value(client, ADM1031_REG_PWM);
 450         adm1031_write_value(client, ADM1031_REG_PWM,
 451                             nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
 452                             : (data->pwm[nr] & 0xf) | (reg & 0xf0));
 453         mutex_unlock(&data->update_lock);
 454         return count;
 455 }
 456
 457 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
 458 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
 459 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
 460                 show_pwm, set_pwm, 0);
 461 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
 462                 show_pwm, set_pwm, 1);
 463
 464 /* Fans */
 465
 466 /*
 467  * That function checks the cases where the fan reading is not
 468  * relevant.  It is used to provide 0 as fan reading when the fan is
 469  * not supposed to run
 470  */
 471 static int trust_fan_readings(struct adm1031_data *data, int chan)
 472 {
 473         int res = 0;
 474
 475         if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
 476                 switch (data->conf1 & 0x60) {
 477                 case 0x00:
 478                         /*
 479                          * remote temp1 controls fan1,
 480                          * remote temp2 controls fan2
 481                          */
 482                         res = data->temp[chan+1] >=
 483                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
 484                         break;
 485                 case 0x20:      /* remote temp1 controls both fans */
 486                         res =
 487                             data->temp[1] >=
 488                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
 489                         break;
 490                 case 0x40:      /* remote temp2 controls both fans */
 491                         res =
 492                             data->temp[2] >=
 493                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
 494                         break;
 495                 case 0x60:      /* max controls both fans */
 496                         res =
 497                             data->temp[0] >=
 498                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
 499                             || data->temp[1] >=
 500                             AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
 501                             || (data->chip_type == adm1031
 502                                 && data->temp[2] >=
 503                                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
 504                         break;
 505                 }
 506         } else {
 507                 res = data->pwm[chan] > 0;
 508         }
 509         return res;
 510 }
 511
 512
 513 static ssize_t show_fan(struct device *dev,
 514                         struct device_attribute *attr, char *buf)
 515 {
 516         int nr = to_sensor_dev_attr(attr)->index;
 517         struct adm1031_data *data = adm1031_update_device(dev);
 518         int value;
 519
 520         value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
 521                                  FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
 522         return sprintf(buf, "%d\n", value);
 523 }
 524
 525 static ssize_t show_fan_div(struct device *dev,
 526                             struct device_attribute *attr, char *buf)
 527 {
 528         int nr = to_sensor_dev_attr(attr)->index;
 529         struct adm1031_data *data = adm1031_update_device(dev);
 530         return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
 531 }
 532 static ssize_t show_fan_min(struct device *dev,
 533                             struct device_attribute *attr, char *buf)
 534 {
 535         int nr = to_sensor_dev_attr(attr)->index;
 536         struct adm1031_data *data = adm1031_update_device(dev);
 537         return sprintf(buf, "%d\n",
 538                        FAN_FROM_REG(data->fan_min[nr],
 539                                     FAN_DIV_FROM_REG(data->fan_div[nr])));
 540 }
 541 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 542                            const char *buf, size_t count)
 543 {
 544         struct i2c_client *client = to_i2c_client(dev);
 545         struct adm1031_data *data = i2c_get_clientdata(client);
 546         int nr = to_sensor_dev_attr(attr)->index;
 547         long val;
 548         int ret;
 549
 550         ret = kstrtol(buf, 10, &val);
 551         if (ret)
 552                 return ret;
 553
 554         mutex_lock(&data->update_lock);
 555         if (val) {
 556                 data->fan_min[nr] =
 557                         FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
 558         } else {
 559                 data->fan_min[nr] = 0xff;
 560         }
 561         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
 562         mutex_unlock(&data->update_lock);
 563         return count;
 564 }
 565 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 566                            const char *buf, size_t count)
 567 {
 568         struct i2c_client *client = to_i2c_client(dev);
 569         struct adm1031_data *data = i2c_get_clientdata(client);
 570         int nr = to_sensor_dev_attr(attr)->index;
 571         long val;
 572         u8 tmp;
 573         int old_div;
 574         int new_min;
 575         int ret;
 576
 577         ret = kstrtol(buf, 10, &val);
 578         if (ret)
 579                 return ret;
 580
 581         tmp = val == 8 ? 0xc0 :
 582               val == 4 ? 0x80 :
 583               val == 2 ? 0x40 :
 584               val == 1 ? 0x00 :
 585               0xff;
 586         if (tmp == 0xff)
 587                 return -EINVAL;
 588
 589         mutex_lock(&data->update_lock);
 590         /* Get fresh readings */
 591         data->fan_div[nr] = adm1031_read_value(client,
 592                                                ADM1031_REG_FAN_DIV(nr));
 593         data->fan_min[nr] = adm1031_read_value(client,
 594                                                ADM1031_REG_FAN_MIN(nr));
 595
 596         /* Write the new clock divider and fan min */
 597         old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
 598         data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
 599         new_min = data->fan_min[nr] * old_div / val;
 600         data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
 601
 602         adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
 603                             data->fan_div[nr]);
 604         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
 605                             data->fan_min[nr]);
 606
 607         /* Invalidate the cache: fan speed is no longer valid */
 608         data->valid = 0;
 609         mutex_unlock(&data->update_lock);
 610         return count;
 611 }
 612
 613 #define fan_offset(offset)                                              \
 614 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
 615                 show_fan, NULL, offset - 1);                            \
 616 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 617                 show_fan_min, set_fan_min, offset - 1);                 \
 618 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
 619                 show_fan_div, set_fan_div, offset - 1)
 620
 621 fan_offset(1);
 622 fan_offset(2);
 623
 624
 625 /* Temps */
 626 static ssize_t show_temp(struct device *dev,
 627                          struct device_attribute *attr, char *buf)
 628 {
 629         int nr = to_sensor_dev_attr(attr)->index;
 630         struct adm1031_data *data = adm1031_update_device(dev);
 631         int ext;
 632         ext = nr == 0 ?
 633             ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
 634             (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
 635         return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
 636 }
 637 static ssize_t show_temp_offset(struct device *dev,
 638                                 struct device_attribute *attr, char *buf)
 639 {
 640         int nr = to_sensor_dev_attr(attr)->index;
 641         struct adm1031_data *data = adm1031_update_device(dev);
 642         return sprintf(buf, "%d\n",
 643                        TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
 644 }
 645 static ssize_t show_temp_min(struct device *dev,
 646                              struct device_attribute *attr, char *buf)
 647 {
 648         int nr = to_sensor_dev_attr(attr)->index;
 649         struct adm1031_data *data = adm1031_update_device(dev);
 650         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 651 }
 652 static ssize_t show_temp_max(struct device *dev,
 653                              struct device_attribute *attr, char *buf)
 654 {
 655         int nr = to_sensor_dev_attr(attr)->index;
 656         struct adm1031_data *data = adm1031_update_device(dev);
 657         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 658 }
 659 static ssize_t show_temp_crit(struct device *dev,
 660                               struct device_attribute *attr, char *buf)
 661 {
 662         int nr = to_sensor_dev_attr(attr)->index;
 663         struct adm1031_data *data = adm1031_update_device(dev);
 664         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
 665 }
 666 static ssize_t set_temp_offset(struct device *dev,
 667                                struct device_attribute *attr, const char *buf,
 668                                size_t count)
 669 {
 670         struct i2c_client *client = to_i2c_client(dev);
 671         struct adm1031_data *data = i2c_get_clientdata(client);
 672         int nr = to_sensor_dev_attr(attr)->index;
 673         long val;
 674         int ret;
 675
 676         ret = kstrtol(buf, 10, &val);
 677         if (ret)
 678                 return ret;
 679
 680         val = clamp_val(val, -15000, 15000);
 681         mutex_lock(&data->update_lock);
 682         data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
 683         adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
 684                             data->temp_offset[nr]);
 685         mutex_unlock(&data->update_lock);
 686         return count;
 687 }
 688 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 689                             const char *buf, size_t count)
 690 {
 691         struct i2c_client *client = to_i2c_client(dev);
 692         struct adm1031_data *data = i2c_get_clientdata(client);
 693         int nr = to_sensor_dev_attr(attr)->index;
 694         long val;
 695         int ret;
 696
 697         ret = kstrtol(buf, 10, &val);
 698         if (ret)
 699                 return ret;
 700
 701         val = clamp_val(val, -55000, 127000);
 702         mutex_lock(&data->update_lock);
 703         data->temp_min[nr] = TEMP_TO_REG(val);
 704         adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
 705                             data->temp_min[nr]);
 706         mutex_unlock(&data->update_lock);
 707         return count;
 708 }
 709 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 710                             const char *buf, size_t count)
 711 {
 712         struct i2c_client *client = to_i2c_client(dev);
 713         struct adm1031_data *data = i2c_get_clientdata(client);
 714         int nr = to_sensor_dev_attr(attr)->index;
 715         long val;
 716         int ret;
 717
 718         ret = kstrtol(buf, 10, &val);
 719         if (ret)
 720                 return ret;
 721
 722         val = clamp_val(val, -55000, 127000);
 723         mutex_lock(&data->update_lock);
 724         data->temp_max[nr] = TEMP_TO_REG(val);
 725         adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
 726                             data->temp_max[nr]);
 727         mutex_unlock(&data->update_lock);
 728         return count;
 729 }
 730 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
 731                              const char *buf, size_t count)
 732 {
 733         struct i2c_client *client = to_i2c_client(dev);
 734         struct adm1031_data *data = i2c_get_clientdata(client);
 735         int nr = to_sensor_dev_attr(attr)->index;
 736         long val;
 737         int ret;
 738
 739         ret = kstrtol(buf, 10, &val);
 740         if (ret)
 741                 return ret;
 742
 743         val = clamp_val(val, -55000, 127000);
 744         mutex_lock(&data->update_lock);
 745         data->temp_crit[nr] = TEMP_TO_REG(val);
 746         adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
 747                             data->temp_crit[nr]);
 748         mutex_unlock(&data->update_lock);
 749         return count;
 750 }
 751
 752 #define temp_reg(offset)                                                \
 753 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 754                 show_temp, NULL, offset - 1);                           \
 755 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR,     \
 756                 show_temp_offset, set_temp_offset, offset - 1);         \
 757 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
 758                 show_temp_min, set_temp_min, offset - 1);               \
 759 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 760                 show_temp_max, set_temp_max, offset - 1);               \
 761 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR,       \
 762                 show_temp_crit, set_temp_crit, offset - 1)
 763
 764 temp_reg(1);
 765 temp_reg(2);
 766 temp_reg(3);
 767
 768 /* Alarms */
 769 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
 770                            char *buf)
 771 {
 772         struct adm1031_data *data = adm1031_update_device(dev);
 773         return sprintf(buf, "%d\n", data->alarm);
 774 }
 775
 776 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 777
 778 static ssize_t show_alarm(struct device *dev,
 779                           struct device_attribute *attr, char *buf)
 780 {
 781         int bitnr = to_sensor_dev_attr(attr)->index;
 782         struct adm1031_data *data = adm1031_update_device(dev);
 783         return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
 784 }
 785
 786 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
 787 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
 788 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
 789 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 790 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
 791 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
 792 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 793 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
 794 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
 795 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
 796 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
 797 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
 798 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
 799 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
 800 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
 801
 802 /* Update Interval */
 803 static const unsigned int update_intervals[] = {
 804         16000, 8000, 4000, 2000, 1000, 500, 250, 125,
 805 };
 806
 807 static ssize_t show_update_interval(struct device *dev,
 808                                     struct device_attribute *attr, char *buf)
 809 {
 810         struct i2c_client *client = to_i2c_client(dev);
 811         struct adm1031_data *data = i2c_get_clientdata(client);
 812
 813         return sprintf(buf, "%u\n", data->update_interval);
 814 }
 815
 816 static ssize_t set_update_interval(struct device *dev,
 817                                    struct device_attribute *attr,
 818                                    const char *buf, size_t count)
 819 {
 820         struct i2c_client *client = to_i2c_client(dev);
 821         struct adm1031_data *data = i2c_get_clientdata(client);
 822         unsigned long val;
 823         int i, err;
 824         u8 reg;
 825
 826         err = kstrtoul(buf, 10, &val);
 827         if (err)
 828                 return err;
 829
 830         /*
 831          * Find the nearest update interval from the table.
 832          * Use it to determine the matching update rate.
 833          */
 834         for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
 835                 if (val >= update_intervals[i])
 836                         break;
 837         }
 838         /* if not found, we point to the last entry (lowest update interval) */
 839
 840         /* set the new update rate while preserving other settings */
 841         reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
 842         reg &= ~ADM1031_UPDATE_RATE_MASK;
 843         reg |= i << ADM1031_UPDATE_RATE_SHIFT;
 844         adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
 845
 846         mutex_lock(&data->update_lock);
 847         data->update_interval = update_intervals[i];
 848         mutex_unlock(&data->update_lock);
 849
 850         return count;
 851 }
 852
 853 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
 854                    set_update_interval);
 855
 856 static struct attribute *adm1031_attributes[] = {
 857         &sensor_dev_attr_fan1_input.dev_attr.attr,
 858         &sensor_dev_attr_fan1_div.dev_attr.attr,
 859         &sensor_dev_attr_fan1_min.dev_attr.attr,
 860         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 861         &sensor_dev_attr_fan1_fault.dev_attr.attr,
 862         &sensor_dev_attr_pwm1.dev_attr.attr,
 863         &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
 864         &sensor_dev_attr_temp1_input.dev_attr.attr,
 865         &sensor_dev_attr_temp1_offset.dev_attr.attr,
 866         &sensor_dev_attr_temp1_min.dev_attr.attr,
 867         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 868         &sensor_dev_attr_temp1_max.dev_attr.attr,
 869         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 870         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 871         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 872         &sensor_dev_attr_temp2_input.dev_attr.attr,
 873         &sensor_dev_attr_temp2_offset.dev_attr.attr,
 874         &sensor_dev_attr_temp2_min.dev_attr.attr,
 875         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 876         &sensor_dev_attr_temp2_max.dev_attr.attr,
 877         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 878         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 879         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 880         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 881
 882         &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
 883         &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
 884         &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
 885
 886         &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
 887         &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
 888         &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
 889
 890         &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
 891
 892         &dev_attr_update_interval.attr,
 893         &dev_attr_alarms.attr,
 894
 895         NULL
 896 };
 897
 898 static const struct attribute_group adm1031_group = {
 899         .attrs = adm1031_attributes,
 900 };
 901
 902 static struct attribute *adm1031_attributes_opt[] = {
 903         &sensor_dev_attr_fan2_input.dev_attr.attr,
 904         &sensor_dev_attr_fan2_div.dev_attr.attr,
 905         &sensor_dev_attr_fan2_min.dev_attr.attr,
 906         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 907         &sensor_dev_attr_fan2_fault.dev_attr.attr,
 908         &sensor_dev_attr_pwm2.dev_attr.attr,
 909         &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
 910         &sensor_dev_attr_temp3_input.dev_attr.attr,
 911         &sensor_dev_attr_temp3_offset.dev_attr.attr,
 912         &sensor_dev_attr_temp3_min.dev_attr.attr,
 913         &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
 914         &sensor_dev_attr_temp3_max.dev_attr.attr,
 915         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
 916         &sensor_dev_attr_temp3_crit.dev_attr.attr,
 917         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
 918         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 919         &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
 920         &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
 921         &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
 922         &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
 923         NULL
 924 };
 925
 926 static const struct attribute_group adm1031_group_opt = {
 927         .attrs = adm1031_attributes_opt,
 928 };
 929
 930 /* Return 0 if detection is successful, -ENODEV otherwise */
 931 static int adm1031_detect(struct i2c_client *client,
 932                           struct i2c_board_info *info)
 933 {
 934         struct i2c_adapter *adapter = client->adapter;
 935         const char *name;
 936         int id, co;
 937
 938         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 939                 return -ENODEV;
 940
 941         id = i2c_smbus_read_byte_data(client, 0x3d);
 942         co = i2c_smbus_read_byte_data(client, 0x3e);
 943
 944         if (!((id == 0x31 || id == 0x30) && co == 0x41))
 945                 return -ENODEV;
 946         name = (id == 0x30) ? "adm1030" : "adm1031";
 947
 948         strlcpy(info->type, name, I2C_NAME_SIZE);
 949
 950         return 0;
 951 }
 952
 953 static int adm1031_probe(struct i2c_client *client,
 954                          const struct i2c_device_id *id)
 955 {
 956         struct adm1031_data *data;
 957         int err;
 958
 959         data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data),
 960                             GFP_KERNEL);
 961         if (!data)
 962                 return -ENOMEM;
 963
 964         i2c_set_clientdata(client, data);
 965         data->chip_type = id->driver_data;
 966         mutex_init(&data->update_lock);
 967
 968         if (data->chip_type == adm1030)
 969                 data->chan_select_table = &auto_channel_select_table_adm1030;
 970         else
 971                 data->chan_select_table = &auto_channel_select_table_adm1031;
 972
 973         /* Initialize the ADM1031 chip */
 974         adm1031_init_client(client);
 975
 976         /* Register sysfs hooks */
 977         err = sysfs_create_group(&client->dev.kobj, &adm1031_group);
 978         if (err)
 979                 return err;
 980
 981         if (data->chip_type == adm1031) {
 982                 err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt);
 983                 if (err)
 984                         goto exit_remove;
 985         }
 986
 987         data->hwmon_dev = hwmon_device_register(&client->dev);
 988         if (IS_ERR(data->hwmon_dev)) {
 989                 err = PTR_ERR(data->hwmon_dev);
 990                 goto exit_remove;
 991         }
 992
 993         return 0;
 994
 995 exit_remove:
 996         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
 997         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
 998         return err;
 999 }
1000
1001 static int adm1031_remove(struct i2c_client *client)
1002 {
1003         struct adm1031_data *data = i2c_get_clientdata(client);
1004
1005         hwmon_device_unregister(data->hwmon_dev);
1006         sysfs_remove_group(&client->dev.kobj, &adm1031_group);
1007         sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
1008         return 0;
1009 }
1010
1011 static void adm1031_init_client(struct i2c_client *client)
1012 {
1013         unsigned int read_val;
1014         unsigned int mask;
1015         int i;
1016         struct adm1031_data *data = i2c_get_clientdata(client);
1017
1018         mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1019         if (data->chip_type == adm1031) {
1020                 mask |= (ADM1031_CONF2_PWM2_ENABLE |
1021                         ADM1031_CONF2_TACH2_ENABLE);
1022         }
1023         /* Initialize the ADM1031 chip (enables fan speed reading ) */
1024         read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1025         if ((read_val | mask) != read_val)
1026                 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1027
1028         read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1029         if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1030                 adm1031_write_value(client, ADM1031_REG_CONF1,
1031                                     read_val | ADM1031_CONF1_MONITOR_ENABLE);
1032         }
1033
1034         /* Read the chip's update rate */
1035         mask = ADM1031_UPDATE_RATE_MASK;
1036         read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1037         i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1038         /* Save it as update interval */
1039         data->update_interval = update_intervals[i];
1040 }
1041
1042 static struct adm1031_data *adm1031_update_device(struct device *dev)
1043 {
1044         struct i2c_client *client = to_i2c_client(dev);
1045         struct adm1031_data *data = i2c_get_clientdata(client);
1046         unsigned long next_update;
1047         int chan;
1048
1049         mutex_lock(&data->update_lock);
1050
1051         next_update = data->last_updated
1052           + msecs_to_jiffies(data->update_interval);
1053         if (time_after(jiffies, next_update) || !data->valid) {
1054
1055                 dev_dbg(&client->dev, "Starting adm1031 update\n");
1056                 for (chan = 0;
1057                      chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1058                         u8 oldh, newh;
1059
1060                         oldh =
1061                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1062                         data->ext_temp[chan] =
1063                             adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1064                         newh =
1065                             adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1066                         if (newh != oldh) {
1067                                 data->ext_temp[chan] =
1068                                     adm1031_read_value(client,
1069                                                        ADM1031_REG_EXT_TEMP);
1070 #ifdef DEBUG
1071                                 oldh =
1072                                     adm1031_read_value(client,
1073                                                        ADM1031_REG_TEMP(chan));
1074
1075                                 /* oldh is actually newer */
1076                                 if (newh != oldh)
1077                                         dev_warn(&client->dev,
1078                                           "Remote temperature may be wrong.\n");
1079 #endif
1080                         }
1081                         data->temp[chan] = newh;
1082
1083                         data->temp_offset[chan] =
1084                             adm1031_read_value(client,
1085                                                ADM1031_REG_TEMP_OFFSET(chan));
1086                         data->temp_min[chan] =
1087                             adm1031_read_value(client,
1088                                                ADM1031_REG_TEMP_MIN(chan));
1089                         data->temp_max[chan] =
1090                             adm1031_read_value(client,
1091                                                ADM1031_REG_TEMP_MAX(chan));
1092                         data->temp_crit[chan] =
1093                             adm1031_read_value(client,
1094                                                ADM1031_REG_TEMP_CRIT(chan));
1095                         data->auto_temp[chan] =
1096                             adm1031_read_value(client,
1097                                                ADM1031_REG_AUTO_TEMP(chan));
1098
1099                 }
1100
1101                 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1102                 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1103
1104                 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1105                     | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
1106                 if (data->chip_type == adm1030)
1107                         data->alarm &= 0xc0ff;
1108
1109                 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
1110                      chan++) {
1111                         data->fan_div[chan] =
1112                             adm1031_read_value(client,
1113                                                ADM1031_REG_FAN_DIV(chan));
1114                         data->fan_min[chan] =
1115                             adm1031_read_value(client,
1116                                                ADM1031_REG_FAN_MIN(chan));
1117                         data->fan[chan] =
1118                             adm1031_read_value(client,
1119                                                ADM1031_REG_FAN_SPEED(chan));
1120                         data->pwm[chan] =
1121                           (adm1031_read_value(client,
1122                                         ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
1123                 }
1124                 data->last_updated = jiffies;
1125                 data->valid = 1;
1126         }
1127
1128         mutex_unlock(&data->update_lock);
1129
1130         return data;
1131 }
1132
1133 module_i2c_driver(adm1031_driver);
1134
1135 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1136 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1137 MODULE_LICENSE("GPL");