drivers/hwmon/adm1031.c

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