drivers/hwmon/adt7470.c

   1 /*
   2  * A hwmon driver for the Analog Devices ADT7470
   3  * Copyright (C) 2007 IBM
   4  *
   5  * Author: Darrick J. Wong <djwong@us.ibm.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/i2c.h>
  25 #include <linux/hwmon.h>
  26 #include <linux/hwmon-sysfs.h>
  27 #include <linux/err.h>
  28 #include <linux/mutex.h>
  29 #include <linux/delay.h>
  30 #include <linux/log2.h>
  31
  32 /* Addresses to scan */
  33 static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
  34
  35 /* Insmod parameters */
  36 I2C_CLIENT_INSMOD_1(adt7470);
  37
  38 /* ADT7470 registers */
  39 #define ADT7470_REG_BASE_ADDR                   0x20
  40 #define ADT7470_REG_TEMP_BASE_ADDR              0x20
  41 #define ADT7470_REG_TEMP_MAX_ADDR               0x29
  42 #define ADT7470_REG_FAN_BASE_ADDR               0x2A
  43 #define ADT7470_REG_FAN_MAX_ADDR                0x31
  44 #define ADT7470_REG_PWM_BASE_ADDR               0x32
  45 #define ADT7470_REG_PWM_MAX_ADDR                0x35
  46 #define ADT7470_REG_PWM_MAX_BASE_ADDR           0x38
  47 #define ADT7470_REG_PWM_MAX_MAX_ADDR            0x3B
  48 #define ADT7470_REG_CFG                         0x40
  49 #define         ADT7470_FSPD_MASK               0x04
  50 #define ADT7470_REG_ALARM1                      0x41
  51 #define         ADT7470_R1T_ALARM               0x01
  52 #define         ADT7470_R2T_ALARM               0x02
  53 #define         ADT7470_R3T_ALARM               0x04
  54 #define         ADT7470_R4T_ALARM               0x08
  55 #define         ADT7470_R5T_ALARM               0x10
  56 #define         ADT7470_R6T_ALARM               0x20
  57 #define         ADT7470_R7T_ALARM               0x40
  58 #define         ADT7470_OOL_ALARM               0x80
  59 #define ADT7470_REG_ALARM2                      0x42
  60 #define         ADT7470_R8T_ALARM               0x01
  61 #define         ADT7470_R9T_ALARM               0x02
  62 #define         ADT7470_R10T_ALARM              0x04
  63 #define         ADT7470_FAN1_ALARM              0x10
  64 #define         ADT7470_FAN2_ALARM              0x20
  65 #define         ADT7470_FAN3_ALARM              0x40
  66 #define         ADT7470_FAN4_ALARM              0x80
  67 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR       0x44
  68 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR        0x57
  69 #define ADT7470_REG_FAN_MIN_BASE_ADDR           0x58
  70 #define ADT7470_REG_FAN_MIN_MAX_ADDR            0x5F
  71 #define ADT7470_REG_FAN_MAX_BASE_ADDR           0x60
  72 #define ADT7470_REG_FAN_MAX_MAX_ADDR            0x67
  73 #define ADT7470_REG_PWM_CFG_BASE_ADDR           0x68
  74 #define ADT7470_REG_PWM12_CFG                   0x68
  75 #define         ADT7470_PWM2_AUTO_MASK          0x40
  76 #define         ADT7470_PWM1_AUTO_MASK          0x80
  77 #define         ADT7470_PWM_AUTO_MASK           0xC0
  78 #define ADT7470_REG_PWM34_CFG                   0x69
  79 #define         ADT7470_PWM3_AUTO_MASK          0x40
  80 #define         ADT7470_PWM4_AUTO_MASK          0x80
  81 #define ADT7470_REG_PWM_MIN_BASE_ADDR           0x6A
  82 #define ADT7470_REG_PWM_MIN_MAX_ADDR            0x6D
  83 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR      0x6E
  84 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR       0x71
  85 #define ADT7470_REG_ACOUSTICS12                 0x75
  86 #define ADT7470_REG_ACOUSTICS34                 0x76
  87 #define ADT7470_REG_DEVICE                      0x3D
  88 #define ADT7470_REG_VENDOR                      0x3E
  89 #define ADT7470_REG_REVISION                    0x3F
  90 #define ADT7470_REG_ALARM1_MASK                 0x72
  91 #define ADT7470_REG_ALARM2_MASK                 0x73
  92 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR     0x7C
  93 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR      0x7D
  94 #define ADT7470_REG_MAX_ADDR                    0x81
  95
  96 #define ADT7470_TEMP_COUNT      10
  97 #define ADT7470_TEMP_REG(x)     (ADT7470_REG_TEMP_BASE_ADDR + (x))
  98 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
  99 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
 100                                 ((x) * 2) + 1)
 101
 102 #define ADT7470_FAN_COUNT       4
 103 #define ADT7470_REG_FAN(x)      (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
 104 #define ADT7470_REG_FAN_MIN(x)  (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
 105 #define ADT7470_REG_FAN_MAX(x)  (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
 106
 107 #define ADT7470_PWM_COUNT       4
 108 #define ADT7470_REG_PWM(x)      (ADT7470_REG_PWM_BASE_ADDR + (x))
 109 #define ADT7470_REG_PWM_MAX(x)  (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
 110 #define ADT7470_REG_PWM_MIN(x)  (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
 111 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
 112 #define ADT7470_REG_PWM_CFG(x)  (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
 113 #define ADT7470_REG_PWM_AUTO_TEMP(x)    (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
 114                                         ((x) / 2))
 115
 116 #define ALARM2(x)               ((x) << 8)
 117
 118 #define ADT7470_VENDOR          0x41
 119 #define ADT7470_DEVICE          0x70
 120 /* datasheet only mentions a revision 2 */
 121 #define ADT7470_REVISION        0x02
 122
 123 /* "all temps" according to hwmon sysfs interface spec */
 124 #define ADT7470_PWM_ALL_TEMPS   0x3FF
 125
 126 /* How often do we reread sensors values? (In jiffies) */
 127 #define SENSOR_REFRESH_INTERVAL (5 * HZ)
 128
 129 /* How often do we reread sensor limit values? (In jiffies) */
 130 #define LIMIT_REFRESH_INTERVAL  (60 * HZ)
 131
 132 /* sleep 1s while gathering temperature data */
 133 #define TEMP_COLLECTION_TIME    1000
 134
 135 /* datasheet says to divide this number by the fan reading to get fan rpm */
 136 #define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
 137 #define FAN_RPM_TO_PERIOD       FAN_PERIOD_TO_RPM
 138 #define FAN_PERIOD_INVALID      65535
 139 #define FAN_DATA_VALID(x)       ((x) && (x) != FAN_PERIOD_INVALID)
 140
 141 struct adt7470_data {
 142         struct device           *hwmon_dev;
 143         struct attribute_group  attrs;
 144         struct mutex            lock;
 145         char                    sensors_valid;
 146         char                    limits_valid;
 147         unsigned long           sensors_last_updated;   /* In jiffies */
 148         unsigned long           limits_last_updated;    /* In jiffies */
 149
 150         s8                      temp[ADT7470_TEMP_COUNT];
 151         s8                      temp_min[ADT7470_TEMP_COUNT];
 152         s8                      temp_max[ADT7470_TEMP_COUNT];
 153         u16                     fan[ADT7470_FAN_COUNT];
 154         u16                     fan_min[ADT7470_FAN_COUNT];
 155         u16                     fan_max[ADT7470_FAN_COUNT];
 156         u16                     alarm;
 157         u16                     alarms_mask;
 158         u8                      force_pwm_max;
 159         u8                      pwm[ADT7470_PWM_COUNT];
 160         u8                      pwm_max[ADT7470_PWM_COUNT];
 161         u8                      pwm_automatic[ADT7470_PWM_COUNT];
 162         u8                      pwm_min[ADT7470_PWM_COUNT];
 163         s8                      pwm_tmin[ADT7470_PWM_COUNT];
 164         u8                      pwm_auto_temp[ADT7470_PWM_COUNT];
 165 };
 166
 167 static int adt7470_probe(struct i2c_client *client,
 168                          const struct i2c_device_id *id);
 169 static int adt7470_detect(struct i2c_client *client, int kind,
 170                           struct i2c_board_info *info);
 171 static int adt7470_remove(struct i2c_client *client);
 172
 173 static const struct i2c_device_id adt7470_id[] = {
 174         { "adt7470", adt7470 },
 175         { }
 176 };
 177 MODULE_DEVICE_TABLE(i2c, adt7470_id);
 178
 179 static struct i2c_driver adt7470_driver = {
 180         .class          = I2C_CLASS_HWMON,
 181         .driver = {
 182                 .name   = "adt7470",
 183         },
 184         .probe          = adt7470_probe,
 185         .remove         = adt7470_remove,
 186         .id_table       = adt7470_id,
 187         .detect         = adt7470_detect,
 188         .address_data   = &addr_data,
 189 };
 190
 191 /*
 192  * 16-bit registers on the ADT7470 are low-byte first.  The data sheet says
 193  * that the low byte must be read before the high byte.
 194  */
 195 static inline int adt7470_read_word_data(struct i2c_client *client, u8 reg)
 196 {
 197         u16 foo;
 198         foo = i2c_smbus_read_byte_data(client, reg);
 199         foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
 200         return foo;
 201 }
 202
 203 static inline int adt7470_write_word_data(struct i2c_client *client, u8 reg,
 204                                           u16 value)
 205 {
 206         return i2c_smbus_write_byte_data(client, reg, value & 0xFF)
 207                && i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
 208 }
 209
 210 static void adt7470_init_client(struct i2c_client *client)
 211 {
 212         int reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
 213
 214         if (reg < 0) {
 215                 dev_err(&client->dev, "cannot read configuration register\n");
 216         } else {
 217                 /* start monitoring (and do a self-test) */
 218                 i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg | 3);
 219         }
 220 }
 221
 222 static struct adt7470_data *adt7470_update_device(struct device *dev)
 223 {
 224         struct i2c_client *client = to_i2c_client(dev);
 225         struct adt7470_data *data = i2c_get_clientdata(client);
 226         unsigned long local_jiffies = jiffies;
 227         u8 cfg, pwm[4], pwm_cfg[2];
 228         int i;
 229
 230         mutex_lock(&data->lock);
 231         if (time_before(local_jiffies, data->sensors_last_updated +
 232                 SENSOR_REFRESH_INTERVAL)
 233                 && data->sensors_valid)
 234                 goto no_sensor_update;
 235
 236         /* save pwm[1-4] config register */
 237         pwm_cfg[0] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(0));
 238         pwm_cfg[1] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM_CFG(2));
 239
 240         /* set manual pwm to whatever it is set to now */
 241         for (i = 0; i < ADT7470_FAN_COUNT; i++)
 242                 pwm[i] = i2c_smbus_read_byte_data(client, ADT7470_REG_PWM(i));
 243
 244         /* put pwm in manual mode */
 245         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0),
 246                 pwm_cfg[0] & ~(ADT7470_PWM_AUTO_MASK));
 247         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2),
 248                 pwm_cfg[1] & ~(ADT7470_PWM_AUTO_MASK));
 249
 250         /* write pwm control to whatever it was */
 251         for (i = 0; i < ADT7470_FAN_COUNT; i++)
 252                 i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(i), pwm[i]);
 253
 254         /* start reading temperature sensors */
 255         cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
 256         cfg |= 0x80;
 257         i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
 258
 259         /*
 260          * Delay is 200ms * number of tmp05 sensors.  Too bad
 261          * there's no way to figure out how many are connected.
 262          * For now, assume 1s will work.
 263          */
 264         msleep(TEMP_COLLECTION_TIME);
 265
 266         /* done reading temperature sensors */
 267         cfg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
 268         cfg &= ~0x80;
 269         i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, cfg);
 270
 271         /* restore pwm[1-4] config registers */
 272         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
 273         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
 274
 275         for (i = 0; i < ADT7470_TEMP_COUNT; i++)
 276                 data->temp[i] = i2c_smbus_read_byte_data(client,
 277                                                 ADT7470_TEMP_REG(i));
 278
 279         for (i = 0; i < ADT7470_FAN_COUNT; i++)
 280                 data->fan[i] = adt7470_read_word_data(client,
 281                                                 ADT7470_REG_FAN(i));
 282
 283         for (i = 0; i < ADT7470_PWM_COUNT; i++) {
 284                 int reg;
 285                 int reg_mask;
 286
 287                 data->pwm[i] = i2c_smbus_read_byte_data(client,
 288                                                 ADT7470_REG_PWM(i));
 289
 290                 if (i % 2)
 291                         reg_mask = ADT7470_PWM2_AUTO_MASK;
 292                 else
 293                         reg_mask = ADT7470_PWM1_AUTO_MASK;
 294
 295                 reg = ADT7470_REG_PWM_CFG(i);
 296                 if (i2c_smbus_read_byte_data(client, reg) & reg_mask)
 297                         data->pwm_automatic[i] = 1;
 298                 else
 299                         data->pwm_automatic[i] = 0;
 300
 301                 reg = ADT7470_REG_PWM_AUTO_TEMP(i);
 302                 cfg = i2c_smbus_read_byte_data(client, reg);
 303                 if (!(i % 2))
 304                         data->pwm_auto_temp[i] = cfg >> 4;
 305                 else
 306                         data->pwm_auto_temp[i] = cfg & 0xF;
 307         }
 308
 309         if (i2c_smbus_read_byte_data(client, ADT7470_REG_CFG) &
 310             ADT7470_FSPD_MASK)
 311                 data->force_pwm_max = 1;
 312         else
 313                 data->force_pwm_max = 0;
 314
 315         data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1);
 316         if (data->alarm & ADT7470_OOL_ALARM)
 317                 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
 318                                                         ADT7470_REG_ALARM2));
 319         data->alarms_mask = adt7470_read_word_data(client,
 320                                                    ADT7470_REG_ALARM1_MASK);
 321
 322         data->sensors_last_updated = local_jiffies;
 323         data->sensors_valid = 1;
 324
 325 no_sensor_update:
 326         if (time_before(local_jiffies, data->limits_last_updated +
 327                 LIMIT_REFRESH_INTERVAL)
 328                 && data->limits_valid)
 329                 goto out;
 330
 331         for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
 332                 data->temp_min[i] = i2c_smbus_read_byte_data(client,
 333                                                 ADT7470_TEMP_MIN_REG(i));
 334                 data->temp_max[i] = i2c_smbus_read_byte_data(client,
 335                                                 ADT7470_TEMP_MAX_REG(i));
 336         }
 337
 338         for (i = 0; i < ADT7470_FAN_COUNT; i++) {
 339                 data->fan_min[i] = adt7470_read_word_data(client,
 340                                                 ADT7470_REG_FAN_MIN(i));
 341                 data->fan_max[i] = adt7470_read_word_data(client,
 342                                                 ADT7470_REG_FAN_MAX(i));
 343         }
 344
 345         for (i = 0; i < ADT7470_PWM_COUNT; i++) {
 346                 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
 347                                                 ADT7470_REG_PWM_MAX(i));
 348                 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
 349                                                 ADT7470_REG_PWM_MIN(i));
 350                 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
 351                                                 ADT7470_REG_PWM_TMIN(i));
 352         }
 353
 354         data->limits_last_updated = local_jiffies;
 355         data->limits_valid = 1;
 356
 357 out:
 358         mutex_unlock(&data->lock);
 359         return data;
 360 }
 361
 362 static ssize_t show_temp_min(struct device *dev,
 363                              struct device_attribute *devattr,
 364                              char *buf)
 365 {
 366         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 367         struct adt7470_data *data = adt7470_update_device(dev);
 368         return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
 369 }
 370
 371 static ssize_t set_temp_min(struct device *dev,
 372                             struct device_attribute *devattr,
 373                             const char *buf,
 374                             size_t count)
 375 {
 376         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 377         struct i2c_client *client = to_i2c_client(dev);
 378         struct adt7470_data *data = i2c_get_clientdata(client);
 379         long temp;
 380
 381         if (strict_strtol(buf, 10, &temp))
 382                 return -EINVAL;
 383
 384         temp = DIV_ROUND_CLOSEST(temp, 1000);
 385         temp = SENSORS_LIMIT(temp, 0, 255);
 386
 387         mutex_lock(&data->lock);
 388         data->temp_min[attr->index] = temp;
 389         i2c_smbus_write_byte_data(client, ADT7470_TEMP_MIN_REG(attr->index),
 390                                   temp);
 391         mutex_unlock(&data->lock);
 392
 393         return count;
 394 }
 395
 396 static ssize_t show_temp_max(struct device *dev,
 397                              struct device_attribute *devattr,
 398                              char *buf)
 399 {
 400         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 401         struct adt7470_data *data = adt7470_update_device(dev);
 402         return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
 403 }
 404
 405 static ssize_t set_temp_max(struct device *dev,
 406                             struct device_attribute *devattr,
 407                             const char *buf,
 408                             size_t count)
 409 {
 410         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 411         struct i2c_client *client = to_i2c_client(dev);
 412         struct adt7470_data *data = i2c_get_clientdata(client);
 413         long temp;
 414
 415         if (strict_strtol(buf, 10, &temp))
 416                 return -EINVAL;
 417
 418         temp = DIV_ROUND_CLOSEST(temp, 1000);
 419         temp = SENSORS_LIMIT(temp, 0, 255);
 420
 421         mutex_lock(&data->lock);
 422         data->temp_max[attr->index] = temp;
 423         i2c_smbus_write_byte_data(client, ADT7470_TEMP_MAX_REG(attr->index),
 424                                   temp);
 425         mutex_unlock(&data->lock);
 426
 427         return count;
 428 }
 429
 430 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 431                          char *buf)
 432 {
 433         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 434         struct adt7470_data *data = adt7470_update_device(dev);
 435         return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
 436 }
 437
 438 static ssize_t show_alarm_mask(struct device *dev,
 439                            struct device_attribute *devattr,
 440                            char *buf)
 441 {
 442         struct adt7470_data *data = adt7470_update_device(dev);
 443
 444         return sprintf(buf, "%x\n", data->alarms_mask);
 445 }
 446
 447 static ssize_t show_fan_max(struct device *dev,
 448                             struct device_attribute *devattr,
 449                             char *buf)
 450 {
 451         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 452         struct adt7470_data *data = adt7470_update_device(dev);
 453
 454         if (FAN_DATA_VALID(data->fan_max[attr->index]))
 455                 return sprintf(buf, "%d\n",
 456                                FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
 457         else
 458                 return sprintf(buf, "0\n");
 459 }
 460
 461 static ssize_t set_fan_max(struct device *dev,
 462                            struct device_attribute *devattr,
 463                            const char *buf, size_t count)
 464 {
 465         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 466         struct i2c_client *client = to_i2c_client(dev);
 467         struct adt7470_data *data = i2c_get_clientdata(client);
 468         long temp;
 469
 470         if (strict_strtol(buf, 10, &temp) || !temp)
 471                 return -EINVAL;
 472
 473         temp = FAN_RPM_TO_PERIOD(temp);
 474         temp = SENSORS_LIMIT(temp, 1, 65534);
 475
 476         mutex_lock(&data->lock);
 477         data->fan_max[attr->index] = temp;
 478         adt7470_write_word_data(client, ADT7470_REG_FAN_MAX(attr->index), temp);
 479         mutex_unlock(&data->lock);
 480
 481         return count;
 482 }
 483
 484 static ssize_t show_fan_min(struct device *dev,
 485                             struct device_attribute *devattr,
 486                             char *buf)
 487 {
 488         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 489         struct adt7470_data *data = adt7470_update_device(dev);
 490
 491         if (FAN_DATA_VALID(data->fan_min[attr->index]))
 492                 return sprintf(buf, "%d\n",
 493                                FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
 494         else
 495                 return sprintf(buf, "0\n");
 496 }
 497
 498 static ssize_t set_fan_min(struct device *dev,
 499                            struct device_attribute *devattr,
 500                            const char *buf, size_t count)
 501 {
 502         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 503         struct i2c_client *client = to_i2c_client(dev);
 504         struct adt7470_data *data = i2c_get_clientdata(client);
 505         long temp;
 506
 507         if (strict_strtol(buf, 10, &temp) || !temp)
 508                 return -EINVAL;
 509
 510         temp = FAN_RPM_TO_PERIOD(temp);
 511         temp = SENSORS_LIMIT(temp, 1, 65534);
 512
 513         mutex_lock(&data->lock);
 514         data->fan_min[attr->index] = temp;
 515         adt7470_write_word_data(client, ADT7470_REG_FAN_MIN(attr->index), temp);
 516         mutex_unlock(&data->lock);
 517
 518         return count;
 519 }
 520
 521 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 522                         char *buf)
 523 {
 524         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 525         struct adt7470_data *data = adt7470_update_device(dev);
 526
 527         if (FAN_DATA_VALID(data->fan[attr->index]))
 528                 return sprintf(buf, "%d\n",
 529                                FAN_PERIOD_TO_RPM(data->fan[attr->index]));
 530         else
 531                 return sprintf(buf, "0\n");
 532 }
 533
 534 static ssize_t show_force_pwm_max(struct device *dev,
 535                                   struct device_attribute *devattr,
 536                                   char *buf)
 537 {
 538         struct adt7470_data *data = adt7470_update_device(dev);
 539         return sprintf(buf, "%d\n", data->force_pwm_max);
 540 }
 541
 542 static ssize_t set_force_pwm_max(struct device *dev,
 543                                  struct device_attribute *devattr,
 544                                  const char *buf,
 545                                  size_t count)
 546 {
 547         struct i2c_client *client = to_i2c_client(dev);
 548         struct adt7470_data *data = i2c_get_clientdata(client);
 549         long temp;
 550         u8 reg;
 551
 552         if (strict_strtol(buf, 10, &temp))
 553                 return -EINVAL;
 554
 555         mutex_lock(&data->lock);
 556         data->force_pwm_max = temp;
 557         reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
 558         if (temp)
 559                 reg |= ADT7470_FSPD_MASK;
 560         else
 561                 reg &= ~ADT7470_FSPD_MASK;
 562         i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg);
 563         mutex_unlock(&data->lock);
 564
 565         return count;
 566 }
 567
 568 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
 569                         char *buf)
 570 {
 571         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 572         struct adt7470_data *data = adt7470_update_device(dev);
 573         return sprintf(buf, "%d\n", data->pwm[attr->index]);
 574 }
 575
 576 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
 577                         const char *buf, size_t count)
 578 {
 579         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 580         struct i2c_client *client = to_i2c_client(dev);
 581         struct adt7470_data *data = i2c_get_clientdata(client);
 582         long temp;
 583
 584         if (strict_strtol(buf, 10, &temp))
 585                 return -EINVAL;
 586
 587         temp = SENSORS_LIMIT(temp, 0, 255);
 588
 589         mutex_lock(&data->lock);
 590         data->pwm[attr->index] = temp;
 591         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(attr->index), temp);
 592         mutex_unlock(&data->lock);
 593
 594         return count;
 595 }
 596
 597 static ssize_t show_pwm_max(struct device *dev,
 598                             struct device_attribute *devattr,
 599                             char *buf)
 600 {
 601         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 602         struct adt7470_data *data = adt7470_update_device(dev);
 603         return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
 604 }
 605
 606 static ssize_t set_pwm_max(struct device *dev,
 607                            struct device_attribute *devattr,
 608                            const char *buf,
 609                            size_t count)
 610 {
 611         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 612         struct i2c_client *client = to_i2c_client(dev);
 613         struct adt7470_data *data = i2c_get_clientdata(client);
 614         long temp;
 615
 616         if (strict_strtol(buf, 10, &temp))
 617                 return -EINVAL;
 618
 619         temp = SENSORS_LIMIT(temp, 0, 255);
 620
 621         mutex_lock(&data->lock);
 622         data->pwm_max[attr->index] = temp;
 623         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MAX(attr->index),
 624                                   temp);
 625         mutex_unlock(&data->lock);
 626
 627         return count;
 628 }
 629
 630 static ssize_t show_pwm_min(struct device *dev,
 631                             struct device_attribute *devattr,
 632                             char *buf)
 633 {
 634         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 635         struct adt7470_data *data = adt7470_update_device(dev);
 636         return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
 637 }
 638
 639 static ssize_t set_pwm_min(struct device *dev,
 640                            struct device_attribute *devattr,
 641                            const char *buf,
 642                            size_t count)
 643 {
 644         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 645         struct i2c_client *client = to_i2c_client(dev);
 646         struct adt7470_data *data = i2c_get_clientdata(client);
 647         long temp;
 648
 649         if (strict_strtol(buf, 10, &temp))
 650                 return -EINVAL;
 651
 652         temp = SENSORS_LIMIT(temp, 0, 255);
 653
 654         mutex_lock(&data->lock);
 655         data->pwm_min[attr->index] = temp;
 656         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MIN(attr->index),
 657                                   temp);
 658         mutex_unlock(&data->lock);
 659
 660         return count;
 661 }
 662
 663 static ssize_t show_pwm_tmax(struct device *dev,
 664                              struct device_attribute *devattr,
 665                              char *buf)
 666 {
 667         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 668         struct adt7470_data *data = adt7470_update_device(dev);
 669         /* the datasheet says that tmax = tmin + 20C */
 670         return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
 671 }
 672
 673 static ssize_t show_pwm_tmin(struct device *dev,
 674                              struct device_attribute *devattr,
 675                              char *buf)
 676 {
 677         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 678         struct adt7470_data *data = adt7470_update_device(dev);
 679         return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
 680 }
 681
 682 static ssize_t set_pwm_tmin(struct device *dev,
 683                             struct device_attribute *devattr,
 684                             const char *buf,
 685                             size_t count)
 686 {
 687         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 688         struct i2c_client *client = to_i2c_client(dev);
 689         struct adt7470_data *data = i2c_get_clientdata(client);
 690         long temp;
 691
 692         if (strict_strtol(buf, 10, &temp))
 693                 return -EINVAL;
 694
 695         temp = DIV_ROUND_CLOSEST(temp, 1000);
 696         temp = SENSORS_LIMIT(temp, 0, 255);
 697
 698         mutex_lock(&data->lock);
 699         data->pwm_tmin[attr->index] = temp;
 700         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_TMIN(attr->index),
 701                                   temp);
 702         mutex_unlock(&data->lock);
 703
 704         return count;
 705 }
 706
 707 static ssize_t show_pwm_auto(struct device *dev,
 708                              struct device_attribute *devattr,
 709                              char *buf)
 710 {
 711         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 712         struct adt7470_data *data = adt7470_update_device(dev);
 713         return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
 714 }
 715
 716 static ssize_t set_pwm_auto(struct device *dev,
 717                             struct device_attribute *devattr,
 718                             const char *buf,
 719                             size_t count)
 720 {
 721         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 722         struct i2c_client *client = to_i2c_client(dev);
 723         struct adt7470_data *data = i2c_get_clientdata(client);
 724         int pwm_auto_reg = ADT7470_REG_PWM_CFG(attr->index);
 725         int pwm_auto_reg_mask;
 726         long temp;
 727         u8 reg;
 728
 729         if (strict_strtol(buf, 10, &temp))
 730                 return -EINVAL;
 731
 732         if (attr->index % 2)
 733                 pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
 734         else
 735                 pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
 736
 737         if (temp != 2 && temp != 1)
 738                 return -EINVAL;
 739         temp--;
 740
 741         mutex_lock(&data->lock);
 742         data->pwm_automatic[attr->index] = temp;
 743         reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
 744         if (temp)
 745                 reg |= pwm_auto_reg_mask;
 746         else
 747                 reg &= ~pwm_auto_reg_mask;
 748         i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
 749         mutex_unlock(&data->lock);
 750
 751         return count;
 752 }
 753
 754 static ssize_t show_pwm_auto_temp(struct device *dev,
 755                                   struct device_attribute *devattr,
 756                                   char *buf)
 757 {
 758         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 759         struct adt7470_data *data = adt7470_update_device(dev);
 760         u8 ctrl = data->pwm_auto_temp[attr->index];
 761
 762         if (ctrl)
 763                 return sprintf(buf, "%d\n", 1 << (ctrl - 1));
 764         else
 765                 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
 766 }
 767
 768 static int cvt_auto_temp(int input)
 769 {
 770         if (input == ADT7470_PWM_ALL_TEMPS)
 771                 return 0;
 772         if (input < 1 || !is_power_of_2(input))
 773                 return -EINVAL;
 774         return ilog2(input) + 1;
 775 }
 776
 777 static ssize_t set_pwm_auto_temp(struct device *dev,
 778                                  struct device_attribute *devattr,
 779                                  const char *buf,
 780                                  size_t count)
 781 {
 782         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 783         struct i2c_client *client = to_i2c_client(dev);
 784         struct adt7470_data *data = i2c_get_clientdata(client);
 785         int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
 786         long temp;
 787         u8 reg;
 788
 789         if (strict_strtol(buf, 10, &temp))
 790                 return -EINVAL;
 791
 792         temp = cvt_auto_temp(temp);
 793         if (temp < 0)
 794                 return temp;
 795
 796         mutex_lock(&data->lock);
 797         data->pwm_automatic[attr->index] = temp;
 798         reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
 799
 800         if (!(attr->index % 2)) {
 801                 reg &= 0xF;
 802                 reg |= (temp << 4) & 0xF0;
 803         } else {
 804                 reg &= 0xF0;
 805                 reg |= temp & 0xF;
 806         }
 807
 808         i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
 809         mutex_unlock(&data->lock);
 810
 811         return count;
 812 }
 813
 814 static ssize_t show_alarm(struct device *dev,
 815                           struct device_attribute *devattr,
 816                           char *buf)
 817 {
 818         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 819         struct adt7470_data *data = adt7470_update_device(dev);
 820
 821         if (data->alarm & attr->index)
 822                 return sprintf(buf, "1\n");
 823         else
 824                 return sprintf(buf, "0\n");
 825 }
 826
 827 static DEVICE_ATTR(alarm_mask, S_IRUGO, show_alarm_mask, NULL);
 828
 829 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
 830                     set_temp_max, 0);
 831 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
 832                     set_temp_max, 1);
 833 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
 834                     set_temp_max, 2);
 835 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
 836                     set_temp_max, 3);
 837 static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_temp_max,
 838                     set_temp_max, 4);
 839 static SENSOR_DEVICE_ATTR(temp6_max, S_IWUSR | S_IRUGO, show_temp_max,
 840                     set_temp_max, 5);
 841 static SENSOR_DEVICE_ATTR(temp7_max, S_IWUSR | S_IRUGO, show_temp_max,
 842                     set_temp_max, 6);
 843 static SENSOR_DEVICE_ATTR(temp8_max, S_IWUSR | S_IRUGO, show_temp_max,
 844                     set_temp_max, 7);
 845 static SENSOR_DEVICE_ATTR(temp9_max, S_IWUSR | S_IRUGO, show_temp_max,
 846                     set_temp_max, 8);
 847 static SENSOR_DEVICE_ATTR(temp10_max, S_IWUSR | S_IRUGO, show_temp_max,
 848                     set_temp_max, 9);
 849
 850 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
 851                     set_temp_min, 0);
 852 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
 853                     set_temp_min, 1);
 854 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
 855                     set_temp_min, 2);
 856 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
 857                     set_temp_min, 3);
 858 static SENSOR_DEVICE_ATTR(temp5_min, S_IWUSR | S_IRUGO, show_temp_min,
 859                     set_temp_min, 4);
 860 static SENSOR_DEVICE_ATTR(temp6_min, S_IWUSR | S_IRUGO, show_temp_min,
 861                     set_temp_min, 5);
 862 static SENSOR_DEVICE_ATTR(temp7_min, S_IWUSR | S_IRUGO, show_temp_min,
 863                     set_temp_min, 6);
 864 static SENSOR_DEVICE_ATTR(temp8_min, S_IWUSR | S_IRUGO, show_temp_min,
 865                     set_temp_min, 7);
 866 static SENSOR_DEVICE_ATTR(temp9_min, S_IWUSR | S_IRUGO, show_temp_min,
 867                     set_temp_min, 8);
 868 static SENSOR_DEVICE_ATTR(temp10_min, S_IWUSR | S_IRUGO, show_temp_min,
 869                     set_temp_min, 9);
 870
 871 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 872 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
 873 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
 874 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
 875 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
 876 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5);
 877 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6);
 878 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7);
 879 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8);
 880 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp, NULL, 9);
 881
 882 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
 883                           ADT7470_R1T_ALARM);
 884 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
 885                           ADT7470_R2T_ALARM);
 886 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
 887                           ADT7470_R3T_ALARM);
 888 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
 889                           ADT7470_R4T_ALARM);
 890 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO, show_alarm, NULL,
 891                           ADT7470_R5T_ALARM);
 892 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO, show_alarm, NULL,
 893                           ADT7470_R6T_ALARM);
 894 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO, show_alarm, NULL,
 895                           ADT7470_R7T_ALARM);
 896 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO, show_alarm, NULL,
 897                           ALARM2(ADT7470_R8T_ALARM));
 898 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO, show_alarm, NULL,
 899                           ALARM2(ADT7470_R9T_ALARM));
 900 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO, show_alarm, NULL,
 901                           ALARM2(ADT7470_R10T_ALARM));
 902
 903 static SENSOR_DEVICE_ATTR(fan1_max, S_IWUSR | S_IRUGO, show_fan_max,
 904                     set_fan_max, 0);
 905 static SENSOR_DEVICE_ATTR(fan2_max, S_IWUSR | S_IRUGO, show_fan_max,
 906                     set_fan_max, 1);
 907 static SENSOR_DEVICE_ATTR(fan3_max, S_IWUSR | S_IRUGO, show_fan_max,
 908                     set_fan_max, 2);
 909 static SENSOR_DEVICE_ATTR(fan4_max, S_IWUSR | S_IRUGO, show_fan_max,
 910                     set_fan_max, 3);
 911
 912 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
 913                     set_fan_min, 0);
 914 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
 915                     set_fan_min, 1);
 916 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
 917                     set_fan_min, 2);
 918 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
 919                     set_fan_min, 3);
 920
 921 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
 922 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
 923 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
 924 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
 925
 926 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
 927                           ALARM2(ADT7470_FAN1_ALARM));
 928 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
 929                           ALARM2(ADT7470_FAN2_ALARM));
 930 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
 931                           ALARM2(ADT7470_FAN3_ALARM));
 932 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
 933                           ALARM2(ADT7470_FAN4_ALARM));
 934
 935 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
 936                     show_force_pwm_max, set_force_pwm_max, 0);
 937
 938 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
 939 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
 940 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
 941 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
 942
 943 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
 944                     show_pwm_min, set_pwm_min, 0);
 945 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
 946                     show_pwm_min, set_pwm_min, 1);
 947 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
 948                     show_pwm_min, set_pwm_min, 2);
 949 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
 950                     show_pwm_min, set_pwm_min, 3);
 951
 952 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
 953                     show_pwm_max, set_pwm_max, 0);
 954 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
 955                     show_pwm_max, set_pwm_max, 1);
 956 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
 957                     show_pwm_max, set_pwm_max, 2);
 958 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
 959                     show_pwm_max, set_pwm_max, 3);
 960
 961 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
 962                     show_pwm_tmin, set_pwm_tmin, 0);
 963 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO,
 964                     show_pwm_tmin, set_pwm_tmin, 1);
 965 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO,
 966                     show_pwm_tmin, set_pwm_tmin, 2);
 967 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO,
 968                     show_pwm_tmin, set_pwm_tmin, 3);
 969
 970 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 971                     NULL, 0);
 972 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 973                     NULL, 1);
 974 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 975                     NULL, 2);
 976 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 977                     NULL, 3);
 978
 979 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 980                     set_pwm_auto, 0);
 981 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 982                     set_pwm_auto, 1);
 983 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 984                     set_pwm_auto, 2);
 985 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 986                     set_pwm_auto, 3);
 987
 988 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
 989                     show_pwm_auto_temp, set_pwm_auto_temp, 0);
 990 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
 991                     show_pwm_auto_temp, set_pwm_auto_temp, 1);
 992 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
 993                     show_pwm_auto_temp, set_pwm_auto_temp, 2);
 994 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
 995                     show_pwm_auto_temp, set_pwm_auto_temp, 3);
 996
 997 static struct attribute *adt7470_attr[] =
 998 {
 999         &dev_attr_alarm_mask.attr,
1000         &sensor_dev_attr_temp1_max.dev_attr.attr,
1001         &sensor_dev_attr_temp2_max.dev_attr.attr,
1002         &sensor_dev_attr_temp3_max.dev_attr.attr,
1003         &sensor_dev_attr_temp4_max.dev_attr.attr,
1004         &sensor_dev_attr_temp5_max.dev_attr.attr,
1005         &sensor_dev_attr_temp6_max.dev_attr.attr,
1006         &sensor_dev_attr_temp7_max.dev_attr.attr,
1007         &sensor_dev_attr_temp8_max.dev_attr.attr,
1008         &sensor_dev_attr_temp9_max.dev_attr.attr,
1009         &sensor_dev_attr_temp10_max.dev_attr.attr,
1010         &sensor_dev_attr_temp1_min.dev_attr.attr,
1011         &sensor_dev_attr_temp2_min.dev_attr.attr,
1012         &sensor_dev_attr_temp3_min.dev_attr.attr,
1013         &sensor_dev_attr_temp4_min.dev_attr.attr,
1014         &sensor_dev_attr_temp5_min.dev_attr.attr,
1015         &sensor_dev_attr_temp6_min.dev_attr.attr,
1016         &sensor_dev_attr_temp7_min.dev_attr.attr,
1017         &sensor_dev_attr_temp8_min.dev_attr.attr,
1018         &sensor_dev_attr_temp9_min.dev_attr.attr,
1019         &sensor_dev_attr_temp10_min.dev_attr.attr,
1020         &sensor_dev_attr_temp1_input.dev_attr.attr,
1021         &sensor_dev_attr_temp2_input.dev_attr.attr,
1022         &sensor_dev_attr_temp3_input.dev_attr.attr,
1023         &sensor_dev_attr_temp4_input.dev_attr.attr,
1024         &sensor_dev_attr_temp5_input.dev_attr.attr,
1025         &sensor_dev_attr_temp6_input.dev_attr.attr,
1026         &sensor_dev_attr_temp7_input.dev_attr.attr,
1027         &sensor_dev_attr_temp8_input.dev_attr.attr,
1028         &sensor_dev_attr_temp9_input.dev_attr.attr,
1029         &sensor_dev_attr_temp10_input.dev_attr.attr,
1030         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1031         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1032         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1033         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1034         &sensor_dev_attr_temp5_alarm.dev_attr.attr,
1035         &sensor_dev_attr_temp6_alarm.dev_attr.attr,
1036         &sensor_dev_attr_temp7_alarm.dev_attr.attr,
1037         &sensor_dev_attr_temp8_alarm.dev_attr.attr,
1038         &sensor_dev_attr_temp9_alarm.dev_attr.attr,
1039         &sensor_dev_attr_temp10_alarm.dev_attr.attr,
1040         &sensor_dev_attr_fan1_max.dev_attr.attr,
1041         &sensor_dev_attr_fan2_max.dev_attr.attr,
1042         &sensor_dev_attr_fan3_max.dev_attr.attr,
1043         &sensor_dev_attr_fan4_max.dev_attr.attr,
1044         &sensor_dev_attr_fan1_min.dev_attr.attr,
1045         &sensor_dev_attr_fan2_min.dev_attr.attr,
1046         &sensor_dev_attr_fan3_min.dev_attr.attr,
1047         &sensor_dev_attr_fan4_min.dev_attr.attr,
1048         &sensor_dev_attr_fan1_input.dev_attr.attr,
1049         &sensor_dev_attr_fan2_input.dev_attr.attr,
1050         &sensor_dev_attr_fan3_input.dev_attr.attr,
1051         &sensor_dev_attr_fan4_input.dev_attr.attr,
1052         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1053         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1054         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1055         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1056         &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1057         &sensor_dev_attr_pwm1.dev_attr.attr,
1058         &sensor_dev_attr_pwm2.dev_attr.attr,
1059         &sensor_dev_attr_pwm3.dev_attr.attr,
1060         &sensor_dev_attr_pwm4.dev_attr.attr,
1061         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1062         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1063         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1064         &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1065         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1066         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1067         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1068         &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1069         &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1070         &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1071         &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1072         &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
1073         &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1074         &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1075         &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1076         &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
1077         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1078         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1079         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1080         &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1081         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1082         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1083         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1084         &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1085         NULL
1086 };
1087
1088 /* Return 0 if detection is successful, -ENODEV otherwise */
1089 static int adt7470_detect(struct i2c_client *client, int kind,
1090                           struct i2c_board_info *info)
1091 {
1092         struct i2c_adapter *adapter = client->adapter;
1093
1094         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1095                 return -ENODEV;
1096
1097         if (kind <= 0) {
1098                 int vendor, device, revision;
1099
1100                 vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
1101                 if (vendor != ADT7470_VENDOR)
1102                         return -ENODEV;
1103
1104                 device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
1105                 if (device != ADT7470_DEVICE)
1106                         return -ENODEV;
1107
1108                 revision = i2c_smbus_read_byte_data(client,
1109                                                     ADT7470_REG_REVISION);
1110                 if (revision != ADT7470_REVISION)
1111                         return -ENODEV;
1112         } else
1113                 dev_dbg(&adapter->dev, "detection forced\n");
1114
1115         strlcpy(info->type, "adt7470", I2C_NAME_SIZE);
1116
1117         return 0;
1118 }
1119
1120 static int adt7470_probe(struct i2c_client *client,
1121                          const struct i2c_device_id *id)
1122 {
1123         struct adt7470_data *data;
1124         int err;
1125
1126         data = kzalloc(sizeof(struct adt7470_data), GFP_KERNEL);
1127         if (!data) {
1128                 err = -ENOMEM;
1129                 goto exit;
1130         }
1131
1132         i2c_set_clientdata(client, data);
1133         mutex_init(&data->lock);
1134
1135         dev_info(&client->dev, "%s chip found\n", client->name);
1136
1137         /* Initialize the ADT7470 chip */
1138         adt7470_init_client(client);
1139
1140         /* Register sysfs hooks */
1141         data->attrs.attrs = adt7470_attr;
1142         if ((err = sysfs_create_group(&client->dev.kobj, &data->attrs)))
1143                 goto exit_free;
1144
1145         data->hwmon_dev = hwmon_device_register(&client->dev);
1146         if (IS_ERR(data->hwmon_dev)) {
1147                 err = PTR_ERR(data->hwmon_dev);
1148                 goto exit_remove;
1149         }
1150
1151         return 0;
1152
1153 exit_remove:
1154         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1155 exit_free:
1156         kfree(data);
1157 exit:
1158         return err;
1159 }
1160
1161 static int adt7470_remove(struct i2c_client *client)
1162 {
1163         struct adt7470_data *data = i2c_get_clientdata(client);
1164
1165         hwmon_device_unregister(data->hwmon_dev);
1166         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1167         kfree(data);
1168         return 0;
1169 }
1170
1171 static int __init adt7470_init(void)
1172 {
1173         return i2c_add_driver(&adt7470_driver);
1174 }
1175
1176 static void __exit adt7470_exit(void)
1177 {
1178         i2c_del_driver(&adt7470_driver);
1179 }
1180
1181 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1182 MODULE_DESCRIPTION("ADT7470 driver");
1183 MODULE_LICENSE("GPL");
1184
1185 module_init(adt7470_init);
1186 module_exit(adt7470_exit);