Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * lm63.c - driver for the National Semiconductor LM63 temperature sensor
0004  *          with integrated fan control
0005  * Copyright (C) 2004-2008  Jean Delvare <jdelvare@suse.de>
0006  * Based on the lm90 driver.
0007  *
0008  * The LM63 is a sensor chip made by National Semiconductor. It measures
0009  * two temperatures (its own and one external one) and the speed of one
0010  * fan, those speed it can additionally control. Complete datasheet can be
0011  * obtained from National's website at:
0012  *   http://www.national.com/pf/LM/LM63.html
0013  *
0014  * The LM63 is basically an LM86 with fan speed monitoring and control
0015  * capabilities added. It misses some of the LM86 features though:
0016  *  - No low limit for local temperature.
0017  *  - No critical limit for local temperature.
0018  *  - Critical limit for remote temperature can be changed only once. We
0019  *    will consider that the critical limit is read-only.
0020  *
0021  * The datasheet isn't very clear about what the tachometer reading is.
0022  * I had a explanation from National Semiconductor though. The two lower
0023  * bits of the read value have to be masked out. The value is still 16 bit
0024  * in width.
0025  */
0026 
0027 #include <linux/module.h>
0028 #include <linux/init.h>
0029 #include <linux/slab.h>
0030 #include <linux/jiffies.h>
0031 #include <linux/i2c.h>
0032 #include <linux/hwmon-sysfs.h>
0033 #include <linux/hwmon.h>
0034 #include <linux/err.h>
0035 #include <linux/mutex.h>
0036 #include <linux/of_device.h>
0037 #include <linux/sysfs.h>
0038 #include <linux/types.h>
0039 
0040 /*
0041  * Addresses to scan
0042  * Address is fully defined internally and cannot be changed except for
0043  * LM64 which has one pin dedicated to address selection.
0044  * LM63 and LM96163 have address 0x4c.
0045  * LM64 can have address 0x18 or 0x4e.
0046  */
0047 
0048 static const unsigned short normal_i2c[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END };
0049 
0050 /*
0051  * The LM63 registers
0052  */
0053 
0054 #define LM63_REG_CONFIG1        0x03
0055 #define LM63_REG_CONVRATE       0x04
0056 #define LM63_REG_CONFIG2        0xBF
0057 #define LM63_REG_CONFIG_FAN     0x4A
0058 
0059 #define LM63_REG_TACH_COUNT_MSB     0x47
0060 #define LM63_REG_TACH_COUNT_LSB     0x46
0061 #define LM63_REG_TACH_LIMIT_MSB     0x49
0062 #define LM63_REG_TACH_LIMIT_LSB     0x48
0063 
0064 #define LM63_REG_PWM_VALUE      0x4C
0065 #define LM63_REG_PWM_FREQ       0x4D
0066 #define LM63_REG_LUT_TEMP_HYST      0x4F
0067 #define LM63_REG_LUT_TEMP(nr)       (0x50 + 2 * (nr))
0068 #define LM63_REG_LUT_PWM(nr)        (0x51 + 2 * (nr))
0069 
0070 #define LM63_REG_LOCAL_TEMP     0x00
0071 #define LM63_REG_LOCAL_HIGH     0x05
0072 
0073 #define LM63_REG_REMOTE_TEMP_MSB    0x01
0074 #define LM63_REG_REMOTE_TEMP_LSB    0x10
0075 #define LM63_REG_REMOTE_OFFSET_MSB  0x11
0076 #define LM63_REG_REMOTE_OFFSET_LSB  0x12
0077 #define LM63_REG_REMOTE_HIGH_MSB    0x07
0078 #define LM63_REG_REMOTE_HIGH_LSB    0x13
0079 #define LM63_REG_REMOTE_LOW_MSB     0x08
0080 #define LM63_REG_REMOTE_LOW_LSB     0x14
0081 #define LM63_REG_REMOTE_TCRIT       0x19
0082 #define LM63_REG_REMOTE_TCRIT_HYST  0x21
0083 
0084 #define LM63_REG_ALERT_STATUS       0x02
0085 #define LM63_REG_ALERT_MASK     0x16
0086 
0087 #define LM63_REG_MAN_ID         0xFE
0088 #define LM63_REG_CHIP_ID        0xFF
0089 
0090 #define LM96163_REG_TRUTHERM        0x30
0091 #define LM96163_REG_REMOTE_TEMP_U_MSB   0x31
0092 #define LM96163_REG_REMOTE_TEMP_U_LSB   0x32
0093 #define LM96163_REG_CONFIG_ENHANCED 0x45
0094 
0095 #define LM63_MAX_CONVRATE       9
0096 
0097 #define LM63_MAX_CONVRATE_HZ        32
0098 #define LM96163_MAX_CONVRATE_HZ     26
0099 
0100 /*
0101  * Conversions and various macros
0102  * For tachometer counts, the LM63 uses 16-bit values.
0103  * For local temperature and high limit, remote critical limit and hysteresis
0104  * value, it uses signed 8-bit values with LSB = 1 degree Celsius.
0105  * For remote temperature, low and high limits, it uses signed 11-bit values
0106  * with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
0107  * For LM64 the actual remote diode temperature is 16 degree Celsius higher
0108  * than the register reading. Remote temperature setpoints have to be
0109  * adapted accordingly.
0110  */
0111 
0112 #define FAN_FROM_REG(reg)   ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
0113                  5400000 / (reg))
0114 #define FAN_TO_REG(val)     ((val) <= 82 ? 0xFFFC : \
0115                  (5400000 / (val)) & 0xFFFC)
0116 #define TEMP8_FROM_REG(reg) ((reg) * 1000)
0117 #define TEMP8_TO_REG(val)   DIV_ROUND_CLOSEST(clamp_val((val), -128000, \
0118                                 127000), 1000)
0119 #define TEMP8U_TO_REG(val)  DIV_ROUND_CLOSEST(clamp_val((val), 0, \
0120                                 255000), 1000)
0121 #define TEMP11_FROM_REG(reg)    ((reg) / 32 * 125)
0122 #define TEMP11_TO_REG(val)  (DIV_ROUND_CLOSEST(clamp_val((val), -128000, \
0123                                  127875), 125) * 32)
0124 #define TEMP11U_TO_REG(val) (DIV_ROUND_CLOSEST(clamp_val((val), 0, \
0125                                  255875), 125) * 32)
0126 #define HYST_TO_REG(val)    DIV_ROUND_CLOSEST(clamp_val((val), 0, 127000), \
0127                           1000)
0128 
0129 #define UPDATE_INTERVAL(max, rate) \
0130             ((1000 << (LM63_MAX_CONVRATE - (rate))) / (max))
0131 
0132 enum chips { lm63, lm64, lm96163 };
0133 
0134 /*
0135  * Client data (each client gets its own)
0136  */
0137 
0138 struct lm63_data {
0139     struct i2c_client *client;
0140     struct mutex update_lock;
0141     const struct attribute_group *groups[5];
0142     bool valid; /* false until following fields are valid */
0143     char lut_valid; /* zero until lut fields are valid */
0144     unsigned long last_updated; /* in jiffies */
0145     unsigned long lut_last_updated; /* in jiffies */
0146     enum chips kind;
0147     int temp2_offset;
0148 
0149     int update_interval;    /* in milliseconds */
0150     int max_convrate_hz;
0151     int lut_size;       /* 8 or 12 */
0152 
0153     /* registers values */
0154     u8 config, config_fan;
0155     u16 fan[2]; /* 0: input
0156                1: low limit */
0157     u8 pwm1_freq;
0158     u8 pwm1[13];    /* 0: current output
0159                1-12: lookup table */
0160     s8 temp8[15];   /* 0: local input
0161                1: local high limit
0162                2: remote critical limit
0163                3-14: lookup table */
0164     s16 temp11[4];  /* 0: remote input
0165                1: remote low limit
0166                2: remote high limit
0167                3: remote offset */
0168     u16 temp11u;    /* remote input (unsigned) */
0169     u8 temp2_crit_hyst;
0170     u8 lut_temp_hyst;
0171     u8 alarms;
0172     bool pwm_highres;
0173     bool lut_temp_highres;
0174     bool remote_unsigned; /* true if unsigned remote upper limits */
0175     bool trutherm;
0176 };
0177 
0178 static inline int temp8_from_reg(struct lm63_data *data, int nr)
0179 {
0180     if (data->remote_unsigned)
0181         return TEMP8_FROM_REG((u8)data->temp8[nr]);
0182     return TEMP8_FROM_REG(data->temp8[nr]);
0183 }
0184 
0185 static inline int lut_temp_from_reg(struct lm63_data *data, int nr)
0186 {
0187     return data->temp8[nr] * (data->lut_temp_highres ? 500 : 1000);
0188 }
0189 
0190 static inline int lut_temp_to_reg(struct lm63_data *data, long val)
0191 {
0192     val -= data->temp2_offset;
0193     if (data->lut_temp_highres)
0194         return DIV_ROUND_CLOSEST(clamp_val(val, 0, 127500), 500);
0195     else
0196         return DIV_ROUND_CLOSEST(clamp_val(val, 0, 127000), 1000);
0197 }
0198 
0199 /*
0200  * Update the lookup table register cache.
0201  * client->update_lock must be held when calling this function.
0202  */
0203 static void lm63_update_lut(struct lm63_data *data)
0204 {
0205     struct i2c_client *client = data->client;
0206     int i;
0207 
0208     if (time_after(jiffies, data->lut_last_updated + 5 * HZ) ||
0209         !data->lut_valid) {
0210         for (i = 0; i < data->lut_size; i++) {
0211             data->pwm1[1 + i] = i2c_smbus_read_byte_data(client,
0212                         LM63_REG_LUT_PWM(i));
0213             data->temp8[3 + i] = i2c_smbus_read_byte_data(client,
0214                          LM63_REG_LUT_TEMP(i));
0215         }
0216         data->lut_temp_hyst = i2c_smbus_read_byte_data(client,
0217                       LM63_REG_LUT_TEMP_HYST);
0218 
0219         data->lut_last_updated = jiffies;
0220         data->lut_valid = 1;
0221     }
0222 }
0223 
0224 static struct lm63_data *lm63_update_device(struct device *dev)
0225 {
0226     struct lm63_data *data = dev_get_drvdata(dev);
0227     struct i2c_client *client = data->client;
0228     unsigned long next_update;
0229 
0230     mutex_lock(&data->update_lock);
0231 
0232     next_update = data->last_updated +
0233               msecs_to_jiffies(data->update_interval);
0234     if (time_after(jiffies, next_update) || !data->valid) {
0235         if (data->config & 0x04) { /* tachometer enabled  */
0236             /* order matters for fan1_input */
0237             data->fan[0] = i2c_smbus_read_byte_data(client,
0238                        LM63_REG_TACH_COUNT_LSB) & 0xFC;
0239             data->fan[0] |= i2c_smbus_read_byte_data(client,
0240                     LM63_REG_TACH_COUNT_MSB) << 8;
0241             data->fan[1] = (i2c_smbus_read_byte_data(client,
0242                     LM63_REG_TACH_LIMIT_LSB) & 0xFC)
0243                      | (i2c_smbus_read_byte_data(client,
0244                     LM63_REG_TACH_LIMIT_MSB) << 8);
0245         }
0246 
0247         data->pwm1_freq = i2c_smbus_read_byte_data(client,
0248                   LM63_REG_PWM_FREQ);
0249         if (data->pwm1_freq == 0)
0250             data->pwm1_freq = 1;
0251         data->pwm1[0] = i2c_smbus_read_byte_data(client,
0252                 LM63_REG_PWM_VALUE);
0253 
0254         data->temp8[0] = i2c_smbus_read_byte_data(client,
0255                  LM63_REG_LOCAL_TEMP);
0256         data->temp8[1] = i2c_smbus_read_byte_data(client,
0257                  LM63_REG_LOCAL_HIGH);
0258 
0259         /* order matters for temp2_input */
0260         data->temp11[0] = i2c_smbus_read_byte_data(client,
0261                   LM63_REG_REMOTE_TEMP_MSB) << 8;
0262         data->temp11[0] |= i2c_smbus_read_byte_data(client,
0263                    LM63_REG_REMOTE_TEMP_LSB);
0264         data->temp11[1] = (i2c_smbus_read_byte_data(client,
0265                   LM63_REG_REMOTE_LOW_MSB) << 8)
0266                 | i2c_smbus_read_byte_data(client,
0267                   LM63_REG_REMOTE_LOW_LSB);
0268         data->temp11[2] = (i2c_smbus_read_byte_data(client,
0269                   LM63_REG_REMOTE_HIGH_MSB) << 8)
0270                 | i2c_smbus_read_byte_data(client,
0271                   LM63_REG_REMOTE_HIGH_LSB);
0272         data->temp11[3] = (i2c_smbus_read_byte_data(client,
0273                   LM63_REG_REMOTE_OFFSET_MSB) << 8)
0274                 | i2c_smbus_read_byte_data(client,
0275                   LM63_REG_REMOTE_OFFSET_LSB);
0276 
0277         if (data->kind == lm96163)
0278             data->temp11u = (i2c_smbus_read_byte_data(client,
0279                     LM96163_REG_REMOTE_TEMP_U_MSB) << 8)
0280                       | i2c_smbus_read_byte_data(client,
0281                     LM96163_REG_REMOTE_TEMP_U_LSB);
0282 
0283         data->temp8[2] = i2c_smbus_read_byte_data(client,
0284                  LM63_REG_REMOTE_TCRIT);
0285         data->temp2_crit_hyst = i2c_smbus_read_byte_data(client,
0286                     LM63_REG_REMOTE_TCRIT_HYST);
0287 
0288         data->alarms = i2c_smbus_read_byte_data(client,
0289                    LM63_REG_ALERT_STATUS) & 0x7F;
0290 
0291         data->last_updated = jiffies;
0292         data->valid = true;
0293     }
0294 
0295     lm63_update_lut(data);
0296 
0297     mutex_unlock(&data->update_lock);
0298 
0299     return data;
0300 }
0301 
0302 /*
0303  * Trip points in the lookup table should be in ascending order for both
0304  * temperatures and PWM output values.
0305  */
0306 static int lm63_lut_looks_bad(struct device *dev, struct lm63_data *data)
0307 {
0308     int i;
0309 
0310     mutex_lock(&data->update_lock);
0311     lm63_update_lut(data);
0312 
0313     for (i = 1; i < data->lut_size; i++) {
0314         if (data->pwm1[1 + i - 1] > data->pwm1[1 + i]
0315          || data->temp8[3 + i - 1] > data->temp8[3 + i]) {
0316             dev_warn(dev,
0317                  "Lookup table doesn't look sane (check entries %d and %d)\n",
0318                  i, i + 1);
0319             break;
0320         }
0321     }
0322     mutex_unlock(&data->update_lock);
0323 
0324     return i == data->lut_size ? 0 : 1;
0325 }
0326 
0327 /*
0328  * Sysfs callback functions and files
0329  */
0330 
0331 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
0332             char *buf)
0333 {
0334     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0335     struct lm63_data *data = lm63_update_device(dev);
0336     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index]));
0337 }
0338 
0339 static ssize_t set_fan(struct device *dev, struct device_attribute *dummy,
0340                const char *buf, size_t count)
0341 {
0342     struct lm63_data *data = dev_get_drvdata(dev);
0343     struct i2c_client *client = data->client;
0344     unsigned long val;
0345     int err;
0346 
0347     err = kstrtoul(buf, 10, &val);
0348     if (err)
0349         return err;
0350 
0351     mutex_lock(&data->update_lock);
0352     data->fan[1] = FAN_TO_REG(val);
0353     i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_LSB,
0354                   data->fan[1] & 0xFF);
0355     i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_MSB,
0356                   data->fan[1] >> 8);
0357     mutex_unlock(&data->update_lock);
0358     return count;
0359 }
0360 
0361 static ssize_t show_pwm1(struct device *dev, struct device_attribute *devattr,
0362              char *buf)
0363 {
0364     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0365     struct lm63_data *data = lm63_update_device(dev);
0366     int nr = attr->index;
0367     int pwm;
0368 
0369     if (data->pwm_highres)
0370         pwm = data->pwm1[nr];
0371     else
0372         pwm = data->pwm1[nr] >= 2 * data->pwm1_freq ?
0373                255 : (data->pwm1[nr] * 255 + data->pwm1_freq) /
0374                (2 * data->pwm1_freq);
0375 
0376     return sprintf(buf, "%d\n", pwm);
0377 }
0378 
0379 static ssize_t set_pwm1(struct device *dev, struct device_attribute *devattr,
0380             const char *buf, size_t count)
0381 {
0382     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0383     struct lm63_data *data = dev_get_drvdata(dev);
0384     struct i2c_client *client = data->client;
0385     int nr = attr->index;
0386     unsigned long val;
0387     int err;
0388     u8 reg;
0389 
0390     if (!(data->config_fan & 0x20)) /* register is read-only */
0391         return -EPERM;
0392 
0393     err = kstrtoul(buf, 10, &val);
0394     if (err)
0395         return err;
0396 
0397     reg = nr ? LM63_REG_LUT_PWM(nr - 1) : LM63_REG_PWM_VALUE;
0398     val = clamp_val(val, 0, 255);
0399 
0400     mutex_lock(&data->update_lock);
0401     data->pwm1[nr] = data->pwm_highres ? val :
0402             (val * data->pwm1_freq * 2 + 127) / 255;
0403     i2c_smbus_write_byte_data(client, reg, data->pwm1[nr]);
0404     mutex_unlock(&data->update_lock);
0405     return count;
0406 }
0407 
0408 static ssize_t pwm1_enable_show(struct device *dev,
0409                 struct device_attribute *dummy, char *buf)
0410 {
0411     struct lm63_data *data = lm63_update_device(dev);
0412     return sprintf(buf, "%d\n", data->config_fan & 0x20 ? 1 : 2);
0413 }
0414 
0415 static ssize_t pwm1_enable_store(struct device *dev,
0416                  struct device_attribute *dummy,
0417                  const char *buf, size_t count)
0418 {
0419     struct lm63_data *data = dev_get_drvdata(dev);
0420     struct i2c_client *client = data->client;
0421     unsigned long val;
0422     int err;
0423 
0424     err = kstrtoul(buf, 10, &val);
0425     if (err)
0426         return err;
0427     if (val < 1 || val > 2)
0428         return -EINVAL;
0429 
0430     /*
0431      * Only let the user switch to automatic mode if the lookup table
0432      * looks sane.
0433      */
0434     if (val == 2 && lm63_lut_looks_bad(dev, data))
0435         return -EPERM;
0436 
0437     mutex_lock(&data->update_lock);
0438     data->config_fan = i2c_smbus_read_byte_data(client,
0439                             LM63_REG_CONFIG_FAN);
0440     if (val == 1)
0441         data->config_fan |= 0x20;
0442     else
0443         data->config_fan &= ~0x20;
0444     i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN,
0445                   data->config_fan);
0446     mutex_unlock(&data->update_lock);
0447     return count;
0448 }
0449 
0450 /*
0451  * There are 8bit registers for both local(temp1) and remote(temp2) sensor.
0452  * For remote sensor registers temp2_offset has to be considered,
0453  * for local sensor it must not.
0454  * So we need separate 8bit accessors for local and remote sensor.
0455  */
0456 static ssize_t show_local_temp8(struct device *dev,
0457                 struct device_attribute *devattr,
0458                 char *buf)
0459 {
0460     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0461     struct lm63_data *data = lm63_update_device(dev);
0462     return sprintf(buf, "%d\n", TEMP8_FROM_REG(data->temp8[attr->index]));
0463 }
0464 
0465 static ssize_t show_remote_temp8(struct device *dev,
0466                  struct device_attribute *devattr,
0467                  char *buf)
0468 {
0469     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0470     struct lm63_data *data = lm63_update_device(dev);
0471     return sprintf(buf, "%d\n", temp8_from_reg(data, attr->index)
0472                + data->temp2_offset);
0473 }
0474 
0475 static ssize_t show_lut_temp(struct device *dev,
0476                   struct device_attribute *devattr,
0477                   char *buf)
0478 {
0479     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0480     struct lm63_data *data = lm63_update_device(dev);
0481     return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
0482                + data->temp2_offset);
0483 }
0484 
0485 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
0486              const char *buf, size_t count)
0487 {
0488     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0489     struct lm63_data *data = dev_get_drvdata(dev);
0490     struct i2c_client *client = data->client;
0491     int nr = attr->index;
0492     long val;
0493     int err;
0494     int temp;
0495     u8 reg;
0496 
0497     err = kstrtol(buf, 10, &val);
0498     if (err)
0499         return err;
0500 
0501     mutex_lock(&data->update_lock);
0502     switch (nr) {
0503     case 2:
0504         reg = LM63_REG_REMOTE_TCRIT;
0505         if (data->remote_unsigned)
0506             temp = TEMP8U_TO_REG(val - data->temp2_offset);
0507         else
0508             temp = TEMP8_TO_REG(val - data->temp2_offset);
0509         break;
0510     case 1:
0511         reg = LM63_REG_LOCAL_HIGH;
0512         temp = TEMP8_TO_REG(val);
0513         break;
0514     default:    /* lookup table */
0515         reg = LM63_REG_LUT_TEMP(nr - 3);
0516         temp = lut_temp_to_reg(data, val);
0517     }
0518     data->temp8[nr] = temp;
0519     i2c_smbus_write_byte_data(client, reg, temp);
0520     mutex_unlock(&data->update_lock);
0521     return count;
0522 }
0523 
0524 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
0525                char *buf)
0526 {
0527     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0528     struct lm63_data *data = lm63_update_device(dev);
0529     int nr = attr->index;
0530     int temp;
0531 
0532     if (!nr) {
0533         /*
0534          * Use unsigned temperature unless its value is zero.
0535          * If it is zero, use signed temperature.
0536          */
0537         if (data->temp11u)
0538             temp = TEMP11_FROM_REG(data->temp11u);
0539         else
0540             temp = TEMP11_FROM_REG(data->temp11[nr]);
0541     } else {
0542         if (data->remote_unsigned && nr == 2)
0543             temp = TEMP11_FROM_REG((u16)data->temp11[nr]);
0544         else
0545             temp = TEMP11_FROM_REG(data->temp11[nr]);
0546     }
0547     return sprintf(buf, "%d\n", temp + data->temp2_offset);
0548 }
0549 
0550 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
0551               const char *buf, size_t count)
0552 {
0553     static const u8 reg[6] = {
0554         LM63_REG_REMOTE_LOW_MSB,
0555         LM63_REG_REMOTE_LOW_LSB,
0556         LM63_REG_REMOTE_HIGH_MSB,
0557         LM63_REG_REMOTE_HIGH_LSB,
0558         LM63_REG_REMOTE_OFFSET_MSB,
0559         LM63_REG_REMOTE_OFFSET_LSB,
0560     };
0561 
0562     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0563     struct lm63_data *data = dev_get_drvdata(dev);
0564     struct i2c_client *client = data->client;
0565     long val;
0566     int err;
0567     int nr = attr->index;
0568 
0569     err = kstrtol(buf, 10, &val);
0570     if (err)
0571         return err;
0572 
0573     mutex_lock(&data->update_lock);
0574     if (data->remote_unsigned && nr == 2)
0575         data->temp11[nr] = TEMP11U_TO_REG(val - data->temp2_offset);
0576     else
0577         data->temp11[nr] = TEMP11_TO_REG(val - data->temp2_offset);
0578 
0579     i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
0580                   data->temp11[nr] >> 8);
0581     i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
0582                   data->temp11[nr] & 0xff);
0583     mutex_unlock(&data->update_lock);
0584     return count;
0585 }
0586 
0587 /*
0588  * Hysteresis register holds a relative value, while we want to present
0589  * an absolute to user-space
0590  */
0591 static ssize_t temp2_crit_hyst_show(struct device *dev,
0592                     struct device_attribute *dummy, char *buf)
0593 {
0594     struct lm63_data *data = lm63_update_device(dev);
0595     return sprintf(buf, "%d\n", temp8_from_reg(data, 2)
0596                + data->temp2_offset
0597                - TEMP8_FROM_REG(data->temp2_crit_hyst));
0598 }
0599 
0600 static ssize_t show_lut_temp_hyst(struct device *dev,
0601                   struct device_attribute *devattr, char *buf)
0602 {
0603     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0604     struct lm63_data *data = lm63_update_device(dev);
0605 
0606     return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
0607                + data->temp2_offset
0608                - TEMP8_FROM_REG(data->lut_temp_hyst));
0609 }
0610 
0611 /*
0612  * And now the other way around, user-space provides an absolute
0613  * hysteresis value and we have to store a relative one
0614  */
0615 static ssize_t temp2_crit_hyst_store(struct device *dev,
0616                      struct device_attribute *dummy,
0617                      const char *buf, size_t count)
0618 {
0619     struct lm63_data *data = dev_get_drvdata(dev);
0620     struct i2c_client *client = data->client;
0621     long val;
0622     int err;
0623     long hyst;
0624 
0625     err = kstrtol(buf, 10, &val);
0626     if (err)
0627         return err;
0628 
0629     mutex_lock(&data->update_lock);
0630     hyst = temp8_from_reg(data, 2) + data->temp2_offset - val;
0631     i2c_smbus_write_byte_data(client, LM63_REG_REMOTE_TCRIT_HYST,
0632                   HYST_TO_REG(hyst));
0633     mutex_unlock(&data->update_lock);
0634     return count;
0635 }
0636 
0637 /*
0638  * Set conversion rate.
0639  * client->update_lock must be held when calling this function.
0640  */
0641 static void lm63_set_convrate(struct lm63_data *data, unsigned int interval)
0642 {
0643     struct i2c_client *client = data->client;
0644     unsigned int update_interval;
0645     int i;
0646 
0647     /* Shift calculations to avoid rounding errors */
0648     interval <<= 6;
0649 
0650     /* find the nearest update rate */
0651     update_interval = (1 << (LM63_MAX_CONVRATE + 6)) * 1000
0652       / data->max_convrate_hz;
0653     for (i = 0; i < LM63_MAX_CONVRATE; i++, update_interval >>= 1)
0654         if (interval >= update_interval * 3 / 4)
0655             break;
0656 
0657     i2c_smbus_write_byte_data(client, LM63_REG_CONVRATE, i);
0658     data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz, i);
0659 }
0660 
0661 static ssize_t update_interval_show(struct device *dev,
0662                     struct device_attribute *attr, char *buf)
0663 {
0664     struct lm63_data *data = dev_get_drvdata(dev);
0665 
0666     return sprintf(buf, "%u\n", data->update_interval);
0667 }
0668 
0669 static ssize_t update_interval_store(struct device *dev,
0670                      struct device_attribute *attr,
0671                      const char *buf, size_t count)
0672 {
0673     struct lm63_data *data = dev_get_drvdata(dev);
0674     unsigned long val;
0675     int err;
0676 
0677     err = kstrtoul(buf, 10, &val);
0678     if (err)
0679         return err;
0680 
0681     mutex_lock(&data->update_lock);
0682     lm63_set_convrate(data, clamp_val(val, 0, 100000));
0683     mutex_unlock(&data->update_lock);
0684 
0685     return count;
0686 }
0687 
0688 static ssize_t temp2_type_show(struct device *dev,
0689                    struct device_attribute *attr, char *buf)
0690 {
0691     struct lm63_data *data = dev_get_drvdata(dev);
0692 
0693     return sprintf(buf, data->trutherm ? "1\n" : "2\n");
0694 }
0695 
0696 static ssize_t temp2_type_store(struct device *dev,
0697                 struct device_attribute *attr,
0698                 const char *buf, size_t count)
0699 {
0700     struct lm63_data *data = dev_get_drvdata(dev);
0701     struct i2c_client *client = data->client;
0702     unsigned long val;
0703     int ret;
0704     u8 reg;
0705 
0706     ret = kstrtoul(buf, 10, &val);
0707     if (ret < 0)
0708         return ret;
0709     if (val != 1 && val != 2)
0710         return -EINVAL;
0711 
0712     mutex_lock(&data->update_lock);
0713     data->trutherm = val == 1;
0714     reg = i2c_smbus_read_byte_data(client, LM96163_REG_TRUTHERM) & ~0x02;
0715     i2c_smbus_write_byte_data(client, LM96163_REG_TRUTHERM,
0716                   reg | (data->trutherm ? 0x02 : 0x00));
0717     data->valid = false;
0718     mutex_unlock(&data->update_lock);
0719 
0720     return count;
0721 }
0722 
0723 static ssize_t alarms_show(struct device *dev, struct device_attribute *dummy,
0724                char *buf)
0725 {
0726     struct lm63_data *data = lm63_update_device(dev);
0727     return sprintf(buf, "%u\n", data->alarms);
0728 }
0729 
0730 static ssize_t show_alarm(struct device *dev, struct device_attribute *devattr,
0731               char *buf)
0732 {
0733     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0734     struct lm63_data *data = lm63_update_device(dev);
0735     int bitnr = attr->index;
0736 
0737     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0738 }
0739 
0740 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
0741 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan,
0742     set_fan, 1);
0743 
0744 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm1, set_pwm1, 0);
0745 static DEVICE_ATTR_RW(pwm1_enable);
0746 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
0747     show_pwm1, set_pwm1, 1);
0748 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
0749     show_lut_temp, set_temp8, 3);
0750 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp_hyst, S_IRUGO,
0751     show_lut_temp_hyst, NULL, 3);
0752 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
0753     show_pwm1, set_pwm1, 2);
0754 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IWUSR | S_IRUGO,
0755     show_lut_temp, set_temp8, 4);
0756 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp_hyst, S_IRUGO,
0757     show_lut_temp_hyst, NULL, 4);
0758 static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IWUSR | S_IRUGO,
0759     show_pwm1, set_pwm1, 3);
0760 static SENSOR_DEVICE_ATTR(pwm1_auto_point3_temp, S_IWUSR | S_IRUGO,
0761     show_lut_temp, set_temp8, 5);
0762 static SENSOR_DEVICE_ATTR(pwm1_auto_point3_temp_hyst, S_IRUGO,
0763     show_lut_temp_hyst, NULL, 5);
0764 static SENSOR_DEVICE_ATTR(pwm1_auto_point4_pwm, S_IWUSR | S_IRUGO,
0765     show_pwm1, set_pwm1, 4);
0766 static SENSOR_DEVICE_ATTR(pwm1_auto_point4_temp, S_IWUSR | S_IRUGO,
0767     show_lut_temp, set_temp8, 6);
0768 static SENSOR_DEVICE_ATTR(pwm1_auto_point4_temp_hyst, S_IRUGO,
0769     show_lut_temp_hyst, NULL, 6);
0770 static SENSOR_DEVICE_ATTR(pwm1_auto_point5_pwm, S_IWUSR | S_IRUGO,
0771     show_pwm1, set_pwm1, 5);
0772 static SENSOR_DEVICE_ATTR(pwm1_auto_point5_temp, S_IWUSR | S_IRUGO,
0773     show_lut_temp, set_temp8, 7);
0774 static SENSOR_DEVICE_ATTR(pwm1_auto_point5_temp_hyst, S_IRUGO,
0775     show_lut_temp_hyst, NULL, 7);
0776 static SENSOR_DEVICE_ATTR(pwm1_auto_point6_pwm, S_IWUSR | S_IRUGO,
0777     show_pwm1, set_pwm1, 6);
0778 static SENSOR_DEVICE_ATTR(pwm1_auto_point6_temp, S_IWUSR | S_IRUGO,
0779     show_lut_temp, set_temp8, 8);
0780 static SENSOR_DEVICE_ATTR(pwm1_auto_point6_temp_hyst, S_IRUGO,
0781     show_lut_temp_hyst, NULL, 8);
0782 static SENSOR_DEVICE_ATTR(pwm1_auto_point7_pwm, S_IWUSR | S_IRUGO,
0783     show_pwm1, set_pwm1, 7);
0784 static SENSOR_DEVICE_ATTR(pwm1_auto_point7_temp, S_IWUSR | S_IRUGO,
0785     show_lut_temp, set_temp8, 9);
0786 static SENSOR_DEVICE_ATTR(pwm1_auto_point7_temp_hyst, S_IRUGO,
0787     show_lut_temp_hyst, NULL, 9);
0788 static SENSOR_DEVICE_ATTR(pwm1_auto_point8_pwm, S_IWUSR | S_IRUGO,
0789     show_pwm1, set_pwm1, 8);
0790 static SENSOR_DEVICE_ATTR(pwm1_auto_point8_temp, S_IWUSR | S_IRUGO,
0791     show_lut_temp, set_temp8, 10);
0792 static SENSOR_DEVICE_ATTR(pwm1_auto_point8_temp_hyst, S_IRUGO,
0793     show_lut_temp_hyst, NULL, 10);
0794 static SENSOR_DEVICE_ATTR(pwm1_auto_point9_pwm, S_IWUSR | S_IRUGO,
0795     show_pwm1, set_pwm1, 9);
0796 static SENSOR_DEVICE_ATTR(pwm1_auto_point9_temp, S_IWUSR | S_IRUGO,
0797     show_lut_temp, set_temp8, 11);
0798 static SENSOR_DEVICE_ATTR(pwm1_auto_point9_temp_hyst, S_IRUGO,
0799     show_lut_temp_hyst, NULL, 11);
0800 static SENSOR_DEVICE_ATTR(pwm1_auto_point10_pwm, S_IWUSR | S_IRUGO,
0801     show_pwm1, set_pwm1, 10);
0802 static SENSOR_DEVICE_ATTR(pwm1_auto_point10_temp, S_IWUSR | S_IRUGO,
0803     show_lut_temp, set_temp8, 12);
0804 static SENSOR_DEVICE_ATTR(pwm1_auto_point10_temp_hyst, S_IRUGO,
0805     show_lut_temp_hyst, NULL, 12);
0806 static SENSOR_DEVICE_ATTR(pwm1_auto_point11_pwm, S_IWUSR | S_IRUGO,
0807     show_pwm1, set_pwm1, 11);
0808 static SENSOR_DEVICE_ATTR(pwm1_auto_point11_temp, S_IWUSR | S_IRUGO,
0809     show_lut_temp, set_temp8, 13);
0810 static SENSOR_DEVICE_ATTR(pwm1_auto_point11_temp_hyst, S_IRUGO,
0811     show_lut_temp_hyst, NULL, 13);
0812 static SENSOR_DEVICE_ATTR(pwm1_auto_point12_pwm, S_IWUSR | S_IRUGO,
0813     show_pwm1, set_pwm1, 12);
0814 static SENSOR_DEVICE_ATTR(pwm1_auto_point12_temp, S_IWUSR | S_IRUGO,
0815     show_lut_temp, set_temp8, 14);
0816 static SENSOR_DEVICE_ATTR(pwm1_auto_point12_temp_hyst, S_IRUGO,
0817     show_lut_temp_hyst, NULL, 14);
0818 
0819 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_local_temp8, NULL, 0);
0820 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_local_temp8,
0821     set_temp8, 1);
0822 
0823 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
0824 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
0825     set_temp11, 1);
0826 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
0827     set_temp11, 2);
0828 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
0829     set_temp11, 3);
0830 static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_remote_temp8,
0831     set_temp8, 2);
0832 static DEVICE_ATTR_RW(temp2_crit_hyst);
0833 
0834 static DEVICE_ATTR_RW(temp2_type);
0835 
0836 /* Individual alarm files */
0837 static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, show_alarm, NULL, 0);
0838 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
0839 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
0840 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
0841 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
0842 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
0843 /* Raw alarm file for compatibility */
0844 static DEVICE_ATTR_RO(alarms);
0845 
0846 static DEVICE_ATTR_RW(update_interval);
0847 
0848 static struct attribute *lm63_attributes[] = {
0849     &sensor_dev_attr_pwm1.dev_attr.attr,
0850     &dev_attr_pwm1_enable.attr,
0851     &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
0852     &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
0853     &sensor_dev_attr_pwm1_auto_point1_temp_hyst.dev_attr.attr,
0854     &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
0855     &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
0856     &sensor_dev_attr_pwm1_auto_point2_temp_hyst.dev_attr.attr,
0857     &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
0858     &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
0859     &sensor_dev_attr_pwm1_auto_point3_temp_hyst.dev_attr.attr,
0860     &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
0861     &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
0862     &sensor_dev_attr_pwm1_auto_point4_temp_hyst.dev_attr.attr,
0863     &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
0864     &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
0865     &sensor_dev_attr_pwm1_auto_point5_temp_hyst.dev_attr.attr,
0866     &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
0867     &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
0868     &sensor_dev_attr_pwm1_auto_point6_temp_hyst.dev_attr.attr,
0869     &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
0870     &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
0871     &sensor_dev_attr_pwm1_auto_point7_temp_hyst.dev_attr.attr,
0872     &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
0873     &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
0874     &sensor_dev_attr_pwm1_auto_point8_temp_hyst.dev_attr.attr,
0875 
0876     &sensor_dev_attr_temp1_input.dev_attr.attr,
0877     &sensor_dev_attr_temp2_input.dev_attr.attr,
0878     &sensor_dev_attr_temp2_min.dev_attr.attr,
0879     &sensor_dev_attr_temp1_max.dev_attr.attr,
0880     &sensor_dev_attr_temp2_max.dev_attr.attr,
0881     &sensor_dev_attr_temp2_offset.dev_attr.attr,
0882     &sensor_dev_attr_temp2_crit.dev_attr.attr,
0883     &dev_attr_temp2_crit_hyst.attr,
0884 
0885     &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
0886     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0887     &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
0888     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
0889     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0890     &dev_attr_alarms.attr,
0891     &dev_attr_update_interval.attr,
0892     NULL
0893 };
0894 
0895 static struct attribute *lm63_attributes_temp2_type[] = {
0896     &dev_attr_temp2_type.attr,
0897     NULL
0898 };
0899 
0900 static const struct attribute_group lm63_group_temp2_type = {
0901     .attrs = lm63_attributes_temp2_type,
0902 };
0903 
0904 static struct attribute *lm63_attributes_extra_lut[] = {
0905     &sensor_dev_attr_pwm1_auto_point9_pwm.dev_attr.attr,
0906     &sensor_dev_attr_pwm1_auto_point9_temp.dev_attr.attr,
0907     &sensor_dev_attr_pwm1_auto_point9_temp_hyst.dev_attr.attr,
0908     &sensor_dev_attr_pwm1_auto_point10_pwm.dev_attr.attr,
0909     &sensor_dev_attr_pwm1_auto_point10_temp.dev_attr.attr,
0910     &sensor_dev_attr_pwm1_auto_point10_temp_hyst.dev_attr.attr,
0911     &sensor_dev_attr_pwm1_auto_point11_pwm.dev_attr.attr,
0912     &sensor_dev_attr_pwm1_auto_point11_temp.dev_attr.attr,
0913     &sensor_dev_attr_pwm1_auto_point11_temp_hyst.dev_attr.attr,
0914     &sensor_dev_attr_pwm1_auto_point12_pwm.dev_attr.attr,
0915     &sensor_dev_attr_pwm1_auto_point12_temp.dev_attr.attr,
0916     &sensor_dev_attr_pwm1_auto_point12_temp_hyst.dev_attr.attr,
0917     NULL
0918 };
0919 
0920 static const struct attribute_group lm63_group_extra_lut = {
0921     .attrs = lm63_attributes_extra_lut,
0922 };
0923 
0924 /*
0925  * On LM63, temp2_crit can be set only once, which should be job
0926  * of the bootloader.
0927  * On LM64, temp2_crit can always be set.
0928  * On LM96163, temp2_crit can be set if bit 1 of the configuration
0929  * register is true.
0930  */
0931 static umode_t lm63_attribute_mode(struct kobject *kobj,
0932                    struct attribute *attr, int index)
0933 {
0934     struct device *dev = kobj_to_dev(kobj);
0935     struct lm63_data *data = dev_get_drvdata(dev);
0936 
0937     if (attr == &sensor_dev_attr_temp2_crit.dev_attr.attr
0938         && (data->kind == lm64 ||
0939         (data->kind == lm96163 && (data->config & 0x02))))
0940         return attr->mode | S_IWUSR;
0941 
0942     return attr->mode;
0943 }
0944 
0945 static const struct attribute_group lm63_group = {
0946     .is_visible = lm63_attribute_mode,
0947     .attrs = lm63_attributes,
0948 };
0949 
0950 static struct attribute *lm63_attributes_fan1[] = {
0951     &sensor_dev_attr_fan1_input.dev_attr.attr,
0952     &sensor_dev_attr_fan1_min.dev_attr.attr,
0953 
0954     &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
0955     NULL
0956 };
0957 
0958 static const struct attribute_group lm63_group_fan1 = {
0959     .attrs = lm63_attributes_fan1,
0960 };
0961 
0962 /*
0963  * Real code
0964  */
0965 
0966 /* Return 0 if detection is successful, -ENODEV otherwise */
0967 static int lm63_detect(struct i2c_client *client,
0968                struct i2c_board_info *info)
0969 {
0970     struct i2c_adapter *adapter = client->adapter;
0971     u8 man_id, chip_id, reg_config1, reg_config2;
0972     u8 reg_alert_status, reg_alert_mask;
0973     int address = client->addr;
0974 
0975     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0976         return -ENODEV;
0977 
0978     man_id = i2c_smbus_read_byte_data(client, LM63_REG_MAN_ID);
0979     chip_id = i2c_smbus_read_byte_data(client, LM63_REG_CHIP_ID);
0980 
0981     reg_config1 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
0982     reg_config2 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG2);
0983     reg_alert_status = i2c_smbus_read_byte_data(client,
0984                LM63_REG_ALERT_STATUS);
0985     reg_alert_mask = i2c_smbus_read_byte_data(client, LM63_REG_ALERT_MASK);
0986 
0987     if (man_id != 0x01 /* National Semiconductor */
0988      || (reg_config1 & 0x18) != 0x00
0989      || (reg_config2 & 0xF8) != 0x00
0990      || (reg_alert_status & 0x20) != 0x00
0991      || (reg_alert_mask & 0xA4) != 0xA4) {
0992         dev_dbg(&adapter->dev,
0993             "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
0994             man_id, chip_id);
0995         return -ENODEV;
0996     }
0997 
0998     if (chip_id == 0x41 && address == 0x4c)
0999         strlcpy(info->type, "lm63", I2C_NAME_SIZE);
1000     else if (chip_id == 0x51 && (address == 0x18 || address == 0x4e))
1001         strlcpy(info->type, "lm64", I2C_NAME_SIZE);
1002     else if (chip_id == 0x49 && address == 0x4c)
1003         strlcpy(info->type, "lm96163", I2C_NAME_SIZE);
1004     else
1005         return -ENODEV;
1006 
1007     return 0;
1008 }
1009 
1010 /*
1011  * Ideally we shouldn't have to initialize anything, since the BIOS
1012  * should have taken care of everything
1013  */
1014 static void lm63_init_client(struct lm63_data *data)
1015 {
1016     struct i2c_client *client = data->client;
1017     struct device *dev = &client->dev;
1018     u8 convrate;
1019 
1020     data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
1021     data->config_fan = i2c_smbus_read_byte_data(client,
1022                             LM63_REG_CONFIG_FAN);
1023 
1024     /* Start converting if needed */
1025     if (data->config & 0x40) { /* standby */
1026         dev_dbg(dev, "Switching to operational mode\n");
1027         data->config &= 0xA7;
1028         i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
1029                       data->config);
1030     }
1031     /* Tachometer is always enabled on LM64 */
1032     if (data->kind == lm64)
1033         data->config |= 0x04;
1034 
1035     /* We may need pwm1_freq before ever updating the client data */
1036     data->pwm1_freq = i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
1037     if (data->pwm1_freq == 0)
1038         data->pwm1_freq = 1;
1039 
1040     switch (data->kind) {
1041     case lm63:
1042     case lm64:
1043         data->max_convrate_hz = LM63_MAX_CONVRATE_HZ;
1044         data->lut_size = 8;
1045         break;
1046     case lm96163:
1047         data->max_convrate_hz = LM96163_MAX_CONVRATE_HZ;
1048         data->lut_size = 12;
1049         data->trutherm
1050           = i2c_smbus_read_byte_data(client,
1051                          LM96163_REG_TRUTHERM) & 0x02;
1052         break;
1053     }
1054     convrate = i2c_smbus_read_byte_data(client, LM63_REG_CONVRATE);
1055     if (unlikely(convrate > LM63_MAX_CONVRATE))
1056         convrate = LM63_MAX_CONVRATE;
1057     data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz,
1058                         convrate);
1059 
1060     /*
1061      * For LM96163, check if high resolution PWM
1062      * and unsigned temperature format is enabled.
1063      */
1064     if (data->kind == lm96163) {
1065         u8 config_enhanced
1066           = i2c_smbus_read_byte_data(client,
1067                          LM96163_REG_CONFIG_ENHANCED);
1068         if (config_enhanced & 0x20)
1069             data->lut_temp_highres = true;
1070         if ((config_enhanced & 0x10)
1071             && !(data->config_fan & 0x08) && data->pwm1_freq == 8)
1072             data->pwm_highres = true;
1073         if (config_enhanced & 0x08)
1074             data->remote_unsigned = true;
1075     }
1076 
1077     /* Show some debug info about the LM63 configuration */
1078     if (data->kind == lm63)
1079         dev_dbg(dev, "Alert/tach pin configured for %s\n",
1080             (data->config & 0x04) ? "tachometer input" :
1081             "alert output");
1082     dev_dbg(dev, "PWM clock %s kHz, output frequency %u Hz\n",
1083         (data->config_fan & 0x08) ? "1.4" : "360",
1084         ((data->config_fan & 0x08) ? 700 : 180000) / data->pwm1_freq);
1085     dev_dbg(dev, "PWM output active %s, %s mode\n",
1086         (data->config_fan & 0x10) ? "low" : "high",
1087         (data->config_fan & 0x20) ? "manual" : "auto");
1088 }
1089 
1090 static const struct i2c_device_id lm63_id[];
1091 
1092 static int lm63_probe(struct i2c_client *client)
1093 {
1094     struct device *dev = &client->dev;
1095     struct device *hwmon_dev;
1096     struct lm63_data *data;
1097     int groups = 0;
1098 
1099     data = devm_kzalloc(dev, sizeof(struct lm63_data), GFP_KERNEL);
1100     if (!data)
1101         return -ENOMEM;
1102 
1103     data->client = client;
1104     mutex_init(&data->update_lock);
1105 
1106     /* Set the device type */
1107     if (client->dev.of_node)
1108         data->kind = (enum chips)of_device_get_match_data(&client->dev);
1109     else
1110         data->kind = i2c_match_id(lm63_id, client)->driver_data;
1111     if (data->kind == lm64)
1112         data->temp2_offset = 16000;
1113 
1114     /* Initialize chip */
1115     lm63_init_client(data);
1116 
1117     /* Register sysfs hooks */
1118     data->groups[groups++] = &lm63_group;
1119     if (data->config & 0x04)    /* tachometer enabled */
1120         data->groups[groups++] = &lm63_group_fan1;
1121 
1122     if (data->kind == lm96163) {
1123         data->groups[groups++] = &lm63_group_temp2_type;
1124         data->groups[groups++] = &lm63_group_extra_lut;
1125     }
1126 
1127     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1128                                data, data->groups);
1129     return PTR_ERR_OR_ZERO(hwmon_dev);
1130 }
1131 
1132 /*
1133  * Driver data (common to all clients)
1134  */
1135 
1136 static const struct i2c_device_id lm63_id[] = {
1137     { "lm63", lm63 },
1138     { "lm64", lm64 },
1139     { "lm96163", lm96163 },
1140     { }
1141 };
1142 MODULE_DEVICE_TABLE(i2c, lm63_id);
1143 
1144 static const struct of_device_id __maybe_unused lm63_of_match[] = {
1145     {
1146         .compatible = "national,lm63",
1147         .data = (void *)lm63
1148     },
1149     {
1150         .compatible = "national,lm64",
1151         .data = (void *)lm64
1152     },
1153     {
1154         .compatible = "national,lm96163",
1155         .data = (void *)lm96163
1156     },
1157     { },
1158 };
1159 MODULE_DEVICE_TABLE(of, lm63_of_match);
1160 
1161 static struct i2c_driver lm63_driver = {
1162     .class      = I2C_CLASS_HWMON,
1163     .driver = {
1164         .name   = "lm63",
1165         .of_match_table = of_match_ptr(lm63_of_match),
1166     },
1167     .probe_new  = lm63_probe,
1168     .id_table   = lm63_id,
1169     .detect     = lm63_detect,
1170     .address_list   = normal_i2c,
1171 };
1172 
1173 module_i2c_driver(lm63_driver);
1174 
1175 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1176 MODULE_DESCRIPTION("LM63 driver");
1177 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!