Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * lm80.c - From lm_sensors, Linux kernel modules for hardware
0004  *      monitoring
0005  * Copyright (C) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
0006  *               and Philip Edelbrock <phil@netroedge.com>
0007  *
0008  * Ported to Linux 2.6 by Tiago Sousa <mirage@kaotik.org>
0009  */
0010 
0011 #include <linux/module.h>
0012 #include <linux/init.h>
0013 #include <linux/slab.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/i2c.h>
0016 #include <linux/hwmon.h>
0017 #include <linux/hwmon-sysfs.h>
0018 #include <linux/err.h>
0019 #include <linux/mutex.h>
0020 
0021 /* Addresses to scan */
0022 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
0023                         0x2e, 0x2f, I2C_CLIENT_END };
0024 
0025 /* Many LM80 constants specified below */
0026 
0027 /* The LM80 registers */
0028 #define LM80_REG_IN_MAX(nr)     (0x2a + (nr) * 2)
0029 #define LM80_REG_IN_MIN(nr)     (0x2b + (nr) * 2)
0030 #define LM80_REG_IN(nr)         (0x20 + (nr))
0031 
0032 #define LM80_REG_FAN1           0x28
0033 #define LM80_REG_FAN2           0x29
0034 #define LM80_REG_FAN_MIN(nr)        (0x3b + (nr))
0035 
0036 #define LM80_REG_TEMP           0x27
0037 #define LM80_REG_TEMP_HOT_MAX       0x38
0038 #define LM80_REG_TEMP_HOT_HYST      0x39
0039 #define LM80_REG_TEMP_OS_MAX        0x3a
0040 #define LM80_REG_TEMP_OS_HYST       0x3b
0041 
0042 #define LM80_REG_CONFIG         0x00
0043 #define LM80_REG_ALARM1         0x01
0044 #define LM80_REG_ALARM2         0x02
0045 #define LM80_REG_MASK1          0x03
0046 #define LM80_REG_MASK2          0x04
0047 #define LM80_REG_FANDIV         0x05
0048 #define LM80_REG_RES            0x06
0049 
0050 #define LM96080_REG_CONV_RATE       0x07
0051 #define LM96080_REG_MAN_ID      0x3e
0052 #define LM96080_REG_DEV_ID      0x3f
0053 
0054 
0055 /*
0056  * Conversions. Rounding and limit checking is only done on the TO_REG
0057  * variants. Note that you should be a bit careful with which arguments
0058  * these macros are called: arguments may be evaluated more than once.
0059  * Fixing this is just not worth it.
0060  */
0061 
0062 #define IN_TO_REG(val)      (clamp_val(((val) + 5) / 10, 0, 255))
0063 #define IN_FROM_REG(val)    ((val) * 10)
0064 
0065 static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div)
0066 {
0067     if (rpm == 0)
0068         return 255;
0069     rpm = clamp_val(rpm, 1, 1000000);
0070     return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
0071 }
0072 
0073 #define FAN_FROM_REG(val, div)  ((val) == 0 ? -1 : \
0074                 (val) == 255 ? 0 : 1350000/((div) * (val)))
0075 
0076 #define TEMP_FROM_REG(reg)  ((reg) * 125 / 32)
0077 #define TEMP_TO_REG(temp)   (DIV_ROUND_CLOSEST(clamp_val((temp), \
0078                     -128000, 127000), 1000) << 8)
0079 
0080 #define DIV_FROM_REG(val)       (1 << (val))
0081 
0082 enum temp_index {
0083     t_input = 0,
0084     t_hot_max,
0085     t_hot_hyst,
0086     t_os_max,
0087     t_os_hyst,
0088     t_num_temp
0089 };
0090 
0091 static const u8 temp_regs[t_num_temp] = {
0092     [t_input] = LM80_REG_TEMP,
0093     [t_hot_max] = LM80_REG_TEMP_HOT_MAX,
0094     [t_hot_hyst] = LM80_REG_TEMP_HOT_HYST,
0095     [t_os_max] = LM80_REG_TEMP_OS_MAX,
0096     [t_os_hyst] = LM80_REG_TEMP_OS_HYST,
0097 };
0098 
0099 enum in_index {
0100     i_input = 0,
0101     i_max,
0102     i_min,
0103     i_num_in
0104 };
0105 
0106 enum fan_index {
0107     f_input,
0108     f_min,
0109     f_num_fan
0110 };
0111 
0112 /*
0113  * Client data (each client gets its own)
0114  */
0115 
0116 struct lm80_data {
0117     struct i2c_client *client;
0118     struct mutex update_lock;
0119     char error;     /* !=0 if error occurred during last update */
0120     bool valid;     /* true if following fields are valid */
0121     unsigned long last_updated; /* In jiffies */
0122 
0123     u8 in[i_num_in][7]; /* Register value, 1st index is enum in_index */
0124     u8 fan[f_num_fan][2];   /* Register value, 1st index enum fan_index */
0125     u8 fan_div[2];      /* Register encoding, shifted right */
0126     s16 temp[t_num_temp];   /* Register values, normalized to 16 bit */
0127     u16 alarms;     /* Register encoding, combined */
0128 };
0129 
0130 static int lm80_read_value(struct i2c_client *client, u8 reg)
0131 {
0132     return i2c_smbus_read_byte_data(client, reg);
0133 }
0134 
0135 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
0136 {
0137     return i2c_smbus_write_byte_data(client, reg, value);
0138 }
0139 
0140 /* Called when we have found a new LM80 and after read errors */
0141 static void lm80_init_client(struct i2c_client *client)
0142 {
0143     /*
0144      * Reset all except Watchdog values and last conversion values
0145      * This sets fan-divs to 2, among others. This makes most other
0146      * initializations unnecessary
0147      */
0148     lm80_write_value(client, LM80_REG_CONFIG, 0x80);
0149     /* Set 11-bit temperature resolution */
0150     lm80_write_value(client, LM80_REG_RES, 0x08);
0151 
0152     /* Start monitoring */
0153     lm80_write_value(client, LM80_REG_CONFIG, 0x01);
0154 }
0155 
0156 static struct lm80_data *lm80_update_device(struct device *dev)
0157 {
0158     struct lm80_data *data = dev_get_drvdata(dev);
0159     struct i2c_client *client = data->client;
0160     int i;
0161     int rv;
0162     int prev_rv;
0163     struct lm80_data *ret = data;
0164 
0165     mutex_lock(&data->update_lock);
0166 
0167     if (data->error)
0168         lm80_init_client(client);
0169 
0170     if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
0171         dev_dbg(dev, "Starting lm80 update\n");
0172         for (i = 0; i <= 6; i++) {
0173             rv = lm80_read_value(client, LM80_REG_IN(i));
0174             if (rv < 0)
0175                 goto abort;
0176             data->in[i_input][i] = rv;
0177 
0178             rv = lm80_read_value(client, LM80_REG_IN_MIN(i));
0179             if (rv < 0)
0180                 goto abort;
0181             data->in[i_min][i] = rv;
0182 
0183             rv = lm80_read_value(client, LM80_REG_IN_MAX(i));
0184             if (rv < 0)
0185                 goto abort;
0186             data->in[i_max][i] = rv;
0187         }
0188 
0189         rv = lm80_read_value(client, LM80_REG_FAN1);
0190         if (rv < 0)
0191             goto abort;
0192         data->fan[f_input][0] = rv;
0193 
0194         rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
0195         if (rv < 0)
0196             goto abort;
0197         data->fan[f_min][0] = rv;
0198 
0199         rv = lm80_read_value(client, LM80_REG_FAN2);
0200         if (rv < 0)
0201             goto abort;
0202         data->fan[f_input][1] = rv;
0203 
0204         rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
0205         if (rv < 0)
0206             goto abort;
0207         data->fan[f_min][1] = rv;
0208 
0209         prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP);
0210         if (rv < 0)
0211             goto abort;
0212         rv = lm80_read_value(client, LM80_REG_RES);
0213         if (rv < 0)
0214             goto abort;
0215         data->temp[t_input] = (prev_rv << 8) | (rv & 0xf0);
0216 
0217         for (i = t_input + 1; i < t_num_temp; i++) {
0218             rv = lm80_read_value(client, temp_regs[i]);
0219             if (rv < 0)
0220                 goto abort;
0221             data->temp[i] = rv << 8;
0222         }
0223 
0224         rv = lm80_read_value(client, LM80_REG_FANDIV);
0225         if (rv < 0)
0226             goto abort;
0227         data->fan_div[0] = (rv >> 2) & 0x03;
0228         data->fan_div[1] = (rv >> 4) & 0x03;
0229 
0230         prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1);
0231         if (rv < 0)
0232             goto abort;
0233         rv = lm80_read_value(client, LM80_REG_ALARM2);
0234         if (rv < 0)
0235             goto abort;
0236         data->alarms = prev_rv + (rv << 8);
0237 
0238         data->last_updated = jiffies;
0239         data->valid = true;
0240         data->error = 0;
0241     }
0242     goto done;
0243 
0244 abort:
0245     ret = ERR_PTR(rv);
0246     data->valid = false;
0247     data->error = 1;
0248 
0249 done:
0250     mutex_unlock(&data->update_lock);
0251 
0252     return ret;
0253 }
0254 
0255 /*
0256  * Sysfs stuff
0257  */
0258 
0259 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
0260                char *buf)
0261 {
0262     struct lm80_data *data = lm80_update_device(dev);
0263     int index = to_sensor_dev_attr_2(attr)->index;
0264     int nr = to_sensor_dev_attr_2(attr)->nr;
0265 
0266     if (IS_ERR(data))
0267         return PTR_ERR(data);
0268     return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr][index]));
0269 }
0270 
0271 static ssize_t in_store(struct device *dev, struct device_attribute *attr,
0272             const char *buf, size_t count)
0273 {
0274     struct lm80_data *data = dev_get_drvdata(dev);
0275     struct i2c_client *client = data->client;
0276     int index = to_sensor_dev_attr_2(attr)->index;
0277     int nr = to_sensor_dev_attr_2(attr)->nr;
0278     long val;
0279     u8 reg;
0280     int err = kstrtol(buf, 10, &val);
0281     if (err < 0)
0282         return err;
0283 
0284     reg = nr == i_min ? LM80_REG_IN_MIN(index) : LM80_REG_IN_MAX(index);
0285 
0286     mutex_lock(&data->update_lock);
0287     data->in[nr][index] = IN_TO_REG(val);
0288     lm80_write_value(client, reg, data->in[nr][index]);
0289     mutex_unlock(&data->update_lock);
0290     return count;
0291 }
0292 
0293 static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
0294             char *buf)
0295 {
0296     int index = to_sensor_dev_attr_2(attr)->index;
0297     int nr = to_sensor_dev_attr_2(attr)->nr;
0298     struct lm80_data *data = lm80_update_device(dev);
0299     if (IS_ERR(data))
0300         return PTR_ERR(data);
0301     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr][index],
0302                DIV_FROM_REG(data->fan_div[index])));
0303 }
0304 
0305 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
0306                 char *buf)
0307 {
0308     int nr = to_sensor_dev_attr(attr)->index;
0309     struct lm80_data *data = lm80_update_device(dev);
0310     if (IS_ERR(data))
0311         return PTR_ERR(data);
0312     return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
0313 }
0314 
0315 static ssize_t fan_store(struct device *dev, struct device_attribute *attr,
0316              const char *buf, size_t count)
0317 {
0318     int index = to_sensor_dev_attr_2(attr)->index;
0319     int nr = to_sensor_dev_attr_2(attr)->nr;
0320     struct lm80_data *data = dev_get_drvdata(dev);
0321     struct i2c_client *client = data->client;
0322     unsigned long val;
0323     int err = kstrtoul(buf, 10, &val);
0324     if (err < 0)
0325         return err;
0326 
0327     mutex_lock(&data->update_lock);
0328     data->fan[nr][index] = FAN_TO_REG(val,
0329                       DIV_FROM_REG(data->fan_div[index]));
0330     lm80_write_value(client, LM80_REG_FAN_MIN(index + 1),
0331              data->fan[nr][index]);
0332     mutex_unlock(&data->update_lock);
0333     return count;
0334 }
0335 
0336 /*
0337  * Note: we save and restore the fan minimum here, because its value is
0338  * determined in part by the fan divisor.  This follows the principle of
0339  * least surprise; the user doesn't expect the fan minimum to change just
0340  * because the divisor changed.
0341  */
0342 static ssize_t fan_div_store(struct device *dev,
0343                  struct device_attribute *attr, const char *buf,
0344                  size_t count)
0345 {
0346     int nr = to_sensor_dev_attr(attr)->index;
0347     struct lm80_data *data = dev_get_drvdata(dev);
0348     struct i2c_client *client = data->client;
0349     unsigned long min, val;
0350     u8 reg;
0351     int rv;
0352 
0353     rv = kstrtoul(buf, 10, &val);
0354     if (rv < 0)
0355         return rv;
0356 
0357     /* Save fan_min */
0358     mutex_lock(&data->update_lock);
0359     min = FAN_FROM_REG(data->fan[f_min][nr],
0360                DIV_FROM_REG(data->fan_div[nr]));
0361 
0362     switch (val) {
0363     case 1:
0364         data->fan_div[nr] = 0;
0365         break;
0366     case 2:
0367         data->fan_div[nr] = 1;
0368         break;
0369     case 4:
0370         data->fan_div[nr] = 2;
0371         break;
0372     case 8:
0373         data->fan_div[nr] = 3;
0374         break;
0375     default:
0376         dev_err(dev,
0377             "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
0378             val);
0379         mutex_unlock(&data->update_lock);
0380         return -EINVAL;
0381     }
0382 
0383     rv = lm80_read_value(client, LM80_REG_FANDIV);
0384     if (rv < 0) {
0385         mutex_unlock(&data->update_lock);
0386         return rv;
0387     }
0388     reg = (rv & ~(3 << (2 * (nr + 1))))
0389         | (data->fan_div[nr] << (2 * (nr + 1)));
0390     lm80_write_value(client, LM80_REG_FANDIV, reg);
0391 
0392     /* Restore fan_min */
0393     data->fan[f_min][nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
0394     lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1),
0395              data->fan[f_min][nr]);
0396     mutex_unlock(&data->update_lock);
0397 
0398     return count;
0399 }
0400 
0401 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
0402              char *buf)
0403 {
0404     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0405     struct lm80_data *data = lm80_update_device(dev);
0406     if (IS_ERR(data))
0407         return PTR_ERR(data);
0408     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index]));
0409 }
0410 
0411 static ssize_t temp_store(struct device *dev,
0412               struct device_attribute *devattr, const char *buf,
0413               size_t count)
0414 {
0415     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0416     struct lm80_data *data = dev_get_drvdata(dev);
0417     struct i2c_client *client = data->client;
0418     int nr = attr->index;
0419     long val;
0420     int err = kstrtol(buf, 10, &val);
0421     if (err < 0)
0422         return err;
0423 
0424     mutex_lock(&data->update_lock);
0425     data->temp[nr] = TEMP_TO_REG(val);
0426     lm80_write_value(client, temp_regs[nr], data->temp[nr] >> 8);
0427     mutex_unlock(&data->update_lock);
0428     return count;
0429 }
0430 
0431 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0432                char *buf)
0433 {
0434     struct lm80_data *data = lm80_update_device(dev);
0435     if (IS_ERR(data))
0436         return PTR_ERR(data);
0437     return sprintf(buf, "%u\n", data->alarms);
0438 }
0439 
0440 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0441               char *buf)
0442 {
0443     int bitnr = to_sensor_dev_attr(attr)->index;
0444     struct lm80_data *data = lm80_update_device(dev);
0445     if (IS_ERR(data))
0446         return PTR_ERR(data);
0447     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0448 }
0449 
0450 static SENSOR_DEVICE_ATTR_2_RW(in0_min, in, i_min, 0);
0451 static SENSOR_DEVICE_ATTR_2_RW(in1_min, in, i_min, 1);
0452 static SENSOR_DEVICE_ATTR_2_RW(in2_min, in, i_min, 2);
0453 static SENSOR_DEVICE_ATTR_2_RW(in3_min, in, i_min, 3);
0454 static SENSOR_DEVICE_ATTR_2_RW(in4_min, in, i_min, 4);
0455 static SENSOR_DEVICE_ATTR_2_RW(in5_min, in, i_min, 5);
0456 static SENSOR_DEVICE_ATTR_2_RW(in6_min, in, i_min, 6);
0457 static SENSOR_DEVICE_ATTR_2_RW(in0_max, in, i_max, 0);
0458 static SENSOR_DEVICE_ATTR_2_RW(in1_max, in, i_max, 1);
0459 static SENSOR_DEVICE_ATTR_2_RW(in2_max, in, i_max, 2);
0460 static SENSOR_DEVICE_ATTR_2_RW(in3_max, in, i_max, 3);
0461 static SENSOR_DEVICE_ATTR_2_RW(in4_max, in, i_max, 4);
0462 static SENSOR_DEVICE_ATTR_2_RW(in5_max, in, i_max, 5);
0463 static SENSOR_DEVICE_ATTR_2_RW(in6_max, in, i_max, 6);
0464 static SENSOR_DEVICE_ATTR_2_RO(in0_input, in, i_input, 0);
0465 static SENSOR_DEVICE_ATTR_2_RO(in1_input, in, i_input, 1);
0466 static SENSOR_DEVICE_ATTR_2_RO(in2_input, in, i_input, 2);
0467 static SENSOR_DEVICE_ATTR_2_RO(in3_input, in, i_input, 3);
0468 static SENSOR_DEVICE_ATTR_2_RO(in4_input, in, i_input, 4);
0469 static SENSOR_DEVICE_ATTR_2_RO(in5_input, in, i_input, 5);
0470 static SENSOR_DEVICE_ATTR_2_RO(in6_input, in, i_input, 6);
0471 static SENSOR_DEVICE_ATTR_2_RW(fan1_min, fan, f_min, 0);
0472 static SENSOR_DEVICE_ATTR_2_RW(fan2_min, fan, f_min, 1);
0473 static SENSOR_DEVICE_ATTR_2_RO(fan1_input, fan, f_input, 0);
0474 static SENSOR_DEVICE_ATTR_2_RO(fan2_input, fan, f_input, 1);
0475 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0476 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0477 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, t_input);
0478 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, t_hot_max);
0479 static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp, t_hot_hyst);
0480 static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp, t_os_max);
0481 static SENSOR_DEVICE_ATTR_RW(temp1_crit_hyst, temp, t_os_hyst);
0482 static DEVICE_ATTR_RO(alarms);
0483 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
0484 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
0485 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
0486 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0487 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 4);
0488 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 5);
0489 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 6);
0490 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 10);
0491 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 11);
0492 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 8);
0493 static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 13);
0494 
0495 /*
0496  * Real code
0497  */
0498 
0499 static struct attribute *lm80_attrs[] = {
0500     &sensor_dev_attr_in0_min.dev_attr.attr,
0501     &sensor_dev_attr_in1_min.dev_attr.attr,
0502     &sensor_dev_attr_in2_min.dev_attr.attr,
0503     &sensor_dev_attr_in3_min.dev_attr.attr,
0504     &sensor_dev_attr_in4_min.dev_attr.attr,
0505     &sensor_dev_attr_in5_min.dev_attr.attr,
0506     &sensor_dev_attr_in6_min.dev_attr.attr,
0507     &sensor_dev_attr_in0_max.dev_attr.attr,
0508     &sensor_dev_attr_in1_max.dev_attr.attr,
0509     &sensor_dev_attr_in2_max.dev_attr.attr,
0510     &sensor_dev_attr_in3_max.dev_attr.attr,
0511     &sensor_dev_attr_in4_max.dev_attr.attr,
0512     &sensor_dev_attr_in5_max.dev_attr.attr,
0513     &sensor_dev_attr_in6_max.dev_attr.attr,
0514     &sensor_dev_attr_in0_input.dev_attr.attr,
0515     &sensor_dev_attr_in1_input.dev_attr.attr,
0516     &sensor_dev_attr_in2_input.dev_attr.attr,
0517     &sensor_dev_attr_in3_input.dev_attr.attr,
0518     &sensor_dev_attr_in4_input.dev_attr.attr,
0519     &sensor_dev_attr_in5_input.dev_attr.attr,
0520     &sensor_dev_attr_in6_input.dev_attr.attr,
0521     &sensor_dev_attr_fan1_min.dev_attr.attr,
0522     &sensor_dev_attr_fan2_min.dev_attr.attr,
0523     &sensor_dev_attr_fan1_input.dev_attr.attr,
0524     &sensor_dev_attr_fan2_input.dev_attr.attr,
0525     &sensor_dev_attr_fan1_div.dev_attr.attr,
0526     &sensor_dev_attr_fan2_div.dev_attr.attr,
0527     &sensor_dev_attr_temp1_input.dev_attr.attr,
0528     &sensor_dev_attr_temp1_max.dev_attr.attr,
0529     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
0530     &sensor_dev_attr_temp1_crit.dev_attr.attr,
0531     &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
0532     &dev_attr_alarms.attr,
0533     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0534     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0535     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0536     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0537     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0538     &sensor_dev_attr_in5_alarm.dev_attr.attr,
0539     &sensor_dev_attr_in6_alarm.dev_attr.attr,
0540     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0541     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0542     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0543     &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
0544     NULL
0545 };
0546 ATTRIBUTE_GROUPS(lm80);
0547 
0548 /* Return 0 if detection is successful, -ENODEV otherwise */
0549 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info)
0550 {
0551     struct i2c_adapter *adapter = client->adapter;
0552     int i, cur, man_id, dev_id;
0553     const char *name = NULL;
0554 
0555     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0556         return -ENODEV;
0557 
0558     /* First check for unused bits, common to both chip types */
0559     if ((lm80_read_value(client, LM80_REG_ALARM2) & 0xc0)
0560      || (lm80_read_value(client, LM80_REG_CONFIG) & 0x80))
0561         return -ENODEV;
0562 
0563     /*
0564      * The LM96080 has manufacturer and stepping/die rev registers so we
0565      * can just check that. The LM80 does not have such registers so we
0566      * have to use a more expensive trick.
0567      */
0568     man_id = lm80_read_value(client, LM96080_REG_MAN_ID);
0569     dev_id = lm80_read_value(client, LM96080_REG_DEV_ID);
0570     if (man_id == 0x01 && dev_id == 0x08) {
0571         /* Check more unused bits for confirmation */
0572         if (lm80_read_value(client, LM96080_REG_CONV_RATE) & 0xfe)
0573             return -ENODEV;
0574 
0575         name = "lm96080";
0576     } else {
0577         /* Check 6-bit addressing */
0578         for (i = 0x2a; i <= 0x3d; i++) {
0579             cur = i2c_smbus_read_byte_data(client, i);
0580             if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur)
0581              || (i2c_smbus_read_byte_data(client, i + 0x80) != cur)
0582              || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur))
0583                 return -ENODEV;
0584         }
0585 
0586         name = "lm80";
0587     }
0588 
0589     strlcpy(info->type, name, I2C_NAME_SIZE);
0590 
0591     return 0;
0592 }
0593 
0594 static int lm80_probe(struct i2c_client *client)
0595 {
0596     struct device *dev = &client->dev;
0597     struct device *hwmon_dev;
0598     struct lm80_data *data;
0599 
0600     data = devm_kzalloc(dev, sizeof(struct lm80_data), GFP_KERNEL);
0601     if (!data)
0602         return -ENOMEM;
0603 
0604     data->client = client;
0605     mutex_init(&data->update_lock);
0606 
0607     /* Initialize the LM80 chip */
0608     lm80_init_client(client);
0609 
0610     /* A few vars need to be filled upon startup */
0611     data->fan[f_min][0] = lm80_read_value(client, LM80_REG_FAN_MIN(1));
0612     data->fan[f_min][1] = lm80_read_value(client, LM80_REG_FAN_MIN(2));
0613 
0614     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0615                                data, lm80_groups);
0616 
0617     return PTR_ERR_OR_ZERO(hwmon_dev);
0618 }
0619 
0620 /*
0621  * Driver data (common to all clients)
0622  */
0623 
0624 static const struct i2c_device_id lm80_id[] = {
0625     { "lm80", 0 },
0626     { "lm96080", 1 },
0627     { }
0628 };
0629 MODULE_DEVICE_TABLE(i2c, lm80_id);
0630 
0631 static struct i2c_driver lm80_driver = {
0632     .class      = I2C_CLASS_HWMON,
0633     .driver = {
0634         .name   = "lm80",
0635     },
0636     .probe_new  = lm80_probe,
0637     .id_table   = lm80_id,
0638     .detect     = lm80_detect,
0639     .address_list   = normal_i2c,
0640 };
0641 
0642 module_i2c_driver(lm80_driver);
0643 
0644 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
0645     "Philip Edelbrock <phil@netroedge.com>");
0646 MODULE_DESCRIPTION("LM80 driver");
0647 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!