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