Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * A hwmon driver for the Analog Devices ADT7462
0004  * Copyright (C) 2008 IBM
0005  *
0006  * Author: Darrick J. Wong <darrick.wong@oracle.com>
0007  */
0008 
0009 #include <linux/module.h>
0010 #include <linux/jiffies.h>
0011 #include <linux/i2c.h>
0012 #include <linux/hwmon.h>
0013 #include <linux/hwmon-sysfs.h>
0014 #include <linux/err.h>
0015 #include <linux/mutex.h>
0016 #include <linux/log2.h>
0017 #include <linux/slab.h>
0018 
0019 /* Addresses to scan */
0020 static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
0021 
0022 /* ADT7462 registers */
0023 #define ADT7462_REG_DEVICE          0x3D
0024 #define ADT7462_REG_VENDOR          0x3E
0025 #define ADT7462_REG_REVISION            0x3F
0026 
0027 #define ADT7462_REG_MIN_TEMP_BASE_ADDR      0x44
0028 #define ADT7462_REG_MIN_TEMP_MAX_ADDR       0x47
0029 #define ADT7462_REG_MAX_TEMP_BASE_ADDR      0x48
0030 #define ADT7462_REG_MAX_TEMP_MAX_ADDR       0x4B
0031 #define ADT7462_REG_TEMP_BASE_ADDR      0x88
0032 #define ADT7462_REG_TEMP_MAX_ADDR       0x8F
0033 
0034 #define ADT7462_REG_FAN_BASE_ADDR       0x98
0035 #define ADT7462_REG_FAN_MAX_ADDR        0x9F
0036 #define ADT7462_REG_FAN2_BASE_ADDR      0xA2
0037 #define ADT7462_REG_FAN2_MAX_ADDR       0xA9
0038 #define ADT7462_REG_FAN_ENABLE          0x07
0039 #define ADT7462_REG_FAN_MIN_BASE_ADDR       0x78
0040 #define ADT7462_REG_FAN_MIN_MAX_ADDR        0x7F
0041 
0042 #define ADT7462_REG_CFG2            0x02
0043 #define     ADT7462_FSPD_MASK       0x20
0044 
0045 #define ADT7462_REG_PWM_BASE_ADDR       0xAA
0046 #define ADT7462_REG_PWM_MAX_ADDR        0xAD
0047 #define ADT7462_REG_PWM_MIN_BASE_ADDR       0x28
0048 #define ADT7462_REG_PWM_MIN_MAX_ADDR        0x2B
0049 #define ADT7462_REG_PWM_MAX         0x2C
0050 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR  0x5C
0051 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR   0x5F
0052 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR    0x60
0053 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
0054 #define ADT7462_PWM_HYST_MASK           0x0F
0055 #define ADT7462_PWM_RANGE_MASK          0xF0
0056 #define     ADT7462_PWM_RANGE_SHIFT     4
0057 #define ADT7462_REG_PWM_CFG_BASE_ADDR       0x21
0058 #define ADT7462_REG_PWM_CFG_MAX_ADDR        0x24
0059 #define     ADT7462_PWM_CHANNEL_MASK    0xE0
0060 #define     ADT7462_PWM_CHANNEL_SHIFT   5
0061 
0062 #define ADT7462_REG_PIN_CFG_BASE_ADDR       0x10
0063 #define ADT7462_REG_PIN_CFG_MAX_ADDR        0x13
0064 #define     ADT7462_PIN7_INPUT      0x01    /* cfg0 */
0065 #define     ADT7462_DIODE3_INPUT        0x20
0066 #define     ADT7462_DIODE1_INPUT        0x40
0067 #define     ADT7462_VID_INPUT       0x80
0068 #define     ADT7462_PIN22_INPUT     0x04    /* cfg1 */
0069 #define     ADT7462_PIN21_INPUT     0x08
0070 #define     ADT7462_PIN19_INPUT     0x10
0071 #define     ADT7462_PIN15_INPUT     0x20
0072 #define     ADT7462_PIN13_INPUT     0x40
0073 #define     ADT7462_PIN8_INPUT      0x80
0074 #define     ADT7462_PIN23_MASK      0x03
0075 #define     ADT7462_PIN23_SHIFT     0
0076 #define     ADT7462_PIN26_MASK      0x0C    /* cfg2 */
0077 #define     ADT7462_PIN26_SHIFT     2
0078 #define     ADT7462_PIN25_MASK      0x30
0079 #define     ADT7462_PIN25_SHIFT     4
0080 #define     ADT7462_PIN24_MASK      0xC0
0081 #define     ADT7462_PIN24_SHIFT     6
0082 #define     ADT7462_PIN26_VOLT_INPUT    0x08
0083 #define     ADT7462_PIN25_VOLT_INPUT    0x20
0084 #define     ADT7462_PIN28_SHIFT     4   /* cfg3 */
0085 #define     ADT7462_PIN28_VOLT      0x5
0086 
0087 #define ADT7462_REG_ALARM1          0xB8
0088 #define ADT7462_LT_ALARM            0x02
0089 #define     ADT7462_R1T_ALARM       0x04
0090 #define     ADT7462_R2T_ALARM       0x08
0091 #define     ADT7462_R3T_ALARM       0x10
0092 #define ADT7462_REG_ALARM2          0xBB
0093 #define     ADT7462_V0_ALARM        0x01
0094 #define     ADT7462_V1_ALARM        0x02
0095 #define     ADT7462_V2_ALARM        0x04
0096 #define     ADT7462_V3_ALARM        0x08
0097 #define     ADT7462_V4_ALARM        0x10
0098 #define     ADT7462_V5_ALARM        0x20
0099 #define     ADT7462_V6_ALARM        0x40
0100 #define     ADT7462_V7_ALARM        0x80
0101 #define ADT7462_REG_ALARM3          0xBC
0102 #define     ADT7462_V8_ALARM        0x08
0103 #define     ADT7462_V9_ALARM        0x10
0104 #define     ADT7462_V10_ALARM       0x20
0105 #define     ADT7462_V11_ALARM       0x40
0106 #define     ADT7462_V12_ALARM       0x80
0107 #define ADT7462_REG_ALARM4          0xBD
0108 #define     ADT7462_F0_ALARM        0x01
0109 #define     ADT7462_F1_ALARM        0x02
0110 #define     ADT7462_F2_ALARM        0x04
0111 #define     ADT7462_F3_ALARM        0x08
0112 #define     ADT7462_F4_ALARM        0x10
0113 #define     ADT7462_F5_ALARM        0x20
0114 #define     ADT7462_F6_ALARM        0x40
0115 #define     ADT7462_F7_ALARM        0x80
0116 #define ADT7462_ALARM1              0x0000
0117 #define ADT7462_ALARM2              0x0100
0118 #define ADT7462_ALARM3              0x0200
0119 #define ADT7462_ALARM4              0x0300
0120 #define ADT7462_ALARM_REG_SHIFT         8
0121 #define ADT7462_ALARM_FLAG_MASK         0x0F
0122 
0123 #define ADT7462_TEMP_COUNT      4
0124 #define ADT7462_TEMP_REG(x)     (ADT7462_REG_TEMP_BASE_ADDR + ((x) * 2))
0125 #define ADT7462_TEMP_MIN_REG(x)     (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
0126 #define ADT7462_TEMP_MAX_REG(x)     (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
0127 #define TEMP_FRAC_OFFSET        6
0128 
0129 #define ADT7462_FAN_COUNT       8
0130 #define ADT7462_REG_FAN_MIN(x)      (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
0131 
0132 #define ADT7462_PWM_COUNT       4
0133 #define ADT7462_REG_PWM(x)      (ADT7462_REG_PWM_BASE_ADDR + (x))
0134 #define ADT7462_REG_PWM_MIN(x)      (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
0135 #define ADT7462_REG_PWM_TMIN(x)     \
0136     (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
0137 #define ADT7462_REG_PWM_TRANGE(x)   \
0138     (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
0139 
0140 #define ADT7462_PIN_CFG_REG_COUNT   4
0141 #define ADT7462_REG_PIN_CFG(x)      (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
0142 #define ADT7462_REG_PWM_CFG(x)      (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
0143 
0144 #define ADT7462_ALARM_REG_COUNT     4
0145 
0146 /*
0147  * The chip can measure 13 different voltage sources:
0148  *
0149  * 1. +12V1 (pin 7)
0150  * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
0151  * 3. +12V3 (pin 22)
0152  * 4. +5V (pin 21)
0153  * 5. +1.25V/+0.9V (pin 19)
0154  * 6. +2.5V/+1.8V (pin 15)
0155  * 7. +3.3v (pin 13)
0156  * 8. +12V2 (pin 8)
0157  * 9. Vbatt/FSB_Vtt (pin 26)
0158  * A. +3.3V/+1.2V1 (pin 25)
0159  * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
0160  * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
0161  * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
0162  *
0163  * Each of these 13 has a factor to convert raw to voltage.  Even better,
0164  * the pins can be connected to other sensors (tach/gpio/hot/etc), which
0165  * makes the bookkeeping tricky.
0166  *
0167  * Some, but not all, of these voltages have low/high limits.
0168  */
0169 #define ADT7462_VOLT_COUNT  13
0170 
0171 #define ADT7462_VENDOR      0x41
0172 #define ADT7462_DEVICE      0x62
0173 /* datasheet only mentions a revision 4 */
0174 #define ADT7462_REVISION    0x04
0175 
0176 /* How often do we reread sensors values? (In jiffies) */
0177 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
0178 
0179 /* How often do we reread sensor limit values? (In jiffies) */
0180 #define LIMIT_REFRESH_INTERVAL  (60 * HZ)
0181 
0182 /* datasheet says to divide this number by the fan reading to get fan rpm */
0183 #define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
0184 #define FAN_RPM_TO_PERIOD   FAN_PERIOD_TO_RPM
0185 #define FAN_PERIOD_INVALID  65535
0186 #define FAN_DATA_VALID(x)   ((x) && (x) != FAN_PERIOD_INVALID)
0187 
0188 #define MASK_AND_SHIFT(value, prefix)   \
0189     (((value) & prefix##_MASK) >> prefix##_SHIFT)
0190 
0191 struct adt7462_data {
0192     struct i2c_client   *client;
0193     struct mutex        lock;
0194     char            sensors_valid;
0195     char            limits_valid;
0196     unsigned long       sensors_last_updated;   /* In jiffies */
0197     unsigned long       limits_last_updated;    /* In jiffies */
0198 
0199     u8          temp[ADT7462_TEMP_COUNT];
0200                 /* bits 6-7 are quarter pieces of temp */
0201     u8          temp_frac[ADT7462_TEMP_COUNT];
0202     u8          temp_min[ADT7462_TEMP_COUNT];
0203     u8          temp_max[ADT7462_TEMP_COUNT];
0204     u16         fan[ADT7462_FAN_COUNT];
0205     u8          fan_enabled;
0206     u8          fan_min[ADT7462_FAN_COUNT];
0207     u8          cfg2;
0208     u8          pwm[ADT7462_PWM_COUNT];
0209     u8          pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
0210     u8          voltages[ADT7462_VOLT_COUNT];
0211     u8          volt_max[ADT7462_VOLT_COUNT];
0212     u8          volt_min[ADT7462_VOLT_COUNT];
0213     u8          pwm_min[ADT7462_PWM_COUNT];
0214     u8          pwm_tmin[ADT7462_PWM_COUNT];
0215     u8          pwm_trange[ADT7462_PWM_COUNT];
0216     u8          pwm_max;    /* only one per chip */
0217     u8          pwm_cfg[ADT7462_PWM_COUNT];
0218     u8          alarms[ADT7462_ALARM_REG_COUNT];
0219 };
0220 
0221 /*
0222  * 16-bit registers on the ADT7462 are low-byte first.  The data sheet says
0223  * that the low byte must be read before the high byte.
0224  */
0225 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
0226 {
0227     u16 foo;
0228     foo = i2c_smbus_read_byte_data(client, reg);
0229     foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
0230     return foo;
0231 }
0232 
0233 /* For some reason these registers are not contiguous. */
0234 static int ADT7462_REG_FAN(int fan)
0235 {
0236     if (fan < 4)
0237         return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
0238     return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
0239 }
0240 
0241 /* Voltage registers are scattered everywhere */
0242 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
0243 {
0244     switch (which) {
0245     case 0:
0246         if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
0247             return 0x7C;
0248         break;
0249     case 1:
0250         return 0x69;
0251     case 2:
0252         if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
0253             return 0x7F;
0254         break;
0255     case 3:
0256         if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
0257             return 0x7E;
0258         break;
0259     case 4:
0260         if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
0261             return 0x4B;
0262         break;
0263     case 5:
0264         if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
0265             return 0x49;
0266         break;
0267     case 6:
0268         if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
0269             return 0x68;
0270         break;
0271     case 7:
0272         if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
0273             return 0x7D;
0274         break;
0275     case 8:
0276         if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
0277             return 0x6C;
0278         break;
0279     case 9:
0280         if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
0281             return 0x6B;
0282         break;
0283     case 10:
0284         return 0x6A;
0285     case 11:
0286         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0287                     ADT7462_PIN28_VOLT &&
0288             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0289             return 0x50;
0290         break;
0291     case 12:
0292         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0293                     ADT7462_PIN28_VOLT &&
0294             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0295             return 0x4C;
0296         break;
0297     }
0298     return 0;
0299 }
0300 
0301 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
0302 {
0303     switch (which) {
0304     case 0:
0305         if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
0306             return 0x6D;
0307         break;
0308     case 1:
0309         return 0x72;
0310     case 2:
0311         if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
0312             return 0x6F;
0313         break;
0314     case 3:
0315         if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
0316             return 0x71;
0317         break;
0318     case 4:
0319         if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
0320             return 0x47;
0321         break;
0322     case 5:
0323         if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
0324             return 0x45;
0325         break;
0326     case 6:
0327         if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
0328             return 0x70;
0329         break;
0330     case 7:
0331         if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
0332             return 0x6E;
0333         break;
0334     case 8:
0335         if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
0336             return 0x75;
0337         break;
0338     case 9:
0339         if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
0340             return 0x74;
0341         break;
0342     case 10:
0343         return 0x73;
0344     case 11:
0345         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0346                     ADT7462_PIN28_VOLT &&
0347             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0348             return 0x76;
0349         break;
0350     case 12:
0351         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0352                     ADT7462_PIN28_VOLT &&
0353             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0354             return 0x77;
0355         break;
0356     }
0357     return 0;
0358 }
0359 
0360 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
0361 {
0362     switch (which) {
0363     case 0:
0364         if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
0365             return 0xA3;
0366         break;
0367     case 1:
0368         return 0x90;
0369     case 2:
0370         if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
0371             return 0xA9;
0372         break;
0373     case 3:
0374         if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
0375             return 0xA7;
0376         break;
0377     case 4:
0378         if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
0379             return 0x8F;
0380         break;
0381     case 5:
0382         if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
0383             return 0x8B;
0384         break;
0385     case 6:
0386         if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
0387             return 0x96;
0388         break;
0389     case 7:
0390         if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
0391             return 0xA5;
0392         break;
0393     case 8:
0394         if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
0395             return 0x93;
0396         break;
0397     case 9:
0398         if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
0399             return 0x92;
0400         break;
0401     case 10:
0402         return 0x91;
0403     case 11:
0404         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0405                     ADT7462_PIN28_VOLT &&
0406             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0407             return 0x94;
0408         break;
0409     case 12:
0410         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0411                     ADT7462_PIN28_VOLT &&
0412             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0413             return 0x95;
0414         break;
0415     }
0416     return 0;
0417 }
0418 
0419 /* Provide labels for sysfs */
0420 static const char *voltage_label(struct adt7462_data *data, int which)
0421 {
0422     switch (which) {
0423     case 0:
0424         if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
0425             return "+12V1";
0426         break;
0427     case 1:
0428         switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
0429         case 0:
0430             return "Vccp1";
0431         case 1:
0432             return "+2.5V";
0433         case 2:
0434             return "+1.8V";
0435         case 3:
0436             return "+1.5V";
0437         }
0438         fallthrough;
0439     case 2:
0440         if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
0441             return "+12V3";
0442         break;
0443     case 3:
0444         if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
0445             return "+5V";
0446         break;
0447     case 4:
0448         if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
0449             if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
0450                 return "+0.9V";
0451             return "+1.25V";
0452         }
0453         break;
0454     case 5:
0455         if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
0456             if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
0457                 return "+1.8V";
0458             return "+2.5V";
0459         }
0460         break;
0461     case 6:
0462         if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
0463             return "+3.3V";
0464         break;
0465     case 7:
0466         if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
0467             return "+12V2";
0468         break;
0469     case 8:
0470         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
0471         case 0:
0472             return "Vbatt";
0473         case 1:
0474             return "FSB_Vtt";
0475         }
0476         break;
0477     case 9:
0478         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
0479         case 0:
0480             return "+3.3V";
0481         case 1:
0482             return "+1.2V1";
0483         }
0484         break;
0485     case 10:
0486         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
0487         case 0:
0488             return "Vccp2";
0489         case 1:
0490             return "+2.5V";
0491         case 2:
0492             return "+1.8V";
0493         case 3:
0494             return "+1.5";
0495         }
0496         fallthrough;
0497     case 11:
0498         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0499                     ADT7462_PIN28_VOLT &&
0500             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0501             return "+1.5V ICH";
0502         break;
0503     case 12:
0504         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0505                     ADT7462_PIN28_VOLT &&
0506             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0507             return "+1.5V 3GPIO";
0508         break;
0509     }
0510     return "N/A";
0511 }
0512 
0513 /* Multipliers are actually in uV, not mV. */
0514 static int voltage_multiplier(struct adt7462_data *data, int which)
0515 {
0516     switch (which) {
0517     case 0:
0518         if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
0519             return 62500;
0520         break;
0521     case 1:
0522         switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
0523         case 0:
0524             if (data->pin_cfg[0] & ADT7462_VID_INPUT)
0525                 return 12500;
0526             return 6250;
0527         case 1:
0528             return 13000;
0529         case 2:
0530             return 9400;
0531         case 3:
0532             return 7800;
0533         }
0534         fallthrough;
0535     case 2:
0536         if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
0537             return 62500;
0538         break;
0539     case 3:
0540         if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
0541             return 26000;
0542         break;
0543     case 4:
0544         if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
0545             if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
0546                 return 4690;
0547             return 6500;
0548         }
0549         break;
0550     case 5:
0551         if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
0552             if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
0553                 return 9400;
0554             return 13000;
0555         }
0556         break;
0557     case 6:
0558         if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
0559             return 17200;
0560         break;
0561     case 7:
0562         if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
0563             return 62500;
0564         break;
0565     case 8:
0566         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
0567         case 0:
0568             return 15600;
0569         case 1:
0570             return 6250;
0571         }
0572         break;
0573     case 9:
0574         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
0575         case 0:
0576             return 17200;
0577         case 1:
0578             return 6250;
0579         }
0580         break;
0581     case 10:
0582         switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
0583         case 0:
0584             return 6250;
0585         case 1:
0586             return 13000;
0587         case 2:
0588             return 9400;
0589         case 3:
0590             return 7800;
0591         }
0592         fallthrough;
0593     case 11:
0594     case 12:
0595         if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
0596                     ADT7462_PIN28_VOLT &&
0597             !(data->pin_cfg[0] & ADT7462_VID_INPUT))
0598             return 7800;
0599     }
0600     return 0;
0601 }
0602 
0603 static int temp_enabled(struct adt7462_data *data, int which)
0604 {
0605     switch (which) {
0606     case 0:
0607     case 2:
0608         return 1;
0609     case 1:
0610         if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
0611             return 1;
0612         break;
0613     case 3:
0614         if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
0615             return 1;
0616         break;
0617     }
0618     return 0;
0619 }
0620 
0621 static const char *temp_label(struct adt7462_data *data, int which)
0622 {
0623     switch (which) {
0624     case 0:
0625         return "local";
0626     case 1:
0627         if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
0628             return "remote1";
0629         break;
0630     case 2:
0631         return "remote2";
0632     case 3:
0633         if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
0634             return "remote3";
0635         break;
0636     }
0637     return "N/A";
0638 }
0639 
0640 /* Map Trange register values to mC */
0641 #define NUM_TRANGE_VALUES   16
0642 static const int trange_values[NUM_TRANGE_VALUES] = {
0643     2000,
0644     2500,
0645     3300,
0646     4000,
0647     5000,
0648     6700,
0649     8000,
0650     10000,
0651     13300,
0652     16000,
0653     20000,
0654     26700,
0655     32000,
0656     40000,
0657     53300,
0658     80000
0659 };
0660 
0661 static int find_trange_value(int trange)
0662 {
0663     int i;
0664 
0665     for (i = 0; i < NUM_TRANGE_VALUES; i++)
0666         if (trange_values[i] == trange)
0667             return i;
0668 
0669     return -EINVAL;
0670 }
0671 
0672 static struct adt7462_data *adt7462_update_device(struct device *dev)
0673 {
0674     struct adt7462_data *data = dev_get_drvdata(dev);
0675     struct i2c_client *client = data->client;
0676     unsigned long local_jiffies = jiffies;
0677     int i;
0678 
0679     mutex_lock(&data->lock);
0680     if (time_before(local_jiffies, data->sensors_last_updated +
0681         SENSOR_REFRESH_INTERVAL)
0682         && data->sensors_valid)
0683         goto no_sensor_update;
0684 
0685     for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
0686         /*
0687          * Reading the fractional register locks the integral
0688          * register until both have been read.
0689          */
0690         data->temp_frac[i] = i2c_smbus_read_byte_data(client,
0691                         ADT7462_TEMP_REG(i));
0692         data->temp[i] = i2c_smbus_read_byte_data(client,
0693                         ADT7462_TEMP_REG(i) + 1);
0694     }
0695 
0696     for (i = 0; i < ADT7462_FAN_COUNT; i++)
0697         data->fan[i] = adt7462_read_word_data(client,
0698                         ADT7462_REG_FAN(i));
0699 
0700     data->fan_enabled = i2c_smbus_read_byte_data(client,
0701                     ADT7462_REG_FAN_ENABLE);
0702 
0703     for (i = 0; i < ADT7462_PWM_COUNT; i++)
0704         data->pwm[i] = i2c_smbus_read_byte_data(client,
0705                         ADT7462_REG_PWM(i));
0706 
0707     for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
0708         data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
0709                 ADT7462_REG_PIN_CFG(i));
0710 
0711     for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
0712         int reg = ADT7462_REG_VOLT(data, i);
0713         if (!reg)
0714             data->voltages[i] = 0;
0715         else
0716             data->voltages[i] = i2c_smbus_read_byte_data(client,
0717                                      reg);
0718     }
0719 
0720     data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
0721     data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
0722     data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
0723     data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
0724 
0725     data->sensors_last_updated = local_jiffies;
0726     data->sensors_valid = 1;
0727 
0728 no_sensor_update:
0729     if (time_before(local_jiffies, data->limits_last_updated +
0730         LIMIT_REFRESH_INTERVAL)
0731         && data->limits_valid)
0732         goto out;
0733 
0734     for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
0735         data->temp_min[i] = i2c_smbus_read_byte_data(client,
0736                         ADT7462_TEMP_MIN_REG(i));
0737         data->temp_max[i] = i2c_smbus_read_byte_data(client,
0738                         ADT7462_TEMP_MAX_REG(i));
0739     }
0740 
0741     for (i = 0; i < ADT7462_FAN_COUNT; i++)
0742         data->fan_min[i] = i2c_smbus_read_byte_data(client,
0743                         ADT7462_REG_FAN_MIN(i));
0744 
0745     for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
0746         int reg = ADT7462_REG_VOLT_MAX(data, i);
0747         data->volt_max[i] =
0748             (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
0749 
0750         reg = ADT7462_REG_VOLT_MIN(data, i);
0751         data->volt_min[i] =
0752             (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
0753     }
0754 
0755     for (i = 0; i < ADT7462_PWM_COUNT; i++) {
0756         data->pwm_min[i] = i2c_smbus_read_byte_data(client,
0757                         ADT7462_REG_PWM_MIN(i));
0758         data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
0759                         ADT7462_REG_PWM_TMIN(i));
0760         data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
0761                         ADT7462_REG_PWM_TRANGE(i));
0762         data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
0763                         ADT7462_REG_PWM_CFG(i));
0764     }
0765 
0766     data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
0767 
0768     data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
0769 
0770     data->limits_last_updated = local_jiffies;
0771     data->limits_valid = 1;
0772 
0773 out:
0774     mutex_unlock(&data->lock);
0775     return data;
0776 }
0777 
0778 static ssize_t temp_min_show(struct device *dev,
0779                  struct device_attribute *devattr, char *buf)
0780 {
0781     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0782     struct adt7462_data *data = adt7462_update_device(dev);
0783 
0784     if (!temp_enabled(data, attr->index))
0785         return sprintf(buf, "0\n");
0786 
0787     return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
0788 }
0789 
0790 static ssize_t temp_min_store(struct device *dev,
0791                   struct device_attribute *devattr,
0792                   const char *buf, size_t count)
0793 {
0794     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0795     struct adt7462_data *data = dev_get_drvdata(dev);
0796     struct i2c_client *client = data->client;
0797     long temp;
0798 
0799     if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
0800         return -EINVAL;
0801 
0802     temp = clamp_val(temp, -64000, 191000);
0803     temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
0804 
0805     mutex_lock(&data->lock);
0806     data->temp_min[attr->index] = temp;
0807     i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
0808                   temp);
0809     mutex_unlock(&data->lock);
0810 
0811     return count;
0812 }
0813 
0814 static ssize_t temp_max_show(struct device *dev,
0815                  struct device_attribute *devattr, char *buf)
0816 {
0817     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0818     struct adt7462_data *data = adt7462_update_device(dev);
0819 
0820     if (!temp_enabled(data, attr->index))
0821         return sprintf(buf, "0\n");
0822 
0823     return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
0824 }
0825 
0826 static ssize_t temp_max_store(struct device *dev,
0827                   struct device_attribute *devattr,
0828                   const char *buf, size_t count)
0829 {
0830     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0831     struct adt7462_data *data = dev_get_drvdata(dev);
0832     struct i2c_client *client = data->client;
0833     long temp;
0834 
0835     if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
0836         return -EINVAL;
0837 
0838     temp = clamp_val(temp, -64000, 191000);
0839     temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
0840 
0841     mutex_lock(&data->lock);
0842     data->temp_max[attr->index] = temp;
0843     i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
0844                   temp);
0845     mutex_unlock(&data->lock);
0846 
0847     return count;
0848 }
0849 
0850 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
0851              char *buf)
0852 {
0853     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0854     struct adt7462_data *data = adt7462_update_device(dev);
0855     u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
0856 
0857     if (!temp_enabled(data, attr->index))
0858         return sprintf(buf, "0\n");
0859 
0860     return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
0861                      250 * frac);
0862 }
0863 
0864 static ssize_t temp_label_show(struct device *dev,
0865                    struct device_attribute *devattr, char *buf)
0866 {
0867     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0868     struct adt7462_data *data = adt7462_update_device(dev);
0869 
0870     return sprintf(buf, "%s\n", temp_label(data, attr->index));
0871 }
0872 
0873 static ssize_t volt_max_show(struct device *dev,
0874                  struct device_attribute *devattr, char *buf)
0875 {
0876     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0877     struct adt7462_data *data = adt7462_update_device(dev);
0878     int x = voltage_multiplier(data, attr->index);
0879 
0880     x *= data->volt_max[attr->index];
0881     x /= 1000; /* convert from uV to mV */
0882 
0883     return sprintf(buf, "%d\n", x);
0884 }
0885 
0886 static ssize_t volt_max_store(struct device *dev,
0887                   struct device_attribute *devattr,
0888                   const char *buf, size_t count)
0889 {
0890     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0891     struct adt7462_data *data = dev_get_drvdata(dev);
0892     struct i2c_client *client = data->client;
0893     int x = voltage_multiplier(data, attr->index);
0894     long temp;
0895 
0896     if (kstrtol(buf, 10, &temp) || !x)
0897         return -EINVAL;
0898 
0899     temp = clamp_val(temp, 0, 255 * x / 1000);
0900     temp *= 1000; /* convert mV to uV */
0901     temp = DIV_ROUND_CLOSEST(temp, x);
0902 
0903     mutex_lock(&data->lock);
0904     data->volt_max[attr->index] = temp;
0905     i2c_smbus_write_byte_data(client,
0906                   ADT7462_REG_VOLT_MAX(data, attr->index),
0907                   temp);
0908     mutex_unlock(&data->lock);
0909 
0910     return count;
0911 }
0912 
0913 static ssize_t volt_min_show(struct device *dev,
0914                  struct device_attribute *devattr, char *buf)
0915 {
0916     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0917     struct adt7462_data *data = adt7462_update_device(dev);
0918     int x = voltage_multiplier(data, attr->index);
0919 
0920     x *= data->volt_min[attr->index];
0921     x /= 1000; /* convert from uV to mV */
0922 
0923     return sprintf(buf, "%d\n", x);
0924 }
0925 
0926 static ssize_t volt_min_store(struct device *dev,
0927                   struct device_attribute *devattr,
0928                   const char *buf, size_t count)
0929 {
0930     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0931     struct adt7462_data *data = dev_get_drvdata(dev);
0932     struct i2c_client *client = data->client;
0933     int x = voltage_multiplier(data, attr->index);
0934     long temp;
0935 
0936     if (kstrtol(buf, 10, &temp) || !x)
0937         return -EINVAL;
0938 
0939     temp = clamp_val(temp, 0, 255 * x / 1000);
0940     temp *= 1000; /* convert mV to uV */
0941     temp = DIV_ROUND_CLOSEST(temp, x);
0942 
0943     mutex_lock(&data->lock);
0944     data->volt_min[attr->index] = temp;
0945     i2c_smbus_write_byte_data(client,
0946                   ADT7462_REG_VOLT_MIN(data, attr->index),
0947                   temp);
0948     mutex_unlock(&data->lock);
0949 
0950     return count;
0951 }
0952 
0953 static ssize_t voltage_show(struct device *dev,
0954                 struct device_attribute *devattr, char *buf)
0955 {
0956     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0957     struct adt7462_data *data = adt7462_update_device(dev);
0958     int x = voltage_multiplier(data, attr->index);
0959 
0960     x *= data->voltages[attr->index];
0961     x /= 1000; /* convert from uV to mV */
0962 
0963     return sprintf(buf, "%d\n", x);
0964 }
0965 
0966 static ssize_t voltage_label_show(struct device *dev,
0967                   struct device_attribute *devattr, char *buf)
0968 {
0969     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0970     struct adt7462_data *data = adt7462_update_device(dev);
0971 
0972     return sprintf(buf, "%s\n", voltage_label(data, attr->index));
0973 }
0974 
0975 static ssize_t alarm_show(struct device *dev,
0976               struct device_attribute *devattr, char *buf)
0977 {
0978     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0979     struct adt7462_data *data = adt7462_update_device(dev);
0980     int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
0981     int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
0982 
0983     if (data->alarms[reg] & mask)
0984         return sprintf(buf, "1\n");
0985     else
0986         return sprintf(buf, "0\n");
0987 }
0988 
0989 static int fan_enabled(struct adt7462_data *data, int fan)
0990 {
0991     return data->fan_enabled & (1 << fan);
0992 }
0993 
0994 static ssize_t fan_min_show(struct device *dev,
0995                 struct device_attribute *devattr, char *buf)
0996 {
0997     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0998     struct adt7462_data *data = adt7462_update_device(dev);
0999     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     strlcpy(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_new  = 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");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!