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         long temp;
 357
 358         if (strict_strtol(buf, 10, &temp))
 359                 return -EINVAL;
 360
 361         temp = DIV_ROUND_CLOSEST(temp, 1000);
 362         temp = SENSORS_LIMIT(temp, 0, 255);
 363
 364         mutex_lock(&data->lock);
 365         data->temp_min[attr->index] = temp;
 366         i2c_smbus_write_byte_data(client, ADT7470_TEMP_MIN_REG(attr->index),
 367                                   temp);
 368         mutex_unlock(&data->lock);
 369
 370         return count;
 371 }
 372
 373 static ssize_t show_temp_max(struct device *dev,
 374                              struct device_attribute *devattr,
 375                              char *buf)
 376 {
 377         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 378         struct adt7470_data *data = adt7470_update_device(dev);
 379         return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
 380 }
 381
 382 static ssize_t set_temp_max(struct device *dev,
 383                             struct device_attribute *devattr,
 384                             const char *buf,
 385                             size_t count)
 386 {
 387         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 388         struct i2c_client *client = to_i2c_client(dev);
 389         struct adt7470_data *data = i2c_get_clientdata(client);
 390         long temp;
 391
 392         if (strict_strtol(buf, 10, &temp))
 393                 return -EINVAL;
 394
 395         temp = DIV_ROUND_CLOSEST(temp, 1000);
 396         temp = SENSORS_LIMIT(temp, 0, 255);
 397
 398         mutex_lock(&data->lock);
 399         data->temp_max[attr->index] = temp;
 400         i2c_smbus_write_byte_data(client, ADT7470_TEMP_MAX_REG(attr->index),
 401                                   temp);
 402         mutex_unlock(&data->lock);
 403
 404         return count;
 405 }
 406
 407 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 408                          char *buf)
 409 {
 410         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 411         struct adt7470_data *data = adt7470_update_device(dev);
 412         return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
 413 }
 414
 415 static ssize_t show_alarm_mask(struct device *dev,
 416                            struct device_attribute *devattr,
 417                            char *buf)
 418 {
 419         struct adt7470_data *data = adt7470_update_device(dev);
 420
 421         return sprintf(buf, "%x\n", data->alarms_mask);
 422 }
 423
 424 static ssize_t show_fan_max(struct device *dev,
 425                             struct device_attribute *devattr,
 426                             char *buf)
 427 {
 428         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 429         struct adt7470_data *data = adt7470_update_device(dev);
 430
 431         if (FAN_DATA_VALID(data->fan_max[attr->index]))
 432                 return sprintf(buf, "%d\n",
 433                                FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
 434         else
 435                 return sprintf(buf, "0\n");
 436 }
 437
 438 static ssize_t set_fan_max(struct device *dev,
 439                            struct device_attribute *devattr,
 440                            const char *buf, size_t count)
 441 {
 442         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 443         struct i2c_client *client = to_i2c_client(dev);
 444         struct adt7470_data *data = i2c_get_clientdata(client);
 445         long temp;
 446
 447         if (strict_strtol(buf, 10, &temp) || !temp)
 448                 return -EINVAL;
 449
 450         temp = FAN_RPM_TO_PERIOD(temp);
 451         temp = SENSORS_LIMIT(temp, 1, 65534);
 452
 453         mutex_lock(&data->lock);
 454         data->fan_max[attr->index] = temp;
 455         adt7470_write_word_data(client, ADT7470_REG_FAN_MAX(attr->index), temp);
 456         mutex_unlock(&data->lock);
 457
 458         return count;
 459 }
 460
 461 static ssize_t show_fan_min(struct device *dev,
 462                             struct device_attribute *devattr,
 463                             char *buf)
 464 {
 465         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 466         struct adt7470_data *data = adt7470_update_device(dev);
 467
 468         if (FAN_DATA_VALID(data->fan_min[attr->index]))
 469                 return sprintf(buf, "%d\n",
 470                                FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
 471         else
 472                 return sprintf(buf, "0\n");
 473 }
 474
 475 static ssize_t set_fan_min(struct device *dev,
 476                            struct device_attribute *devattr,
 477                            const char *buf, size_t count)
 478 {
 479         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 480         struct i2c_client *client = to_i2c_client(dev);
 481         struct adt7470_data *data = i2c_get_clientdata(client);
 482         long temp;
 483
 484         if (strict_strtol(buf, 10, &temp) || !temp)
 485                 return -EINVAL;
 486
 487         temp = FAN_RPM_TO_PERIOD(temp);
 488         temp = SENSORS_LIMIT(temp, 1, 65534);
 489
 490         mutex_lock(&data->lock);
 491         data->fan_min[attr->index] = temp;
 492         adt7470_write_word_data(client, ADT7470_REG_FAN_MIN(attr->index), temp);
 493         mutex_unlock(&data->lock);
 494
 495         return count;
 496 }
 497
 498 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 499                         char *buf)
 500 {
 501         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 502         struct adt7470_data *data = adt7470_update_device(dev);
 503
 504         if (FAN_DATA_VALID(data->fan[attr->index]))
 505                 return sprintf(buf, "%d\n",
 506                                FAN_PERIOD_TO_RPM(data->fan[attr->index]));
 507         else
 508                 return sprintf(buf, "0\n");
 509 }
 510
 511 static ssize_t show_force_pwm_max(struct device *dev,
 512                                   struct device_attribute *devattr,
 513                                   char *buf)
 514 {
 515         struct adt7470_data *data = adt7470_update_device(dev);
 516         return sprintf(buf, "%d\n", data->force_pwm_max);
 517 }
 518
 519 static ssize_t set_force_pwm_max(struct device *dev,
 520                                  struct device_attribute *devattr,
 521                                  const char *buf,
 522                                  size_t count)
 523 {
 524         struct i2c_client *client = to_i2c_client(dev);
 525         struct adt7470_data *data = i2c_get_clientdata(client);
 526         long temp;
 527         u8 reg;
 528
 529         if (strict_strtol(buf, 10, &temp))
 530                 return -EINVAL;
 531
 532         mutex_lock(&data->lock);
 533         data->force_pwm_max = temp;
 534         reg = i2c_smbus_read_byte_data(client, ADT7470_REG_CFG);
 535         if (temp)
 536                 reg |= ADT7470_FSPD_MASK;
 537         else
 538                 reg &= ~ADT7470_FSPD_MASK;
 539         i2c_smbus_write_byte_data(client, ADT7470_REG_CFG, reg);
 540         mutex_unlock(&data->lock);
 541
 542         return count;
 543 }
 544
 545 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
 546                         char *buf)
 547 {
 548         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 549         struct adt7470_data *data = adt7470_update_device(dev);
 550         return sprintf(buf, "%d\n", data->pwm[attr->index]);
 551 }
 552
 553 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
 554                         const char *buf, size_t count)
 555 {
 556         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 557         struct i2c_client *client = to_i2c_client(dev);
 558         struct adt7470_data *data = i2c_get_clientdata(client);
 559         long temp;
 560
 561         if (strict_strtol(buf, 10, &temp))
 562                 return -EINVAL;
 563
 564         temp = SENSORS_LIMIT(temp, 0, 255);
 565
 566         mutex_lock(&data->lock);
 567         data->pwm[attr->index] = temp;
 568         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM(attr->index), temp);
 569         mutex_unlock(&data->lock);
 570
 571         return count;
 572 }
 573
 574 static ssize_t show_pwm_max(struct device *dev,
 575                             struct device_attribute *devattr,
 576                             char *buf)
 577 {
 578         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 579         struct adt7470_data *data = adt7470_update_device(dev);
 580         return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
 581 }
 582
 583 static ssize_t set_pwm_max(struct device *dev,
 584                            struct device_attribute *devattr,
 585                            const char *buf,
 586                            size_t count)
 587 {
 588         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 589         struct i2c_client *client = to_i2c_client(dev);
 590         struct adt7470_data *data = i2c_get_clientdata(client);
 591         long temp;
 592
 593         if (strict_strtol(buf, 10, &temp))
 594                 return -EINVAL;
 595
 596         temp = SENSORS_LIMIT(temp, 0, 255);
 597
 598         mutex_lock(&data->lock);
 599         data->pwm_max[attr->index] = temp;
 600         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MAX(attr->index),
 601                                   temp);
 602         mutex_unlock(&data->lock);
 603
 604         return count;
 605 }
 606
 607 static ssize_t show_pwm_min(struct device *dev,
 608                             struct device_attribute *devattr,
 609                             char *buf)
 610 {
 611         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 612         struct adt7470_data *data = adt7470_update_device(dev);
 613         return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
 614 }
 615
 616 static ssize_t set_pwm_min(struct device *dev,
 617                            struct device_attribute *devattr,
 618                            const char *buf,
 619                            size_t count)
 620 {
 621         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 622         struct i2c_client *client = to_i2c_client(dev);
 623         struct adt7470_data *data = i2c_get_clientdata(client);
 624         long temp;
 625
 626         if (strict_strtol(buf, 10, &temp))
 627                 return -EINVAL;
 628
 629         temp = SENSORS_LIMIT(temp, 0, 255);
 630
 631         mutex_lock(&data->lock);
 632         data->pwm_min[attr->index] = temp;
 633         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_MIN(attr->index),
 634                                   temp);
 635         mutex_unlock(&data->lock);
 636
 637         return count;
 638 }
 639
 640 static ssize_t show_pwm_tmax(struct device *dev,
 641                              struct device_attribute *devattr,
 642                              char *buf)
 643 {
 644         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 645         struct adt7470_data *data = adt7470_update_device(dev);
 646         /* the datasheet says that tmax = tmin + 20C */
 647         return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
 648 }
 649
 650 static ssize_t show_pwm_tmin(struct device *dev,
 651                              struct device_attribute *devattr,
 652                              char *buf)
 653 {
 654         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 655         struct adt7470_data *data = adt7470_update_device(dev);
 656         return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
 657 }
 658
 659 static ssize_t set_pwm_tmin(struct device *dev,
 660                             struct device_attribute *devattr,
 661                             const char *buf,
 662                             size_t count)
 663 {
 664         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 665         struct i2c_client *client = to_i2c_client(dev);
 666         struct adt7470_data *data = i2c_get_clientdata(client);
 667         long temp;
 668
 669         if (strict_strtol(buf, 10, &temp))
 670                 return -EINVAL;
 671
 672         temp = DIV_ROUND_CLOSEST(temp, 1000);
 673         temp = SENSORS_LIMIT(temp, 0, 255);
 674
 675         mutex_lock(&data->lock);
 676         data->pwm_tmin[attr->index] = temp;
 677         i2c_smbus_write_byte_data(client, ADT7470_REG_PWM_TMIN(attr->index),
 678                                   temp);
 679         mutex_unlock(&data->lock);
 680
 681         return count;
 682 }
 683
 684 static ssize_t show_pwm_auto(struct device *dev,
 685                              struct device_attribute *devattr,
 686                              char *buf)
 687 {
 688         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 689         struct adt7470_data *data = adt7470_update_device(dev);
 690         return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
 691 }
 692
 693 static ssize_t set_pwm_auto(struct device *dev,
 694                             struct device_attribute *devattr,
 695                             const char *buf,
 696                             size_t count)
 697 {
 698         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 699         struct i2c_client *client = to_i2c_client(dev);
 700         struct adt7470_data *data = i2c_get_clientdata(client);
 701         int pwm_auto_reg = ADT7470_REG_PWM_CFG(attr->index);
 702         int pwm_auto_reg_mask;
 703         long temp;
 704         u8 reg;
 705
 706         if (strict_strtol(buf, 10, &temp))
 707                 return -EINVAL;
 708
 709         if (attr->index % 2)
 710                 pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
 711         else
 712                 pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
 713
 714         if (temp != 2 && temp != 1)
 715                 return -EINVAL;
 716         temp--;
 717
 718         mutex_lock(&data->lock);
 719         data->pwm_automatic[attr->index] = temp;
 720         reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
 721         if (temp)
 722                 reg |= pwm_auto_reg_mask;
 723         else
 724                 reg &= ~pwm_auto_reg_mask;
 725         i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
 726         mutex_unlock(&data->lock);
 727
 728         return count;
 729 }
 730
 731 static ssize_t show_pwm_auto_temp(struct device *dev,
 732                                   struct device_attribute *devattr,
 733                                   char *buf)
 734 {
 735         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 736         struct adt7470_data *data = adt7470_update_device(dev);
 737         u8 ctrl = data->pwm_auto_temp[attr->index];
 738
 739         if (ctrl)
 740                 return sprintf(buf, "%d\n", 1 << (ctrl - 1));
 741         else
 742                 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
 743 }
 744
 745 static int cvt_auto_temp(int input)
 746 {
 747         if (input == ADT7470_PWM_ALL_TEMPS)
 748                 return 0;
 749         if (input < 1 || !is_power_of_2(input))
 750                 return -EINVAL;
 751         return ilog2(input) + 1;
 752 }
 753
 754 static ssize_t set_pwm_auto_temp(struct device *dev,
 755                                  struct device_attribute *devattr,
 756                                  const char *buf,
 757                                  size_t count)
 758 {
 759         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 760         struct i2c_client *client = to_i2c_client(dev);
 761         struct adt7470_data *data = i2c_get_clientdata(client);
 762         int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
 763         long temp;
 764         u8 reg;
 765
 766         if (strict_strtol(buf, 10, &temp))
 767                 return -EINVAL;
 768
 769         temp = cvt_auto_temp(temp);
 770         if (temp < 0)
 771                 return temp;
 772
 773         mutex_lock(&data->lock);
 774         data->pwm_automatic[attr->index] = temp;
 775         reg = i2c_smbus_read_byte_data(client, pwm_auto_reg);
 776
 777         if (!(attr->index % 2)) {
 778                 reg &= 0xF;
 779                 reg |= (temp << 4) & 0xF0;
 780         } else {
 781                 reg &= 0xF0;
 782                 reg |= temp & 0xF;
 783         }
 784
 785         i2c_smbus_write_byte_data(client, pwm_auto_reg, reg);
 786         mutex_unlock(&data->lock);
 787
 788         return count;
 789 }
 790
 791 static ssize_t show_alarm(struct device *dev,
 792                           struct device_attribute *devattr,
 793                           char *buf)
 794 {
 795         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 796         struct adt7470_data *data = adt7470_update_device(dev);
 797
 798         if (data->alarm & attr->index)
 799                 return sprintf(buf, "1\n");
 800         else
 801                 return sprintf(buf, "0\n");
 802 }
 803
 804 static DEVICE_ATTR(alarm_mask, S_IRUGO, show_alarm_mask, NULL);
 805
 806 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
 807                     set_temp_max, 0);
 808 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
 809                     set_temp_max, 1);
 810 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
 811                     set_temp_max, 2);
 812 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
 813                     set_temp_max, 3);
 814 static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_temp_max,
 815                     set_temp_max, 4);
 816 static SENSOR_DEVICE_ATTR(temp6_max, S_IWUSR | S_IRUGO, show_temp_max,
 817                     set_temp_max, 5);
 818 static SENSOR_DEVICE_ATTR(temp7_max, S_IWUSR | S_IRUGO, show_temp_max,
 819                     set_temp_max, 6);
 820 static SENSOR_DEVICE_ATTR(temp8_max, S_IWUSR | S_IRUGO, show_temp_max,
 821                     set_temp_max, 7);
 822 static SENSOR_DEVICE_ATTR(temp9_max, S_IWUSR | S_IRUGO, show_temp_max,
 823                     set_temp_max, 8);
 824 static SENSOR_DEVICE_ATTR(temp10_max, S_IWUSR | S_IRUGO, show_temp_max,
 825                     set_temp_max, 9);
 826
 827 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
 828                     set_temp_min, 0);
 829 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
 830                     set_temp_min, 1);
 831 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
 832                     set_temp_min, 2);
 833 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
 834                     set_temp_min, 3);
 835 static SENSOR_DEVICE_ATTR(temp5_min, S_IWUSR | S_IRUGO, show_temp_min,
 836                     set_temp_min, 4);
 837 static SENSOR_DEVICE_ATTR(temp6_min, S_IWUSR | S_IRUGO, show_temp_min,
 838                     set_temp_min, 5);
 839 static SENSOR_DEVICE_ATTR(temp7_min, S_IWUSR | S_IRUGO, show_temp_min,
 840                     set_temp_min, 6);
 841 static SENSOR_DEVICE_ATTR(temp8_min, S_IWUSR | S_IRUGO, show_temp_min,
 842                     set_temp_min, 7);
 843 static SENSOR_DEVICE_ATTR(temp9_min, S_IWUSR | S_IRUGO, show_temp_min,
 844                     set_temp_min, 8);
 845 static SENSOR_DEVICE_ATTR(temp10_min, S_IWUSR | S_IRUGO, show_temp_min,
 846                     set_temp_min, 9);
 847
 848 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 849 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
 850 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
 851 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
 852 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
 853 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5);
 854 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6);
 855 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7);
 856 static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8);
 857 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp, NULL, 9);
 858
 859 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
 860                           ADT7470_R1T_ALARM);
 861 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
 862                           ADT7470_R2T_ALARM);
 863 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
 864                           ADT7470_R3T_ALARM);
 865 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
 866                           ADT7470_R4T_ALARM);
 867 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO, show_alarm, NULL,
 868                           ADT7470_R5T_ALARM);
 869 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO, show_alarm, NULL,
 870                           ADT7470_R6T_ALARM);
 871 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO, show_alarm, NULL,
 872                           ADT7470_R7T_ALARM);
 873 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO, show_alarm, NULL,
 874                           ALARM2(ADT7470_R8T_ALARM));
 875 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO, show_alarm, NULL,
 876                           ALARM2(ADT7470_R9T_ALARM));
 877 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO, show_alarm, NULL,
 878                           ALARM2(ADT7470_R10T_ALARM));
 879
 880 static SENSOR_DEVICE_ATTR(fan1_max, S_IWUSR | S_IRUGO, show_fan_max,
 881                     set_fan_max, 0);
 882 static SENSOR_DEVICE_ATTR(fan2_max, S_IWUSR | S_IRUGO, show_fan_max,
 883                     set_fan_max, 1);
 884 static SENSOR_DEVICE_ATTR(fan3_max, S_IWUSR | S_IRUGO, show_fan_max,
 885                     set_fan_max, 2);
 886 static SENSOR_DEVICE_ATTR(fan4_max, S_IWUSR | S_IRUGO, show_fan_max,
 887                     set_fan_max, 3);
 888
 889 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
 890                     set_fan_min, 0);
 891 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
 892                     set_fan_min, 1);
 893 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
 894                     set_fan_min, 2);
 895 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
 896                     set_fan_min, 3);
 897
 898 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
 899 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
 900 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
 901 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
 902
 903 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
 904                           ALARM2(ADT7470_FAN1_ALARM));
 905 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
 906                           ALARM2(ADT7470_FAN2_ALARM));
 907 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
 908                           ALARM2(ADT7470_FAN3_ALARM));
 909 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
 910                           ALARM2(ADT7470_FAN4_ALARM));
 911
 912 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
 913                     show_force_pwm_max, set_force_pwm_max, 0);
 914
 915 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
 916 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
 917 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
 918 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
 919
 920 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
 921                     show_pwm_min, set_pwm_min, 0);
 922 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
 923                     show_pwm_min, set_pwm_min, 1);
 924 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
 925                     show_pwm_min, set_pwm_min, 2);
 926 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
 927                     show_pwm_min, set_pwm_min, 3);
 928
 929 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
 930                     show_pwm_max, set_pwm_max, 0);
 931 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
 932                     show_pwm_max, set_pwm_max, 1);
 933 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
 934                     show_pwm_max, set_pwm_max, 2);
 935 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
 936                     show_pwm_max, set_pwm_max, 3);
 937
 938 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
 939                     show_pwm_tmin, set_pwm_tmin, 0);
 940 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_temp, S_IWUSR | S_IRUGO,
 941                     show_pwm_tmin, set_pwm_tmin, 1);
 942 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_temp, S_IWUSR | S_IRUGO,
 943                     show_pwm_tmin, set_pwm_tmin, 2);
 944 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_temp, S_IWUSR | S_IRUGO,
 945                     show_pwm_tmin, set_pwm_tmin, 3);
 946
 947 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 948                     NULL, 0);
 949 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 950                     NULL, 1);
 951 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 952                     NULL, 2);
 953 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_temp, S_IRUGO, show_pwm_tmax,
 954                     NULL, 3);
 955
 956 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 957                     set_pwm_auto, 0);
 958 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 959                     set_pwm_auto, 1);
 960 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 961                     set_pwm_auto, 2);
 962 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
 963                     set_pwm_auto, 3);
 964
 965 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
 966                     show_pwm_auto_temp, set_pwm_auto_temp, 0);
 967 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
 968                     show_pwm_auto_temp, set_pwm_auto_temp, 1);
 969 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
 970                     show_pwm_auto_temp, set_pwm_auto_temp, 2);
 971 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
 972                     show_pwm_auto_temp, set_pwm_auto_temp, 3);
 973
 974 static struct attribute *adt7470_attr[] =
 975 {
 976         &dev_attr_alarm_mask.attr,
 977         &sensor_dev_attr_temp1_max.dev_attr.attr,
 978         &sensor_dev_attr_temp2_max.dev_attr.attr,
 979         &sensor_dev_attr_temp3_max.dev_attr.attr,
 980         &sensor_dev_attr_temp4_max.dev_attr.attr,
 981         &sensor_dev_attr_temp5_max.dev_attr.attr,
 982         &sensor_dev_attr_temp6_max.dev_attr.attr,
 983         &sensor_dev_attr_temp7_max.dev_attr.attr,
 984         &sensor_dev_attr_temp8_max.dev_attr.attr,
 985         &sensor_dev_attr_temp9_max.dev_attr.attr,
 986         &sensor_dev_attr_temp10_max.dev_attr.attr,
 987         &sensor_dev_attr_temp1_min.dev_attr.attr,
 988         &sensor_dev_attr_temp2_min.dev_attr.attr,
 989         &sensor_dev_attr_temp3_min.dev_attr.attr,
 990         &sensor_dev_attr_temp4_min.dev_attr.attr,
 991         &sensor_dev_attr_temp5_min.dev_attr.attr,
 992         &sensor_dev_attr_temp6_min.dev_attr.attr,
 993         &sensor_dev_attr_temp7_min.dev_attr.attr,
 994         &sensor_dev_attr_temp8_min.dev_attr.attr,
 995         &sensor_dev_attr_temp9_min.dev_attr.attr,
 996         &sensor_dev_attr_temp10_min.dev_attr.attr,
 997         &sensor_dev_attr_temp1_input.dev_attr.attr,
 998         &sensor_dev_attr_temp2_input.dev_attr.attr,
 999         &sensor_dev_attr_temp3_input.dev_attr.attr,
1000         &sensor_dev_attr_temp4_input.dev_attr.attr,
1001         &sensor_dev_attr_temp5_input.dev_attr.attr,
1002         &sensor_dev_attr_temp6_input.dev_attr.attr,
1003         &sensor_dev_attr_temp7_input.dev_attr.attr,
1004         &sensor_dev_attr_temp8_input.dev_attr.attr,
1005         &sensor_dev_attr_temp9_input.dev_attr.attr,
1006         &sensor_dev_attr_temp10_input.dev_attr.attr,
1007         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1008         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1009         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1010         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1011         &sensor_dev_attr_temp5_alarm.dev_attr.attr,
1012         &sensor_dev_attr_temp6_alarm.dev_attr.attr,
1013         &sensor_dev_attr_temp7_alarm.dev_attr.attr,
1014         &sensor_dev_attr_temp8_alarm.dev_attr.attr,
1015         &sensor_dev_attr_temp9_alarm.dev_attr.attr,
1016         &sensor_dev_attr_temp10_alarm.dev_attr.attr,
1017         &sensor_dev_attr_fan1_max.dev_attr.attr,
1018         &sensor_dev_attr_fan2_max.dev_attr.attr,
1019         &sensor_dev_attr_fan3_max.dev_attr.attr,
1020         &sensor_dev_attr_fan4_max.dev_attr.attr,
1021         &sensor_dev_attr_fan1_min.dev_attr.attr,
1022         &sensor_dev_attr_fan2_min.dev_attr.attr,
1023         &sensor_dev_attr_fan3_min.dev_attr.attr,
1024         &sensor_dev_attr_fan4_min.dev_attr.attr,
1025         &sensor_dev_attr_fan1_input.dev_attr.attr,
1026         &sensor_dev_attr_fan2_input.dev_attr.attr,
1027         &sensor_dev_attr_fan3_input.dev_attr.attr,
1028         &sensor_dev_attr_fan4_input.dev_attr.attr,
1029         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1030         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1031         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1032         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1033         &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1034         &sensor_dev_attr_pwm1.dev_attr.attr,
1035         &sensor_dev_attr_pwm2.dev_attr.attr,
1036         &sensor_dev_attr_pwm3.dev_attr.attr,
1037         &sensor_dev_attr_pwm4.dev_attr.attr,
1038         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1039         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1040         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1041         &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1042         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1043         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1044         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1045         &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1046         &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1047         &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1048         &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1049         &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
1050         &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1051         &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1052         &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1053         &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
1054         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1055         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1056         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1057         &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1058         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1059         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1060         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1061         &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1062         NULL
1063 };
1064
1065 /* Return 0 if detection is successful, -ENODEV otherwise */
1066 static int adt7470_detect(struct i2c_client *client, int kind,
1067                           struct i2c_board_info *info)
1068 {
1069         struct i2c_adapter *adapter = client->adapter;
1070
1071         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1072                 return -ENODEV;
1073
1074         if (kind <= 0) {
1075                 int vendor, device, revision;
1076
1077                 vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
1078                 if (vendor != ADT7470_VENDOR)
1079                         return -ENODEV;
1080
1081                 device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
1082                 if (device != ADT7470_DEVICE)
1083                         return -ENODEV;
1084
1085                 revision = i2c_smbus_read_byte_data(client,
1086                                                     ADT7470_REG_REVISION);
1087                 if (revision != ADT7470_REVISION)
1088                         return -ENODEV;
1089         } else
1090                 dev_dbg(&adapter->dev, "detection forced\n");
1091
1092         strlcpy(info->type, "adt7470", I2C_NAME_SIZE);
1093
1094         return 0;
1095 }
1096
1097 static int adt7470_probe(struct i2c_client *client,
1098                          const struct i2c_device_id *id)
1099 {
1100         struct adt7470_data *data;
1101         int err;
1102
1103         data = kzalloc(sizeof(struct adt7470_data), GFP_KERNEL);
1104         if (!data) {
1105                 err = -ENOMEM;
1106                 goto exit;
1107         }
1108
1109         i2c_set_clientdata(client, data);
1110         mutex_init(&data->lock);
1111
1112         dev_info(&client->dev, "%s chip found\n", client->name);
1113
1114         /* Initialize the ADT7470 chip */
1115         adt7470_init_client(client);
1116
1117         /* Register sysfs hooks */
1118         data->attrs.attrs = adt7470_attr;
1119         if ((err = sysfs_create_group(&client->dev.kobj, &data->attrs)))
1120                 goto exit_free;
1121
1122         data->hwmon_dev = hwmon_device_register(&client->dev);
1123         if (IS_ERR(data->hwmon_dev)) {
1124                 err = PTR_ERR(data->hwmon_dev);
1125                 goto exit_remove;
1126         }
1127
1128         return 0;
1129
1130 exit_remove:
1131         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1132 exit_free:
1133         kfree(data);
1134 exit:
1135         return err;
1136 }
1137
1138 static int adt7470_remove(struct i2c_client *client)
1139 {
1140         struct adt7470_data *data = i2c_get_clientdata(client);
1141
1142         hwmon_device_unregister(data->hwmon_dev);
1143         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1144         kfree(data);
1145         return 0;
1146 }
1147
1148 static int __init adt7470_init(void)
1149 {
1150         return i2c_add_driver(&adt7470_driver);
1151 }
1152
1153 static void __exit adt7470_exit(void)
1154 {
1155         i2c_del_driver(&adt7470_driver);
1156 }
1157
1158 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1159 MODULE_DESCRIPTION("ADT7470 driver");
1160 MODULE_LICENSE("GPL");
1161
1162 module_init(adt7470_init);
1163 module_exit(adt7470_exit);