1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Texas Instruments TMP108 SMBus temperature sensor driver 3 * 4 * Copyright (C) 2016 John Muir <john@jmuir.com> 5 */ 6 7 #include <linux/delay.h> 8 #include <linux/device.h> 9 #include <linux/err.h> 10 #include <linux/hwmon.h> 11 #include <linux/mod_devicetable.h> 12 #include <linux/module.h> 13 #include <linux/mutex.h> 14 #include <linux/i2c.h> 15 #include <linux/i3c/device.h> 16 #include <linux/init.h> 17 #include <linux/jiffies.h> 18 #include <linux/regmap.h> 19 #include <linux/regulator/consumer.h> 20 #include <linux/slab.h> 21 22 #define DRIVER_NAME "tmp108" 23 24 #define TMP108_REG_TEMP 0x00 25 #define TMP108_REG_CONF 0x01 26 #define TMP108_REG_TLOW 0x02 27 #define TMP108_REG_THIGH 0x03 28 29 #define TMP108_TEMP_MIN_MC -50000 /* Minimum millicelcius. */ 30 #define TMP108_TEMP_MAX_MC 127937 /* Maximum millicelcius. */ 31 32 /* Configuration register bits. 33 * Note: these bit definitions are byte swapped. 34 */ 35 #define TMP108_CONF_M0 0x0100 /* Sensor mode. */ 36 #define TMP108_CONF_M1 0x0200 37 #define TMP108_CONF_TM 0x0400 /* Thermostat mode. */ 38 #define TMP108_CONF_FL 0x0800 /* Watchdog flag - TLOW */ 39 #define TMP108_CONF_FH 0x1000 /* Watchdog flag - THIGH */ 40 #define TMP108_CONF_CR0 0x2000 /* Conversion rate. */ 41 #define TMP108_CONF_CR1 0x4000 42 #define TMP108_CONF_ID 0x8000 43 #define TMP108_CONF_HYS0 0x0010 /* Hysteresis. */ 44 #define TMP108_CONF_HYS1 0x0020 45 #define TMP108_CONF_POL 0x0080 /* Polarity of alert. */ 46 47 /* Defaults set by the hardware upon reset. */ 48 #define TMP108_CONF_DEFAULTS (TMP108_CONF_CR0 | TMP108_CONF_TM |\ 49 TMP108_CONF_HYS0 | TMP108_CONF_M1) 50 /* These bits are read-only. */ 51 #define TMP108_CONF_READ_ONLY (TMP108_CONF_FL | TMP108_CONF_FH |\ 52 TMP108_CONF_ID) 53 54 #define TMP108_CONF_MODE_MASK (TMP108_CONF_M0|TMP108_CONF_M1) 55 #define TMP108_MODE_SHUTDOWN 0x0000 56 #define TMP108_MODE_ONE_SHOT TMP108_CONF_M0 57 #define TMP108_MODE_CONTINUOUS TMP108_CONF_M1 /* Default */ 58 /* When M1 is set, M0 is ignored. */ 59 60 #define TMP108_CONF_CONVRATE_MASK (TMP108_CONF_CR0|TMP108_CONF_CR1) 61 #define TMP108_CONVRATE_0P25HZ 0x0000 62 #define TMP108_CONVRATE_1HZ TMP108_CONF_CR0 /* Default */ 63 #define TMP108_CONVRATE_4HZ TMP108_CONF_CR1 64 #define TMP108_CONVRATE_16HZ (TMP108_CONF_CR0|TMP108_CONF_CR1) 65 66 #define TMP108_CONF_HYSTERESIS_MASK (TMP108_CONF_HYS0|TMP108_CONF_HYS1) 67 #define TMP108_HYSTERESIS_0C 0x0000 68 #define TMP108_HYSTERESIS_1C TMP108_CONF_HYS0 /* Default */ 69 #define TMP108_HYSTERESIS_2C TMP108_CONF_HYS1 70 #define TMP108_HYSTERESIS_4C (TMP108_CONF_HYS0|TMP108_CONF_HYS1) 71 72 #define TMP108_CONVERSION_TIME_MS 30 /* in milli-seconds */ 73 74 struct tmp108 { 75 struct regmap *regmap; 76 u16 orig_config; 77 unsigned long ready_time; 78 }; 79 80 /* convert 12-bit TMP108 register value to milliCelsius */ 81 static inline int tmp108_temp_reg_to_mC(s16 val) 82 { 83 return (val & ~0x0f) * 1000 / 256; 84 } 85 86 /* convert milliCelsius to left adjusted 12-bit TMP108 register value */ 87 static inline u16 tmp108_mC_to_temp_reg(int val) 88 { 89 return (val * 256) / 1000; 90 } 91 92 static int tmp108_read(struct device *dev, enum hwmon_sensor_types type, 93 u32 attr, int channel, long *temp) 94 { 95 struct tmp108 *tmp108 = dev_get_drvdata(dev); 96 unsigned int regval; 97 int err, hyst; 98 99 if (type == hwmon_chip) { 100 if (attr == hwmon_chip_update_interval) { 101 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, 102 ®val); 103 if (err < 0) 104 return err; 105 switch (regval & TMP108_CONF_CONVRATE_MASK) { 106 case TMP108_CONVRATE_0P25HZ: 107 default: 108 *temp = 4000; 109 break; 110 case TMP108_CONVRATE_1HZ: 111 *temp = 1000; 112 break; 113 case TMP108_CONVRATE_4HZ: 114 *temp = 250; 115 break; 116 case TMP108_CONVRATE_16HZ: 117 *temp = 63; 118 break; 119 } 120 return 0; 121 } 122 return -EOPNOTSUPP; 123 } 124 125 switch (attr) { 126 case hwmon_temp_input: 127 /* Is it too early to return a conversion ? */ 128 if (time_before(jiffies, tmp108->ready_time)) { 129 dev_dbg(dev, "%s: Conversion not ready yet..\n", 130 __func__); 131 return -EAGAIN; 132 } 133 err = regmap_read(tmp108->regmap, TMP108_REG_TEMP, ®val); 134 if (err < 0) 135 return err; 136 *temp = tmp108_temp_reg_to_mC(regval); 137 break; 138 case hwmon_temp_min: 139 case hwmon_temp_max: 140 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min ? 141 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val); 142 if (err < 0) 143 return err; 144 *temp = tmp108_temp_reg_to_mC(regval); 145 break; 146 case hwmon_temp_min_alarm: 147 case hwmon_temp_max_alarm: 148 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val); 149 if (err < 0) 150 return err; 151 *temp = !!(regval & (attr == hwmon_temp_min_alarm ? 152 TMP108_CONF_FL : TMP108_CONF_FH)); 153 break; 154 case hwmon_temp_min_hyst: 155 case hwmon_temp_max_hyst: 156 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val); 157 if (err < 0) 158 return err; 159 switch (regval & TMP108_CONF_HYSTERESIS_MASK) { 160 case TMP108_HYSTERESIS_0C: 161 default: 162 hyst = 0; 163 break; 164 case TMP108_HYSTERESIS_1C: 165 hyst = 1000; 166 break; 167 case TMP108_HYSTERESIS_2C: 168 hyst = 2000; 169 break; 170 case TMP108_HYSTERESIS_4C: 171 hyst = 4000; 172 break; 173 } 174 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min_hyst ? 175 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val); 176 if (err < 0) 177 return err; 178 *temp = tmp108_temp_reg_to_mC(regval); 179 if (attr == hwmon_temp_min_hyst) 180 *temp += hyst; 181 else 182 *temp -= hyst; 183 break; 184 default: 185 return -EOPNOTSUPP; 186 } 187 188 return 0; 189 } 190 191 static int tmp108_write(struct device *dev, enum hwmon_sensor_types type, 192 u32 attr, int channel, long temp) 193 { 194 struct tmp108 *tmp108 = dev_get_drvdata(dev); 195 u32 regval, mask; 196 int err; 197 198 if (type == hwmon_chip) { 199 if (attr == hwmon_chip_update_interval) { 200 if (temp < 156) 201 mask = TMP108_CONVRATE_16HZ; 202 else if (temp < 625) 203 mask = TMP108_CONVRATE_4HZ; 204 else if (temp < 2500) 205 mask = TMP108_CONVRATE_1HZ; 206 else 207 mask = TMP108_CONVRATE_0P25HZ; 208 return regmap_update_bits(tmp108->regmap, 209 TMP108_REG_CONF, 210 TMP108_CONF_CONVRATE_MASK, 211 mask); 212 } 213 return -EOPNOTSUPP; 214 } 215 216 switch (attr) { 217 case hwmon_temp_min: 218 case hwmon_temp_max: 219 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC); 220 return regmap_write(tmp108->regmap, 221 attr == hwmon_temp_min ? 222 TMP108_REG_TLOW : TMP108_REG_THIGH, 223 tmp108_mC_to_temp_reg(temp)); 224 case hwmon_temp_min_hyst: 225 case hwmon_temp_max_hyst: 226 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC); 227 err = regmap_read(tmp108->regmap, 228 attr == hwmon_temp_min_hyst ? 229 TMP108_REG_TLOW : TMP108_REG_THIGH, 230 ®val); 231 if (err < 0) 232 return err; 233 if (attr == hwmon_temp_min_hyst) 234 temp -= tmp108_temp_reg_to_mC(regval); 235 else 236 temp = tmp108_temp_reg_to_mC(regval) - temp; 237 if (temp < 500) 238 mask = TMP108_HYSTERESIS_0C; 239 else if (temp < 1500) 240 mask = TMP108_HYSTERESIS_1C; 241 else if (temp < 3000) 242 mask = TMP108_HYSTERESIS_2C; 243 else 244 mask = TMP108_HYSTERESIS_4C; 245 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 246 TMP108_CONF_HYSTERESIS_MASK, mask); 247 default: 248 return -EOPNOTSUPP; 249 } 250 } 251 252 static umode_t tmp108_is_visible(const void *data, enum hwmon_sensor_types type, 253 u32 attr, int channel) 254 { 255 if (type == hwmon_chip && attr == hwmon_chip_update_interval) 256 return 0644; 257 258 if (type != hwmon_temp) 259 return 0; 260 261 switch (attr) { 262 case hwmon_temp_input: 263 case hwmon_temp_min_alarm: 264 case hwmon_temp_max_alarm: 265 return 0444; 266 case hwmon_temp_min: 267 case hwmon_temp_max: 268 case hwmon_temp_min_hyst: 269 case hwmon_temp_max_hyst: 270 return 0644; 271 default: 272 return 0; 273 } 274 } 275 276 static const struct hwmon_channel_info * const tmp108_info[] = { 277 HWMON_CHANNEL_INFO(chip, 278 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL), 279 HWMON_CHANNEL_INFO(temp, 280 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | 281 HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 282 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM), 283 NULL 284 }; 285 286 static const struct hwmon_ops tmp108_hwmon_ops = { 287 .is_visible = tmp108_is_visible, 288 .read = tmp108_read, 289 .write = tmp108_write, 290 }; 291 292 static const struct hwmon_chip_info tmp108_chip_info = { 293 .ops = &tmp108_hwmon_ops, 294 .info = tmp108_info, 295 }; 296 297 static void tmp108_restore_config(void *data) 298 { 299 struct tmp108 *tmp108 = data; 300 301 regmap_write(tmp108->regmap, TMP108_REG_CONF, tmp108->orig_config); 302 } 303 304 static bool tmp108_is_writeable_reg(struct device *dev, unsigned int reg) 305 { 306 return reg != TMP108_REG_TEMP; 307 } 308 309 static bool tmp108_is_volatile_reg(struct device *dev, unsigned int reg) 310 { 311 /* Configuration register must be volatile to enable FL and FH. */ 312 return reg == TMP108_REG_TEMP || reg == TMP108_REG_CONF; 313 } 314 315 static const struct regmap_config tmp108_regmap_config = { 316 .reg_bits = 8, 317 .val_bits = 16, 318 .max_register = TMP108_REG_THIGH, 319 .writeable_reg = tmp108_is_writeable_reg, 320 .volatile_reg = tmp108_is_volatile_reg, 321 .val_format_endian = REGMAP_ENDIAN_BIG, 322 .cache_type = REGCACHE_MAPLE, 323 .use_single_read = true, 324 .use_single_write = true, 325 }; 326 327 static int tmp108_common_probe(struct device *dev, struct regmap *regmap, char *name) 328 { 329 struct device *hwmon_dev; 330 struct tmp108 *tmp108; 331 u32 config; 332 int err; 333 334 err = devm_regulator_get_enable(dev, "vcc"); 335 if (err) 336 return dev_err_probe(dev, err, "Failed to enable regulator\n"); 337 338 tmp108 = devm_kzalloc(dev, sizeof(*tmp108), GFP_KERNEL); 339 if (!tmp108) 340 return -ENOMEM; 341 342 dev_set_drvdata(dev, tmp108); 343 tmp108->regmap = regmap; 344 345 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &config); 346 if (err < 0) { 347 dev_err(dev, "error reading config register: %d", err); 348 return err; 349 } 350 tmp108->orig_config = config; 351 352 /* Only continuous mode is supported. */ 353 config &= ~TMP108_CONF_MODE_MASK; 354 config |= TMP108_MODE_CONTINUOUS; 355 356 /* Only comparator mode is supported. */ 357 config &= ~TMP108_CONF_TM; 358 359 err = regmap_write(tmp108->regmap, TMP108_REG_CONF, config); 360 if (err < 0) { 361 dev_err(dev, "error writing config register: %d", err); 362 return err; 363 } 364 365 tmp108->ready_time = jiffies; 366 if ((tmp108->orig_config & TMP108_CONF_MODE_MASK) == 367 TMP108_MODE_SHUTDOWN) 368 tmp108->ready_time += 369 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS); 370 371 err = devm_add_action_or_reset(dev, tmp108_restore_config, tmp108); 372 if (err) { 373 dev_err(dev, "add action or reset failed: %d", err); 374 return err; 375 } 376 377 hwmon_dev = devm_hwmon_device_register_with_info(dev, name, 378 tmp108, 379 &tmp108_chip_info, 380 NULL); 381 return PTR_ERR_OR_ZERO(hwmon_dev); 382 } 383 384 static int tmp108_probe(struct i2c_client *client) 385 { 386 struct device *dev = &client->dev; 387 struct regmap *regmap; 388 389 if (!i2c_check_functionality(client->adapter, 390 I2C_FUNC_SMBUS_WORD_DATA)) 391 return dev_err_probe(dev, -ENODEV, 392 "adapter doesn't support SMBus word transactions\n"); 393 394 regmap = devm_regmap_init_i2c(client, &tmp108_regmap_config); 395 if (IS_ERR(regmap)) 396 return dev_err_probe(dev, PTR_ERR(regmap), "regmap init failed"); 397 398 return tmp108_common_probe(dev, regmap, client->name); 399 } 400 401 static int tmp108_suspend(struct device *dev) 402 { 403 struct tmp108 *tmp108 = dev_get_drvdata(dev); 404 405 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 406 TMP108_CONF_MODE_MASK, TMP108_MODE_SHUTDOWN); 407 } 408 409 static int tmp108_resume(struct device *dev) 410 { 411 struct tmp108 *tmp108 = dev_get_drvdata(dev); 412 int err; 413 414 err = regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 415 TMP108_CONF_MODE_MASK, TMP108_MODE_CONTINUOUS); 416 tmp108->ready_time = jiffies + 417 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS); 418 return err; 419 } 420 421 static DEFINE_SIMPLE_DEV_PM_OPS(tmp108_dev_pm_ops, tmp108_suspend, tmp108_resume); 422 423 static const struct i2c_device_id tmp108_i2c_ids[] = { 424 { "p3t1085" }, 425 { "tmp108" }, 426 { } 427 }; 428 MODULE_DEVICE_TABLE(i2c, tmp108_i2c_ids); 429 430 static const struct of_device_id tmp108_of_ids[] = { 431 { .compatible = "nxp,p3t1085", }, 432 { .compatible = "ti,tmp108", }, 433 {} 434 }; 435 MODULE_DEVICE_TABLE(of, tmp108_of_ids); 436 437 static struct i2c_driver tmp108_driver = { 438 .driver = { 439 .name = DRIVER_NAME, 440 .pm = pm_sleep_ptr(&tmp108_dev_pm_ops), 441 .of_match_table = tmp108_of_ids, 442 }, 443 .probe = tmp108_probe, 444 .id_table = tmp108_i2c_ids, 445 }; 446 447 static const struct i3c_device_id p3t1085_i3c_ids[] = { 448 I3C_DEVICE(0x011b, 0x1529, NULL), 449 {} 450 }; 451 MODULE_DEVICE_TABLE(i3c, p3t1085_i3c_ids); 452 453 static int p3t1085_i3c_probe(struct i3c_device *i3cdev) 454 { 455 struct device *dev = i3cdev_to_dev(i3cdev); 456 struct regmap *regmap; 457 458 regmap = devm_regmap_init_i3c(i3cdev, &tmp108_regmap_config); 459 if (IS_ERR(regmap)) 460 return dev_err_probe(dev, PTR_ERR(regmap), 461 "Failed to register i3c regmap\n"); 462 463 return tmp108_common_probe(dev, regmap, "p3t1085_i3c"); 464 } 465 466 static struct i3c_driver p3t1085_driver = { 467 .driver = { 468 .name = "p3t1085_i3c", 469 }, 470 .probe = p3t1085_i3c_probe, 471 .id_table = p3t1085_i3c_ids, 472 }; 473 474 module_i3c_i2c_driver(p3t1085_driver, &tmp108_driver) 475 476 MODULE_AUTHOR("John Muir <john@jmuir.com>"); 477 MODULE_DESCRIPTION("Texas Instruments TMP108 temperature sensor driver"); 478 MODULE_LICENSE("GPL"); 479