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/bitfield.h> 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/hwmon.h> 12 #include <linux/module.h> 13 #include <linux/i2c.h> 14 #include <linux/i3c/device.h> 15 #include <linux/init.h> 16 #include <linux/jiffies.h> 17 #include <linux/regmap.h> 18 #include <linux/regulator/consumer.h> 19 #include <linux/slab.h> 20 #include <linux/util_macros.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 #define TMP108_CONF_CR0_POS 13 75 #define TMP108_CONF_CR1_POS 14 76 #define TMP108_CONF_CONVRATE_FLD GENMASK(TMP108_CONF_CR1_POS, TMP108_CONF_CR0_POS) 77 78 struct tmp108 { 79 struct regmap *regmap; 80 u16 orig_config; 81 unsigned long ready_time; 82 const struct tmp108_params *params; 83 }; 84 85 struct tmp108_params { 86 bool config_reg_16bits; 87 const u16 *sample_times; 88 size_t n_sample_times; 89 }; 90 91 static const u16 p3t1035_sample_times[] = {4000, 1000, 250, 125}; 92 static const u16 tmp108_sample_times[] = {4000, 1000, 250, 63}; 93 94 static const struct tmp108_params p3t1035_data = { 95 .sample_times = p3t1035_sample_times, 96 .n_sample_times = ARRAY_SIZE(p3t1035_sample_times), 97 .config_reg_16bits = false, 98 }; 99 100 static const struct tmp108_params tmp108_data = { 101 .sample_times = tmp108_sample_times, 102 .n_sample_times = ARRAY_SIZE(tmp108_sample_times), 103 .config_reg_16bits = true, 104 }; 105 106 /* convert 12-bit TMP108 register value to milliCelsius */ 107 static inline int tmp108_temp_reg_to_mC(s16 val) 108 { 109 return (val & ~0x0f) * 1000 / 256; 110 } 111 112 /* convert milliCelsius to left adjusted 12-bit TMP108 register value */ 113 static inline u16 tmp108_mC_to_temp_reg(int val) 114 { 115 return (val * 256) / 1000; 116 } 117 118 static int tmp108_read(struct device *dev, enum hwmon_sensor_types type, 119 u32 attr, int channel, long *temp) 120 { 121 struct tmp108 *tmp108 = dev_get_drvdata(dev); 122 unsigned int regval; 123 int err, hyst; 124 125 if (type == hwmon_chip) { 126 if (attr == hwmon_chip_update_interval) { 127 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, 128 ®val); 129 if (err < 0) 130 return err; 131 *temp = tmp108->params->sample_times[FIELD_GET(TMP108_CONF_CONVRATE_FLD, 132 regval)]; 133 return 0; 134 } 135 return -EOPNOTSUPP; 136 } 137 138 switch (attr) { 139 case hwmon_temp_input: 140 /* Is it too early to return a conversion ? */ 141 if (time_before(jiffies, tmp108->ready_time)) { 142 dev_dbg(dev, "%s: Conversion not ready yet..\n", 143 __func__); 144 return -EAGAIN; 145 } 146 err = regmap_read(tmp108->regmap, TMP108_REG_TEMP, ®val); 147 if (err < 0) 148 return err; 149 *temp = tmp108_temp_reg_to_mC(regval); 150 break; 151 case hwmon_temp_min: 152 case hwmon_temp_max: 153 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min ? 154 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val); 155 if (err < 0) 156 return err; 157 *temp = tmp108_temp_reg_to_mC(regval); 158 break; 159 case hwmon_temp_min_alarm: 160 case hwmon_temp_max_alarm: 161 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val); 162 if (err < 0) 163 return err; 164 *temp = !!(regval & (attr == hwmon_temp_min_alarm ? 165 TMP108_CONF_FL : TMP108_CONF_FH)); 166 break; 167 case hwmon_temp_min_hyst: 168 case hwmon_temp_max_hyst: 169 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val); 170 if (err < 0) 171 return err; 172 switch (regval & TMP108_CONF_HYSTERESIS_MASK) { 173 case TMP108_HYSTERESIS_0C: 174 default: 175 hyst = 0; 176 break; 177 case TMP108_HYSTERESIS_1C: 178 hyst = 1000; 179 break; 180 case TMP108_HYSTERESIS_2C: 181 hyst = 2000; 182 break; 183 case TMP108_HYSTERESIS_4C: 184 hyst = 4000; 185 break; 186 } 187 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min_hyst ? 188 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val); 189 if (err < 0) 190 return err; 191 *temp = tmp108_temp_reg_to_mC(regval); 192 if (attr == hwmon_temp_min_hyst) 193 *temp += hyst; 194 else 195 *temp -= hyst; 196 break; 197 default: 198 return -EOPNOTSUPP; 199 } 200 201 return 0; 202 } 203 204 static int tmp108_write(struct device *dev, enum hwmon_sensor_types type, 205 u32 attr, int channel, long temp) 206 { 207 struct tmp108 *tmp108 = dev_get_drvdata(dev); 208 u32 regval, mask; 209 size_t len; 210 u8 index; 211 int err; 212 213 if (type == hwmon_chip) { 214 if (attr == hwmon_chip_update_interval) { 215 len = tmp108->params->n_sample_times; 216 index = find_closest_descending(temp, tmp108->params->sample_times, len); 217 return regmap_update_bits(tmp108->regmap, 218 TMP108_REG_CONF, 219 TMP108_CONF_CONVRATE_MASK, 220 FIELD_PREP(TMP108_CONF_CONVRATE_FLD, index)); 221 } 222 return -EOPNOTSUPP; 223 } 224 225 switch (attr) { 226 case hwmon_temp_min: 227 case hwmon_temp_max: 228 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC); 229 return regmap_write(tmp108->regmap, 230 attr == hwmon_temp_min ? 231 TMP108_REG_TLOW : TMP108_REG_THIGH, 232 tmp108_mC_to_temp_reg(temp)); 233 case hwmon_temp_min_hyst: 234 case hwmon_temp_max_hyst: 235 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC); 236 err = regmap_read(tmp108->regmap, 237 attr == hwmon_temp_min_hyst ? 238 TMP108_REG_TLOW : TMP108_REG_THIGH, 239 ®val); 240 if (err < 0) 241 return err; 242 if (attr == hwmon_temp_min_hyst) 243 temp -= tmp108_temp_reg_to_mC(regval); 244 else 245 temp = tmp108_temp_reg_to_mC(regval) - temp; 246 if (temp < 500) 247 mask = TMP108_HYSTERESIS_0C; 248 else if (temp < 1500) 249 mask = TMP108_HYSTERESIS_1C; 250 else if (temp < 3000) 251 mask = TMP108_HYSTERESIS_2C; 252 else 253 mask = TMP108_HYSTERESIS_4C; 254 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 255 TMP108_CONF_HYSTERESIS_MASK, mask); 256 default: 257 return -EOPNOTSUPP; 258 } 259 } 260 261 static umode_t tmp108_is_visible(const void *data, enum hwmon_sensor_types type, 262 u32 attr, int channel) 263 { 264 const struct tmp108 *tmp108 = data; 265 266 if (type == hwmon_chip && attr == hwmon_chip_update_interval) 267 return 0644; 268 269 if (type != hwmon_temp) 270 return 0; 271 272 switch (attr) { 273 case hwmon_temp_input: 274 case hwmon_temp_min_alarm: 275 case hwmon_temp_max_alarm: 276 return 0444; 277 case hwmon_temp_min: 278 case hwmon_temp_max: 279 return 0644; 280 case hwmon_temp_min_hyst: 281 case hwmon_temp_max_hyst: 282 if (!tmp108->params->config_reg_16bits) 283 return 0; 284 return 0644; 285 default: 286 return 0; 287 } 288 } 289 290 static const struct hwmon_channel_info * const tmp108_info[] = { 291 HWMON_CHANNEL_INFO(chip, 292 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL), 293 HWMON_CHANNEL_INFO(temp, 294 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | 295 HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 296 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM), 297 NULL 298 }; 299 300 static const struct hwmon_ops tmp108_hwmon_ops = { 301 .is_visible = tmp108_is_visible, 302 .read = tmp108_read, 303 .write = tmp108_write, 304 }; 305 306 static const struct hwmon_chip_info tmp108_chip_info = { 307 .ops = &tmp108_hwmon_ops, 308 .info = tmp108_info, 309 }; 310 311 static void tmp108_restore_config(void *data) 312 { 313 struct tmp108 *tmp108 = data; 314 315 regmap_write(tmp108->regmap, TMP108_REG_CONF, tmp108->orig_config); 316 } 317 318 static bool tmp108_is_writeable_reg(struct device *dev, unsigned int reg) 319 { 320 return reg != TMP108_REG_TEMP; 321 } 322 323 static bool tmp108_is_volatile_reg(struct device *dev, unsigned int reg) 324 { 325 /* Configuration register must be volatile to enable FL and FH. */ 326 return reg == TMP108_REG_TEMP || reg == TMP108_REG_CONF; 327 } 328 329 static int tmp108_i2c_reg_read(void *context, unsigned int reg, unsigned int *val) 330 { 331 struct i2c_client *client = context; 332 struct tmp108 *tmp108 = i2c_get_clientdata(client); 333 int ret; 334 335 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits) { 336 ret = i2c_smbus_read_byte_data(client, TMP108_REG_CONF); 337 if (ret < 0) 338 return ret; 339 *val = ret << 8; 340 return 0; 341 } 342 343 ret = i2c_smbus_read_word_swapped(client, reg); 344 if (ret < 0) 345 return ret; 346 *val = ret; 347 return 0; 348 } 349 350 static int tmp108_i2c_reg_write(void *context, unsigned int reg, unsigned int val) 351 { 352 struct i2c_client *client = context; 353 struct tmp108 *tmp108 = i2c_get_clientdata(client); 354 355 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits) 356 return i2c_smbus_write_byte_data(client, reg, val >> 8); 357 return i2c_smbus_write_word_swapped(client, reg, val); 358 } 359 360 static const struct regmap_bus tmp108_i2c_regmap_bus = { 361 .reg_read = tmp108_i2c_reg_read, 362 .reg_write = tmp108_i2c_reg_write, 363 }; 364 365 static int tmp108_i3c_reg_read(void *context, unsigned int reg, unsigned int *val) 366 { 367 struct i3c_device *i3cdev = context; 368 struct tmp108 *tmp108 = i3cdev_get_drvdata(i3cdev); 369 u8 reg_buf[1], val_buf[2]; 370 struct i3c_xfer xfers[] = { 371 { 372 .rnw = false, 373 .len = 1, 374 .data.out = reg_buf, 375 }, 376 { 377 .rnw = true, 378 .len = 2, 379 .data.in = val_buf, 380 }, 381 }; 382 int ret; 383 384 reg_buf[0] = reg; 385 386 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits) 387 xfers[1].len--; 388 389 ret = i3c_device_do_xfers(i3cdev, xfers, 2, I3C_SDR); 390 if (ret < 0) 391 return ret; 392 393 *val = val_buf[0] << 8; 394 if (reg != TMP108_REG_CONF || tmp108->params->config_reg_16bits) 395 *val |= val_buf[1]; 396 397 return 0; 398 } 399 400 static int tmp108_i3c_reg_write(void *context, unsigned int reg, unsigned int val) 401 { 402 struct i3c_device *i3cdev = context; 403 struct tmp108 *tmp108 = i3cdev_get_drvdata(i3cdev); 404 u8 val_buf[3]; 405 struct i3c_xfer xfers[] = { 406 { 407 .rnw = false, 408 .len = 3, 409 .data.out = val_buf, 410 }, 411 }; 412 413 val_buf[0] = reg; 414 val_buf[1] = (val >> 8) & 0xff; 415 416 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits) 417 xfers[0].len--; 418 else 419 val_buf[2] = val & 0xff; 420 421 return i3c_device_do_xfers(i3cdev, xfers, 1, I3C_SDR); 422 } 423 424 static const struct regmap_bus tmp108_i3c_regmap_bus = { 425 .reg_read = tmp108_i3c_reg_read, 426 .reg_write = tmp108_i3c_reg_write, 427 }; 428 429 static const struct regmap_config tmp108_regmap_config = { 430 .reg_bits = 8, 431 .val_bits = 16, 432 .max_register = TMP108_REG_THIGH, 433 .writeable_reg = tmp108_is_writeable_reg, 434 .volatile_reg = tmp108_is_volatile_reg, 435 .val_format_endian = REGMAP_ENDIAN_BIG, 436 .cache_type = REGCACHE_MAPLE, 437 .use_single_read = true, 438 .use_single_write = true, 439 }; 440 441 static int tmp108_common_probe(struct device *dev, struct regmap *regmap, char *name, 442 const struct tmp108_params *params) 443 { 444 struct device *hwmon_dev; 445 struct tmp108 *tmp108; 446 u32 config; 447 int err; 448 449 err = devm_regulator_get_enable(dev, "vcc"); 450 if (err) 451 return dev_err_probe(dev, err, "Failed to enable regulator\n"); 452 453 tmp108 = devm_kzalloc(dev, sizeof(*tmp108), GFP_KERNEL); 454 if (!tmp108) 455 return -ENOMEM; 456 457 dev_set_drvdata(dev, tmp108); 458 tmp108->regmap = regmap; 459 tmp108->params = params; 460 461 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &config); 462 if (err < 0) { 463 dev_err(dev, "error reading config register: %d", err); 464 return err; 465 } 466 tmp108->orig_config = config; 467 468 /* Only continuous mode is supported. */ 469 config &= ~TMP108_CONF_MODE_MASK; 470 config |= TMP108_MODE_CONTINUOUS; 471 /* Only comparator mode is supported. */ 472 config &= ~TMP108_CONF_TM; 473 474 err = regmap_write(tmp108->regmap, TMP108_REG_CONF, config); 475 if (err < 0) { 476 dev_err(dev, "error writing config register: %d", err); 477 return err; 478 } 479 480 tmp108->ready_time = jiffies; 481 if ((tmp108->orig_config & TMP108_CONF_MODE_MASK) == 482 TMP108_MODE_SHUTDOWN) 483 tmp108->ready_time += 484 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS); 485 486 err = devm_add_action_or_reset(dev, tmp108_restore_config, tmp108); 487 if (err) { 488 dev_err(dev, "add action or reset failed: %d", err); 489 return err; 490 } 491 492 hwmon_dev = devm_hwmon_device_register_with_info(dev, name, 493 tmp108, 494 &tmp108_chip_info, 495 NULL); 496 return PTR_ERR_OR_ZERO(hwmon_dev); 497 } 498 499 static int tmp108_probe(struct i2c_client *client) 500 { 501 struct device *dev = &client->dev; 502 struct regmap *regmap; 503 504 if (!i2c_check_functionality(client->adapter, 505 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 506 return dev_err_probe(dev, -ENODEV, 507 "adapter doesn't support SMBus word transactions\n"); 508 509 regmap = devm_regmap_init(dev, &tmp108_i2c_regmap_bus, client, &tmp108_regmap_config); 510 if (IS_ERR(regmap)) 511 return dev_err_probe(dev, PTR_ERR(regmap), "regmap init failed"); 512 513 return tmp108_common_probe(dev, regmap, client->name, i2c_get_match_data(client)); 514 } 515 516 static int tmp108_suspend(struct device *dev) 517 { 518 struct tmp108 *tmp108 = dev_get_drvdata(dev); 519 520 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 521 TMP108_CONF_MODE_MASK, TMP108_MODE_SHUTDOWN); 522 } 523 524 static int tmp108_resume(struct device *dev) 525 { 526 struct tmp108 *tmp108 = dev_get_drvdata(dev); 527 int err; 528 529 err = regmap_update_bits(tmp108->regmap, TMP108_REG_CONF, 530 TMP108_CONF_MODE_MASK, TMP108_MODE_CONTINUOUS); 531 tmp108->ready_time = jiffies + 532 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS); 533 return err; 534 } 535 536 static DEFINE_SIMPLE_DEV_PM_OPS(tmp108_dev_pm_ops, tmp108_suspend, tmp108_resume); 537 538 static const struct i2c_device_id tmp108_i2c_ids[] = { 539 { .name = "p3t1035", .driver_data = (unsigned long)&p3t1035_data }, 540 { .name = "p3t1085", .driver_data = (unsigned long)&tmp108_data }, 541 { .name = "tmp108", .driver_data = (unsigned long)&tmp108_data }, 542 { } 543 }; 544 MODULE_DEVICE_TABLE(i2c, tmp108_i2c_ids); 545 546 static const struct of_device_id tmp108_of_ids[] = { 547 { .compatible = "nxp,p3t1035", .data = &p3t1035_data }, 548 { .compatible = "nxp,p3t1085", .data = &tmp108_data }, 549 { .compatible = "ti,tmp108", .data = &tmp108_data }, 550 {} 551 }; 552 MODULE_DEVICE_TABLE(of, tmp108_of_ids); 553 554 static struct i2c_driver tmp108_driver = { 555 .driver = { 556 .name = DRIVER_NAME, 557 .pm = pm_sleep_ptr(&tmp108_dev_pm_ops), 558 .of_match_table = tmp108_of_ids, 559 }, 560 .probe = tmp108_probe, 561 .id_table = tmp108_i2c_ids, 562 }; 563 564 static const struct i3c_device_id p3t1085_i3c_ids[] = { 565 I3C_DEVICE(0x011B, 0x1529, &tmp108_data), 566 I3C_DEVICE(0x011B, 0x152B, &p3t1035_data), 567 {} 568 }; 569 MODULE_DEVICE_TABLE(i3c, p3t1085_i3c_ids); 570 571 static int p3t1085_i3c_probe(struct i3c_device *i3cdev) 572 { 573 struct device *dev = i3cdev_to_dev(i3cdev); 574 struct regmap *regmap; 575 const struct i3c_device_id *id; 576 577 regmap = devm_regmap_init(dev, &tmp108_i3c_regmap_bus, i3cdev, &tmp108_regmap_config); 578 if (IS_ERR(regmap)) 579 return dev_err_probe(dev, PTR_ERR(regmap), 580 "Failed to register i3c regmap\n"); 581 582 id = i3c_device_match_id(i3cdev, p3t1085_i3c_ids); 583 584 return tmp108_common_probe(dev, regmap, "p3t1085_i3c", id->data); 585 } 586 587 static struct i3c_driver p3t1085_driver = { 588 .driver = { 589 .name = "p3t1085_i3c", 590 }, 591 .probe = p3t1085_i3c_probe, 592 .id_table = p3t1085_i3c_ids, 593 }; 594 595 module_i3c_i2c_driver(p3t1085_driver, &tmp108_driver) 596 597 MODULE_AUTHOR("John Muir <john@jmuir.com>"); 598 MODULE_DESCRIPTION("Texas Instruments TMP108 temperature sensor driver"); 599 MODULE_LICENSE("GPL"); 600