Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for Texas Instruments / National Semiconductor LM95234
0004  *
0005  * Copyright (c) 2013, 2014 Guenter Roeck <linux@roeck-us.net>
0006  *
0007  * Derived from lm95241.c
0008  * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com>
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 #include <linux/sysfs.h>
0021 
0022 #define DRVNAME "lm95234"
0023 
0024 enum chips { lm95233, lm95234 };
0025 
0026 static const unsigned short normal_i2c[] = {
0027     0x18, 0x2a, 0x2b, 0x4d, 0x4e, I2C_CLIENT_END };
0028 
0029 /* LM95234 registers */
0030 #define LM95234_REG_MAN_ID      0xFE
0031 #define LM95234_REG_CHIP_ID     0xFF
0032 #define LM95234_REG_STATUS      0x02
0033 #define LM95234_REG_CONFIG      0x03
0034 #define LM95234_REG_CONVRATE        0x04
0035 #define LM95234_REG_STS_FAULT       0x07
0036 #define LM95234_REG_STS_TCRIT1      0x08
0037 #define LM95234_REG_STS_TCRIT2      0x09
0038 #define LM95234_REG_TEMPH(x)        ((x) + 0x10)
0039 #define LM95234_REG_TEMPL(x)        ((x) + 0x20)
0040 #define LM95234_REG_UTEMPH(x)       ((x) + 0x19)    /* Remote only */
0041 #define LM95234_REG_UTEMPL(x)       ((x) + 0x29)
0042 #define LM95234_REG_REM_MODEL       0x30
0043 #define LM95234_REG_REM_MODEL_STS   0x38
0044 #define LM95234_REG_OFFSET(x)       ((x) + 0x31)    /* Remote only */
0045 #define LM95234_REG_TCRIT1(x)       ((x) + 0x40)
0046 #define LM95234_REG_TCRIT2(x)       ((x) + 0x49)    /* Remote channel 1,2 */
0047 #define LM95234_REG_TCRIT_HYST      0x5a
0048 
0049 #define NATSEMI_MAN_ID          0x01
0050 #define LM95233_CHIP_ID         0x89
0051 #define LM95234_CHIP_ID         0x79
0052 
0053 /* Client data (each client gets its own) */
0054 struct lm95234_data {
0055     struct i2c_client *client;
0056     const struct attribute_group *groups[3];
0057     struct mutex update_lock;
0058     unsigned long last_updated, interval;   /* in jiffies */
0059     bool valid;     /* false until following fields are valid */
0060     /* registers values */
0061     int temp[5];        /* temperature (signed) */
0062     u32 status;     /* fault/alarm status */
0063     u8 tcrit1[5];       /* critical temperature limit */
0064     u8 tcrit2[2];       /* high temperature limit */
0065     s8 toffset[4];      /* remote temperature offset */
0066     u8 thyst;       /* common hysteresis */
0067 
0068     u8 sensor_type;     /* temperature sensor type */
0069 };
0070 
0071 static int lm95234_read_temp(struct i2c_client *client, int index, int *t)
0072 {
0073     int val;
0074     u16 temp = 0;
0075 
0076     if (index) {
0077         val = i2c_smbus_read_byte_data(client,
0078                            LM95234_REG_UTEMPH(index - 1));
0079         if (val < 0)
0080             return val;
0081         temp = val << 8;
0082         val = i2c_smbus_read_byte_data(client,
0083                            LM95234_REG_UTEMPL(index - 1));
0084         if (val < 0)
0085             return val;
0086         temp |= val;
0087         *t = temp;
0088     }
0089     /*
0090      * Read signed temperature if unsigned temperature is 0,
0091      * or if this is the local sensor.
0092      */
0093     if (!temp) {
0094         val = i2c_smbus_read_byte_data(client,
0095                            LM95234_REG_TEMPH(index));
0096         if (val < 0)
0097             return val;
0098         temp = val << 8;
0099         val = i2c_smbus_read_byte_data(client,
0100                            LM95234_REG_TEMPL(index));
0101         if (val < 0)
0102             return val;
0103         temp |= val;
0104         *t = (s16)temp;
0105     }
0106     return 0;
0107 }
0108 
0109 static u16 update_intervals[] = { 143, 364, 1000, 2500 };
0110 
0111 /* Fill value cache. Must be called with update lock held. */
0112 
0113 static int lm95234_fill_cache(struct lm95234_data *data,
0114                   struct i2c_client *client)
0115 {
0116     int i, ret;
0117 
0118     ret = i2c_smbus_read_byte_data(client, LM95234_REG_CONVRATE);
0119     if (ret < 0)
0120         return ret;
0121 
0122     data->interval = msecs_to_jiffies(update_intervals[ret & 0x03]);
0123 
0124     for (i = 0; i < ARRAY_SIZE(data->tcrit1); i++) {
0125         ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT1(i));
0126         if (ret < 0)
0127             return ret;
0128         data->tcrit1[i] = ret;
0129     }
0130     for (i = 0; i < ARRAY_SIZE(data->tcrit2); i++) {
0131         ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT2(i));
0132         if (ret < 0)
0133             return ret;
0134         data->tcrit2[i] = ret;
0135     }
0136     for (i = 0; i < ARRAY_SIZE(data->toffset); i++) {
0137         ret = i2c_smbus_read_byte_data(client, LM95234_REG_OFFSET(i));
0138         if (ret < 0)
0139             return ret;
0140         data->toffset[i] = ret;
0141     }
0142 
0143     ret = i2c_smbus_read_byte_data(client, LM95234_REG_TCRIT_HYST);
0144     if (ret < 0)
0145         return ret;
0146     data->thyst = ret;
0147 
0148     ret = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
0149     if (ret < 0)
0150         return ret;
0151     data->sensor_type = ret;
0152 
0153     return 0;
0154 }
0155 
0156 static int lm95234_update_device(struct lm95234_data *data)
0157 {
0158     struct i2c_client *client = data->client;
0159     int ret;
0160 
0161     mutex_lock(&data->update_lock);
0162 
0163     if (time_after(jiffies, data->last_updated + data->interval) ||
0164         !data->valid) {
0165         int i;
0166 
0167         if (!data->valid) {
0168             ret = lm95234_fill_cache(data, client);
0169             if (ret < 0)
0170                 goto abort;
0171         }
0172 
0173         data->valid = false;
0174         for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
0175             ret = lm95234_read_temp(client, i, &data->temp[i]);
0176             if (ret < 0)
0177                 goto abort;
0178         }
0179 
0180         ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_FAULT);
0181         if (ret < 0)
0182             goto abort;
0183         data->status = ret;
0184 
0185         ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_TCRIT1);
0186         if (ret < 0)
0187             goto abort;
0188         data->status |= ret << 8;
0189 
0190         ret = i2c_smbus_read_byte_data(client, LM95234_REG_STS_TCRIT2);
0191         if (ret < 0)
0192             goto abort;
0193         data->status |= ret << 16;
0194 
0195         data->last_updated = jiffies;
0196         data->valid = true;
0197     }
0198     ret = 0;
0199 abort:
0200     mutex_unlock(&data->update_lock);
0201 
0202     return ret;
0203 }
0204 
0205 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0206              char *buf)
0207 {
0208     struct lm95234_data *data = dev_get_drvdata(dev);
0209     int index = to_sensor_dev_attr(attr)->index;
0210     int ret = lm95234_update_device(data);
0211 
0212     if (ret)
0213         return ret;
0214 
0215     return sprintf(buf, "%d\n",
0216                DIV_ROUND_CLOSEST(data->temp[index] * 125, 32));
0217 }
0218 
0219 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0220               char *buf)
0221 {
0222     struct lm95234_data *data = dev_get_drvdata(dev);
0223     u32 mask = to_sensor_dev_attr(attr)->index;
0224     int ret = lm95234_update_device(data);
0225 
0226     if (ret)
0227         return ret;
0228 
0229     return sprintf(buf, "%u", !!(data->status & mask));
0230 }
0231 
0232 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
0233              char *buf)
0234 {
0235     struct lm95234_data *data = dev_get_drvdata(dev);
0236     u8 mask = to_sensor_dev_attr(attr)->index;
0237     int ret = lm95234_update_device(data);
0238 
0239     if (ret)
0240         return ret;
0241 
0242     return sprintf(buf, data->sensor_type & mask ? "1\n" : "2\n");
0243 }
0244 
0245 static ssize_t type_store(struct device *dev, struct device_attribute *attr,
0246               const char *buf, size_t count)
0247 {
0248     struct lm95234_data *data = dev_get_drvdata(dev);
0249     unsigned long val;
0250     u8 mask = to_sensor_dev_attr(attr)->index;
0251     int ret = lm95234_update_device(data);
0252 
0253     if (ret)
0254         return ret;
0255 
0256     ret = kstrtoul(buf, 10, &val);
0257     if (ret < 0)
0258         return ret;
0259 
0260     if (val != 1 && val != 2)
0261         return -EINVAL;
0262 
0263     mutex_lock(&data->update_lock);
0264     if (val == 1)
0265         data->sensor_type |= mask;
0266     else
0267         data->sensor_type &= ~mask;
0268     data->valid = false;
0269     i2c_smbus_write_byte_data(data->client, LM95234_REG_REM_MODEL,
0270                   data->sensor_type);
0271     mutex_unlock(&data->update_lock);
0272 
0273     return count;
0274 }
0275 
0276 static ssize_t tcrit2_show(struct device *dev, struct device_attribute *attr,
0277                char *buf)
0278 {
0279     struct lm95234_data *data = dev_get_drvdata(dev);
0280     int index = to_sensor_dev_attr(attr)->index;
0281     int ret = lm95234_update_device(data);
0282 
0283     if (ret)
0284         return ret;
0285 
0286     return sprintf(buf, "%u", data->tcrit2[index] * 1000);
0287 }
0288 
0289 static ssize_t tcrit2_store(struct device *dev, struct device_attribute *attr,
0290                 const char *buf, size_t count)
0291 {
0292     struct lm95234_data *data = dev_get_drvdata(dev);
0293     int index = to_sensor_dev_attr(attr)->index;
0294     long val;
0295     int ret = lm95234_update_device(data);
0296 
0297     if (ret)
0298         return ret;
0299 
0300     ret = kstrtol(buf, 10, &val);
0301     if (ret < 0)
0302         return ret;
0303 
0304     val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, index ? 255 : 127);
0305 
0306     mutex_lock(&data->update_lock);
0307     data->tcrit2[index] = val;
0308     i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT2(index), val);
0309     mutex_unlock(&data->update_lock);
0310 
0311     return count;
0312 }
0313 
0314 static ssize_t tcrit2_hyst_show(struct device *dev,
0315                 struct device_attribute *attr, char *buf)
0316 {
0317     struct lm95234_data *data = dev_get_drvdata(dev);
0318     int index = to_sensor_dev_attr(attr)->index;
0319     int ret = lm95234_update_device(data);
0320 
0321     if (ret)
0322         return ret;
0323 
0324     /* Result can be negative, so be careful with unsigned operands */
0325     return sprintf(buf, "%d",
0326                ((int)data->tcrit2[index] - (int)data->thyst) * 1000);
0327 }
0328 
0329 static ssize_t tcrit1_show(struct device *dev, struct device_attribute *attr,
0330                char *buf)
0331 {
0332     struct lm95234_data *data = dev_get_drvdata(dev);
0333     int index = to_sensor_dev_attr(attr)->index;
0334 
0335     return sprintf(buf, "%u", data->tcrit1[index] * 1000);
0336 }
0337 
0338 static ssize_t tcrit1_store(struct device *dev, struct device_attribute *attr,
0339                 const char *buf, size_t count)
0340 {
0341     struct lm95234_data *data = dev_get_drvdata(dev);
0342     int index = to_sensor_dev_attr(attr)->index;
0343     int ret = lm95234_update_device(data);
0344     long val;
0345 
0346     if (ret)
0347         return ret;
0348 
0349     ret = kstrtol(buf, 10, &val);
0350     if (ret < 0)
0351         return ret;
0352 
0353     val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, 255);
0354 
0355     mutex_lock(&data->update_lock);
0356     data->tcrit1[index] = val;
0357     i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT1(index), val);
0358     mutex_unlock(&data->update_lock);
0359 
0360     return count;
0361 }
0362 
0363 static ssize_t tcrit1_hyst_show(struct device *dev,
0364                 struct device_attribute *attr, char *buf)
0365 {
0366     struct lm95234_data *data = dev_get_drvdata(dev);
0367     int index = to_sensor_dev_attr(attr)->index;
0368     int ret = lm95234_update_device(data);
0369 
0370     if (ret)
0371         return ret;
0372 
0373     /* Result can be negative, so be careful with unsigned operands */
0374     return sprintf(buf, "%d",
0375                ((int)data->tcrit1[index] - (int)data->thyst) * 1000);
0376 }
0377 
0378 static ssize_t tcrit1_hyst_store(struct device *dev,
0379                  struct device_attribute *attr,
0380                  const char *buf, size_t count)
0381 {
0382     struct lm95234_data *data = dev_get_drvdata(dev);
0383     int index = to_sensor_dev_attr(attr)->index;
0384     int ret = lm95234_update_device(data);
0385     long val;
0386 
0387     if (ret)
0388         return ret;
0389 
0390     ret = kstrtol(buf, 10, &val);
0391     if (ret < 0)
0392         return ret;
0393 
0394     val = DIV_ROUND_CLOSEST(val, 1000);
0395     val = clamp_val((int)data->tcrit1[index] - val, 0, 31);
0396 
0397     mutex_lock(&data->update_lock);
0398     data->thyst = val;
0399     i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT_HYST, val);
0400     mutex_unlock(&data->update_lock);
0401 
0402     return count;
0403 }
0404 
0405 static ssize_t offset_show(struct device *dev, struct device_attribute *attr,
0406                char *buf)
0407 {
0408     struct lm95234_data *data = dev_get_drvdata(dev);
0409     int index = to_sensor_dev_attr(attr)->index;
0410     int ret = lm95234_update_device(data);
0411 
0412     if (ret)
0413         return ret;
0414 
0415     return sprintf(buf, "%d", data->toffset[index] * 500);
0416 }
0417 
0418 static ssize_t offset_store(struct device *dev, struct device_attribute *attr,
0419                 const char *buf, size_t count)
0420 {
0421     struct lm95234_data *data = dev_get_drvdata(dev);
0422     int index = to_sensor_dev_attr(attr)->index;
0423     int ret = lm95234_update_device(data);
0424     long val;
0425 
0426     if (ret)
0427         return ret;
0428 
0429     ret = kstrtol(buf, 10, &val);
0430     if (ret < 0)
0431         return ret;
0432 
0433     /* Accuracy is 1/2 degrees C */
0434     val = clamp_val(DIV_ROUND_CLOSEST(val, 500), -128, 127);
0435 
0436     mutex_lock(&data->update_lock);
0437     data->toffset[index] = val;
0438     i2c_smbus_write_byte_data(data->client, LM95234_REG_OFFSET(index), val);
0439     mutex_unlock(&data->update_lock);
0440 
0441     return count;
0442 }
0443 
0444 static ssize_t update_interval_show(struct device *dev,
0445                     struct device_attribute *attr, char *buf)
0446 {
0447     struct lm95234_data *data = dev_get_drvdata(dev);
0448     int ret = lm95234_update_device(data);
0449 
0450     if (ret)
0451         return ret;
0452 
0453     return sprintf(buf, "%lu\n",
0454                DIV_ROUND_CLOSEST(data->interval * 1000, HZ));
0455 }
0456 
0457 static ssize_t update_interval_store(struct device *dev,
0458                      struct device_attribute *attr,
0459                      const char *buf, size_t count)
0460 {
0461     struct lm95234_data *data = dev_get_drvdata(dev);
0462     int ret = lm95234_update_device(data);
0463     unsigned long val;
0464     u8 regval;
0465 
0466     if (ret)
0467         return ret;
0468 
0469     ret = kstrtoul(buf, 10, &val);
0470     if (ret < 0)
0471         return ret;
0472 
0473     for (regval = 0; regval < 3; regval++) {
0474         if (val <= update_intervals[regval])
0475             break;
0476     }
0477 
0478     mutex_lock(&data->update_lock);
0479     data->interval = msecs_to_jiffies(update_intervals[regval]);
0480     i2c_smbus_write_byte_data(data->client, LM95234_REG_CONVRATE, regval);
0481     mutex_unlock(&data->update_lock);
0482 
0483     return count;
0484 }
0485 
0486 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0487 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0488 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0489 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
0490 static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
0491 
0492 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, BIT(0) | BIT(1));
0493 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, BIT(2) | BIT(3));
0494 static SENSOR_DEVICE_ATTR_RO(temp4_fault, alarm, BIT(4) | BIT(5));
0495 static SENSOR_DEVICE_ATTR_RO(temp5_fault, alarm, BIT(6) | BIT(7));
0496 
0497 static SENSOR_DEVICE_ATTR_RW(temp2_type, type, BIT(1));
0498 static SENSOR_DEVICE_ATTR_RW(temp3_type, type, BIT(2));
0499 static SENSOR_DEVICE_ATTR_RW(temp4_type, type, BIT(3));
0500 static SENSOR_DEVICE_ATTR_RW(temp5_type, type, BIT(4));
0501 
0502 static SENSOR_DEVICE_ATTR_RW(temp1_max, tcrit1, 0);
0503 static SENSOR_DEVICE_ATTR_RW(temp2_max, tcrit2, 0);
0504 static SENSOR_DEVICE_ATTR_RW(temp3_max, tcrit2, 1);
0505 static SENSOR_DEVICE_ATTR_RW(temp4_max, tcrit1, 3);
0506 static SENSOR_DEVICE_ATTR_RW(temp5_max, tcrit1, 4);
0507 
0508 static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, tcrit1_hyst, 0);
0509 static SENSOR_DEVICE_ATTR_RO(temp2_max_hyst, tcrit2_hyst, 0);
0510 static SENSOR_DEVICE_ATTR_RO(temp3_max_hyst, tcrit2_hyst, 1);
0511 static SENSOR_DEVICE_ATTR_RO(temp4_max_hyst, tcrit1_hyst, 3);
0512 static SENSOR_DEVICE_ATTR_RO(temp5_max_hyst, tcrit1_hyst, 4);
0513 
0514 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, BIT(0 + 8));
0515 static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, BIT(1 + 16));
0516 static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, BIT(2 + 16));
0517 static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, alarm, BIT(3 + 8));
0518 static SENSOR_DEVICE_ATTR_RO(temp5_max_alarm, alarm, BIT(4 + 8));
0519 
0520 static SENSOR_DEVICE_ATTR_RW(temp2_crit, tcrit1, 1);
0521 static SENSOR_DEVICE_ATTR_RW(temp3_crit, tcrit1, 2);
0522 
0523 static SENSOR_DEVICE_ATTR_RO(temp2_crit_hyst, tcrit1_hyst, 1);
0524 static SENSOR_DEVICE_ATTR_RO(temp3_crit_hyst, tcrit1_hyst, 2);
0525 
0526 static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, BIT(1 + 8));
0527 static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, BIT(2 + 8));
0528 
0529 static SENSOR_DEVICE_ATTR_RW(temp2_offset, offset, 0);
0530 static SENSOR_DEVICE_ATTR_RW(temp3_offset, offset, 1);
0531 static SENSOR_DEVICE_ATTR_RW(temp4_offset, offset, 2);
0532 static SENSOR_DEVICE_ATTR_RW(temp5_offset, offset, 3);
0533 
0534 static DEVICE_ATTR_RW(update_interval);
0535 
0536 static struct attribute *lm95234_common_attrs[] = {
0537     &sensor_dev_attr_temp1_input.dev_attr.attr,
0538     &sensor_dev_attr_temp2_input.dev_attr.attr,
0539     &sensor_dev_attr_temp3_input.dev_attr.attr,
0540     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0541     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0542     &sensor_dev_attr_temp2_type.dev_attr.attr,
0543     &sensor_dev_attr_temp3_type.dev_attr.attr,
0544     &sensor_dev_attr_temp1_max.dev_attr.attr,
0545     &sensor_dev_attr_temp2_max.dev_attr.attr,
0546     &sensor_dev_attr_temp3_max.dev_attr.attr,
0547     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
0548     &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
0549     &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
0550     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0551     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
0552     &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
0553     &sensor_dev_attr_temp2_crit.dev_attr.attr,
0554     &sensor_dev_attr_temp3_crit.dev_attr.attr,
0555     &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
0556     &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
0557     &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
0558     &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
0559     &sensor_dev_attr_temp2_offset.dev_attr.attr,
0560     &sensor_dev_attr_temp3_offset.dev_attr.attr,
0561     &dev_attr_update_interval.attr,
0562     NULL
0563 };
0564 
0565 static const struct attribute_group lm95234_common_group = {
0566     .attrs = lm95234_common_attrs,
0567 };
0568 
0569 static struct attribute *lm95234_attrs[] = {
0570     &sensor_dev_attr_temp4_input.dev_attr.attr,
0571     &sensor_dev_attr_temp5_input.dev_attr.attr,
0572     &sensor_dev_attr_temp4_fault.dev_attr.attr,
0573     &sensor_dev_attr_temp5_fault.dev_attr.attr,
0574     &sensor_dev_attr_temp4_type.dev_attr.attr,
0575     &sensor_dev_attr_temp5_type.dev_attr.attr,
0576     &sensor_dev_attr_temp4_max.dev_attr.attr,
0577     &sensor_dev_attr_temp5_max.dev_attr.attr,
0578     &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
0579     &sensor_dev_attr_temp5_max_hyst.dev_attr.attr,
0580     &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
0581     &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
0582     &sensor_dev_attr_temp4_offset.dev_attr.attr,
0583     &sensor_dev_attr_temp5_offset.dev_attr.attr,
0584     NULL
0585 };
0586 
0587 static const struct attribute_group lm95234_group = {
0588     .attrs = lm95234_attrs,
0589 };
0590 
0591 static int lm95234_detect(struct i2c_client *client,
0592               struct i2c_board_info *info)
0593 {
0594     struct i2c_adapter *adapter = client->adapter;
0595     int address = client->addr;
0596     u8 config_mask, model_mask;
0597     int mfg_id, chip_id, val;
0598     const char *name;
0599 
0600     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0601         return -ENODEV;
0602 
0603     mfg_id = i2c_smbus_read_byte_data(client, LM95234_REG_MAN_ID);
0604     if (mfg_id != NATSEMI_MAN_ID)
0605         return -ENODEV;
0606 
0607     chip_id = i2c_smbus_read_byte_data(client, LM95234_REG_CHIP_ID);
0608     switch (chip_id) {
0609     case LM95233_CHIP_ID:
0610         if (address != 0x18 && address != 0x2a && address != 0x2b)
0611             return -ENODEV;
0612         config_mask = 0xbf;
0613         model_mask = 0xf9;
0614         name = "lm95233";
0615         break;
0616     case LM95234_CHIP_ID:
0617         if (address != 0x18 && address != 0x4d && address != 0x4e)
0618             return -ENODEV;
0619         config_mask = 0xbc;
0620         model_mask = 0xe1;
0621         name = "lm95234";
0622         break;
0623     default:
0624         return -ENODEV;
0625     }
0626 
0627     val = i2c_smbus_read_byte_data(client, LM95234_REG_STATUS);
0628     if (val & 0x30)
0629         return -ENODEV;
0630 
0631     val = i2c_smbus_read_byte_data(client, LM95234_REG_CONFIG);
0632     if (val & config_mask)
0633         return -ENODEV;
0634 
0635     val = i2c_smbus_read_byte_data(client, LM95234_REG_CONVRATE);
0636     if (val & 0xfc)
0637         return -ENODEV;
0638 
0639     val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
0640     if (val & model_mask)
0641         return -ENODEV;
0642 
0643     val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL_STS);
0644     if (val & model_mask)
0645         return -ENODEV;
0646 
0647     strlcpy(info->type, name, I2C_NAME_SIZE);
0648     return 0;
0649 }
0650 
0651 static int lm95234_init_client(struct i2c_client *client)
0652 {
0653     int val, model;
0654 
0655     /* start conversion if necessary */
0656     val = i2c_smbus_read_byte_data(client, LM95234_REG_CONFIG);
0657     if (val < 0)
0658         return val;
0659     if (val & 0x40)
0660         i2c_smbus_write_byte_data(client, LM95234_REG_CONFIG,
0661                       val & ~0x40);
0662 
0663     /* If diode type status reports an error, try to fix it */
0664     val = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL_STS);
0665     if (val < 0)
0666         return val;
0667     model = i2c_smbus_read_byte_data(client, LM95234_REG_REM_MODEL);
0668     if (model < 0)
0669         return model;
0670     if (model & val) {
0671         dev_notice(&client->dev,
0672                "Fixing remote diode type misconfiguration (0x%x)\n",
0673                val);
0674         i2c_smbus_write_byte_data(client, LM95234_REG_REM_MODEL,
0675                       model & ~val);
0676     }
0677     return 0;
0678 }
0679 
0680 static const struct i2c_device_id lm95234_id[];
0681 
0682 static int lm95234_probe(struct i2c_client *client)
0683 {
0684     struct device *dev = &client->dev;
0685     struct lm95234_data *data;
0686     struct device *hwmon_dev;
0687     int err;
0688 
0689     data = devm_kzalloc(dev, sizeof(struct lm95234_data), GFP_KERNEL);
0690     if (!data)
0691         return -ENOMEM;
0692 
0693     data->client = client;
0694     mutex_init(&data->update_lock);
0695 
0696     /* Initialize the LM95234 chip */
0697     err = lm95234_init_client(client);
0698     if (err < 0)
0699         return err;
0700 
0701     data->groups[0] = &lm95234_common_group;
0702     if (i2c_match_id(lm95234_id, client)->driver_data == lm95234)
0703         data->groups[1] = &lm95234_group;
0704 
0705     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0706                                data, data->groups);
0707     return PTR_ERR_OR_ZERO(hwmon_dev);
0708 }
0709 
0710 /* Driver data (common to all clients) */
0711 static const struct i2c_device_id lm95234_id[] = {
0712     { "lm95233", lm95233 },
0713     { "lm95234", lm95234 },
0714     { }
0715 };
0716 MODULE_DEVICE_TABLE(i2c, lm95234_id);
0717 
0718 static struct i2c_driver lm95234_driver = {
0719     .class      = I2C_CLASS_HWMON,
0720     .driver = {
0721         .name   = DRVNAME,
0722     },
0723     .probe_new  = lm95234_probe,
0724     .id_table   = lm95234_id,
0725     .detect     = lm95234_detect,
0726     .address_list   = normal_i2c,
0727 };
0728 
0729 module_i2c_driver(lm95234_driver);
0730 
0731 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
0732 MODULE_DESCRIPTION("LM95233/LM95234 sensor driver");
0733 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!