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