Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * smsc47m192.c - Support for hardware monitoring block of
0004  *        SMSC LPC47M192 and compatible Super I/O chips
0005  *
0006  * Copyright (C) 2006  Hartmut Rick <linux@rick.claranet.de>
0007  *
0008  * Derived from lm78.c and other chip drivers.
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/hwmon-vid.h>
0019 #include <linux/err.h>
0020 #include <linux/sysfs.h>
0021 #include <linux/mutex.h>
0022 
0023 /* Addresses to scan */
0024 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
0025 
0026 /* SMSC47M192 registers */
0027 #define SMSC47M192_REG_IN(nr)       ((nr) < 6 ? (0x20 + (nr)) : \
0028                     (0x50 + (nr) - 6))
0029 #define SMSC47M192_REG_IN_MAX(nr)   ((nr) < 6 ? (0x2b + (nr) * 2) : \
0030                     (0x54 + (((nr) - 6) * 2)))
0031 #define SMSC47M192_REG_IN_MIN(nr)   ((nr) < 6 ? (0x2c + (nr) * 2) : \
0032                     (0x55 + (((nr) - 6) * 2)))
0033 static u8 SMSC47M192_REG_TEMP[3] =  { 0x27, 0x26, 0x52 };
0034 static u8 SMSC47M192_REG_TEMP_MAX[3] =  { 0x39, 0x37, 0x58 };
0035 static u8 SMSC47M192_REG_TEMP_MIN[3] =  { 0x3A, 0x38, 0x59 };
0036 #define SMSC47M192_REG_TEMP_OFFSET(nr)  ((nr) == 2 ? 0x1e : 0x1f)
0037 #define SMSC47M192_REG_ALARM1       0x41
0038 #define SMSC47M192_REG_ALARM2       0x42
0039 #define SMSC47M192_REG_VID      0x47
0040 #define SMSC47M192_REG_VID4     0x49
0041 #define SMSC47M192_REG_CONFIG       0x40
0042 #define SMSC47M192_REG_SFR      0x4f
0043 #define SMSC47M192_REG_COMPANY_ID   0x3e
0044 #define SMSC47M192_REG_VERSION      0x3f
0045 
0046 /* generalised scaling with integer rounding */
0047 static inline int SCALE(long val, int mul, int div)
0048 {
0049     if (val < 0)
0050         return (val * mul - div / 2) / div;
0051     else
0052         return (val * mul + div / 2) / div;
0053 }
0054 
0055 /* Conversions */
0056 
0057 /* smsc47m192 internally scales voltage measurements */
0058 static const u16 nom_mv[] = { 2500, 2250, 3300, 5000, 12000, 3300, 1500, 1800 };
0059 
0060 static inline unsigned int IN_FROM_REG(u8 reg, int n)
0061 {
0062     return SCALE(reg, nom_mv[n], 192);
0063 }
0064 
0065 static inline u8 IN_TO_REG(unsigned long val, int n)
0066 {
0067     val = clamp_val(val, 0, nom_mv[n] * 255 / 192);
0068     return SCALE(val, 192, nom_mv[n]);
0069 }
0070 
0071 /*
0072  * TEMP: 0.001 degC units (-128C to +127C)
0073  * REG: 1C/bit, two's complement
0074  */
0075 static inline s8 TEMP_TO_REG(long val)
0076 {
0077     return SCALE(clamp_val(val, -128000, 127000), 1, 1000);
0078 }
0079 
0080 static inline int TEMP_FROM_REG(s8 val)
0081 {
0082     return val * 1000;
0083 }
0084 
0085 struct smsc47m192_data {
0086     struct i2c_client *client;
0087     const struct attribute_group *groups[3];
0088     struct mutex update_lock;
0089     bool valid;     /* true if following fields are valid */
0090     unsigned long last_updated; /* In jiffies */
0091 
0092     u8 in[8];       /* Register value */
0093     u8 in_max[8];       /* Register value */
0094     u8 in_min[8];       /* Register value */
0095     s8 temp[3];     /* Register value */
0096     s8 temp_max[3];     /* Register value */
0097     s8 temp_min[3];     /* Register value */
0098     s8 temp_offset[3];  /* Register value */
0099     u16 alarms;     /* Register encoding, combined */
0100     u8 vid;         /* Register encoding, combined */
0101     u8 vrm;
0102 };
0103 
0104 static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
0105 {
0106     struct smsc47m192_data *data = dev_get_drvdata(dev);
0107     struct i2c_client *client = data->client;
0108     int i, config;
0109 
0110     mutex_lock(&data->update_lock);
0111 
0112     if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
0113      || !data->valid) {
0114         u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
0115 
0116         dev_dbg(&client->dev, "Starting smsc47m192 update\n");
0117 
0118         for (i = 0; i <= 7; i++) {
0119             data->in[i] = i2c_smbus_read_byte_data(client,
0120                         SMSC47M192_REG_IN(i));
0121             data->in_min[i] = i2c_smbus_read_byte_data(client,
0122                         SMSC47M192_REG_IN_MIN(i));
0123             data->in_max[i] = i2c_smbus_read_byte_data(client,
0124                         SMSC47M192_REG_IN_MAX(i));
0125         }
0126         for (i = 0; i < 3; i++) {
0127             data->temp[i] = i2c_smbus_read_byte_data(client,
0128                         SMSC47M192_REG_TEMP[i]);
0129             data->temp_max[i] = i2c_smbus_read_byte_data(client,
0130                         SMSC47M192_REG_TEMP_MAX[i]);
0131             data->temp_min[i] = i2c_smbus_read_byte_data(client,
0132                         SMSC47M192_REG_TEMP_MIN[i]);
0133         }
0134         for (i = 1; i < 3; i++)
0135             data->temp_offset[i] = i2c_smbus_read_byte_data(client,
0136                         SMSC47M192_REG_TEMP_OFFSET(i));
0137         /*
0138          * first offset is temp_offset[0] if SFR bit 4 is set,
0139          * temp_offset[1] otherwise
0140          */
0141         if (sfr & 0x10) {
0142             data->temp_offset[0] = data->temp_offset[1];
0143             data->temp_offset[1] = 0;
0144         } else
0145             data->temp_offset[0] = 0;
0146 
0147         data->vid = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VID)
0148                 & 0x0f;
0149         config = i2c_smbus_read_byte_data(client,
0150                           SMSC47M192_REG_CONFIG);
0151         if (config & 0x20)
0152             data->vid |= (i2c_smbus_read_byte_data(client,
0153                     SMSC47M192_REG_VID4) & 0x01) << 4;
0154         data->alarms = i2c_smbus_read_byte_data(client,
0155                         SMSC47M192_REG_ALARM1) |
0156                    (i2c_smbus_read_byte_data(client,
0157                         SMSC47M192_REG_ALARM2) << 8);
0158 
0159         data->last_updated = jiffies;
0160         data->valid = true;
0161     }
0162 
0163     mutex_unlock(&data->update_lock);
0164 
0165     return data;
0166 }
0167 
0168 /* Voltages */
0169 static ssize_t in_show(struct device *dev, struct device_attribute *attr,
0170                char *buf)
0171 {
0172     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0173     int nr = sensor_attr->index;
0174     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0175     return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr], nr));
0176 }
0177 
0178 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
0179                char *buf)
0180 {
0181     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0182     int nr = sensor_attr->index;
0183     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0184     return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr], nr));
0185 }
0186 
0187 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
0188                char *buf)
0189 {
0190     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0191     int nr = sensor_attr->index;
0192     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0193     return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr], nr));
0194 }
0195 
0196 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0197                 const char *buf, size_t count)
0198 {
0199     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0200     int nr = sensor_attr->index;
0201     struct smsc47m192_data *data = dev_get_drvdata(dev);
0202     struct i2c_client *client = data->client;
0203     unsigned long val;
0204     int err;
0205 
0206     err = kstrtoul(buf, 10, &val);
0207     if (err)
0208         return err;
0209 
0210     mutex_lock(&data->update_lock);
0211     data->in_min[nr] = IN_TO_REG(val, nr);
0212     i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),
0213                             data->in_min[nr]);
0214     mutex_unlock(&data->update_lock);
0215     return count;
0216 }
0217 
0218 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0219                 const char *buf, size_t count)
0220 {
0221     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0222     int nr = sensor_attr->index;
0223     struct smsc47m192_data *data = dev_get_drvdata(dev);
0224     struct i2c_client *client = data->client;
0225     unsigned long val;
0226     int err;
0227 
0228     err = kstrtoul(buf, 10, &val);
0229     if (err)
0230         return err;
0231 
0232     mutex_lock(&data->update_lock);
0233     data->in_max[nr] = IN_TO_REG(val, nr);
0234     i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MAX(nr),
0235                             data->in_max[nr]);
0236     mutex_unlock(&data->update_lock);
0237     return count;
0238 }
0239 
0240 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0241 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0242 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0243 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0244 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0245 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0246 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0247 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0248 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0249 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0250 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0251 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0252 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0253 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0254 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0255 static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
0256 static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
0257 static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
0258 static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
0259 static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
0260 static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
0261 static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
0262 static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
0263 static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
0264 
0265 /* Temperatures */
0266 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0267              char *buf)
0268 {
0269     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0270     int nr = sensor_attr->index;
0271     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0272     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
0273 }
0274 
0275 static ssize_t temp_min_show(struct device *dev,
0276                  struct device_attribute *attr, char *buf)
0277 {
0278     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0279     int nr = sensor_attr->index;
0280     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0281     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
0282 }
0283 
0284 static ssize_t temp_max_show(struct device *dev,
0285                  struct device_attribute *attr, char *buf)
0286 {
0287     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0288     int nr = sensor_attr->index;
0289     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0290     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
0291 }
0292 
0293 static ssize_t temp_min_store(struct device *dev,
0294                   struct device_attribute *attr, const char *buf,
0295                   size_t count)
0296 {
0297     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0298     int nr = sensor_attr->index;
0299     struct smsc47m192_data *data = dev_get_drvdata(dev);
0300     struct i2c_client *client = data->client;
0301     long val;
0302     int err;
0303 
0304     err = kstrtol(buf, 10, &val);
0305     if (err)
0306         return err;
0307 
0308     mutex_lock(&data->update_lock);
0309     data->temp_min[nr] = TEMP_TO_REG(val);
0310     i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MIN[nr],
0311                         data->temp_min[nr]);
0312     mutex_unlock(&data->update_lock);
0313     return count;
0314 }
0315 
0316 static ssize_t temp_max_store(struct device *dev,
0317                   struct device_attribute *attr, const char *buf,
0318                   size_t count)
0319 {
0320     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0321     int nr = sensor_attr->index;
0322     struct smsc47m192_data *data = dev_get_drvdata(dev);
0323     struct i2c_client *client = data->client;
0324     long val;
0325     int err;
0326 
0327     err = kstrtol(buf, 10, &val);
0328     if (err)
0329         return err;
0330 
0331     mutex_lock(&data->update_lock);
0332     data->temp_max[nr] = TEMP_TO_REG(val);
0333     i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
0334                         data->temp_max[nr]);
0335     mutex_unlock(&data->update_lock);
0336     return count;
0337 }
0338 
0339 static ssize_t temp_offset_show(struct device *dev,
0340                 struct device_attribute *attr, char *buf)
0341 {
0342     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0343     int nr = sensor_attr->index;
0344     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0345     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
0346 }
0347 
0348 static ssize_t temp_offset_store(struct device *dev,
0349                  struct device_attribute *attr,
0350                  const char *buf, size_t count)
0351 {
0352     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0353     int nr = sensor_attr->index;
0354     struct smsc47m192_data *data = dev_get_drvdata(dev);
0355     struct i2c_client *client = data->client;
0356     u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
0357     long val;
0358     int err;
0359 
0360     err = kstrtol(buf, 10, &val);
0361     if (err)
0362         return err;
0363 
0364     mutex_lock(&data->update_lock);
0365     data->temp_offset[nr] = TEMP_TO_REG(val);
0366     if (nr > 1)
0367         i2c_smbus_write_byte_data(client,
0368             SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
0369     else if (data->temp_offset[nr] != 0) {
0370         /*
0371          * offset[0] and offset[1] share the same register,
0372          * SFR bit 4 activates offset[0]
0373          */
0374         i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
0375                     (sfr & 0xef) | (nr == 0 ? 0x10 : 0));
0376         data->temp_offset[1-nr] = 0;
0377         i2c_smbus_write_byte_data(client,
0378             SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
0379     } else if ((sfr & 0x10) == (nr == 0 ? 0x10 : 0))
0380         i2c_smbus_write_byte_data(client,
0381                     SMSC47M192_REG_TEMP_OFFSET(nr), 0);
0382     mutex_unlock(&data->update_lock);
0383     return count;
0384 }
0385 
0386 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0387 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
0388 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0389 static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
0390 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0391 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
0392 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0393 static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
0394 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0395 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
0396 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
0397 static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
0398 
0399 /* VID */
0400 static ssize_t cpu0_vid_show(struct device *dev,
0401                  struct device_attribute *attr, char *buf)
0402 {
0403     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0404     return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
0405 }
0406 static DEVICE_ATTR_RO(cpu0_vid);
0407 
0408 static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
0409         char *buf)
0410 {
0411     struct smsc47m192_data *data = dev_get_drvdata(dev);
0412     return sprintf(buf, "%d\n", data->vrm);
0413 }
0414 
0415 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
0416              const char *buf, size_t count)
0417 {
0418     struct smsc47m192_data *data = dev_get_drvdata(dev);
0419     unsigned long val;
0420     int err;
0421 
0422     err = kstrtoul(buf, 10, &val);
0423     if (err)
0424         return err;
0425     if (val > 255)
0426         return -EINVAL;
0427 
0428     data->vrm = val;
0429     return count;
0430 }
0431 static DEVICE_ATTR_RW(vrm);
0432 
0433 /* Alarms */
0434 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0435               char *buf)
0436 {
0437     struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
0438     int nr = sensor_attr->index;
0439     struct smsc47m192_data *data = smsc47m192_update_device(dev);
0440     return sprintf(buf, "%u\n", (data->alarms & nr) ? 1 : 0);
0441 }
0442 
0443 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0x0010);
0444 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0x0020);
0445 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0x0040);
0446 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 0x4000);
0447 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 0x8000);
0448 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0x0001);
0449 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0x0002);
0450 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 0x0004);
0451 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 0x0008);
0452 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 0x0100);
0453 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 0x0200);
0454 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 0x0400);
0455 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 0x0800);
0456 
0457 static struct attribute *smsc47m192_attributes[] = {
0458     &sensor_dev_attr_in0_input.dev_attr.attr,
0459     &sensor_dev_attr_in0_min.dev_attr.attr,
0460     &sensor_dev_attr_in0_max.dev_attr.attr,
0461     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0462     &sensor_dev_attr_in1_input.dev_attr.attr,
0463     &sensor_dev_attr_in1_min.dev_attr.attr,
0464     &sensor_dev_attr_in1_max.dev_attr.attr,
0465     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0466     &sensor_dev_attr_in2_input.dev_attr.attr,
0467     &sensor_dev_attr_in2_min.dev_attr.attr,
0468     &sensor_dev_attr_in2_max.dev_attr.attr,
0469     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0470     &sensor_dev_attr_in3_input.dev_attr.attr,
0471     &sensor_dev_attr_in3_min.dev_attr.attr,
0472     &sensor_dev_attr_in3_max.dev_attr.attr,
0473     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0474     &sensor_dev_attr_in5_input.dev_attr.attr,
0475     &sensor_dev_attr_in5_min.dev_attr.attr,
0476     &sensor_dev_attr_in5_max.dev_attr.attr,
0477     &sensor_dev_attr_in5_alarm.dev_attr.attr,
0478     &sensor_dev_attr_in6_input.dev_attr.attr,
0479     &sensor_dev_attr_in6_min.dev_attr.attr,
0480     &sensor_dev_attr_in6_max.dev_attr.attr,
0481     &sensor_dev_attr_in6_alarm.dev_attr.attr,
0482     &sensor_dev_attr_in7_input.dev_attr.attr,
0483     &sensor_dev_attr_in7_min.dev_attr.attr,
0484     &sensor_dev_attr_in7_max.dev_attr.attr,
0485     &sensor_dev_attr_in7_alarm.dev_attr.attr,
0486 
0487     &sensor_dev_attr_temp1_input.dev_attr.attr,
0488     &sensor_dev_attr_temp1_max.dev_attr.attr,
0489     &sensor_dev_attr_temp1_min.dev_attr.attr,
0490     &sensor_dev_attr_temp1_offset.dev_attr.attr,
0491     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0492     &sensor_dev_attr_temp2_input.dev_attr.attr,
0493     &sensor_dev_attr_temp2_max.dev_attr.attr,
0494     &sensor_dev_attr_temp2_min.dev_attr.attr,
0495     &sensor_dev_attr_temp2_offset.dev_attr.attr,
0496     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0497     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0498     &sensor_dev_attr_temp3_input.dev_attr.attr,
0499     &sensor_dev_attr_temp3_max.dev_attr.attr,
0500     &sensor_dev_attr_temp3_min.dev_attr.attr,
0501     &sensor_dev_attr_temp3_offset.dev_attr.attr,
0502     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0503     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0504 
0505     &dev_attr_cpu0_vid.attr,
0506     &dev_attr_vrm.attr,
0507     NULL
0508 };
0509 
0510 static const struct attribute_group smsc47m192_group = {
0511     .attrs = smsc47m192_attributes,
0512 };
0513 
0514 static struct attribute *smsc47m192_attributes_in4[] = {
0515     &sensor_dev_attr_in4_input.dev_attr.attr,
0516     &sensor_dev_attr_in4_min.dev_attr.attr,
0517     &sensor_dev_attr_in4_max.dev_attr.attr,
0518     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0519     NULL
0520 };
0521 
0522 static const struct attribute_group smsc47m192_group_in4 = {
0523     .attrs = smsc47m192_attributes_in4,
0524 };
0525 
0526 static void smsc47m192_init_client(struct i2c_client *client)
0527 {
0528     int i;
0529     u8 config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
0530     u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
0531 
0532     /* select cycle mode (pause 1 sec between updates) */
0533     i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
0534                         (sfr & 0xfd) | 0x02);
0535     if (!(config & 0x01)) {
0536         /* initialize alarm limits */
0537         for (i = 0; i < 8; i++) {
0538             i2c_smbus_write_byte_data(client,
0539                 SMSC47M192_REG_IN_MIN(i), 0);
0540             i2c_smbus_write_byte_data(client,
0541                 SMSC47M192_REG_IN_MAX(i), 0xff);
0542         }
0543         for (i = 0; i < 3; i++) {
0544             i2c_smbus_write_byte_data(client,
0545                 SMSC47M192_REG_TEMP_MIN[i], 0x80);
0546             i2c_smbus_write_byte_data(client,
0547                 SMSC47M192_REG_TEMP_MAX[i], 0x7f);
0548         }
0549 
0550         /* start monitoring */
0551         i2c_smbus_write_byte_data(client, SMSC47M192_REG_CONFIG,
0552                         (config & 0xf7) | 0x01);
0553     }
0554 }
0555 
0556 /* Return 0 if detection is successful, -ENODEV otherwise */
0557 static int smsc47m192_detect(struct i2c_client *client,
0558                  struct i2c_board_info *info)
0559 {
0560     struct i2c_adapter *adapter = client->adapter;
0561     int version;
0562 
0563     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0564         return -ENODEV;
0565 
0566     /* Detection criteria from sensors_detect script */
0567     version = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VERSION);
0568     if (i2c_smbus_read_byte_data(client,
0569                 SMSC47M192_REG_COMPANY_ID) == 0x55
0570      && (version & 0xf0) == 0x20
0571      && (i2c_smbus_read_byte_data(client,
0572                 SMSC47M192_REG_VID) & 0x70) == 0x00
0573      && (i2c_smbus_read_byte_data(client,
0574                 SMSC47M192_REG_VID4) & 0xfe) == 0x80) {
0575         dev_info(&adapter->dev,
0576              "found SMSC47M192 or compatible, "
0577              "version 2, stepping A%d\n", version & 0x0f);
0578     } else {
0579         dev_dbg(&adapter->dev,
0580             "SMSC47M192 detection failed at 0x%02x\n",
0581             client->addr);
0582         return -ENODEV;
0583     }
0584 
0585     strlcpy(info->type, "smsc47m192", I2C_NAME_SIZE);
0586 
0587     return 0;
0588 }
0589 
0590 static int smsc47m192_probe(struct i2c_client *client)
0591 {
0592     struct device *dev = &client->dev;
0593     struct device *hwmon_dev;
0594     struct smsc47m192_data *data;
0595     int config;
0596 
0597     data = devm_kzalloc(dev, sizeof(struct smsc47m192_data), GFP_KERNEL);
0598     if (!data)
0599         return -ENOMEM;
0600 
0601     data->client = client;
0602     data->vrm = vid_which_vrm();
0603     mutex_init(&data->update_lock);
0604 
0605     /* Initialize the SMSC47M192 chip */
0606     smsc47m192_init_client(client);
0607 
0608     /* sysfs hooks */
0609     data->groups[0] = &smsc47m192_group;
0610     /* Pin 110 is either in4 (+12V) or VID4 */
0611     config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
0612     if (!(config & 0x20))
0613         data->groups[1] = &smsc47m192_group_in4;
0614 
0615     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0616                                data, data->groups);
0617     return PTR_ERR_OR_ZERO(hwmon_dev);
0618 }
0619 
0620 static const struct i2c_device_id smsc47m192_id[] = {
0621     { "smsc47m192", 0 },
0622     { }
0623 };
0624 MODULE_DEVICE_TABLE(i2c, smsc47m192_id);
0625 
0626 static struct i2c_driver smsc47m192_driver = {
0627     .class      = I2C_CLASS_HWMON,
0628     .driver = {
0629         .name   = "smsc47m192",
0630     },
0631     .probe_new  = smsc47m192_probe,
0632     .id_table   = smsc47m192_id,
0633     .detect     = smsc47m192_detect,
0634     .address_list   = normal_i2c,
0635 };
0636 
0637 module_i2c_driver(smsc47m192_driver);
0638 
0639 MODULE_AUTHOR("Hartmut Rick <linux@rick.claranet.de>");
0640 MODULE_DESCRIPTION("SMSC47M192 driver");
0641 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!