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         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 }
 375 static 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 }
 383 static ssize_t
 384 set_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)                                           \
 407 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO,             \
 408                 show_auto_temp_off, NULL, offset - 1);                  \
 409 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR,   \
 410                 show_auto_temp_min, set_auto_temp_min, offset - 1);     \
 411 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR,   \
 412                 show_auto_temp_max, set_auto_temp_max, offset - 1)
 413
 414 auto_temp_reg(1);
 415 auto_temp_reg(2);
 416 auto_temp_reg(3);
 417
 418 /* pwm */
 419 static 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 }
 426 static 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
 455 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
 456 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
 457 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
 458                 show_pwm, set_pwm, 0);
 459 static 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  */
 469 static 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
 511 static 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
 523 static 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 }
 530 static 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 }
 539 static 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 }
 563 static 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)                                              \
 612 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
 613                 show_fan, NULL, offset - 1);                            \
 614 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 615                 show_fan_min, set_fan_min, offset - 1);                 \
 616 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
 617                 show_fan_div, set_fan_div, offset - 1)
 618
 619 fan_offset(1);
 620 fan_offset(2);
 621
 622
 623 /* Temps */
 624 static 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 }
 635 static 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 }
 643 static 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 }
 650 static 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 }
 657 static 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 }
 664 static 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 = clamp_val(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 }
 686 static 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 = clamp_val(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 }
 707 static 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 = clamp_val(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 }
 728 static 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 = clamp_val(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)                                                \
 751 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 752                 show_temp, NULL, offset - 1);                           \
 753 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR,     \
 754                 show_temp_offset, set_temp_offset, offset - 1);         \
 755 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
 756                 show_temp_min, set_temp_min, offset - 1);               \
 757 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 758                 show_temp_max, set_temp_max, offset - 1);               \
 759 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR,       \
 760                 show_temp_crit, set_temp_crit, offset - 1)
 761
 762 temp_reg(1);
 763 temp_reg(2);
 764 temp_reg(3);
 765
 766 /* Alarms */
 767 static 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
 774 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 775
 776 static 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
 784 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
 785 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
 786 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
 787 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 788 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
 789 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
 790 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 791 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
 792 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
 793 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
 794 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
 795 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
 796 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
 797 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
 798 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
 799
 800 /* Update Interval */
 801 static const unsigned int update_intervals[] = {
 802         16000, 8000, 4000, 2000, 1000, 500, 250, 125,
 803 };
 804
 805 static 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
 814 static 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
 851 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
 852                    set_update_interval);
 853
 854 static 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
 896 static const struct attribute_group adm1031_group = {
 897         .attrs = adm1031_attributes,
 898 };
 899
 900 static 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
 924 static const struct attribute_group adm1031_group_opt = {
 925         .attrs = adm1031_attributes_opt,
 926 };
 927
 928 /* Return 0 if detection is successful, -ENODEV otherwise */
 929 static 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
 951 static 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
 993 exit_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
 999 static 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
1009 static 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
1040 static 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
1131 module_i2c_driver(adm1031_driver);
1132
1133 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1134 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1135 MODULE_LICENSE("GPL");