drivers/hwmon/adt7462.c

   1 /*
   2  * A hwmon driver for the Analog Devices ADT7462
   3  * Copyright (C) 2008 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 #include <linux/slab.h>
  32
  33 /* Addresses to scan */
  34 static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
  35
  36 /* ADT7462 registers */
  37 #define ADT7462_REG_DEVICE                      0x3D
  38 #define ADT7462_REG_VENDOR                      0x3E
  39 #define ADT7462_REG_REVISION                    0x3F
  40
  41 #define ADT7462_REG_MIN_TEMP_BASE_ADDR          0x44
  42 #define ADT7462_REG_MIN_TEMP_MAX_ADDR           0x47
  43 #define ADT7462_REG_MAX_TEMP_BASE_ADDR          0x48
  44 #define ADT7462_REG_MAX_TEMP_MAX_ADDR           0x4B
  45 #define ADT7462_REG_TEMP_BASE_ADDR              0x88
  46 #define ADT7462_REG_TEMP_MAX_ADDR               0x8F
  47
  48 #define ADT7462_REG_FAN_BASE_ADDR               0x98
  49 #define ADT7462_REG_FAN_MAX_ADDR                0x9F
  50 #define ADT7462_REG_FAN2_BASE_ADDR              0xA2
  51 #define ADT7462_REG_FAN2_MAX_ADDR               0xA9
  52 #define ADT7462_REG_FAN_ENABLE                  0x07
  53 #define ADT7462_REG_FAN_MIN_BASE_ADDR           0x78
  54 #define ADT7462_REG_FAN_MIN_MAX_ADDR            0x7F
  55
  56 #define ADT7462_REG_CFG2                        0x02
  57 #define         ADT7462_FSPD_MASK               0x20
  58
  59 #define ADT7462_REG_PWM_BASE_ADDR               0xAA
  60 #define ADT7462_REG_PWM_MAX_ADDR                0xAD
  61 #define ADT7462_REG_PWM_MIN_BASE_ADDR           0x28
  62 #define ADT7462_REG_PWM_MIN_MAX_ADDR            0x2B
  63 #define ADT7462_REG_PWM_MAX                     0x2C
  64 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR      0x5C
  65 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR       0x5F
  66 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR    0x60
  67 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR     0x63
  68 #define         ADT7462_PWM_HYST_MASK           0x0F
  69 #define         ADT7462_PWM_RANGE_MASK          0xF0
  70 #define         ADT7462_PWM_RANGE_SHIFT         4
  71 #define ADT7462_REG_PWM_CFG_BASE_ADDR           0x21
  72 #define ADT7462_REG_PWM_CFG_MAX_ADDR            0x24
  73 #define         ADT7462_PWM_CHANNEL_MASK        0xE0
  74 #define         ADT7462_PWM_CHANNEL_SHIFT       5
  75
  76 #define ADT7462_REG_PIN_CFG_BASE_ADDR           0x10
  77 #define ADT7462_REG_PIN_CFG_MAX_ADDR            0x13
  78 #define         ADT7462_PIN7_INPUT              0x01    /* cfg0 */
  79 #define         ADT7462_DIODE3_INPUT            0x20
  80 #define         ADT7462_DIODE1_INPUT            0x40
  81 #define         ADT7462_VID_INPUT               0x80
  82 #define         ADT7462_PIN22_INPUT             0x04    /* cfg1 */
  83 #define         ADT7462_PIN21_INPUT             0x08
  84 #define         ADT7462_PIN19_INPUT             0x10
  85 #define         ADT7462_PIN15_INPUT             0x20
  86 #define         ADT7462_PIN13_INPUT             0x40
  87 #define         ADT7462_PIN8_INPUT              0x80
  88 #define         ADT7462_PIN23_MASK              0x03
  89 #define         ADT7462_PIN23_SHIFT             0
  90 #define         ADT7462_PIN26_MASK              0x0C    /* cfg2 */
  91 #define         ADT7462_PIN26_SHIFT             2
  92 #define         ADT7462_PIN25_MASK              0x30
  93 #define         ADT7462_PIN25_SHIFT             4
  94 #define         ADT7462_PIN24_MASK              0xC0
  95 #define         ADT7462_PIN24_SHIFT             6
  96 #define         ADT7462_PIN26_VOLT_INPUT        0x08
  97 #define         ADT7462_PIN25_VOLT_INPUT        0x20
  98 #define         ADT7462_PIN28_SHIFT             4       /* cfg3 */
  99 #define         ADT7462_PIN28_VOLT              0x5
 100
 101 #define ADT7462_REG_ALARM1                      0xB8
 102 #define         ADT7462_LT_ALARM                0x02
 103 #define         ADT7462_R1T_ALARM               0x04
 104 #define         ADT7462_R2T_ALARM               0x08
 105 #define         ADT7462_R3T_ALARM               0x10
 106 #define ADT7462_REG_ALARM2                      0xBB
 107 #define         ADT7462_V0_ALARM                0x01
 108 #define         ADT7462_V1_ALARM                0x02
 109 #define         ADT7462_V2_ALARM                0x04
 110 #define         ADT7462_V3_ALARM                0x08
 111 #define         ADT7462_V4_ALARM                0x10
 112 #define         ADT7462_V5_ALARM                0x20
 113 #define         ADT7462_V6_ALARM                0x40
 114 #define         ADT7462_V7_ALARM                0x80
 115 #define ADT7462_REG_ALARM3                      0xBC
 116 #define         ADT7462_V8_ALARM                0x08
 117 #define         ADT7462_V9_ALARM                0x10
 118 #define         ADT7462_V10_ALARM               0x20
 119 #define         ADT7462_V11_ALARM               0x40
 120 #define         ADT7462_V12_ALARM               0x80
 121 #define ADT7462_REG_ALARM4                      0xBD
 122 #define         ADT7462_F0_ALARM                0x01
 123 #define         ADT7462_F1_ALARM                0x02
 124 #define         ADT7462_F2_ALARM                0x04
 125 #define         ADT7462_F3_ALARM                0x08
 126 #define         ADT7462_F4_ALARM                0x10
 127 #define         ADT7462_F5_ALARM                0x20
 128 #define         ADT7462_F6_ALARM                0x40
 129 #define         ADT7462_F7_ALARM                0x80
 130 #define ADT7462_ALARM1                          0x0000
 131 #define ADT7462_ALARM2                          0x0100
 132 #define ADT7462_ALARM3                          0x0200
 133 #define ADT7462_ALARM4                          0x0300
 134 #define ADT7462_ALARM_REG_SHIFT                 8
 135 #define ADT7462_ALARM_FLAG_MASK                 0x0F
 136
 137 #define ADT7462_TEMP_COUNT              4
 138 #define ADT7462_TEMP_REG(x)             (ADT7462_REG_TEMP_BASE_ADDR + (x * 2))
 139 #define ADT7462_TEMP_MIN_REG(x)         (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
 140 #define ADT7462_TEMP_MAX_REG(x)         (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
 141 #define TEMP_FRAC_OFFSET                6
 142
 143 #define ADT7462_FAN_COUNT               8
 144 #define ADT7462_REG_FAN_MIN(x)          (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
 145
 146 #define ADT7462_PWM_COUNT               4
 147 #define ADT7462_REG_PWM(x)              (ADT7462_REG_PWM_BASE_ADDR + (x))
 148 #define ADT7462_REG_PWM_MIN(x)          (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
 149 #define ADT7462_REG_PWM_TMIN(x)         \
 150         (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
 151 #define ADT7462_REG_PWM_TRANGE(x)       \
 152         (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
 153
 154 #define ADT7462_PIN_CFG_REG_COUNT       4
 155 #define ADT7462_REG_PIN_CFG(x)          (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
 156 #define ADT7462_REG_PWM_CFG(x)          (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
 157
 158 #define ADT7462_ALARM_REG_COUNT         4
 159
 160 /*
 161  * The chip can measure 13 different voltage sources:
 162  *
 163  * 1. +12V1 (pin 7)
 164  * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
 165  * 3. +12V3 (pin 22)
 166  * 4. +5V (pin 21)
 167  * 5. +1.25V/+0.9V (pin 19)
 168  * 6. +2.5V/+1.8V (pin 15)
 169  * 7. +3.3v (pin 13)
 170  * 8. +12V2 (pin 8)
 171  * 9. Vbatt/FSB_Vtt (pin 26)
 172  * A. +3.3V/+1.2V1 (pin 25)
 173  * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
 174  * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
 175  * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
 176  *
 177  * Each of these 13 has a factor to convert raw to voltage.  Even better,
 178  * the pins can be connected to other sensors (tach/gpio/hot/etc), which
 179  * makes the bookkeeping tricky.
 180  *
 181  * Some, but not all, of these voltages have low/high limits.
 182  */
 183 #define ADT7462_VOLT_COUNT      13
 184
 185 #define ADT7462_VENDOR          0x41
 186 #define ADT7462_DEVICE          0x62
 187 /* datasheet only mentions a revision 4 */
 188 #define ADT7462_REVISION        0x04
 189
 190 /* How often do we reread sensors values? (In jiffies) */
 191 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
 192
 193 /* How often do we reread sensor limit values? (In jiffies) */
 194 #define LIMIT_REFRESH_INTERVAL  (60 * HZ)
 195
 196 /* datasheet says to divide this number by the fan reading to get fan rpm */
 197 #define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
 198 #define FAN_RPM_TO_PERIOD       FAN_PERIOD_TO_RPM
 199 #define FAN_PERIOD_INVALID      65535
 200 #define FAN_DATA_VALID(x)       ((x) && (x) != FAN_PERIOD_INVALID)
 201
 202 #define MASK_AND_SHIFT(value, prefix)   \
 203         (((value) & prefix##_MASK) >> prefix##_SHIFT)
 204
 205 struct adt7462_data {
 206         struct device           *hwmon_dev;
 207         struct attribute_group  attrs;
 208         struct mutex            lock;
 209         char                    sensors_valid;
 210         char                    limits_valid;
 211         unsigned long           sensors_last_updated;   /* In jiffies */
 212         unsigned long           limits_last_updated;    /* In jiffies */
 213
 214         u8                      temp[ADT7462_TEMP_COUNT];
 215                                 /* bits 6-7 are quarter pieces of temp */
 216         u8                      temp_frac[ADT7462_TEMP_COUNT];
 217         u8                      temp_min[ADT7462_TEMP_COUNT];
 218         u8                      temp_max[ADT7462_TEMP_COUNT];
 219         u16                     fan[ADT7462_FAN_COUNT];
 220         u8                      fan_enabled;
 221         u8                      fan_min[ADT7462_FAN_COUNT];
 222         u8                      cfg2;
 223         u8                      pwm[ADT7462_PWM_COUNT];
 224         u8                      pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
 225         u8                      voltages[ADT7462_VOLT_COUNT];
 226         u8                      volt_max[ADT7462_VOLT_COUNT];
 227         u8                      volt_min[ADT7462_VOLT_COUNT];
 228         u8                      pwm_min[ADT7462_PWM_COUNT];
 229         u8                      pwm_tmin[ADT7462_PWM_COUNT];
 230         u8                      pwm_trange[ADT7462_PWM_COUNT];
 231         u8                      pwm_max;        /* only one per chip */
 232         u8                      pwm_cfg[ADT7462_PWM_COUNT];
 233         u8                      alarms[ADT7462_ALARM_REG_COUNT];
 234 };
 235
 236 static int adt7462_probe(struct i2c_client *client,
 237                          const struct i2c_device_id *id);
 238 static int adt7462_detect(struct i2c_client *client,
 239                           struct i2c_board_info *info);
 240 static int adt7462_remove(struct i2c_client *client);
 241
 242 static const struct i2c_device_id adt7462_id[] = {
 243         { "adt7462", 0 },
 244         { }
 245 };
 246 MODULE_DEVICE_TABLE(i2c, adt7462_id);
 247
 248 static struct i2c_driver adt7462_driver = {
 249         .class          = I2C_CLASS_HWMON,
 250         .driver = {
 251                 .name   = "adt7462",
 252         },
 253         .probe          = adt7462_probe,
 254         .remove         = adt7462_remove,
 255         .id_table       = adt7462_id,
 256         .detect         = adt7462_detect,
 257         .address_list   = normal_i2c,
 258 };
 259
 260 /*
 261  * 16-bit registers on the ADT7462 are low-byte first.  The data sheet says
 262  * that the low byte must be read before the high byte.
 263  */
 264 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
 265 {
 266         u16 foo;
 267         foo = i2c_smbus_read_byte_data(client, reg);
 268         foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
 269         return foo;
 270 }
 271
 272 /* For some reason these registers are not contiguous. */
 273 static int ADT7462_REG_FAN(int fan)
 274 {
 275         if (fan < 4)
 276                 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
 277         return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
 278 }
 279
 280 /* Voltage registers are scattered everywhere */
 281 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
 282 {
 283         switch (which) {
 284         case 0:
 285                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 286                         return 0x7C;
 287                 break;
 288         case 1:
 289                 return 0x69;
 290         case 2:
 291                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 292                         return 0x7F;
 293                 break;
 294         case 3:
 295                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 296                         return 0x7E;
 297                 break;
 298         case 4:
 299                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 300                         return 0x4B;
 301                 break;
 302         case 5:
 303                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 304                         return 0x49;
 305                 break;
 306         case 6:
 307                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 308                         return 0x68;
 309                 break;
 310         case 7:
 311                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 312                         return 0x7D;
 313                 break;
 314         case 8:
 315                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 316                         return 0x6C;
 317                 break;
 318         case 9:
 319                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 320                         return 0x6B;
 321                 break;
 322         case 10:
 323                 return 0x6A;
 324         case 11:
 325                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 326                                         ADT7462_PIN28_VOLT &&
 327                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 328                         return 0x50;
 329                 break;
 330         case 12:
 331                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 332                                         ADT7462_PIN28_VOLT &&
 333                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 334                         return 0x4C;
 335                 break;
 336         }
 337         return -ENODEV;
 338 }
 339
 340 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
 341 {
 342         switch (which) {
 343         case 0:
 344                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 345                         return 0x6D;
 346                 break;
 347         case 1:
 348                 return 0x72;
 349         case 2:
 350                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 351                         return 0x6F;
 352                 break;
 353         case 3:
 354                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 355                         return 0x71;
 356                 break;
 357         case 4:
 358                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 359                         return 0x47;
 360                 break;
 361         case 5:
 362                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 363                         return 0x45;
 364                 break;
 365         case 6:
 366                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 367                         return 0x70;
 368                 break;
 369         case 7:
 370                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 371                         return 0x6E;
 372                 break;
 373         case 8:
 374                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 375                         return 0x75;
 376                 break;
 377         case 9:
 378                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 379                         return 0x74;
 380                 break;
 381         case 10:
 382                 return 0x73;
 383         case 11:
 384                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 385                                         ADT7462_PIN28_VOLT &&
 386                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 387                         return 0x76;
 388                 break;
 389         case 12:
 390                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 391                                         ADT7462_PIN28_VOLT &&
 392                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 393                         return 0x77;
 394                 break;
 395         }
 396         return -ENODEV;
 397 }
 398
 399 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
 400 {
 401         switch (which) {
 402         case 0:
 403                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 404                         return 0xA3;
 405                 break;
 406         case 1:
 407                 return 0x90;
 408         case 2:
 409                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 410                         return 0xA9;
 411                 break;
 412         case 3:
 413                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 414                         return 0xA7;
 415                 break;
 416         case 4:
 417                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 418                         return 0x8F;
 419                 break;
 420         case 5:
 421                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 422                         return 0x8B;
 423                 break;
 424         case 6:
 425                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 426                         return 0x96;
 427                 break;
 428         case 7:
 429                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 430                         return 0xA5;
 431                 break;
 432         case 8:
 433                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 434                         return 0x93;
 435                 break;
 436         case 9:
 437                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 438                         return 0x92;
 439                 break;
 440         case 10:
 441                 return 0x91;
 442         case 11:
 443                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 444                                         ADT7462_PIN28_VOLT &&
 445                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 446                         return 0x94;
 447                 break;
 448         case 12:
 449                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 450                                         ADT7462_PIN28_VOLT &&
 451                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 452                         return 0x95;
 453                 break;
 454         }
 455         return -ENODEV;
 456 }
 457
 458 /* Provide labels for sysfs */
 459 static const char *voltage_label(struct adt7462_data *data, int which)
 460 {
 461         switch (which) {
 462         case 0:
 463                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 464                         return "+12V1";
 465                 break;
 466         case 1:
 467                 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 468                 case 0:
 469                         return "Vccp1";
 470                 case 1:
 471                         return "+2.5V";
 472                 case 2:
 473                         return "+1.8V";
 474                 case 3:
 475                         return "+1.5V";
 476                 }
 477         case 2:
 478                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 479                         return "+12V3";
 480                 break;
 481         case 3:
 482                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 483                         return "+5V";
 484                 break;
 485         case 4:
 486                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 487                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 488                                 return "+0.9V";
 489                         return "+1.25V";
 490                 }
 491                 break;
 492         case 5:
 493                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 494                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 495                                 return "+1.8V";
 496                         return "+2.5V";
 497                 }
 498                 break;
 499         case 6:
 500                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 501                         return "+3.3V";
 502                 break;
 503         case 7:
 504                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 505                         return "+12V2";
 506                 break;
 507         case 8:
 508                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 509                 case 0:
 510                         return "Vbatt";
 511                 case 1:
 512                         return "FSB_Vtt";
 513                 }
 514                 break;
 515         case 9:
 516                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 517                 case 0:
 518                         return "+3.3V";
 519                 case 1:
 520                         return "+1.2V1";
 521                 }
 522                 break;
 523         case 10:
 524                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 525                 case 0:
 526                         return "Vccp2";
 527                 case 1:
 528                         return "+2.5V";
 529                 case 2:
 530                         return "+1.8V";
 531                 case 3:
 532                         return "+1.5";
 533                 }
 534         case 11:
 535                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 536                                         ADT7462_PIN28_VOLT &&
 537                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 538                         return "+1.5V ICH";
 539                 break;
 540         case 12:
 541                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 542                                         ADT7462_PIN28_VOLT &&
 543                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 544                         return "+1.5V 3GPIO";
 545                 break;
 546         }
 547         return "N/A";
 548 }
 549
 550 /* Multipliers are actually in uV, not mV. */
 551 static int voltage_multiplier(struct adt7462_data *data, int which)
 552 {
 553         switch (which) {
 554         case 0:
 555                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 556                         return 62500;
 557                 break;
 558         case 1:
 559                 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 560                 case 0:
 561                         if (data->pin_cfg[0] & ADT7462_VID_INPUT)
 562                                 return 12500;
 563                         return 6250;
 564                 case 1:
 565                         return 13000;
 566                 case 2:
 567                         return 9400;
 568                 case 3:
 569                         return 7800;
 570                 }
 571         case 2:
 572                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 573                         return 62500;
 574                 break;
 575         case 3:
 576                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 577                         return 26000;
 578                 break;
 579         case 4:
 580                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 581                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 582                                 return 4690;
 583                         return 6500;
 584                 }
 585                 break;
 586         case 5:
 587                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 588                         if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
 589                                 return 9400;
 590                         return 13000;
 591                 }
 592                 break;
 593         case 6:
 594                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 595                         return 17200;
 596                 break;
 597         case 7:
 598                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 599                         return 62500;
 600                 break;
 601         case 8:
 602                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 603                 case 0:
 604                         return 15600;
 605                 case 1:
 606                         return 6250;
 607                 }
 608                 break;
 609         case 9:
 610                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 611                 case 0:
 612                         return 17200;
 613                 case 1:
 614                         return 6250;
 615                 }
 616                 break;
 617         case 10:
 618                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 619                 case 0:
 620                         return 6250;
 621                 case 1:
 622                         return 13000;
 623                 case 2:
 624                         return 9400;
 625                 case 3:
 626                         return 7800;
 627                 }
 628         case 11:
 629         case 12:
 630                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 631                                         ADT7462_PIN28_VOLT &&
 632                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 633                         return 7800;
 634         }
 635         return 0;
 636 }
 637
 638 static int temp_enabled(struct adt7462_data *data, int which)
 639 {
 640         switch (which) {
 641         case 0:
 642         case 2:
 643                 return 1;
 644         case 1:
 645                 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 646                         return 1;
 647                 break;
 648         case 3:
 649                 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 650                         return 1;
 651                 break;
 652         }
 653         return 0;
 654 }
 655
 656 static const char *temp_label(struct adt7462_data *data, int which)
 657 {
 658         switch (which) {
 659         case 0:
 660                 return "local";
 661         case 1:
 662                 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 663                         return "remote1";
 664                 break;
 665         case 2:
 666                 return "remote2";
 667         case 3:
 668                 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 669                         return "remote3";
 670                 break;
 671         }
 672         return "N/A";
 673 }
 674
 675 /* Map Trange register values to mC */
 676 #define NUM_TRANGE_VALUES       16
 677 static const int trange_values[NUM_TRANGE_VALUES] = {
 678         2000,
 679         2500,
 680         3300,
 681         4000,
 682         5000,
 683         6700,
 684         8000,
 685         10000,
 686         13300,
 687         16000,
 688         20000,
 689         26700,
 690         32000,
 691         40000,
 692         53300,
 693         80000
 694 };
 695
 696 static int find_trange_value(int trange)
 697 {
 698         int i;
 699
 700         for (i = 0; i < NUM_TRANGE_VALUES; i++)
 701                 if (trange_values[i] == trange)
 702                         return i;
 703
 704         return -ENODEV;
 705 }
 706
 707 static struct adt7462_data *adt7462_update_device(struct device *dev)
 708 {
 709         struct i2c_client *client = to_i2c_client(dev);
 710         struct adt7462_data *data = i2c_get_clientdata(client);
 711         unsigned long local_jiffies = jiffies;
 712         int i;
 713
 714         mutex_lock(&data->lock);
 715         if (time_before(local_jiffies, data->sensors_last_updated +
 716                 SENSOR_REFRESH_INTERVAL)
 717                 && data->sensors_valid)
 718                 goto no_sensor_update;
 719
 720         for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 721                 /*
 722                  * Reading the fractional register locks the integral
 723                  * register until both have been read.
 724                  */
 725                 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
 726                                                 ADT7462_TEMP_REG(i));
 727                 data->temp[i] = i2c_smbus_read_byte_data(client,
 728                                                 ADT7462_TEMP_REG(i) + 1);
 729         }
 730
 731         for (i = 0; i < ADT7462_FAN_COUNT; i++)
 732                 data->fan[i] = adt7462_read_word_data(client,
 733                                                 ADT7462_REG_FAN(i));
 734
 735         data->fan_enabled = i2c_smbus_read_byte_data(client,
 736                                         ADT7462_REG_FAN_ENABLE);
 737
 738         for (i = 0; i < ADT7462_PWM_COUNT; i++)
 739                 data->pwm[i] = i2c_smbus_read_byte_data(client,
 740                                                 ADT7462_REG_PWM(i));
 741
 742         for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
 743                 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
 744                                 ADT7462_REG_PIN_CFG(i));
 745
 746         for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 747                 int reg = ADT7462_REG_VOLT(data, i);
 748                 if (!reg)
 749                         data->voltages[i] = 0;
 750                 else
 751                         data->voltages[i] = i2c_smbus_read_byte_data(client,
 752                                                                      reg);
 753         }
 754
 755         data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
 756         data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
 757         data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
 758         data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
 759
 760         data->sensors_last_updated = local_jiffies;
 761         data->sensors_valid = 1;
 762
 763 no_sensor_update:
 764         if (time_before(local_jiffies, data->limits_last_updated +
 765                 LIMIT_REFRESH_INTERVAL)
 766                 && data->limits_valid)
 767                 goto out;
 768
 769         for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 770                 data->temp_min[i] = i2c_smbus_read_byte_data(client,
 771                                                 ADT7462_TEMP_MIN_REG(i));
 772                 data->temp_max[i] = i2c_smbus_read_byte_data(client,
 773                                                 ADT7462_TEMP_MAX_REG(i));
 774         }
 775
 776         for (i = 0; i < ADT7462_FAN_COUNT; i++)
 777                 data->fan_min[i] = i2c_smbus_read_byte_data(client,
 778                                                 ADT7462_REG_FAN_MIN(i));
 779
 780         for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 781                 int reg = ADT7462_REG_VOLT_MAX(data, i);
 782                 data->volt_max[i] =
 783                         (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 784
 785                 reg = ADT7462_REG_VOLT_MIN(data, i);
 786                 data->volt_min[i] =
 787                         (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 788         }
 789
 790         for (i = 0; i < ADT7462_PWM_COUNT; i++) {
 791                 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
 792                                                 ADT7462_REG_PWM_MIN(i));
 793                 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
 794                                                 ADT7462_REG_PWM_TMIN(i));
 795                 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
 796                                                 ADT7462_REG_PWM_TRANGE(i));
 797                 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
 798                                                 ADT7462_REG_PWM_CFG(i));
 799         }
 800
 801         data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
 802
 803         data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
 804
 805         data->limits_last_updated = local_jiffies;
 806         data->limits_valid = 1;
 807
 808 out:
 809         mutex_unlock(&data->lock);
 810         return data;
 811 }
 812
 813 static ssize_t show_temp_min(struct device *dev,
 814                              struct device_attribute *devattr,
 815                              char *buf)
 816 {
 817         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 818         struct adt7462_data *data = adt7462_update_device(dev);
 819
 820         if (!temp_enabled(data, attr->index))
 821                 return sprintf(buf, "0\n");
 822
 823         return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
 824 }
 825
 826 static ssize_t set_temp_min(struct device *dev,
 827                             struct device_attribute *devattr,
 828                             const char *buf,
 829                             size_t count)
 830 {
 831         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 832         struct i2c_client *client = to_i2c_client(dev);
 833         struct adt7462_data *data = i2c_get_clientdata(client);
 834         long temp;
 835
 836         if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 837                 return -EINVAL;
 838
 839         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 840         temp = SENSORS_LIMIT(temp, 0, 255);
 841
 842         mutex_lock(&data->lock);
 843         data->temp_min[attr->index] = temp;
 844         i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
 845                                   temp);
 846         mutex_unlock(&data->lock);
 847
 848         return count;
 849 }
 850
 851 static ssize_t show_temp_max(struct device *dev,
 852                              struct device_attribute *devattr,
 853                              char *buf)
 854 {
 855         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 856         struct adt7462_data *data = adt7462_update_device(dev);
 857
 858         if (!temp_enabled(data, attr->index))
 859                 return sprintf(buf, "0\n");
 860
 861         return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
 862 }
 863
 864 static ssize_t set_temp_max(struct device *dev,
 865                             struct device_attribute *devattr,
 866                             const char *buf,
 867                             size_t count)
 868 {
 869         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 870         struct i2c_client *client = to_i2c_client(dev);
 871         struct adt7462_data *data = i2c_get_clientdata(client);
 872         long temp;
 873
 874         if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 875                 return -EINVAL;
 876
 877         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 878         temp = SENSORS_LIMIT(temp, 0, 255);
 879
 880         mutex_lock(&data->lock);
 881         data->temp_max[attr->index] = temp;
 882         i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
 883                                   temp);
 884         mutex_unlock(&data->lock);
 885
 886         return count;
 887 }
 888
 889 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 890                          char *buf)
 891 {
 892         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 893         struct adt7462_data *data = adt7462_update_device(dev);
 894         u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
 895
 896         if (!temp_enabled(data, attr->index))
 897                 return sprintf(buf, "0\n");
 898
 899         return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
 900                                      250 * frac);
 901 }
 902
 903 static ssize_t show_temp_label(struct device *dev,
 904                                struct device_attribute *devattr,
 905                                char *buf)
 906 {
 907         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 908         struct adt7462_data *data = adt7462_update_device(dev);
 909
 910         return sprintf(buf, "%s\n", temp_label(data, attr->index));
 911 }
 912
 913 static ssize_t show_volt_max(struct device *dev,
 914                              struct device_attribute *devattr,
 915                              char *buf)
 916 {
 917         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 918         struct adt7462_data *data = adt7462_update_device(dev);
 919         int x = voltage_multiplier(data, attr->index);
 920
 921         x *= data->volt_max[attr->index];
 922         x /= 1000; /* convert from uV to mV */
 923
 924         return sprintf(buf, "%d\n", x);
 925 }
 926
 927 static ssize_t set_volt_max(struct device *dev,
 928                             struct device_attribute *devattr,
 929                             const char *buf,
 930                             size_t count)
 931 {
 932         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 933         struct i2c_client *client = to_i2c_client(dev);
 934         struct adt7462_data *data = i2c_get_clientdata(client);
 935         int x = voltage_multiplier(data, attr->index);
 936         long temp;
 937
 938         if (strict_strtol(buf, 10, &temp) || !x)
 939                 return -EINVAL;
 940
 941         temp *= 1000; /* convert mV to uV */
 942         temp = DIV_ROUND_CLOSEST(temp, x);
 943         temp = SENSORS_LIMIT(temp, 0, 255);
 944
 945         mutex_lock(&data->lock);
 946         data->volt_max[attr->index] = temp;
 947         i2c_smbus_write_byte_data(client,
 948                                   ADT7462_REG_VOLT_MAX(data, attr->index),
 949                                   temp);
 950         mutex_unlock(&data->lock);
 951
 952         return count;
 953 }
 954
 955 static ssize_t show_volt_min(struct device *dev,
 956                              struct device_attribute *devattr,
 957                              char *buf)
 958 {
 959         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 960         struct adt7462_data *data = adt7462_update_device(dev);
 961         int x = voltage_multiplier(data, attr->index);
 962
 963         x *= data->volt_min[attr->index];
 964         x /= 1000; /* convert from uV to mV */
 965
 966         return sprintf(buf, "%d\n", x);
 967 }
 968
 969 static ssize_t set_volt_min(struct device *dev,
 970                             struct device_attribute *devattr,
 971                             const char *buf,
 972                             size_t count)
 973 {
 974         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 975         struct i2c_client *client = to_i2c_client(dev);
 976         struct adt7462_data *data = i2c_get_clientdata(client);
 977         int x = voltage_multiplier(data, attr->index);
 978         long temp;
 979
 980         if (strict_strtol(buf, 10, &temp) || !x)
 981                 return -EINVAL;
 982
 983         temp *= 1000; /* convert mV to uV */
 984         temp = DIV_ROUND_CLOSEST(temp, x);
 985         temp = SENSORS_LIMIT(temp, 0, 255);
 986
 987         mutex_lock(&data->lock);
 988         data->volt_min[attr->index] = temp;
 989         i2c_smbus_write_byte_data(client,
 990                                   ADT7462_REG_VOLT_MIN(data, attr->index),
 991                                   temp);
 992         mutex_unlock(&data->lock);
 993
 994         return count;
 995 }
 996
 997 static ssize_t show_voltage(struct device *dev,
 998                             struct device_attribute *devattr,
 999                             char *buf)
1000 {
1001         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1002         struct adt7462_data *data = adt7462_update_device(dev);
1003         int x = voltage_multiplier(data, attr->index);
1004
1005         x *= data->voltages[attr->index];
1006         x /= 1000; /* convert from uV to mV */
1007
1008         return sprintf(buf, "%d\n", x);
1009 }
1010
1011 static ssize_t show_voltage_label(struct device *dev,
1012                                   struct device_attribute *devattr,
1013                                   char *buf)
1014 {
1015         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1016         struct adt7462_data *data = adt7462_update_device(dev);
1017
1018         return sprintf(buf, "%s\n", voltage_label(data, attr->index));
1019 }
1020
1021 static ssize_t show_alarm(struct device *dev,
1022                           struct device_attribute *devattr,
1023                           char *buf)
1024 {
1025         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1026         struct adt7462_data *data = adt7462_update_device(dev);
1027         int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
1028         int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
1029
1030         if (data->alarms[reg] & mask)
1031                 return sprintf(buf, "1\n");
1032         else
1033                 return sprintf(buf, "0\n");
1034 }
1035
1036 static int fan_enabled(struct adt7462_data *data, int fan)
1037 {
1038         return data->fan_enabled & (1 << fan);
1039 }
1040
1041 static ssize_t show_fan_min(struct device *dev,
1042                             struct device_attribute *devattr,
1043                             char *buf)
1044 {
1045         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1046         struct adt7462_data *data = adt7462_update_device(dev);
1047         u16 temp;
1048
1049         /* Only the MSB of the min fan period is stored... */
1050         temp = data->fan_min[attr->index];
1051         temp <<= 8;
1052
1053         if (!fan_enabled(data, attr->index) ||
1054             !FAN_DATA_VALID(temp))
1055                 return sprintf(buf, "0\n");
1056
1057         return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1058 }
1059
1060 static ssize_t set_fan_min(struct device *dev,
1061                            struct device_attribute *devattr,
1062                            const char *buf, size_t count)
1063 {
1064         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1065         struct i2c_client *client = to_i2c_client(dev);
1066         struct adt7462_data *data = i2c_get_clientdata(client);
1067         long temp;
1068
1069         if (strict_strtol(buf, 10, &temp) || !temp ||
1070             !fan_enabled(data, attr->index))
1071                 return -EINVAL;
1072
1073         temp = FAN_RPM_TO_PERIOD(temp);
1074         temp >>= 8;
1075         temp = SENSORS_LIMIT(temp, 1, 255);
1076
1077         mutex_lock(&data->lock);
1078         data->fan_min[attr->index] = temp;
1079         i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1080                                   temp);
1081         mutex_unlock(&data->lock);
1082
1083         return count;
1084 }
1085
1086 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
1087                         char *buf)
1088 {
1089         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1090         struct adt7462_data *data = adt7462_update_device(dev);
1091
1092         if (!fan_enabled(data, attr->index) ||
1093             !FAN_DATA_VALID(data->fan[attr->index]))
1094                 return sprintf(buf, "0\n");
1095
1096         return sprintf(buf, "%d\n",
1097                        FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1098 }
1099
1100 static ssize_t show_force_pwm_max(struct device *dev,
1101                                   struct device_attribute *devattr,
1102                                   char *buf)
1103 {
1104         struct adt7462_data *data = adt7462_update_device(dev);
1105         return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1106 }
1107
1108 static ssize_t set_force_pwm_max(struct device *dev,
1109                                  struct device_attribute *devattr,
1110                                  const char *buf,
1111                                  size_t count)
1112 {
1113         struct i2c_client *client = to_i2c_client(dev);
1114         struct adt7462_data *data = i2c_get_clientdata(client);
1115         long temp;
1116         u8 reg;
1117
1118         if (strict_strtol(buf, 10, &temp))
1119                 return -EINVAL;
1120
1121         mutex_lock(&data->lock);
1122         reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1123         if (temp)
1124                 reg |= ADT7462_FSPD_MASK;
1125         else
1126                 reg &= ~ADT7462_FSPD_MASK;
1127         data->cfg2 = reg;
1128         i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1129         mutex_unlock(&data->lock);
1130
1131         return count;
1132 }
1133
1134 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
1135                         char *buf)
1136 {
1137         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1138         struct adt7462_data *data = adt7462_update_device(dev);
1139         return sprintf(buf, "%d\n", data->pwm[attr->index]);
1140 }
1141
1142 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
1143                         const char *buf, size_t count)
1144 {
1145         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1146         struct i2c_client *client = to_i2c_client(dev);
1147         struct adt7462_data *data = i2c_get_clientdata(client);
1148         long temp;
1149
1150         if (strict_strtol(buf, 10, &temp))
1151                 return -EINVAL;
1152
1153         temp = SENSORS_LIMIT(temp, 0, 255);
1154
1155         mutex_lock(&data->lock);
1156         data->pwm[attr->index] = temp;
1157         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1158         mutex_unlock(&data->lock);
1159
1160         return count;
1161 }
1162
1163 static ssize_t show_pwm_max(struct device *dev,
1164                             struct device_attribute *devattr,
1165                             char *buf)
1166 {
1167         struct adt7462_data *data = adt7462_update_device(dev);
1168         return sprintf(buf, "%d\n", data->pwm_max);
1169 }
1170
1171 static ssize_t set_pwm_max(struct device *dev,
1172                            struct device_attribute *devattr,
1173                            const char *buf,
1174                            size_t count)
1175 {
1176         struct i2c_client *client = to_i2c_client(dev);
1177         struct adt7462_data *data = i2c_get_clientdata(client);
1178         long temp;
1179
1180         if (strict_strtol(buf, 10, &temp))
1181                 return -EINVAL;
1182
1183         temp = SENSORS_LIMIT(temp, 0, 255);
1184
1185         mutex_lock(&data->lock);
1186         data->pwm_max = temp;
1187         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1188         mutex_unlock(&data->lock);
1189
1190         return count;
1191 }
1192
1193 static ssize_t show_pwm_min(struct device *dev,
1194                             struct device_attribute *devattr,
1195                             char *buf)
1196 {
1197         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1198         struct adt7462_data *data = adt7462_update_device(dev);
1199         return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1200 }
1201
1202 static ssize_t set_pwm_min(struct device *dev,
1203                            struct device_attribute *devattr,
1204                            const char *buf,
1205                            size_t count)
1206 {
1207         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1208         struct i2c_client *client = to_i2c_client(dev);
1209         struct adt7462_data *data = i2c_get_clientdata(client);
1210         long temp;
1211
1212         if (strict_strtol(buf, 10, &temp))
1213                 return -EINVAL;
1214
1215         temp = SENSORS_LIMIT(temp, 0, 255);
1216
1217         mutex_lock(&data->lock);
1218         data->pwm_min[attr->index] = temp;
1219         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1220                                   temp);
1221         mutex_unlock(&data->lock);
1222
1223         return count;
1224 }
1225
1226 static ssize_t show_pwm_hyst(struct device *dev,
1227                              struct device_attribute *devattr,
1228                              char *buf)
1229 {
1230         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1231         struct adt7462_data *data = adt7462_update_device(dev);
1232         return sprintf(buf, "%d\n", 1000 *
1233                       (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1234 }
1235
1236 static ssize_t set_pwm_hyst(struct device *dev,
1237                             struct device_attribute *devattr,
1238                             const char *buf,
1239                             size_t count)
1240 {
1241         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1242         struct i2c_client *client = to_i2c_client(dev);
1243         struct adt7462_data *data = i2c_get_clientdata(client);
1244         long temp;
1245
1246         if (strict_strtol(buf, 10, &temp))
1247                 return -EINVAL;
1248
1249         temp = DIV_ROUND_CLOSEST(temp, 1000);
1250         temp = SENSORS_LIMIT(temp, 0, 15);
1251
1252         /* package things up */
1253         temp &= ADT7462_PWM_HYST_MASK;
1254         temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1255
1256         mutex_lock(&data->lock);
1257         data->pwm_trange[attr->index] = temp;
1258         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1259                                   temp);
1260         mutex_unlock(&data->lock);
1261
1262         return count;
1263 }
1264
1265 static ssize_t show_pwm_tmax(struct device *dev,
1266                              struct device_attribute *devattr,
1267                              char *buf)
1268 {
1269         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1270         struct adt7462_data *data = adt7462_update_device(dev);
1271
1272         /* tmax = tmin + trange */
1273         int trange = trange_values[data->pwm_trange[attr->index] >>
1274                                    ADT7462_PWM_RANGE_SHIFT];
1275         int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1276
1277         return sprintf(buf, "%d\n", tmin + trange);
1278 }
1279
1280 static ssize_t set_pwm_tmax(struct device *dev,
1281                             struct device_attribute *devattr,
1282                             const char *buf,
1283                             size_t count)
1284 {
1285         int temp;
1286         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1287         struct i2c_client *client = to_i2c_client(dev);
1288         struct adt7462_data *data = i2c_get_clientdata(client);
1289         int tmin, trange_value;
1290         long trange;
1291
1292         if (strict_strtol(buf, 10, &trange))
1293                 return -EINVAL;
1294
1295         /* trange = tmax - tmin */
1296         tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1297         trange_value = find_trange_value(trange - tmin);
1298
1299         if (trange_value < 0)
1300                 return -EINVAL;
1301
1302         temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1303         temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1304
1305         mutex_lock(&data->lock);
1306         data->pwm_trange[attr->index] = temp;
1307         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1308                                   temp);
1309         mutex_unlock(&data->lock);
1310
1311         return count;
1312 }
1313
1314 static ssize_t show_pwm_tmin(struct device *dev,
1315                              struct device_attribute *devattr,
1316                              char *buf)
1317 {
1318         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1319         struct adt7462_data *data = adt7462_update_device(dev);
1320         return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1321 }
1322
1323 static ssize_t set_pwm_tmin(struct device *dev,
1324                             struct device_attribute *devattr,
1325                             const char *buf,
1326                             size_t count)
1327 {
1328         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1329         struct i2c_client *client = to_i2c_client(dev);
1330         struct adt7462_data *data = i2c_get_clientdata(client);
1331         long temp;
1332
1333         if (strict_strtol(buf, 10, &temp))
1334                 return -EINVAL;
1335
1336         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1337         temp = SENSORS_LIMIT(temp, 0, 255);
1338
1339         mutex_lock(&data->lock);
1340         data->pwm_tmin[attr->index] = temp;
1341         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1342                                   temp);
1343         mutex_unlock(&data->lock);
1344
1345         return count;
1346 }
1347
1348 static ssize_t show_pwm_auto(struct device *dev,
1349                              struct device_attribute *devattr,
1350                              char *buf)
1351 {
1352         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1353         struct adt7462_data *data = adt7462_update_device(dev);
1354         int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1355
1356         switch (cfg) {
1357         case 4: /* off */
1358                 return sprintf(buf, "0\n");
1359         case 7: /* manual */
1360                 return sprintf(buf, "1\n");
1361         default: /* automatic */
1362                 return sprintf(buf, "2\n");
1363         }
1364 }
1365
1366 static void set_pwm_channel(struct i2c_client *client,
1367                             struct adt7462_data *data,
1368                             int which,
1369                             int value)
1370 {
1371         int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1372         temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1373
1374         mutex_lock(&data->lock);
1375         data->pwm_cfg[which] = temp;
1376         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1377         mutex_unlock(&data->lock);
1378 }
1379
1380 static ssize_t set_pwm_auto(struct device *dev,
1381                             struct device_attribute *devattr,
1382                             const char *buf,
1383                             size_t count)
1384 {
1385         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1386         struct i2c_client *client = to_i2c_client(dev);
1387         struct adt7462_data *data = i2c_get_clientdata(client);
1388         long temp;
1389
1390         if (strict_strtol(buf, 10, &temp))
1391                 return -EINVAL;
1392
1393         switch (temp) {
1394         case 0: /* off */
1395                 set_pwm_channel(client, data, attr->index, 4);
1396                 return count;
1397         case 1: /* manual */
1398                 set_pwm_channel(client, data, attr->index, 7);
1399                 return count;
1400         default:
1401                 return -EINVAL;
1402         }
1403 }
1404
1405 static ssize_t show_pwm_auto_temp(struct device *dev,
1406                                   struct device_attribute *devattr,
1407                                   char *buf)
1408 {
1409         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1410         struct adt7462_data *data = adt7462_update_device(dev);
1411         int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1412
1413         switch (channel) {
1414         case 0: /* temp[1234] only */
1415         case 1:
1416         case 2:
1417         case 3:
1418                 return sprintf(buf, "%d\n", (1 << channel));
1419         case 5: /* temp1 & temp4  */
1420                 return sprintf(buf, "9\n");
1421         case 6:
1422                 return sprintf(buf, "15\n");
1423         default:
1424                 return sprintf(buf, "0\n");
1425         }
1426 }
1427
1428 static int cvt_auto_temp(int input)
1429 {
1430         if (input == 0xF)
1431                 return 6;
1432         if (input == 0x9)
1433                 return 5;
1434         if (input < 1 || !is_power_of_2(input))
1435                 return -EINVAL;
1436         return ilog2(input);
1437 }
1438
1439 static ssize_t set_pwm_auto_temp(struct device *dev,
1440                                  struct device_attribute *devattr,
1441                                  const char *buf,
1442                                  size_t count)
1443 {
1444         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1445         struct i2c_client *client = to_i2c_client(dev);
1446         struct adt7462_data *data = i2c_get_clientdata(client);
1447         long temp;
1448
1449         if (strict_strtol(buf, 10, &temp))
1450                 return -EINVAL;
1451
1452         temp = cvt_auto_temp(temp);
1453         if (temp < 0)
1454                 return temp;
1455
1456         set_pwm_channel(client, data, attr->index, temp);
1457
1458         return count;
1459 }
1460
1461 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
1462                     set_temp_max, 0);
1463 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
1464                     set_temp_max, 1);
1465 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
1466                     set_temp_max, 2);
1467 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
1468                     set_temp_max, 3);
1469
1470 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
1471                     set_temp_min, 0);
1472 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
1473                     set_temp_min, 1);
1474 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
1475                     set_temp_min, 2);
1476 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
1477                     set_temp_min, 3);
1478
1479 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1480 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1481 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1482 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
1483
1484 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
1485 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
1486 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
1487 static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
1488
1489 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
1490                           ADT7462_ALARM1 | ADT7462_LT_ALARM);
1491 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
1492                           ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1493 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
1494                           ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1495 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
1496                           ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1497
1498 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
1499                     set_volt_max, 0);
1500 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
1501                     set_volt_max, 1);
1502 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
1503                     set_volt_max, 2);
1504 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
1505                     set_volt_max, 3);
1506 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
1507                     set_volt_max, 4);
1508 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
1509                     set_volt_max, 5);
1510 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
1511                     set_volt_max, 6);
1512 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
1513                     set_volt_max, 7);
1514 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
1515                     set_volt_max, 8);
1516 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
1517                     set_volt_max, 9);
1518 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
1519                     set_volt_max, 10);
1520 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
1521                     set_volt_max, 11);
1522 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
1523                     set_volt_max, 12);
1524
1525 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
1526                     set_volt_min, 0);
1527 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
1528                     set_volt_min, 1);
1529 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
1530                     set_volt_min, 2);
1531 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
1532                     set_volt_min, 3);
1533 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
1534                     set_volt_min, 4);
1535 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
1536                     set_volt_min, 5);
1537 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
1538                     set_volt_min, 6);
1539 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
1540                     set_volt_min, 7);
1541 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
1542                     set_volt_min, 8);
1543 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
1544                     set_volt_min, 9);
1545 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
1546                     set_volt_min, 10);
1547 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
1548                     set_volt_min, 11);
1549 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
1550                     set_volt_min, 12);
1551
1552 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
1553 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
1554 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
1555 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
1556 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
1557 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
1558 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
1559 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
1560 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
1561 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
1562 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
1563 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
1564 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
1565
1566 static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
1567 static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
1568 static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
1569 static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
1570 static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
1571 static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
1572 static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
1573 static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
1574 static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
1575 static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
1576 static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
1577 static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
1578 static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
1579
1580 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
1581                           ADT7462_ALARM2 | ADT7462_V0_ALARM);
1582 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
1583                           ADT7462_ALARM2 | ADT7462_V7_ALARM);
1584 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
1585                           ADT7462_ALARM2 | ADT7462_V2_ALARM);
1586 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
1587                           ADT7462_ALARM2 | ADT7462_V6_ALARM);
1588 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
1589                           ADT7462_ALARM2 | ADT7462_V5_ALARM);
1590 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
1591                           ADT7462_ALARM2 | ADT7462_V4_ALARM);
1592 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
1593                           ADT7462_ALARM2 | ADT7462_V3_ALARM);
1594 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
1595                           ADT7462_ALARM2 | ADT7462_V1_ALARM);
1596 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
1597                           ADT7462_ALARM3 | ADT7462_V10_ALARM);
1598 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
1599                           ADT7462_ALARM3 | ADT7462_V9_ALARM);
1600 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
1601                           ADT7462_ALARM3 | ADT7462_V8_ALARM);
1602 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
1603                           ADT7462_ALARM3 | ADT7462_V11_ALARM);
1604 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
1605                           ADT7462_ALARM3 | ADT7462_V12_ALARM);
1606
1607 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1608                     set_fan_min, 0);
1609 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1610                     set_fan_min, 1);
1611 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1612                     set_fan_min, 2);
1613 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1614                     set_fan_min, 3);
1615 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1616                     set_fan_min, 4);
1617 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
1618                     set_fan_min, 5);
1619 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
1620                     set_fan_min, 6);
1621 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
1622                     set_fan_min, 7);
1623
1624 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1625 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1626 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1627 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1628 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
1629 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
1630 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
1631 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
1632
1633 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1634                           ADT7462_ALARM4 | ADT7462_F0_ALARM);
1635 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1636                           ADT7462_ALARM4 | ADT7462_F1_ALARM);
1637 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1638                           ADT7462_ALARM4 | ADT7462_F2_ALARM);
1639 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1640                           ADT7462_ALARM4 | ADT7462_F3_ALARM);
1641 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
1642                           ADT7462_ALARM4 | ADT7462_F4_ALARM);
1643 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
1644                           ADT7462_ALARM4 | ADT7462_F5_ALARM);
1645 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
1646                           ADT7462_ALARM4 | ADT7462_F6_ALARM);
1647 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
1648                           ADT7462_ALARM4 | ADT7462_F7_ALARM);
1649
1650 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1651                     show_force_pwm_max, set_force_pwm_max, 0);
1652
1653 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1654 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1655 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1656 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1657
1658 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1659                     show_pwm_min, set_pwm_min, 0);
1660 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1661                     show_pwm_min, set_pwm_min, 1);
1662 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1663                     show_pwm_min, set_pwm_min, 2);
1664 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1665                     show_pwm_min, set_pwm_min, 3);
1666
1667 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1668                     show_pwm_max, set_pwm_max, 0);
1669 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1670                     show_pwm_max, set_pwm_max, 1);
1671 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1672                     show_pwm_max, set_pwm_max, 2);
1673 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1674                     show_pwm_max, set_pwm_max, 3);
1675
1676 static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
1677                     show_pwm_hyst, set_pwm_hyst, 0);
1678 static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
1679                     show_pwm_hyst, set_pwm_hyst, 1);
1680 static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
1681                     show_pwm_hyst, set_pwm_hyst, 2);
1682 static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
1683                     show_pwm_hyst, set_pwm_hyst, 3);
1684
1685 static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
1686                     show_pwm_hyst, set_pwm_hyst, 0);
1687 static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
1688                     show_pwm_hyst, set_pwm_hyst, 1);
1689 static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
1690                     show_pwm_hyst, set_pwm_hyst, 2);
1691 static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
1692                     show_pwm_hyst, set_pwm_hyst, 3);
1693
1694 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
1695                     show_pwm_tmin, set_pwm_tmin, 0);
1696 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
1697                     show_pwm_tmin, set_pwm_tmin, 1);
1698 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
1699                     show_pwm_tmin, set_pwm_tmin, 2);
1700 static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
1701                     show_pwm_tmin, set_pwm_tmin, 3);
1702
1703 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
1704                     show_pwm_tmax, set_pwm_tmax, 0);
1705 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1706                     show_pwm_tmax, set_pwm_tmax, 1);
1707 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1708                     show_pwm_tmax, set_pwm_tmax, 2);
1709 static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
1710                     show_pwm_tmax, set_pwm_tmax, 3);
1711
1712 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1713                     set_pwm_auto, 0);
1714 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1715                     set_pwm_auto, 1);
1716 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1717                     set_pwm_auto, 2);
1718 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1719                     set_pwm_auto, 3);
1720
1721 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1722                     show_pwm_auto_temp, set_pwm_auto_temp, 0);
1723 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1724                     show_pwm_auto_temp, set_pwm_auto_temp, 1);
1725 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1726                     show_pwm_auto_temp, set_pwm_auto_temp, 2);
1727 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1728                     show_pwm_auto_temp, set_pwm_auto_temp, 3);
1729
1730 static struct attribute *adt7462_attr[] =
1731 {
1732         &sensor_dev_attr_temp1_max.dev_attr.attr,
1733         &sensor_dev_attr_temp2_max.dev_attr.attr,
1734         &sensor_dev_attr_temp3_max.dev_attr.attr,
1735         &sensor_dev_attr_temp4_max.dev_attr.attr,
1736
1737         &sensor_dev_attr_temp1_min.dev_attr.attr,
1738         &sensor_dev_attr_temp2_min.dev_attr.attr,
1739         &sensor_dev_attr_temp3_min.dev_attr.attr,
1740         &sensor_dev_attr_temp4_min.dev_attr.attr,
1741
1742         &sensor_dev_attr_temp1_input.dev_attr.attr,
1743         &sensor_dev_attr_temp2_input.dev_attr.attr,
1744         &sensor_dev_attr_temp3_input.dev_attr.attr,
1745         &sensor_dev_attr_temp4_input.dev_attr.attr,
1746
1747         &sensor_dev_attr_temp1_label.dev_attr.attr,
1748         &sensor_dev_attr_temp2_label.dev_attr.attr,
1749         &sensor_dev_attr_temp3_label.dev_attr.attr,
1750         &sensor_dev_attr_temp4_label.dev_attr.attr,
1751
1752         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1753         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1754         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1755         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1756
1757         &sensor_dev_attr_in1_max.dev_attr.attr,
1758         &sensor_dev_attr_in2_max.dev_attr.attr,
1759         &sensor_dev_attr_in3_max.dev_attr.attr,
1760         &sensor_dev_attr_in4_max.dev_attr.attr,
1761         &sensor_dev_attr_in5_max.dev_attr.attr,
1762         &sensor_dev_attr_in6_max.dev_attr.attr,
1763         &sensor_dev_attr_in7_max.dev_attr.attr,
1764         &sensor_dev_attr_in8_max.dev_attr.attr,
1765         &sensor_dev_attr_in9_max.dev_attr.attr,
1766         &sensor_dev_attr_in10_max.dev_attr.attr,
1767         &sensor_dev_attr_in11_max.dev_attr.attr,
1768         &sensor_dev_attr_in12_max.dev_attr.attr,
1769         &sensor_dev_attr_in13_max.dev_attr.attr,
1770
1771         &sensor_dev_attr_in1_min.dev_attr.attr,
1772         &sensor_dev_attr_in2_min.dev_attr.attr,
1773         &sensor_dev_attr_in3_min.dev_attr.attr,
1774         &sensor_dev_attr_in4_min.dev_attr.attr,
1775         &sensor_dev_attr_in5_min.dev_attr.attr,
1776         &sensor_dev_attr_in6_min.dev_attr.attr,
1777         &sensor_dev_attr_in7_min.dev_attr.attr,
1778         &sensor_dev_attr_in8_min.dev_attr.attr,
1779         &sensor_dev_attr_in9_min.dev_attr.attr,
1780         &sensor_dev_attr_in10_min.dev_attr.attr,
1781         &sensor_dev_attr_in11_min.dev_attr.attr,
1782         &sensor_dev_attr_in12_min.dev_attr.attr,
1783         &sensor_dev_attr_in13_min.dev_attr.attr,
1784
1785         &sensor_dev_attr_in1_input.dev_attr.attr,
1786         &sensor_dev_attr_in2_input.dev_attr.attr,
1787         &sensor_dev_attr_in3_input.dev_attr.attr,
1788         &sensor_dev_attr_in4_input.dev_attr.attr,
1789         &sensor_dev_attr_in5_input.dev_attr.attr,
1790         &sensor_dev_attr_in6_input.dev_attr.attr,
1791         &sensor_dev_attr_in7_input.dev_attr.attr,
1792         &sensor_dev_attr_in8_input.dev_attr.attr,
1793         &sensor_dev_attr_in9_input.dev_attr.attr,
1794         &sensor_dev_attr_in10_input.dev_attr.attr,
1795         &sensor_dev_attr_in11_input.dev_attr.attr,
1796         &sensor_dev_attr_in12_input.dev_attr.attr,
1797         &sensor_dev_attr_in13_input.dev_attr.attr,
1798
1799         &sensor_dev_attr_in1_label.dev_attr.attr,
1800         &sensor_dev_attr_in2_label.dev_attr.attr,
1801         &sensor_dev_attr_in3_label.dev_attr.attr,
1802         &sensor_dev_attr_in4_label.dev_attr.attr,
1803         &sensor_dev_attr_in5_label.dev_attr.attr,
1804         &sensor_dev_attr_in6_label.dev_attr.attr,
1805         &sensor_dev_attr_in7_label.dev_attr.attr,
1806         &sensor_dev_attr_in8_label.dev_attr.attr,
1807         &sensor_dev_attr_in9_label.dev_attr.attr,
1808         &sensor_dev_attr_in10_label.dev_attr.attr,
1809         &sensor_dev_attr_in11_label.dev_attr.attr,
1810         &sensor_dev_attr_in12_label.dev_attr.attr,
1811         &sensor_dev_attr_in13_label.dev_attr.attr,
1812
1813         &sensor_dev_attr_in1_alarm.dev_attr.attr,
1814         &sensor_dev_attr_in2_alarm.dev_attr.attr,
1815         &sensor_dev_attr_in3_alarm.dev_attr.attr,
1816         &sensor_dev_attr_in4_alarm.dev_attr.attr,
1817         &sensor_dev_attr_in5_alarm.dev_attr.attr,
1818         &sensor_dev_attr_in6_alarm.dev_attr.attr,
1819         &sensor_dev_attr_in7_alarm.dev_attr.attr,
1820         &sensor_dev_attr_in8_alarm.dev_attr.attr,
1821         &sensor_dev_attr_in9_alarm.dev_attr.attr,
1822         &sensor_dev_attr_in10_alarm.dev_attr.attr,
1823         &sensor_dev_attr_in11_alarm.dev_attr.attr,
1824         &sensor_dev_attr_in12_alarm.dev_attr.attr,
1825         &sensor_dev_attr_in13_alarm.dev_attr.attr,
1826
1827         &sensor_dev_attr_fan1_min.dev_attr.attr,
1828         &sensor_dev_attr_fan2_min.dev_attr.attr,
1829         &sensor_dev_attr_fan3_min.dev_attr.attr,
1830         &sensor_dev_attr_fan4_min.dev_attr.attr,
1831         &sensor_dev_attr_fan5_min.dev_attr.attr,
1832         &sensor_dev_attr_fan6_min.dev_attr.attr,
1833         &sensor_dev_attr_fan7_min.dev_attr.attr,
1834         &sensor_dev_attr_fan8_min.dev_attr.attr,
1835
1836         &sensor_dev_attr_fan1_input.dev_attr.attr,
1837         &sensor_dev_attr_fan2_input.dev_attr.attr,
1838         &sensor_dev_attr_fan3_input.dev_attr.attr,
1839         &sensor_dev_attr_fan4_input.dev_attr.attr,
1840         &sensor_dev_attr_fan5_input.dev_attr.attr,
1841         &sensor_dev_attr_fan6_input.dev_attr.attr,
1842         &sensor_dev_attr_fan7_input.dev_attr.attr,
1843         &sensor_dev_attr_fan8_input.dev_attr.attr,
1844
1845         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1846         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1847         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1848         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1849         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1850         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1851         &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1852         &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1853
1854         &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1855         &sensor_dev_attr_pwm1.dev_attr.attr,
1856         &sensor_dev_attr_pwm2.dev_attr.attr,
1857         &sensor_dev_attr_pwm3.dev_attr.attr,
1858         &sensor_dev_attr_pwm4.dev_attr.attr,
1859
1860         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1861         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1862         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1863         &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1864
1865         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1866         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1867         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1868         &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1869
1870         &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1871         &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1872         &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1873         &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1874
1875         &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1876         &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1877         &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1878         &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1879
1880         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1881         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1882         &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1883         &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1884
1885         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1886         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1887         &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1888         &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1889
1890         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1891         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1892         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1893         &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1894
1895         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1896         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1897         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1898         &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1899         NULL
1900 };
1901
1902 /* Return 0 if detection is successful, -ENODEV otherwise */
1903 static int adt7462_detect(struct i2c_client *client,
1904                           struct i2c_board_info *info)
1905 {
1906         struct i2c_adapter *adapter = client->adapter;
1907         int vendor, device, revision;
1908
1909         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1910                 return -ENODEV;
1911
1912         vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1913         if (vendor != ADT7462_VENDOR)
1914                 return -ENODEV;
1915
1916         device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1917         if (device != ADT7462_DEVICE)
1918                 return -ENODEV;
1919
1920         revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1921         if (revision != ADT7462_REVISION)
1922                 return -ENODEV;
1923
1924         strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1925
1926         return 0;
1927 }
1928
1929 static int adt7462_probe(struct i2c_client *client,
1930                          const struct i2c_device_id *id)
1931 {
1932         struct adt7462_data *data;
1933         int err;
1934
1935         data = kzalloc(sizeof(struct adt7462_data), GFP_KERNEL);
1936         if (!data) {
1937                 err = -ENOMEM;
1938                 goto exit;
1939         }
1940
1941         i2c_set_clientdata(client, data);
1942         mutex_init(&data->lock);
1943
1944         dev_info(&client->dev, "%s chip found\n", client->name);
1945
1946         /* Register sysfs hooks */
1947         data->attrs.attrs = adt7462_attr;
1948         err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1949         if (err)
1950                 goto exit_free;
1951
1952         data->hwmon_dev = hwmon_device_register(&client->dev);
1953         if (IS_ERR(data->hwmon_dev)) {
1954                 err = PTR_ERR(data->hwmon_dev);
1955                 goto exit_remove;
1956         }
1957
1958         return 0;
1959
1960 exit_remove:
1961         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1962 exit_free:
1963         kfree(data);
1964 exit:
1965         return err;
1966 }
1967
1968 static int adt7462_remove(struct i2c_client *client)
1969 {
1970         struct adt7462_data *data = i2c_get_clientdata(client);
1971
1972         hwmon_device_unregister(data->hwmon_dev);
1973         sysfs_remove_group(&client->dev.kobj, &data->attrs);
1974         kfree(data);
1975         return 0;
1976 }
1977
1978 static int __init adt7462_init(void)
1979 {
1980         return i2c_add_driver(&adt7462_driver);
1981 }
1982
1983 static void __exit adt7462_exit(void)
1984 {
1985         i2c_del_driver(&adt7462_driver);
1986 }
1987
1988 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1989 MODULE_DESCRIPTION("ADT7462 driver");
1990 MODULE_LICENSE("GPL");
1991
1992 module_init(adt7462_init);
1993 module_exit(adt7462_exit);