drivers/hwmon/lm83.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * lm83.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *          monitoring
0005  * Copyright (C) 2003-2009  Jean Delvare <jdelvare@suse.de>
0006  *
0007  * Heavily inspired from the lm78, lm75 and adm1021 drivers. The LM83 is
0008  * a sensor chip made by National Semiconductor. It reports up to four
0009  * temperatures (its own plus up to three external ones) with a 1 deg
0010  * resolution and a 3-4 deg accuracy. Complete datasheet can be obtained
0011  * from National's website at:
0012  *   http://www.national.com/pf/LM/LM83.html
0013  * Since the datasheet omits to give the chip stepping code, I give it
0014  * here: 0x03 (at register 0xff).
0015  *
0016  * Also supports the LM82 temp sensor, which is basically a stripped down
0017  * model of the LM83.  Datasheet is here:
0018  * http://www.national.com/pf/LM/LM82.html
0019  */
0020
0021 #include <linux/bits.h>
0022 #include <linux/err.h>
0023 #include <linux/i2c.h>
0024 #include <linux/init.h>
0025 #include <linux/hwmon.h>
0026 #include <linux/module.h>
0027 #include <linux/regmap.h>
0028 #include <linux/slab.h>
0029
0030 /*
0031  * Addresses to scan
0032  * Address is selected using 2 three-level pins, resulting in 9 possible
0033  * addresses.
0034  */
0035
0036 static const unsigned short normal_i2c[] = {
0037     0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
0038
0039 enum chips { lm83, lm82 };
0040
0041 /*
0042  * The LM83 registers
0043  * Manufacturer ID is 0x01 for National Semiconductor.
0044  */
0045
0046 #define LM83_REG_R_MAN_ID       0xFE
0047 #define LM83_REG_R_CHIP_ID      0xFF
0048 #define LM83_REG_R_CONFIG       0x03
0049 #define LM83_REG_W_CONFIG       0x09
0050 #define LM83_REG_R_STATUS1      0x02
0051 #define LM83_REG_R_STATUS2      0x35
0052 #define LM83_REG_R_LOCAL_TEMP       0x00
0053 #define LM83_REG_R_LOCAL_HIGH       0x05
0054 #define LM83_REG_W_LOCAL_HIGH       0x0B
0055 #define LM83_REG_R_REMOTE1_TEMP     0x30
0056 #define LM83_REG_R_REMOTE1_HIGH     0x38
0057 #define LM83_REG_W_REMOTE1_HIGH     0x50
0058 #define LM83_REG_R_REMOTE2_TEMP     0x01
0059 #define LM83_REG_R_REMOTE2_HIGH     0x07
0060 #define LM83_REG_W_REMOTE2_HIGH     0x0D
0061 #define LM83_REG_R_REMOTE3_TEMP     0x31
0062 #define LM83_REG_R_REMOTE3_HIGH     0x3A
0063 #define LM83_REG_W_REMOTE3_HIGH     0x52
0064 #define LM83_REG_R_TCRIT        0x42
0065 #define LM83_REG_W_TCRIT        0x5A
0066
0067 static const u8 LM83_REG_TEMP[] = {
0068     LM83_REG_R_LOCAL_TEMP,
0069     LM83_REG_R_REMOTE1_TEMP,
0070     LM83_REG_R_REMOTE2_TEMP,
0071     LM83_REG_R_REMOTE3_TEMP,
0072 };
0073
0074 static const u8 LM83_REG_MAX[] = {
0075     LM83_REG_R_LOCAL_HIGH,
0076     LM83_REG_R_REMOTE1_HIGH,
0077     LM83_REG_R_REMOTE2_HIGH,
0078     LM83_REG_R_REMOTE3_HIGH,
0079 };
0080
0081 /* alarm and fault registers and bits, indexed by channel */
0082 static const u8 LM83_ALARM_REG[] = {
0083     LM83_REG_R_STATUS1, LM83_REG_R_STATUS2, LM83_REG_R_STATUS1, LM83_REG_R_STATUS2
0084 };
0085
0086 static const u8 LM83_MAX_ALARM_BIT[] = {
0087     BIT(6), BIT(7), BIT(4), BIT(4)
0088 };
0089
0090 static const u8 LM83_CRIT_ALARM_BIT[] = {
0091     BIT(0), BIT(0), BIT(1), BIT(1)
0092 };
0093
0094 static const u8 LM83_FAULT_BIT[] = {
0095     0, BIT(5), BIT(2), BIT(2)
0096 };
0097
0098 /*
0099  * Client data (each client gets its own)
0100  */
0101
0102 struct lm83_data {
0103     struct regmap *regmap;
0104     enum chips type;
0105 };
0106
0107 /* regmap code */
0108
0109 static int lm83_regmap_reg_read(void *context, unsigned int reg, unsigned int *val)
0110 {
0111     struct i2c_client *client = context;
0112     int ret;
0113
0114     ret = i2c_smbus_read_byte_data(client, reg);
0115     if (ret < 0)
0116         return ret;
0117
0118     *val = ret;
0119     return 0;
0120 }
0121
0122 /*
0123  * The regmap write function maps read register addresses to write register
0124  * addresses. This is necessary for regmap register caching to work.
0125  * An alternative would be to clear the regmap cache whenever a register is
0126  * written, but that would be much more expensive.
0127  */
0128 static int lm83_regmap_reg_write(void *context, unsigned int reg, unsigned int val)
0129 {
0130     struct i2c_client *client = context;
0131
0132     switch (reg) {
0133     case LM83_REG_R_CONFIG:
0134     case LM83_REG_R_LOCAL_HIGH:
0135     case LM83_REG_R_REMOTE2_HIGH:
0136         reg += 0x06;
0137         break;
0138     case LM83_REG_R_REMOTE1_HIGH:
0139     case LM83_REG_R_REMOTE3_HIGH:
0140     case LM83_REG_R_TCRIT:
0141         reg += 0x18;
0142         break;
0143     default:
0144         break;
0145     }
0146
0147     return i2c_smbus_write_byte_data(client, reg, val);
0148 }
0149
0150 static bool lm83_regmap_is_volatile(struct device *dev, unsigned int reg)
0151 {
0152     switch (reg) {
0153     case LM83_REG_R_LOCAL_TEMP:
0154     case LM83_REG_R_REMOTE1_TEMP:
0155     case LM83_REG_R_REMOTE2_TEMP:
0156     case LM83_REG_R_REMOTE3_TEMP:
0157     case LM83_REG_R_STATUS1:
0158     case LM83_REG_R_STATUS2:
0159         return true;
0160     default:
0161         return false;
0162     }
0163 }
0164
0165 static const struct regmap_config lm83_regmap_config = {
0166     .reg_bits = 8,
0167     .val_bits = 8,
0168     .cache_type = REGCACHE_RBTREE,
0169     .volatile_reg = lm83_regmap_is_volatile,
0170     .reg_read = lm83_regmap_reg_read,
0171     .reg_write = lm83_regmap_reg_write,
0172 };
0173
0174 /* hwmon API */
0175
0176 static int lm83_temp_read(struct device *dev, u32 attr, int channel, long *val)
0177 {
0178     struct lm83_data *data = dev_get_drvdata(dev);
0179     unsigned int regval;
0180     int err;
0181
0182     switch (attr) {
0183     case hwmon_temp_input:
0184         err = regmap_read(data->regmap, LM83_REG_TEMP[channel], &regval);
0185         if (err < 0)
0186             return err;
0187         *val = (s8)regval * 1000;
0188         break;
0189     case hwmon_temp_max:
0190         err = regmap_read(data->regmap, LM83_REG_MAX[channel], &regval);
0191         if (err < 0)
0192             return err;
0193         *val = (s8)regval * 1000;
0194         break;
0195     case hwmon_temp_crit:
0196         err = regmap_read(data->regmap, LM83_REG_R_TCRIT, &regval);
0197         if (err < 0)
0198             return err;
0199         *val = (s8)regval * 1000;
0200         break;
0201     case hwmon_temp_max_alarm:
0202         err = regmap_read(data->regmap, LM83_ALARM_REG[channel], &regval);
0203         if (err < 0)
0204             return err;
0205         *val = !!(regval & LM83_MAX_ALARM_BIT[channel]);
0206         break;
0207     case hwmon_temp_crit_alarm:
0208         err = regmap_read(data->regmap, LM83_ALARM_REG[channel], &regval);
0209         if (err < 0)
0210             return err;
0211         *val = !!(regval & LM83_CRIT_ALARM_BIT[channel]);
0212         break;
0213     case hwmon_temp_fault:
0214         err = regmap_read(data->regmap, LM83_ALARM_REG[channel], &regval);
0215         if (err < 0)
0216             return err;
0217         *val = !!(regval & LM83_FAULT_BIT[channel]);
0218         break;
0219     default:
0220         return -EOPNOTSUPP;
0221     }
0222     return 0;
0223 }
0224
0225 static int lm83_temp_write(struct device *dev, u32 attr, int channel, long val)
0226 {
0227     struct lm83_data *data = dev_get_drvdata(dev);
0228     unsigned int regval;
0229     int err;
0230
0231     regval = DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), 1000);
0232
0233     switch (attr) {
0234     case hwmon_temp_max:
0235         err = regmap_write(data->regmap, LM83_REG_MAX[channel], regval);
0236         if (err < 0)
0237             return err;
0238         break;
0239     case hwmon_temp_crit:
0240         err = regmap_write(data->regmap, LM83_REG_R_TCRIT, regval);
0241         if (err < 0)
0242             return err;
0243         break;
0244     default:
0245         return -EOPNOTSUPP;
0246     }
0247     return 0;
0248 }
0249
0250 static int lm83_chip_read(struct device *dev, u32 attr, int channel, long *val)
0251 {
0252     struct lm83_data *data = dev_get_drvdata(dev);
0253     unsigned int regval;
0254     int err;
0255
0256     switch (attr) {
0257     case hwmon_chip_alarms:
0258         err = regmap_read(data->regmap, LM83_REG_R_STATUS1, &regval);
0259         if (err < 0)
0260             return err;
0261         *val = regval;
0262         err = regmap_read(data->regmap, LM83_REG_R_STATUS2, &regval);
0263         if (err < 0)
0264             return err;
0265         *val |= regval << 8;
0266         return 0;
0267     default:
0268         return -EOPNOTSUPP;
0269     }
0270
0271     return 0;
0272 }
0273
0274 static int lm83_read(struct device *dev, enum hwmon_sensor_types type,
0275              u32 attr, int channel, long *val)
0276 {
0277     switch (type) {
0278     case hwmon_chip:
0279         return lm83_chip_read(dev, attr, channel, val);
0280     case hwmon_temp:
0281         return lm83_temp_read(dev, attr, channel, val);
0282     default:
0283         return -EOPNOTSUPP;
0284     }
0285 }
0286
0287 static int lm83_write(struct device *dev, enum hwmon_sensor_types type,
0288               u32 attr, int channel, long val)
0289 {
0290     switch (type) {
0291     case hwmon_temp:
0292         return lm83_temp_write(dev, attr, channel, val);
0293     default:
0294         return -EOPNOTSUPP;
0295     }
0296 }
0297
0298 static umode_t lm83_is_visible(const void *_data, enum hwmon_sensor_types type,
0299                    u32 attr, int channel)
0300 {
0301     const struct lm83_data *data = _data;
0302
0303     /*
0304      * LM82 only supports a single external channel, modeled as channel 2.
0305      */
0306     if (data->type == lm82 && (channel == 1 || channel == 3))
0307         return 0;
0308
0309     switch (type) {
0310     case hwmon_chip:
0311         if (attr == hwmon_chip_alarms)
0312             return 0444;
0313         break;
0314     case hwmon_temp:
0315         switch (attr) {
0316         case hwmon_temp_input:
0317         case hwmon_temp_max_alarm:
0318         case hwmon_temp_crit_alarm:
0319             return 0444;
0320         case hwmon_temp_fault:
0321             if (channel)
0322                 return 0444;
0323             break;
0324         case hwmon_temp_max:
0325             return 0644;
0326         case hwmon_temp_crit:
0327             if (channel == 2)
0328                 return 0644;
0329             return 0444;
0330         default:
0331             break;
0332         }
0333         break;
0334     default:
0335         break;
0336     }
0337     return 0;
0338 }
0339
0340 static const struct hwmon_channel_info *lm83_info[] = {
0341     HWMON_CHANNEL_INFO(chip, HWMON_C_ALARMS),
0342     HWMON_CHANNEL_INFO(temp,
0343                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
0344                HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM,
0345                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
0346                HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT,
0347                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
0348                HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT,
0349                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
0350                HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT
0351                ),
0352     NULL
0353 };
0354
0355 static const struct hwmon_ops lm83_hwmon_ops = {
0356     .is_visible = lm83_is_visible,
0357     .read = lm83_read,
0358     .write = lm83_write,
0359 };
0360
0361 static const struct hwmon_chip_info lm83_chip_info = {
0362     .ops = &lm83_hwmon_ops,
0363     .info = lm83_info,
0364 };
0365
0366 /* Return 0 if detection is successful, -ENODEV otherwise */
0367 static int lm83_detect(struct i2c_client *client,
0368                struct i2c_board_info *info)
0369 {
0370     struct i2c_adapter *adapter = client->adapter;
0371     const char *name;
0372     u8 man_id, chip_id;
0373
0374     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0375         return -ENODEV;
0376
0377     /* Detection */
0378     if ((i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS1) & 0xA8) ||
0379         (i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS2) & 0x48) ||
0380         (i2c_smbus_read_byte_data(client, LM83_REG_R_CONFIG) & 0x41)) {
0381         dev_dbg(&adapter->dev, "LM83 detection failed at 0x%02x\n",
0382             client->addr);
0383         return -ENODEV;
0384     }
0385
0386     /* Identification */
0387     man_id = i2c_smbus_read_byte_data(client, LM83_REG_R_MAN_ID);
0388     if (man_id != 0x01) /* National Semiconductor */
0389         return -ENODEV;
0390
0391     chip_id = i2c_smbus_read_byte_data(client, LM83_REG_R_CHIP_ID);
0392     switch (chip_id) {
0393     case 0x03:
0394         /*
0395          * According to the LM82 datasheet dated March 2013, recent
0396          * revisions of LM82 have a die revision of 0x03. This was
0397          * confirmed with a real chip. Further details in this revision
0398          * of the LM82 datasheet strongly suggest that LM82 is just a
0399          * repackaged LM83. It is therefore impossible to distinguish
0400          * those chips from LM83, and they will be misdetected as LM83.
0401          */
0402         name = "lm83";
0403         break;
0404     case 0x01:
0405         name = "lm82";
0406         break;
0407     default:
0408         /* identification failed */
0409         dev_dbg(&adapter->dev,
0410             "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
0411             man_id, chip_id);
0412         return -ENODEV;
0413     }
0414
0415     strlcpy(info->type, name, I2C_NAME_SIZE);
0416
0417     return 0;
0418 }
0419
0420 static const struct i2c_device_id lm83_id[] = {
0421     { "lm83", lm83 },
0422     { "lm82", lm82 },
0423     { }
0424 };
0425 MODULE_DEVICE_TABLE(i2c, lm83_id);
0426
0427 static int lm83_probe(struct i2c_client *client)
0428 {
0429     struct device *dev = &client->dev;
0430     struct device *hwmon_dev;
0431     struct lm83_data *data;
0432
0433     data = devm_kzalloc(dev, sizeof(struct lm83_data), GFP_KERNEL);
0434     if (!data)
0435         return -ENOMEM;
0436
0437     data->regmap = devm_regmap_init(dev, NULL, client, &lm83_regmap_config);
0438     if (IS_ERR(data->regmap))
0439         return PTR_ERR(data->regmap);
0440
0441     data->type = i2c_match_id(lm83_id, client)->driver_data;
0442
0443     hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
0444                              data, &lm83_chip_info, NULL);
0445     return PTR_ERR_OR_ZERO(hwmon_dev);
0446 }
0447
0448 /*
0449  * Driver data (common to all clients)
0450  */
0451
0452 static struct i2c_driver lm83_driver = {
0453     .class      = I2C_CLASS_HWMON,
0454     .driver = {
0455         .name   = "lm83",
0456     },
0457     .probe_new  = lm83_probe,
0458     .id_table   = lm83_id,
0459     .detect     = lm83_detect,
0460     .address_list   = normal_i2c,
0461 };
0462
0463 module_i2c_driver(lm83_driver);
0464
0465 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
0466 MODULE_DESCRIPTION("LM83 driver");
0467 MODULE_LICENSE("GPL");