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