drivers/hwmon/w83773g.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2017 IBM Corp.
0004  *
0005  * Driver for the Nuvoton W83773G SMBus temperature sensor IC.
0006  * Supported models: W83773G
0007  */
0008
0009 #include <linux/module.h>
0010 #include <linux/init.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/of_device.h>
0016 #include <linux/regmap.h>
0017
0018 /* W83773 has 3 channels */
0019 #define W83773_CHANNELS             3
0020
0021 /* The W83773 registers */
0022 #define W83773_CONVERSION_RATE_REG_READ     0x04
0023 #define W83773_CONVERSION_RATE_REG_WRITE    0x0A
0024 #define W83773_MANUFACTURER_ID_REG      0xFE
0025 #define W83773_LOCAL_TEMP           0x00
0026
0027 static const u8 W83773_STATUS[2] = { 0x02, 0x17 };
0028
0029 static const u8 W83773_TEMP_LSB[2] = { 0x10, 0x25 };
0030 static const u8 W83773_TEMP_MSB[2] = { 0x01, 0x24 };
0031
0032 static const u8 W83773_OFFSET_LSB[2] = { 0x12, 0x16 };
0033 static const u8 W83773_OFFSET_MSB[2] = { 0x11, 0x15 };
0034
0035 /* this is the number of sensors in the device */
0036 static const struct i2c_device_id w83773_id[] = {
0037     { "w83773g" },
0038     { }
0039 };
0040
0041 MODULE_DEVICE_TABLE(i2c, w83773_id);
0042
0043 static const struct of_device_id __maybe_unused w83773_of_match[] = {
0044     {
0045         .compatible = "nuvoton,w83773g"
0046     },
0047     { },
0048 };
0049 MODULE_DEVICE_TABLE(of, w83773_of_match);
0050
0051 static inline long temp_of_local(s8 reg)
0052 {
0053     return reg * 1000;
0054 }
0055
0056 static inline long temp_of_remote(s8 hb, u8 lb)
0057 {
0058     return (hb << 3 | lb >> 5) * 125;
0059 }
0060
0061 static int get_local_temp(struct regmap *regmap, long *val)
0062 {
0063     unsigned int regval;
0064     int ret;
0065
0066     ret = regmap_read(regmap, W83773_LOCAL_TEMP, &regval);
0067     if (ret < 0)
0068         return ret;
0069
0070     *val = temp_of_local(regval);
0071     return 0;
0072 }
0073
0074 static int get_remote_temp(struct regmap *regmap, int index, long *val)
0075 {
0076     unsigned int regval_high;
0077     unsigned int regval_low;
0078     int ret;
0079
0080     ret = regmap_read(regmap, W83773_TEMP_MSB[index], &regval_high);
0081     if (ret < 0)
0082         return ret;
0083
0084     ret = regmap_read(regmap, W83773_TEMP_LSB[index], &regval_low);
0085     if (ret < 0)
0086         return ret;
0087
0088     *val = temp_of_remote(regval_high, regval_low);
0089     return 0;
0090 }
0091
0092 static int get_fault(struct regmap *regmap, int index, long *val)
0093 {
0094     unsigned int regval;
0095     int ret;
0096
0097     ret = regmap_read(regmap, W83773_STATUS[index], &regval);
0098     if (ret < 0)
0099         return ret;
0100
0101     *val = (regval & 0x04) >> 2;
0102     return 0;
0103 }
0104
0105 static int get_offset(struct regmap *regmap, int index, long *val)
0106 {
0107     unsigned int regval_high;
0108     unsigned int regval_low;
0109     int ret;
0110
0111     ret = regmap_read(regmap, W83773_OFFSET_MSB[index], &regval_high);
0112     if (ret < 0)
0113         return ret;
0114
0115     ret = regmap_read(regmap, W83773_OFFSET_LSB[index], &regval_low);
0116     if (ret < 0)
0117         return ret;
0118
0119     *val = temp_of_remote(regval_high, regval_low);
0120     return 0;
0121 }
0122
0123 static int set_offset(struct regmap *regmap, int index, long val)
0124 {
0125     int ret;
0126     u8 high_byte;
0127     u8 low_byte;
0128
0129     val = clamp_val(val, -127825, 127825);
0130     /* offset value equals to (high_byte << 3 | low_byte >> 5) * 125 */
0131     val /= 125;
0132     high_byte = val >> 3;
0133     low_byte = (val & 0x07) << 5;
0134
0135     ret = regmap_write(regmap, W83773_OFFSET_MSB[index], high_byte);
0136     if (ret < 0)
0137         return ret;
0138
0139     return regmap_write(regmap, W83773_OFFSET_LSB[index], low_byte);
0140 }
0141
0142 static int get_update_interval(struct regmap *regmap, long *val)
0143 {
0144     unsigned int regval;
0145     int ret;
0146
0147     ret = regmap_read(regmap, W83773_CONVERSION_RATE_REG_READ, &regval);
0148     if (ret < 0)
0149         return ret;
0150
0151     *val = 16000 >> regval;
0152     return 0;
0153 }
0154
0155 static int set_update_interval(struct regmap *regmap, long val)
0156 {
0157     int rate;
0158
0159     /*
0160      * For valid rates, interval can be calculated as
0161      *  interval = (1 << (8 - rate)) * 62.5;
0162      * Rounded rate is therefore
0163      *  rate = 8 - __fls(interval * 8 / (62.5 * 7));
0164      * Use clamp_val() to avoid overflows, and to ensure valid input
0165      * for __fls.
0166      */
0167     val = clamp_val(val, 62, 16000) * 10;
0168     rate = 8 - __fls((val * 8 / (625 * 7)));
0169     return regmap_write(regmap, W83773_CONVERSION_RATE_REG_WRITE, rate);
0170 }
0171
0172 static int w83773_read(struct device *dev, enum hwmon_sensor_types type,
0173                u32 attr, int channel, long *val)
0174 {
0175     struct regmap *regmap = dev_get_drvdata(dev);
0176
0177     if (type == hwmon_chip) {
0178         if (attr == hwmon_chip_update_interval)
0179             return get_update_interval(regmap, val);
0180         return -EOPNOTSUPP;
0181     }
0182
0183     switch (attr) {
0184     case hwmon_temp_input:
0185         if (channel == 0)
0186             return get_local_temp(regmap, val);
0187         return get_remote_temp(regmap, channel - 1, val);
0188     case hwmon_temp_fault:
0189         return get_fault(regmap, channel - 1, val);
0190     case hwmon_temp_offset:
0191         return get_offset(regmap, channel - 1, val);
0192     default:
0193         return -EOPNOTSUPP;
0194     }
0195 }
0196
0197 static int w83773_write(struct device *dev, enum hwmon_sensor_types type,
0198             u32 attr, int channel, long val)
0199 {
0200     struct regmap *regmap = dev_get_drvdata(dev);
0201
0202     if (type == hwmon_chip && attr == hwmon_chip_update_interval)
0203         return set_update_interval(regmap, val);
0204
0205     if (type == hwmon_temp && attr == hwmon_temp_offset)
0206         return set_offset(regmap, channel - 1, val);
0207
0208     return -EOPNOTSUPP;
0209 }
0210
0211 static umode_t w83773_is_visible(const void *data, enum hwmon_sensor_types type,
0212                  u32 attr, int channel)
0213 {
0214     switch (type) {
0215     case hwmon_chip:
0216         switch (attr) {
0217         case hwmon_chip_update_interval:
0218             return 0644;
0219         }
0220         break;
0221     case hwmon_temp:
0222         switch (attr) {
0223         case hwmon_temp_input:
0224         case hwmon_temp_fault:
0225             return 0444;
0226         case hwmon_temp_offset:
0227             return 0644;
0228         }
0229         break;
0230     default:
0231         break;
0232     }
0233     return 0;
0234 }
0235
0236 static const struct hwmon_channel_info *w83773_info[] = {
0237     HWMON_CHANNEL_INFO(chip,
0238                HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
0239     HWMON_CHANNEL_INFO(temp,
0240                HWMON_T_INPUT,
0241                HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_OFFSET,
0242                HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_OFFSET),
0243     NULL
0244 };
0245
0246 static const struct hwmon_ops w83773_ops = {
0247     .is_visible = w83773_is_visible,
0248     .read = w83773_read,
0249     .write = w83773_write,
0250 };
0251
0252 static const struct hwmon_chip_info w83773_chip_info = {
0253     .ops = &w83773_ops,
0254     .info = w83773_info,
0255 };
0256
0257 static const struct regmap_config w83773_regmap_config = {
0258     .reg_bits = 8,
0259     .val_bits = 8,
0260 };
0261
0262 static int w83773_probe(struct i2c_client *client)
0263 {
0264     struct device *dev = &client->dev;
0265     struct device *hwmon_dev;
0266     struct regmap *regmap;
0267     int ret;
0268
0269     regmap = devm_regmap_init_i2c(client, &w83773_regmap_config);
0270     if (IS_ERR(regmap)) {
0271         dev_err(dev, "failed to allocate register map\n");
0272         return PTR_ERR(regmap);
0273     }
0274
0275     /* Set the conversion rate to 2 Hz */
0276     ret = regmap_write(regmap, W83773_CONVERSION_RATE_REG_WRITE, 0x05);
0277     if (ret < 0) {
0278         dev_err(&client->dev, "error writing config rate register\n");
0279         return ret;
0280     }
0281
0282     i2c_set_clientdata(client, regmap);
0283
0284     hwmon_dev = devm_hwmon_device_register_with_info(dev,
0285                              client->name,
0286                              regmap,
0287                              &w83773_chip_info,
0288                              NULL);
0289     return PTR_ERR_OR_ZERO(hwmon_dev);
0290 }
0291
0292 static struct i2c_driver w83773_driver = {
0293     .class = I2C_CLASS_HWMON,
0294     .driver = {
0295         .name   = "w83773g",
0296         .of_match_table = of_match_ptr(w83773_of_match),
0297     },
0298     .probe_new = w83773_probe,
0299     .id_table = w83773_id,
0300 };
0301
0302 module_i2c_driver(w83773_driver);
0303
0304 MODULE_AUTHOR("Lei YU <mine260309@gmail.com>");
0305 MODULE_DESCRIPTION("W83773G temperature sensor driver");
0306 MODULE_LICENSE("GPL");