drivers/hwmon/max1668.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2011 David George <david.george@ska.ac.za>
0004  *
0005  * based on adm1021.c
0006  * some credit to Christoph Scheurer, but largely a rewrite
0007  */
0008
0009 #include <linux/module.h>
0010 #include <linux/init.h>
0011 #include <linux/slab.h>
0012 #include <linux/jiffies.h>
0013 #include <linux/i2c.h>
0014 #include <linux/hwmon.h>
0015 #include <linux/hwmon-sysfs.h>
0016 #include <linux/err.h>
0017 #include <linux/mutex.h>
0018
0019 /* Addresses to scan */
0020 static const unsigned short max1668_addr_list[] = {
0021     0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
0022
0023 /* max1668 registers */
0024
0025 #define MAX1668_REG_TEMP(nr)    (nr)
0026 #define MAX1668_REG_STAT1   0x05
0027 #define MAX1668_REG_STAT2   0x06
0028 #define MAX1668_REG_MAN_ID  0xfe
0029 #define MAX1668_REG_DEV_ID  0xff
0030
0031 /* limits */
0032
0033 /* write high limits */
0034 #define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr))
0035 /* write low limits */
0036 #define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr))
0037 /* read high limits */
0038 #define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr))
0039 /* read low limits */
0040 #define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr))
0041
0042 /* manufacturer and device ID Constants */
0043 #define MAN_ID_MAXIM        0x4d
0044 #define DEV_ID_MAX1668      0x3
0045 #define DEV_ID_MAX1805      0x5
0046 #define DEV_ID_MAX1989      0xb
0047
0048 /* read only mode module parameter */
0049 static bool read_only;
0050 module_param(read_only, bool, 0);
0051 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
0052
0053 enum chips { max1668, max1805, max1989 };
0054
0055 struct max1668_data {
0056     struct i2c_client *client;
0057     const struct attribute_group *groups[3];
0058     enum chips type;
0059
0060     struct mutex update_lock;
0061     bool valid;     /* true if following fields are valid */
0062     unsigned long last_updated; /* In jiffies */
0063
0064     /* 1x local and 4x remote */
0065     s8 temp_max[5];
0066     s8 temp_min[5];
0067     s8 temp[5];
0068     u16 alarms;
0069 };
0070
0071 static struct max1668_data *max1668_update_device(struct device *dev)
0072 {
0073     struct max1668_data *data = dev_get_drvdata(dev);
0074     struct i2c_client *client = data->client;
0075     struct max1668_data *ret = data;
0076     s32 val;
0077     int i;
0078
0079     mutex_lock(&data->update_lock);
0080
0081     if (data->valid && !time_after(jiffies,
0082             data->last_updated + HZ + HZ / 2))
0083         goto abort;
0084
0085     for (i = 0; i < 5; i++) {
0086         val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i));
0087         if (unlikely(val < 0)) {
0088             ret = ERR_PTR(val);
0089             goto abort;
0090         }
0091         data->temp[i] = (s8) val;
0092
0093         val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i));
0094         if (unlikely(val < 0)) {
0095             ret = ERR_PTR(val);
0096             goto abort;
0097         }
0098         data->temp_max[i] = (s8) val;
0099
0100         val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i));
0101         if (unlikely(val < 0)) {
0102             ret = ERR_PTR(val);
0103             goto abort;
0104         }
0105         data->temp_min[i] = (s8) val;
0106     }
0107
0108     val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1);
0109     if (unlikely(val < 0)) {
0110         ret = ERR_PTR(val);
0111         goto abort;
0112     }
0113     data->alarms = val << 8;
0114
0115     val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2);
0116     if (unlikely(val < 0)) {
0117         ret = ERR_PTR(val);
0118         goto abort;
0119     }
0120     data->alarms |= val;
0121
0122     data->last_updated = jiffies;
0123     data->valid = true;
0124 abort:
0125     mutex_unlock(&data->update_lock);
0126
0127     return ret;
0128 }
0129
0130 static ssize_t show_temp(struct device *dev,
0131              struct device_attribute *devattr, char *buf)
0132 {
0133     int index = to_sensor_dev_attr(devattr)->index;
0134     struct max1668_data *data = max1668_update_device(dev);
0135
0136     if (IS_ERR(data))
0137         return PTR_ERR(data);
0138
0139     return sprintf(buf, "%d\n", data->temp[index] * 1000);
0140 }
0141
0142 static ssize_t show_temp_max(struct device *dev,
0143                  struct device_attribute *devattr, char *buf)
0144 {
0145     int index = to_sensor_dev_attr(devattr)->index;
0146     struct max1668_data *data = max1668_update_device(dev);
0147
0148     if (IS_ERR(data))
0149         return PTR_ERR(data);
0150
0151     return sprintf(buf, "%d\n", data->temp_max[index] * 1000);
0152 }
0153
0154 static ssize_t show_temp_min(struct device *dev,
0155                  struct device_attribute *devattr, char *buf)
0156 {
0157     int index = to_sensor_dev_attr(devattr)->index;
0158     struct max1668_data *data = max1668_update_device(dev);
0159
0160     if (IS_ERR(data))
0161         return PTR_ERR(data);
0162
0163     return sprintf(buf, "%d\n", data->temp_min[index] * 1000);
0164 }
0165
0166 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
0167               char *buf)
0168 {
0169     int index = to_sensor_dev_attr(attr)->index;
0170     struct max1668_data *data = max1668_update_device(dev);
0171
0172     if (IS_ERR(data))
0173         return PTR_ERR(data);
0174
0175     return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1);
0176 }
0177
0178 static ssize_t show_fault(struct device *dev,
0179               struct device_attribute *devattr, char *buf)
0180 {
0181     int index = to_sensor_dev_attr(devattr)->index;
0182     struct max1668_data *data = max1668_update_device(dev);
0183
0184     if (IS_ERR(data))
0185         return PTR_ERR(data);
0186
0187     return sprintf(buf, "%u\n",
0188                (data->alarms & (1 << 12)) && data->temp[index] == 127);
0189 }
0190
0191 static ssize_t set_temp_max(struct device *dev,
0192                 struct device_attribute *devattr,
0193                 const char *buf, size_t count)
0194 {
0195     int index = to_sensor_dev_attr(devattr)->index;
0196     struct max1668_data *data = dev_get_drvdata(dev);
0197     struct i2c_client *client = data->client;
0198     long temp;
0199     int ret;
0200
0201     ret = kstrtol(buf, 10, &temp);
0202     if (ret < 0)
0203         return ret;
0204
0205     mutex_lock(&data->update_lock);
0206     data->temp_max[index] = clamp_val(temp/1000, -128, 127);
0207     ret = i2c_smbus_write_byte_data(client,
0208                     MAX1668_REG_LIMH_WR(index),
0209                     data->temp_max[index]);
0210     if (ret < 0)
0211         count = ret;
0212     mutex_unlock(&data->update_lock);
0213
0214     return count;
0215 }
0216
0217 static ssize_t set_temp_min(struct device *dev,
0218                 struct device_attribute *devattr,
0219                 const char *buf, size_t count)
0220 {
0221     int index = to_sensor_dev_attr(devattr)->index;
0222     struct max1668_data *data = dev_get_drvdata(dev);
0223     struct i2c_client *client = data->client;
0224     long temp;
0225     int ret;
0226
0227     ret = kstrtol(buf, 10, &temp);
0228     if (ret < 0)
0229         return ret;
0230
0231     mutex_lock(&data->update_lock);
0232     data->temp_min[index] = clamp_val(temp/1000, -128, 127);
0233     ret = i2c_smbus_write_byte_data(client,
0234                     MAX1668_REG_LIML_WR(index),
0235                     data->temp_min[index]);
0236     if (ret < 0)
0237         count = ret;
0238     mutex_unlock(&data->update_lock);
0239
0240     return count;
0241 }
0242
0243 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
0244 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max,
0245                 set_temp_max, 0);
0246 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min,
0247                 set_temp_min, 0);
0248 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
0249 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max,
0250                 set_temp_max, 1);
0251 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min,
0252                 set_temp_min, 1);
0253 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
0254 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max,
0255                 set_temp_max, 2);
0256 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min,
0257                 set_temp_min, 2);
0258 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
0259 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max,
0260                 set_temp_max, 3);
0261 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min,
0262                 set_temp_min, 3);
0263 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
0264 static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max,
0265                 set_temp_max, 4);
0266 static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min,
0267                 set_temp_min, 4);
0268
0269 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14);
0270 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13);
0271 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7);
0272 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6);
0273 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5);
0274 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
0275 static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3);
0276 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2);
0277 static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1);
0278 static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0);
0279
0280 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1);
0281 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2);
0282 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3);
0283 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4);
0284
0285 /* Attributes common to MAX1668, MAX1989 and MAX1805 */
0286 static struct attribute *max1668_attribute_common[] = {
0287     &sensor_dev_attr_temp1_max.dev_attr.attr,
0288     &sensor_dev_attr_temp1_min.dev_attr.attr,
0289     &sensor_dev_attr_temp1_input.dev_attr.attr,
0290     &sensor_dev_attr_temp2_max.dev_attr.attr,
0291     &sensor_dev_attr_temp2_min.dev_attr.attr,
0292     &sensor_dev_attr_temp2_input.dev_attr.attr,
0293     &sensor_dev_attr_temp3_max.dev_attr.attr,
0294     &sensor_dev_attr_temp3_min.dev_attr.attr,
0295     &sensor_dev_attr_temp3_input.dev_attr.attr,
0296
0297     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0298     &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
0299     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
0300     &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
0301     &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
0302     &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
0303
0304     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0305     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0306     NULL
0307 };
0308
0309 /* Attributes not present on MAX1805 */
0310 static struct attribute *max1668_attribute_unique[] = {
0311     &sensor_dev_attr_temp4_max.dev_attr.attr,
0312     &sensor_dev_attr_temp4_min.dev_attr.attr,
0313     &sensor_dev_attr_temp4_input.dev_attr.attr,
0314     &sensor_dev_attr_temp5_max.dev_attr.attr,
0315     &sensor_dev_attr_temp5_min.dev_attr.attr,
0316     &sensor_dev_attr_temp5_input.dev_attr.attr,
0317
0318     &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
0319     &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
0320     &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
0321     &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
0322
0323     &sensor_dev_attr_temp4_fault.dev_attr.attr,
0324     &sensor_dev_attr_temp5_fault.dev_attr.attr,
0325     NULL
0326 };
0327
0328 static umode_t max1668_attribute_mode(struct kobject *kobj,
0329                      struct attribute *attr, int index)
0330 {
0331     umode_t ret = S_IRUGO;
0332     if (read_only)
0333         return ret;
0334     if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr ||
0335         attr == &sensor_dev_attr_temp2_max.dev_attr.attr ||
0336         attr == &sensor_dev_attr_temp3_max.dev_attr.attr ||
0337         attr == &sensor_dev_attr_temp4_max.dev_attr.attr ||
0338         attr == &sensor_dev_attr_temp5_max.dev_attr.attr ||
0339         attr == &sensor_dev_attr_temp1_min.dev_attr.attr ||
0340         attr == &sensor_dev_attr_temp2_min.dev_attr.attr ||
0341         attr == &sensor_dev_attr_temp3_min.dev_attr.attr ||
0342         attr == &sensor_dev_attr_temp4_min.dev_attr.attr ||
0343         attr == &sensor_dev_attr_temp5_min.dev_attr.attr)
0344         ret |= S_IWUSR;
0345     return ret;
0346 }
0347
0348 static const struct attribute_group max1668_group_common = {
0349     .attrs = max1668_attribute_common,
0350     .is_visible = max1668_attribute_mode
0351 };
0352
0353 static const struct attribute_group max1668_group_unique = {
0354     .attrs = max1668_attribute_unique,
0355     .is_visible = max1668_attribute_mode
0356 };
0357
0358 /* Return 0 if detection is successful, -ENODEV otherwise */
0359 static int max1668_detect(struct i2c_client *client,
0360               struct i2c_board_info *info)
0361 {
0362     struct i2c_adapter *adapter = client->adapter;
0363     const char *type_name;
0364     int man_id, dev_id;
0365
0366     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0367         return -ENODEV;
0368
0369     /* Check for unsupported part */
0370     man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID);
0371     if (man_id != MAN_ID_MAXIM)
0372         return -ENODEV;
0373
0374     dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID);
0375     if (dev_id < 0)
0376         return -ENODEV;
0377
0378     type_name = NULL;
0379     if (dev_id == DEV_ID_MAX1668)
0380         type_name = "max1668";
0381     else if (dev_id == DEV_ID_MAX1805)
0382         type_name = "max1805";
0383     else if (dev_id == DEV_ID_MAX1989)
0384         type_name = "max1989";
0385
0386     if (!type_name)
0387         return -ENODEV;
0388
0389     strlcpy(info->type, type_name, I2C_NAME_SIZE);
0390
0391     return 0;
0392 }
0393
0394 static const struct i2c_device_id max1668_id[];
0395
0396 static int max1668_probe(struct i2c_client *client)
0397 {
0398     struct i2c_adapter *adapter = client->adapter;
0399     struct device *dev = &client->dev;
0400     struct device *hwmon_dev;
0401     struct max1668_data *data;
0402
0403     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0404         return -ENODEV;
0405
0406     data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL);
0407     if (!data)
0408         return -ENOMEM;
0409
0410     data->client = client;
0411     data->type = i2c_match_id(max1668_id, client)->driver_data;
0412     mutex_init(&data->update_lock);
0413
0414     /* sysfs hooks */
0415     data->groups[0] = &max1668_group_common;
0416     if (data->type == max1668 || data->type == max1989)
0417         data->groups[1] = &max1668_group_unique;
0418
0419     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0420                                data, data->groups);
0421     return PTR_ERR_OR_ZERO(hwmon_dev);
0422 }
0423
0424 static const struct i2c_device_id max1668_id[] = {
0425     { "max1668", max1668 },
0426     { "max1805", max1805 },
0427     { "max1989", max1989 },
0428     { }
0429 };
0430 MODULE_DEVICE_TABLE(i2c, max1668_id);
0431
0432 /* This is the driver that will be inserted */
0433 static struct i2c_driver max1668_driver = {
0434     .class = I2C_CLASS_HWMON,
0435     .driver = {
0436           .name = "max1668",
0437           },
0438     .probe_new = max1668_probe,
0439     .id_table = max1668_id,
0440     .detect = max1668_detect,
0441     .address_list = max1668_addr_list,
0442 };
0443
0444 module_i2c_driver(max1668_driver);
0445
0446 MODULE_AUTHOR("David George <david.george@ska.ac.za>");
0447 MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver");
0448 MODULE_LICENSE("GPL");