Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * A hwmon driver for the Analog Devices ADT7470
0004  * Copyright (C) 2007 IBM
0005  *
0006  * Author: Darrick J. Wong <darrick.wong@oracle.com>
0007  */
0008 
0009 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0010 
0011 #include <linux/module.h>
0012 #include <linux/jiffies.h>
0013 #include <linux/i2c.h>
0014 #include <linux/hwmon.h>
0015 #include <linux/hwmon-sysfs.h>
0016 #include <linux/err.h>
0017 #include <linux/mutex.h>
0018 #include <linux/delay.h>
0019 #include <linux/log2.h>
0020 #include <linux/kthread.h>
0021 #include <linux/regmap.h>
0022 #include <linux/sched.h>
0023 #include <linux/slab.h>
0024 #include <linux/util_macros.h>
0025 
0026 /* Addresses to scan */
0027 static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
0028 
0029 /* ADT7470 registers */
0030 #define ADT7470_REG_BASE_ADDR           0x20
0031 #define ADT7470_REG_TEMP_BASE_ADDR      0x20
0032 #define ADT7470_REG_TEMP_MAX_ADDR       0x29
0033 #define ADT7470_REG_FAN_BASE_ADDR       0x2A
0034 #define ADT7470_REG_FAN_MAX_ADDR        0x31
0035 #define ADT7470_REG_PWM_BASE_ADDR       0x32
0036 #define ADT7470_REG_PWM_MAX_ADDR        0x35
0037 #define ADT7470_REG_PWM_MAX_BASE_ADDR       0x38
0038 #define ADT7470_REG_PWM_MAX_MAX_ADDR        0x3B
0039 #define ADT7470_REG_CFG             0x40
0040 #define     ADT7470_STRT_MASK       0x01
0041 #define     ADT7470_TEST_MASK       0x02
0042 #define     ADT7470_FSPD_MASK       0x04
0043 #define     ADT7470_T05_STB_MASK        0x80
0044 #define ADT7470_REG_ALARM1          0x41
0045 #define     ADT7470_R1T_ALARM       0x01
0046 #define     ADT7470_R2T_ALARM       0x02
0047 #define     ADT7470_R3T_ALARM       0x04
0048 #define     ADT7470_R4T_ALARM       0x08
0049 #define     ADT7470_R5T_ALARM       0x10
0050 #define     ADT7470_R6T_ALARM       0x20
0051 #define     ADT7470_R7T_ALARM       0x40
0052 #define     ADT7470_OOL_ALARM       0x80
0053 #define ADT7470_REG_ALARM2          0x42
0054 #define     ADT7470_R8T_ALARM       0x01
0055 #define     ADT7470_R9T_ALARM       0x02
0056 #define     ADT7470_R10T_ALARM      0x04
0057 #define     ADT7470_FAN1_ALARM      0x10
0058 #define     ADT7470_FAN2_ALARM      0x20
0059 #define     ADT7470_FAN3_ALARM      0x40
0060 #define     ADT7470_FAN4_ALARM      0x80
0061 #define ADT7470_REG_TEMP_LIMITS_BASE_ADDR   0x44
0062 #define ADT7470_REG_TEMP_LIMITS_MAX_ADDR    0x57
0063 #define ADT7470_REG_FAN_MIN_BASE_ADDR       0x58
0064 #define ADT7470_REG_FAN_MIN_MAX_ADDR        0x5F
0065 #define ADT7470_REG_FAN_MAX_BASE_ADDR       0x60
0066 #define ADT7470_REG_FAN_MAX_MAX_ADDR        0x67
0067 #define ADT7470_REG_PWM_CFG_BASE_ADDR       0x68
0068 #define ADT7470_REG_PWM12_CFG           0x68
0069 #define     ADT7470_PWM2_AUTO_MASK      0x40
0070 #define     ADT7470_PWM1_AUTO_MASK      0x80
0071 #define     ADT7470_PWM_AUTO_MASK       0xC0
0072 #define ADT7470_REG_PWM34_CFG           0x69
0073 #define     ADT7470_PWM3_AUTO_MASK      0x40
0074 #define     ADT7470_PWM4_AUTO_MASK      0x80
0075 #define ADT7470_REG_PWM_MIN_BASE_ADDR       0x6A
0076 #define ADT7470_REG_PWM_MIN_MAX_ADDR        0x6D
0077 #define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR  0x6E
0078 #define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR   0x71
0079 #define ADT7470_REG_CFG_2           0x74
0080 #define ADT7470_REG_ACOUSTICS12         0x75
0081 #define ADT7470_REG_ACOUSTICS34         0x76
0082 #define ADT7470_REG_DEVICE          0x3D
0083 #define ADT7470_REG_VENDOR          0x3E
0084 #define ADT7470_REG_REVISION            0x3F
0085 #define ADT7470_REG_ALARM1_MASK         0x72
0086 #define ADT7470_REG_ALARM2_MASK         0x73
0087 #define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR 0x7C
0088 #define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR  0x7D
0089 #define ADT7470_REG_MAX_ADDR            0x81
0090 
0091 #define ADT7470_TEMP_COUNT  10
0092 #define ADT7470_TEMP_REG(x) (ADT7470_REG_TEMP_BASE_ADDR + (x))
0093 #define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
0094 #define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
0095                 ((x) * 2) + 1)
0096 
0097 #define ADT7470_FAN_COUNT   4
0098 #define ADT7470_REG_FAN(x)  (ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
0099 #define ADT7470_REG_FAN_MIN(x)  (ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
0100 #define ADT7470_REG_FAN_MAX(x)  (ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
0101 
0102 #define ADT7470_PWM_COUNT   4
0103 #define ADT7470_REG_PWM(x)  (ADT7470_REG_PWM_BASE_ADDR + (x))
0104 #define ADT7470_REG_PWM_MAX(x)  (ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
0105 #define ADT7470_REG_PWM_MIN(x)  (ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
0106 #define ADT7470_REG_PWM_TMIN(x) (ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
0107 #define ADT7470_REG_PWM_CFG(x)  (ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
0108 #define ADT7470_REG_PWM_AUTO_TEMP(x)    (ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
0109                     ((x) / 2))
0110 
0111 #define ALARM2(x)       ((x) << 8)
0112 
0113 #define ADT7470_VENDOR      0x41
0114 #define ADT7470_DEVICE      0x70
0115 /* datasheet only mentions a revision 2 */
0116 #define ADT7470_REVISION    0x02
0117 
0118 /* "all temps" according to hwmon sysfs interface spec */
0119 #define ADT7470_PWM_ALL_TEMPS   0x3FF
0120 
0121 /* How often do we reread sensors values? (In jiffies) */
0122 #define SENSOR_REFRESH_INTERVAL (5 * HZ)
0123 
0124 /* How often do we reread sensor limit values? (In jiffies) */
0125 #define LIMIT_REFRESH_INTERVAL  (60 * HZ)
0126 
0127 /* Wait at least 200ms per sensor for 10 sensors */
0128 #define TEMP_COLLECTION_TIME    2000
0129 
0130 /* auto update thing won't fire more than every 2s */
0131 #define AUTO_UPDATE_INTERVAL    2000
0132 
0133 /* datasheet says to divide this number by the fan reading to get fan rpm */
0134 #define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
0135 #define FAN_RPM_TO_PERIOD   FAN_PERIOD_TO_RPM
0136 #define FAN_PERIOD_INVALID  65535
0137 #define FAN_DATA_VALID(x)   ((x) && (x) != FAN_PERIOD_INVALID)
0138 
0139 /* Config registers 1 and 2 include fields for selecting the PWM frequency */
0140 #define ADT7470_CFG_LF      0x40
0141 #define ADT7470_FREQ_MASK   0x70
0142 #define ADT7470_FREQ_SHIFT  4
0143 
0144 struct adt7470_data {
0145     struct regmap       *regmap;
0146     struct mutex        lock;
0147     char            sensors_valid;
0148     char            limits_valid;
0149     unsigned long       sensors_last_updated;   /* In jiffies */
0150     unsigned long       limits_last_updated;    /* In jiffies */
0151 
0152     int         num_temp_sensors;   /* -1 = probe */
0153     int         temperatures_probed;
0154 
0155     s8          temp[ADT7470_TEMP_COUNT];
0156     s8          temp_min[ADT7470_TEMP_COUNT];
0157     s8          temp_max[ADT7470_TEMP_COUNT];
0158     u16         fan[ADT7470_FAN_COUNT];
0159     u16         fan_min[ADT7470_FAN_COUNT];
0160     u16         fan_max[ADT7470_FAN_COUNT];
0161     u16         alarm;
0162     u16         alarms_mask;
0163     u8          force_pwm_max;
0164     u8          pwm[ADT7470_PWM_COUNT];
0165     u8          pwm_max[ADT7470_PWM_COUNT];
0166     u8          pwm_automatic[ADT7470_PWM_COUNT];
0167     u8          pwm_min[ADT7470_PWM_COUNT];
0168     s8          pwm_tmin[ADT7470_PWM_COUNT];
0169     u8          pwm_auto_temp[ADT7470_PWM_COUNT];
0170 
0171     struct task_struct  *auto_update;
0172     unsigned int        auto_update_interval;
0173 };
0174 
0175 /*
0176  * 16-bit registers on the ADT7470 are low-byte first.  The data sheet says
0177  * that the low byte must be read before the high byte.
0178  */
0179 static inline int adt7470_read_word_data(struct adt7470_data *data, unsigned int reg,
0180                      unsigned int *val)
0181 {
0182     u8 regval[2];
0183     int err;
0184 
0185     err = regmap_bulk_read(data->regmap, reg, &regval, 2);
0186     if (err < 0)
0187         return err;
0188 
0189     *val = regval[0] | (regval[1] << 8);
0190 
0191     return 0;
0192 }
0193 
0194 static inline int adt7470_write_word_data(struct adt7470_data *data, unsigned int reg,
0195                       unsigned int val)
0196 {
0197     u8 regval[2];
0198 
0199     regval[0] = val & 0xFF;
0200     regval[1] = val >> 8;
0201 
0202     return regmap_bulk_write(data->regmap, reg, &regval, 2);
0203 }
0204 
0205 /* Probe for temperature sensors.  Assumes lock is held */
0206 static int adt7470_read_temperatures(struct adt7470_data *data)
0207 {
0208     unsigned long res;
0209     unsigned int pwm_cfg[2];
0210     int err;
0211     int i;
0212     u8 pwm[ADT7470_FAN_COUNT];
0213 
0214     /* save pwm[1-4] config register */
0215     err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(0), &pwm_cfg[0]);
0216     if (err < 0)
0217         return err;
0218     err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(2), &pwm_cfg[1]);
0219     if (err < 0)
0220         return err;
0221 
0222     /* set manual pwm to whatever it is set to now */
0223     err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
0224                    ADT7470_PWM_COUNT);
0225     if (err < 0)
0226         return err;
0227 
0228     /* put pwm in manual mode */
0229     err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(0),
0230                  ADT7470_PWM_AUTO_MASK, 0);
0231     if (err < 0)
0232         return err;
0233     err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(2),
0234                  ADT7470_PWM_AUTO_MASK, 0);
0235     if (err < 0)
0236         return err;
0237 
0238     /* write pwm control to whatever it was */
0239     err = regmap_bulk_write(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
0240                 ADT7470_PWM_COUNT);
0241     if (err < 0)
0242         return err;
0243 
0244     /* start reading temperature sensors */
0245     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
0246                  ADT7470_T05_STB_MASK, ADT7470_T05_STB_MASK);
0247     if (err < 0)
0248         return err;
0249 
0250     /* Delay is 200ms * number of temp sensors. */
0251     res = msleep_interruptible((data->num_temp_sensors >= 0 ?
0252                     data->num_temp_sensors * 200 :
0253                     TEMP_COLLECTION_TIME));
0254 
0255     /* done reading temperature sensors */
0256     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
0257                  ADT7470_T05_STB_MASK, 0);
0258     if (err < 0)
0259         return err;
0260 
0261     /* restore pwm[1-4] config registers */
0262     err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
0263     if (err < 0)
0264         return err;
0265     err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
0266     if (err < 0)
0267         return err;
0268 
0269     if (res)
0270         return -EAGAIN;
0271 
0272     /* Only count fans if we have to */
0273     if (data->num_temp_sensors >= 0)
0274         return 0;
0275 
0276     err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
0277                    ADT7470_TEMP_COUNT);
0278     if (err < 0)
0279         return err;
0280     for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
0281         if (data->temp[i])
0282             data->num_temp_sensors = i + 1;
0283     }
0284     data->temperatures_probed = 1;
0285     return 0;
0286 }
0287 
0288 static int adt7470_update_thread(void *p)
0289 {
0290     struct i2c_client *client = p;
0291     struct adt7470_data *data = i2c_get_clientdata(client);
0292 
0293     while (!kthread_should_stop()) {
0294         mutex_lock(&data->lock);
0295         adt7470_read_temperatures(data);
0296         mutex_unlock(&data->lock);
0297 
0298         if (kthread_should_stop())
0299             break;
0300 
0301         schedule_timeout_interruptible(msecs_to_jiffies(data->auto_update_interval));
0302     }
0303 
0304     return 0;
0305 }
0306 
0307 static int adt7470_update_sensors(struct adt7470_data *data)
0308 {
0309     unsigned int val;
0310     int err;
0311     int i;
0312 
0313     if (!data->temperatures_probed)
0314         err = adt7470_read_temperatures(data);
0315     else
0316         err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
0317                        ADT7470_TEMP_COUNT);
0318     if (err < 0)
0319         return err;
0320 
0321     for (i = 0; i < ADT7470_FAN_COUNT; i++) {
0322         err = adt7470_read_word_data(data, ADT7470_REG_FAN(i), &val);
0323         if (err < 0)
0324             return err;
0325         data->fan[i] =  val;
0326     }
0327 
0328     err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &data->pwm[0], ADT7470_PWM_COUNT);
0329     if (err < 0)
0330         return err;
0331 
0332     for (i = 0; i < ADT7470_PWM_COUNT; i++) {
0333         unsigned int mask;
0334 
0335         if (i % 2)
0336             mask = ADT7470_PWM2_AUTO_MASK;
0337         else
0338             mask = ADT7470_PWM1_AUTO_MASK;
0339 
0340         err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(i), &val);
0341         if (err < 0)
0342             return err;
0343         data->pwm_automatic[i] = !!(val & mask);
0344 
0345         err = regmap_read(data->regmap, ADT7470_REG_PWM_AUTO_TEMP(i), &val);
0346         if (err < 0)
0347             return err;
0348         if (!(i % 2))
0349             data->pwm_auto_temp[i] = val >> 4;
0350         else
0351             data->pwm_auto_temp[i] = val & 0xF;
0352     }
0353 
0354     err = regmap_read(data->regmap, ADT7470_REG_CFG, &val);
0355     if (err < 0)
0356         return err;
0357     data->force_pwm_max = !!(val & ADT7470_FSPD_MASK);
0358 
0359     err = regmap_read(data->regmap, ADT7470_REG_ALARM1, &val);
0360     if (err < 0)
0361         return err;
0362     data->alarm = val;
0363     if (data->alarm & ADT7470_OOL_ALARM) {
0364         err = regmap_read(data->regmap, ADT7470_REG_ALARM2, &val);
0365         if (err < 0)
0366             return err;
0367         data->alarm |= ALARM2(val);
0368     }
0369 
0370     err = adt7470_read_word_data(data, ADT7470_REG_ALARM1_MASK, &val);
0371     if (err < 0)
0372         return err;
0373     data->alarms_mask = val;
0374 
0375     return 0;
0376 }
0377 
0378 static int adt7470_update_limits(struct adt7470_data *data)
0379 {
0380     unsigned int val;
0381     int err;
0382     int i;
0383 
0384     for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
0385         err = regmap_read(data->regmap, ADT7470_TEMP_MIN_REG(i), &val);
0386         if (err < 0)
0387             return err;
0388         data->temp_min[i] = (s8)val;
0389         err = regmap_read(data->regmap, ADT7470_TEMP_MAX_REG(i), &val);
0390         if (err < 0)
0391             return err;
0392         data->temp_max[i] = (s8)val;
0393     }
0394 
0395     for (i = 0; i < ADT7470_FAN_COUNT; i++) {
0396         err = adt7470_read_word_data(data, ADT7470_REG_FAN_MIN(i), &val);
0397         if (err < 0)
0398             return err;
0399         data->fan_min[i] = val;
0400         err = adt7470_read_word_data(data, ADT7470_REG_FAN_MAX(i), &val);
0401         if (err < 0)
0402             return err;
0403         data->fan_max[i] = val;
0404     }
0405 
0406     for (i = 0; i < ADT7470_PWM_COUNT; i++) {
0407         err = regmap_read(data->regmap, ADT7470_REG_PWM_MAX(i), &val);
0408         if (err < 0)
0409             return err;
0410         data->pwm_max[i] = val;
0411         err = regmap_read(data->regmap, ADT7470_REG_PWM_MIN(i), &val);
0412         if (err < 0)
0413             return err;
0414         data->pwm_min[i] = val;
0415         err = regmap_read(data->regmap, ADT7470_REG_PWM_TMIN(i), &val);
0416         if (err < 0)
0417             return err;
0418         data->pwm_tmin[i] = (s8)val;
0419     }
0420 
0421     return 0;
0422 }
0423 
0424 static struct adt7470_data *adt7470_update_device(struct device *dev)
0425 {
0426     struct adt7470_data *data = dev_get_drvdata(dev);
0427     unsigned long local_jiffies = jiffies;
0428     int need_sensors = 1;
0429     int need_limits = 1;
0430     int err;
0431 
0432     /*
0433      * Figure out if we need to update the shadow registers.
0434      * Lockless means that we may occasionally report out of
0435      * date data.
0436      */
0437     if (time_before(local_jiffies, data->sensors_last_updated +
0438             SENSOR_REFRESH_INTERVAL) &&
0439         data->sensors_valid)
0440         need_sensors = 0;
0441 
0442     if (time_before(local_jiffies, data->limits_last_updated +
0443             LIMIT_REFRESH_INTERVAL) &&
0444         data->limits_valid)
0445         need_limits = 0;
0446 
0447     if (!need_sensors && !need_limits)
0448         return data;
0449 
0450     mutex_lock(&data->lock);
0451     if (need_sensors) {
0452         err = adt7470_update_sensors(data);
0453         if (err < 0)
0454             goto out;
0455         data->sensors_last_updated = local_jiffies;
0456         data->sensors_valid = 1;
0457     }
0458 
0459     if (need_limits) {
0460         err = adt7470_update_limits(data);
0461         if (err < 0)
0462             goto out;
0463         data->limits_last_updated = local_jiffies;
0464         data->limits_valid = 1;
0465     }
0466 out:
0467     mutex_unlock(&data->lock);
0468 
0469     return err < 0 ? ERR_PTR(err) : data;
0470 }
0471 
0472 static ssize_t auto_update_interval_show(struct device *dev,
0473                      struct device_attribute *devattr,
0474                      char *buf)
0475 {
0476     struct adt7470_data *data = adt7470_update_device(dev);
0477 
0478     if (IS_ERR(data))
0479         return PTR_ERR(data);
0480 
0481     return sprintf(buf, "%d\n", data->auto_update_interval);
0482 }
0483 
0484 static ssize_t auto_update_interval_store(struct device *dev,
0485                       struct device_attribute *devattr,
0486                       const char *buf, size_t count)
0487 {
0488     struct adt7470_data *data = dev_get_drvdata(dev);
0489     long temp;
0490 
0491     if (kstrtol(buf, 10, &temp))
0492         return -EINVAL;
0493 
0494     temp = clamp_val(temp, 0, 60000);
0495 
0496     mutex_lock(&data->lock);
0497     data->auto_update_interval = temp;
0498     mutex_unlock(&data->lock);
0499 
0500     return count;
0501 }
0502 
0503 static ssize_t num_temp_sensors_show(struct device *dev,
0504                      struct device_attribute *devattr,
0505                      char *buf)
0506 {
0507     struct adt7470_data *data = adt7470_update_device(dev);
0508 
0509     if (IS_ERR(data))
0510         return PTR_ERR(data);
0511 
0512     return sprintf(buf, "%d\n", data->num_temp_sensors);
0513 }
0514 
0515 static ssize_t num_temp_sensors_store(struct device *dev,
0516                       struct device_attribute *devattr,
0517                       const char *buf, size_t count)
0518 {
0519     struct adt7470_data *data = dev_get_drvdata(dev);
0520     long temp;
0521 
0522     if (kstrtol(buf, 10, &temp))
0523         return -EINVAL;
0524 
0525     temp = clamp_val(temp, -1, 10);
0526 
0527     mutex_lock(&data->lock);
0528     data->num_temp_sensors = temp;
0529     if (temp < 0)
0530         data->temperatures_probed = 0;
0531     mutex_unlock(&data->lock);
0532 
0533     return count;
0534 }
0535 
0536 static int adt7470_temp_read(struct device *dev, u32 attr, int channel, long *val)
0537 {
0538     struct adt7470_data *data = adt7470_update_device(dev);
0539 
0540     if (IS_ERR(data))
0541         return PTR_ERR(data);
0542 
0543     switch (attr) {
0544     case hwmon_temp_input:
0545         *val = 1000 * data->temp[channel];
0546         break;
0547     case hwmon_temp_min:
0548         *val = 1000 * data->temp_min[channel];
0549         break;
0550     case hwmon_temp_max:
0551         *val = 1000 * data->temp_max[channel];
0552         break;
0553     case hwmon_temp_alarm:
0554         *val = !!(data->alarm & channel);
0555         break;
0556     default:
0557         return -EOPNOTSUPP;
0558     }
0559 
0560     return 0;
0561 }
0562 
0563 static int adt7470_temp_write(struct device *dev, u32 attr, int channel, long val)
0564 {
0565     struct adt7470_data *data = dev_get_drvdata(dev);
0566     int err;
0567 
0568     val = clamp_val(val, -128000, 127000);
0569     val = DIV_ROUND_CLOSEST(val, 1000);
0570 
0571     switch (attr) {
0572     case hwmon_temp_min:
0573         mutex_lock(&data->lock);
0574         data->temp_min[channel] = val;
0575         err = regmap_write(data->regmap, ADT7470_TEMP_MIN_REG(channel), val);
0576         mutex_unlock(&data->lock);
0577         break;
0578     case hwmon_temp_max:
0579         mutex_lock(&data->lock);
0580         data->temp_max[channel] = val;
0581         err = regmap_write(data->regmap, ADT7470_TEMP_MAX_REG(channel), val);
0582         mutex_unlock(&data->lock);
0583         break;
0584     default:
0585         return -EOPNOTSUPP;
0586     }
0587 
0588     return err;
0589 }
0590 
0591 static ssize_t alarm_mask_show(struct device *dev,
0592                    struct device_attribute *devattr, char *buf)
0593 {
0594     struct adt7470_data *data = adt7470_update_device(dev);
0595 
0596     if (IS_ERR(data))
0597         return PTR_ERR(data);
0598 
0599     return sprintf(buf, "%x\n", data->alarms_mask);
0600 }
0601 
0602 static ssize_t alarm_mask_store(struct device *dev,
0603                 struct device_attribute *devattr,
0604                 const char *buf, size_t count)
0605 {
0606     struct adt7470_data *data = dev_get_drvdata(dev);
0607     long mask;
0608     int err;
0609 
0610     if (kstrtoul(buf, 0, &mask))
0611         return -EINVAL;
0612 
0613     if (mask & ~0xffff)
0614         return -EINVAL;
0615 
0616     mutex_lock(&data->lock);
0617     data->alarms_mask = mask;
0618     err = adt7470_write_word_data(data, ADT7470_REG_ALARM1_MASK, mask);
0619     mutex_unlock(&data->lock);
0620 
0621     return err < 0 ? err : count;
0622 }
0623 
0624 static int adt7470_fan_read(struct device *dev, u32 attr, int channel, long *val)
0625 {
0626     struct adt7470_data *data = adt7470_update_device(dev);
0627 
0628     if (IS_ERR(data))
0629         return PTR_ERR(data);
0630 
0631     switch (attr) {
0632     case hwmon_fan_input:
0633         if (FAN_DATA_VALID(data->fan[channel]))
0634             *val = FAN_PERIOD_TO_RPM(data->fan[channel]);
0635         else
0636             *val = 0;
0637         break;
0638     case hwmon_fan_min:
0639         if (FAN_DATA_VALID(data->fan_min[channel]))
0640             *val = FAN_PERIOD_TO_RPM(data->fan_min[channel]);
0641         else
0642             *val = 0;
0643         break;
0644     case hwmon_fan_max:
0645         if (FAN_DATA_VALID(data->fan_max[channel]))
0646             *val = FAN_PERIOD_TO_RPM(data->fan_max[channel]);
0647         else
0648             *val = 0;
0649         break;
0650     case hwmon_fan_alarm:
0651         *val = !!(data->alarm & (1 << (12 + channel)));
0652         break;
0653     default:
0654         return -EOPNOTSUPP;
0655     }
0656 
0657     return 0;
0658 }
0659 
0660 static int adt7470_fan_write(struct device *dev, u32 attr, int channel, long val)
0661 {
0662     struct adt7470_data *data = dev_get_drvdata(dev);
0663     int err;
0664 
0665     if (val <= 0)
0666         return -EINVAL;
0667 
0668     val = FAN_RPM_TO_PERIOD(val);
0669     val = clamp_val(val, 1, 65534);
0670 
0671     switch (attr) {
0672     case hwmon_fan_min:
0673         mutex_lock(&data->lock);
0674         data->fan_min[channel] = val;
0675         err = adt7470_write_word_data(data, ADT7470_REG_FAN_MIN(channel), val);
0676         mutex_unlock(&data->lock);
0677         break;
0678     case hwmon_fan_max:
0679         mutex_lock(&data->lock);
0680         data->fan_max[channel] = val;
0681         err = adt7470_write_word_data(data, ADT7470_REG_FAN_MAX(channel), val);
0682         mutex_unlock(&data->lock);
0683         break;
0684     default:
0685         return -EOPNOTSUPP;
0686     }
0687 
0688     return err;
0689 }
0690 
0691 static ssize_t force_pwm_max_show(struct device *dev,
0692                   struct device_attribute *devattr, char *buf)
0693 {
0694     struct adt7470_data *data = adt7470_update_device(dev);
0695 
0696     if (IS_ERR(data))
0697         return PTR_ERR(data);
0698 
0699     return sprintf(buf, "%d\n", data->force_pwm_max);
0700 }
0701 
0702 static ssize_t force_pwm_max_store(struct device *dev,
0703                    struct device_attribute *devattr,
0704                    const char *buf, size_t count)
0705 {
0706     struct adt7470_data *data = dev_get_drvdata(dev);
0707     long temp;
0708     int err;
0709 
0710     if (kstrtol(buf, 10, &temp))
0711         return -EINVAL;
0712 
0713     mutex_lock(&data->lock);
0714     data->force_pwm_max = temp;
0715     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
0716                  ADT7470_FSPD_MASK,
0717                  temp ? ADT7470_FSPD_MASK : 0);
0718     mutex_unlock(&data->lock);
0719 
0720     return err < 0 ? err : count;
0721 }
0722 
0723 /* These are the valid PWM frequencies to the nearest Hz */
0724 static const int adt7470_freq_map[] = {
0725     11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500
0726 };
0727 
0728 static int pwm1_freq_get(struct device *dev)
0729 {
0730     struct adt7470_data *data = dev_get_drvdata(dev);
0731     unsigned int cfg_reg_1, cfg_reg_2;
0732     int index;
0733     int err;
0734 
0735     mutex_lock(&data->lock);
0736     err = regmap_read(data->regmap, ADT7470_REG_CFG, &cfg_reg_1);
0737     if (err < 0)
0738         goto out;
0739     err = regmap_read(data->regmap, ADT7470_REG_CFG_2, &cfg_reg_2);
0740     if (err < 0)
0741         goto out;
0742     mutex_unlock(&data->lock);
0743 
0744     index = (cfg_reg_2 & ADT7470_FREQ_MASK) >> ADT7470_FREQ_SHIFT;
0745     if (!(cfg_reg_1 & ADT7470_CFG_LF))
0746         index += 8;
0747     if (index >= ARRAY_SIZE(adt7470_freq_map))
0748         index = ARRAY_SIZE(adt7470_freq_map) - 1;
0749 
0750     return adt7470_freq_map[index];
0751 
0752 out:
0753     mutex_unlock(&data->lock);
0754     return err;
0755 }
0756 
0757 static int adt7470_pwm_read(struct device *dev, u32 attr, int channel, long *val)
0758 {
0759     struct adt7470_data *data = adt7470_update_device(dev);
0760 
0761     if (IS_ERR(data))
0762         return PTR_ERR(data);
0763 
0764     switch (attr) {
0765     case hwmon_pwm_input:
0766         *val = data->pwm[channel];
0767         break;
0768     case hwmon_pwm_enable:
0769         *val = 1 + data->pwm_automatic[channel];
0770         break;
0771     case hwmon_pwm_freq:
0772         *val = pwm1_freq_get(dev);
0773         break;
0774     default:
0775         return -EOPNOTSUPP;
0776     }
0777 
0778     return 0;
0779 }
0780 
0781 static int pwm1_freq_set(struct device *dev, long freq)
0782 {
0783     struct adt7470_data *data = dev_get_drvdata(dev);
0784     unsigned int low_freq = ADT7470_CFG_LF;
0785     int index;
0786     int err;
0787 
0788     /* Round the user value given to the closest available frequency */
0789     index = find_closest(freq, adt7470_freq_map,
0790                  ARRAY_SIZE(adt7470_freq_map));
0791 
0792     if (index >= 8) {
0793         index -= 8;
0794         low_freq = 0;
0795     }
0796 
0797     mutex_lock(&data->lock);
0798     /* Configuration Register 1 */
0799     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
0800                  ADT7470_CFG_LF, low_freq);
0801     if (err < 0)
0802         goto out;
0803 
0804     /* Configuration Register 2 */
0805     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG_2,
0806                  ADT7470_FREQ_MASK,
0807                  index << ADT7470_FREQ_SHIFT);
0808 out:
0809     mutex_unlock(&data->lock);
0810 
0811     return err;
0812 }
0813 
0814 static int adt7470_pwm_write(struct device *dev, u32 attr, int channel, long val)
0815 {
0816     struct adt7470_data *data = dev_get_drvdata(dev);
0817     unsigned int pwm_auto_reg_mask;
0818     int err;
0819 
0820     switch (attr) {
0821     case hwmon_pwm_input:
0822         val = clamp_val(val, 0, 255);
0823         mutex_lock(&data->lock);
0824         data->pwm[channel] = val;
0825         err = regmap_write(data->regmap, ADT7470_REG_PWM(channel),
0826                    data->pwm[channel]);
0827         mutex_unlock(&data->lock);
0828         break;
0829     case hwmon_pwm_enable:
0830         if (channel % 2)
0831             pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
0832         else
0833             pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
0834 
0835         if (val != 2 && val != 1)
0836             return -EINVAL;
0837         val--;
0838 
0839         mutex_lock(&data->lock);
0840         data->pwm_automatic[channel] = val;
0841         err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(channel),
0842                      pwm_auto_reg_mask,
0843                      val ? pwm_auto_reg_mask : 0);
0844         mutex_unlock(&data->lock);
0845         break;
0846     case hwmon_pwm_freq:
0847         err = pwm1_freq_set(dev, val);
0848         break;
0849     default:
0850         return -EOPNOTSUPP;
0851     }
0852 
0853     return err;
0854 }
0855 
0856 static ssize_t pwm_max_show(struct device *dev,
0857                 struct device_attribute *devattr, char *buf)
0858 {
0859     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0860     struct adt7470_data *data = adt7470_update_device(dev);
0861 
0862     if (IS_ERR(data))
0863         return PTR_ERR(data);
0864 
0865     return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
0866 }
0867 
0868 static ssize_t pwm_max_store(struct device *dev,
0869                  struct device_attribute *devattr,
0870                  const char *buf, size_t count)
0871 {
0872     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0873     struct adt7470_data *data = dev_get_drvdata(dev);
0874     long temp;
0875     int err;
0876 
0877     if (kstrtol(buf, 10, &temp))
0878         return -EINVAL;
0879 
0880     temp = clamp_val(temp, 0, 255);
0881 
0882     mutex_lock(&data->lock);
0883     data->pwm_max[attr->index] = temp;
0884     err = regmap_write(data->regmap, ADT7470_REG_PWM_MAX(attr->index),
0885                temp);
0886     mutex_unlock(&data->lock);
0887 
0888     return err < 0 ? err : count;
0889 }
0890 
0891 static ssize_t pwm_min_show(struct device *dev,
0892                 struct device_attribute *devattr, char *buf)
0893 {
0894     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0895     struct adt7470_data *data = adt7470_update_device(dev);
0896 
0897     if (IS_ERR(data))
0898         return PTR_ERR(data);
0899 
0900     return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
0901 }
0902 
0903 static ssize_t pwm_min_store(struct device *dev,
0904                  struct device_attribute *devattr,
0905                  const char *buf, size_t count)
0906 {
0907     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0908     struct adt7470_data *data = dev_get_drvdata(dev);
0909     long temp;
0910     int err;
0911 
0912     if (kstrtol(buf, 10, &temp))
0913         return -EINVAL;
0914 
0915     temp = clamp_val(temp, 0, 255);
0916 
0917     mutex_lock(&data->lock);
0918     data->pwm_min[attr->index] = temp;
0919     err = regmap_write(data->regmap, ADT7470_REG_PWM_MIN(attr->index),
0920                temp);
0921     mutex_unlock(&data->lock);
0922 
0923     return err < 0 ? err : count;
0924 }
0925 
0926 static ssize_t pwm_tmax_show(struct device *dev,
0927                  struct device_attribute *devattr, char *buf)
0928 {
0929     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0930     struct adt7470_data *data = adt7470_update_device(dev);
0931 
0932     if (IS_ERR(data))
0933         return PTR_ERR(data);
0934 
0935     /* the datasheet says that tmax = tmin + 20C */
0936     return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
0937 }
0938 
0939 static ssize_t pwm_tmin_show(struct device *dev,
0940                  struct device_attribute *devattr, char *buf)
0941 {
0942     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0943     struct adt7470_data *data = adt7470_update_device(dev);
0944 
0945     if (IS_ERR(data))
0946         return PTR_ERR(data);
0947 
0948     return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
0949 }
0950 
0951 static ssize_t pwm_tmin_store(struct device *dev,
0952                   struct device_attribute *devattr,
0953                   const char *buf, size_t count)
0954 {
0955     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0956     struct adt7470_data *data = dev_get_drvdata(dev);
0957     long temp;
0958     int err;
0959 
0960     if (kstrtol(buf, 10, &temp))
0961         return -EINVAL;
0962 
0963     temp = clamp_val(temp, -128000, 127000);
0964     temp = DIV_ROUND_CLOSEST(temp, 1000);
0965 
0966     mutex_lock(&data->lock);
0967     data->pwm_tmin[attr->index] = temp;
0968     err = regmap_write(data->regmap, ADT7470_REG_PWM_TMIN(attr->index),
0969                temp);
0970     mutex_unlock(&data->lock);
0971 
0972     return err < 0 ? err : count;
0973 }
0974 
0975 static ssize_t pwm_auto_temp_show(struct device *dev,
0976                   struct device_attribute *devattr, char *buf)
0977 {
0978     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0979     struct adt7470_data *data = adt7470_update_device(dev);
0980     u8 ctrl;
0981 
0982     if (IS_ERR(data))
0983         return PTR_ERR(data);
0984 
0985     ctrl = data->pwm_auto_temp[attr->index];
0986     if (ctrl)
0987         return sprintf(buf, "%d\n", 1 << (ctrl - 1));
0988     else
0989         return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
0990 }
0991 
0992 static int cvt_auto_temp(int input)
0993 {
0994     if (input == ADT7470_PWM_ALL_TEMPS)
0995         return 0;
0996     if (input < 1 || !is_power_of_2(input))
0997         return -EINVAL;
0998     return ilog2(input) + 1;
0999 }
1000 
1001 static ssize_t pwm_auto_temp_store(struct device *dev,
1002                    struct device_attribute *devattr,
1003                    const char *buf, size_t count)
1004 {
1005     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1006     struct adt7470_data *data = dev_get_drvdata(dev);
1007     int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
1008     unsigned int mask, val;
1009     long temp;
1010     int err;
1011 
1012     if (kstrtol(buf, 10, &temp))
1013         return -EINVAL;
1014 
1015     temp = cvt_auto_temp(temp);
1016     if (temp < 0)
1017         return temp;
1018 
1019     mutex_lock(&data->lock);
1020     data->pwm_automatic[attr->index] = temp;
1021 
1022     if (!(attr->index % 2)) {
1023         mask = 0xF0;
1024         val = (temp << 4) & 0xF0;
1025     } else {
1026         mask = 0x0F;
1027         val = temp & 0x0F;
1028     }
1029 
1030     err = regmap_update_bits(data->regmap, pwm_auto_reg, mask, val);
1031     mutex_unlock(&data->lock);
1032 
1033     return err < 0 ? err : count;
1034 }
1035 
1036 static DEVICE_ATTR_RW(alarm_mask);
1037 static DEVICE_ATTR_RW(num_temp_sensors);
1038 static DEVICE_ATTR_RW(auto_update_interval);
1039 
1040 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1041 
1042 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1043 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1044 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1045 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1046 
1047 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1048 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1049 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1050 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1051 
1052 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_tmin, 0);
1053 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_temp, pwm_tmin, 1);
1054 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_temp, pwm_tmin, 2);
1055 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_temp, pwm_tmin, 3);
1056 
1057 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_temp, pwm_tmax, 0);
1058 static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point2_temp, pwm_tmax, 1);
1059 static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point2_temp, pwm_tmax, 2);
1060 static SENSOR_DEVICE_ATTR_RO(pwm4_auto_point2_temp, pwm_tmax, 3);
1061 
1062 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1063 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1064 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1065 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1066 
1067 static struct attribute *adt7470_attrs[] = {
1068     &dev_attr_alarm_mask.attr,
1069     &dev_attr_num_temp_sensors.attr,
1070     &dev_attr_auto_update_interval.attr,
1071     &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1072     &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1073     &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1074     &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1075     &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1076     &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1077     &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1078     &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1079     &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1080     &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1081     &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1082     &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1083     &sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
1084     &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1085     &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1086     &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1087     &sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
1088     &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1089     &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1090     &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1091     &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1092     NULL
1093 };
1094 
1095 ATTRIBUTE_GROUPS(adt7470);
1096 
1097 static int adt7470_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1098             int channel, long *val)
1099 {
1100     switch (type) {
1101     case hwmon_temp:
1102         return adt7470_temp_read(dev, attr, channel, val);
1103     case hwmon_fan:
1104         return adt7470_fan_read(dev, attr, channel, val);
1105     case hwmon_pwm:
1106         return adt7470_pwm_read(dev, attr, channel, val);
1107     default:
1108         return -EOPNOTSUPP;
1109     }
1110 }
1111 
1112 static int adt7470_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1113              int channel, long val)
1114 {
1115     switch (type) {
1116     case hwmon_temp:
1117         return adt7470_temp_write(dev, attr, channel, val);
1118     case hwmon_fan:
1119         return adt7470_fan_write(dev, attr, channel, val);
1120     case hwmon_pwm:
1121         return adt7470_pwm_write(dev, attr, channel, val);
1122     default:
1123         return -EOPNOTSUPP;
1124     }
1125 }
1126 
1127 static umode_t adt7470_is_visible(const void *_data, enum hwmon_sensor_types type,
1128                   u32 attr, int channel)
1129 {
1130     umode_t mode = 0;
1131 
1132     switch (type) {
1133     case hwmon_temp:
1134         switch (attr) {
1135         case hwmon_temp:
1136         case hwmon_temp_alarm:
1137             mode = 0444;
1138             break;
1139         case hwmon_temp_min:
1140         case hwmon_temp_max:
1141             mode = 0644;
1142             break;
1143         default:
1144             break;
1145         }
1146         break;
1147     case hwmon_fan:
1148         switch (attr) {
1149         case hwmon_fan_input:
1150         case hwmon_fan_alarm:
1151             mode = 0444;
1152             break;
1153         case hwmon_fan_min:
1154         case hwmon_fan_max:
1155             mode = 0644;
1156             break;
1157         default:
1158             break;
1159         }
1160         break;
1161     case hwmon_pwm:
1162         switch (attr) {
1163         case hwmon_pwm_input:
1164         case hwmon_pwm_enable:
1165             mode = 0644;
1166             break;
1167         case hwmon_pwm_freq:
1168             if (channel == 0)
1169                 mode = 0644;
1170             else
1171                 mode = 0;
1172             break;
1173         default:
1174             break;
1175         }
1176         break;
1177     default:
1178         break;
1179     }
1180 
1181     return mode;
1182 }
1183 
1184 static const struct hwmon_ops adt7470_hwmon_ops = {
1185     .is_visible = adt7470_is_visible,
1186     .read = adt7470_read,
1187     .write = adt7470_write,
1188 };
1189 
1190 static const struct hwmon_channel_info *adt7470_info[] = {
1191     HWMON_CHANNEL_INFO(temp,
1192                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1193                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1194                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1195                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1196                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1197                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1198                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1199                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1200                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1201                HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM),
1202     HWMON_CHANNEL_INFO(fan,
1203                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1204                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1205                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1206                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM),
1207     HWMON_CHANNEL_INFO(pwm,
1208                HWMON_PWM_INPUT | HWMON_PWM_ENABLE | HWMON_PWM_FREQ,
1209                HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
1210                HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
1211                HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
1212     NULL
1213 };
1214 
1215 static const struct hwmon_chip_info adt7470_chip_info = {
1216     .ops = &adt7470_hwmon_ops,
1217     .info = adt7470_info,
1218 };
1219 
1220 /* Return 0 if detection is successful, -ENODEV otherwise */
1221 static int adt7470_detect(struct i2c_client *client,
1222               struct i2c_board_info *info)
1223 {
1224     struct i2c_adapter *adapter = client->adapter;
1225     int vendor, device, revision;
1226 
1227     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1228         return -ENODEV;
1229 
1230     vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
1231     if (vendor != ADT7470_VENDOR)
1232         return -ENODEV;
1233 
1234     device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
1235     if (device != ADT7470_DEVICE)
1236         return -ENODEV;
1237 
1238     revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);
1239     if (revision != ADT7470_REVISION)
1240         return -ENODEV;
1241 
1242     strscpy(info->type, "adt7470", I2C_NAME_SIZE);
1243 
1244     return 0;
1245 }
1246 
1247 static const struct regmap_config adt7470_regmap_config = {
1248     .reg_bits = 8,
1249     .val_bits = 8,
1250     .use_single_read = true,
1251     .use_single_write = true,
1252 };
1253 
1254 static int adt7470_probe(struct i2c_client *client)
1255 {
1256     struct device *dev = &client->dev;
1257     struct adt7470_data *data;
1258     struct device *hwmon_dev;
1259     int err;
1260 
1261     data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);
1262     if (!data)
1263         return -ENOMEM;
1264 
1265     data->num_temp_sensors = -1;
1266     data->auto_update_interval = AUTO_UPDATE_INTERVAL;
1267     data->regmap = devm_regmap_init_i2c(client, &adt7470_regmap_config);
1268     if (IS_ERR(data->regmap))
1269         return PTR_ERR(data->regmap);
1270 
1271     i2c_set_clientdata(client, data);
1272     mutex_init(&data->lock);
1273 
1274     dev_info(&client->dev, "%s chip found\n", client->name);
1275 
1276     /* Initialize the ADT7470 chip */
1277     err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
1278                  ADT7470_STRT_MASK | ADT7470_TEST_MASK,
1279                  ADT7470_STRT_MASK | ADT7470_TEST_MASK);
1280     if (err < 0)
1281         return err;
1282 
1283     /* Register sysfs hooks */
1284     hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
1285                              &adt7470_chip_info,
1286                              adt7470_groups);
1287 
1288     if (IS_ERR(hwmon_dev))
1289         return PTR_ERR(hwmon_dev);
1290 
1291     data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
1292                     dev_name(hwmon_dev));
1293     if (IS_ERR(data->auto_update))
1294         return PTR_ERR(data->auto_update);
1295 
1296     return 0;
1297 }
1298 
1299 static int adt7470_remove(struct i2c_client *client)
1300 {
1301     struct adt7470_data *data = i2c_get_clientdata(client);
1302 
1303     kthread_stop(data->auto_update);
1304     return 0;
1305 }
1306 
1307 static const struct i2c_device_id adt7470_id[] = {
1308     { "adt7470", 0 },
1309     { }
1310 };
1311 MODULE_DEVICE_TABLE(i2c, adt7470_id);
1312 
1313 static struct i2c_driver adt7470_driver = {
1314     .class      = I2C_CLASS_HWMON,
1315     .driver = {
1316         .name   = "adt7470",
1317     },
1318     .probe_new  = adt7470_probe,
1319     .remove     = adt7470_remove,
1320     .id_table   = adt7470_id,
1321     .detect     = adt7470_detect,
1322     .address_list   = normal_i2c,
1323 };
1324 
1325 module_i2c_driver(adt7470_driver);
1326 
1327 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1328 MODULE_DESCRIPTION("ADT7470 driver");
1329 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!