drivers/hwmon/thmc50.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * thmc50.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *        monitoring
0005  * Copyright (C) 2007 Krzysztof Helt <krzysztof.h1@wp.pl>
0006  * Based on 2.4 driver by Frodo Looijaard <frodol@dds.nl> and
0007  * Philip Edelbrock <phil@netroedge.com>
0008  */
0009
0010 #include <linux/module.h>
0011 #include <linux/init.h>
0012 #include <linux/slab.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 #include <linux/jiffies.h>
0019
0020 MODULE_LICENSE("GPL");
0021
0022 /* Addresses to scan */
0023 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0024
0025 /* Insmod parameters */
0026 enum chips { thmc50, adm1022 };
0027
0028 static unsigned short adm1022_temp3[16];
0029 static unsigned int adm1022_temp3_num;
0030 module_param_array(adm1022_temp3, ushort, &adm1022_temp3_num, 0);
0031 MODULE_PARM_DESC(adm1022_temp3,
0032          "List of adapter,address pairs to enable 3rd temperature (ADM1022 only)");
0033
0034 /* Many THMC50 constants specified below */
0035
0036 /* The THMC50 registers */
0037 #define THMC50_REG_CONF             0x40
0038 #define THMC50_REG_COMPANY_ID           0x3E
0039 #define THMC50_REG_DIE_CODE         0x3F
0040 #define THMC50_REG_ANALOG_OUT           0x19
0041 /*
0042  * The mirror status register cannot be used as
0043  * reading it does not clear alarms.
0044  */
0045 #define THMC50_REG_INTR             0x41
0046
0047 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 };
0048 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C };
0049 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B };
0050 static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 };
0051 static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 };
0052
0053 #define THMC50_REG_CONF_nFANOFF         0x20
0054 #define THMC50_REG_CONF_PROGRAMMED      0x08
0055
0056 /* Each client has this additional data */
0057 struct thmc50_data {
0058     struct i2c_client *client;
0059     const struct attribute_group *groups[3];
0060
0061     struct mutex update_lock;
0062     enum chips type;
0063     unsigned long last_updated; /* In jiffies */
0064     char has_temp3;     /* !=0 if it is ADM1022 in temp3 mode */
0065     bool valid;     /* true if following fields are valid */
0066
0067     /* Register values */
0068     s8 temp_input[3];
0069     s8 temp_max[3];
0070     s8 temp_min[3];
0071     s8 temp_critical[3];
0072     u8 analog_out;
0073     u8 alarms;
0074 };
0075
0076 static struct thmc50_data *thmc50_update_device(struct device *dev)
0077 {
0078     struct thmc50_data *data = dev_get_drvdata(dev);
0079     struct i2c_client *client = data->client;
0080     int timeout = HZ / 5 + (data->type == thmc50 ? HZ : 0);
0081
0082     mutex_lock(&data->update_lock);
0083
0084     if (time_after(jiffies, data->last_updated + timeout)
0085         || !data->valid) {
0086
0087         int temps = data->has_temp3 ? 3 : 2;
0088         int i;
0089         int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
0090
0091         prog &= THMC50_REG_CONF_PROGRAMMED;
0092
0093         for (i = 0; i < temps; i++) {
0094             data->temp_input[i] = i2c_smbus_read_byte_data(client,
0095                         THMC50_REG_TEMP[i]);
0096             data->temp_max[i] = i2c_smbus_read_byte_data(client,
0097                         THMC50_REG_TEMP_MAX[i]);
0098             data->temp_min[i] = i2c_smbus_read_byte_data(client,
0099                         THMC50_REG_TEMP_MIN[i]);
0100             data->temp_critical[i] =
0101                 i2c_smbus_read_byte_data(client,
0102                     prog ? THMC50_REG_TEMP_CRITICAL[i]
0103                          : THMC50_REG_TEMP_DEFAULT[i]);
0104         }
0105         data->analog_out =
0106             i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT);
0107         data->alarms =
0108             i2c_smbus_read_byte_data(client, THMC50_REG_INTR);
0109         data->last_updated = jiffies;
0110         data->valid = true;
0111     }
0112
0113     mutex_unlock(&data->update_lock);
0114
0115     return data;
0116 }
0117
0118 static ssize_t analog_out_show(struct device *dev,
0119                    struct device_attribute *attr, char *buf)
0120 {
0121     struct thmc50_data *data = thmc50_update_device(dev);
0122     return sprintf(buf, "%d\n", data->analog_out);
0123 }
0124
0125 static ssize_t analog_out_store(struct device *dev,
0126                 struct device_attribute *attr,
0127                 const char *buf, size_t count)
0128 {
0129     struct thmc50_data *data = dev_get_drvdata(dev);
0130     struct i2c_client *client = data->client;
0131     int config;
0132     unsigned long tmp;
0133     int err;
0134
0135     err = kstrtoul(buf, 10, &tmp);
0136     if (err)
0137         return err;
0138
0139     mutex_lock(&data->update_lock);
0140     data->analog_out = clamp_val(tmp, 0, 255);
0141     i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
0142                   data->analog_out);
0143
0144     config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
0145     if (data->analog_out == 0)
0146         config &= ~THMC50_REG_CONF_nFANOFF;
0147     else
0148         config |= THMC50_REG_CONF_nFANOFF;
0149     i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
0150
0151     mutex_unlock(&data->update_lock);
0152     return count;
0153 }
0154
0155 /* There is only one PWM mode = DC */
0156 static ssize_t pwm_mode_show(struct device *dev,
0157                  struct device_attribute *attr, char *buf)
0158 {
0159     return sprintf(buf, "0\n");
0160 }
0161
0162 /* Temperatures */
0163 static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
0164              char *buf)
0165 {
0166     int nr = to_sensor_dev_attr(attr)->index;
0167     struct thmc50_data *data = thmc50_update_device(dev);
0168     return sprintf(buf, "%d\n", data->temp_input[nr] * 1000);
0169 }
0170
0171 static ssize_t temp_min_show(struct device *dev,
0172                  struct device_attribute *attr, char *buf)
0173 {
0174     int nr = to_sensor_dev_attr(attr)->index;
0175     struct thmc50_data *data = thmc50_update_device(dev);
0176     return sprintf(buf, "%d\n", data->temp_min[nr] * 1000);
0177 }
0178
0179 static ssize_t temp_min_store(struct device *dev,
0180                   struct device_attribute *attr, const char *buf,
0181                   size_t count)
0182 {
0183     int nr = to_sensor_dev_attr(attr)->index;
0184     struct thmc50_data *data = dev_get_drvdata(dev);
0185     struct i2c_client *client = data->client;
0186     long val;
0187     int err;
0188
0189     err = kstrtol(buf, 10, &val);
0190     if (err)
0191         return err;
0192
0193     mutex_lock(&data->update_lock);
0194     data->temp_min[nr] = clamp_val(val / 1000, -128, 127);
0195     i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MIN[nr],
0196                   data->temp_min[nr]);
0197     mutex_unlock(&data->update_lock);
0198     return count;
0199 }
0200
0201 static ssize_t temp_max_show(struct device *dev,
0202                  struct device_attribute *attr, char *buf)
0203 {
0204     int nr = to_sensor_dev_attr(attr)->index;
0205     struct thmc50_data *data = thmc50_update_device(dev);
0206     return sprintf(buf, "%d\n", data->temp_max[nr] * 1000);
0207 }
0208
0209 static ssize_t temp_max_store(struct device *dev,
0210                   struct device_attribute *attr, const char *buf,
0211                   size_t count)
0212 {
0213     int nr = to_sensor_dev_attr(attr)->index;
0214     struct thmc50_data *data = dev_get_drvdata(dev);
0215     struct i2c_client *client = data->client;
0216     long val;
0217     int err;
0218
0219     err = kstrtol(buf, 10, &val);
0220     if (err)
0221         return err;
0222
0223     mutex_lock(&data->update_lock);
0224     data->temp_max[nr] = clamp_val(val / 1000, -128, 127);
0225     i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MAX[nr],
0226                   data->temp_max[nr]);
0227     mutex_unlock(&data->update_lock);
0228     return count;
0229 }
0230
0231 static ssize_t temp_critical_show(struct device *dev,
0232                   struct device_attribute *attr, char *buf)
0233 {
0234     int nr = to_sensor_dev_attr(attr)->index;
0235     struct thmc50_data *data = thmc50_update_device(dev);
0236     return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000);
0237 }
0238
0239 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
0240               char *buf)
0241 {
0242     int index = to_sensor_dev_attr(attr)->index;
0243     struct thmc50_data *data = thmc50_update_device(dev);
0244
0245     return sprintf(buf, "%u\n", (data->alarms >> index) & 1);
0246 }
0247
0248 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0249 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
0250 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0251 static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp_critical, 0);
0252 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0253 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
0254 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0255 static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp_critical, 1);
0256 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
0257 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
0258 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
0259 static SENSOR_DEVICE_ATTR_RO(temp3_crit, temp_critical, 2);
0260
0261 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0);
0262 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5);
0263 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
0264 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 7);
0265 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2);
0266
0267 static SENSOR_DEVICE_ATTR_RW(pwm1, analog_out, 0);
0268 static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0);
0269
0270 static struct attribute *thmc50_attributes[] = {
0271     &sensor_dev_attr_temp1_max.dev_attr.attr,
0272     &sensor_dev_attr_temp1_min.dev_attr.attr,
0273     &sensor_dev_attr_temp1_input.dev_attr.attr,
0274     &sensor_dev_attr_temp1_crit.dev_attr.attr,
0275     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0276     &sensor_dev_attr_temp2_max.dev_attr.attr,
0277     &sensor_dev_attr_temp2_min.dev_attr.attr,
0278     &sensor_dev_attr_temp2_input.dev_attr.attr,
0279     &sensor_dev_attr_temp2_crit.dev_attr.attr,
0280     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0281     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0282     &sensor_dev_attr_pwm1.dev_attr.attr,
0283     &sensor_dev_attr_pwm1_mode.dev_attr.attr,
0284     NULL
0285 };
0286
0287 static const struct attribute_group thmc50_group = {
0288     .attrs = thmc50_attributes,
0289 };
0290
0291 /* for ADM1022 3rd temperature mode */
0292 static struct attribute *temp3_attributes[] = {
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     &sensor_dev_attr_temp3_crit.dev_attr.attr,
0297     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0298     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0299     NULL
0300 };
0301
0302 static const struct attribute_group temp3_group = {
0303     .attrs = temp3_attributes,
0304 };
0305
0306 /* Return 0 if detection is successful, -ENODEV otherwise */
0307 static int thmc50_detect(struct i2c_client *client,
0308              struct i2c_board_info *info)
0309 {
0310     unsigned company;
0311     unsigned revision;
0312     unsigned config;
0313     struct i2c_adapter *adapter = client->adapter;
0314     const char *type_name;
0315
0316     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
0317         pr_debug("thmc50: detect failed, smbus byte data not supported!\n");
0318         return -ENODEV;
0319     }
0320
0321     pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n",
0322          client->addr, i2c_adapter_id(client->adapter));
0323
0324     company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID);
0325     revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE);
0326     config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
0327     if (revision < 0xc0 || (config & 0x10))
0328         return -ENODEV;
0329
0330     if (company == 0x41) {
0331         int id = i2c_adapter_id(client->adapter);
0332         int i;
0333
0334         type_name = "adm1022";
0335         for (i = 0; i + 1 < adm1022_temp3_num; i += 2)
0336             if (adm1022_temp3[i] == id &&
0337                 adm1022_temp3[i + 1] == client->addr) {
0338                 /* enable 2nd remote temp */
0339                 config |= (1 << 7);
0340                 i2c_smbus_write_byte_data(client,
0341                               THMC50_REG_CONF,
0342                               config);
0343                 break;
0344             }
0345     } else if (company == 0x49) {
0346         type_name = "thmc50";
0347     } else {
0348         pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n");
0349         return -ENODEV;
0350     }
0351
0352     pr_debug("thmc50: Detected %s (version %x, revision %x)\n",
0353          type_name, (revision >> 4) - 0xc, revision & 0xf);
0354
0355     strlcpy(info->type, type_name, I2C_NAME_SIZE);
0356
0357     return 0;
0358 }
0359
0360 static void thmc50_init_client(struct thmc50_data *data)
0361 {
0362     struct i2c_client *client = data->client;
0363     int config;
0364
0365     data->analog_out = i2c_smbus_read_byte_data(client,
0366                             THMC50_REG_ANALOG_OUT);
0367     /* set up to at least 1 */
0368     if (data->analog_out == 0) {
0369         data->analog_out = 1;
0370         i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT,
0371                       data->analog_out);
0372     }
0373     config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
0374     config |= 0x1;  /* start the chip if it is in standby mode */
0375     if (data->type == adm1022 && (config & (1 << 7)))
0376         data->has_temp3 = 1;
0377     i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config);
0378 }
0379
0380 static const struct i2c_device_id thmc50_id[];
0381
0382 static int thmc50_probe(struct i2c_client *client)
0383 {
0384     struct device *dev = &client->dev;
0385     struct thmc50_data *data;
0386     struct device *hwmon_dev;
0387     int idx = 0;
0388
0389     data = devm_kzalloc(dev, sizeof(struct thmc50_data), GFP_KERNEL);
0390     if (!data)
0391         return -ENOMEM;
0392
0393     data->client = client;
0394     data->type = i2c_match_id(thmc50_id, client)->driver_data;
0395     mutex_init(&data->update_lock);
0396
0397     thmc50_init_client(data);
0398
0399     /* sysfs hooks */
0400     data->groups[idx++] = &thmc50_group;
0401
0402     /* Register additional ADM1022 sysfs hooks */
0403     if (data->has_temp3)
0404         data->groups[idx++] = &temp3_group;
0405
0406     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0407                                data, data->groups);
0408     return PTR_ERR_OR_ZERO(hwmon_dev);
0409 }
0410
0411 static const struct i2c_device_id thmc50_id[] = {
0412     { "adm1022", adm1022 },
0413     { "thmc50", thmc50 },
0414     { }
0415 };
0416 MODULE_DEVICE_TABLE(i2c, thmc50_id);
0417
0418 static struct i2c_driver thmc50_driver = {
0419     .class = I2C_CLASS_HWMON,
0420     .driver = {
0421         .name = "thmc50",
0422     },
0423     .probe_new = thmc50_probe,
0424     .id_table = thmc50_id,
0425     .detect = thmc50_detect,
0426     .address_list = normal_i2c,
0427 };
0428
0429 module_i2c_driver(thmc50_driver);
0430
0431 MODULE_AUTHOR("Krzysztof Helt <krzysztof.h1@wp.pl>");
0432 MODULE_DESCRIPTION("THMC50 driver");