Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * lm85.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *      monitoring
0005  * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
0006  * Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
0007  * Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
0008  * Copyright (c) 2004        Justin Thiessen <jthiessen@penguincomputing.com>
0009  * Copyright (C) 2007--2014  Jean Delvare <jdelvare@suse.de>
0010  *
0011  * Chip details at        <http://www.national.com/ds/LM/LM85.pdf>
0012  */
0013 
0014 #include <linux/module.h>
0015 #include <linux/of_device.h>
0016 #include <linux/init.h>
0017 #include <linux/slab.h>
0018 #include <linux/jiffies.h>
0019 #include <linux/i2c.h>
0020 #include <linux/hwmon.h>
0021 #include <linux/hwmon-vid.h>
0022 #include <linux/hwmon-sysfs.h>
0023 #include <linux/err.h>
0024 #include <linux/mutex.h>
0025 #include <linux/util_macros.h>
0026 
0027 /* Addresses to scan */
0028 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0029 
0030 enum chips {
0031     lm85, lm96000,
0032     adm1027, adt7463, adt7468,
0033     emc6d100, emc6d102, emc6d103, emc6d103s
0034 };
0035 
0036 /* The LM85 registers */
0037 
0038 #define LM85_REG_IN(nr)         (0x20 + (nr))
0039 #define LM85_REG_IN_MIN(nr)     (0x44 + (nr) * 2)
0040 #define LM85_REG_IN_MAX(nr)     (0x45 + (nr) * 2)
0041 
0042 #define LM85_REG_TEMP(nr)       (0x25 + (nr))
0043 #define LM85_REG_TEMP_MIN(nr)       (0x4e + (nr) * 2)
0044 #define LM85_REG_TEMP_MAX(nr)       (0x4f + (nr) * 2)
0045 
0046 /* Fan speeds are LSB, MSB (2 bytes) */
0047 #define LM85_REG_FAN(nr)        (0x28 + (nr) * 2)
0048 #define LM85_REG_FAN_MIN(nr)        (0x54 + (nr) * 2)
0049 
0050 #define LM85_REG_PWM(nr)        (0x30 + (nr))
0051 
0052 #define LM85_REG_COMPANY        0x3e
0053 #define LM85_REG_VERSTEP        0x3f
0054 
0055 #define ADT7468_REG_CFG5        0x7c
0056 #define ADT7468_OFF64           (1 << 0)
0057 #define ADT7468_HFPWM           (1 << 1)
0058 #define IS_ADT7468_OFF64(data)      \
0059     ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_OFF64))
0060 #define IS_ADT7468_HFPWM(data)      \
0061     ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_HFPWM))
0062 
0063 /* These are the recognized values for the above regs */
0064 #define LM85_COMPANY_NATIONAL       0x01
0065 #define LM85_COMPANY_ANALOG_DEV     0x41
0066 #define LM85_COMPANY_SMSC       0x5c
0067 #define LM85_VERSTEP_LM85C      0x60
0068 #define LM85_VERSTEP_LM85B      0x62
0069 #define LM85_VERSTEP_LM96000_1      0x68
0070 #define LM85_VERSTEP_LM96000_2      0x69
0071 #define LM85_VERSTEP_ADM1027        0x60
0072 #define LM85_VERSTEP_ADT7463        0x62
0073 #define LM85_VERSTEP_ADT7463C       0x6A
0074 #define LM85_VERSTEP_ADT7468_1      0x71
0075 #define LM85_VERSTEP_ADT7468_2      0x72
0076 #define LM85_VERSTEP_EMC6D100_A0        0x60
0077 #define LM85_VERSTEP_EMC6D100_A1        0x61
0078 #define LM85_VERSTEP_EMC6D102       0x65
0079 #define LM85_VERSTEP_EMC6D103_A0    0x68
0080 #define LM85_VERSTEP_EMC6D103_A1    0x69
0081 #define LM85_VERSTEP_EMC6D103S      0x6A    /* Also known as EMC6D103:A2 */
0082 
0083 #define LM85_REG_CONFIG         0x40
0084 
0085 #define LM85_REG_ALARM1         0x41
0086 #define LM85_REG_ALARM2         0x42
0087 
0088 #define LM85_REG_VID            0x43
0089 
0090 /* Automated FAN control */
0091 #define LM85_REG_AFAN_CONFIG(nr)    (0x5c + (nr))
0092 #define LM85_REG_AFAN_RANGE(nr)     (0x5f + (nr))
0093 #define LM85_REG_AFAN_SPIKE1        0x62
0094 #define LM85_REG_AFAN_MINPWM(nr)    (0x64 + (nr))
0095 #define LM85_REG_AFAN_LIMIT(nr)     (0x67 + (nr))
0096 #define LM85_REG_AFAN_CRITICAL(nr)  (0x6a + (nr))
0097 #define LM85_REG_AFAN_HYST1     0x6d
0098 #define LM85_REG_AFAN_HYST2     0x6e
0099 
0100 #define ADM1027_REG_EXTEND_ADC1     0x76
0101 #define ADM1027_REG_EXTEND_ADC2     0x77
0102 
0103 #define EMC6D100_REG_ALARM3             0x7d
0104 /* IN5, IN6 and IN7 */
0105 #define EMC6D100_REG_IN(nr)             (0x70 + ((nr) - 5))
0106 #define EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr) - 5) * 2)
0107 #define EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr) - 5) * 2)
0108 #define EMC6D102_REG_EXTEND_ADC1    0x85
0109 #define EMC6D102_REG_EXTEND_ADC2    0x86
0110 #define EMC6D102_REG_EXTEND_ADC3    0x87
0111 #define EMC6D102_REG_EXTEND_ADC4    0x88
0112 
0113 /*
0114  * Conversions. Rounding and limit checking is only done on the TO_REG
0115  * variants. Note that you should be a bit careful with which arguments
0116  * these macros are called: arguments may be evaluated more than once.
0117  */
0118 
0119 /* IN are scaled according to built-in resistors */
0120 static const int lm85_scaling[] = {  /* .001 Volts */
0121     2500, 2250, 3300, 5000, 12000,
0122     3300, 1500, 1800 /*EMC6D100*/
0123 };
0124 #define SCALE(val, from, to)    (((val) * (to) + ((from) / 2)) / (from))
0125 
0126 #define INS_TO_REG(n, val)  \
0127         SCALE(clamp_val(val, 0, 255 * lm85_scaling[n] / 192), \
0128               lm85_scaling[n], 192)
0129 
0130 #define INSEXT_FROM_REG(n, val, ext)    \
0131         SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])
0132 
0133 #define INS_FROM_REG(n, val)    SCALE((val), 192, lm85_scaling[n])
0134 
0135 /* FAN speed is measured using 90kHz clock */
0136 static inline u16 FAN_TO_REG(unsigned long val)
0137 {
0138     if (!val)
0139         return 0xffff;
0140     return clamp_val(5400000 / val, 1, 0xfffe);
0141 }
0142 #define FAN_FROM_REG(val)   ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \
0143                  5400000 / (val))
0144 
0145 /* Temperature is reported in .001 degC increments */
0146 #define TEMP_TO_REG(val)    \
0147         DIV_ROUND_CLOSEST(clamp_val((val), -127000, 127000), 1000)
0148 #define TEMPEXT_FROM_REG(val, ext)  \
0149         SCALE(((val) << 4) + (ext), 16, 1000)
0150 #define TEMP_FROM_REG(val)  ((val) * 1000)
0151 
0152 #define PWM_TO_REG(val)         clamp_val(val, 0, 255)
0153 #define PWM_FROM_REG(val)       (val)
0154 
0155 /*
0156  * ZONEs have the following parameters:
0157  *    Limit (low) temp,           1. degC
0158  *    Hysteresis (below limit),   1. degC (0-15)
0159  *    Range of speed control,     .1 degC (2-80)
0160  *    Critical (high) temp,       1. degC
0161  *
0162  * FAN PWMs have the following parameters:
0163  *    Reference Zone,                 1, 2, 3, etc.
0164  *    Spinup time,                    .05 sec
0165  *    PWM value at limit/low temp,    1 count
0166  *    PWM Frequency,                  1. Hz
0167  *    PWM is Min or OFF below limit,  flag
0168  *    Invert PWM output,              flag
0169  *
0170  * Some chips filter the temp, others the fan.
0171  *    Filter constant (or disabled)   .1 seconds
0172  */
0173 
0174 /* These are the zone temperature range encodings in .001 degree C */
0175 static const int lm85_range_map[] = {
0176     2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,
0177     13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
0178 };
0179 
0180 static int RANGE_TO_REG(long range)
0181 {
0182     return find_closest(range, lm85_range_map, ARRAY_SIZE(lm85_range_map));
0183 }
0184 #define RANGE_FROM_REG(val) lm85_range_map[(val) & 0x0f]
0185 
0186 /* These are the PWM frequency encodings */
0187 static const int lm85_freq_map[] = { /* 1 Hz */
0188     10, 15, 23, 30, 38, 47, 61, 94
0189 };
0190 
0191 static const int lm96000_freq_map[] = { /* 1 Hz */
0192     10, 15, 23, 30, 38, 47, 61, 94,
0193     22500, 24000, 25700, 25700, 27700, 27700, 30000, 30000
0194 };
0195 
0196 static const int adm1027_freq_map[] = { /* 1 Hz */
0197     11, 15, 22, 29, 35, 44, 59, 88
0198 };
0199 
0200 static int FREQ_TO_REG(const int *map,
0201                unsigned int map_size, unsigned long freq)
0202 {
0203     return find_closest(freq, map, map_size);
0204 }
0205 
0206 static int FREQ_FROM_REG(const int *map, unsigned int map_size, u8 reg)
0207 {
0208     return map[reg % map_size];
0209 }
0210 
0211 /*
0212  * Since we can't use strings, I'm abusing these numbers
0213  *   to stand in for the following meanings:
0214  *      1 -- PWM responds to Zone 1
0215  *      2 -- PWM responds to Zone 2
0216  *      3 -- PWM responds to Zone 3
0217  *     23 -- PWM responds to the higher temp of Zone 2 or 3
0218  *    123 -- PWM responds to highest of Zone 1, 2, or 3
0219  *      0 -- PWM is always at 0% (ie, off)
0220  *     -1 -- PWM is always at 100%
0221  *     -2 -- PWM responds to manual control
0222  */
0223 
0224 static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
0225 #define ZONE_FROM_REG(val)  lm85_zone_map[(val) >> 5]
0226 
0227 static int ZONE_TO_REG(int zone)
0228 {
0229     int i;
0230 
0231     for (i = 0; i <= 7; ++i)
0232         if (zone == lm85_zone_map[i])
0233             break;
0234     if (i > 7)   /* Not found. */
0235         i = 3;  /* Always 100% */
0236     return i << 5;
0237 }
0238 
0239 #define HYST_TO_REG(val)    clamp_val(((val) + 500) / 1000, 0, 15)
0240 #define HYST_FROM_REG(val)  ((val) * 1000)
0241 
0242 /*
0243  * Chip sampling rates
0244  *
0245  * Some sensors are not updated more frequently than once per second
0246  *    so it doesn't make sense to read them more often than that.
0247  *    We cache the results and return the saved data if the driver
0248  *    is called again before a second has elapsed.
0249  *
0250  * Also, there is significant configuration data for this chip
0251  *    given the automatic PWM fan control that is possible.  There
0252  *    are about 47 bytes of config data to only 22 bytes of actual
0253  *    readings.  So, we keep the config data up to date in the cache
0254  *    when it is written and only sample it once every 1 *minute*
0255  */
0256 #define LM85_DATA_INTERVAL  (HZ + HZ / 2)
0257 #define LM85_CONFIG_INTERVAL  (1 * 60 * HZ)
0258 
0259 /*
0260  * LM85 can automatically adjust fan speeds based on temperature
0261  * This structure encapsulates an entire Zone config.  There are
0262  * three zones (one for each temperature input) on the lm85
0263  */
0264 struct lm85_zone {
0265     s8 limit;   /* Low temp limit */
0266     u8 hyst;    /* Low limit hysteresis. (0-15) */
0267     u8 range;   /* Temp range, encoded */
0268     s8 critical;    /* "All fans ON" temp limit */
0269     u8 max_desired; /*
0270              * Actual "max" temperature specified.  Preserved
0271              * to prevent "drift" as other autofan control
0272              * values change.
0273              */
0274 };
0275 
0276 struct lm85_autofan {
0277     u8 config;  /* Register value */
0278     u8 min_pwm; /* Minimum PWM value, encoded */
0279     u8 min_off; /* Min PWM or OFF below "limit", flag */
0280 };
0281 
0282 /*
0283  * For each registered chip, we need to keep some data in memory.
0284  * The structure is dynamically allocated.
0285  */
0286 struct lm85_data {
0287     struct i2c_client *client;
0288     const struct attribute_group *groups[6];
0289     const int *freq_map;
0290     unsigned int freq_map_size;
0291 
0292     enum chips type;
0293 
0294     bool has_vid5;  /* true if VID5 is configured for ADT7463 or ADT7468 */
0295 
0296     struct mutex update_lock;
0297     bool valid;     /* true if following fields are valid */
0298     unsigned long last_reading; /* In jiffies */
0299     unsigned long last_config;  /* In jiffies */
0300 
0301     u8 in[8];       /* Register value */
0302     u8 in_max[8];       /* Register value */
0303     u8 in_min[8];       /* Register value */
0304     s8 temp[3];     /* Register value */
0305     s8 temp_min[3];     /* Register value */
0306     s8 temp_max[3];     /* Register value */
0307     u16 fan[4];     /* Register value */
0308     u16 fan_min[4];     /* Register value */
0309     u8 pwm[3];      /* Register value */
0310     u8 pwm_freq[3];     /* Register encoding */
0311     u8 temp_ext[3];     /* Decoded values */
0312     u8 in_ext[8];       /* Decoded values */
0313     u8 vid;         /* Register value */
0314     u8 vrm;         /* VRM version */
0315     u32 alarms;     /* Register encoding, combined */
0316     u8 cfg5;        /* Config Register 5 on ADT7468 */
0317     struct lm85_autofan autofan[3];
0318     struct lm85_zone zone[3];
0319 };
0320 
0321 static int lm85_read_value(struct i2c_client *client, u8 reg)
0322 {
0323     int res;
0324 
0325     /* What size location is it? */
0326     switch (reg) {
0327     case LM85_REG_FAN(0):  /* Read WORD data */
0328     case LM85_REG_FAN(1):
0329     case LM85_REG_FAN(2):
0330     case LM85_REG_FAN(3):
0331     case LM85_REG_FAN_MIN(0):
0332     case LM85_REG_FAN_MIN(1):
0333     case LM85_REG_FAN_MIN(2):
0334     case LM85_REG_FAN_MIN(3):
0335     case LM85_REG_ALARM1:   /* Read both bytes at once */
0336         res = i2c_smbus_read_byte_data(client, reg) & 0xff;
0337         res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
0338         break;
0339     default:    /* Read BYTE data */
0340         res = i2c_smbus_read_byte_data(client, reg);
0341         break;
0342     }
0343 
0344     return res;
0345 }
0346 
0347 static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
0348 {
0349     switch (reg) {
0350     case LM85_REG_FAN(0):  /* Write WORD data */
0351     case LM85_REG_FAN(1):
0352     case LM85_REG_FAN(2):
0353     case LM85_REG_FAN(3):
0354     case LM85_REG_FAN_MIN(0):
0355     case LM85_REG_FAN_MIN(1):
0356     case LM85_REG_FAN_MIN(2):
0357     case LM85_REG_FAN_MIN(3):
0358     /* NOTE: ALARM is read only, so not included here */
0359         i2c_smbus_write_byte_data(client, reg, value & 0xff);
0360         i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
0361         break;
0362     default:    /* Write BYTE data */
0363         i2c_smbus_write_byte_data(client, reg, value);
0364         break;
0365     }
0366 }
0367 
0368 static struct lm85_data *lm85_update_device(struct device *dev)
0369 {
0370     struct lm85_data *data = dev_get_drvdata(dev);
0371     struct i2c_client *client = data->client;
0372     int i;
0373 
0374     mutex_lock(&data->update_lock);
0375 
0376     if (!data->valid ||
0377          time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
0378         /* Things that change quickly */
0379         dev_dbg(&client->dev, "Reading sensor values\n");
0380 
0381         /*
0382          * Have to read extended bits first to "freeze" the
0383          * more significant bits that are read later.
0384          * There are 2 additional resolution bits per channel and we
0385          * have room for 4, so we shift them to the left.
0386          */
0387         if (data->type == adm1027 || data->type == adt7463 ||
0388             data->type == adt7468) {
0389             int ext1 = lm85_read_value(client,
0390                            ADM1027_REG_EXTEND_ADC1);
0391             int ext2 =  lm85_read_value(client,
0392                             ADM1027_REG_EXTEND_ADC2);
0393             int val = (ext1 << 8) + ext2;
0394 
0395             for (i = 0; i <= 4; i++)
0396                 data->in_ext[i] =
0397                     ((val >> (i * 2)) & 0x03) << 2;
0398 
0399             for (i = 0; i <= 2; i++)
0400                 data->temp_ext[i] =
0401                     (val >> ((i + 4) * 2)) & 0x0c;
0402         }
0403 
0404         data->vid = lm85_read_value(client, LM85_REG_VID);
0405 
0406         for (i = 0; i <= 3; ++i) {
0407             data->in[i] =
0408                 lm85_read_value(client, LM85_REG_IN(i));
0409             data->fan[i] =
0410                 lm85_read_value(client, LM85_REG_FAN(i));
0411         }
0412 
0413         if (!data->has_vid5)
0414             data->in[4] = lm85_read_value(client, LM85_REG_IN(4));
0415 
0416         if (data->type == adt7468)
0417             data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);
0418 
0419         for (i = 0; i <= 2; ++i) {
0420             data->temp[i] =
0421                 lm85_read_value(client, LM85_REG_TEMP(i));
0422             data->pwm[i] =
0423                 lm85_read_value(client, LM85_REG_PWM(i));
0424 
0425             if (IS_ADT7468_OFF64(data))
0426                 data->temp[i] -= 64;
0427         }
0428 
0429         data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
0430 
0431         if (data->type == emc6d100) {
0432             /* Three more voltage sensors */
0433             for (i = 5; i <= 7; ++i) {
0434                 data->in[i] = lm85_read_value(client,
0435                             EMC6D100_REG_IN(i));
0436             }
0437             /* More alarm bits */
0438             data->alarms |= lm85_read_value(client,
0439                         EMC6D100_REG_ALARM3) << 16;
0440         } else if (data->type == emc6d102 || data->type == emc6d103 ||
0441                data->type == emc6d103s) {
0442             /*
0443              * Have to read LSB bits after the MSB ones because
0444              * the reading of the MSB bits has frozen the
0445              * LSBs (backward from the ADM1027).
0446              */
0447             int ext1 = lm85_read_value(client,
0448                            EMC6D102_REG_EXTEND_ADC1);
0449             int ext2 = lm85_read_value(client,
0450                            EMC6D102_REG_EXTEND_ADC2);
0451             int ext3 = lm85_read_value(client,
0452                            EMC6D102_REG_EXTEND_ADC3);
0453             int ext4 = lm85_read_value(client,
0454                            EMC6D102_REG_EXTEND_ADC4);
0455             data->in_ext[0] = ext3 & 0x0f;
0456             data->in_ext[1] = ext4 & 0x0f;
0457             data->in_ext[2] = ext4 >> 4;
0458             data->in_ext[3] = ext3 >> 4;
0459             data->in_ext[4] = ext2 >> 4;
0460 
0461             data->temp_ext[0] = ext1 & 0x0f;
0462             data->temp_ext[1] = ext2 & 0x0f;
0463             data->temp_ext[2] = ext1 >> 4;
0464         }
0465 
0466         data->last_reading = jiffies;
0467     }  /* last_reading */
0468 
0469     if (!data->valid ||
0470          time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
0471         /* Things that don't change often */
0472         dev_dbg(&client->dev, "Reading config values\n");
0473 
0474         for (i = 0; i <= 3; ++i) {
0475             data->in_min[i] =
0476                 lm85_read_value(client, LM85_REG_IN_MIN(i));
0477             data->in_max[i] =
0478                 lm85_read_value(client, LM85_REG_IN_MAX(i));
0479             data->fan_min[i] =
0480                 lm85_read_value(client, LM85_REG_FAN_MIN(i));
0481         }
0482 
0483         if (!data->has_vid5)  {
0484             data->in_min[4] = lm85_read_value(client,
0485                       LM85_REG_IN_MIN(4));
0486             data->in_max[4] = lm85_read_value(client,
0487                       LM85_REG_IN_MAX(4));
0488         }
0489 
0490         if (data->type == emc6d100) {
0491             for (i = 5; i <= 7; ++i) {
0492                 data->in_min[i] = lm85_read_value(client,
0493                         EMC6D100_REG_IN_MIN(i));
0494                 data->in_max[i] = lm85_read_value(client,
0495                         EMC6D100_REG_IN_MAX(i));
0496             }
0497         }
0498 
0499         for (i = 0; i <= 2; ++i) {
0500             int val;
0501 
0502             data->temp_min[i] =
0503                 lm85_read_value(client, LM85_REG_TEMP_MIN(i));
0504             data->temp_max[i] =
0505                 lm85_read_value(client, LM85_REG_TEMP_MAX(i));
0506 
0507             data->autofan[i].config =
0508                 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
0509             val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
0510             data->pwm_freq[i] = val % data->freq_map_size;
0511             data->zone[i].range = val >> 4;
0512             data->autofan[i].min_pwm =
0513                 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
0514             data->zone[i].limit =
0515                 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
0516             data->zone[i].critical =
0517                 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
0518 
0519             if (IS_ADT7468_OFF64(data)) {
0520                 data->temp_min[i] -= 64;
0521                 data->temp_max[i] -= 64;
0522                 data->zone[i].limit -= 64;
0523                 data->zone[i].critical -= 64;
0524             }
0525         }
0526 
0527         if (data->type != emc6d103s) {
0528             i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
0529             data->autofan[0].min_off = (i & 0x20) != 0;
0530             data->autofan[1].min_off = (i & 0x40) != 0;
0531             data->autofan[2].min_off = (i & 0x80) != 0;
0532 
0533             i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
0534             data->zone[0].hyst = i >> 4;
0535             data->zone[1].hyst = i & 0x0f;
0536 
0537             i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
0538             data->zone[2].hyst = i >> 4;
0539         }
0540 
0541         data->last_config = jiffies;
0542     }  /* last_config */
0543 
0544     data->valid = true;
0545 
0546     mutex_unlock(&data->update_lock);
0547 
0548     return data;
0549 }
0550 
0551 /* 4 Fans */
0552 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
0553             char *buf)
0554 {
0555     int nr = to_sensor_dev_attr(attr)->index;
0556     struct lm85_data *data = lm85_update_device(dev);
0557     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));
0558 }
0559 
0560 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
0561                 char *buf)
0562 {
0563     int nr = to_sensor_dev_attr(attr)->index;
0564     struct lm85_data *data = lm85_update_device(dev);
0565     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));
0566 }
0567 
0568 static ssize_t fan_min_store(struct device *dev,
0569                  struct device_attribute *attr, const char *buf,
0570                  size_t count)
0571 {
0572     int nr = to_sensor_dev_attr(attr)->index;
0573     struct lm85_data *data = dev_get_drvdata(dev);
0574     struct i2c_client *client = data->client;
0575     unsigned long val;
0576     int err;
0577 
0578     err = kstrtoul(buf, 10, &val);
0579     if (err)
0580         return err;
0581 
0582     mutex_lock(&data->update_lock);
0583     data->fan_min[nr] = FAN_TO_REG(val);
0584     lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);
0585     mutex_unlock(&data->update_lock);
0586     return count;
0587 }
0588 
0589 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
0590 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0591 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
0592 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0593 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
0594 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
0595 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
0596 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
0597 
0598 /* vid, vrm, alarms */
0599 
0600 static ssize_t cpu0_vid_show(struct device *dev,
0601                  struct device_attribute *attr, char *buf)
0602 {
0603     struct lm85_data *data = lm85_update_device(dev);
0604     int vid;
0605 
0606     if (data->has_vid5) {
0607         /* 6-pin VID (VRM 10) */
0608         vid = vid_from_reg(data->vid & 0x3f, data->vrm);
0609     } else {
0610         /* 5-pin VID (VRM 9) */
0611         vid = vid_from_reg(data->vid & 0x1f, data->vrm);
0612     }
0613 
0614     return sprintf(buf, "%d\n", vid);
0615 }
0616 
0617 static DEVICE_ATTR_RO(cpu0_vid);
0618 
0619 static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
0620             char *buf)
0621 {
0622     struct lm85_data *data = dev_get_drvdata(dev);
0623     return sprintf(buf, "%ld\n", (long) data->vrm);
0624 }
0625 
0626 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
0627              const char *buf, size_t count)
0628 {
0629     struct lm85_data *data = dev_get_drvdata(dev);
0630     unsigned long val;
0631     int err;
0632 
0633     err = kstrtoul(buf, 10, &val);
0634     if (err)
0635         return err;
0636 
0637     if (val > 255)
0638         return -EINVAL;
0639 
0640     data->vrm = val;
0641     return count;
0642 }
0643 
0644 static DEVICE_ATTR_RW(vrm);
0645 
0646 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0647                char *buf)
0648 {
0649     struct lm85_data *data = lm85_update_device(dev);
0650     return sprintf(buf, "%u\n", data->alarms);
0651 }
0652 
0653 static DEVICE_ATTR_RO(alarms);
0654 
0655 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0656               char *buf)
0657 {
0658     int nr = to_sensor_dev_attr(attr)->index;
0659     struct lm85_data *data = lm85_update_device(dev);
0660     return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
0661 }
0662 
0663 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
0664 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
0665 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
0666 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0667 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
0668 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 18);
0669 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 16);
0670 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 17);
0671 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
0672 static SENSOR_DEVICE_ATTR_RO(temp1_fault, alarm, 14);
0673 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
0674 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 6);
0675 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 15);
0676 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 10);
0677 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 11);
0678 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 12);
0679 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 13);
0680 
0681 /* pwm */
0682 
0683 static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
0684             char *buf)
0685 {
0686     int nr = to_sensor_dev_attr(attr)->index;
0687     struct lm85_data *data = lm85_update_device(dev);
0688     return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
0689 }
0690 
0691 static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
0692              const char *buf, size_t count)
0693 {
0694     int nr = to_sensor_dev_attr(attr)->index;
0695     struct lm85_data *data = dev_get_drvdata(dev);
0696     struct i2c_client *client = data->client;
0697     unsigned long val;
0698     int err;
0699 
0700     err = kstrtoul(buf, 10, &val);
0701     if (err)
0702         return err;
0703 
0704     mutex_lock(&data->update_lock);
0705     data->pwm[nr] = PWM_TO_REG(val);
0706     lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);
0707     mutex_unlock(&data->update_lock);
0708     return count;
0709 }
0710 
0711 static ssize_t pwm_enable_show(struct device *dev,
0712                    struct device_attribute *attr, char *buf)
0713 {
0714     int nr = to_sensor_dev_attr(attr)->index;
0715     struct lm85_data *data = lm85_update_device(dev);
0716     int pwm_zone, enable;
0717 
0718     pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);
0719     switch (pwm_zone) {
0720     case -1:    /* PWM is always at 100% */
0721         enable = 0;
0722         break;
0723     case 0:     /* PWM is always at 0% */
0724     case -2:    /* PWM responds to manual control */
0725         enable = 1;
0726         break;
0727     default:    /* PWM in automatic mode */
0728         enable = 2;
0729     }
0730     return sprintf(buf, "%d\n", enable);
0731 }
0732 
0733 static ssize_t pwm_enable_store(struct device *dev,
0734                 struct device_attribute *attr,
0735                 const char *buf, size_t count)
0736 {
0737     int nr = to_sensor_dev_attr(attr)->index;
0738     struct lm85_data *data = dev_get_drvdata(dev);
0739     struct i2c_client *client = data->client;
0740     u8 config;
0741     unsigned long val;
0742     int err;
0743 
0744     err = kstrtoul(buf, 10, &val);
0745     if (err)
0746         return err;
0747 
0748     switch (val) {
0749     case 0:
0750         config = 3;
0751         break;
0752     case 1:
0753         config = 7;
0754         break;
0755     case 2:
0756         /*
0757          * Here we have to choose arbitrarily one of the 5 possible
0758          * configurations; I go for the safest
0759          */
0760         config = 6;
0761         break;
0762     default:
0763         return -EINVAL;
0764     }
0765 
0766     mutex_lock(&data->update_lock);
0767     data->autofan[nr].config = lm85_read_value(client,
0768         LM85_REG_AFAN_CONFIG(nr));
0769     data->autofan[nr].config = (data->autofan[nr].config & ~0xe0)
0770         | (config << 5);
0771     lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
0772         data->autofan[nr].config);
0773     mutex_unlock(&data->update_lock);
0774     return count;
0775 }
0776 
0777 static ssize_t pwm_freq_show(struct device *dev,
0778                  struct device_attribute *attr, char *buf)
0779 {
0780     int nr = to_sensor_dev_attr(attr)->index;
0781     struct lm85_data *data = lm85_update_device(dev);
0782     int freq;
0783 
0784     if (IS_ADT7468_HFPWM(data))
0785         freq = 22500;
0786     else
0787         freq = FREQ_FROM_REG(data->freq_map, data->freq_map_size,
0788                      data->pwm_freq[nr]);
0789 
0790     return sprintf(buf, "%d\n", freq);
0791 }
0792 
0793 static ssize_t pwm_freq_store(struct device *dev,
0794                   struct device_attribute *attr, const char *buf,
0795                   size_t count)
0796 {
0797     int nr = to_sensor_dev_attr(attr)->index;
0798     struct lm85_data *data = dev_get_drvdata(dev);
0799     struct i2c_client *client = data->client;
0800     unsigned long val;
0801     int err;
0802 
0803     err = kstrtoul(buf, 10, &val);
0804     if (err)
0805         return err;
0806 
0807     mutex_lock(&data->update_lock);
0808     /*
0809      * The ADT7468 has a special high-frequency PWM output mode,
0810      * where all PWM outputs are driven by a 22.5 kHz clock.
0811      * This might confuse the user, but there's not much we can do.
0812      */
0813     if (data->type == adt7468 && val >= 11300) {    /* High freq. mode */
0814         data->cfg5 &= ~ADT7468_HFPWM;
0815         lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
0816     } else {                    /* Low freq. mode */
0817         data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map,
0818                          data->freq_map_size, val);
0819         lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
0820                  (data->zone[nr].range << 4)
0821                  | data->pwm_freq[nr]);
0822         if (data->type == adt7468) {
0823             data->cfg5 |= ADT7468_HFPWM;
0824             lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
0825         }
0826     }
0827     mutex_unlock(&data->update_lock);
0828     return count;
0829 }
0830 
0831 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
0832 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_enable, 0);
0833 static SENSOR_DEVICE_ATTR_RW(pwm1_freq, pwm_freq, 0);
0834 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
0835 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_enable, 1);
0836 static SENSOR_DEVICE_ATTR_RW(pwm2_freq, pwm_freq, 1);
0837 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2);
0838 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_enable, 2);
0839 static SENSOR_DEVICE_ATTR_RW(pwm3_freq, pwm_freq, 2);
0840 
0841 /* Voltages */
0842 
0843 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
0844                char *buf)
0845 {
0846     int nr = to_sensor_dev_attr(attr)->index;
0847     struct lm85_data *data = lm85_update_device(dev);
0848     return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],
0849                             data->in_ext[nr]));
0850 }
0851 
0852 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
0853                char *buf)
0854 {
0855     int nr = to_sensor_dev_attr(attr)->index;
0856     struct lm85_data *data = lm85_update_device(dev);
0857     return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
0858 }
0859 
0860 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0861                 const char *buf, size_t count)
0862 {
0863     int nr = to_sensor_dev_attr(attr)->index;
0864     struct lm85_data *data = dev_get_drvdata(dev);
0865     struct i2c_client *client = data->client;
0866     long val;
0867     int err;
0868 
0869     err = kstrtol(buf, 10, &val);
0870     if (err)
0871         return err;
0872 
0873     mutex_lock(&data->update_lock);
0874     data->in_min[nr] = INS_TO_REG(nr, val);
0875     lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);
0876     mutex_unlock(&data->update_lock);
0877     return count;
0878 }
0879 
0880 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
0881                char *buf)
0882 {
0883     int nr = to_sensor_dev_attr(attr)->index;
0884     struct lm85_data *data = lm85_update_device(dev);
0885     return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
0886 }
0887 
0888 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0889                 const char *buf, size_t count)
0890 {
0891     int nr = to_sensor_dev_attr(attr)->index;
0892     struct lm85_data *data = dev_get_drvdata(dev);
0893     struct i2c_client *client = data->client;
0894     long val;
0895     int err;
0896 
0897     err = kstrtol(buf, 10, &val);
0898     if (err)
0899         return err;
0900 
0901     mutex_lock(&data->update_lock);
0902     data->in_max[nr] = INS_TO_REG(nr, val);
0903     lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);
0904     mutex_unlock(&data->update_lock);
0905     return count;
0906 }
0907 
0908 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0909 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0910 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0911 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0912 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0913 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0914 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0915 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0916 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0917 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0918 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0919 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0920 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0921 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0922 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0923 static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
0924 static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
0925 static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
0926 static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
0927 static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
0928 static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
0929 static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
0930 static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
0931 static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
0932 
0933 /* Temps */
0934 
0935 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0936              char *buf)
0937 {
0938     int nr = to_sensor_dev_attr(attr)->index;
0939     struct lm85_data *data = lm85_update_device(dev);
0940     return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],
0941                              data->temp_ext[nr]));
0942 }
0943 
0944 static ssize_t temp_min_show(struct device *dev,
0945                  struct device_attribute *attr, char *buf)
0946 {
0947     int nr = to_sensor_dev_attr(attr)->index;
0948     struct lm85_data *data = lm85_update_device(dev);
0949     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
0950 }
0951 
0952 static ssize_t temp_min_store(struct device *dev,
0953                   struct device_attribute *attr, const char *buf,
0954                   size_t count)
0955 {
0956     int nr = to_sensor_dev_attr(attr)->index;
0957     struct lm85_data *data = dev_get_drvdata(dev);
0958     struct i2c_client *client = data->client;
0959     long val;
0960     int err;
0961 
0962     err = kstrtol(buf, 10, &val);
0963     if (err)
0964         return err;
0965 
0966     if (IS_ADT7468_OFF64(data))
0967         val += 64;
0968 
0969     mutex_lock(&data->update_lock);
0970     data->temp_min[nr] = TEMP_TO_REG(val);
0971     lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);
0972     mutex_unlock(&data->update_lock);
0973     return count;
0974 }
0975 
0976 static ssize_t temp_max_show(struct device *dev,
0977                  struct device_attribute *attr, char *buf)
0978 {
0979     int nr = to_sensor_dev_attr(attr)->index;
0980     struct lm85_data *data = lm85_update_device(dev);
0981     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
0982 }
0983 
0984 static ssize_t temp_max_store(struct device *dev,
0985                   struct device_attribute *attr, const char *buf,
0986                   size_t count)
0987 {
0988     int nr = to_sensor_dev_attr(attr)->index;
0989     struct lm85_data *data = dev_get_drvdata(dev);
0990     struct i2c_client *client = data->client;
0991     long val;
0992     int err;
0993 
0994     err = kstrtol(buf, 10, &val);
0995     if (err)
0996         return err;
0997 
0998     if (IS_ADT7468_OFF64(data))
0999         val += 64;
1000 
1001     mutex_lock(&data->update_lock);
1002     data->temp_max[nr] = TEMP_TO_REG(val);
1003     lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);
1004     mutex_unlock(&data->update_lock);
1005     return count;
1006 }
1007 
1008 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
1009 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
1010 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
1011 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
1012 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
1013 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
1014 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
1015 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
1016 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
1017 
1018 /* Automatic PWM control */
1019 
1020 static ssize_t pwm_auto_channels_show(struct device *dev,
1021                       struct device_attribute *attr,
1022                       char *buf)
1023 {
1024     int nr = to_sensor_dev_attr(attr)->index;
1025     struct lm85_data *data = lm85_update_device(dev);
1026     return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));
1027 }
1028 
1029 static ssize_t pwm_auto_channels_store(struct device *dev,
1030                        struct device_attribute *attr,
1031                        const char *buf, size_t count)
1032 {
1033     int nr = to_sensor_dev_attr(attr)->index;
1034     struct lm85_data *data = dev_get_drvdata(dev);
1035     struct i2c_client *client = data->client;
1036     long val;
1037     int err;
1038 
1039     err = kstrtol(buf, 10, &val);
1040     if (err)
1041         return err;
1042 
1043     mutex_lock(&data->update_lock);
1044     data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
1045         | ZONE_TO_REG(val);
1046     lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
1047         data->autofan[nr].config);
1048     mutex_unlock(&data->update_lock);
1049     return count;
1050 }
1051 
1052 static ssize_t pwm_auto_pwm_min_show(struct device *dev,
1053                      struct device_attribute *attr, char *buf)
1054 {
1055     int nr = to_sensor_dev_attr(attr)->index;
1056     struct lm85_data *data = lm85_update_device(dev);
1057     return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
1058 }
1059 
1060 static ssize_t pwm_auto_pwm_min_store(struct device *dev,
1061                       struct device_attribute *attr,
1062                       const char *buf, size_t count)
1063 {
1064     int nr = to_sensor_dev_attr(attr)->index;
1065     struct lm85_data *data = dev_get_drvdata(dev);
1066     struct i2c_client *client = data->client;
1067     unsigned long val;
1068     int err;
1069 
1070     err = kstrtoul(buf, 10, &val);
1071     if (err)
1072         return err;
1073 
1074     mutex_lock(&data->update_lock);
1075     data->autofan[nr].min_pwm = PWM_TO_REG(val);
1076     lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
1077         data->autofan[nr].min_pwm);
1078     mutex_unlock(&data->update_lock);
1079     return count;
1080 }
1081 
1082 static ssize_t pwm_auto_pwm_minctl_show(struct device *dev,
1083                     struct device_attribute *attr,
1084                     char *buf)
1085 {
1086     int nr = to_sensor_dev_attr(attr)->index;
1087     struct lm85_data *data = lm85_update_device(dev);
1088     return sprintf(buf, "%d\n", data->autofan[nr].min_off);
1089 }
1090 
1091 static ssize_t pwm_auto_pwm_minctl_store(struct device *dev,
1092                      struct device_attribute *attr,
1093                      const char *buf, size_t count)
1094 {
1095     int nr = to_sensor_dev_attr(attr)->index;
1096     struct lm85_data *data = dev_get_drvdata(dev);
1097     struct i2c_client *client = data->client;
1098     u8 tmp;
1099     long val;
1100     int err;
1101 
1102     err = kstrtol(buf, 10, &val);
1103     if (err)
1104         return err;
1105 
1106     mutex_lock(&data->update_lock);
1107     data->autofan[nr].min_off = val;
1108     tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
1109     tmp &= ~(0x20 << nr);
1110     if (data->autofan[nr].min_off)
1111         tmp |= 0x20 << nr;
1112     lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);
1113     mutex_unlock(&data->update_lock);
1114     return count;
1115 }
1116 
1117 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels, pwm_auto_channels, 0);
1118 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_pwm_min, pwm_auto_pwm_min, 0);
1119 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_pwm_minctl, pwm_auto_pwm_minctl, 0);
1120 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels, pwm_auto_channels, 1);
1121 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_pwm_min, pwm_auto_pwm_min, 1);
1122 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_pwm_minctl, pwm_auto_pwm_minctl, 1);
1123 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels, pwm_auto_channels, 2);
1124 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_pwm_min, pwm_auto_pwm_min, 2);
1125 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_pwm_minctl, pwm_auto_pwm_minctl, 2);
1126 
1127 /* Temperature settings for automatic PWM control */
1128 
1129 static ssize_t temp_auto_temp_off_show(struct device *dev,
1130                        struct device_attribute *attr,
1131                        char *buf)
1132 {
1133     int nr = to_sensor_dev_attr(attr)->index;
1134     struct lm85_data *data = lm85_update_device(dev);
1135     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
1136         HYST_FROM_REG(data->zone[nr].hyst));
1137 }
1138 
1139 static ssize_t temp_auto_temp_off_store(struct device *dev,
1140                     struct device_attribute *attr,
1141                     const char *buf, size_t count)
1142 {
1143     int nr = to_sensor_dev_attr(attr)->index;
1144     struct lm85_data *data = dev_get_drvdata(dev);
1145     struct i2c_client *client = data->client;
1146     int min;
1147     long val;
1148     int err;
1149 
1150     err = kstrtol(buf, 10, &val);
1151     if (err)
1152         return err;
1153 
1154     mutex_lock(&data->update_lock);
1155     min = TEMP_FROM_REG(data->zone[nr].limit);
1156     data->zone[nr].hyst = HYST_TO_REG(min - val);
1157     if (nr == 0 || nr == 1) {
1158         lm85_write_value(client, LM85_REG_AFAN_HYST1,
1159             (data->zone[0].hyst << 4)
1160             | data->zone[1].hyst);
1161     } else {
1162         lm85_write_value(client, LM85_REG_AFAN_HYST2,
1163             (data->zone[2].hyst << 4));
1164     }
1165     mutex_unlock(&data->update_lock);
1166     return count;
1167 }
1168 
1169 static ssize_t temp_auto_temp_min_show(struct device *dev,
1170                        struct device_attribute *attr,
1171                        char *buf)
1172 {
1173     int nr = to_sensor_dev_attr(attr)->index;
1174     struct lm85_data *data = lm85_update_device(dev);
1175     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));
1176 }
1177 
1178 static ssize_t temp_auto_temp_min_store(struct device *dev,
1179                     struct device_attribute *attr,
1180                     const char *buf, size_t count)
1181 {
1182     int nr = to_sensor_dev_attr(attr)->index;
1183     struct lm85_data *data = dev_get_drvdata(dev);
1184     struct i2c_client *client = data->client;
1185     long val;
1186     int err;
1187 
1188     err = kstrtol(buf, 10, &val);
1189     if (err)
1190         return err;
1191 
1192     mutex_lock(&data->update_lock);
1193     data->zone[nr].limit = TEMP_TO_REG(val);
1194     lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
1195         data->zone[nr].limit);
1196 
1197 /* Update temp_auto_max and temp_auto_range */
1198     data->zone[nr].range = RANGE_TO_REG(
1199         TEMP_FROM_REG(data->zone[nr].max_desired) -
1200         TEMP_FROM_REG(data->zone[nr].limit));
1201     lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
1202         ((data->zone[nr].range & 0x0f) << 4)
1203         | data->pwm_freq[nr]);
1204 
1205     mutex_unlock(&data->update_lock);
1206     return count;
1207 }
1208 
1209 static ssize_t temp_auto_temp_max_show(struct device *dev,
1210                        struct device_attribute *attr,
1211                        char *buf)
1212 {
1213     int nr = to_sensor_dev_attr(attr)->index;
1214     struct lm85_data *data = lm85_update_device(dev);
1215     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
1216         RANGE_FROM_REG(data->zone[nr].range));
1217 }
1218 
1219 static ssize_t temp_auto_temp_max_store(struct device *dev,
1220                     struct device_attribute *attr,
1221                     const char *buf, size_t count)
1222 {
1223     int nr = to_sensor_dev_attr(attr)->index;
1224     struct lm85_data *data = dev_get_drvdata(dev);
1225     struct i2c_client *client = data->client;
1226     int min;
1227     long val;
1228     int err;
1229 
1230     err = kstrtol(buf, 10, &val);
1231     if (err)
1232         return err;
1233 
1234     mutex_lock(&data->update_lock);
1235     min = TEMP_FROM_REG(data->zone[nr].limit);
1236     data->zone[nr].max_desired = TEMP_TO_REG(val);
1237     data->zone[nr].range = RANGE_TO_REG(
1238         val - min);
1239     lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
1240         ((data->zone[nr].range & 0x0f) << 4)
1241         | data->pwm_freq[nr]);
1242     mutex_unlock(&data->update_lock);
1243     return count;
1244 }
1245 
1246 static ssize_t temp_auto_temp_crit_show(struct device *dev,
1247                     struct device_attribute *attr,
1248                     char *buf)
1249 {
1250     int nr = to_sensor_dev_attr(attr)->index;
1251     struct lm85_data *data = lm85_update_device(dev);
1252     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));
1253 }
1254 
1255 static ssize_t temp_auto_temp_crit_store(struct device *dev,
1256                      struct device_attribute *attr,
1257                      const char *buf, size_t count)
1258 {
1259     int nr = to_sensor_dev_attr(attr)->index;
1260     struct lm85_data *data = dev_get_drvdata(dev);
1261     struct i2c_client *client = data->client;
1262     long val;
1263     int err;
1264 
1265     err = kstrtol(buf, 10, &val);
1266     if (err)
1267         return err;
1268 
1269     mutex_lock(&data->update_lock);
1270     data->zone[nr].critical = TEMP_TO_REG(val);
1271     lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
1272         data->zone[nr].critical);
1273     mutex_unlock(&data->update_lock);
1274     return count;
1275 }
1276 
1277 static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_off, temp_auto_temp_off, 0);
1278 static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_min, temp_auto_temp_min, 0);
1279 static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_max, temp_auto_temp_max, 0);
1280 static SENSOR_DEVICE_ATTR_RW(temp1_auto_temp_crit, temp_auto_temp_crit, 0);
1281 static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_off, temp_auto_temp_off, 1);
1282 static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_min, temp_auto_temp_min, 1);
1283 static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_max, temp_auto_temp_max, 1);
1284 static SENSOR_DEVICE_ATTR_RW(temp2_auto_temp_crit, temp_auto_temp_crit, 1);
1285 static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_off, temp_auto_temp_off, 2);
1286 static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_min, temp_auto_temp_min, 2);
1287 static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_max, temp_auto_temp_max, 2);
1288 static SENSOR_DEVICE_ATTR_RW(temp3_auto_temp_crit, temp_auto_temp_crit, 2);
1289 
1290 static struct attribute *lm85_attributes[] = {
1291     &sensor_dev_attr_fan1_input.dev_attr.attr,
1292     &sensor_dev_attr_fan2_input.dev_attr.attr,
1293     &sensor_dev_attr_fan3_input.dev_attr.attr,
1294     &sensor_dev_attr_fan4_input.dev_attr.attr,
1295     &sensor_dev_attr_fan1_min.dev_attr.attr,
1296     &sensor_dev_attr_fan2_min.dev_attr.attr,
1297     &sensor_dev_attr_fan3_min.dev_attr.attr,
1298     &sensor_dev_attr_fan4_min.dev_attr.attr,
1299     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1300     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1301     &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1302     &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1303 
1304     &sensor_dev_attr_pwm1.dev_attr.attr,
1305     &sensor_dev_attr_pwm2.dev_attr.attr,
1306     &sensor_dev_attr_pwm3.dev_attr.attr,
1307     &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1308     &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1309     &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1310     &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1311     &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1312     &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1313 
1314     &sensor_dev_attr_in0_input.dev_attr.attr,
1315     &sensor_dev_attr_in1_input.dev_attr.attr,
1316     &sensor_dev_attr_in2_input.dev_attr.attr,
1317     &sensor_dev_attr_in3_input.dev_attr.attr,
1318     &sensor_dev_attr_in0_min.dev_attr.attr,
1319     &sensor_dev_attr_in1_min.dev_attr.attr,
1320     &sensor_dev_attr_in2_min.dev_attr.attr,
1321     &sensor_dev_attr_in3_min.dev_attr.attr,
1322     &sensor_dev_attr_in0_max.dev_attr.attr,
1323     &sensor_dev_attr_in1_max.dev_attr.attr,
1324     &sensor_dev_attr_in2_max.dev_attr.attr,
1325     &sensor_dev_attr_in3_max.dev_attr.attr,
1326     &sensor_dev_attr_in0_alarm.dev_attr.attr,
1327     &sensor_dev_attr_in1_alarm.dev_attr.attr,
1328     &sensor_dev_attr_in2_alarm.dev_attr.attr,
1329     &sensor_dev_attr_in3_alarm.dev_attr.attr,
1330 
1331     &sensor_dev_attr_temp1_input.dev_attr.attr,
1332     &sensor_dev_attr_temp2_input.dev_attr.attr,
1333     &sensor_dev_attr_temp3_input.dev_attr.attr,
1334     &sensor_dev_attr_temp1_min.dev_attr.attr,
1335     &sensor_dev_attr_temp2_min.dev_attr.attr,
1336     &sensor_dev_attr_temp3_min.dev_attr.attr,
1337     &sensor_dev_attr_temp1_max.dev_attr.attr,
1338     &sensor_dev_attr_temp2_max.dev_attr.attr,
1339     &sensor_dev_attr_temp3_max.dev_attr.attr,
1340     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1341     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1342     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1343     &sensor_dev_attr_temp1_fault.dev_attr.attr,
1344     &sensor_dev_attr_temp3_fault.dev_attr.attr,
1345 
1346     &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
1347     &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
1348     &sensor_dev_attr_pwm3_auto_channels.dev_attr.attr,
1349     &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
1350     &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
1351     &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
1352 
1353     &sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr,
1354     &sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr,
1355     &sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr,
1356     &sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr,
1357     &sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr,
1358     &sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr,
1359     &sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr,
1360     &sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr,
1361     &sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr,
1362 
1363     &dev_attr_vrm.attr,
1364     &dev_attr_cpu0_vid.attr,
1365     &dev_attr_alarms.attr,
1366     NULL
1367 };
1368 
1369 static const struct attribute_group lm85_group = {
1370     .attrs = lm85_attributes,
1371 };
1372 
1373 static struct attribute *lm85_attributes_minctl[] = {
1374     &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,
1375     &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,
1376     &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,
1377     NULL
1378 };
1379 
1380 static const struct attribute_group lm85_group_minctl = {
1381     .attrs = lm85_attributes_minctl,
1382 };
1383 
1384 static struct attribute *lm85_attributes_temp_off[] = {
1385     &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,
1386     &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,
1387     &sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr,
1388     NULL
1389 };
1390 
1391 static const struct attribute_group lm85_group_temp_off = {
1392     .attrs = lm85_attributes_temp_off,
1393 };
1394 
1395 static struct attribute *lm85_attributes_in4[] = {
1396     &sensor_dev_attr_in4_input.dev_attr.attr,
1397     &sensor_dev_attr_in4_min.dev_attr.attr,
1398     &sensor_dev_attr_in4_max.dev_attr.attr,
1399     &sensor_dev_attr_in4_alarm.dev_attr.attr,
1400     NULL
1401 };
1402 
1403 static const struct attribute_group lm85_group_in4 = {
1404     .attrs = lm85_attributes_in4,
1405 };
1406 
1407 static struct attribute *lm85_attributes_in567[] = {
1408     &sensor_dev_attr_in5_input.dev_attr.attr,
1409     &sensor_dev_attr_in6_input.dev_attr.attr,
1410     &sensor_dev_attr_in7_input.dev_attr.attr,
1411     &sensor_dev_attr_in5_min.dev_attr.attr,
1412     &sensor_dev_attr_in6_min.dev_attr.attr,
1413     &sensor_dev_attr_in7_min.dev_attr.attr,
1414     &sensor_dev_attr_in5_max.dev_attr.attr,
1415     &sensor_dev_attr_in6_max.dev_attr.attr,
1416     &sensor_dev_attr_in7_max.dev_attr.attr,
1417     &sensor_dev_attr_in5_alarm.dev_attr.attr,
1418     &sensor_dev_attr_in6_alarm.dev_attr.attr,
1419     &sensor_dev_attr_in7_alarm.dev_attr.attr,
1420     NULL
1421 };
1422 
1423 static const struct attribute_group lm85_group_in567 = {
1424     .attrs = lm85_attributes_in567,
1425 };
1426 
1427 static void lm85_init_client(struct i2c_client *client)
1428 {
1429     int value;
1430 
1431     /* Start monitoring if needed */
1432     value = lm85_read_value(client, LM85_REG_CONFIG);
1433     if (!(value & 0x01)) {
1434         dev_info(&client->dev, "Starting monitoring\n");
1435         lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);
1436     }
1437 
1438     /* Warn about unusual configuration bits */
1439     if (value & 0x02)
1440         dev_warn(&client->dev, "Device configuration is locked\n");
1441     if (!(value & 0x04))
1442         dev_warn(&client->dev, "Device is not ready\n");
1443 }
1444 
1445 static int lm85_is_fake(struct i2c_client *client)
1446 {
1447     /*
1448      * Differenciate between real LM96000 and Winbond WPCD377I. The latter
1449      * emulate the former except that it has no hardware monitoring function
1450      * so the readings are always 0.
1451      */
1452     int i;
1453     u8 in_temp, fan;
1454 
1455     for (i = 0; i < 8; i++) {
1456         in_temp = i2c_smbus_read_byte_data(client, 0x20 + i);
1457         fan = i2c_smbus_read_byte_data(client, 0x28 + i);
1458         if (in_temp != 0x00 || fan != 0xff)
1459             return 0;
1460     }
1461 
1462     return 1;
1463 }
1464 
1465 /* Return 0 if detection is successful, -ENODEV otherwise */
1466 static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info)
1467 {
1468     struct i2c_adapter *adapter = client->adapter;
1469     int address = client->addr;
1470     const char *type_name = NULL;
1471     int company, verstep;
1472 
1473     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1474         /* We need to be able to do byte I/O */
1475         return -ENODEV;
1476     }
1477 
1478     /* Determine the chip type */
1479     company = lm85_read_value(client, LM85_REG_COMPANY);
1480     verstep = lm85_read_value(client, LM85_REG_VERSTEP);
1481 
1482     dev_dbg(&adapter->dev,
1483         "Detecting device at 0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
1484         address, company, verstep);
1485 
1486     if (company == LM85_COMPANY_NATIONAL) {
1487         switch (verstep) {
1488         case LM85_VERSTEP_LM85C:
1489             type_name = "lm85c";
1490             break;
1491         case LM85_VERSTEP_LM85B:
1492             type_name = "lm85b";
1493             break;
1494         case LM85_VERSTEP_LM96000_1:
1495         case LM85_VERSTEP_LM96000_2:
1496             /* Check for Winbond WPCD377I */
1497             if (lm85_is_fake(client)) {
1498                 dev_dbg(&adapter->dev,
1499                     "Found Winbond WPCD377I, ignoring\n");
1500                 return -ENODEV;
1501             }
1502             type_name = "lm96000";
1503             break;
1504         }
1505     } else if (company == LM85_COMPANY_ANALOG_DEV) {
1506         switch (verstep) {
1507         case LM85_VERSTEP_ADM1027:
1508             type_name = "adm1027";
1509             break;
1510         case LM85_VERSTEP_ADT7463:
1511         case LM85_VERSTEP_ADT7463C:
1512             type_name = "adt7463";
1513             break;
1514         case LM85_VERSTEP_ADT7468_1:
1515         case LM85_VERSTEP_ADT7468_2:
1516             type_name = "adt7468";
1517             break;
1518         }
1519     } else if (company == LM85_COMPANY_SMSC) {
1520         switch (verstep) {
1521         case LM85_VERSTEP_EMC6D100_A0:
1522         case LM85_VERSTEP_EMC6D100_A1:
1523             /* Note: we can't tell a '100 from a '101 */
1524             type_name = "emc6d100";
1525             break;
1526         case LM85_VERSTEP_EMC6D102:
1527             type_name = "emc6d102";
1528             break;
1529         case LM85_VERSTEP_EMC6D103_A0:
1530         case LM85_VERSTEP_EMC6D103_A1:
1531             type_name = "emc6d103";
1532             break;
1533         case LM85_VERSTEP_EMC6D103S:
1534             type_name = "emc6d103s";
1535             break;
1536         }
1537     }
1538 
1539     if (!type_name)
1540         return -ENODEV;
1541 
1542     strlcpy(info->type, type_name, I2C_NAME_SIZE);
1543 
1544     return 0;
1545 }
1546 
1547 static const struct i2c_device_id lm85_id[];
1548 
1549 static int lm85_probe(struct i2c_client *client)
1550 {
1551     struct device *dev = &client->dev;
1552     struct device *hwmon_dev;
1553     struct lm85_data *data;
1554     int idx = 0;
1555 
1556     data = devm_kzalloc(dev, sizeof(struct lm85_data), GFP_KERNEL);
1557     if (!data)
1558         return -ENOMEM;
1559 
1560     data->client = client;
1561     if (client->dev.of_node)
1562         data->type = (enum chips)of_device_get_match_data(&client->dev);
1563     else
1564         data->type = i2c_match_id(lm85_id, client)->driver_data;
1565     mutex_init(&data->update_lock);
1566 
1567     /* Fill in the chip specific driver values */
1568     switch (data->type) {
1569     case adm1027:
1570     case adt7463:
1571     case adt7468:
1572     case emc6d100:
1573     case emc6d102:
1574     case emc6d103:
1575     case emc6d103s:
1576         data->freq_map = adm1027_freq_map;
1577         data->freq_map_size = ARRAY_SIZE(adm1027_freq_map);
1578         break;
1579     case lm96000:
1580         data->freq_map = lm96000_freq_map;
1581         data->freq_map_size = ARRAY_SIZE(lm96000_freq_map);
1582         break;
1583     default:
1584         data->freq_map = lm85_freq_map;
1585         data->freq_map_size = ARRAY_SIZE(lm85_freq_map);
1586     }
1587 
1588     /* Set the VRM version */
1589     data->vrm = vid_which_vrm();
1590 
1591     /* Initialize the LM85 chip */
1592     lm85_init_client(client);
1593 
1594     /* sysfs hooks */
1595     data->groups[idx++] = &lm85_group;
1596 
1597     /* minctl and temp_off exist on all chips except emc6d103s */
1598     if (data->type != emc6d103s) {
1599         data->groups[idx++] = &lm85_group_minctl;
1600         data->groups[idx++] = &lm85_group_temp_off;
1601     }
1602 
1603     /*
1604      * The ADT7463/68 have an optional VRM 10 mode where pin 21 is used
1605      * as a sixth digital VID input rather than an analog input.
1606      */
1607     if (data->type == adt7463 || data->type == adt7468) {
1608         u8 vid = lm85_read_value(client, LM85_REG_VID);
1609         if (vid & 0x80)
1610             data->has_vid5 = true;
1611     }
1612 
1613     if (!data->has_vid5)
1614         data->groups[idx++] = &lm85_group_in4;
1615 
1616     /* The EMC6D100 has 3 additional voltage inputs */
1617     if (data->type == emc6d100)
1618         data->groups[idx++] = &lm85_group_in567;
1619 
1620     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1621                                data, data->groups);
1622     return PTR_ERR_OR_ZERO(hwmon_dev);
1623 }
1624 
1625 static const struct i2c_device_id lm85_id[] = {
1626     { "adm1027", adm1027 },
1627     { "adt7463", adt7463 },
1628     { "adt7468", adt7468 },
1629     { "lm85", lm85 },
1630     { "lm85b", lm85 },
1631     { "lm85c", lm85 },
1632     { "lm96000", lm96000 },
1633     { "emc6d100", emc6d100 },
1634     { "emc6d101", emc6d100 },
1635     { "emc6d102", emc6d102 },
1636     { "emc6d103", emc6d103 },
1637     { "emc6d103s", emc6d103s },
1638     { }
1639 };
1640 MODULE_DEVICE_TABLE(i2c, lm85_id);
1641 
1642 static const struct of_device_id __maybe_unused lm85_of_match[] = {
1643     {
1644         .compatible = "adi,adm1027",
1645         .data = (void *)adm1027
1646     },
1647     {
1648         .compatible = "adi,adt7463",
1649         .data = (void *)adt7463
1650     },
1651     {
1652         .compatible = "adi,adt7468",
1653         .data = (void *)adt7468
1654     },
1655     {
1656         .compatible = "national,lm85",
1657         .data = (void *)lm85
1658     },
1659     {
1660         .compatible = "national,lm85b",
1661         .data = (void *)lm85
1662     },
1663     {
1664         .compatible = "national,lm85c",
1665         .data = (void *)lm85
1666     },
1667     {
1668         .compatible = "ti,lm96000",
1669         .data = (void *)lm96000
1670     },
1671     {
1672         .compatible = "smsc,emc6d100",
1673         .data = (void *)emc6d100
1674     },
1675     {
1676         .compatible = "smsc,emc6d101",
1677         .data = (void *)emc6d100
1678     },
1679     {
1680         .compatible = "smsc,emc6d102",
1681         .data = (void *)emc6d102
1682     },
1683     {
1684         .compatible = "smsc,emc6d103",
1685         .data = (void *)emc6d103
1686     },
1687     {
1688         .compatible = "smsc,emc6d103s",
1689         .data = (void *)emc6d103s
1690     },
1691     { },
1692 };
1693 MODULE_DEVICE_TABLE(of, lm85_of_match);
1694 
1695 static struct i2c_driver lm85_driver = {
1696     .class      = I2C_CLASS_HWMON,
1697     .driver = {
1698         .name   = "lm85",
1699         .of_match_table = of_match_ptr(lm85_of_match),
1700     },
1701     .probe_new  = lm85_probe,
1702     .id_table   = lm85_id,
1703     .detect     = lm85_detect,
1704     .address_list   = normal_i2c,
1705 };
1706 
1707 module_i2c_driver(lm85_driver);
1708 
1709 MODULE_LICENSE("GPL");
1710 MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
1711     "Margit Schubert-While <margitsw@t-online.de>, "
1712     "Justin Thiessen <jthiessen@penguincomputing.com>");
1713 MODULE_DESCRIPTION("LM85-B, LM85-C 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!