Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * lm87.c
0004  *
0005  * Copyright (C) 2000       Frodo Looijaard <frodol@dds.nl>
0006  *                          Philip Edelbrock <phil@netroedge.com>
0007  *                          Stephen Rousset <stephen.rousset@rocketlogix.com>
0008  *                          Dan Eaton <dan.eaton@rocketlogix.com>
0009  * Copyright (C) 2004-2008  Jean Delvare <jdelvare@suse.de>
0010  *
0011  * Original port to Linux 2.6 by Jeff Oliver.
0012  *
0013  * The LM87 is a sensor chip made by National Semiconductor. It monitors up
0014  * to 8 voltages (including its own power source), up to three temperatures
0015  * (its own plus up to two external ones) and up to two fans. The default
0016  * configuration is 6 voltages, two temperatures and two fans (see below).
0017  * Voltages are scaled internally with ratios such that the nominal value of
0018  * each voltage correspond to a register value of 192 (which means a
0019  * resolution of about 0.5% of the nominal value). Temperature values are
0020  * reported with a 1 deg resolution and a 3-4 deg accuracy. Complete
0021  * datasheet can be obtained from National's website at:
0022  *   http://www.national.com/pf/LM/LM87.html
0023  *
0024  * Some functions share pins, so not all functions are available at the same
0025  * time. Which are depends on the hardware setup. This driver normally
0026  * assumes that firmware configured the chip correctly. Where this is not
0027  * the case, platform code must set the I2C client's platform_data to point
0028  * to a u8 value to be written to the channel register.
0029  * For reference, here is the list of exclusive functions:
0030  *  - in0+in5 (default) or temp3
0031  *  - fan1 (default) or in6
0032  *  - fan2 (default) or in7
0033  *  - VID lines (default) or IRQ lines (not handled by this driver)
0034  *
0035  * The LM87 additionally features an analog output, supposedly usable to
0036  * control the speed of a fan. All new chips use pulse width modulation
0037  * instead. The LM87 is the only hardware monitoring chipset I know of
0038  * which uses amplitude modulation. Be careful when using this feature.
0039  *
0040  * This driver also supports the ADM1024, a sensor chip made by Analog
0041  * Devices. That chip is fully compatible with the LM87. Complete
0042  * datasheet can be obtained from Analog's website at:
0043  *   https://www.analog.com/en/prod/0,2877,ADM1024,00.html
0044  */
0045 
0046 #include <linux/module.h>
0047 #include <linux/init.h>
0048 #include <linux/slab.h>
0049 #include <linux/jiffies.h>
0050 #include <linux/i2c.h>
0051 #include <linux/hwmon.h>
0052 #include <linux/hwmon-sysfs.h>
0053 #include <linux/hwmon-vid.h>
0054 #include <linux/err.h>
0055 #include <linux/mutex.h>
0056 #include <linux/regulator/consumer.h>
0057 
0058 /*
0059  * Addresses to scan
0060  * LM87 has three possible addresses: 0x2c, 0x2d and 0x2e.
0061  */
0062 
0063 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0064 
0065 /*
0066  * The LM87 registers
0067  */
0068 
0069 /* nr in 0..5 */
0070 #define LM87_REG_IN(nr)         (0x20 + (nr))
0071 #define LM87_REG_IN_MAX(nr)     (0x2B + (nr) * 2)
0072 #define LM87_REG_IN_MIN(nr)     (0x2C + (nr) * 2)
0073 /* nr in 0..1 */
0074 #define LM87_REG_AIN(nr)        (0x28 + (nr))
0075 #define LM87_REG_AIN_MIN(nr)        (0x1A + (nr))
0076 #define LM87_REG_AIN_MAX(nr)        (0x3B + (nr))
0077 
0078 static u8 LM87_REG_TEMP[3] = { 0x27, 0x26, 0x20 };
0079 static u8 LM87_REG_TEMP_HIGH[3] = { 0x39, 0x37, 0x2B };
0080 static u8 LM87_REG_TEMP_LOW[3] = { 0x3A, 0x38, 0x2C };
0081 
0082 #define LM87_REG_TEMP_HW_INT_LOCK   0x13
0083 #define LM87_REG_TEMP_HW_EXT_LOCK   0x14
0084 #define LM87_REG_TEMP_HW_INT        0x17
0085 #define LM87_REG_TEMP_HW_EXT        0x18
0086 
0087 /* nr in 0..1 */
0088 #define LM87_REG_FAN(nr)        (0x28 + (nr))
0089 #define LM87_REG_FAN_MIN(nr)        (0x3B + (nr))
0090 #define LM87_REG_AOUT           0x19
0091 
0092 #define LM87_REG_CONFIG         0x40
0093 #define LM87_REG_CHANNEL_MODE       0x16
0094 #define LM87_REG_VID_FAN_DIV        0x47
0095 #define LM87_REG_VID4           0x49
0096 
0097 #define LM87_REG_ALARMS1        0x41
0098 #define LM87_REG_ALARMS2        0x42
0099 
0100 #define LM87_REG_COMPANY_ID     0x3E
0101 #define LM87_REG_REVISION       0x3F
0102 
0103 /*
0104  * Conversions and various macros
0105  * The LM87 uses signed 8-bit values for temperatures.
0106  */
0107 
0108 #define IN_FROM_REG(reg, scale) (((reg) * (scale) + 96) / 192)
0109 #define IN_TO_REG(val, scale)   ((val) <= 0 ? 0 : \
0110                  (val) >= (scale) * 255 / 192 ? 255 : \
0111                  ((val) * 192 + (scale) / 2) / (scale))
0112 
0113 #define TEMP_FROM_REG(reg)  ((reg) * 1000)
0114 #define TEMP_TO_REG(val)    ((val) <= -127500 ? -128 : \
0115                  (val) >= 126500 ? 127 : \
0116                  (((val) < 0 ? (val) - 500 : \
0117                    (val) + 500) / 1000))
0118 
0119 #define FAN_FROM_REG(reg, div)  ((reg) == 255 || (reg) == 0 ? 0 : \
0120                  (1350000 + (reg)*(div) / 2) / ((reg) * (div)))
0121 #define FAN_TO_REG(val, div)    ((val) * (div) * 255 <= 1350000 ? 255 : \
0122                  (1350000 + (val)*(div) / 2) / ((val) * (div)))
0123 
0124 #define FAN_DIV_FROM_REG(reg)   (1 << (reg))
0125 
0126 /* analog out is 9.80mV/LSB */
0127 #define AOUT_FROM_REG(reg)  (((reg) * 98 + 5) / 10)
0128 #define AOUT_TO_REG(val)    ((val) <= 0 ? 0 : \
0129                  (val) >= 2500 ? 255 : \
0130                  ((val) * 10 + 49) / 98)
0131 
0132 /* nr in 0..1 */
0133 #define CHAN_NO_FAN(nr)     (1 << (nr))
0134 #define CHAN_TEMP3      (1 << 2)
0135 #define CHAN_VCC_5V     (1 << 3)
0136 #define CHAN_NO_VID     (1 << 7)
0137 
0138 /*
0139  * Client data (each client gets its own)
0140  */
0141 
0142 struct lm87_data {
0143     struct mutex update_lock;
0144     bool valid; /* false until following fields are valid */
0145     unsigned long last_updated; /* In jiffies */
0146 
0147     u8 channel;     /* register value */
0148     u8 config;      /* original register value */
0149 
0150     u8 in[8];       /* register value */
0151     u8 in_max[8];       /* register value */
0152     u8 in_min[8];       /* register value */
0153     u16 in_scale[8];
0154 
0155     s8 temp[3];     /* register value */
0156     s8 temp_high[3];    /* register value */
0157     s8 temp_low[3];     /* register value */
0158     s8 temp_crit_int;   /* min of two register values */
0159     s8 temp_crit_ext;   /* min of two register values */
0160 
0161     u8 fan[2];      /* register value */
0162     u8 fan_min[2];      /* register value */
0163     u8 fan_div[2];      /* register value, shifted right */
0164     u8 aout;        /* register value */
0165 
0166     u16 alarms;     /* register values, combined */
0167     u8 vid;         /* register values, combined */
0168     u8 vrm;
0169 
0170     const struct attribute_group *attr_groups[6];
0171 };
0172 
0173 static inline int lm87_read_value(struct i2c_client *client, u8 reg)
0174 {
0175     return i2c_smbus_read_byte_data(client, reg);
0176 }
0177 
0178 static inline int lm87_write_value(struct i2c_client *client, u8 reg, u8 value)
0179 {
0180     return i2c_smbus_write_byte_data(client, reg, value);
0181 }
0182 
0183 static struct lm87_data *lm87_update_device(struct device *dev)
0184 {
0185     struct i2c_client *client = dev_get_drvdata(dev);
0186     struct lm87_data *data = i2c_get_clientdata(client);
0187 
0188     mutex_lock(&data->update_lock);
0189 
0190     if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
0191         int i, j;
0192 
0193         dev_dbg(&client->dev, "Updating data.\n");
0194 
0195         i = (data->channel & CHAN_TEMP3) ? 1 : 0;
0196         j = (data->channel & CHAN_TEMP3) ? 5 : 6;
0197         for (; i < j; i++) {
0198             data->in[i] = lm87_read_value(client,
0199                       LM87_REG_IN(i));
0200             data->in_min[i] = lm87_read_value(client,
0201                       LM87_REG_IN_MIN(i));
0202             data->in_max[i] = lm87_read_value(client,
0203                       LM87_REG_IN_MAX(i));
0204         }
0205 
0206         for (i = 0; i < 2; i++) {
0207             if (data->channel & CHAN_NO_FAN(i)) {
0208                 data->in[6+i] = lm87_read_value(client,
0209                         LM87_REG_AIN(i));
0210                 data->in_max[6+i] = lm87_read_value(client,
0211                             LM87_REG_AIN_MAX(i));
0212                 data->in_min[6+i] = lm87_read_value(client,
0213                             LM87_REG_AIN_MIN(i));
0214 
0215             } else {
0216                 data->fan[i] = lm87_read_value(client,
0217                            LM87_REG_FAN(i));
0218                 data->fan_min[i] = lm87_read_value(client,
0219                            LM87_REG_FAN_MIN(i));
0220             }
0221         }
0222 
0223         j = (data->channel & CHAN_TEMP3) ? 3 : 2;
0224         for (i = 0 ; i < j; i++) {
0225             data->temp[i] = lm87_read_value(client,
0226                     LM87_REG_TEMP[i]);
0227             data->temp_high[i] = lm87_read_value(client,
0228                          LM87_REG_TEMP_HIGH[i]);
0229             data->temp_low[i] = lm87_read_value(client,
0230                         LM87_REG_TEMP_LOW[i]);
0231         }
0232 
0233         i = lm87_read_value(client, LM87_REG_TEMP_HW_INT_LOCK);
0234         j = lm87_read_value(client, LM87_REG_TEMP_HW_INT);
0235         data->temp_crit_int = min(i, j);
0236 
0237         i = lm87_read_value(client, LM87_REG_TEMP_HW_EXT_LOCK);
0238         j = lm87_read_value(client, LM87_REG_TEMP_HW_EXT);
0239         data->temp_crit_ext = min(i, j);
0240 
0241         i = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
0242         data->fan_div[0] = (i >> 4) & 0x03;
0243         data->fan_div[1] = (i >> 6) & 0x03;
0244         data->vid = (i & 0x0F)
0245               | (lm87_read_value(client, LM87_REG_VID4) & 0x01)
0246                  << 4;
0247 
0248         data->alarms = lm87_read_value(client, LM87_REG_ALARMS1)
0249                  | (lm87_read_value(client, LM87_REG_ALARMS2)
0250                 << 8);
0251         data->aout = lm87_read_value(client, LM87_REG_AOUT);
0252 
0253         data->last_updated = jiffies;
0254         data->valid = true;
0255     }
0256 
0257     mutex_unlock(&data->update_lock);
0258 
0259     return data;
0260 }
0261 
0262 /*
0263  * Sysfs stuff
0264  */
0265 
0266 static ssize_t in_input_show(struct device *dev,
0267                  struct device_attribute *attr, char *buf)
0268 {
0269     struct lm87_data *data = lm87_update_device(dev);
0270     int nr = to_sensor_dev_attr(attr)->index;
0271 
0272     return sprintf(buf, "%u\n", IN_FROM_REG(data->in[nr],
0273                data->in_scale[nr]));
0274 }
0275 
0276 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
0277                char *buf)
0278 {
0279     struct lm87_data *data = lm87_update_device(dev);
0280     int nr = to_sensor_dev_attr(attr)->index;
0281 
0282     return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[nr],
0283                data->in_scale[nr]));
0284 }
0285 
0286 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
0287                char *buf)
0288 {
0289     struct lm87_data *data = lm87_update_device(dev);
0290     int nr = to_sensor_dev_attr(attr)->index;
0291 
0292     return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[nr],
0293                data->in_scale[nr]));
0294 }
0295 
0296 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0297                 const char *buf, size_t count)
0298 {
0299     struct i2c_client *client = dev_get_drvdata(dev);
0300     struct lm87_data *data = i2c_get_clientdata(client);
0301     int nr = to_sensor_dev_attr(attr)->index;
0302     long val;
0303     int err;
0304 
0305     err = kstrtol(buf, 10, &val);
0306     if (err)
0307         return err;
0308 
0309     mutex_lock(&data->update_lock);
0310     data->in_min[nr] = IN_TO_REG(val, data->in_scale[nr]);
0311     lm87_write_value(client, nr < 6 ? LM87_REG_IN_MIN(nr) :
0312              LM87_REG_AIN_MIN(nr - 6), data->in_min[nr]);
0313     mutex_unlock(&data->update_lock);
0314     return count;
0315 }
0316 
0317 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0318                 const char *buf, size_t count)
0319 {
0320     struct i2c_client *client = dev_get_drvdata(dev);
0321     struct lm87_data *data = i2c_get_clientdata(client);
0322     int nr = to_sensor_dev_attr(attr)->index;
0323     long val;
0324     int err;
0325 
0326     err = kstrtol(buf, 10, &val);
0327     if (err)
0328         return err;
0329 
0330     mutex_lock(&data->update_lock);
0331     data->in_max[nr] = IN_TO_REG(val, data->in_scale[nr]);
0332     lm87_write_value(client, nr < 6 ? LM87_REG_IN_MAX(nr) :
0333              LM87_REG_AIN_MAX(nr - 6), data->in_max[nr]);
0334     mutex_unlock(&data->update_lock);
0335     return count;
0336 }
0337 
0338 static SENSOR_DEVICE_ATTR_RO(in0_input, in_input, 0);
0339 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0340 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0341 static SENSOR_DEVICE_ATTR_RO(in1_input, in_input, 1);
0342 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0343 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0344 static SENSOR_DEVICE_ATTR_RO(in2_input, in_input, 2);
0345 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0346 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0347 static SENSOR_DEVICE_ATTR_RO(in3_input, in_input, 3);
0348 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0349 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0350 static SENSOR_DEVICE_ATTR_RO(in4_input, in_input, 4);
0351 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0352 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0353 static SENSOR_DEVICE_ATTR_RO(in5_input, in_input, 5);
0354 static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
0355 static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
0356 static SENSOR_DEVICE_ATTR_RO(in6_input, in_input, 6);
0357 static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
0358 static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
0359 static SENSOR_DEVICE_ATTR_RO(in7_input, in_input, 7);
0360 static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
0361 static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
0362 
0363 static ssize_t temp_input_show(struct device *dev,
0364                    struct device_attribute *attr, char *buf)
0365 {
0366     struct lm87_data *data = lm87_update_device(dev);
0367     int nr = to_sensor_dev_attr(attr)->index;
0368 
0369     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
0370 }
0371 
0372 static ssize_t temp_low_show(struct device *dev,
0373                  struct device_attribute *attr, char *buf)
0374 {
0375     struct lm87_data *data = lm87_update_device(dev);
0376     int nr = to_sensor_dev_attr(attr)->index;
0377 
0378     return sprintf(buf, "%d\n",
0379                TEMP_FROM_REG(data->temp_low[nr]));
0380 }
0381 
0382 static ssize_t temp_high_show(struct device *dev,
0383                   struct device_attribute *attr, char *buf)
0384 {
0385     struct lm87_data *data = lm87_update_device(dev);
0386     int nr = to_sensor_dev_attr(attr)->index;
0387 
0388     return sprintf(buf, "%d\n",
0389                TEMP_FROM_REG(data->temp_high[nr]));
0390 }
0391 
0392 static ssize_t temp_low_store(struct device *dev,
0393                   struct device_attribute *attr, const char *buf,
0394                   size_t count)
0395 {
0396     struct i2c_client *client = dev_get_drvdata(dev);
0397     struct lm87_data *data = i2c_get_clientdata(client);
0398     int nr = to_sensor_dev_attr(attr)->index;
0399     long val;
0400     int err;
0401 
0402     err = kstrtol(buf, 10, &val);
0403     if (err)
0404         return err;
0405 
0406     mutex_lock(&data->update_lock);
0407     data->temp_low[nr] = TEMP_TO_REG(val);
0408     lm87_write_value(client, LM87_REG_TEMP_LOW[nr], data->temp_low[nr]);
0409     mutex_unlock(&data->update_lock);
0410     return count;
0411 }
0412 
0413 static ssize_t temp_high_store(struct device *dev,
0414                    struct device_attribute *attr, const char *buf,
0415                    size_t count)
0416 {
0417     struct i2c_client *client = dev_get_drvdata(dev);
0418     struct lm87_data *data = i2c_get_clientdata(client);
0419     int nr = to_sensor_dev_attr(attr)->index;
0420     long val;
0421     int err;
0422 
0423     err = kstrtol(buf, 10, &val);
0424     if (err)
0425         return err;
0426 
0427     mutex_lock(&data->update_lock);
0428     data->temp_high[nr] = TEMP_TO_REG(val);
0429     lm87_write_value(client, LM87_REG_TEMP_HIGH[nr], data->temp_high[nr]);
0430     mutex_unlock(&data->update_lock);
0431     return count;
0432 }
0433 
0434 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
0435 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_low, 0);
0436 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_high, 0);
0437 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
0438 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_low, 1);
0439 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_high, 1);
0440 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp_input, 2);
0441 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_low, 2);
0442 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_high, 2);
0443 
0444 static ssize_t temp1_crit_show(struct device *dev,
0445                    struct device_attribute *attr, char *buf)
0446 {
0447     struct lm87_data *data = lm87_update_device(dev);
0448     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit_int));
0449 }
0450 
0451 static ssize_t temp2_crit_show(struct device *dev,
0452                    struct device_attribute *attr, char *buf)
0453 {
0454     struct lm87_data *data = lm87_update_device(dev);
0455     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit_ext));
0456 }
0457 
0458 static DEVICE_ATTR_RO(temp1_crit);
0459 static DEVICE_ATTR_RO(temp2_crit);
0460 static DEVICE_ATTR(temp3_crit, 0444, temp2_crit_show, NULL);
0461 
0462 static ssize_t fan_input_show(struct device *dev,
0463                   struct device_attribute *attr, char *buf)
0464 {
0465     struct lm87_data *data = lm87_update_device(dev);
0466     int nr = to_sensor_dev_attr(attr)->index;
0467 
0468     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
0469                FAN_DIV_FROM_REG(data->fan_div[nr])));
0470 }
0471 
0472 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
0473                 char *buf)
0474 {
0475     struct lm87_data *data = lm87_update_device(dev);
0476     int nr = to_sensor_dev_attr(attr)->index;
0477 
0478     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
0479                FAN_DIV_FROM_REG(data->fan_div[nr])));
0480 }
0481 
0482 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
0483                 char *buf)
0484 {
0485     struct lm87_data *data = lm87_update_device(dev);
0486     int nr = to_sensor_dev_attr(attr)->index;
0487 
0488     return sprintf(buf, "%d\n",
0489                FAN_DIV_FROM_REG(data->fan_div[nr]));
0490 }
0491 
0492 static ssize_t fan_min_store(struct device *dev,
0493                  struct device_attribute *attr, const char *buf,
0494                  size_t count)
0495 {
0496     struct i2c_client *client = dev_get_drvdata(dev);
0497     struct lm87_data *data = i2c_get_clientdata(client);
0498     int nr = to_sensor_dev_attr(attr)->index;
0499     long val;
0500     int err;
0501 
0502     err = kstrtol(buf, 10, &val);
0503     if (err)
0504         return err;
0505 
0506     mutex_lock(&data->update_lock);
0507     data->fan_min[nr] = FAN_TO_REG(val,
0508                 FAN_DIV_FROM_REG(data->fan_div[nr]));
0509     lm87_write_value(client, LM87_REG_FAN_MIN(nr), data->fan_min[nr]);
0510     mutex_unlock(&data->update_lock);
0511     return count;
0512 }
0513 
0514 /*
0515  * Note: we save and restore the fan minimum here, because its value is
0516  * determined in part by the fan clock divider.  This follows the principle
0517  * of least surprise; the user doesn't expect the fan minimum to change just
0518  * because the divider changed.
0519  */
0520 static ssize_t fan_div_store(struct device *dev,
0521                  struct device_attribute *attr, const char *buf,
0522                  size_t count)
0523 {
0524     struct i2c_client *client = dev_get_drvdata(dev);
0525     struct lm87_data *data = i2c_get_clientdata(client);
0526     int nr = to_sensor_dev_attr(attr)->index;
0527     long val;
0528     int err;
0529     unsigned long min;
0530     u8 reg;
0531 
0532     err = kstrtol(buf, 10, &val);
0533     if (err)
0534         return err;
0535 
0536     mutex_lock(&data->update_lock);
0537     min = FAN_FROM_REG(data->fan_min[nr],
0538                FAN_DIV_FROM_REG(data->fan_div[nr]));
0539 
0540     switch (val) {
0541     case 1:
0542         data->fan_div[nr] = 0;
0543         break;
0544     case 2:
0545         data->fan_div[nr] = 1;
0546         break;
0547     case 4:
0548         data->fan_div[nr] = 2;
0549         break;
0550     case 8:
0551         data->fan_div[nr] = 3;
0552         break;
0553     default:
0554         mutex_unlock(&data->update_lock);
0555         return -EINVAL;
0556     }
0557 
0558     reg = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
0559     switch (nr) {
0560     case 0:
0561         reg = (reg & 0xCF) | (data->fan_div[0] << 4);
0562         break;
0563     case 1:
0564         reg = (reg & 0x3F) | (data->fan_div[1] << 6);
0565         break;
0566     }
0567     lm87_write_value(client, LM87_REG_VID_FAN_DIV, reg);
0568 
0569     data->fan_min[nr] = FAN_TO_REG(min, val);
0570     lm87_write_value(client, LM87_REG_FAN_MIN(nr),
0571              data->fan_min[nr]);
0572     mutex_unlock(&data->update_lock);
0573 
0574     return count;
0575 }
0576 
0577 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
0578 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
0579 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
0580 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
0581 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
0582 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
0583 
0584 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0585                char *buf)
0586 {
0587     struct lm87_data *data = lm87_update_device(dev);
0588     return sprintf(buf, "%d\n", data->alarms);
0589 }
0590 static DEVICE_ATTR_RO(alarms);
0591 
0592 static ssize_t cpu0_vid_show(struct device *dev,
0593                  struct device_attribute *attr, char *buf)
0594 {
0595     struct lm87_data *data = lm87_update_device(dev);
0596     return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
0597 }
0598 static DEVICE_ATTR_RO(cpu0_vid);
0599 
0600 static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
0601             char *buf)
0602 {
0603     struct lm87_data *data = dev_get_drvdata(dev);
0604     return sprintf(buf, "%d\n", data->vrm);
0605 }
0606 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
0607              const char *buf, size_t count)
0608 {
0609     struct lm87_data *data = dev_get_drvdata(dev);
0610     unsigned long val;
0611     int err;
0612 
0613     err = kstrtoul(buf, 10, &val);
0614     if (err)
0615         return err;
0616 
0617     if (val > 255)
0618         return -EINVAL;
0619 
0620     data->vrm = val;
0621     return count;
0622 }
0623 static DEVICE_ATTR_RW(vrm);
0624 
0625 static ssize_t aout_output_show(struct device *dev,
0626                 struct device_attribute *attr, char *buf)
0627 {
0628     struct lm87_data *data = lm87_update_device(dev);
0629     return sprintf(buf, "%d\n", AOUT_FROM_REG(data->aout));
0630 }
0631 static ssize_t aout_output_store(struct device *dev,
0632                  struct device_attribute *attr,
0633                  const char *buf, size_t count)
0634 {
0635     struct i2c_client *client = dev_get_drvdata(dev);
0636     struct lm87_data *data = i2c_get_clientdata(client);
0637     long val;
0638     int err;
0639 
0640     err = kstrtol(buf, 10, &val);
0641     if (err)
0642         return err;
0643 
0644     mutex_lock(&data->update_lock);
0645     data->aout = AOUT_TO_REG(val);
0646     lm87_write_value(client, LM87_REG_AOUT, data->aout);
0647     mutex_unlock(&data->update_lock);
0648     return count;
0649 }
0650 static DEVICE_ATTR_RW(aout_output);
0651 
0652 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0653               char *buf)
0654 {
0655     struct lm87_data *data = lm87_update_device(dev);
0656     int bitnr = to_sensor_dev_attr(attr)->index;
0657     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0658 }
0659 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
0660 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
0661 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
0662 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0663 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
0664 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);
0665 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 6);
0666 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 7);
0667 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
0668 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
0669 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 5);
0670 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
0671 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
0672 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 14);
0673 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 15);
0674 
0675 /*
0676  * Real code
0677  */
0678 
0679 static struct attribute *lm87_attributes[] = {
0680     &sensor_dev_attr_in1_input.dev_attr.attr,
0681     &sensor_dev_attr_in1_min.dev_attr.attr,
0682     &sensor_dev_attr_in1_max.dev_attr.attr,
0683     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0684     &sensor_dev_attr_in2_input.dev_attr.attr,
0685     &sensor_dev_attr_in2_min.dev_attr.attr,
0686     &sensor_dev_attr_in2_max.dev_attr.attr,
0687     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0688     &sensor_dev_attr_in3_input.dev_attr.attr,
0689     &sensor_dev_attr_in3_min.dev_attr.attr,
0690     &sensor_dev_attr_in3_max.dev_attr.attr,
0691     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0692     &sensor_dev_attr_in4_input.dev_attr.attr,
0693     &sensor_dev_attr_in4_min.dev_attr.attr,
0694     &sensor_dev_attr_in4_max.dev_attr.attr,
0695     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0696 
0697     &sensor_dev_attr_temp1_input.dev_attr.attr,
0698     &sensor_dev_attr_temp1_max.dev_attr.attr,
0699     &sensor_dev_attr_temp1_min.dev_attr.attr,
0700     &dev_attr_temp1_crit.attr,
0701     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0702     &sensor_dev_attr_temp2_input.dev_attr.attr,
0703     &sensor_dev_attr_temp2_max.dev_attr.attr,
0704     &sensor_dev_attr_temp2_min.dev_attr.attr,
0705     &dev_attr_temp2_crit.attr,
0706     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0707     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0708 
0709     &dev_attr_alarms.attr,
0710     &dev_attr_aout_output.attr,
0711 
0712     NULL
0713 };
0714 
0715 static const struct attribute_group lm87_group = {
0716     .attrs = lm87_attributes,
0717 };
0718 
0719 static struct attribute *lm87_attributes_in6[] = {
0720     &sensor_dev_attr_in6_input.dev_attr.attr,
0721     &sensor_dev_attr_in6_min.dev_attr.attr,
0722     &sensor_dev_attr_in6_max.dev_attr.attr,
0723     &sensor_dev_attr_in6_alarm.dev_attr.attr,
0724     NULL
0725 };
0726 
0727 static const struct attribute_group lm87_group_in6 = {
0728     .attrs = lm87_attributes_in6,
0729 };
0730 
0731 static struct attribute *lm87_attributes_fan1[] = {
0732     &sensor_dev_attr_fan1_input.dev_attr.attr,
0733     &sensor_dev_attr_fan1_min.dev_attr.attr,
0734     &sensor_dev_attr_fan1_div.dev_attr.attr,
0735     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0736     NULL
0737 };
0738 
0739 static const struct attribute_group lm87_group_fan1 = {
0740     .attrs = lm87_attributes_fan1,
0741 };
0742 
0743 static struct attribute *lm87_attributes_in7[] = {
0744     &sensor_dev_attr_in7_input.dev_attr.attr,
0745     &sensor_dev_attr_in7_min.dev_attr.attr,
0746     &sensor_dev_attr_in7_max.dev_attr.attr,
0747     &sensor_dev_attr_in7_alarm.dev_attr.attr,
0748     NULL
0749 };
0750 
0751 static const struct attribute_group lm87_group_in7 = {
0752     .attrs = lm87_attributes_in7,
0753 };
0754 
0755 static struct attribute *lm87_attributes_fan2[] = {
0756     &sensor_dev_attr_fan2_input.dev_attr.attr,
0757     &sensor_dev_attr_fan2_min.dev_attr.attr,
0758     &sensor_dev_attr_fan2_div.dev_attr.attr,
0759     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0760     NULL
0761 };
0762 
0763 static const struct attribute_group lm87_group_fan2 = {
0764     .attrs = lm87_attributes_fan2,
0765 };
0766 
0767 static struct attribute *lm87_attributes_temp3[] = {
0768     &sensor_dev_attr_temp3_input.dev_attr.attr,
0769     &sensor_dev_attr_temp3_max.dev_attr.attr,
0770     &sensor_dev_attr_temp3_min.dev_attr.attr,
0771     &dev_attr_temp3_crit.attr,
0772     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0773     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0774     NULL
0775 };
0776 
0777 static const struct attribute_group lm87_group_temp3 = {
0778     .attrs = lm87_attributes_temp3,
0779 };
0780 
0781 static struct attribute *lm87_attributes_in0_5[] = {
0782     &sensor_dev_attr_in0_input.dev_attr.attr,
0783     &sensor_dev_attr_in0_min.dev_attr.attr,
0784     &sensor_dev_attr_in0_max.dev_attr.attr,
0785     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0786     &sensor_dev_attr_in5_input.dev_attr.attr,
0787     &sensor_dev_attr_in5_min.dev_attr.attr,
0788     &sensor_dev_attr_in5_max.dev_attr.attr,
0789     &sensor_dev_attr_in5_alarm.dev_attr.attr,
0790     NULL
0791 };
0792 
0793 static const struct attribute_group lm87_group_in0_5 = {
0794     .attrs = lm87_attributes_in0_5,
0795 };
0796 
0797 static struct attribute *lm87_attributes_vid[] = {
0798     &dev_attr_cpu0_vid.attr,
0799     &dev_attr_vrm.attr,
0800     NULL
0801 };
0802 
0803 static const struct attribute_group lm87_group_vid = {
0804     .attrs = lm87_attributes_vid,
0805 };
0806 
0807 /* Return 0 if detection is successful, -ENODEV otherwise */
0808 static int lm87_detect(struct i2c_client *client, struct i2c_board_info *info)
0809 {
0810     struct i2c_adapter *adapter = client->adapter;
0811     const char *name;
0812     u8 cid, rev;
0813 
0814     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0815         return -ENODEV;
0816 
0817     if (lm87_read_value(client, LM87_REG_CONFIG) & 0x80)
0818         return -ENODEV;
0819 
0820     /* Now, we do the remaining detection. */
0821     cid = lm87_read_value(client, LM87_REG_COMPANY_ID);
0822     rev = lm87_read_value(client, LM87_REG_REVISION);
0823 
0824     if (cid == 0x02         /* National Semiconductor */
0825      && (rev >= 0x01 && rev <= 0x08))
0826         name = "lm87";
0827     else if (cid == 0x41        /* Analog Devices */
0828           && (rev & 0xf0) == 0x10)
0829         name = "adm1024";
0830     else {
0831         dev_dbg(&adapter->dev, "LM87 detection failed at 0x%02x\n",
0832             client->addr);
0833         return -ENODEV;
0834     }
0835 
0836     strlcpy(info->type, name, I2C_NAME_SIZE);
0837 
0838     return 0;
0839 }
0840 
0841 static void lm87_restore_config(void *arg)
0842 {
0843     struct i2c_client *client = arg;
0844     struct lm87_data *data = i2c_get_clientdata(client);
0845 
0846     lm87_write_value(client, LM87_REG_CONFIG, data->config);
0847 }
0848 
0849 static int lm87_init_client(struct i2c_client *client)
0850 {
0851     struct lm87_data *data = i2c_get_clientdata(client);
0852     int rc;
0853     struct device_node *of_node = client->dev.of_node;
0854     u8 val = 0;
0855     struct regulator *vcc = NULL;
0856 
0857     if (of_node) {
0858         if (of_property_read_bool(of_node, "has-temp3"))
0859             val |= CHAN_TEMP3;
0860         if (of_property_read_bool(of_node, "has-in6"))
0861             val |= CHAN_NO_FAN(0);
0862         if (of_property_read_bool(of_node, "has-in7"))
0863             val |= CHAN_NO_FAN(1);
0864         vcc = devm_regulator_get_optional(&client->dev, "vcc");
0865         if (!IS_ERR(vcc)) {
0866             if (regulator_get_voltage(vcc) == 5000000)
0867                 val |= CHAN_VCC_5V;
0868         }
0869         data->channel = val;
0870         lm87_write_value(client,
0871                 LM87_REG_CHANNEL_MODE, data->channel);
0872     } else if (dev_get_platdata(&client->dev)) {
0873         data->channel = *(u8 *)dev_get_platdata(&client->dev);
0874         lm87_write_value(client,
0875                  LM87_REG_CHANNEL_MODE, data->channel);
0876     } else {
0877         data->channel = lm87_read_value(client, LM87_REG_CHANNEL_MODE);
0878     }
0879     data->config = lm87_read_value(client, LM87_REG_CONFIG) & 0x6F;
0880 
0881     rc = devm_add_action(&client->dev, lm87_restore_config, client);
0882     if (rc)
0883         return rc;
0884 
0885     if (!(data->config & 0x01)) {
0886         int i;
0887 
0888         /* Limits are left uninitialized after power-up */
0889         for (i = 1; i < 6; i++) {
0890             lm87_write_value(client, LM87_REG_IN_MIN(i), 0x00);
0891             lm87_write_value(client, LM87_REG_IN_MAX(i), 0xFF);
0892         }
0893         for (i = 0; i < 2; i++) {
0894             lm87_write_value(client, LM87_REG_TEMP_HIGH[i], 0x7F);
0895             lm87_write_value(client, LM87_REG_TEMP_LOW[i], 0x00);
0896             lm87_write_value(client, LM87_REG_AIN_MIN(i), 0x00);
0897             lm87_write_value(client, LM87_REG_AIN_MAX(i), 0xFF);
0898         }
0899         if (data->channel & CHAN_TEMP3) {
0900             lm87_write_value(client, LM87_REG_TEMP_HIGH[2], 0x7F);
0901             lm87_write_value(client, LM87_REG_TEMP_LOW[2], 0x00);
0902         } else {
0903             lm87_write_value(client, LM87_REG_IN_MIN(0), 0x00);
0904             lm87_write_value(client, LM87_REG_IN_MAX(0), 0xFF);
0905         }
0906     }
0907 
0908     /* Make sure Start is set and INT#_Clear is clear */
0909     if ((data->config & 0x09) != 0x01)
0910         lm87_write_value(client, LM87_REG_CONFIG,
0911                  (data->config & 0x77) | 0x01);
0912     return 0;
0913 }
0914 
0915 static int lm87_probe(struct i2c_client *client)
0916 {
0917     struct lm87_data *data;
0918     struct device *hwmon_dev;
0919     int err;
0920     unsigned int group_tail = 0;
0921 
0922     data = devm_kzalloc(&client->dev, sizeof(struct lm87_data), GFP_KERNEL);
0923     if (!data)
0924         return -ENOMEM;
0925 
0926     i2c_set_clientdata(client, data);
0927     mutex_init(&data->update_lock);
0928 
0929     /* Initialize the LM87 chip */
0930     err = lm87_init_client(client);
0931     if (err)
0932         return err;
0933 
0934     data->in_scale[0] = 2500;
0935     data->in_scale[1] = 2700;
0936     data->in_scale[2] = (data->channel & CHAN_VCC_5V) ? 5000 : 3300;
0937     data->in_scale[3] = 5000;
0938     data->in_scale[4] = 12000;
0939     data->in_scale[5] = 2700;
0940     data->in_scale[6] = 1875;
0941     data->in_scale[7] = 1875;
0942 
0943     /*
0944      * Construct the list of attributes, the list depends on the
0945      * configuration of the chip
0946      */
0947     data->attr_groups[group_tail++] = &lm87_group;
0948     if (data->channel & CHAN_NO_FAN(0))
0949         data->attr_groups[group_tail++] = &lm87_group_in6;
0950     else
0951         data->attr_groups[group_tail++] = &lm87_group_fan1;
0952 
0953     if (data->channel & CHAN_NO_FAN(1))
0954         data->attr_groups[group_tail++] = &lm87_group_in7;
0955     else
0956         data->attr_groups[group_tail++] = &lm87_group_fan2;
0957 
0958     if (data->channel & CHAN_TEMP3)
0959         data->attr_groups[group_tail++] = &lm87_group_temp3;
0960     else
0961         data->attr_groups[group_tail++] = &lm87_group_in0_5;
0962 
0963     if (!(data->channel & CHAN_NO_VID)) {
0964         data->vrm = vid_which_vrm();
0965         data->attr_groups[group_tail++] = &lm87_group_vid;
0966     }
0967 
0968     hwmon_dev = devm_hwmon_device_register_with_groups(
0969         &client->dev, client->name, client, data->attr_groups);
0970     return PTR_ERR_OR_ZERO(hwmon_dev);
0971 }
0972 
0973 /*
0974  * Driver data (common to all clients)
0975  */
0976 
0977 static const struct i2c_device_id lm87_id[] = {
0978     { "lm87", 0 },
0979     { "adm1024", 0 },
0980     { }
0981 };
0982 MODULE_DEVICE_TABLE(i2c, lm87_id);
0983 
0984 static const struct of_device_id lm87_of_match[] = {
0985     { .compatible = "ti,lm87" },
0986     { .compatible = "adi,adm1024" },
0987     { },
0988 };
0989 MODULE_DEVICE_TABLE(of, lm87_of_match);
0990 
0991 static struct i2c_driver lm87_driver = {
0992     .class      = I2C_CLASS_HWMON,
0993     .driver = {
0994         .name   = "lm87",
0995         .of_match_table = lm87_of_match,
0996     },
0997     .probe_new  = lm87_probe,
0998     .id_table   = lm87_id,
0999     .detect     = lm87_detect,
1000     .address_list   = normal_i2c,
1001 };
1002 
1003 module_i2c_driver(lm87_driver);
1004 
1005 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de> and others");
1006 MODULE_DESCRIPTION("LM87 driver");
1007 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!