Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * adm1026.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *         monitoring
0005  * Copyright (C) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
0006  * Copyright (C) 2004 Justin Thiessen <jthiessen@penguincomputing.com>
0007  *
0008  * Chip details at:
0009  *
0010  * <https://www.onsemi.com/PowerSolutions/product.do?id=ADM1026>
0011  */
0012 
0013 #include <linux/module.h>
0014 #include <linux/init.h>
0015 #include <linux/slab.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/i2c.h>
0018 #include <linux/hwmon.h>
0019 #include <linux/hwmon-sysfs.h>
0020 #include <linux/hwmon-vid.h>
0021 #include <linux/err.h>
0022 #include <linux/mutex.h>
0023 
0024 /* Addresses to scan */
0025 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0026 
0027 static int gpio_input[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
0028                 -1, -1, -1, -1, -1, -1, -1, -1 };
0029 static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
0030                 -1, -1, -1, -1, -1, -1, -1, -1 };
0031 static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
0032                 -1, -1, -1, -1, -1, -1, -1, -1 };
0033 static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
0034                 -1, -1, -1, -1, -1, -1, -1, -1 };
0035 static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
0036 module_param_array(gpio_input, int, NULL, 0);
0037 MODULE_PARM_DESC(gpio_input, "List of GPIO pins (0-16) to program as inputs");
0038 module_param_array(gpio_output, int, NULL, 0);
0039 MODULE_PARM_DESC(gpio_output,
0040          "List of GPIO pins (0-16) to program as outputs");
0041 module_param_array(gpio_inverted, int, NULL, 0);
0042 MODULE_PARM_DESC(gpio_inverted,
0043          "List of GPIO pins (0-16) to program as inverted");
0044 module_param_array(gpio_normal, int, NULL, 0);
0045 MODULE_PARM_DESC(gpio_normal,
0046          "List of GPIO pins (0-16) to program as normal/non-inverted");
0047 module_param_array(gpio_fan, int, NULL, 0);
0048 MODULE_PARM_DESC(gpio_fan, "List of GPIO pins (0-7) to program as fan tachs");
0049 
0050 /* Many ADM1026 constants specified below */
0051 
0052 /* The ADM1026 registers */
0053 #define ADM1026_REG_CONFIG1 0x00
0054 #define CFG1_MONITOR        0x01
0055 #define CFG1_INT_ENABLE     0x02
0056 #define CFG1_INT_CLEAR      0x04
0057 #define CFG1_AIN8_9     0x08
0058 #define CFG1_THERM_HOT      0x10
0059 #define CFG1_DAC_AFC        0x20
0060 #define CFG1_PWM_AFC        0x40
0061 #define CFG1_RESET      0x80
0062 
0063 #define ADM1026_REG_CONFIG2 0x01
0064 /* CONFIG2 controls FAN0/GPIO0 through FAN7/GPIO7 */
0065 
0066 #define ADM1026_REG_CONFIG3 0x07
0067 #define CFG3_GPIO16_ENABLE  0x01
0068 #define CFG3_CI_CLEAR       0x02
0069 #define CFG3_VREF_250       0x04
0070 #define CFG3_GPIO16_DIR     0x40
0071 #define CFG3_GPIO16_POL     0x80
0072 
0073 #define ADM1026_REG_E2CONFIG    0x13
0074 #define E2CFG_READ      0x01
0075 #define E2CFG_WRITE     0x02
0076 #define E2CFG_ERASE     0x04
0077 #define E2CFG_ROM       0x08
0078 #define E2CFG_CLK_EXT       0x80
0079 
0080 /*
0081  * There are 10 general analog inputs and 7 dedicated inputs
0082  * They are:
0083  *    0 - 9  =  AIN0 - AIN9
0084  *       10  =  Vbat
0085  *       11  =  3.3V Standby
0086  *       12  =  3.3V Main
0087  *       13  =  +5V
0088  *       14  =  Vccp (CPU core voltage)
0089  *       15  =  +12V
0090  *       16  =  -12V
0091  */
0092 static u16 ADM1026_REG_IN[] = {
0093         0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
0094         0x36, 0x37, 0x27, 0x29, 0x26, 0x2a,
0095         0x2b, 0x2c, 0x2d, 0x2e, 0x2f
0096     };
0097 static u16 ADM1026_REG_IN_MIN[] = {
0098         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d,
0099         0x5e, 0x5f, 0x6d, 0x49, 0x6b, 0x4a,
0100         0x4b, 0x4c, 0x4d, 0x4e, 0x4f
0101     };
0102 static u16 ADM1026_REG_IN_MAX[] = {
0103         0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
0104         0x56, 0x57, 0x6c, 0x41, 0x6a, 0x42,
0105         0x43, 0x44, 0x45, 0x46, 0x47
0106     };
0107 
0108 /*
0109  * Temperatures are:
0110  *    0 - Internal
0111  *    1 - External 1
0112  *    2 - External 2
0113  */
0114 static u16 ADM1026_REG_TEMP[] = { 0x1f, 0x28, 0x29 };
0115 static u16 ADM1026_REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 };
0116 static u16 ADM1026_REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 };
0117 static u16 ADM1026_REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 };
0118 static u16 ADM1026_REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f };
0119 static u16 ADM1026_REG_TEMP_OFFSET[] = { 0x1e, 0x6e, 0x6f };
0120 
0121 #define ADM1026_REG_FAN(nr)     (0x38 + (nr))
0122 #define ADM1026_REG_FAN_MIN(nr)     (0x60 + (nr))
0123 #define ADM1026_REG_FAN_DIV_0_3     0x02
0124 #define ADM1026_REG_FAN_DIV_4_7     0x03
0125 
0126 #define ADM1026_REG_DAC         0x04
0127 #define ADM1026_REG_PWM         0x05
0128 
0129 #define ADM1026_REG_GPIO_CFG_0_3    0x08
0130 #define ADM1026_REG_GPIO_CFG_4_7    0x09
0131 #define ADM1026_REG_GPIO_CFG_8_11   0x0a
0132 #define ADM1026_REG_GPIO_CFG_12_15  0x0b
0133 /* CFG_16 in REG_CFG3 */
0134 #define ADM1026_REG_GPIO_STATUS_0_7 0x24
0135 #define ADM1026_REG_GPIO_STATUS_8_15    0x25
0136 /* STATUS_16 in REG_STATUS4 */
0137 #define ADM1026_REG_GPIO_MASK_0_7   0x1c
0138 #define ADM1026_REG_GPIO_MASK_8_15  0x1d
0139 /* MASK_16 in REG_MASK4 */
0140 
0141 #define ADM1026_REG_COMPANY     0x16
0142 #define ADM1026_REG_VERSTEP     0x17
0143 /* These are the recognized values for the above regs */
0144 #define ADM1026_COMPANY_ANALOG_DEV  0x41
0145 #define ADM1026_VERSTEP_GENERIC     0x40
0146 #define ADM1026_VERSTEP_ADM1026     0x44
0147 
0148 #define ADM1026_REG_MASK1       0x18
0149 #define ADM1026_REG_MASK2       0x19
0150 #define ADM1026_REG_MASK3       0x1a
0151 #define ADM1026_REG_MASK4       0x1b
0152 
0153 #define ADM1026_REG_STATUS1     0x20
0154 #define ADM1026_REG_STATUS2     0x21
0155 #define ADM1026_REG_STATUS3     0x22
0156 #define ADM1026_REG_STATUS4     0x23
0157 
0158 #define ADM1026_FAN_ACTIVATION_TEMP_HYST -6
0159 #define ADM1026_FAN_CONTROL_TEMP_RANGE  20
0160 #define ADM1026_PWM_MAX         255
0161 
0162 /*
0163  * Conversions. Rounding and limit checking is only done on the TO_REG
0164  * variants. Note that you should be a bit careful with which arguments
0165  * these macros are called: arguments may be evaluated more than once.
0166  */
0167 
0168 /*
0169  * IN are scaled according to built-in resistors.  These are the
0170  *   voltages corresponding to 3/4 of full scale (192 or 0xc0)
0171  *   NOTE: The -12V input needs an additional factor to account
0172  *      for the Vref pullup resistor.
0173  *      NEG12_OFFSET = SCALE * Vref / V-192 - Vref
0174  *                   = 13875 * 2.50 / 1.875 - 2500
0175  *                   = 16000
0176  *
0177  * The values in this table are based on Table II, page 15 of the
0178  *    datasheet.
0179  */
0180 static int adm1026_scaling[] = { /* .001 Volts */
0181         2250, 2250, 2250, 2250, 2250, 2250,
0182         1875, 1875, 1875, 1875, 3000, 3330,
0183         3330, 4995, 2250, 12000, 13875
0184     };
0185 #define NEG12_OFFSET  16000
0186 #define SCALE(val, from, to) (((val)*(to) + ((from)/2))/(from))
0187 #define INS_TO_REG(n, val)  \
0188         SCALE(clamp_val(val, 0, 255 * adm1026_scaling[n] / 192), \
0189               adm1026_scaling[n], 192)
0190 #define INS_FROM_REG(n, val) (SCALE(val, 192, adm1026_scaling[n]))
0191 
0192 /*
0193  * FAN speed is measured using 22.5kHz clock and counts for 2 pulses
0194  *   and we assume a 2 pulse-per-rev fan tach signal
0195  *      22500 kHz * 60 (sec/min) * 2 (pulse) / 2 (pulse/rev) == 1350000
0196  */
0197 #define FAN_TO_REG(val, div)  ((val) <= 0 ? 0xff : \
0198                 clamp_val(1350000 / ((val) * (div)), \
0199                           1, 254))
0200 #define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : (val) == 0xff ? 0 : \
0201                 1350000 / ((val) * (div)))
0202 #define DIV_FROM_REG(val) (1 << (val))
0203 #define DIV_TO_REG(val) ((val) >= 8 ? 3 : (val) >= 4 ? 2 : (val) >= 2 ? 1 : 0)
0204 
0205 /* Temperature is reported in 1 degC increments */
0206 #define TEMP_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), \
0207                        1000)
0208 #define TEMP_FROM_REG(val) ((val) * 1000)
0209 #define OFFSET_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), \
0210                          1000)
0211 #define OFFSET_FROM_REG(val) ((val) * 1000)
0212 
0213 #define PWM_TO_REG(val) (clamp_val(val, 0, 255))
0214 #define PWM_FROM_REG(val) (val)
0215 
0216 #define PWM_MIN_TO_REG(val) ((val) & 0xf0)
0217 #define PWM_MIN_FROM_REG(val) (((val) & 0xf0) + ((val) >> 4))
0218 
0219 /*
0220  * Analog output is a voltage, and scaled to millivolts.  The datasheet
0221  *   indicates that the DAC could be used to drive the fans, but in our
0222  *   example board (Arima HDAMA) it isn't connected to the fans at all.
0223  */
0224 #define DAC_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, 0, 2500) * 255, \
0225                       2500)
0226 #define DAC_FROM_REG(val) (((val) * 2500) / 255)
0227 
0228 /*
0229  * Chip sampling rates
0230  *
0231  * Some sensors are not updated more frequently than once per second
0232  *    so it doesn't make sense to read them more often than that.
0233  *    We cache the results and return the saved data if the driver
0234  *    is called again before a second has elapsed.
0235  *
0236  * Also, there is significant configuration data for this chip
0237  *    So, we keep the config data up to date in the cache
0238  *    when it is written and only sample it once every 5 *minutes*
0239  */
0240 #define ADM1026_DATA_INTERVAL       (1 * HZ)
0241 #define ADM1026_CONFIG_INTERVAL     (5 * 60 * HZ)
0242 
0243 /*
0244  * We allow for multiple chips in a single system.
0245  *
0246  * For each registered ADM1026, we need to keep state information
0247  * at client->data. The adm1026_data structure is dynamically
0248  * allocated, when a new client structure is allocated.
0249  */
0250 
0251 struct pwm_data {
0252     u8 pwm;
0253     u8 enable;
0254     u8 auto_pwm_min;
0255 };
0256 
0257 struct adm1026_data {
0258     struct i2c_client *client;
0259     const struct attribute_group *groups[3];
0260 
0261     struct mutex update_lock;
0262     bool valid;     /* true if following fields are valid */
0263     unsigned long last_reading; /* In jiffies */
0264     unsigned long last_config;  /* In jiffies */
0265 
0266     u8 in[17];      /* Register value */
0267     u8 in_max[17];      /* Register value */
0268     u8 in_min[17];      /* Register value */
0269     s8 temp[3];     /* Register value */
0270     s8 temp_min[3];     /* Register value */
0271     s8 temp_max[3];     /* Register value */
0272     s8 temp_tmin[3];    /* Register value */
0273     s8 temp_crit[3];    /* Register value */
0274     s8 temp_offset[3];  /* Register value */
0275     u8 fan[8];      /* Register value */
0276     u8 fan_min[8];      /* Register value */
0277     u8 fan_div[8];      /* Decoded value */
0278     struct pwm_data pwm1;   /* Pwm control values */
0279     u8 vrm;         /* VRM version */
0280     u8 analog_out;      /* Register value (DAC) */
0281     long alarms;        /* Register encoding, combined */
0282     long alarm_mask;    /* Register encoding, combined */
0283     long gpio;      /* Register encoding, combined */
0284     long gpio_mask;     /* Register encoding, combined */
0285     u8 gpio_config[17]; /* Decoded value */
0286     u8 config1;     /* Register value */
0287     u8 config2;     /* Register value */
0288     u8 config3;     /* Register value */
0289 };
0290 
0291 static int adm1026_read_value(struct i2c_client *client, u8 reg)
0292 {
0293     int res;
0294 
0295     if (reg < 0x80) {
0296         /* "RAM" locations */
0297         res = i2c_smbus_read_byte_data(client, reg) & 0xff;
0298     } else {
0299         /* EEPROM, do nothing */
0300         res = 0;
0301     }
0302     return res;
0303 }
0304 
0305 static int adm1026_write_value(struct i2c_client *client, u8 reg, int value)
0306 {
0307     int res;
0308 
0309     if (reg < 0x80) {
0310         /* "RAM" locations */
0311         res = i2c_smbus_write_byte_data(client, reg, value);
0312     } else {
0313         /* EEPROM, do nothing */
0314         res = 0;
0315     }
0316     return res;
0317 }
0318 
0319 static struct adm1026_data *adm1026_update_device(struct device *dev)
0320 {
0321     struct adm1026_data *data = dev_get_drvdata(dev);
0322     struct i2c_client *client = data->client;
0323     int i;
0324     long value, alarms, gpio;
0325 
0326     mutex_lock(&data->update_lock);
0327     if (!data->valid
0328         || time_after(jiffies,
0329               data->last_reading + ADM1026_DATA_INTERVAL)) {
0330         /* Things that change quickly */
0331         dev_dbg(&client->dev, "Reading sensor values\n");
0332         for (i = 0; i <= 16; ++i) {
0333             data->in[i] =
0334                 adm1026_read_value(client, ADM1026_REG_IN[i]);
0335         }
0336 
0337         for (i = 0; i <= 7; ++i) {
0338             data->fan[i] =
0339                 adm1026_read_value(client, ADM1026_REG_FAN(i));
0340         }
0341 
0342         for (i = 0; i <= 2; ++i) {
0343             /*
0344              * NOTE: temp[] is s8 and we assume 2's complement
0345              *   "conversion" in the assignment
0346              */
0347             data->temp[i] =
0348                 adm1026_read_value(client, ADM1026_REG_TEMP[i]);
0349         }
0350 
0351         data->pwm1.pwm = adm1026_read_value(client,
0352             ADM1026_REG_PWM);
0353         data->analog_out = adm1026_read_value(client,
0354             ADM1026_REG_DAC);
0355         /* GPIO16 is MSbit of alarms, move it to gpio */
0356         alarms = adm1026_read_value(client, ADM1026_REG_STATUS4);
0357         gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */
0358         alarms &= 0x7f;
0359         alarms <<= 8;
0360         alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3);
0361         alarms <<= 8;
0362         alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2);
0363         alarms <<= 8;
0364         alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1);
0365         data->alarms = alarms;
0366 
0367         /* Read the GPIO values */
0368         gpio |= adm1026_read_value(client,
0369             ADM1026_REG_GPIO_STATUS_8_15);
0370         gpio <<= 8;
0371         gpio |= adm1026_read_value(client,
0372             ADM1026_REG_GPIO_STATUS_0_7);
0373         data->gpio = gpio;
0374 
0375         data->last_reading = jiffies;
0376     }   /* last_reading */
0377 
0378     if (!data->valid ||
0379         time_after(jiffies, data->last_config + ADM1026_CONFIG_INTERVAL)) {
0380         /* Things that don't change often */
0381         dev_dbg(&client->dev, "Reading config values\n");
0382         for (i = 0; i <= 16; ++i) {
0383             data->in_min[i] = adm1026_read_value(client,
0384                 ADM1026_REG_IN_MIN[i]);
0385             data->in_max[i] = adm1026_read_value(client,
0386                 ADM1026_REG_IN_MAX[i]);
0387         }
0388 
0389         value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3)
0390             | (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7)
0391             << 8);
0392         for (i = 0; i <= 7; ++i) {
0393             data->fan_min[i] = adm1026_read_value(client,
0394                 ADM1026_REG_FAN_MIN(i));
0395             data->fan_div[i] = DIV_FROM_REG(value & 0x03);
0396             value >>= 2;
0397         }
0398 
0399         for (i = 0; i <= 2; ++i) {
0400             /*
0401              * NOTE: temp_xxx[] are s8 and we assume 2's
0402              *    complement "conversion" in the assignment
0403              */
0404             data->temp_min[i] = adm1026_read_value(client,
0405                 ADM1026_REG_TEMP_MIN[i]);
0406             data->temp_max[i] = adm1026_read_value(client,
0407                 ADM1026_REG_TEMP_MAX[i]);
0408             data->temp_tmin[i] = adm1026_read_value(client,
0409                 ADM1026_REG_TEMP_TMIN[i]);
0410             data->temp_crit[i] = adm1026_read_value(client,
0411                 ADM1026_REG_TEMP_THERM[i]);
0412             data->temp_offset[i] = adm1026_read_value(client,
0413                 ADM1026_REG_TEMP_OFFSET[i]);
0414         }
0415 
0416         /* Read the STATUS/alarm masks */
0417         alarms = adm1026_read_value(client, ADM1026_REG_MASK4);
0418         gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */
0419         alarms = (alarms & 0x7f) << 8;
0420         alarms |= adm1026_read_value(client, ADM1026_REG_MASK3);
0421         alarms <<= 8;
0422         alarms |= adm1026_read_value(client, ADM1026_REG_MASK2);
0423         alarms <<= 8;
0424         alarms |= adm1026_read_value(client, ADM1026_REG_MASK1);
0425         data->alarm_mask = alarms;
0426 
0427         /* Read the GPIO values */
0428         gpio |= adm1026_read_value(client,
0429             ADM1026_REG_GPIO_MASK_8_15);
0430         gpio <<= 8;
0431         gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7);
0432         data->gpio_mask = gpio;
0433 
0434         /* Read various values from CONFIG1 */
0435         data->config1 = adm1026_read_value(client,
0436             ADM1026_REG_CONFIG1);
0437         if (data->config1 & CFG1_PWM_AFC) {
0438             data->pwm1.enable = 2;
0439             data->pwm1.auto_pwm_min =
0440                 PWM_MIN_FROM_REG(data->pwm1.pwm);
0441         }
0442         /* Read the GPIO config */
0443         data->config2 = adm1026_read_value(client,
0444             ADM1026_REG_CONFIG2);
0445         data->config3 = adm1026_read_value(client,
0446             ADM1026_REG_CONFIG3);
0447         data->gpio_config[16] = (data->config3 >> 6) & 0x03;
0448 
0449         value = 0;
0450         for (i = 0; i <= 15; ++i) {
0451             if ((i & 0x03) == 0) {
0452                 value = adm1026_read_value(client,
0453                         ADM1026_REG_GPIO_CFG_0_3 + i/4);
0454             }
0455             data->gpio_config[i] = value & 0x03;
0456             value >>= 2;
0457         }
0458 
0459         data->last_config = jiffies;
0460     }   /* last_config */
0461 
0462     data->valid = true;
0463     mutex_unlock(&data->update_lock);
0464     return data;
0465 }
0466 
0467 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
0468                char *buf)
0469 {
0470     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0471     int nr = sensor_attr->index;
0472     struct adm1026_data *data = adm1026_update_device(dev);
0473     return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in[nr]));
0474 }
0475 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
0476                char *buf)
0477 {
0478     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0479     int nr = sensor_attr->index;
0480     struct adm1026_data *data = adm1026_update_device(dev);
0481     return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
0482 }
0483 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0484                 const char *buf, size_t count)
0485 {
0486     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0487     int nr = sensor_attr->index;
0488     struct adm1026_data *data = dev_get_drvdata(dev);
0489     struct i2c_client *client = data->client;
0490     long val;
0491     int err;
0492 
0493     err = kstrtol(buf, 10, &val);
0494     if (err)
0495         return err;
0496 
0497     mutex_lock(&data->update_lock);
0498     data->in_min[nr] = INS_TO_REG(nr, val);
0499     adm1026_write_value(client, ADM1026_REG_IN_MIN[nr], data->in_min[nr]);
0500     mutex_unlock(&data->update_lock);
0501     return count;
0502 }
0503 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
0504                char *buf)
0505 {
0506     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0507     int nr = sensor_attr->index;
0508     struct adm1026_data *data = adm1026_update_device(dev);
0509     return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
0510 }
0511 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0512                 const char *buf, size_t count)
0513 {
0514     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0515     int nr = sensor_attr->index;
0516     struct adm1026_data *data = dev_get_drvdata(dev);
0517     struct i2c_client *client = data->client;
0518     long val;
0519     int err;
0520 
0521     err = kstrtol(buf, 10, &val);
0522     if (err)
0523         return err;
0524 
0525     mutex_lock(&data->update_lock);
0526     data->in_max[nr] = INS_TO_REG(nr, val);
0527     adm1026_write_value(client, ADM1026_REG_IN_MAX[nr], data->in_max[nr]);
0528     mutex_unlock(&data->update_lock);
0529     return count;
0530 }
0531 
0532 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0533 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0534 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0535 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0536 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0537 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0538 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0539 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0540 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0541 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0542 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0543 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0544 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0545 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0546 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0547 static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
0548 static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
0549 static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
0550 static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
0551 static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
0552 static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
0553 static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
0554 static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
0555 static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
0556 static SENSOR_DEVICE_ATTR_RO(in8_input, in, 8);
0557 static SENSOR_DEVICE_ATTR_RW(in8_min, in_min, 8);
0558 static SENSOR_DEVICE_ATTR_RW(in8_max, in_max, 8);
0559 static SENSOR_DEVICE_ATTR_RO(in9_input, in, 9);
0560 static SENSOR_DEVICE_ATTR_RW(in9_min, in_min, 9);
0561 static SENSOR_DEVICE_ATTR_RW(in9_max, in_max, 9);
0562 static SENSOR_DEVICE_ATTR_RO(in10_input, in, 10);
0563 static SENSOR_DEVICE_ATTR_RW(in10_min, in_min, 10);
0564 static SENSOR_DEVICE_ATTR_RW(in10_max, in_max, 10);
0565 static SENSOR_DEVICE_ATTR_RO(in11_input, in, 11);
0566 static SENSOR_DEVICE_ATTR_RW(in11_min, in_min, 11);
0567 static SENSOR_DEVICE_ATTR_RW(in11_max, in_max, 11);
0568 static SENSOR_DEVICE_ATTR_RO(in12_input, in, 12);
0569 static SENSOR_DEVICE_ATTR_RW(in12_min, in_min, 12);
0570 static SENSOR_DEVICE_ATTR_RW(in12_max, in_max, 12);
0571 static SENSOR_DEVICE_ATTR_RO(in13_input, in, 13);
0572 static SENSOR_DEVICE_ATTR_RW(in13_min, in_min, 13);
0573 static SENSOR_DEVICE_ATTR_RW(in13_max, in_max, 13);
0574 static SENSOR_DEVICE_ATTR_RO(in14_input, in, 14);
0575 static SENSOR_DEVICE_ATTR_RW(in14_min, in_min, 14);
0576 static SENSOR_DEVICE_ATTR_RW(in14_max, in_max, 14);
0577 static SENSOR_DEVICE_ATTR_RO(in15_input, in, 15);
0578 static SENSOR_DEVICE_ATTR_RW(in15_min, in_min, 15);
0579 static SENSOR_DEVICE_ATTR_RW(in15_max, in_max, 15);
0580 
0581 static ssize_t in16_show(struct device *dev, struct device_attribute *attr,
0582              char *buf)
0583 {
0584     struct adm1026_data *data = adm1026_update_device(dev);
0585     return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in[16]) -
0586         NEG12_OFFSET);
0587 }
0588 static ssize_t in16_min_show(struct device *dev,
0589                  struct device_attribute *attr, char *buf)
0590 {
0591     struct adm1026_data *data = adm1026_update_device(dev);
0592     return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_min[16])
0593         - NEG12_OFFSET);
0594 }
0595 static ssize_t in16_min_store(struct device *dev,
0596                   struct device_attribute *attr, const char *buf,
0597                   size_t count)
0598 {
0599     struct adm1026_data *data = dev_get_drvdata(dev);
0600     struct i2c_client *client = data->client;
0601     long val;
0602     int err;
0603 
0604     err = kstrtol(buf, 10, &val);
0605     if (err)
0606         return err;
0607 
0608     mutex_lock(&data->update_lock);
0609     data->in_min[16] = INS_TO_REG(16,
0610                       clamp_val(val, INT_MIN,
0611                         INT_MAX - NEG12_OFFSET) +
0612                       NEG12_OFFSET);
0613     adm1026_write_value(client, ADM1026_REG_IN_MIN[16], data->in_min[16]);
0614     mutex_unlock(&data->update_lock);
0615     return count;
0616 }
0617 static ssize_t in16_max_show(struct device *dev,
0618                  struct device_attribute *attr, char *buf)
0619 {
0620     struct adm1026_data *data = adm1026_update_device(dev);
0621     return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_max[16])
0622             - NEG12_OFFSET);
0623 }
0624 static ssize_t in16_max_store(struct device *dev,
0625                   struct device_attribute *attr, const char *buf,
0626                   size_t count)
0627 {
0628     struct adm1026_data *data = dev_get_drvdata(dev);
0629     struct i2c_client *client = data->client;
0630     long val;
0631     int err;
0632 
0633     err = kstrtol(buf, 10, &val);
0634     if (err)
0635         return err;
0636 
0637     mutex_lock(&data->update_lock);
0638     data->in_max[16] = INS_TO_REG(16,
0639                       clamp_val(val, INT_MIN,
0640                         INT_MAX - NEG12_OFFSET) +
0641                       NEG12_OFFSET);
0642     adm1026_write_value(client, ADM1026_REG_IN_MAX[16], data->in_max[16]);
0643     mutex_unlock(&data->update_lock);
0644     return count;
0645 }
0646 
0647 static SENSOR_DEVICE_ATTR_RO(in16_input, in16, 16);
0648 static SENSOR_DEVICE_ATTR_RW(in16_min, in16_min, 16);
0649 static SENSOR_DEVICE_ATTR_RW(in16_max, in16_max, 16);
0650 
0651 /* Now add fan read/write functions */
0652 
0653 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
0654             char *buf)
0655 {
0656     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0657     int nr = sensor_attr->index;
0658     struct adm1026_data *data = adm1026_update_device(dev);
0659     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
0660         data->fan_div[nr]));
0661 }
0662 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
0663                 char *buf)
0664 {
0665     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0666     int nr = sensor_attr->index;
0667     struct adm1026_data *data = adm1026_update_device(dev);
0668     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
0669         data->fan_div[nr]));
0670 }
0671 static ssize_t fan_min_store(struct device *dev,
0672                  struct device_attribute *attr, const char *buf,
0673                  size_t count)
0674 {
0675     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0676     int nr = sensor_attr->index;
0677     struct adm1026_data *data = dev_get_drvdata(dev);
0678     struct i2c_client *client = data->client;
0679     long val;
0680     int err;
0681 
0682     err = kstrtol(buf, 10, &val);
0683     if (err)
0684         return err;
0685 
0686     mutex_lock(&data->update_lock);
0687     data->fan_min[nr] = FAN_TO_REG(val, data->fan_div[nr]);
0688     adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
0689         data->fan_min[nr]);
0690     mutex_unlock(&data->update_lock);
0691     return count;
0692 }
0693 
0694 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
0695 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0696 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
0697 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0698 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
0699 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
0700 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
0701 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
0702 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
0703 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
0704 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
0705 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
0706 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
0707 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
0708 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
0709 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
0710 
0711 /* Adjust fan_min to account for new fan divisor */
0712 static void fixup_fan_min(struct device *dev, int fan, int old_div)
0713 {
0714     struct adm1026_data *data = dev_get_drvdata(dev);
0715     struct i2c_client *client = data->client;
0716     int new_min;
0717     int new_div = data->fan_div[fan];
0718 
0719     /* 0 and 0xff are special.  Don't adjust them */
0720     if (data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff)
0721         return;
0722 
0723     new_min = data->fan_min[fan] * old_div / new_div;
0724     new_min = clamp_val(new_min, 1, 254);
0725     data->fan_min[fan] = new_min;
0726     adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), new_min);
0727 }
0728 
0729 /* Now add fan_div read/write functions */
0730 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
0731                 char *buf)
0732 {
0733     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0734     int nr = sensor_attr->index;
0735     struct adm1026_data *data = adm1026_update_device(dev);
0736     return sprintf(buf, "%d\n", data->fan_div[nr]);
0737 }
0738 static ssize_t fan_div_store(struct device *dev,
0739                  struct device_attribute *attr, const char *buf,
0740                  size_t count)
0741 {
0742     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0743     int nr = sensor_attr->index;
0744     struct adm1026_data *data = dev_get_drvdata(dev);
0745     struct i2c_client *client = data->client;
0746     long val;
0747     int orig_div, new_div;
0748     int err;
0749 
0750     err = kstrtol(buf, 10, &val);
0751     if (err)
0752         return err;
0753 
0754     new_div = DIV_TO_REG(val);
0755 
0756     mutex_lock(&data->update_lock);
0757     orig_div = data->fan_div[nr];
0758     data->fan_div[nr] = DIV_FROM_REG(new_div);
0759 
0760     if (nr < 4) { /* 0 <= nr < 4 */
0761         adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3,
0762                     (DIV_TO_REG(data->fan_div[0]) << 0) |
0763                     (DIV_TO_REG(data->fan_div[1]) << 2) |
0764                     (DIV_TO_REG(data->fan_div[2]) << 4) |
0765                     (DIV_TO_REG(data->fan_div[3]) << 6));
0766     } else { /* 3 < nr < 8 */
0767         adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7,
0768                     (DIV_TO_REG(data->fan_div[4]) << 0) |
0769                     (DIV_TO_REG(data->fan_div[5]) << 2) |
0770                     (DIV_TO_REG(data->fan_div[6]) << 4) |
0771                     (DIV_TO_REG(data->fan_div[7]) << 6));
0772     }
0773 
0774     if (data->fan_div[nr] != orig_div)
0775         fixup_fan_min(dev, nr, orig_div);
0776 
0777     mutex_unlock(&data->update_lock);
0778     return count;
0779 }
0780 
0781 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0782 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0783 static SENSOR_DEVICE_ATTR_RW(fan3_div, fan_div, 2);
0784 static SENSOR_DEVICE_ATTR_RW(fan4_div, fan_div, 3);
0785 static SENSOR_DEVICE_ATTR_RW(fan5_div, fan_div, 4);
0786 static SENSOR_DEVICE_ATTR_RW(fan6_div, fan_div, 5);
0787 static SENSOR_DEVICE_ATTR_RW(fan7_div, fan_div, 6);
0788 static SENSOR_DEVICE_ATTR_RW(fan8_div, fan_div, 7);
0789 
0790 /* Temps */
0791 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0792              char *buf)
0793 {
0794     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0795     int nr = sensor_attr->index;
0796     struct adm1026_data *data = adm1026_update_device(dev);
0797     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
0798 }
0799 static ssize_t temp_min_show(struct device *dev,
0800                  struct device_attribute *attr, char *buf)
0801 {
0802     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0803     int nr = sensor_attr->index;
0804     struct adm1026_data *data = adm1026_update_device(dev);
0805     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
0806 }
0807 static ssize_t temp_min_store(struct device *dev,
0808                   struct device_attribute *attr, const char *buf,
0809                   size_t count)
0810 {
0811     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0812     int nr = sensor_attr->index;
0813     struct adm1026_data *data = dev_get_drvdata(dev);
0814     struct i2c_client *client = data->client;
0815     long val;
0816     int err;
0817 
0818     err = kstrtol(buf, 10, &val);
0819     if (err)
0820         return err;
0821 
0822     mutex_lock(&data->update_lock);
0823     data->temp_min[nr] = TEMP_TO_REG(val);
0824     adm1026_write_value(client, ADM1026_REG_TEMP_MIN[nr],
0825         data->temp_min[nr]);
0826     mutex_unlock(&data->update_lock);
0827     return count;
0828 }
0829 static ssize_t temp_max_show(struct device *dev,
0830                  struct device_attribute *attr, char *buf)
0831 {
0832     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0833     int nr = sensor_attr->index;
0834     struct adm1026_data *data = adm1026_update_device(dev);
0835     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
0836 }
0837 static ssize_t temp_max_store(struct device *dev,
0838                   struct device_attribute *attr, const char *buf,
0839                   size_t count)
0840 {
0841     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0842     int nr = sensor_attr->index;
0843     struct adm1026_data *data = dev_get_drvdata(dev);
0844     struct i2c_client *client = data->client;
0845     long val;
0846     int err;
0847 
0848     err = kstrtol(buf, 10, &val);
0849     if (err)
0850         return err;
0851 
0852     mutex_lock(&data->update_lock);
0853     data->temp_max[nr] = TEMP_TO_REG(val);
0854     adm1026_write_value(client, ADM1026_REG_TEMP_MAX[nr],
0855         data->temp_max[nr]);
0856     mutex_unlock(&data->update_lock);
0857     return count;
0858 }
0859 
0860 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0861 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
0862 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0863 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0864 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
0865 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0866 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0867 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
0868 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
0869 
0870 static ssize_t temp_offset_show(struct device *dev,
0871                 struct device_attribute *attr, char *buf)
0872 {
0873     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0874     int nr = sensor_attr->index;
0875     struct adm1026_data *data = adm1026_update_device(dev);
0876     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
0877 }
0878 static ssize_t temp_offset_store(struct device *dev,
0879                  struct device_attribute *attr,
0880                  const char *buf, size_t count)
0881 {
0882     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0883     int nr = sensor_attr->index;
0884     struct adm1026_data *data = dev_get_drvdata(dev);
0885     struct i2c_client *client = data->client;
0886     long val;
0887     int err;
0888 
0889     err = kstrtol(buf, 10, &val);
0890     if (err)
0891         return err;
0892 
0893     mutex_lock(&data->update_lock);
0894     data->temp_offset[nr] = TEMP_TO_REG(val);
0895     adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET[nr],
0896         data->temp_offset[nr]);
0897     mutex_unlock(&data->update_lock);
0898     return count;
0899 }
0900 
0901 static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
0902 static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
0903 static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
0904 
0905 static ssize_t temp_auto_point1_temp_hyst_show(struct device *dev,
0906                            struct device_attribute *attr,
0907                            char *buf)
0908 {
0909     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0910     int nr = sensor_attr->index;
0911     struct adm1026_data *data = adm1026_update_device(dev);
0912     return sprintf(buf, "%d\n", TEMP_FROM_REG(
0913         ADM1026_FAN_ACTIVATION_TEMP_HYST + data->temp_tmin[nr]));
0914 }
0915 static ssize_t temp_auto_point2_temp_show(struct device *dev,
0916                       struct device_attribute *attr,
0917                       char *buf)
0918 {
0919     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0920     int nr = sensor_attr->index;
0921     struct adm1026_data *data = adm1026_update_device(dev);
0922     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr] +
0923         ADM1026_FAN_CONTROL_TEMP_RANGE));
0924 }
0925 static ssize_t temp_auto_point1_temp_show(struct device *dev,
0926                       struct device_attribute *attr,
0927                       char *buf)
0928 {
0929     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0930     int nr = sensor_attr->index;
0931     struct adm1026_data *data = adm1026_update_device(dev);
0932     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr]));
0933 }
0934 static ssize_t temp_auto_point1_temp_store(struct device *dev,
0935                        struct device_attribute *attr,
0936                        const char *buf, size_t count)
0937 {
0938     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0939     int nr = sensor_attr->index;
0940     struct adm1026_data *data = dev_get_drvdata(dev);
0941     struct i2c_client *client = data->client;
0942     long val;
0943     int err;
0944 
0945     err = kstrtol(buf, 10, &val);
0946     if (err)
0947         return err;
0948 
0949     mutex_lock(&data->update_lock);
0950     data->temp_tmin[nr] = TEMP_TO_REG(val);
0951     adm1026_write_value(client, ADM1026_REG_TEMP_TMIN[nr],
0952         data->temp_tmin[nr]);
0953     mutex_unlock(&data->update_lock);
0954     return count;
0955 }
0956 
0957 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, temp_auto_point1_temp, 0);
0958 static SENSOR_DEVICE_ATTR_RO(temp1_auto_point1_temp_hyst,
0959                  temp_auto_point1_temp_hyst, 0);
0960 static SENSOR_DEVICE_ATTR_RO(temp1_auto_point2_temp, temp_auto_point2_temp, 0);
0961 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, temp_auto_point1_temp, 1);
0962 static SENSOR_DEVICE_ATTR_RO(temp2_auto_point1_temp_hyst,
0963                  temp_auto_point1_temp_hyst, 1);
0964 static SENSOR_DEVICE_ATTR_RO(temp2_auto_point2_temp, temp_auto_point2_temp, 1);
0965 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, temp_auto_point1_temp, 2);
0966 static SENSOR_DEVICE_ATTR_RO(temp3_auto_point1_temp_hyst,
0967                  temp_auto_point1_temp_hyst, 2);
0968 static SENSOR_DEVICE_ATTR_RO(temp3_auto_point2_temp, temp_auto_point2_temp, 2);
0969 
0970 static ssize_t show_temp_crit_enable(struct device *dev,
0971         struct device_attribute *attr, char *buf)
0972 {
0973     struct adm1026_data *data = adm1026_update_device(dev);
0974     return sprintf(buf, "%d\n", (data->config1 & CFG1_THERM_HOT) >> 4);
0975 }
0976 static ssize_t set_temp_crit_enable(struct device *dev,
0977         struct device_attribute *attr, const char *buf, size_t count)
0978 {
0979     struct adm1026_data *data = dev_get_drvdata(dev);
0980     struct i2c_client *client = data->client;
0981     unsigned long val;
0982     int err;
0983 
0984     err = kstrtoul(buf, 10, &val);
0985     if (err)
0986         return err;
0987 
0988     if (val > 1)
0989         return -EINVAL;
0990 
0991     mutex_lock(&data->update_lock);
0992     data->config1 = (data->config1 & ~CFG1_THERM_HOT) | (val << 4);
0993     adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1);
0994     mutex_unlock(&data->update_lock);
0995 
0996     return count;
0997 }
0998 
0999 static DEVICE_ATTR(temp1_crit_enable, 0644, show_temp_crit_enable,
1000            set_temp_crit_enable);
1001 static DEVICE_ATTR(temp2_crit_enable, 0644, show_temp_crit_enable,
1002            set_temp_crit_enable);
1003 static DEVICE_ATTR(temp3_crit_enable, 0644, show_temp_crit_enable,
1004            set_temp_crit_enable);
1005 
1006 static ssize_t temp_crit_show(struct device *dev,
1007                   struct device_attribute *attr, char *buf)
1008 {
1009     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1010     int nr = sensor_attr->index;
1011     struct adm1026_data *data = adm1026_update_device(dev);
1012     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
1013 }
1014 static ssize_t temp_crit_store(struct device *dev,
1015                    struct device_attribute *attr, const char *buf,
1016                    size_t count)
1017 {
1018     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1019     int nr = sensor_attr->index;
1020     struct adm1026_data *data = dev_get_drvdata(dev);
1021     struct i2c_client *client = data->client;
1022     long val;
1023     int err;
1024 
1025     err = kstrtol(buf, 10, &val);
1026     if (err)
1027         return err;
1028 
1029     mutex_lock(&data->update_lock);
1030     data->temp_crit[nr] = TEMP_TO_REG(val);
1031     adm1026_write_value(client, ADM1026_REG_TEMP_THERM[nr],
1032         data->temp_crit[nr]);
1033     mutex_unlock(&data->update_lock);
1034     return count;
1035 }
1036 
1037 static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
1038 static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
1039 static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
1040 
1041 static ssize_t analog_out_show(struct device *dev,
1042                    struct device_attribute *attr, char *buf)
1043 {
1044     struct adm1026_data *data = adm1026_update_device(dev);
1045     return sprintf(buf, "%d\n", DAC_FROM_REG(data->analog_out));
1046 }
1047 static ssize_t analog_out_store(struct device *dev,
1048                 struct device_attribute *attr,
1049                 const char *buf, size_t count)
1050 {
1051     struct adm1026_data *data = dev_get_drvdata(dev);
1052     struct i2c_client *client = data->client;
1053     long val;
1054     int err;
1055 
1056     err = kstrtol(buf, 10, &val);
1057     if (err)
1058         return err;
1059 
1060     mutex_lock(&data->update_lock);
1061     data->analog_out = DAC_TO_REG(val);
1062     adm1026_write_value(client, ADM1026_REG_DAC, data->analog_out);
1063     mutex_unlock(&data->update_lock);
1064     return count;
1065 }
1066 
1067 static DEVICE_ATTR_RW(analog_out);
1068 
1069 static ssize_t cpu0_vid_show(struct device *dev,
1070                  struct device_attribute *attr, char *buf)
1071 {
1072     struct adm1026_data *data = adm1026_update_device(dev);
1073     int vid = (data->gpio >> 11) & 0x1f;
1074 
1075     dev_dbg(dev, "Setting VID from GPIO11-15.\n");
1076     return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm));
1077 }
1078 
1079 static DEVICE_ATTR_RO(cpu0_vid);
1080 
1081 static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
1082             char *buf)
1083 {
1084     struct adm1026_data *data = dev_get_drvdata(dev);
1085     return sprintf(buf, "%d\n", data->vrm);
1086 }
1087 
1088 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
1089              const char *buf, size_t count)
1090 {
1091     struct adm1026_data *data = dev_get_drvdata(dev);
1092     unsigned long val;
1093     int err;
1094 
1095     err = kstrtoul(buf, 10, &val);
1096     if (err)
1097         return err;
1098 
1099     if (val > 255)
1100         return -EINVAL;
1101 
1102     data->vrm = val;
1103     return count;
1104 }
1105 
1106 static DEVICE_ATTR_RW(vrm);
1107 
1108 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
1109                char *buf)
1110 {
1111     struct adm1026_data *data = adm1026_update_device(dev);
1112     return sprintf(buf, "%ld\n", data->alarms);
1113 }
1114 
1115 static DEVICE_ATTR_RO(alarms);
1116 
1117 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
1118               char *buf)
1119 {
1120     struct adm1026_data *data = adm1026_update_device(dev);
1121     int bitnr = to_sensor_dev_attr(attr)->index;
1122     return sprintf(buf, "%ld\n", (data->alarms >> bitnr) & 1);
1123 }
1124 
1125 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0);
1126 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
1127 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm, 1);
1128 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm, 2);
1129 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm, 3);
1130 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm, 4);
1131 static SENSOR_DEVICE_ATTR_RO(in14_alarm, alarm, 5);
1132 static SENSOR_DEVICE_ATTR_RO(in15_alarm, alarm, 6);
1133 static SENSOR_DEVICE_ATTR_RO(in16_alarm, alarm, 7);
1134 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 8);
1135 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 9);
1136 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 10);
1137 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 11);
1138 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 12);
1139 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 13);
1140 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 14);
1141 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 15);
1142 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 16);
1143 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 17);
1144 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 18);
1145 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 19);
1146 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm, 20);
1147 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm, 21);
1148 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm, 22);
1149 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm, 23);
1150 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 24);
1151 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm, 25);
1152 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm, 26);
1153 
1154 static ssize_t alarm_mask_show(struct device *dev,
1155                    struct device_attribute *attr, char *buf)
1156 {
1157     struct adm1026_data *data = adm1026_update_device(dev);
1158     return sprintf(buf, "%ld\n", data->alarm_mask);
1159 }
1160 static ssize_t alarm_mask_store(struct device *dev,
1161                 struct device_attribute *attr,
1162                 const char *buf, size_t count)
1163 {
1164     struct adm1026_data *data = dev_get_drvdata(dev);
1165     struct i2c_client *client = data->client;
1166     unsigned long mask;
1167     long val;
1168     int err;
1169 
1170     err = kstrtol(buf, 10, &val);
1171     if (err)
1172         return err;
1173 
1174     mutex_lock(&data->update_lock);
1175     data->alarm_mask = val & 0x7fffffff;
1176     mask = data->alarm_mask
1177         | (data->gpio_mask & 0x10000 ? 0x80000000 : 0);
1178     adm1026_write_value(client, ADM1026_REG_MASK1,
1179         mask & 0xff);
1180     mask >>= 8;
1181     adm1026_write_value(client, ADM1026_REG_MASK2,
1182         mask & 0xff);
1183     mask >>= 8;
1184     adm1026_write_value(client, ADM1026_REG_MASK3,
1185         mask & 0xff);
1186     mask >>= 8;
1187     adm1026_write_value(client, ADM1026_REG_MASK4,
1188         mask & 0xff);
1189     mutex_unlock(&data->update_lock);
1190     return count;
1191 }
1192 
1193 static DEVICE_ATTR_RW(alarm_mask);
1194 
1195 static ssize_t gpio_show(struct device *dev, struct device_attribute *attr,
1196              char *buf)
1197 {
1198     struct adm1026_data *data = adm1026_update_device(dev);
1199     return sprintf(buf, "%ld\n", data->gpio);
1200 }
1201 static ssize_t gpio_store(struct device *dev, struct device_attribute *attr,
1202               const char *buf, size_t count)
1203 {
1204     struct adm1026_data *data = dev_get_drvdata(dev);
1205     struct i2c_client *client = data->client;
1206     long gpio;
1207     long val;
1208     int err;
1209 
1210     err = kstrtol(buf, 10, &val);
1211     if (err)
1212         return err;
1213 
1214     mutex_lock(&data->update_lock);
1215     data->gpio = val & 0x1ffff;
1216     gpio = data->gpio;
1217     adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_0_7, gpio & 0xff);
1218     gpio >>= 8;
1219     adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15, gpio & 0xff);
1220     gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
1221     adm1026_write_value(client, ADM1026_REG_STATUS4, gpio & 0xff);
1222     mutex_unlock(&data->update_lock);
1223     return count;
1224 }
1225 
1226 static DEVICE_ATTR_RW(gpio);
1227 
1228 static ssize_t gpio_mask_show(struct device *dev,
1229                   struct device_attribute *attr,
1230                   char *buf)
1231 {
1232     struct adm1026_data *data = adm1026_update_device(dev);
1233     return sprintf(buf, "%ld\n", data->gpio_mask);
1234 }
1235 static ssize_t gpio_mask_store(struct device *dev,
1236                    struct device_attribute *attr, const char *buf,
1237                    size_t count)
1238 {
1239     struct adm1026_data *data = dev_get_drvdata(dev);
1240     struct i2c_client *client = data->client;
1241     long mask;
1242     long val;
1243     int err;
1244 
1245     err = kstrtol(buf, 10, &val);
1246     if (err)
1247         return err;
1248 
1249     mutex_lock(&data->update_lock);
1250     data->gpio_mask = val & 0x1ffff;
1251     mask = data->gpio_mask;
1252     adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7, mask & 0xff);
1253     mask >>= 8;
1254     adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15, mask & 0xff);
1255     mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
1256     adm1026_write_value(client, ADM1026_REG_MASK1, mask & 0xff);
1257     mutex_unlock(&data->update_lock);
1258     return count;
1259 }
1260 
1261 static DEVICE_ATTR_RW(gpio_mask);
1262 
1263 static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
1264              char *buf)
1265 {
1266     struct adm1026_data *data = adm1026_update_device(dev);
1267     return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm1.pwm));
1268 }
1269 
1270 static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
1271               const char *buf, size_t count)
1272 {
1273     struct adm1026_data *data = dev_get_drvdata(dev);
1274     struct i2c_client *client = data->client;
1275 
1276     if (data->pwm1.enable == 1) {
1277         long val;
1278         int err;
1279 
1280         err = kstrtol(buf, 10, &val);
1281         if (err)
1282             return err;
1283 
1284         mutex_lock(&data->update_lock);
1285         data->pwm1.pwm = PWM_TO_REG(val);
1286         adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1287         mutex_unlock(&data->update_lock);
1288     }
1289     return count;
1290 }
1291 
1292 static ssize_t temp1_auto_point1_pwm_show(struct device *dev,
1293                       struct device_attribute *attr,
1294                       char *buf)
1295 {
1296     struct adm1026_data *data = adm1026_update_device(dev);
1297     return sprintf(buf, "%d\n", data->pwm1.auto_pwm_min);
1298 }
1299 
1300 static ssize_t temp1_auto_point1_pwm_store(struct device *dev,
1301                        struct device_attribute *attr,
1302                        const char *buf, size_t count)
1303 {
1304     struct adm1026_data *data = dev_get_drvdata(dev);
1305     struct i2c_client *client = data->client;
1306     unsigned long val;
1307     int err;
1308 
1309     err = kstrtoul(buf, 10, &val);
1310     if (err)
1311         return err;
1312 
1313     mutex_lock(&data->update_lock);
1314     data->pwm1.auto_pwm_min = clamp_val(val, 0, 255);
1315     if (data->pwm1.enable == 2) { /* apply immediately */
1316         data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1317             PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1318         adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1319     }
1320     mutex_unlock(&data->update_lock);
1321     return count;
1322 }
1323 
1324 static ssize_t temp1_auto_point2_pwm_show(struct device *dev,
1325                       struct device_attribute *attr,
1326                       char *buf)
1327 {
1328     return sprintf(buf, "%d\n", ADM1026_PWM_MAX);
1329 }
1330 
1331 static ssize_t pwm1_enable_show(struct device *dev,
1332                 struct device_attribute *attr, char *buf)
1333 {
1334     struct adm1026_data *data = adm1026_update_device(dev);
1335     return sprintf(buf, "%d\n", data->pwm1.enable);
1336 }
1337 
1338 static ssize_t pwm1_enable_store(struct device *dev,
1339                  struct device_attribute *attr,
1340                  const char *buf, size_t count)
1341 {
1342     struct adm1026_data *data = dev_get_drvdata(dev);
1343     struct i2c_client *client = data->client;
1344     int old_enable;
1345     unsigned long val;
1346     int err;
1347 
1348     err = kstrtoul(buf, 10, &val);
1349     if (err)
1350         return err;
1351 
1352     if (val >= 3)
1353         return -EINVAL;
1354 
1355     mutex_lock(&data->update_lock);
1356     old_enable = data->pwm1.enable;
1357     data->pwm1.enable = val;
1358     data->config1 = (data->config1 & ~CFG1_PWM_AFC)
1359             | ((val == 2) ? CFG1_PWM_AFC : 0);
1360     adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1);
1361     if (val == 2) { /* apply pwm1_auto_pwm_min to pwm1 */
1362         data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1363             PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1364         adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1365     } else if (!((old_enable == 1) && (val == 1))) {
1366         /* set pwm to safe value */
1367         data->pwm1.pwm = 255;
1368         adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1369     }
1370     mutex_unlock(&data->update_lock);
1371 
1372     return count;
1373 }
1374 
1375 /* enable PWM fan control */
1376 static DEVICE_ATTR_RW(pwm1);
1377 static DEVICE_ATTR(pwm2, 0644, pwm1_show, pwm1_store);
1378 static DEVICE_ATTR(pwm3, 0644, pwm1_show, pwm1_store);
1379 static DEVICE_ATTR_RW(pwm1_enable);
1380 static DEVICE_ATTR(pwm2_enable, 0644, pwm1_enable_show,
1381            pwm1_enable_store);
1382 static DEVICE_ATTR(pwm3_enable, 0644, pwm1_enable_show,
1383            pwm1_enable_store);
1384 static DEVICE_ATTR_RW(temp1_auto_point1_pwm);
1385 static DEVICE_ATTR(temp2_auto_point1_pwm, 0644,
1386            temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1387 static DEVICE_ATTR(temp3_auto_point1_pwm, 0644,
1388            temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1389 
1390 static DEVICE_ATTR_RO(temp1_auto_point2_pwm);
1391 static DEVICE_ATTR(temp2_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1392            NULL);
1393 static DEVICE_ATTR(temp3_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1394            NULL);
1395 
1396 static struct attribute *adm1026_attributes[] = {
1397     &sensor_dev_attr_in0_input.dev_attr.attr,
1398     &sensor_dev_attr_in0_max.dev_attr.attr,
1399     &sensor_dev_attr_in0_min.dev_attr.attr,
1400     &sensor_dev_attr_in0_alarm.dev_attr.attr,
1401     &sensor_dev_attr_in1_input.dev_attr.attr,
1402     &sensor_dev_attr_in1_max.dev_attr.attr,
1403     &sensor_dev_attr_in1_min.dev_attr.attr,
1404     &sensor_dev_attr_in1_alarm.dev_attr.attr,
1405     &sensor_dev_attr_in2_input.dev_attr.attr,
1406     &sensor_dev_attr_in2_max.dev_attr.attr,
1407     &sensor_dev_attr_in2_min.dev_attr.attr,
1408     &sensor_dev_attr_in2_alarm.dev_attr.attr,
1409     &sensor_dev_attr_in3_input.dev_attr.attr,
1410     &sensor_dev_attr_in3_max.dev_attr.attr,
1411     &sensor_dev_attr_in3_min.dev_attr.attr,
1412     &sensor_dev_attr_in3_alarm.dev_attr.attr,
1413     &sensor_dev_attr_in4_input.dev_attr.attr,
1414     &sensor_dev_attr_in4_max.dev_attr.attr,
1415     &sensor_dev_attr_in4_min.dev_attr.attr,
1416     &sensor_dev_attr_in4_alarm.dev_attr.attr,
1417     &sensor_dev_attr_in5_input.dev_attr.attr,
1418     &sensor_dev_attr_in5_max.dev_attr.attr,
1419     &sensor_dev_attr_in5_min.dev_attr.attr,
1420     &sensor_dev_attr_in5_alarm.dev_attr.attr,
1421     &sensor_dev_attr_in6_input.dev_attr.attr,
1422     &sensor_dev_attr_in6_max.dev_attr.attr,
1423     &sensor_dev_attr_in6_min.dev_attr.attr,
1424     &sensor_dev_attr_in6_alarm.dev_attr.attr,
1425     &sensor_dev_attr_in7_input.dev_attr.attr,
1426     &sensor_dev_attr_in7_max.dev_attr.attr,
1427     &sensor_dev_attr_in7_min.dev_attr.attr,
1428     &sensor_dev_attr_in7_alarm.dev_attr.attr,
1429     &sensor_dev_attr_in10_input.dev_attr.attr,
1430     &sensor_dev_attr_in10_max.dev_attr.attr,
1431     &sensor_dev_attr_in10_min.dev_attr.attr,
1432     &sensor_dev_attr_in10_alarm.dev_attr.attr,
1433     &sensor_dev_attr_in11_input.dev_attr.attr,
1434     &sensor_dev_attr_in11_max.dev_attr.attr,
1435     &sensor_dev_attr_in11_min.dev_attr.attr,
1436     &sensor_dev_attr_in11_alarm.dev_attr.attr,
1437     &sensor_dev_attr_in12_input.dev_attr.attr,
1438     &sensor_dev_attr_in12_max.dev_attr.attr,
1439     &sensor_dev_attr_in12_min.dev_attr.attr,
1440     &sensor_dev_attr_in12_alarm.dev_attr.attr,
1441     &sensor_dev_attr_in13_input.dev_attr.attr,
1442     &sensor_dev_attr_in13_max.dev_attr.attr,
1443     &sensor_dev_attr_in13_min.dev_attr.attr,
1444     &sensor_dev_attr_in13_alarm.dev_attr.attr,
1445     &sensor_dev_attr_in14_input.dev_attr.attr,
1446     &sensor_dev_attr_in14_max.dev_attr.attr,
1447     &sensor_dev_attr_in14_min.dev_attr.attr,
1448     &sensor_dev_attr_in14_alarm.dev_attr.attr,
1449     &sensor_dev_attr_in15_input.dev_attr.attr,
1450     &sensor_dev_attr_in15_max.dev_attr.attr,
1451     &sensor_dev_attr_in15_min.dev_attr.attr,
1452     &sensor_dev_attr_in15_alarm.dev_attr.attr,
1453     &sensor_dev_attr_in16_input.dev_attr.attr,
1454     &sensor_dev_attr_in16_max.dev_attr.attr,
1455     &sensor_dev_attr_in16_min.dev_attr.attr,
1456     &sensor_dev_attr_in16_alarm.dev_attr.attr,
1457     &sensor_dev_attr_fan1_input.dev_attr.attr,
1458     &sensor_dev_attr_fan1_div.dev_attr.attr,
1459     &sensor_dev_attr_fan1_min.dev_attr.attr,
1460     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1461     &sensor_dev_attr_fan2_input.dev_attr.attr,
1462     &sensor_dev_attr_fan2_div.dev_attr.attr,
1463     &sensor_dev_attr_fan2_min.dev_attr.attr,
1464     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1465     &sensor_dev_attr_fan3_input.dev_attr.attr,
1466     &sensor_dev_attr_fan3_div.dev_attr.attr,
1467     &sensor_dev_attr_fan3_min.dev_attr.attr,
1468     &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1469     &sensor_dev_attr_fan4_input.dev_attr.attr,
1470     &sensor_dev_attr_fan4_div.dev_attr.attr,
1471     &sensor_dev_attr_fan4_min.dev_attr.attr,
1472     &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1473     &sensor_dev_attr_fan5_input.dev_attr.attr,
1474     &sensor_dev_attr_fan5_div.dev_attr.attr,
1475     &sensor_dev_attr_fan5_min.dev_attr.attr,
1476     &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1477     &sensor_dev_attr_fan6_input.dev_attr.attr,
1478     &sensor_dev_attr_fan6_div.dev_attr.attr,
1479     &sensor_dev_attr_fan6_min.dev_attr.attr,
1480     &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1481     &sensor_dev_attr_fan7_input.dev_attr.attr,
1482     &sensor_dev_attr_fan7_div.dev_attr.attr,
1483     &sensor_dev_attr_fan7_min.dev_attr.attr,
1484     &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1485     &sensor_dev_attr_fan8_input.dev_attr.attr,
1486     &sensor_dev_attr_fan8_div.dev_attr.attr,
1487     &sensor_dev_attr_fan8_min.dev_attr.attr,
1488     &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1489     &sensor_dev_attr_temp1_input.dev_attr.attr,
1490     &sensor_dev_attr_temp1_max.dev_attr.attr,
1491     &sensor_dev_attr_temp1_min.dev_attr.attr,
1492     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1493     &sensor_dev_attr_temp2_input.dev_attr.attr,
1494     &sensor_dev_attr_temp2_max.dev_attr.attr,
1495     &sensor_dev_attr_temp2_min.dev_attr.attr,
1496     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1497     &sensor_dev_attr_temp1_offset.dev_attr.attr,
1498     &sensor_dev_attr_temp2_offset.dev_attr.attr,
1499     &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1500     &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1501     &sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr,
1502     &sensor_dev_attr_temp2_auto_point1_temp_hyst.dev_attr.attr,
1503     &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1504     &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1505     &sensor_dev_attr_temp1_crit.dev_attr.attr,
1506     &sensor_dev_attr_temp2_crit.dev_attr.attr,
1507     &dev_attr_temp1_crit_enable.attr,
1508     &dev_attr_temp2_crit_enable.attr,
1509     &dev_attr_cpu0_vid.attr,
1510     &dev_attr_vrm.attr,
1511     &dev_attr_alarms.attr,
1512     &dev_attr_alarm_mask.attr,
1513     &dev_attr_gpio.attr,
1514     &dev_attr_gpio_mask.attr,
1515     &dev_attr_pwm1.attr,
1516     &dev_attr_pwm2.attr,
1517     &dev_attr_pwm3.attr,
1518     &dev_attr_pwm1_enable.attr,
1519     &dev_attr_pwm2_enable.attr,
1520     &dev_attr_pwm3_enable.attr,
1521     &dev_attr_temp1_auto_point1_pwm.attr,
1522     &dev_attr_temp2_auto_point1_pwm.attr,
1523     &dev_attr_temp1_auto_point2_pwm.attr,
1524     &dev_attr_temp2_auto_point2_pwm.attr,
1525     &dev_attr_analog_out.attr,
1526     NULL
1527 };
1528 
1529 static const struct attribute_group adm1026_group = {
1530     .attrs = adm1026_attributes,
1531 };
1532 
1533 static struct attribute *adm1026_attributes_temp3[] = {
1534     &sensor_dev_attr_temp3_input.dev_attr.attr,
1535     &sensor_dev_attr_temp3_max.dev_attr.attr,
1536     &sensor_dev_attr_temp3_min.dev_attr.attr,
1537     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1538     &sensor_dev_attr_temp3_offset.dev_attr.attr,
1539     &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1540     &sensor_dev_attr_temp3_auto_point1_temp_hyst.dev_attr.attr,
1541     &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1542     &sensor_dev_attr_temp3_crit.dev_attr.attr,
1543     &dev_attr_temp3_crit_enable.attr,
1544     &dev_attr_temp3_auto_point1_pwm.attr,
1545     &dev_attr_temp3_auto_point2_pwm.attr,
1546     NULL
1547 };
1548 
1549 static const struct attribute_group adm1026_group_temp3 = {
1550     .attrs = adm1026_attributes_temp3,
1551 };
1552 
1553 static struct attribute *adm1026_attributes_in8_9[] = {
1554     &sensor_dev_attr_in8_input.dev_attr.attr,
1555     &sensor_dev_attr_in8_max.dev_attr.attr,
1556     &sensor_dev_attr_in8_min.dev_attr.attr,
1557     &sensor_dev_attr_in8_alarm.dev_attr.attr,
1558     &sensor_dev_attr_in9_input.dev_attr.attr,
1559     &sensor_dev_attr_in9_max.dev_attr.attr,
1560     &sensor_dev_attr_in9_min.dev_attr.attr,
1561     &sensor_dev_attr_in9_alarm.dev_attr.attr,
1562     NULL
1563 };
1564 
1565 static const struct attribute_group adm1026_group_in8_9 = {
1566     .attrs = adm1026_attributes_in8_9,
1567 };
1568 
1569 /* Return 0 if detection is successful, -ENODEV otherwise */
1570 static int adm1026_detect(struct i2c_client *client,
1571               struct i2c_board_info *info)
1572 {
1573     struct i2c_adapter *adapter = client->adapter;
1574     int address = client->addr;
1575     int company, verstep;
1576 
1577     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1578         /* We need to be able to do byte I/O */
1579         return -ENODEV;
1580     }
1581 
1582     /* Now, we do the remaining detection. */
1583 
1584     company = adm1026_read_value(client, ADM1026_REG_COMPANY);
1585     verstep = adm1026_read_value(client, ADM1026_REG_VERSTEP);
1586 
1587     dev_dbg(&adapter->dev,
1588         "Detecting device at %d,0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
1589         i2c_adapter_id(client->adapter), client->addr,
1590         company, verstep);
1591 
1592     /* Determine the chip type. */
1593     dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x...\n",
1594         i2c_adapter_id(adapter), address);
1595     if (company == ADM1026_COMPANY_ANALOG_DEV
1596         && verstep == ADM1026_VERSTEP_ADM1026) {
1597         /* Analog Devices ADM1026 */
1598     } else if (company == ADM1026_COMPANY_ANALOG_DEV
1599         && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
1600         dev_err(&adapter->dev,
1601             "Unrecognized stepping 0x%02x. Defaulting to ADM1026.\n",
1602             verstep);
1603     } else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
1604         dev_err(&adapter->dev,
1605             "Found version/stepping 0x%02x. Assuming generic ADM1026.\n",
1606             verstep);
1607     } else {
1608         dev_dbg(&adapter->dev, "Autodetection failed\n");
1609         /* Not an ADM1026... */
1610         return -ENODEV;
1611     }
1612 
1613     strlcpy(info->type, "adm1026", I2C_NAME_SIZE);
1614 
1615     return 0;
1616 }
1617 
1618 static void adm1026_print_gpio(struct i2c_client *client)
1619 {
1620     struct adm1026_data *data = i2c_get_clientdata(client);
1621     int i;
1622 
1623     dev_dbg(&client->dev, "GPIO config is:\n");
1624     for (i = 0; i <= 7; ++i) {
1625         if (data->config2 & (1 << i)) {
1626             dev_dbg(&client->dev, "\t%sGP%s%d\n",
1627                 data->gpio_config[i] & 0x02 ? "" : "!",
1628                 data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1629                 i);
1630         } else {
1631             dev_dbg(&client->dev, "\tFAN%d\n", i);
1632         }
1633     }
1634     for (i = 8; i <= 15; ++i) {
1635         dev_dbg(&client->dev, "\t%sGP%s%d\n",
1636             data->gpio_config[i] & 0x02 ? "" : "!",
1637             data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1638             i);
1639     }
1640     if (data->config3 & CFG3_GPIO16_ENABLE) {
1641         dev_dbg(&client->dev, "\t%sGP%s16\n",
1642             data->gpio_config[16] & 0x02 ? "" : "!",
1643             data->gpio_config[16] & 0x01 ? "OUT" : "IN");
1644     } else {
1645         /* GPIO16 is THERM */
1646         dev_dbg(&client->dev, "\tTHERM\n");
1647     }
1648 }
1649 
1650 static void adm1026_fixup_gpio(struct i2c_client *client)
1651 {
1652     struct adm1026_data *data = i2c_get_clientdata(client);
1653     int i;
1654     int value;
1655 
1656     /* Make the changes requested. */
1657     /*
1658      * We may need to unlock/stop monitoring or soft-reset the
1659      *    chip before we can make changes.  This hasn't been
1660      *    tested much.  FIXME
1661      */
1662 
1663     /* Make outputs */
1664     for (i = 0; i <= 16; ++i) {
1665         if (gpio_output[i] >= 0 && gpio_output[i] <= 16)
1666             data->gpio_config[gpio_output[i]] |= 0x01;
1667         /* if GPIO0-7 is output, it isn't a FAN tach */
1668         if (gpio_output[i] >= 0 && gpio_output[i] <= 7)
1669             data->config2 |= 1 << gpio_output[i];
1670     }
1671 
1672     /* Input overrides output */
1673     for (i = 0; i <= 16; ++i) {
1674         if (gpio_input[i] >= 0 && gpio_input[i] <= 16)
1675             data->gpio_config[gpio_input[i]] &= ~0x01;
1676         /* if GPIO0-7 is input, it isn't a FAN tach */
1677         if (gpio_input[i] >= 0 && gpio_input[i] <= 7)
1678             data->config2 |= 1 << gpio_input[i];
1679     }
1680 
1681     /* Inverted */
1682     for (i = 0; i <= 16; ++i) {
1683         if (gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16)
1684             data->gpio_config[gpio_inverted[i]] &= ~0x02;
1685     }
1686 
1687     /* Normal overrides inverted */
1688     for (i = 0; i <= 16; ++i) {
1689         if (gpio_normal[i] >= 0 && gpio_normal[i] <= 16)
1690             data->gpio_config[gpio_normal[i]] |= 0x02;
1691     }
1692 
1693     /* Fan overrides input and output */
1694     for (i = 0; i <= 7; ++i) {
1695         if (gpio_fan[i] >= 0 && gpio_fan[i] <= 7)
1696             data->config2 &= ~(1 << gpio_fan[i]);
1697     }
1698 
1699     /* Write new configs to registers */
1700     adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2);
1701     data->config3 = (data->config3 & 0x3f)
1702             | ((data->gpio_config[16] & 0x03) << 6);
1703     adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3);
1704     for (i = 15, value = 0; i >= 0; --i) {
1705         value <<= 2;
1706         value |= data->gpio_config[i] & 0x03;
1707         if ((i & 0x03) == 0) {
1708             adm1026_write_value(client,
1709                     ADM1026_REG_GPIO_CFG_0_3 + i/4,
1710                     value);
1711             value = 0;
1712         }
1713     }
1714 
1715     /* Print the new config */
1716     adm1026_print_gpio(client);
1717 }
1718 
1719 static void adm1026_init_client(struct i2c_client *client)
1720 {
1721     int value, i;
1722     struct adm1026_data *data = i2c_get_clientdata(client);
1723 
1724     dev_dbg(&client->dev, "Initializing device\n");
1725     /* Read chip config */
1726     data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
1727     data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
1728     data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
1729 
1730     /* Inform user of chip config */
1731     dev_dbg(&client->dev, "ADM1026_REG_CONFIG1 is: 0x%02x\n",
1732         data->config1);
1733     if ((data->config1 & CFG1_MONITOR) == 0) {
1734         dev_dbg(&client->dev,
1735             "Monitoring not currently enabled.\n");
1736     }
1737     if (data->config1 & CFG1_INT_ENABLE) {
1738         dev_dbg(&client->dev,
1739             "SMBALERT interrupts are enabled.\n");
1740     }
1741     if (data->config1 & CFG1_AIN8_9) {
1742         dev_dbg(&client->dev,
1743             "in8 and in9 enabled. temp3 disabled.\n");
1744     } else {
1745         dev_dbg(&client->dev,
1746             "temp3 enabled.  in8 and in9 disabled.\n");
1747     }
1748     if (data->config1 & CFG1_THERM_HOT) {
1749         dev_dbg(&client->dev,
1750             "Automatic THERM, PWM, and temp limits enabled.\n");
1751     }
1752 
1753     if (data->config3 & CFG3_GPIO16_ENABLE) {
1754         dev_dbg(&client->dev,
1755             "GPIO16 enabled.  THERM pin disabled.\n");
1756     } else {
1757         dev_dbg(&client->dev,
1758             "THERM pin enabled.  GPIO16 disabled.\n");
1759     }
1760     if (data->config3 & CFG3_VREF_250)
1761         dev_dbg(&client->dev, "Vref is 2.50 Volts.\n");
1762     else
1763         dev_dbg(&client->dev, "Vref is 1.82 Volts.\n");
1764     /* Read and pick apart the existing GPIO configuration */
1765     value = 0;
1766     for (i = 0; i <= 15; ++i) {
1767         if ((i & 0x03) == 0) {
1768             value = adm1026_read_value(client,
1769                     ADM1026_REG_GPIO_CFG_0_3 + i / 4);
1770         }
1771         data->gpio_config[i] = value & 0x03;
1772         value >>= 2;
1773     }
1774     data->gpio_config[16] = (data->config3 >> 6) & 0x03;
1775 
1776     /* ... and then print it */
1777     adm1026_print_gpio(client);
1778 
1779     /*
1780      * If the user asks us to reprogram the GPIO config, then
1781      * do it now.
1782      */
1783     if (gpio_input[0] != -1 || gpio_output[0] != -1
1784         || gpio_inverted[0] != -1 || gpio_normal[0] != -1
1785         || gpio_fan[0] != -1) {
1786         adm1026_fixup_gpio(client);
1787     }
1788 
1789     /*
1790      * WE INTENTIONALLY make no changes to the limits,
1791      *   offsets, pwms, fans and zones.  If they were
1792      *   configured, we don't want to mess with them.
1793      *   If they weren't, the default is 100% PWM, no
1794      *   control and will suffice until 'sensors -s'
1795      *   can be run by the user.  We DO set the default
1796      *   value for pwm1.auto_pwm_min to its maximum
1797      *   so that enabling automatic pwm fan control
1798      *   without first setting a value for pwm1.auto_pwm_min
1799      *   will not result in potentially dangerous fan speed decrease.
1800      */
1801     data->pwm1.auto_pwm_min = 255;
1802     /* Start monitoring */
1803     value = adm1026_read_value(client, ADM1026_REG_CONFIG1);
1804     /* Set MONITOR, clear interrupt acknowledge and s/w reset */
1805     value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET);
1806     dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value);
1807     data->config1 = value;
1808     adm1026_write_value(client, ADM1026_REG_CONFIG1, value);
1809 
1810     /* initialize fan_div[] to hardware defaults */
1811     value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3) |
1812         (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8);
1813     for (i = 0; i <= 7; ++i) {
1814         data->fan_div[i] = DIV_FROM_REG(value & 0x03);
1815         value >>= 2;
1816     }
1817 }
1818 
1819 static int adm1026_probe(struct i2c_client *client)
1820 {
1821     struct device *dev = &client->dev;
1822     struct device *hwmon_dev;
1823     struct adm1026_data *data;
1824 
1825     data = devm_kzalloc(dev, sizeof(struct adm1026_data), GFP_KERNEL);
1826     if (!data)
1827         return -ENOMEM;
1828 
1829     i2c_set_clientdata(client, data);
1830     data->client = client;
1831     mutex_init(&data->update_lock);
1832 
1833     /* Set the VRM version */
1834     data->vrm = vid_which_vrm();
1835 
1836     /* Initialize the ADM1026 chip */
1837     adm1026_init_client(client);
1838 
1839     /* sysfs hooks */
1840     data->groups[0] = &adm1026_group;
1841     if (data->config1 & CFG1_AIN8_9)
1842         data->groups[1] = &adm1026_group_in8_9;
1843     else
1844         data->groups[1] = &adm1026_group_temp3;
1845 
1846     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1847                                data, data->groups);
1848     return PTR_ERR_OR_ZERO(hwmon_dev);
1849 }
1850 
1851 static const struct i2c_device_id adm1026_id[] = {
1852     { "adm1026", 0 },
1853     { }
1854 };
1855 MODULE_DEVICE_TABLE(i2c, adm1026_id);
1856 
1857 static struct i2c_driver adm1026_driver = {
1858     .class      = I2C_CLASS_HWMON,
1859     .driver = {
1860         .name   = "adm1026",
1861     },
1862     .probe_new  = adm1026_probe,
1863     .id_table   = adm1026_id,
1864     .detect     = adm1026_detect,
1865     .address_list   = normal_i2c,
1866 };
1867 
1868 module_i2c_driver(adm1026_driver);
1869 
1870 MODULE_LICENSE("GPL");
1871 MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
1872           "Justin Thiessen <jthiessen@penguincomputing.com>");
1873 MODULE_DESCRIPTION("ADM1026 driver");
[ 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!