drivers/hwmon/adt7462.c

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