Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * emc6w201.c - Hardware monitoring driver for the SMSC EMC6W201
0004  * Copyright (C) 2011  Jean Delvare <jdelvare@suse.de>
0005  */
0006 
0007 #include <linux/module.h>
0008 #include <linux/init.h>
0009 #include <linux/slab.h>
0010 #include <linux/jiffies.h>
0011 #include <linux/i2c.h>
0012 #include <linux/hwmon.h>
0013 #include <linux/hwmon-sysfs.h>
0014 #include <linux/err.h>
0015 #include <linux/mutex.h>
0016 
0017 /*
0018  * Addresses to scan
0019  */
0020 
0021 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0022 
0023 /*
0024  * The EMC6W201 registers
0025  */
0026 
0027 #define EMC6W201_REG_IN(nr)     (0x20 + (nr))
0028 #define EMC6W201_REG_TEMP(nr)       (0x26 + (nr))
0029 #define EMC6W201_REG_FAN(nr)        (0x2C + (nr) * 2)
0030 #define EMC6W201_REG_COMPANY        0x3E
0031 #define EMC6W201_REG_VERSTEP        0x3F
0032 #define EMC6W201_REG_CONFIG     0x40
0033 #define EMC6W201_REG_IN_LOW(nr)     (0x4A + (nr) * 2)
0034 #define EMC6W201_REG_IN_HIGH(nr)    (0x4B + (nr) * 2)
0035 #define EMC6W201_REG_TEMP_LOW(nr)   (0x56 + (nr) * 2)
0036 #define EMC6W201_REG_TEMP_HIGH(nr)  (0x57 + (nr) * 2)
0037 #define EMC6W201_REG_FAN_MIN(nr)    (0x62 + (nr) * 2)
0038 
0039 enum subfeature { input, min, max };
0040 
0041 /*
0042  * Per-device data
0043  */
0044 
0045 struct emc6w201_data {
0046     struct i2c_client *client;
0047     struct mutex update_lock;
0048     bool valid; /* false until following fields are valid */
0049     unsigned long last_updated; /* in jiffies */
0050 
0051     /* registers values */
0052     u8 in[3][6];
0053     s8 temp[3][6];
0054     u16 fan[2][5];
0055 };
0056 
0057 /*
0058  * Combine LSB and MSB registers in a single value
0059  * Locking: must be called with data->update_lock held
0060  */
0061 static u16 emc6w201_read16(struct i2c_client *client, u8 reg)
0062 {
0063     int lsb, msb;
0064 
0065     lsb = i2c_smbus_read_byte_data(client, reg);
0066     msb = i2c_smbus_read_byte_data(client, reg + 1);
0067     if (unlikely(lsb < 0 || msb < 0)) {
0068         dev_err(&client->dev, "%d-bit %s failed at 0x%02x\n",
0069             16, "read", reg);
0070         return 0xFFFF;  /* Arbitrary value */
0071     }
0072 
0073     return (msb << 8) | lsb;
0074 }
0075 
0076 /*
0077  * Write 16-bit value to LSB and MSB registers
0078  * Locking: must be called with data->update_lock held
0079  */
0080 static int emc6w201_write16(struct i2c_client *client, u8 reg, u16 val)
0081 {
0082     int err;
0083 
0084     err = i2c_smbus_write_byte_data(client, reg, val & 0xff);
0085     if (likely(!err))
0086         err = i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
0087     if (unlikely(err < 0))
0088         dev_err(&client->dev, "%d-bit %s failed at 0x%02x\n",
0089             16, "write", reg);
0090 
0091     return err;
0092 }
0093 
0094 /* Read 8-bit value from register */
0095 static u8 emc6w201_read8(struct i2c_client *client, u8 reg)
0096 {
0097     int val;
0098 
0099     val = i2c_smbus_read_byte_data(client, reg);
0100     if (unlikely(val < 0)) {
0101         dev_err(&client->dev, "%d-bit %s failed at 0x%02x\n",
0102             8, "read", reg);
0103         return 0x00;    /* Arbitrary value */
0104     }
0105 
0106     return val;
0107 }
0108 
0109 /* Write 8-bit value to register */
0110 static int emc6w201_write8(struct i2c_client *client, u8 reg, u8 val)
0111 {
0112     int err;
0113 
0114     err = i2c_smbus_write_byte_data(client, reg, val);
0115     if (unlikely(err < 0))
0116         dev_err(&client->dev, "%d-bit %s failed at 0x%02x\n",
0117             8, "write", reg);
0118 
0119     return err;
0120 }
0121 
0122 static struct emc6w201_data *emc6w201_update_device(struct device *dev)
0123 {
0124     struct emc6w201_data *data = dev_get_drvdata(dev);
0125     struct i2c_client *client = data->client;
0126     int nr;
0127 
0128     mutex_lock(&data->update_lock);
0129 
0130     if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
0131         for (nr = 0; nr < 6; nr++) {
0132             data->in[input][nr] =
0133                 emc6w201_read8(client,
0134                         EMC6W201_REG_IN(nr));
0135             data->in[min][nr] =
0136                 emc6w201_read8(client,
0137                         EMC6W201_REG_IN_LOW(nr));
0138             data->in[max][nr] =
0139                 emc6w201_read8(client,
0140                         EMC6W201_REG_IN_HIGH(nr));
0141         }
0142 
0143         for (nr = 0; nr < 6; nr++) {
0144             data->temp[input][nr] =
0145                 emc6w201_read8(client,
0146                         EMC6W201_REG_TEMP(nr));
0147             data->temp[min][nr] =
0148                 emc6w201_read8(client,
0149                         EMC6W201_REG_TEMP_LOW(nr));
0150             data->temp[max][nr] =
0151                 emc6w201_read8(client,
0152                         EMC6W201_REG_TEMP_HIGH(nr));
0153         }
0154 
0155         for (nr = 0; nr < 5; nr++) {
0156             data->fan[input][nr] =
0157                 emc6w201_read16(client,
0158                         EMC6W201_REG_FAN(nr));
0159             data->fan[min][nr] =
0160                 emc6w201_read16(client,
0161                         EMC6W201_REG_FAN_MIN(nr));
0162         }
0163 
0164         data->last_updated = jiffies;
0165         data->valid = true;
0166     }
0167 
0168     mutex_unlock(&data->update_lock);
0169 
0170     return data;
0171 }
0172 
0173 /*
0174  * Sysfs callback functions
0175  */
0176 
0177 static const s16 nominal_mv[6] = { 2500, 1500, 3300, 5000, 1500, 1500 };
0178 
0179 static ssize_t in_show(struct device *dev, struct device_attribute *devattr,
0180                char *buf)
0181 {
0182     struct emc6w201_data *data = emc6w201_update_device(dev);
0183     int sf = to_sensor_dev_attr_2(devattr)->index;
0184     int nr = to_sensor_dev_attr_2(devattr)->nr;
0185 
0186     return sprintf(buf, "%u\n",
0187                (unsigned)data->in[sf][nr] * nominal_mv[nr] / 0xC0);
0188 }
0189 
0190 static ssize_t in_store(struct device *dev, struct device_attribute *devattr,
0191             const char *buf, size_t count)
0192 {
0193     struct emc6w201_data *data = dev_get_drvdata(dev);
0194     struct i2c_client *client = data->client;
0195     int sf = to_sensor_dev_attr_2(devattr)->index;
0196     int nr = to_sensor_dev_attr_2(devattr)->nr;
0197     int err;
0198     long val;
0199     u8 reg;
0200 
0201     err = kstrtol(buf, 10, &val);
0202     if (err < 0)
0203         return err;
0204 
0205     val = clamp_val(val, 0, 255 * nominal_mv[nr] / 192);
0206     val = DIV_ROUND_CLOSEST(val * 192, nominal_mv[nr]);
0207     reg = (sf == min) ? EMC6W201_REG_IN_LOW(nr)
0208               : EMC6W201_REG_IN_HIGH(nr);
0209 
0210     mutex_lock(&data->update_lock);
0211     data->in[sf][nr] = val;
0212     err = emc6w201_write8(client, reg, data->in[sf][nr]);
0213     mutex_unlock(&data->update_lock);
0214 
0215     return err < 0 ? err : count;
0216 }
0217 
0218 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
0219              char *buf)
0220 {
0221     struct emc6w201_data *data = emc6w201_update_device(dev);
0222     int sf = to_sensor_dev_attr_2(devattr)->index;
0223     int nr = to_sensor_dev_attr_2(devattr)->nr;
0224 
0225     return sprintf(buf, "%d\n", (int)data->temp[sf][nr] * 1000);
0226 }
0227 
0228 static ssize_t temp_store(struct device *dev,
0229               struct device_attribute *devattr, const char *buf,
0230               size_t count)
0231 {
0232     struct emc6w201_data *data = dev_get_drvdata(dev);
0233     struct i2c_client *client = data->client;
0234     int sf = to_sensor_dev_attr_2(devattr)->index;
0235     int nr = to_sensor_dev_attr_2(devattr)->nr;
0236     int err;
0237     long val;
0238     u8 reg;
0239 
0240     err = kstrtol(buf, 10, &val);
0241     if (err < 0)
0242         return err;
0243 
0244     val = clamp_val(val, -127000, 127000);
0245     val = DIV_ROUND_CLOSEST(val, 1000);
0246     reg = (sf == min) ? EMC6W201_REG_TEMP_LOW(nr)
0247               : EMC6W201_REG_TEMP_HIGH(nr);
0248 
0249     mutex_lock(&data->update_lock);
0250     data->temp[sf][nr] = val;
0251     err = emc6w201_write8(client, reg, data->temp[sf][nr]);
0252     mutex_unlock(&data->update_lock);
0253 
0254     return err < 0 ? err : count;
0255 }
0256 
0257 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
0258             char *buf)
0259 {
0260     struct emc6w201_data *data = emc6w201_update_device(dev);
0261     int sf = to_sensor_dev_attr_2(devattr)->index;
0262     int nr = to_sensor_dev_attr_2(devattr)->nr;
0263     unsigned rpm;
0264 
0265     if (data->fan[sf][nr] == 0 || data->fan[sf][nr] == 0xFFFF)
0266         rpm = 0;
0267     else
0268         rpm = 5400000U / data->fan[sf][nr];
0269 
0270     return sprintf(buf, "%u\n", rpm);
0271 }
0272 
0273 static ssize_t fan_store(struct device *dev, struct device_attribute *devattr,
0274              const char *buf, size_t count)
0275 {
0276     struct emc6w201_data *data = dev_get_drvdata(dev);
0277     struct i2c_client *client = data->client;
0278     int sf = to_sensor_dev_attr_2(devattr)->index;
0279     int nr = to_sensor_dev_attr_2(devattr)->nr;
0280     int err;
0281     unsigned long val;
0282 
0283     err = kstrtoul(buf, 10, &val);
0284     if (err < 0)
0285         return err;
0286 
0287     if (val == 0) {
0288         val = 0xFFFF;
0289     } else {
0290         val = DIV_ROUND_CLOSEST(5400000U, val);
0291         val = clamp_val(val, 0, 0xFFFE);
0292     }
0293 
0294     mutex_lock(&data->update_lock);
0295     data->fan[sf][nr] = val;
0296     err = emc6w201_write16(client, EMC6W201_REG_FAN_MIN(nr),
0297                    data->fan[sf][nr]);
0298     mutex_unlock(&data->update_lock);
0299 
0300     return err < 0 ? err : count;
0301 }
0302 
0303 static SENSOR_DEVICE_ATTR_2_RO(in0_input, in, 0, input);
0304 static SENSOR_DEVICE_ATTR_2_RW(in0_min, in, 0, min);
0305 static SENSOR_DEVICE_ATTR_2_RW(in0_max, in, 0, max);
0306 static SENSOR_DEVICE_ATTR_2_RO(in1_input, in, 1, input);
0307 static SENSOR_DEVICE_ATTR_2_RW(in1_min, in, 1, min);
0308 static SENSOR_DEVICE_ATTR_2_RW(in1_max, in, 1, max);
0309 static SENSOR_DEVICE_ATTR_2_RO(in2_input, in, 2, input);
0310 static SENSOR_DEVICE_ATTR_2_RW(in2_min, in, 2, min);
0311 static SENSOR_DEVICE_ATTR_2_RW(in2_max, in, 2, max);
0312 static SENSOR_DEVICE_ATTR_2_RO(in3_input, in, 3, input);
0313 static SENSOR_DEVICE_ATTR_2_RW(in3_min, in, 3, min);
0314 static SENSOR_DEVICE_ATTR_2_RW(in3_max, in, 3, max);
0315 static SENSOR_DEVICE_ATTR_2_RO(in4_input, in, 4, input);
0316 static SENSOR_DEVICE_ATTR_2_RW(in4_min, in, 4, min);
0317 static SENSOR_DEVICE_ATTR_2_RW(in4_max, in, 4, max);
0318 static SENSOR_DEVICE_ATTR_2_RO(in5_input, in, 5, input);
0319 static SENSOR_DEVICE_ATTR_2_RW(in5_min, in, 5, min);
0320 static SENSOR_DEVICE_ATTR_2_RW(in5_max, in, 5, max);
0321 
0322 static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0, input);
0323 static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 0, min);
0324 static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 0, max);
0325 static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 1, input);
0326 static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 1, min);
0327 static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 1, max);
0328 static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 2, input);
0329 static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 2, min);
0330 static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 2, max);
0331 static SENSOR_DEVICE_ATTR_2_RO(temp4_input, temp, 3, input);
0332 static SENSOR_DEVICE_ATTR_2_RW(temp4_min, temp, 3, min);
0333 static SENSOR_DEVICE_ATTR_2_RW(temp4_max, temp, 3, max);
0334 static SENSOR_DEVICE_ATTR_2_RO(temp5_input, temp, 4, input);
0335 static SENSOR_DEVICE_ATTR_2_RW(temp5_min, temp, 4, min);
0336 static SENSOR_DEVICE_ATTR_2_RW(temp5_max, temp, 4, max);
0337 static SENSOR_DEVICE_ATTR_2_RO(temp6_input, temp, 5, input);
0338 static SENSOR_DEVICE_ATTR_2_RW(temp6_min, temp, 5, min);
0339 static SENSOR_DEVICE_ATTR_2_RW(temp6_max, temp, 5, max);
0340 
0341 static SENSOR_DEVICE_ATTR_2_RO(fan1_input, fan, 0, input);
0342 static SENSOR_DEVICE_ATTR_2_RW(fan1_min, fan, 0, min);
0343 static SENSOR_DEVICE_ATTR_2_RO(fan2_input, fan, 1, input);
0344 static SENSOR_DEVICE_ATTR_2_RW(fan2_min, fan, 1, min);
0345 static SENSOR_DEVICE_ATTR_2_RO(fan3_input, fan, 2, input);
0346 static SENSOR_DEVICE_ATTR_2_RW(fan3_min, fan, 2, min);
0347 static SENSOR_DEVICE_ATTR_2_RO(fan4_input, fan, 3, input);
0348 static SENSOR_DEVICE_ATTR_2_RW(fan4_min, fan, 3, min);
0349 static SENSOR_DEVICE_ATTR_2_RO(fan5_input, fan, 4, input);
0350 static SENSOR_DEVICE_ATTR_2_RW(fan5_min, fan, 4, min);
0351 
0352 static struct attribute *emc6w201_attrs[] = {
0353     &sensor_dev_attr_in0_input.dev_attr.attr,
0354     &sensor_dev_attr_in0_min.dev_attr.attr,
0355     &sensor_dev_attr_in0_max.dev_attr.attr,
0356     &sensor_dev_attr_in1_input.dev_attr.attr,
0357     &sensor_dev_attr_in1_min.dev_attr.attr,
0358     &sensor_dev_attr_in1_max.dev_attr.attr,
0359     &sensor_dev_attr_in2_input.dev_attr.attr,
0360     &sensor_dev_attr_in2_min.dev_attr.attr,
0361     &sensor_dev_attr_in2_max.dev_attr.attr,
0362     &sensor_dev_attr_in3_input.dev_attr.attr,
0363     &sensor_dev_attr_in3_min.dev_attr.attr,
0364     &sensor_dev_attr_in3_max.dev_attr.attr,
0365     &sensor_dev_attr_in4_input.dev_attr.attr,
0366     &sensor_dev_attr_in4_min.dev_attr.attr,
0367     &sensor_dev_attr_in4_max.dev_attr.attr,
0368     &sensor_dev_attr_in5_input.dev_attr.attr,
0369     &sensor_dev_attr_in5_min.dev_attr.attr,
0370     &sensor_dev_attr_in5_max.dev_attr.attr,
0371 
0372     &sensor_dev_attr_temp1_input.dev_attr.attr,
0373     &sensor_dev_attr_temp1_min.dev_attr.attr,
0374     &sensor_dev_attr_temp1_max.dev_attr.attr,
0375     &sensor_dev_attr_temp2_input.dev_attr.attr,
0376     &sensor_dev_attr_temp2_min.dev_attr.attr,
0377     &sensor_dev_attr_temp2_max.dev_attr.attr,
0378     &sensor_dev_attr_temp3_input.dev_attr.attr,
0379     &sensor_dev_attr_temp3_min.dev_attr.attr,
0380     &sensor_dev_attr_temp3_max.dev_attr.attr,
0381     &sensor_dev_attr_temp4_input.dev_attr.attr,
0382     &sensor_dev_attr_temp4_min.dev_attr.attr,
0383     &sensor_dev_attr_temp4_max.dev_attr.attr,
0384     &sensor_dev_attr_temp5_input.dev_attr.attr,
0385     &sensor_dev_attr_temp5_min.dev_attr.attr,
0386     &sensor_dev_attr_temp5_max.dev_attr.attr,
0387     &sensor_dev_attr_temp6_input.dev_attr.attr,
0388     &sensor_dev_attr_temp6_min.dev_attr.attr,
0389     &sensor_dev_attr_temp6_max.dev_attr.attr,
0390 
0391     &sensor_dev_attr_fan1_input.dev_attr.attr,
0392     &sensor_dev_attr_fan1_min.dev_attr.attr,
0393     &sensor_dev_attr_fan2_input.dev_attr.attr,
0394     &sensor_dev_attr_fan2_min.dev_attr.attr,
0395     &sensor_dev_attr_fan3_input.dev_attr.attr,
0396     &sensor_dev_attr_fan3_min.dev_attr.attr,
0397     &sensor_dev_attr_fan4_input.dev_attr.attr,
0398     &sensor_dev_attr_fan4_min.dev_attr.attr,
0399     &sensor_dev_attr_fan5_input.dev_attr.attr,
0400     &sensor_dev_attr_fan5_min.dev_attr.attr,
0401     NULL
0402 };
0403 
0404 ATTRIBUTE_GROUPS(emc6w201);
0405 
0406 /*
0407  * Driver interface
0408  */
0409 
0410 /* Return 0 if detection is successful, -ENODEV otherwise */
0411 static int emc6w201_detect(struct i2c_client *client,
0412                struct i2c_board_info *info)
0413 {
0414     struct i2c_adapter *adapter = client->adapter;
0415     int company, verstep, config;
0416 
0417     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0418         return -ENODEV;
0419 
0420     /* Identification */
0421     company = i2c_smbus_read_byte_data(client, EMC6W201_REG_COMPANY);
0422     if (company != 0x5C)
0423         return -ENODEV;
0424     verstep = i2c_smbus_read_byte_data(client, EMC6W201_REG_VERSTEP);
0425     if (verstep < 0 || (verstep & 0xF0) != 0xB0)
0426         return -ENODEV;
0427     if ((verstep & 0x0F) > 2) {
0428         dev_dbg(&client->dev, "Unknown EMC6W201 stepping %d\n",
0429             verstep & 0x0F);
0430         return -ENODEV;
0431     }
0432 
0433     /* Check configuration */
0434     config = i2c_smbus_read_byte_data(client, EMC6W201_REG_CONFIG);
0435     if (config < 0 || (config & 0xF4) != 0x04)
0436         return -ENODEV;
0437     if (!(config & 0x01)) {
0438         dev_err(&client->dev, "Monitoring not enabled\n");
0439         return -ENODEV;
0440     }
0441 
0442     strlcpy(info->type, "emc6w201", I2C_NAME_SIZE);
0443 
0444     return 0;
0445 }
0446 
0447 static int emc6w201_probe(struct i2c_client *client)
0448 {
0449     struct device *dev = &client->dev;
0450     struct emc6w201_data *data;
0451     struct device *hwmon_dev;
0452 
0453     data = devm_kzalloc(dev, sizeof(struct emc6w201_data), GFP_KERNEL);
0454     if (!data)
0455         return -ENOMEM;
0456 
0457     data->client = client;
0458     mutex_init(&data->update_lock);
0459 
0460     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0461                                data,
0462                                emc6w201_groups);
0463     return PTR_ERR_OR_ZERO(hwmon_dev);
0464 }
0465 
0466 static const struct i2c_device_id emc6w201_id[] = {
0467     { "emc6w201", 0 },
0468     { }
0469 };
0470 MODULE_DEVICE_TABLE(i2c, emc6w201_id);
0471 
0472 static struct i2c_driver emc6w201_driver = {
0473     .class      = I2C_CLASS_HWMON,
0474     .driver = {
0475         .name   = "emc6w201",
0476     },
0477     .probe_new  = emc6w201_probe,
0478     .id_table   = emc6w201_id,
0479     .detect     = emc6w201_detect,
0480     .address_list   = normal_i2c,
0481 };
0482 
0483 module_i2c_driver(emc6w201_driver);
0484 
0485 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
0486 MODULE_DESCRIPTION("SMSC EMC6W201 hardware monitoring driver");
0487 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!