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