Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *         monitoring
0005  * Based on lm75.c and lm85.c
0006  * Supports adm1030 / adm1031
0007  * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
0008  * Reworked by Jean Delvare <jdelvare@suse.de>
0009  */
0010 
0011 #include <linux/module.h>
0012 #include <linux/init.h>
0013 #include <linux/slab.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/i2c.h>
0016 #include <linux/hwmon.h>
0017 #include <linux/hwmon-sysfs.h>
0018 #include <linux/err.h>
0019 #include <linux/mutex.h>
0020 
0021 /* Following macros takes channel parameter starting from 0 to 2 */
0022 #define ADM1031_REG_FAN_SPEED(nr)   (0x08 + (nr))
0023 #define ADM1031_REG_FAN_DIV(nr)     (0x20 + (nr))
0024 #define ADM1031_REG_PWM         (0x22)
0025 #define ADM1031_REG_FAN_MIN(nr)     (0x10 + (nr))
0026 #define ADM1031_REG_FAN_FILTER      (0x23)
0027 
0028 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
0029 #define ADM1031_REG_TEMP_MAX(nr)    (0x14 + 4 * (nr))
0030 #define ADM1031_REG_TEMP_MIN(nr)    (0x15 + 4 * (nr))
0031 #define ADM1031_REG_TEMP_CRIT(nr)   (0x16 + 4 * (nr))
0032 
0033 #define ADM1031_REG_TEMP(nr)        (0x0a + (nr))
0034 #define ADM1031_REG_AUTO_TEMP(nr)   (0x24 + (nr))
0035 
0036 #define ADM1031_REG_STATUS(nr)      (0x2 + (nr))
0037 
0038 #define ADM1031_REG_CONF1       0x00
0039 #define ADM1031_REG_CONF2       0x01
0040 #define ADM1031_REG_EXT_TEMP        0x06
0041 
0042 #define ADM1031_CONF1_MONITOR_ENABLE    0x01    /* Monitoring enable */
0043 #define ADM1031_CONF1_PWM_INVERT    0x08    /* PWM Invert */
0044 #define ADM1031_CONF1_AUTO_MODE     0x80    /* Auto FAN */
0045 
0046 #define ADM1031_CONF2_PWM1_ENABLE   0x01
0047 #define ADM1031_CONF2_PWM2_ENABLE   0x02
0048 #define ADM1031_CONF2_TACH1_ENABLE  0x04
0049 #define ADM1031_CONF2_TACH2_ENABLE  0x08
0050 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
0051 
0052 #define ADM1031_UPDATE_RATE_MASK    0x1c
0053 #define ADM1031_UPDATE_RATE_SHIFT   2
0054 
0055 /* Addresses to scan */
0056 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0057 
0058 enum chips { adm1030, adm1031 };
0059 
0060 typedef u8 auto_chan_table_t[8][2];
0061 
0062 /* Each client has this additional data */
0063 struct adm1031_data {
0064     struct i2c_client *client;
0065     const struct attribute_group *groups[3];
0066     struct mutex update_lock;
0067     int chip_type;
0068     bool valid;     /* true if following fields are valid */
0069     unsigned long last_updated; /* In jiffies */
0070     unsigned int update_interval;   /* In milliseconds */
0071     /*
0072      * The chan_select_table contains the possible configurations for
0073      * auto fan control.
0074      */
0075     const auto_chan_table_t *chan_select_table;
0076     u16 alarm;
0077     u8 conf1;
0078     u8 conf2;
0079     u8 fan[2];
0080     u8 fan_div[2];
0081     u8 fan_min[2];
0082     u8 pwm[2];
0083     u8 old_pwm[2];
0084     s8 temp[3];
0085     u8 ext_temp[3];
0086     u8 auto_temp[3];
0087     u8 auto_temp_min[3];
0088     u8 auto_temp_off[3];
0089     u8 auto_temp_max[3];
0090     s8 temp_offset[3];
0091     s8 temp_min[3];
0092     s8 temp_max[3];
0093     s8 temp_crit[3];
0094 };
0095 
0096 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
0097 {
0098     return i2c_smbus_read_byte_data(client, reg);
0099 }
0100 
0101 static inline int
0102 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
0103 {
0104     return i2c_smbus_write_byte_data(client, reg, value);
0105 }
0106 
0107 static struct adm1031_data *adm1031_update_device(struct device *dev)
0108 {
0109     struct adm1031_data *data = dev_get_drvdata(dev);
0110     struct i2c_client *client = data->client;
0111     unsigned long next_update;
0112     int chan;
0113 
0114     mutex_lock(&data->update_lock);
0115 
0116     next_update = data->last_updated
0117       + msecs_to_jiffies(data->update_interval);
0118     if (time_after(jiffies, next_update) || !data->valid) {
0119 
0120         dev_dbg(&client->dev, "Starting adm1031 update\n");
0121         for (chan = 0;
0122              chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
0123             u8 oldh, newh;
0124 
0125             oldh =
0126                 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
0127             data->ext_temp[chan] =
0128                 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
0129             newh =
0130                 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
0131             if (newh != oldh) {
0132                 data->ext_temp[chan] =
0133                     adm1031_read_value(client,
0134                                ADM1031_REG_EXT_TEMP);
0135 #ifdef DEBUG
0136                 oldh =
0137                     adm1031_read_value(client,
0138                                ADM1031_REG_TEMP(chan));
0139 
0140                 /* oldh is actually newer */
0141                 if (newh != oldh)
0142                     dev_warn(&client->dev,
0143                       "Remote temperature may be wrong.\n");
0144 #endif
0145             }
0146             data->temp[chan] = newh;
0147 
0148             data->temp_offset[chan] =
0149                 adm1031_read_value(client,
0150                            ADM1031_REG_TEMP_OFFSET(chan));
0151             data->temp_min[chan] =
0152                 adm1031_read_value(client,
0153                            ADM1031_REG_TEMP_MIN(chan));
0154             data->temp_max[chan] =
0155                 adm1031_read_value(client,
0156                            ADM1031_REG_TEMP_MAX(chan));
0157             data->temp_crit[chan] =
0158                 adm1031_read_value(client,
0159                            ADM1031_REG_TEMP_CRIT(chan));
0160             data->auto_temp[chan] =
0161                 adm1031_read_value(client,
0162                            ADM1031_REG_AUTO_TEMP(chan));
0163 
0164         }
0165 
0166         data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
0167         data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
0168 
0169         data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
0170             | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
0171         if (data->chip_type == adm1030)
0172             data->alarm &= 0xc0ff;
0173 
0174         for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
0175              chan++) {
0176             data->fan_div[chan] =
0177                 adm1031_read_value(client,
0178                            ADM1031_REG_FAN_DIV(chan));
0179             data->fan_min[chan] =
0180                 adm1031_read_value(client,
0181                            ADM1031_REG_FAN_MIN(chan));
0182             data->fan[chan] =
0183                 adm1031_read_value(client,
0184                            ADM1031_REG_FAN_SPEED(chan));
0185             data->pwm[chan] =
0186               (adm1031_read_value(client,
0187                     ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
0188         }
0189         data->last_updated = jiffies;
0190         data->valid = true;
0191     }
0192 
0193     mutex_unlock(&data->update_lock);
0194 
0195     return data;
0196 }
0197 
0198 #define TEMP_TO_REG(val)        (((val) < 0 ? ((val - 500) / 1000) : \
0199                     ((val + 500) / 1000)))
0200 
0201 #define TEMP_FROM_REG(val)      ((val) * 1000)
0202 
0203 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
0204 
0205 #define TEMP_OFFSET_TO_REG(val)     (TEMP_TO_REG(val) & 0x8f)
0206 #define TEMP_OFFSET_FROM_REG(val)   TEMP_FROM_REG((val) < 0 ? \
0207                               (val) | 0x70 : (val))
0208 
0209 #define FAN_FROM_REG(reg, div)      ((reg) ? \
0210                      (11250 * 60) / ((reg) * (div)) : 0)
0211 
0212 static int FAN_TO_REG(int reg, int div)
0213 {
0214     int tmp;
0215     tmp = FAN_FROM_REG(clamp_val(reg, 0, 65535), div);
0216     return tmp > 255 ? 255 : tmp;
0217 }
0218 
0219 #define FAN_DIV_FROM_REG(reg)       (1<<(((reg)&0xc0)>>6))
0220 
0221 #define PWM_TO_REG(val)         (clamp_val((val), 0, 255) >> 4)
0222 #define PWM_FROM_REG(val)       ((val) << 4)
0223 
0224 #define FAN_CHAN_FROM_REG(reg)      (((reg) >> 5) & 7)
0225 #define FAN_CHAN_TO_REG(val, reg)   \
0226     (((reg) & 0x1F) | (((val) << 5) & 0xe0))
0227 
0228 #define AUTO_TEMP_MIN_TO_REG(val, reg)  \
0229     ((((val) / 500) & 0xf8) | ((reg) & 0x7))
0230 #define AUTO_TEMP_RANGE_FROM_REG(reg)   (5000 * (1 << ((reg) & 0x7)))
0231 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
0232 
0233 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
0234 
0235 #define AUTO_TEMP_OFF_FROM_REG(reg)     \
0236     (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
0237 
0238 #define AUTO_TEMP_MAX_FROM_REG(reg)     \
0239     (AUTO_TEMP_RANGE_FROM_REG(reg) +    \
0240     AUTO_TEMP_MIN_FROM_REG(reg))
0241 
0242 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
0243 {
0244     int ret;
0245     int range = ((val - AUTO_TEMP_MIN_FROM_REG(reg)) * 10) / (16 - pwm);
0246 
0247     ret = ((reg & 0xf8) |
0248            (range < 10000 ? 0 :
0249         range < 20000 ? 1 :
0250         range < 40000 ? 2 : range < 80000 ? 3 : 4));
0251     return ret;
0252 }
0253 
0254 /* FAN auto control */
0255 #define GET_FAN_AUTO_BITFIELD(data, idx)    \
0256     (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
0257 
0258 /*
0259  * The tables below contains the possible values for the auto fan
0260  * control bitfields. the index in the table is the register value.
0261  * MSb is the auto fan control enable bit, so the four first entries
0262  * in the table disables auto fan control when both bitfields are zero.
0263  */
0264 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
0265     { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
0266     { 2 /* 0b010 */ , 4 /* 0b100 */ },
0267     { 2 /* 0b010 */ , 2 /* 0b010 */ },
0268     { 4 /* 0b100 */ , 4 /* 0b100 */ },
0269     { 7 /* 0b111 */ , 7 /* 0b111 */ },
0270 };
0271 
0272 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
0273     { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
0274     { 2 /* 0b10 */      , 0 },
0275     { 0xff /* invalid */    , 0 },
0276     { 0xff /* invalid */    , 0 },
0277     { 3 /* 0b11 */      , 0 },
0278 };
0279 
0280 /*
0281  * That function checks if a bitfield is valid and returns the other bitfield
0282  * nearest match if no exact match where found.
0283  */
0284 static int
0285 get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
0286 {
0287     int i;
0288     int first_match = -1, exact_match = -1;
0289     u8 other_reg_val =
0290         (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
0291 
0292     if (val == 0)
0293         return 0;
0294 
0295     for (i = 0; i < 8; i++) {
0296         if ((val == (*data->chan_select_table)[i][chan]) &&
0297             ((*data->chan_select_table)[i][chan ? 0 : 1] ==
0298              other_reg_val)) {
0299             /* We found an exact match */
0300             exact_match = i;
0301             break;
0302         } else if (val == (*data->chan_select_table)[i][chan] &&
0303                first_match == -1) {
0304             /*
0305              * Save the first match in case of an exact match has
0306              * not been found
0307              */
0308             first_match = i;
0309         }
0310     }
0311 
0312     if (exact_match >= 0)
0313         return exact_match;
0314     else if (first_match >= 0)
0315         return first_match;
0316 
0317     return -EINVAL;
0318 }
0319 
0320 static ssize_t fan_auto_channel_show(struct device *dev,
0321                      struct device_attribute *attr, char *buf)
0322 {
0323     int nr = to_sensor_dev_attr(attr)->index;
0324     struct adm1031_data *data = adm1031_update_device(dev);
0325     return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
0326 }
0327 
0328 static ssize_t
0329 fan_auto_channel_store(struct device *dev, struct device_attribute *attr,
0330                const char *buf, size_t count)
0331 {
0332     struct adm1031_data *data = dev_get_drvdata(dev);
0333     struct i2c_client *client = data->client;
0334     int nr = to_sensor_dev_attr(attr)->index;
0335     long val;
0336     u8 reg;
0337     int ret;
0338     u8 old_fan_mode;
0339 
0340     ret = kstrtol(buf, 10, &val);
0341     if (ret)
0342         return ret;
0343 
0344     old_fan_mode = data->conf1;
0345 
0346     mutex_lock(&data->update_lock);
0347 
0348     ret = get_fan_auto_nearest(data, nr, val, data->conf1);
0349     if (ret < 0) {
0350         mutex_unlock(&data->update_lock);
0351         return ret;
0352     }
0353     reg = ret;
0354     data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
0355     if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
0356         (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
0357         if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
0358             /*
0359              * Switch to Auto Fan Mode
0360              * Save PWM registers
0361              * Set PWM registers to 33% Both
0362              */
0363             data->old_pwm[0] = data->pwm[0];
0364             data->old_pwm[1] = data->pwm[1];
0365             adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
0366         } else {
0367             /* Switch to Manual Mode */
0368             data->pwm[0] = data->old_pwm[0];
0369             data->pwm[1] = data->old_pwm[1];
0370             /* Restore PWM registers */
0371             adm1031_write_value(client, ADM1031_REG_PWM,
0372                         data->pwm[0] | (data->pwm[1] << 4));
0373         }
0374     }
0375     data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
0376     adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
0377     mutex_unlock(&data->update_lock);
0378     return count;
0379 }
0380 
0381 static SENSOR_DEVICE_ATTR_RW(auto_fan1_channel, fan_auto_channel, 0);
0382 static SENSOR_DEVICE_ATTR_RW(auto_fan2_channel, fan_auto_channel, 1);
0383 
0384 /* Auto Temps */
0385 static ssize_t auto_temp_off_show(struct device *dev,
0386                   struct device_attribute *attr, char *buf)
0387 {
0388     int nr = to_sensor_dev_attr(attr)->index;
0389     struct adm1031_data *data = adm1031_update_device(dev);
0390     return sprintf(buf, "%d\n",
0391                AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
0392 }
0393 static ssize_t auto_temp_min_show(struct device *dev,
0394                   struct device_attribute *attr, char *buf)
0395 {
0396     int nr = to_sensor_dev_attr(attr)->index;
0397     struct adm1031_data *data = adm1031_update_device(dev);
0398     return sprintf(buf, "%d\n",
0399                AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
0400 }
0401 static ssize_t
0402 auto_temp_min_store(struct device *dev, struct device_attribute *attr,
0403             const char *buf, size_t count)
0404 {
0405     struct adm1031_data *data = dev_get_drvdata(dev);
0406     struct i2c_client *client = data->client;
0407     int nr = to_sensor_dev_attr(attr)->index;
0408     long val;
0409     int ret;
0410 
0411     ret = kstrtol(buf, 10, &val);
0412     if (ret)
0413         return ret;
0414 
0415     val = clamp_val(val, 0, 127000);
0416     mutex_lock(&data->update_lock);
0417     data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
0418     adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
0419                 data->auto_temp[nr]);
0420     mutex_unlock(&data->update_lock);
0421     return count;
0422 }
0423 static ssize_t auto_temp_max_show(struct device *dev,
0424                   struct device_attribute *attr, char *buf)
0425 {
0426     int nr = to_sensor_dev_attr(attr)->index;
0427     struct adm1031_data *data = adm1031_update_device(dev);
0428     return sprintf(buf, "%d\n",
0429                AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
0430 }
0431 static ssize_t
0432 auto_temp_max_store(struct device *dev, struct device_attribute *attr,
0433             const char *buf, size_t count)
0434 {
0435     struct adm1031_data *data = dev_get_drvdata(dev);
0436     struct i2c_client *client = data->client;
0437     int nr = to_sensor_dev_attr(attr)->index;
0438     long val;
0439     int ret;
0440 
0441     ret = kstrtol(buf, 10, &val);
0442     if (ret)
0443         return ret;
0444 
0445     val = clamp_val(val, 0, 127000);
0446     mutex_lock(&data->update_lock);
0447     data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
0448                           data->pwm[nr]);
0449     adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
0450                 data->temp_max[nr]);
0451     mutex_unlock(&data->update_lock);
0452     return count;
0453 }
0454 
0455 static SENSOR_DEVICE_ATTR_RO(auto_temp1_off, auto_temp_off, 0);
0456 static SENSOR_DEVICE_ATTR_RW(auto_temp1_min, auto_temp_min, 0);
0457 static SENSOR_DEVICE_ATTR_RW(auto_temp1_max, auto_temp_max, 0);
0458 static SENSOR_DEVICE_ATTR_RO(auto_temp2_off, auto_temp_off, 1);
0459 static SENSOR_DEVICE_ATTR_RW(auto_temp2_min, auto_temp_min, 1);
0460 static SENSOR_DEVICE_ATTR_RW(auto_temp2_max, auto_temp_max, 1);
0461 static SENSOR_DEVICE_ATTR_RO(auto_temp3_off, auto_temp_off, 2);
0462 static SENSOR_DEVICE_ATTR_RW(auto_temp3_min, auto_temp_min, 2);
0463 static SENSOR_DEVICE_ATTR_RW(auto_temp3_max, auto_temp_max, 2);
0464 
0465 /* pwm */
0466 static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
0467             char *buf)
0468 {
0469     int nr = to_sensor_dev_attr(attr)->index;
0470     struct adm1031_data *data = adm1031_update_device(dev);
0471     return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
0472 }
0473 static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
0474              const char *buf, size_t count)
0475 {
0476     struct adm1031_data *data = dev_get_drvdata(dev);
0477     struct i2c_client *client = data->client;
0478     int nr = to_sensor_dev_attr(attr)->index;
0479     long val;
0480     int ret, reg;
0481 
0482     ret = kstrtol(buf, 10, &val);
0483     if (ret)
0484         return ret;
0485 
0486     mutex_lock(&data->update_lock);
0487     if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
0488         (((val>>4) & 0xf) != 5)) {
0489         /* In automatic mode, the only PWM accepted is 33% */
0490         mutex_unlock(&data->update_lock);
0491         return -EINVAL;
0492     }
0493     data->pwm[nr] = PWM_TO_REG(val);
0494     reg = adm1031_read_value(client, ADM1031_REG_PWM);
0495     adm1031_write_value(client, ADM1031_REG_PWM,
0496                 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
0497                 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
0498     mutex_unlock(&data->update_lock);
0499     return count;
0500 }
0501 
0502 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
0503 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
0504 static SENSOR_DEVICE_ATTR_RW(auto_fan1_min_pwm, pwm, 0);
0505 static SENSOR_DEVICE_ATTR_RW(auto_fan2_min_pwm, pwm, 1);
0506 
0507 /* Fans */
0508 
0509 /*
0510  * That function checks the cases where the fan reading is not
0511  * relevant.  It is used to provide 0 as fan reading when the fan is
0512  * not supposed to run
0513  */
0514 static int trust_fan_readings(struct adm1031_data *data, int chan)
0515 {
0516     int res = 0;
0517 
0518     if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
0519         switch (data->conf1 & 0x60) {
0520         case 0x00:
0521             /*
0522              * remote temp1 controls fan1,
0523              * remote temp2 controls fan2
0524              */
0525             res = data->temp[chan+1] >=
0526                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
0527             break;
0528         case 0x20:  /* remote temp1 controls both fans */
0529             res =
0530                 data->temp[1] >=
0531                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
0532             break;
0533         case 0x40:  /* remote temp2 controls both fans */
0534             res =
0535                 data->temp[2] >=
0536                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
0537             break;
0538         case 0x60:  /* max controls both fans */
0539             res =
0540                 data->temp[0] >=
0541                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
0542                 || data->temp[1] >=
0543                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
0544                 || (data->chip_type == adm1031
0545                 && data->temp[2] >=
0546                 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
0547             break;
0548         }
0549     } else {
0550         res = data->pwm[chan] > 0;
0551     }
0552     return res;
0553 }
0554 
0555 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
0556             char *buf)
0557 {
0558     int nr = to_sensor_dev_attr(attr)->index;
0559     struct adm1031_data *data = adm1031_update_device(dev);
0560     int value;
0561 
0562     value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
0563                  FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
0564     return sprintf(buf, "%d\n", value);
0565 }
0566 
0567 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
0568                 char *buf)
0569 {
0570     int nr = to_sensor_dev_attr(attr)->index;
0571     struct adm1031_data *data = adm1031_update_device(dev);
0572     return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
0573 }
0574 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
0575                 char *buf)
0576 {
0577     int nr = to_sensor_dev_attr(attr)->index;
0578     struct adm1031_data *data = adm1031_update_device(dev);
0579     return sprintf(buf, "%d\n",
0580                FAN_FROM_REG(data->fan_min[nr],
0581                     FAN_DIV_FROM_REG(data->fan_div[nr])));
0582 }
0583 static ssize_t fan_min_store(struct device *dev,
0584                  struct device_attribute *attr, const char *buf,
0585                  size_t count)
0586 {
0587     struct adm1031_data *data = dev_get_drvdata(dev);
0588     struct i2c_client *client = data->client;
0589     int nr = to_sensor_dev_attr(attr)->index;
0590     long val;
0591     int ret;
0592 
0593     ret = kstrtol(buf, 10, &val);
0594     if (ret)
0595         return ret;
0596 
0597     mutex_lock(&data->update_lock);
0598     if (val) {
0599         data->fan_min[nr] =
0600             FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
0601     } else {
0602         data->fan_min[nr] = 0xff;
0603     }
0604     adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
0605     mutex_unlock(&data->update_lock);
0606     return count;
0607 }
0608 static ssize_t fan_div_store(struct device *dev,
0609                  struct device_attribute *attr, const char *buf,
0610                  size_t count)
0611 {
0612     struct adm1031_data *data = dev_get_drvdata(dev);
0613     struct i2c_client *client = data->client;
0614     int nr = to_sensor_dev_attr(attr)->index;
0615     long val;
0616     u8 tmp;
0617     int old_div;
0618     int new_min;
0619     int ret;
0620 
0621     ret = kstrtol(buf, 10, &val);
0622     if (ret)
0623         return ret;
0624 
0625     tmp = val == 8 ? 0xc0 :
0626           val == 4 ? 0x80 :
0627           val == 2 ? 0x40 :
0628           val == 1 ? 0x00 :
0629           0xff;
0630     if (tmp == 0xff)
0631         return -EINVAL;
0632 
0633     mutex_lock(&data->update_lock);
0634     /* Get fresh readings */
0635     data->fan_div[nr] = adm1031_read_value(client,
0636                            ADM1031_REG_FAN_DIV(nr));
0637     data->fan_min[nr] = adm1031_read_value(client,
0638                            ADM1031_REG_FAN_MIN(nr));
0639 
0640     /* Write the new clock divider and fan min */
0641     old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
0642     data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
0643     new_min = data->fan_min[nr] * old_div / val;
0644     data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
0645 
0646     adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
0647                 data->fan_div[nr]);
0648     adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
0649                 data->fan_min[nr]);
0650 
0651     /* Invalidate the cache: fan speed is no longer valid */
0652     data->valid = false;
0653     mutex_unlock(&data->update_lock);
0654     return count;
0655 }
0656 
0657 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
0658 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0659 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0660 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
0661 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0662 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0663 
0664 /* Temps */
0665 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0666              char *buf)
0667 {
0668     int nr = to_sensor_dev_attr(attr)->index;
0669     struct adm1031_data *data = adm1031_update_device(dev);
0670     int ext;
0671     ext = nr == 0 ?
0672         ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
0673         (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
0674     return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
0675 }
0676 static ssize_t temp_offset_show(struct device *dev,
0677                 struct device_attribute *attr, char *buf)
0678 {
0679     int nr = to_sensor_dev_attr(attr)->index;
0680     struct adm1031_data *data = adm1031_update_device(dev);
0681     return sprintf(buf, "%d\n",
0682                TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
0683 }
0684 static ssize_t temp_min_show(struct device *dev,
0685                  struct device_attribute *attr, char *buf)
0686 {
0687     int nr = to_sensor_dev_attr(attr)->index;
0688     struct adm1031_data *data = adm1031_update_device(dev);
0689     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
0690 }
0691 static ssize_t temp_max_show(struct device *dev,
0692                  struct device_attribute *attr, char *buf)
0693 {
0694     int nr = to_sensor_dev_attr(attr)->index;
0695     struct adm1031_data *data = adm1031_update_device(dev);
0696     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
0697 }
0698 static ssize_t temp_crit_show(struct device *dev,
0699                   struct device_attribute *attr, char *buf)
0700 {
0701     int nr = to_sensor_dev_attr(attr)->index;
0702     struct adm1031_data *data = adm1031_update_device(dev);
0703     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
0704 }
0705 static ssize_t temp_offset_store(struct device *dev,
0706                  struct device_attribute *attr,
0707                  const char *buf, size_t count)
0708 {
0709     struct adm1031_data *data = dev_get_drvdata(dev);
0710     struct i2c_client *client = data->client;
0711     int nr = to_sensor_dev_attr(attr)->index;
0712     long val;
0713     int ret;
0714 
0715     ret = kstrtol(buf, 10, &val);
0716     if (ret)
0717         return ret;
0718 
0719     val = clamp_val(val, -15000, 15000);
0720     mutex_lock(&data->update_lock);
0721     data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
0722     adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
0723                 data->temp_offset[nr]);
0724     mutex_unlock(&data->update_lock);
0725     return count;
0726 }
0727 static ssize_t temp_min_store(struct device *dev,
0728                   struct device_attribute *attr, const char *buf,
0729                   size_t count)
0730 {
0731     struct adm1031_data *data = dev_get_drvdata(dev);
0732     struct i2c_client *client = data->client;
0733     int nr = to_sensor_dev_attr(attr)->index;
0734     long val;
0735     int ret;
0736 
0737     ret = kstrtol(buf, 10, &val);
0738     if (ret)
0739         return ret;
0740 
0741     val = clamp_val(val, -55000, 127000);
0742     mutex_lock(&data->update_lock);
0743     data->temp_min[nr] = TEMP_TO_REG(val);
0744     adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
0745                 data->temp_min[nr]);
0746     mutex_unlock(&data->update_lock);
0747     return count;
0748 }
0749 static ssize_t temp_max_store(struct device *dev,
0750                   struct device_attribute *attr, const char *buf,
0751                   size_t count)
0752 {
0753     struct adm1031_data *data = dev_get_drvdata(dev);
0754     struct i2c_client *client = data->client;
0755     int nr = to_sensor_dev_attr(attr)->index;
0756     long val;
0757     int ret;
0758 
0759     ret = kstrtol(buf, 10, &val);
0760     if (ret)
0761         return ret;
0762 
0763     val = clamp_val(val, -55000, 127000);
0764     mutex_lock(&data->update_lock);
0765     data->temp_max[nr] = TEMP_TO_REG(val);
0766     adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
0767                 data->temp_max[nr]);
0768     mutex_unlock(&data->update_lock);
0769     return count;
0770 }
0771 static ssize_t temp_crit_store(struct device *dev,
0772                    struct device_attribute *attr, const char *buf,
0773                    size_t count)
0774 {
0775     struct adm1031_data *data = dev_get_drvdata(dev);
0776     struct i2c_client *client = data->client;
0777     int nr = to_sensor_dev_attr(attr)->index;
0778     long val;
0779     int ret;
0780 
0781     ret = kstrtol(buf, 10, &val);
0782     if (ret)
0783         return ret;
0784 
0785     val = clamp_val(val, -55000, 127000);
0786     mutex_lock(&data->update_lock);
0787     data->temp_crit[nr] = TEMP_TO_REG(val);
0788     adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
0789                 data->temp_crit[nr]);
0790     mutex_unlock(&data->update_lock);
0791     return count;
0792 }
0793 
0794 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0795 static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
0796 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
0797 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0798 static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
0799 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0800 static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
0801 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
0802 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0803 static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
0804 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0805 static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
0806 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
0807 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
0808 static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
0809 
0810 /* Alarms */
0811 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0812                char *buf)
0813 {
0814     struct adm1031_data *data = adm1031_update_device(dev);
0815     return sprintf(buf, "%d\n", data->alarm);
0816 }
0817 
0818 static DEVICE_ATTR_RO(alarms);
0819 
0820 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0821               char *buf)
0822 {
0823     int bitnr = to_sensor_dev_attr(attr)->index;
0824     struct adm1031_data *data = adm1031_update_device(dev);
0825     return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
0826 }
0827 
0828 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 0);
0829 static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
0830 static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
0831 static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, alarm, 3);
0832 static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 4);
0833 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 5);
0834 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 6);
0835 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, 7);
0836 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 8);
0837 static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 9);
0838 static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, 10);
0839 static SENSOR_DEVICE_ATTR_RO(temp3_min_alarm, alarm, 11);
0840 static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, 12);
0841 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 13);
0842 static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 14);
0843 
0844 /* Update Interval */
0845 static const unsigned int update_intervals[] = {
0846     16000, 8000, 4000, 2000, 1000, 500, 250, 125,
0847 };
0848 
0849 static ssize_t update_interval_show(struct device *dev,
0850                     struct device_attribute *attr, char *buf)
0851 {
0852     struct adm1031_data *data = dev_get_drvdata(dev);
0853 
0854     return sprintf(buf, "%u\n", data->update_interval);
0855 }
0856 
0857 static ssize_t update_interval_store(struct device *dev,
0858                      struct device_attribute *attr,
0859                      const char *buf, size_t count)
0860 {
0861     struct adm1031_data *data = dev_get_drvdata(dev);
0862     struct i2c_client *client = data->client;
0863     unsigned long val;
0864     int i, err;
0865     u8 reg;
0866 
0867     err = kstrtoul(buf, 10, &val);
0868     if (err)
0869         return err;
0870 
0871     /*
0872      * Find the nearest update interval from the table.
0873      * Use it to determine the matching update rate.
0874      */
0875     for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
0876         if (val >= update_intervals[i])
0877             break;
0878     }
0879     /* if not found, we point to the last entry (lowest update interval) */
0880 
0881     /* set the new update rate while preserving other settings */
0882     reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
0883     reg &= ~ADM1031_UPDATE_RATE_MASK;
0884     reg |= i << ADM1031_UPDATE_RATE_SHIFT;
0885     adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
0886 
0887     mutex_lock(&data->update_lock);
0888     data->update_interval = update_intervals[i];
0889     mutex_unlock(&data->update_lock);
0890 
0891     return count;
0892 }
0893 
0894 static DEVICE_ATTR_RW(update_interval);
0895 
0896 static struct attribute *adm1031_attributes[] = {
0897     &sensor_dev_attr_fan1_input.dev_attr.attr,
0898     &sensor_dev_attr_fan1_div.dev_attr.attr,
0899     &sensor_dev_attr_fan1_min.dev_attr.attr,
0900     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0901     &sensor_dev_attr_fan1_fault.dev_attr.attr,
0902     &sensor_dev_attr_pwm1.dev_attr.attr,
0903     &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
0904     &sensor_dev_attr_temp1_input.dev_attr.attr,
0905     &sensor_dev_attr_temp1_offset.dev_attr.attr,
0906     &sensor_dev_attr_temp1_min.dev_attr.attr,
0907     &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
0908     &sensor_dev_attr_temp1_max.dev_attr.attr,
0909     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0910     &sensor_dev_attr_temp1_crit.dev_attr.attr,
0911     &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
0912     &sensor_dev_attr_temp2_input.dev_attr.attr,
0913     &sensor_dev_attr_temp2_offset.dev_attr.attr,
0914     &sensor_dev_attr_temp2_min.dev_attr.attr,
0915     &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
0916     &sensor_dev_attr_temp2_max.dev_attr.attr,
0917     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
0918     &sensor_dev_attr_temp2_crit.dev_attr.attr,
0919     &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
0920     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0921 
0922     &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
0923     &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
0924     &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
0925 
0926     &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
0927     &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
0928     &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
0929 
0930     &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
0931 
0932     &dev_attr_update_interval.attr,
0933     &dev_attr_alarms.attr,
0934 
0935     NULL
0936 };
0937 
0938 static const struct attribute_group adm1031_group = {
0939     .attrs = adm1031_attributes,
0940 };
0941 
0942 static struct attribute *adm1031_attributes_opt[] = {
0943     &sensor_dev_attr_fan2_input.dev_attr.attr,
0944     &sensor_dev_attr_fan2_div.dev_attr.attr,
0945     &sensor_dev_attr_fan2_min.dev_attr.attr,
0946     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0947     &sensor_dev_attr_fan2_fault.dev_attr.attr,
0948     &sensor_dev_attr_pwm2.dev_attr.attr,
0949     &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
0950     &sensor_dev_attr_temp3_input.dev_attr.attr,
0951     &sensor_dev_attr_temp3_offset.dev_attr.attr,
0952     &sensor_dev_attr_temp3_min.dev_attr.attr,
0953     &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
0954     &sensor_dev_attr_temp3_max.dev_attr.attr,
0955     &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
0956     &sensor_dev_attr_temp3_crit.dev_attr.attr,
0957     &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
0958     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0959     &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
0960     &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
0961     &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
0962     &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
0963     NULL
0964 };
0965 
0966 static const struct attribute_group adm1031_group_opt = {
0967     .attrs = adm1031_attributes_opt,
0968 };
0969 
0970 /* Return 0 if detection is successful, -ENODEV otherwise */
0971 static int adm1031_detect(struct i2c_client *client,
0972               struct i2c_board_info *info)
0973 {
0974     struct i2c_adapter *adapter = client->adapter;
0975     const char *name;
0976     int id, co;
0977 
0978     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0979         return -ENODEV;
0980 
0981     id = i2c_smbus_read_byte_data(client, 0x3d);
0982     co = i2c_smbus_read_byte_data(client, 0x3e);
0983 
0984     if (!((id == 0x31 || id == 0x30) && co == 0x41))
0985         return -ENODEV;
0986     name = (id == 0x30) ? "adm1030" : "adm1031";
0987 
0988     strlcpy(info->type, name, I2C_NAME_SIZE);
0989 
0990     return 0;
0991 }
0992 
0993 static void adm1031_init_client(struct i2c_client *client)
0994 {
0995     unsigned int read_val;
0996     unsigned int mask;
0997     int i;
0998     struct adm1031_data *data = i2c_get_clientdata(client);
0999 
1000     mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1001     if (data->chip_type == adm1031) {
1002         mask |= (ADM1031_CONF2_PWM2_ENABLE |
1003             ADM1031_CONF2_TACH2_ENABLE);
1004     }
1005     /* Initialize the ADM1031 chip (enables fan speed reading ) */
1006     read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1007     if ((read_val | mask) != read_val)
1008         adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1009 
1010     read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1011     if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1012         adm1031_write_value(client, ADM1031_REG_CONF1,
1013                     read_val | ADM1031_CONF1_MONITOR_ENABLE);
1014     }
1015 
1016     /* Read the chip's update rate */
1017     mask = ADM1031_UPDATE_RATE_MASK;
1018     read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1019     i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1020     /* Save it as update interval */
1021     data->update_interval = update_intervals[i];
1022 }
1023 
1024 static const struct i2c_device_id adm1031_id[];
1025 
1026 static int adm1031_probe(struct i2c_client *client)
1027 {
1028     struct device *dev = &client->dev;
1029     struct device *hwmon_dev;
1030     struct adm1031_data *data;
1031 
1032     data = devm_kzalloc(dev, sizeof(struct adm1031_data), GFP_KERNEL);
1033     if (!data)
1034         return -ENOMEM;
1035 
1036     i2c_set_clientdata(client, data);
1037     data->client = client;
1038     data->chip_type = i2c_match_id(adm1031_id, client)->driver_data;
1039     mutex_init(&data->update_lock);
1040 
1041     if (data->chip_type == adm1030)
1042         data->chan_select_table = &auto_channel_select_table_adm1030;
1043     else
1044         data->chan_select_table = &auto_channel_select_table_adm1031;
1045 
1046     /* Initialize the ADM1031 chip */
1047     adm1031_init_client(client);
1048 
1049     /* sysfs hooks */
1050     data->groups[0] = &adm1031_group;
1051     if (data->chip_type == adm1031)
1052         data->groups[1] = &adm1031_group_opt;
1053 
1054     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1055                                data, data->groups);
1056     return PTR_ERR_OR_ZERO(hwmon_dev);
1057 }
1058 
1059 static const struct i2c_device_id adm1031_id[] = {
1060     { "adm1030", adm1030 },
1061     { "adm1031", adm1031 },
1062     { }
1063 };
1064 MODULE_DEVICE_TABLE(i2c, adm1031_id);
1065 
1066 static struct i2c_driver adm1031_driver = {
1067     .class      = I2C_CLASS_HWMON,
1068     .driver = {
1069         .name = "adm1031",
1070     },
1071     .probe_new  = adm1031_probe,
1072     .id_table   = adm1031_id,
1073     .detect     = adm1031_detect,
1074     .address_list   = normal_i2c,
1075 };
1076 
1077 module_i2c_driver(adm1031_driver);
1078 
1079 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1080 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1081 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!