drivers/hwmon/tmp103.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Texas Instruments TMP103 SMBus temperature sensor driver
0004  * Copyright (C) 2014 Heiko Schocher <hs@denx.de>
0005  *
0006  * Based on:
0007  * Texas Instruments TMP102 SMBus temperature sensor driver
0008  *
0009  * Copyright (C) 2010 Steven King <sfking@fdwdc.com>
0010  */
0011
0012 #include <linux/module.h>
0013 #include <linux/init.h>
0014 #include <linux/slab.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/device.h>
0021 #include <linux/jiffies.h>
0022 #include <linux/regmap.h>
0023
0024 #define TMP103_TEMP_REG     0x00
0025 #define TMP103_CONF_REG     0x01
0026 #define TMP103_TLOW_REG     0x02
0027 #define TMP103_THIGH_REG    0x03
0028
0029 #define TMP103_CONF_M0      0x01
0030 #define TMP103_CONF_M1      0x02
0031 #define TMP103_CONF_LC      0x04
0032 #define TMP103_CONF_FL      0x08
0033 #define TMP103_CONF_FH      0x10
0034 #define TMP103_CONF_CR0     0x20
0035 #define TMP103_CONF_CR1     0x40
0036 #define TMP103_CONF_ID      0x80
0037 #define TMP103_CONF_SD      (TMP103_CONF_M1)
0038 #define TMP103_CONF_SD_MASK (TMP103_CONF_M0 | TMP103_CONF_M1)
0039
0040 #define TMP103_CONFIG       (TMP103_CONF_CR1 | TMP103_CONF_M1)
0041 #define TMP103_CONFIG_MASK  (TMP103_CONF_CR0 | TMP103_CONF_CR1 | \
0042                  TMP103_CONF_M0 | TMP103_CONF_M1)
0043
0044 static inline int tmp103_reg_to_mc(s8 val)
0045 {
0046     return val * 1000;
0047 }
0048
0049 static inline u8 tmp103_mc_to_reg(int val)
0050 {
0051     return DIV_ROUND_CLOSEST(val, 1000);
0052 }
0053
0054 static int tmp103_read(struct device *dev, enum hwmon_sensor_types type,
0055                u32 attr, int channel, long *temp)
0056 {
0057     struct regmap *regmap = dev_get_drvdata(dev);
0058     unsigned int regval;
0059     int err, reg;
0060
0061     switch (attr) {
0062     case hwmon_temp_input:
0063         reg = TMP103_TEMP_REG;
0064         break;
0065     case hwmon_temp_min:
0066         reg = TMP103_TLOW_REG;
0067         break;
0068     case hwmon_temp_max:
0069         reg = TMP103_THIGH_REG;
0070         break;
0071     default:
0072         return -EOPNOTSUPP;
0073     }
0074
0075     err = regmap_read(regmap, reg, &regval);
0076     if (err < 0)
0077         return err;
0078
0079     *temp = tmp103_reg_to_mc(regval);
0080
0081     return 0;
0082 }
0083
0084 static int tmp103_write(struct device *dev, enum hwmon_sensor_types type,
0085             u32 attr, int channel, long temp)
0086 {
0087     struct regmap *regmap = dev_get_drvdata(dev);
0088     int reg;
0089
0090     switch (attr) {
0091     case hwmon_temp_min:
0092         reg = TMP103_TLOW_REG;
0093         break;
0094     case hwmon_temp_max:
0095         reg = TMP103_THIGH_REG;
0096         break;
0097     default:
0098         return -EOPNOTSUPP;
0099     }
0100
0101     temp = clamp_val(temp, -55000, 127000);
0102     return regmap_write(regmap, reg, tmp103_mc_to_reg(temp));
0103 }
0104
0105 static umode_t tmp103_is_visible(const void *data, enum hwmon_sensor_types type,
0106                  u32 attr, int channel)
0107 {
0108     if (type != hwmon_temp)
0109         return 0;
0110
0111     switch (attr) {
0112     case hwmon_temp_input:
0113         return 0444;
0114     case hwmon_temp_min:
0115     case hwmon_temp_max:
0116         return 0644;
0117     default:
0118         return 0;
0119     }
0120 }
0121
0122 static const struct hwmon_channel_info *tmp103_info[] = {
0123     HWMON_CHANNEL_INFO(chip,
0124                HWMON_C_REGISTER_TZ),
0125     HWMON_CHANNEL_INFO(temp,
0126                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN),
0127     NULL
0128 };
0129
0130 static const struct hwmon_ops tmp103_hwmon_ops = {
0131     .is_visible = tmp103_is_visible,
0132     .read = tmp103_read,
0133     .write = tmp103_write,
0134 };
0135
0136 static const struct hwmon_chip_info tmp103_chip_info = {
0137     .ops = &tmp103_hwmon_ops,
0138     .info = tmp103_info,
0139 };
0140
0141 static bool tmp103_regmap_is_volatile(struct device *dev, unsigned int reg)
0142 {
0143     return reg == TMP103_TEMP_REG;
0144 }
0145
0146 static const struct regmap_config tmp103_regmap_config = {
0147     .reg_bits = 8,
0148     .val_bits = 8,
0149     .max_register = TMP103_THIGH_REG,
0150     .volatile_reg = tmp103_regmap_is_volatile,
0151 };
0152
0153 static int tmp103_probe(struct i2c_client *client)
0154 {
0155     struct device *dev = &client->dev;
0156     struct device *hwmon_dev;
0157     struct regmap *regmap;
0158     int ret;
0159
0160     regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config);
0161     if (IS_ERR(regmap)) {
0162         dev_err(dev, "failed to allocate register map\n");
0163         return PTR_ERR(regmap);
0164     }
0165
0166     ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK,
0167                  TMP103_CONFIG);
0168     if (ret < 0) {
0169         dev_err(&client->dev, "error writing config register\n");
0170         return ret;
0171     }
0172
0173     i2c_set_clientdata(client, regmap);
0174     hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
0175                              regmap,
0176                              &tmp103_chip_info,
0177                              NULL);
0178     return PTR_ERR_OR_ZERO(hwmon_dev);
0179 }
0180
0181 static int __maybe_unused tmp103_suspend(struct device *dev)
0182 {
0183     struct regmap *regmap = dev_get_drvdata(dev);
0184
0185     return regmap_update_bits(regmap, TMP103_CONF_REG,
0186                   TMP103_CONF_SD_MASK, 0);
0187 }
0188
0189 static int __maybe_unused tmp103_resume(struct device *dev)
0190 {
0191     struct regmap *regmap = dev_get_drvdata(dev);
0192
0193     return regmap_update_bits(regmap, TMP103_CONF_REG,
0194                   TMP103_CONF_SD_MASK, TMP103_CONF_SD);
0195 }
0196
0197 static SIMPLE_DEV_PM_OPS(tmp103_dev_pm_ops, tmp103_suspend, tmp103_resume);
0198
0199 static const struct i2c_device_id tmp103_id[] = {
0200     { "tmp103", 0 },
0201     { }
0202 };
0203 MODULE_DEVICE_TABLE(i2c, tmp103_id);
0204
0205 static const struct of_device_id __maybe_unused tmp103_of_match[] = {
0206     { .compatible = "ti,tmp103" },
0207     { },
0208 };
0209 MODULE_DEVICE_TABLE(of, tmp103_of_match);
0210
0211 static struct i2c_driver tmp103_driver = {
0212     .driver = {
0213         .name   = "tmp103",
0214         .of_match_table = of_match_ptr(tmp103_of_match),
0215         .pm = &tmp103_dev_pm_ops,
0216     },
0217     .probe_new  = tmp103_probe,
0218     .id_table   = tmp103_id,
0219 };
0220
0221 module_i2c_driver(tmp103_driver);
0222
0223 MODULE_AUTHOR("Heiko Schocher <hs@denx.de>");
0224 MODULE_DESCRIPTION("Texas Instruments TMP103 temperature sensor driver");
0225 MODULE_LICENSE("GPL");