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 <darrick.wong@oracle.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/log2.h>
  30 #include <linux/slab.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 i2c_client       *client;
 206         struct mutex            lock;
 207         char                    sensors_valid;
 208         char                    limits_valid;
 209         unsigned long           sensors_last_updated;   /* In jiffies */
 210         unsigned long           limits_last_updated;    /* In jiffies */
 211
 212         u8                      temp[ADT7462_TEMP_COUNT];
 213                                 /* bits 6-7 are quarter pieces of temp */
 214         u8                      temp_frac[ADT7462_TEMP_COUNT];
 215         u8                      temp_min[ADT7462_TEMP_COUNT];
 216         u8                      temp_max[ADT7462_TEMP_COUNT];
 217         u16                     fan[ADT7462_FAN_COUNT];
 218         u8                      fan_enabled;
 219         u8                      fan_min[ADT7462_FAN_COUNT];
 220         u8                      cfg2;
 221         u8                      pwm[ADT7462_PWM_COUNT];
 222         u8                      pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
 223         u8                      voltages[ADT7462_VOLT_COUNT];
 224         u8                      volt_max[ADT7462_VOLT_COUNT];
 225         u8                      volt_min[ADT7462_VOLT_COUNT];
 226         u8                      pwm_min[ADT7462_PWM_COUNT];
 227         u8                      pwm_tmin[ADT7462_PWM_COUNT];
 228         u8                      pwm_trange[ADT7462_PWM_COUNT];
 229         u8                      pwm_max;        /* only one per chip */
 230         u8                      pwm_cfg[ADT7462_PWM_COUNT];
 231         u8                      alarms[ADT7462_ALARM_REG_COUNT];
 232 };
 233
 234 /*
 235  * 16-bit registers on the ADT7462 are low-byte first.  The data sheet says
 236  * that the low byte must be read before the high byte.
 237  */
 238 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
 239 {
 240         u16 foo;
 241         foo = i2c_smbus_read_byte_data(client, reg);
 242         foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
 243         return foo;
 244 }
 245
 246 /* For some reason these registers are not contiguous. */
 247 static int ADT7462_REG_FAN(int fan)
 248 {
 249         if (fan < 4)
 250                 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
 251         return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
 252 }
 253
 254 /* Voltage registers are scattered everywhere */
 255 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
 256 {
 257         switch (which) {
 258         case 0:
 259                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 260                         return 0x7C;
 261                 break;
 262         case 1:
 263                 return 0x69;
 264         case 2:
 265                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 266                         return 0x7F;
 267                 break;
 268         case 3:
 269                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 270                         return 0x7E;
 271                 break;
 272         case 4:
 273                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 274                         return 0x4B;
 275                 break;
 276         case 5:
 277                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 278                         return 0x49;
 279                 break;
 280         case 6:
 281                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 282                         return 0x68;
 283                 break;
 284         case 7:
 285                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 286                         return 0x7D;
 287                 break;
 288         case 8:
 289                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 290                         return 0x6C;
 291                 break;
 292         case 9:
 293                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 294                         return 0x6B;
 295                 break;
 296         case 10:
 297                 return 0x6A;
 298         case 11:
 299                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 300                                         ADT7462_PIN28_VOLT &&
 301                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 302                         return 0x50;
 303                 break;
 304         case 12:
 305                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 306                                         ADT7462_PIN28_VOLT &&
 307                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 308                         return 0x4C;
 309                 break;
 310         }
 311         return 0;
 312 }
 313
 314 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
 315 {
 316         switch (which) {
 317         case 0:
 318                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 319                         return 0x6D;
 320                 break;
 321         case 1:
 322                 return 0x72;
 323         case 2:
 324                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 325                         return 0x6F;
 326                 break;
 327         case 3:
 328                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 329                         return 0x71;
 330                 break;
 331         case 4:
 332                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 333                         return 0x47;
 334                 break;
 335         case 5:
 336                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 337                         return 0x45;
 338                 break;
 339         case 6:
 340                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 341                         return 0x70;
 342                 break;
 343         case 7:
 344                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 345                         return 0x6E;
 346                 break;
 347         case 8:
 348                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 349                         return 0x75;
 350                 break;
 351         case 9:
 352                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 353                         return 0x74;
 354                 break;
 355         case 10:
 356                 return 0x73;
 357         case 11:
 358                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 359                                         ADT7462_PIN28_VOLT &&
 360                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 361                         return 0x76;
 362                 break;
 363         case 12:
 364                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 365                                         ADT7462_PIN28_VOLT &&
 366                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 367                         return 0x77;
 368                 break;
 369         }
 370         return 0;
 371 }
 372
 373 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
 374 {
 375         switch (which) {
 376         case 0:
 377                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 378                         return 0xA3;
 379                 break;
 380         case 1:
 381                 return 0x90;
 382         case 2:
 383                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 384                         return 0xA9;
 385                 break;
 386         case 3:
 387                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 388                         return 0xA7;
 389                 break;
 390         case 4:
 391                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 392                         return 0x8F;
 393                 break;
 394         case 5:
 395                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 396                         return 0x8B;
 397                 break;
 398         case 6:
 399                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 400                         return 0x96;
 401                 break;
 402         case 7:
 403                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 404                         return 0xA5;
 405                 break;
 406         case 8:
 407                 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 408                         return 0x93;
 409                 break;
 410         case 9:
 411                 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 412                         return 0x92;
 413                 break;
 414         case 10:
 415                 return 0x91;
 416         case 11:
 417                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 418                                         ADT7462_PIN28_VOLT &&
 419                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 420                         return 0x94;
 421                 break;
 422         case 12:
 423                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 424                                         ADT7462_PIN28_VOLT &&
 425                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 426                         return 0x95;
 427                 break;
 428         }
 429         return -ENODEV;
 430 }
 431
 432 /* Provide labels for sysfs */
 433 static const char *voltage_label(struct adt7462_data *data, int which)
 434 {
 435         switch (which) {
 436         case 0:
 437                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 438                         return "+12V1";
 439                 break;
 440         case 1:
 441                 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 442                 case 0:
 443                         return "Vccp1";
 444                 case 1:
 445                         return "+2.5V";
 446                 case 2:
 447                         return "+1.8V";
 448                 case 3:
 449                         return "+1.5V";
 450                 }
 451                 /* fall through */
 452         case 2:
 453                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 454                         return "+12V3";
 455                 break;
 456         case 3:
 457                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 458                         return "+5V";
 459                 break;
 460         case 4:
 461                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 462                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 463                                 return "+0.9V";
 464                         return "+1.25V";
 465                 }
 466                 break;
 467         case 5:
 468                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 469                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 470                                 return "+1.8V";
 471                         return "+2.5V";
 472                 }
 473                 break;
 474         case 6:
 475                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 476                         return "+3.3V";
 477                 break;
 478         case 7:
 479                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 480                         return "+12V2";
 481                 break;
 482         case 8:
 483                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 484                 case 0:
 485                         return "Vbatt";
 486                 case 1:
 487                         return "FSB_Vtt";
 488                 }
 489                 break;
 490         case 9:
 491                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 492                 case 0:
 493                         return "+3.3V";
 494                 case 1:
 495                         return "+1.2V1";
 496                 }
 497                 break;
 498         case 10:
 499                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 500                 case 0:
 501                         return "Vccp2";
 502                 case 1:
 503                         return "+2.5V";
 504                 case 2:
 505                         return "+1.8V";
 506                 case 3:
 507                         return "+1.5";
 508                 }
 509                 /* fall through */
 510         case 11:
 511                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 512                                         ADT7462_PIN28_VOLT &&
 513                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 514                         return "+1.5V ICH";
 515                 break;
 516         case 12:
 517                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 518                                         ADT7462_PIN28_VOLT &&
 519                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 520                         return "+1.5V 3GPIO";
 521                 break;
 522         }
 523         return "N/A";
 524 }
 525
 526 /* Multipliers are actually in uV, not mV. */
 527 static int voltage_multiplier(struct adt7462_data *data, int which)
 528 {
 529         switch (which) {
 530         case 0:
 531                 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 532                         return 62500;
 533                 break;
 534         case 1:
 535                 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 536                 case 0:
 537                         if (data->pin_cfg[0] & ADT7462_VID_INPUT)
 538                                 return 12500;
 539                         return 6250;
 540                 case 1:
 541                         return 13000;
 542                 case 2:
 543                         return 9400;
 544                 case 3:
 545                         return 7800;
 546                 }
 547                 /* fall through */
 548         case 2:
 549                 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 550                         return 62500;
 551                 break;
 552         case 3:
 553                 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 554                         return 26000;
 555                 break;
 556         case 4:
 557                 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 558                         if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 559                                 return 4690;
 560                         return 6500;
 561                 }
 562                 break;
 563         case 5:
 564                 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 565                         if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
 566                                 return 9400;
 567                         return 13000;
 568                 }
 569                 break;
 570         case 6:
 571                 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 572                         return 17200;
 573                 break;
 574         case 7:
 575                 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 576                         return 62500;
 577                 break;
 578         case 8:
 579                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 580                 case 0:
 581                         return 15600;
 582                 case 1:
 583                         return 6250;
 584                 }
 585                 break;
 586         case 9:
 587                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 588                 case 0:
 589                         return 17200;
 590                 case 1:
 591                         return 6250;
 592                 }
 593                 break;
 594         case 10:
 595                 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 596                 case 0:
 597                         return 6250;
 598                 case 1:
 599                         return 13000;
 600                 case 2:
 601                         return 9400;
 602                 case 3:
 603                         return 7800;
 604                 }
 605                 /* fall through */
 606         case 11:
 607         case 12:
 608                 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 609                                         ADT7462_PIN28_VOLT &&
 610                     !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 611                         return 7800;
 612         }
 613         return 0;
 614 }
 615
 616 static int temp_enabled(struct adt7462_data *data, int which)
 617 {
 618         switch (which) {
 619         case 0:
 620         case 2:
 621                 return 1;
 622         case 1:
 623                 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 624                         return 1;
 625                 break;
 626         case 3:
 627                 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 628                         return 1;
 629                 break;
 630         }
 631         return 0;
 632 }
 633
 634 static const char *temp_label(struct adt7462_data *data, int which)
 635 {
 636         switch (which) {
 637         case 0:
 638                 return "local";
 639         case 1:
 640                 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 641                         return "remote1";
 642                 break;
 643         case 2:
 644                 return "remote2";
 645         case 3:
 646                 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 647                         return "remote3";
 648                 break;
 649         }
 650         return "N/A";
 651 }
 652
 653 /* Map Trange register values to mC */
 654 #define NUM_TRANGE_VALUES       16
 655 static const int trange_values[NUM_TRANGE_VALUES] = {
 656         2000,
 657         2500,
 658         3300,
 659         4000,
 660         5000,
 661         6700,
 662         8000,
 663         10000,
 664         13300,
 665         16000,
 666         20000,
 667         26700,
 668         32000,
 669         40000,
 670         53300,
 671         80000
 672 };
 673
 674 static int find_trange_value(int trange)
 675 {
 676         int i;
 677
 678         for (i = 0; i < NUM_TRANGE_VALUES; i++)
 679                 if (trange_values[i] == trange)
 680                         return i;
 681
 682         return -EINVAL;
 683 }
 684
 685 static struct adt7462_data *adt7462_update_device(struct device *dev)
 686 {
 687         struct adt7462_data *data = dev_get_drvdata(dev);
 688         struct i2c_client *client = data->client;
 689         unsigned long local_jiffies = jiffies;
 690         int i;
 691
 692         mutex_lock(&data->lock);
 693         if (time_before(local_jiffies, data->sensors_last_updated +
 694                 SENSOR_REFRESH_INTERVAL)
 695                 && data->sensors_valid)
 696                 goto no_sensor_update;
 697
 698         for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 699                 /*
 700                  * Reading the fractional register locks the integral
 701                  * register until both have been read.
 702                  */
 703                 data->temp_frac[i] = i2c_smbus_read_byte_data(client,
 704                                                 ADT7462_TEMP_REG(i));
 705                 data->temp[i] = i2c_smbus_read_byte_data(client,
 706                                                 ADT7462_TEMP_REG(i) + 1);
 707         }
 708
 709         for (i = 0; i < ADT7462_FAN_COUNT; i++)
 710                 data->fan[i] = adt7462_read_word_data(client,
 711                                                 ADT7462_REG_FAN(i));
 712
 713         data->fan_enabled = i2c_smbus_read_byte_data(client,
 714                                         ADT7462_REG_FAN_ENABLE);
 715
 716         for (i = 0; i < ADT7462_PWM_COUNT; i++)
 717                 data->pwm[i] = i2c_smbus_read_byte_data(client,
 718                                                 ADT7462_REG_PWM(i));
 719
 720         for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
 721                 data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
 722                                 ADT7462_REG_PIN_CFG(i));
 723
 724         for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 725                 int reg = ADT7462_REG_VOLT(data, i);
 726                 if (!reg)
 727                         data->voltages[i] = 0;
 728                 else
 729                         data->voltages[i] = i2c_smbus_read_byte_data(client,
 730                                                                      reg);
 731         }
 732
 733         data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
 734         data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
 735         data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
 736         data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
 737
 738         data->sensors_last_updated = local_jiffies;
 739         data->sensors_valid = 1;
 740
 741 no_sensor_update:
 742         if (time_before(local_jiffies, data->limits_last_updated +
 743                 LIMIT_REFRESH_INTERVAL)
 744                 && data->limits_valid)
 745                 goto out;
 746
 747         for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 748                 data->temp_min[i] = i2c_smbus_read_byte_data(client,
 749                                                 ADT7462_TEMP_MIN_REG(i));
 750                 data->temp_max[i] = i2c_smbus_read_byte_data(client,
 751                                                 ADT7462_TEMP_MAX_REG(i));
 752         }
 753
 754         for (i = 0; i < ADT7462_FAN_COUNT; i++)
 755                 data->fan_min[i] = i2c_smbus_read_byte_data(client,
 756                                                 ADT7462_REG_FAN_MIN(i));
 757
 758         for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 759                 int reg = ADT7462_REG_VOLT_MAX(data, i);
 760                 data->volt_max[i] =
 761                         (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 762
 763                 reg = ADT7462_REG_VOLT_MIN(data, i);
 764                 data->volt_min[i] =
 765                         (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 766         }
 767
 768         for (i = 0; i < ADT7462_PWM_COUNT; i++) {
 769                 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
 770                                                 ADT7462_REG_PWM_MIN(i));
 771                 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
 772                                                 ADT7462_REG_PWM_TMIN(i));
 773                 data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
 774                                                 ADT7462_REG_PWM_TRANGE(i));
 775                 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
 776                                                 ADT7462_REG_PWM_CFG(i));
 777         }
 778
 779         data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
 780
 781         data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
 782
 783         data->limits_last_updated = local_jiffies;
 784         data->limits_valid = 1;
 785
 786 out:
 787         mutex_unlock(&data->lock);
 788         return data;
 789 }
 790
 791 static ssize_t temp_min_show(struct device *dev,
 792                              struct device_attribute *devattr, char *buf)
 793 {
 794         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 795         struct adt7462_data *data = adt7462_update_device(dev);
 796
 797         if (!temp_enabled(data, attr->index))
 798                 return sprintf(buf, "0\n");
 799
 800         return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
 801 }
 802
 803 static ssize_t temp_min_store(struct device *dev,
 804                               struct device_attribute *devattr,
 805                               const char *buf, size_t count)
 806 {
 807         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 808         struct adt7462_data *data = dev_get_drvdata(dev);
 809         struct i2c_client *client = data->client;
 810         long temp;
 811
 812         if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 813                 return -EINVAL;
 814
 815         temp = clamp_val(temp, -64000, 191000);
 816         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 817
 818         mutex_lock(&data->lock);
 819         data->temp_min[attr->index] = temp;
 820         i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
 821                                   temp);
 822         mutex_unlock(&data->lock);
 823
 824         return count;
 825 }
 826
 827 static ssize_t temp_max_show(struct device *dev,
 828                              struct device_attribute *devattr, char *buf)
 829 {
 830         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 831         struct adt7462_data *data = adt7462_update_device(dev);
 832
 833         if (!temp_enabled(data, attr->index))
 834                 return sprintf(buf, "0\n");
 835
 836         return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
 837 }
 838
 839 static ssize_t temp_max_store(struct device *dev,
 840                               struct device_attribute *devattr,
 841                               const char *buf, size_t count)
 842 {
 843         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 844         struct adt7462_data *data = dev_get_drvdata(dev);
 845         struct i2c_client *client = data->client;
 846         long temp;
 847
 848         if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 849                 return -EINVAL;
 850
 851         temp = clamp_val(temp, -64000, 191000);
 852         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 853
 854         mutex_lock(&data->lock);
 855         data->temp_max[attr->index] = temp;
 856         i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
 857                                   temp);
 858         mutex_unlock(&data->lock);
 859
 860         return count;
 861 }
 862
 863 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
 864                          char *buf)
 865 {
 866         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 867         struct adt7462_data *data = adt7462_update_device(dev);
 868         u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
 869
 870         if (!temp_enabled(data, attr->index))
 871                 return sprintf(buf, "0\n");
 872
 873         return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
 874                                      250 * frac);
 875 }
 876
 877 static ssize_t temp_label_show(struct device *dev,
 878                                struct device_attribute *devattr, char *buf)
 879 {
 880         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 881         struct adt7462_data *data = adt7462_update_device(dev);
 882
 883         return sprintf(buf, "%s\n", temp_label(data, attr->index));
 884 }
 885
 886 static ssize_t volt_max_show(struct device *dev,
 887                              struct device_attribute *devattr, char *buf)
 888 {
 889         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 890         struct adt7462_data *data = adt7462_update_device(dev);
 891         int x = voltage_multiplier(data, attr->index);
 892
 893         x *= data->volt_max[attr->index];
 894         x /= 1000; /* convert from uV to mV */
 895
 896         return sprintf(buf, "%d\n", x);
 897 }
 898
 899 static ssize_t volt_max_store(struct device *dev,
 900                               struct device_attribute *devattr,
 901                               const char *buf, size_t count)
 902 {
 903         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 904         struct adt7462_data *data = dev_get_drvdata(dev);
 905         struct i2c_client *client = data->client;
 906         int x = voltage_multiplier(data, attr->index);
 907         long temp;
 908
 909         if (kstrtol(buf, 10, &temp) || !x)
 910                 return -EINVAL;
 911
 912         temp = clamp_val(temp, 0, 255 * x / 1000);
 913         temp *= 1000; /* convert mV to uV */
 914         temp = DIV_ROUND_CLOSEST(temp, x);
 915
 916         mutex_lock(&data->lock);
 917         data->volt_max[attr->index] = temp;
 918         i2c_smbus_write_byte_data(client,
 919                                   ADT7462_REG_VOLT_MAX(data, attr->index),
 920                                   temp);
 921         mutex_unlock(&data->lock);
 922
 923         return count;
 924 }
 925
 926 static ssize_t volt_min_show(struct device *dev,
 927                              struct device_attribute *devattr, char *buf)
 928 {
 929         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 930         struct adt7462_data *data = adt7462_update_device(dev);
 931         int x = voltage_multiplier(data, attr->index);
 932
 933         x *= data->volt_min[attr->index];
 934         x /= 1000; /* convert from uV to mV */
 935
 936         return sprintf(buf, "%d\n", x);
 937 }
 938
 939 static ssize_t volt_min_store(struct device *dev,
 940                               struct device_attribute *devattr,
 941                               const char *buf, size_t count)
 942 {
 943         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 944         struct adt7462_data *data = dev_get_drvdata(dev);
 945         struct i2c_client *client = data->client;
 946         int x = voltage_multiplier(data, attr->index);
 947         long temp;
 948
 949         if (kstrtol(buf, 10, &temp) || !x)
 950                 return -EINVAL;
 951
 952         temp = clamp_val(temp, 0, 255 * x / 1000);
 953         temp *= 1000; /* convert mV to uV */
 954         temp = DIV_ROUND_CLOSEST(temp, x);
 955
 956         mutex_lock(&data->lock);
 957         data->volt_min[attr->index] = temp;
 958         i2c_smbus_write_byte_data(client,
 959                                   ADT7462_REG_VOLT_MIN(data, attr->index),
 960                                   temp);
 961         mutex_unlock(&data->lock);
 962
 963         return count;
 964 }
 965
 966 static ssize_t voltage_show(struct device *dev,
 967                             struct device_attribute *devattr, char *buf)
 968 {
 969         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 970         struct adt7462_data *data = adt7462_update_device(dev);
 971         int x = voltage_multiplier(data, attr->index);
 972
 973         x *= data->voltages[attr->index];
 974         x /= 1000; /* convert from uV to mV */
 975
 976         return sprintf(buf, "%d\n", x);
 977 }
 978
 979 static ssize_t voltage_label_show(struct device *dev,
 980                                   struct device_attribute *devattr, char *buf)
 981 {
 982         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 983         struct adt7462_data *data = adt7462_update_device(dev);
 984
 985         return sprintf(buf, "%s\n", voltage_label(data, attr->index));
 986 }
 987
 988 static ssize_t alarm_show(struct device *dev,
 989                           struct device_attribute *devattr, char *buf)
 990 {
 991         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 992         struct adt7462_data *data = adt7462_update_device(dev);
 993         int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
 994         int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
 995
 996         if (data->alarms[reg] & mask)
 997                 return sprintf(buf, "1\n");
 998         else
 999                 return sprintf(buf, "0\n");
1000 }
1001
1002 static int fan_enabled(struct adt7462_data *data, int fan)
1003 {
1004         return data->fan_enabled & (1 << fan);
1005 }
1006
1007 static ssize_t fan_min_show(struct device *dev,
1008                             struct device_attribute *devattr, char *buf)
1009 {
1010         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1011         struct adt7462_data *data = adt7462_update_device(dev);
1012         u16 temp;
1013
1014         /* Only the MSB of the min fan period is stored... */
1015         temp = data->fan_min[attr->index];
1016         temp <<= 8;
1017
1018         if (!fan_enabled(data, attr->index) ||
1019             !FAN_DATA_VALID(temp))
1020                 return sprintf(buf, "0\n");
1021
1022         return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1023 }
1024
1025 static ssize_t fan_min_store(struct device *dev,
1026                              struct device_attribute *devattr,
1027                              const char *buf, size_t count)
1028 {
1029         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1030         struct adt7462_data *data = dev_get_drvdata(dev);
1031         struct i2c_client *client = data->client;
1032         long temp;
1033
1034         if (kstrtol(buf, 10, &temp) || !temp ||
1035             !fan_enabled(data, attr->index))
1036                 return -EINVAL;
1037
1038         temp = FAN_RPM_TO_PERIOD(temp);
1039         temp >>= 8;
1040         temp = clamp_val(temp, 1, 255);
1041
1042         mutex_lock(&data->lock);
1043         data->fan_min[attr->index] = temp;
1044         i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1045                                   temp);
1046         mutex_unlock(&data->lock);
1047
1048         return count;
1049 }
1050
1051 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
1052                         char *buf)
1053 {
1054         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1055         struct adt7462_data *data = adt7462_update_device(dev);
1056
1057         if (!fan_enabled(data, attr->index) ||
1058             !FAN_DATA_VALID(data->fan[attr->index]))
1059                 return sprintf(buf, "0\n");
1060
1061         return sprintf(buf, "%d\n",
1062                        FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1063 }
1064
1065 static ssize_t force_pwm_max_show(struct device *dev,
1066                                   struct device_attribute *devattr, char *buf)
1067 {
1068         struct adt7462_data *data = adt7462_update_device(dev);
1069         return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1070 }
1071
1072 static ssize_t force_pwm_max_store(struct device *dev,
1073                                    struct device_attribute *devattr,
1074                                    const char *buf, size_t count)
1075 {
1076         struct adt7462_data *data = dev_get_drvdata(dev);
1077         struct i2c_client *client = data->client;
1078         long temp;
1079         u8 reg;
1080
1081         if (kstrtol(buf, 10, &temp))
1082                 return -EINVAL;
1083
1084         mutex_lock(&data->lock);
1085         reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1086         if (temp)
1087                 reg |= ADT7462_FSPD_MASK;
1088         else
1089                 reg &= ~ADT7462_FSPD_MASK;
1090         data->cfg2 = reg;
1091         i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1092         mutex_unlock(&data->lock);
1093
1094         return count;
1095 }
1096
1097 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
1098                         char *buf)
1099 {
1100         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1101         struct adt7462_data *data = adt7462_update_device(dev);
1102         return sprintf(buf, "%d\n", data->pwm[attr->index]);
1103 }
1104
1105 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
1106                          const char *buf, size_t count)
1107 {
1108         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1109         struct adt7462_data *data = dev_get_drvdata(dev);
1110         struct i2c_client *client = data->client;
1111         long temp;
1112
1113         if (kstrtol(buf, 10, &temp))
1114                 return -EINVAL;
1115
1116         temp = clamp_val(temp, 0, 255);
1117
1118         mutex_lock(&data->lock);
1119         data->pwm[attr->index] = temp;
1120         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1121         mutex_unlock(&data->lock);
1122
1123         return count;
1124 }
1125
1126 static ssize_t pwm_max_show(struct device *dev,
1127                             struct device_attribute *devattr, char *buf)
1128 {
1129         struct adt7462_data *data = adt7462_update_device(dev);
1130         return sprintf(buf, "%d\n", data->pwm_max);
1131 }
1132
1133 static ssize_t pwm_max_store(struct device *dev,
1134                              struct device_attribute *devattr,
1135                              const char *buf, size_t count)
1136 {
1137         struct adt7462_data *data = dev_get_drvdata(dev);
1138         struct i2c_client *client = data->client;
1139         long temp;
1140
1141         if (kstrtol(buf, 10, &temp))
1142                 return -EINVAL;
1143
1144         temp = clamp_val(temp, 0, 255);
1145
1146         mutex_lock(&data->lock);
1147         data->pwm_max = temp;
1148         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1149         mutex_unlock(&data->lock);
1150
1151         return count;
1152 }
1153
1154 static ssize_t pwm_min_show(struct device *dev,
1155                             struct device_attribute *devattr, char *buf)
1156 {
1157         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1158         struct adt7462_data *data = adt7462_update_device(dev);
1159         return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1160 }
1161
1162 static ssize_t pwm_min_store(struct device *dev,
1163                              struct device_attribute *devattr,
1164                              const char *buf, size_t count)
1165 {
1166         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1167         struct adt7462_data *data = dev_get_drvdata(dev);
1168         struct i2c_client *client = data->client;
1169         long temp;
1170
1171         if (kstrtol(buf, 10, &temp))
1172                 return -EINVAL;
1173
1174         temp = clamp_val(temp, 0, 255);
1175
1176         mutex_lock(&data->lock);
1177         data->pwm_min[attr->index] = temp;
1178         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1179                                   temp);
1180         mutex_unlock(&data->lock);
1181
1182         return count;
1183 }
1184
1185 static ssize_t pwm_hyst_show(struct device *dev,
1186                              struct device_attribute *devattr, char *buf)
1187 {
1188         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1189         struct adt7462_data *data = adt7462_update_device(dev);
1190         return sprintf(buf, "%d\n", 1000 *
1191                       (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1192 }
1193
1194 static ssize_t pwm_hyst_store(struct device *dev,
1195                               struct device_attribute *devattr,
1196                               const char *buf, size_t count)
1197 {
1198         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1199         struct adt7462_data *data = dev_get_drvdata(dev);
1200         struct i2c_client *client = data->client;
1201         long temp;
1202
1203         if (kstrtol(buf, 10, &temp))
1204                 return -EINVAL;
1205
1206         temp = clamp_val(temp, 0, 15000);
1207         temp = DIV_ROUND_CLOSEST(temp, 1000);
1208
1209         /* package things up */
1210         temp &= ADT7462_PWM_HYST_MASK;
1211         temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1212
1213         mutex_lock(&data->lock);
1214         data->pwm_trange[attr->index] = temp;
1215         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1216                                   temp);
1217         mutex_unlock(&data->lock);
1218
1219         return count;
1220 }
1221
1222 static ssize_t pwm_tmax_show(struct device *dev,
1223                              struct device_attribute *devattr, char *buf)
1224 {
1225         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1226         struct adt7462_data *data = adt7462_update_device(dev);
1227
1228         /* tmax = tmin + trange */
1229         int trange = trange_values[data->pwm_trange[attr->index] >>
1230                                    ADT7462_PWM_RANGE_SHIFT];
1231         int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1232
1233         return sprintf(buf, "%d\n", tmin + trange);
1234 }
1235
1236 static ssize_t pwm_tmax_store(struct device *dev,
1237                               struct device_attribute *devattr,
1238                               const char *buf, size_t count)
1239 {
1240         int temp;
1241         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1242         struct adt7462_data *data = dev_get_drvdata(dev);
1243         struct i2c_client *client = data->client;
1244         int tmin, trange_value;
1245         long trange;
1246
1247         if (kstrtol(buf, 10, &trange))
1248                 return -EINVAL;
1249
1250         /* trange = tmax - tmin */
1251         tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1252         trange_value = find_trange_value(trange - tmin);
1253         if (trange_value < 0)
1254                 return trange_value;
1255
1256         temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1257         temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1258
1259         mutex_lock(&data->lock);
1260         data->pwm_trange[attr->index] = temp;
1261         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1262                                   temp);
1263         mutex_unlock(&data->lock);
1264
1265         return count;
1266 }
1267
1268 static ssize_t pwm_tmin_show(struct device *dev,
1269                              struct device_attribute *devattr, char *buf)
1270 {
1271         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1272         struct adt7462_data *data = adt7462_update_device(dev);
1273         return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1274 }
1275
1276 static ssize_t pwm_tmin_store(struct device *dev,
1277                               struct device_attribute *devattr,
1278                               const char *buf, size_t count)
1279 {
1280         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1281         struct adt7462_data *data = dev_get_drvdata(dev);
1282         struct i2c_client *client = data->client;
1283         long temp;
1284
1285         if (kstrtol(buf, 10, &temp))
1286                 return -EINVAL;
1287
1288         temp = clamp_val(temp, -64000, 191000);
1289         temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1290
1291         mutex_lock(&data->lock);
1292         data->pwm_tmin[attr->index] = temp;
1293         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1294                                   temp);
1295         mutex_unlock(&data->lock);
1296
1297         return count;
1298 }
1299
1300 static ssize_t pwm_auto_show(struct device *dev,
1301                              struct device_attribute *devattr, char *buf)
1302 {
1303         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1304         struct adt7462_data *data = adt7462_update_device(dev);
1305         int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1306
1307         switch (cfg) {
1308         case 4: /* off */
1309                 return sprintf(buf, "0\n");
1310         case 7: /* manual */
1311                 return sprintf(buf, "1\n");
1312         default: /* automatic */
1313                 return sprintf(buf, "2\n");
1314         }
1315 }
1316
1317 static void set_pwm_channel(struct i2c_client *client,
1318                             struct adt7462_data *data,
1319                             int which,
1320                             int value)
1321 {
1322         int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1323         temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1324
1325         mutex_lock(&data->lock);
1326         data->pwm_cfg[which] = temp;
1327         i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1328         mutex_unlock(&data->lock);
1329 }
1330
1331 static ssize_t pwm_auto_store(struct device *dev,
1332                               struct device_attribute *devattr,
1333                               const char *buf, size_t count)
1334 {
1335         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1336         struct adt7462_data *data = dev_get_drvdata(dev);
1337         struct i2c_client *client = data->client;
1338         long temp;
1339
1340         if (kstrtol(buf, 10, &temp))
1341                 return -EINVAL;
1342
1343         switch (temp) {
1344         case 0: /* off */
1345                 set_pwm_channel(client, data, attr->index, 4);
1346                 return count;
1347         case 1: /* manual */
1348                 set_pwm_channel(client, data, attr->index, 7);
1349                 return count;
1350         default:
1351                 return -EINVAL;
1352         }
1353 }
1354
1355 static ssize_t pwm_auto_temp_show(struct device *dev,
1356                                   struct device_attribute *devattr, char *buf)
1357 {
1358         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1359         struct adt7462_data *data = adt7462_update_device(dev);
1360         int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1361
1362         switch (channel) {
1363         case 0: /* temp[1234] only */
1364         case 1:
1365         case 2:
1366         case 3:
1367                 return sprintf(buf, "%d\n", (1 << channel));
1368         case 5: /* temp1 & temp4  */
1369                 return sprintf(buf, "9\n");
1370         case 6:
1371                 return sprintf(buf, "15\n");
1372         default:
1373                 return sprintf(buf, "0\n");
1374         }
1375 }
1376
1377 static int cvt_auto_temp(int input)
1378 {
1379         if (input == 0xF)
1380                 return 6;
1381         if (input == 0x9)
1382                 return 5;
1383         if (input < 1 || !is_power_of_2(input))
1384                 return -EINVAL;
1385         return ilog2(input);
1386 }
1387
1388 static ssize_t pwm_auto_temp_store(struct device *dev,
1389                                    struct device_attribute *devattr,
1390                                    const char *buf, size_t count)
1391 {
1392         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1393         struct adt7462_data *data = dev_get_drvdata(dev);
1394         struct i2c_client *client = data->client;
1395         long temp;
1396
1397         if (kstrtol(buf, 10, &temp))
1398                 return -EINVAL;
1399
1400         temp = cvt_auto_temp(temp);
1401         if (temp < 0)
1402                 return temp;
1403
1404         set_pwm_channel(client, data, attr->index, temp);
1405
1406         return count;
1407 }
1408
1409 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
1410 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
1411 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
1412 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3);
1413
1414 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
1415 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
1416 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
1417 static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3);
1418
1419 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
1420 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
1421 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
1422 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
1423
1424 static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0);
1425 static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1);
1426 static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2);
1427 static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3);
1428
1429 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm,
1430                              ADT7462_ALARM1 | ADT7462_LT_ALARM);
1431 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm,
1432                              ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1433 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm,
1434                              ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1435 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm,
1436                              ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1437
1438 static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0);
1439 static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1);
1440 static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2);
1441 static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3);
1442 static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4);
1443 static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5);
1444 static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6);
1445 static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7);
1446 static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8);
1447 static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9);
1448 static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10);
1449 static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11);
1450 static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12);
1451
1452 static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0);
1453 static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1);
1454 static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2);
1455 static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3);
1456 static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4);
1457 static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5);
1458 static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6);
1459 static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7);
1460 static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8);
1461 static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9);
1462 static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10);
1463 static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11);
1464 static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12);
1465
1466 static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0);
1467 static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1);
1468 static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2);
1469 static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3);
1470 static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4);
1471 static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5);
1472 static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6);
1473 static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7);
1474 static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8);
1475 static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9);
1476 static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10);
1477 static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11);
1478 static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12);
1479
1480 static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0);
1481 static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1);
1482 static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2);
1483 static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3);
1484 static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4);
1485 static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5);
1486 static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6);
1487 static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7);
1488 static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8);
1489 static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9);
1490 static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10);
1491 static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11);
1492 static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12);
1493
1494 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm,
1495                              ADT7462_ALARM2 | ADT7462_V0_ALARM);
1496 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm,
1497                              ADT7462_ALARM2 | ADT7462_V7_ALARM);
1498 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm,
1499                              ADT7462_ALARM2 | ADT7462_V2_ALARM);
1500 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm,
1501                              ADT7462_ALARM2 | ADT7462_V6_ALARM);
1502 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm,
1503                              ADT7462_ALARM2 | ADT7462_V5_ALARM);
1504 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm,
1505                              ADT7462_ALARM2 | ADT7462_V4_ALARM);
1506 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm,
1507                              ADT7462_ALARM2 | ADT7462_V3_ALARM);
1508 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm,
1509                              ADT7462_ALARM2 | ADT7462_V1_ALARM);
1510 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm,
1511                              ADT7462_ALARM3 | ADT7462_V10_ALARM);
1512 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm,
1513                              ADT7462_ALARM3 | ADT7462_V9_ALARM);
1514 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm,
1515                              ADT7462_ALARM3 | ADT7462_V8_ALARM);
1516 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm,
1517                              ADT7462_ALARM3 | ADT7462_V11_ALARM);
1518 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm,
1519                              ADT7462_ALARM3 | ADT7462_V12_ALARM);
1520
1521 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
1522 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
1523 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
1524 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
1525 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
1526 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
1527 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
1528 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
1529
1530 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
1531 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
1532 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
1533 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
1534 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
1535 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
1536 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
1537 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
1538
1539 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm,
1540                              ADT7462_ALARM4 | ADT7462_F0_ALARM);
1541 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm,
1542                              ADT7462_ALARM4 | ADT7462_F1_ALARM);
1543 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm,
1544                              ADT7462_ALARM4 | ADT7462_F2_ALARM);
1545 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm,
1546                              ADT7462_ALARM4 | ADT7462_F3_ALARM);
1547 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm,
1548                              ADT7462_ALARM4 | ADT7462_F4_ALARM);
1549 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm,
1550                              ADT7462_ALARM4 | ADT7462_F5_ALARM);
1551 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm,
1552                              ADT7462_ALARM4 | ADT7462_F6_ALARM);
1553 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm,
1554                              ADT7462_ALARM4 | ADT7462_F7_ALARM);
1555
1556 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1557
1558 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
1559 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
1560 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
1561 static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3);
1562
1563 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1564 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1565 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1566 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1567
1568 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1569 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1570 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1571 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1572
1573 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0);
1574 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1);
1575 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2);
1576 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3);
1577
1578 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0);
1579 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1);
1580 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2);
1581 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3);
1582
1583 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0);
1584 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1);
1585 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2);
1586 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3);
1587
1588 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0);
1589 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1);
1590 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2);
1591 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3);
1592
1593 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0);
1594 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1);
1595 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2);
1596 static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3);
1597
1598 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1599 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1600 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1601 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1602
1603 static struct attribute *adt7462_attrs[] = {
1604         &sensor_dev_attr_temp1_max.dev_attr.attr,
1605         &sensor_dev_attr_temp2_max.dev_attr.attr,
1606         &sensor_dev_attr_temp3_max.dev_attr.attr,
1607         &sensor_dev_attr_temp4_max.dev_attr.attr,
1608
1609         &sensor_dev_attr_temp1_min.dev_attr.attr,
1610         &sensor_dev_attr_temp2_min.dev_attr.attr,
1611         &sensor_dev_attr_temp3_min.dev_attr.attr,
1612         &sensor_dev_attr_temp4_min.dev_attr.attr,
1613
1614         &sensor_dev_attr_temp1_input.dev_attr.attr,
1615         &sensor_dev_attr_temp2_input.dev_attr.attr,
1616         &sensor_dev_attr_temp3_input.dev_attr.attr,
1617         &sensor_dev_attr_temp4_input.dev_attr.attr,
1618
1619         &sensor_dev_attr_temp1_label.dev_attr.attr,
1620         &sensor_dev_attr_temp2_label.dev_attr.attr,
1621         &sensor_dev_attr_temp3_label.dev_attr.attr,
1622         &sensor_dev_attr_temp4_label.dev_attr.attr,
1623
1624         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1625         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1626         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1627         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1628
1629         &sensor_dev_attr_in1_max.dev_attr.attr,
1630         &sensor_dev_attr_in2_max.dev_attr.attr,
1631         &sensor_dev_attr_in3_max.dev_attr.attr,
1632         &sensor_dev_attr_in4_max.dev_attr.attr,
1633         &sensor_dev_attr_in5_max.dev_attr.attr,
1634         &sensor_dev_attr_in6_max.dev_attr.attr,
1635         &sensor_dev_attr_in7_max.dev_attr.attr,
1636         &sensor_dev_attr_in8_max.dev_attr.attr,
1637         &sensor_dev_attr_in9_max.dev_attr.attr,
1638         &sensor_dev_attr_in10_max.dev_attr.attr,
1639         &sensor_dev_attr_in11_max.dev_attr.attr,
1640         &sensor_dev_attr_in12_max.dev_attr.attr,
1641         &sensor_dev_attr_in13_max.dev_attr.attr,
1642
1643         &sensor_dev_attr_in1_min.dev_attr.attr,
1644         &sensor_dev_attr_in2_min.dev_attr.attr,
1645         &sensor_dev_attr_in3_min.dev_attr.attr,
1646         &sensor_dev_attr_in4_min.dev_attr.attr,
1647         &sensor_dev_attr_in5_min.dev_attr.attr,
1648         &sensor_dev_attr_in6_min.dev_attr.attr,
1649         &sensor_dev_attr_in7_min.dev_attr.attr,
1650         &sensor_dev_attr_in8_min.dev_attr.attr,
1651         &sensor_dev_attr_in9_min.dev_attr.attr,
1652         &sensor_dev_attr_in10_min.dev_attr.attr,
1653         &sensor_dev_attr_in11_min.dev_attr.attr,
1654         &sensor_dev_attr_in12_min.dev_attr.attr,
1655         &sensor_dev_attr_in13_min.dev_attr.attr,
1656
1657         &sensor_dev_attr_in1_input.dev_attr.attr,
1658         &sensor_dev_attr_in2_input.dev_attr.attr,
1659         &sensor_dev_attr_in3_input.dev_attr.attr,
1660         &sensor_dev_attr_in4_input.dev_attr.attr,
1661         &sensor_dev_attr_in5_input.dev_attr.attr,
1662         &sensor_dev_attr_in6_input.dev_attr.attr,
1663         &sensor_dev_attr_in7_input.dev_attr.attr,
1664         &sensor_dev_attr_in8_input.dev_attr.attr,
1665         &sensor_dev_attr_in9_input.dev_attr.attr,
1666         &sensor_dev_attr_in10_input.dev_attr.attr,
1667         &sensor_dev_attr_in11_input.dev_attr.attr,
1668         &sensor_dev_attr_in12_input.dev_attr.attr,
1669         &sensor_dev_attr_in13_input.dev_attr.attr,
1670
1671         &sensor_dev_attr_in1_label.dev_attr.attr,
1672         &sensor_dev_attr_in2_label.dev_attr.attr,
1673         &sensor_dev_attr_in3_label.dev_attr.attr,
1674         &sensor_dev_attr_in4_label.dev_attr.attr,
1675         &sensor_dev_attr_in5_label.dev_attr.attr,
1676         &sensor_dev_attr_in6_label.dev_attr.attr,
1677         &sensor_dev_attr_in7_label.dev_attr.attr,
1678         &sensor_dev_attr_in8_label.dev_attr.attr,
1679         &sensor_dev_attr_in9_label.dev_attr.attr,
1680         &sensor_dev_attr_in10_label.dev_attr.attr,
1681         &sensor_dev_attr_in11_label.dev_attr.attr,
1682         &sensor_dev_attr_in12_label.dev_attr.attr,
1683         &sensor_dev_attr_in13_label.dev_attr.attr,
1684
1685         &sensor_dev_attr_in1_alarm.dev_attr.attr,
1686         &sensor_dev_attr_in2_alarm.dev_attr.attr,
1687         &sensor_dev_attr_in3_alarm.dev_attr.attr,
1688         &sensor_dev_attr_in4_alarm.dev_attr.attr,
1689         &sensor_dev_attr_in5_alarm.dev_attr.attr,
1690         &sensor_dev_attr_in6_alarm.dev_attr.attr,
1691         &sensor_dev_attr_in7_alarm.dev_attr.attr,
1692         &sensor_dev_attr_in8_alarm.dev_attr.attr,
1693         &sensor_dev_attr_in9_alarm.dev_attr.attr,
1694         &sensor_dev_attr_in10_alarm.dev_attr.attr,
1695         &sensor_dev_attr_in11_alarm.dev_attr.attr,
1696         &sensor_dev_attr_in12_alarm.dev_attr.attr,
1697         &sensor_dev_attr_in13_alarm.dev_attr.attr,
1698
1699         &sensor_dev_attr_fan1_min.dev_attr.attr,
1700         &sensor_dev_attr_fan2_min.dev_attr.attr,
1701         &sensor_dev_attr_fan3_min.dev_attr.attr,
1702         &sensor_dev_attr_fan4_min.dev_attr.attr,
1703         &sensor_dev_attr_fan5_min.dev_attr.attr,
1704         &sensor_dev_attr_fan6_min.dev_attr.attr,
1705         &sensor_dev_attr_fan7_min.dev_attr.attr,
1706         &sensor_dev_attr_fan8_min.dev_attr.attr,
1707
1708         &sensor_dev_attr_fan1_input.dev_attr.attr,
1709         &sensor_dev_attr_fan2_input.dev_attr.attr,
1710         &sensor_dev_attr_fan3_input.dev_attr.attr,
1711         &sensor_dev_attr_fan4_input.dev_attr.attr,
1712         &sensor_dev_attr_fan5_input.dev_attr.attr,
1713         &sensor_dev_attr_fan6_input.dev_attr.attr,
1714         &sensor_dev_attr_fan7_input.dev_attr.attr,
1715         &sensor_dev_attr_fan8_input.dev_attr.attr,
1716
1717         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1718         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1719         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1720         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1721         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1722         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1723         &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1724         &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1725
1726         &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1727         &sensor_dev_attr_pwm1.dev_attr.attr,
1728         &sensor_dev_attr_pwm2.dev_attr.attr,
1729         &sensor_dev_attr_pwm3.dev_attr.attr,
1730         &sensor_dev_attr_pwm4.dev_attr.attr,
1731
1732         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1733         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1734         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1735         &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1736
1737         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1738         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1739         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1740         &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1741
1742         &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1743         &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1744         &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1745         &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1746
1747         &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1748         &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1749         &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1750         &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1751
1752         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1753         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1754         &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1755         &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1756
1757         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1758         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1759         &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1760         &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1761
1762         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1763         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1764         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1765         &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1766
1767         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1768         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1769         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1770         &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1771         NULL
1772 };
1773
1774 ATTRIBUTE_GROUPS(adt7462);
1775
1776 /* Return 0 if detection is successful, -ENODEV otherwise */
1777 static int adt7462_detect(struct i2c_client *client,
1778                           struct i2c_board_info *info)
1779 {
1780         struct i2c_adapter *adapter = client->adapter;
1781         int vendor, device, revision;
1782
1783         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1784                 return -ENODEV;
1785
1786         vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1787         if (vendor != ADT7462_VENDOR)
1788                 return -ENODEV;
1789
1790         device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1791         if (device != ADT7462_DEVICE)
1792                 return -ENODEV;
1793
1794         revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1795         if (revision != ADT7462_REVISION)
1796                 return -ENODEV;
1797
1798         strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1799
1800         return 0;
1801 }
1802
1803 static int adt7462_probe(struct i2c_client *client,
1804                          const struct i2c_device_id *id)
1805 {
1806         struct device *dev = &client->dev;
1807         struct adt7462_data *data;
1808         struct device *hwmon_dev;
1809
1810         data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL);
1811         if (!data)
1812                 return -ENOMEM;
1813
1814         data->client = client;
1815         mutex_init(&data->lock);
1816
1817         dev_info(&client->dev, "%s chip found\n", client->name);
1818
1819         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1820                                                            data,
1821                                                            adt7462_groups);
1822         return PTR_ERR_OR_ZERO(hwmon_dev);
1823 }
1824
1825 static const struct i2c_device_id adt7462_id[] = {
1826         { "adt7462", 0 },
1827         { }
1828 };
1829 MODULE_DEVICE_TABLE(i2c, adt7462_id);
1830
1831 static struct i2c_driver adt7462_driver = {
1832         .class          = I2C_CLASS_HWMON,
1833         .driver = {
1834                 .name   = "adt7462",
1835         },
1836         .probe          = adt7462_probe,
1837         .id_table       = adt7462_id,
1838         .detect         = adt7462_detect,
1839         .address_list   = normal_i2c,
1840 };
1841
1842 module_i2c_driver(adt7462_driver);
1843
1844 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1845 MODULE_DESCRIPTION("ADT7462 driver");
1846 MODULE_LICENSE("GPL");