1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * STTS751 sensor driver 4 * 5 * Copyright (C) 2016-2017 Istituto Italiano di Tecnologia - RBCS - EDL 6 * Robotics, Brain and Cognitive Sciences department 7 * Electronic Design Laboratory 8 * 9 * Written by Andrea Merello <andrea.merello@gmail.com> 10 * 11 * Based on LM95241 driver and LM90 driver 12 */ 13 14 #include <linux/bitops.h> 15 #include <linux/err.h> 16 #include <linux/hwmon.h> 17 #include <linux/hwmon-sysfs.h> 18 #include <linux/i2c.h> 19 #include <linux/init.h> 20 #include <linux/interrupt.h> 21 #include <linux/jiffies.h> 22 #include <linux/module.h> 23 #include <linux/mutex.h> 24 #include <linux/property.h> 25 #include <linux/slab.h> 26 #include <linux/sysfs.h> 27 #include <linux/util_macros.h> 28 29 #define DEVNAME "stts751" 30 31 static const unsigned short normal_i2c[] = { 32 0x48, 0x49, 0x38, 0x39, /* STTS751-0 */ 33 0x4A, 0x4B, 0x3A, 0x3B, /* STTS751-1 */ 34 I2C_CLIENT_END }; 35 36 #define STTS751_REG_TEMP_H 0x00 37 #define STTS751_REG_STATUS 0x01 38 #define STTS751_STATUS_TRIPT BIT(0) 39 #define STTS751_STATUS_TRIPL BIT(5) 40 #define STTS751_STATUS_TRIPH BIT(6) 41 #define STTS751_REG_TEMP_L 0x02 42 #define STTS751_REG_CONF 0x03 43 #define STTS751_CONF_RES_MASK 0x0C 44 #define STTS751_CONF_RES_SHIFT 2 45 #define STTS751_CONF_EVENT_DIS BIT(7) 46 #define STTS751_CONF_STOP BIT(6) 47 #define STTS751_REG_RATE 0x04 48 #define STTS751_REG_HLIM_H 0x05 49 #define STTS751_REG_HLIM_L 0x06 50 #define STTS751_REG_LLIM_H 0x07 51 #define STTS751_REG_LLIM_L 0x08 52 #define STTS751_REG_TLIM 0x20 53 #define STTS751_REG_HYST 0x21 54 #define STTS751_REG_SMBUS_TO 0x22 55 56 #define STTS751_REG_PROD_ID 0xFD 57 #define STTS751_REG_MAN_ID 0xFE 58 #define STTS751_REG_REV_ID 0xFF 59 60 #define STTS751_0_PROD_ID 0x00 61 #define STTS751_1_PROD_ID 0x01 62 #define ST_MAN_ID 0x53 63 64 /* 65 * Possible update intervals are (in mS): 66 * 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 62.5, 31.25 67 * However we are not going to complicate things too much and we stick to the 68 * approx value in mS. 69 */ 70 static const int stts751_intervals[] = { 71 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 31 72 }; 73 74 static const struct i2c_device_id stts751_id[] = { 75 { "stts751" }, 76 { } 77 }; 78 79 static const struct of_device_id __maybe_unused stts751_of_match[] = { 80 { .compatible = "st,stts751" }, 81 { }, 82 }; 83 MODULE_DEVICE_TABLE(of, stts751_of_match); 84 85 struct stts751_priv { 86 struct device *dev; 87 struct i2c_client *client; 88 struct mutex access_lock; 89 u8 interval; 90 int res; 91 int event_max, event_min; 92 int therm; 93 int hyst; 94 int temp; 95 unsigned long last_update, last_alert_update; 96 u8 config; 97 bool min_alert, max_alert, therm_trip; 98 bool data_valid, alert_valid; 99 bool notify_max, notify_min; 100 }; 101 102 /* 103 * These functions converts temperature from HW format to integer format and 104 * vice-vers. They are (mostly) taken from lm90 driver. Unit is in mC. 105 */ 106 static int stts751_to_deg(s16 hw_val) 107 { 108 return hw_val * 125 / 32; 109 } 110 111 static s32 stts751_to_hw(int val) 112 { 113 return DIV_ROUND_CLOSEST(val, 125) * 32; 114 } 115 116 static int stts751_adjust_resolution(struct stts751_priv *priv) 117 { 118 u8 res; 119 120 switch (priv->interval) { 121 case 9: 122 /* 10 bits */ 123 res = 0; 124 break; 125 case 8: 126 /* 11 bits */ 127 res = 1; 128 break; 129 default: 130 /* 12 bits */ 131 res = 3; 132 break; 133 } 134 135 if (priv->res == res) 136 return 0; 137 138 priv->config &= ~STTS751_CONF_RES_MASK; 139 priv->config |= res << STTS751_CONF_RES_SHIFT; 140 dev_dbg(&priv->client->dev, "setting res %d. config %x", 141 res, priv->config); 142 priv->res = res; 143 144 return i2c_smbus_write_byte_data(priv->client, 145 STTS751_REG_CONF, priv->config); 146 } 147 148 static int stts751_update_temp(struct stts751_priv *priv) 149 { 150 s32 integer1, integer2, frac; 151 152 /* 153 * There is a trick here, like in the lm90 driver. We have to read two 154 * registers to get the sensor temperature, but we have to beware a 155 * conversion could occur between the readings. We could use the 156 * one-shot conversion register, but we don't want to do this (disables 157 * hardware monitoring). So the solution used here is to read the high 158 * byte once, then the low byte, then the high byte again. If the new 159 * high byte matches the old one, then we have a valid reading. Else we 160 * have to read the low byte again, and now we believe we have a correct 161 * reading. 162 */ 163 integer1 = i2c_smbus_read_byte_data(priv->client, STTS751_REG_TEMP_H); 164 if (integer1 < 0) { 165 dev_dbg(&priv->client->dev, 166 "I2C read failed (temp H). ret: %x\n", integer1); 167 return integer1; 168 } 169 170 frac = i2c_smbus_read_byte_data(priv->client, STTS751_REG_TEMP_L); 171 if (frac < 0) { 172 dev_dbg(&priv->client->dev, 173 "I2C read failed (temp L). ret: %x\n", frac); 174 return frac; 175 } 176 177 integer2 = i2c_smbus_read_byte_data(priv->client, STTS751_REG_TEMP_H); 178 if (integer2 < 0) { 179 dev_dbg(&priv->client->dev, 180 "I2C 2nd read failed (temp H). ret: %x\n", integer2); 181 return integer2; 182 } 183 184 if (integer1 != integer2) { 185 frac = i2c_smbus_read_byte_data(priv->client, 186 STTS751_REG_TEMP_L); 187 if (frac < 0) { 188 dev_dbg(&priv->client->dev, 189 "I2C 2nd read failed (temp L). ret: %x\n", 190 frac); 191 return frac; 192 } 193 } 194 195 priv->temp = stts751_to_deg((integer1 << 8) | frac); 196 return 0; 197 } 198 199 static int stts751_set_temp_reg16(struct stts751_priv *priv, int temp, 200 u8 hreg, u8 lreg) 201 { 202 s32 hwval; 203 int ret; 204 205 hwval = stts751_to_hw(temp); 206 207 ret = i2c_smbus_write_byte_data(priv->client, hreg, hwval >> 8); 208 if (ret) 209 return ret; 210 211 return i2c_smbus_write_byte_data(priv->client, lreg, hwval & 0xff); 212 } 213 214 static int stts751_set_temp_reg8(struct stts751_priv *priv, int temp, u8 reg) 215 { 216 s32 hwval; 217 218 hwval = stts751_to_hw(temp); 219 return i2c_smbus_write_byte_data(priv->client, reg, hwval >> 8); 220 } 221 222 static int stts751_read_reg16(struct stts751_priv *priv, int *temp, 223 u8 hreg, u8 lreg) 224 { 225 int integer, frac; 226 227 integer = i2c_smbus_read_byte_data(priv->client, hreg); 228 if (integer < 0) 229 return integer; 230 231 frac = i2c_smbus_read_byte_data(priv->client, lreg); 232 if (frac < 0) 233 return frac; 234 235 *temp = stts751_to_deg((integer << 8) | frac); 236 237 return 0; 238 } 239 240 static int stts751_read_reg8(struct stts751_priv *priv, int *temp, u8 reg) 241 { 242 int integer; 243 244 integer = i2c_smbus_read_byte_data(priv->client, reg); 245 if (integer < 0) 246 return integer; 247 248 *temp = stts751_to_deg(integer << 8); 249 250 return 0; 251 } 252 253 /* 254 * Update alert flags without waiting for cache to expire. We detects alerts 255 * immediately for the sake of the alert handler; we still need to deal with 256 * caching to workaround the fact that alarm flags int the status register, 257 * despite what the datasheet claims, gets always cleared on read. 258 */ 259 static int stts751_update_alert(struct stts751_priv *priv) 260 { 261 int ret; 262 bool conv_done; 263 int cache_time = msecs_to_jiffies(stts751_intervals[priv->interval]); 264 265 /* 266 * Add another 10% because if we run faster than the HW conversion 267 * rate we will end up in reporting incorrectly alarms. 268 */ 269 cache_time += cache_time / 10; 270 271 ret = i2c_smbus_read_byte_data(priv->client, STTS751_REG_STATUS); 272 if (ret < 0) 273 return ret; 274 275 dev_dbg(&priv->client->dev, "status reg %x\n", ret); 276 conv_done = ret & (STTS751_STATUS_TRIPH | STTS751_STATUS_TRIPL); 277 /* 278 * Reset the cache if the cache time expired, or if we are sure 279 * we have valid data from a device conversion, or if we know 280 * our cache has been never written. 281 * 282 * Note that when the cache has been never written the point is 283 * to correctly initialize the timestamp, rather than clearing 284 * the cache values. 285 * 286 * Note that updating the cache timestamp when we get an alarm flag 287 * is required, otherwise we could incorrectly report alarms to be zero. 288 */ 289 if (time_after(jiffies, priv->last_alert_update + cache_time) || 290 conv_done || !priv->alert_valid) { 291 priv->max_alert = false; 292 priv->min_alert = false; 293 priv->alert_valid = true; 294 priv->last_alert_update = jiffies; 295 dev_dbg(&priv->client->dev, "invalidating alert cache\n"); 296 } 297 298 priv->max_alert |= !!(ret & STTS751_STATUS_TRIPH); 299 priv->min_alert |= !!(ret & STTS751_STATUS_TRIPL); 300 priv->therm_trip = !!(ret & STTS751_STATUS_TRIPT); 301 302 dev_dbg(&priv->client->dev, "max_alert: %d, min_alert: %d, therm_trip: %d\n", 303 priv->max_alert, priv->min_alert, priv->therm_trip); 304 305 return 0; 306 } 307 308 static void stts751_alert(struct i2c_client *client, 309 enum i2c_alert_protocol type, unsigned int data) 310 { 311 int ret; 312 struct stts751_priv *priv = i2c_get_clientdata(client); 313 314 if (type != I2C_PROTOCOL_SMBUS_ALERT) 315 return; 316 317 dev_dbg(&client->dev, "alert!"); 318 319 mutex_lock(&priv->access_lock); 320 ret = stts751_update_alert(priv); 321 if (ret < 0) { 322 /* default to worst case */ 323 priv->max_alert = true; 324 priv->min_alert = true; 325 326 dev_warn(priv->dev, 327 "Alert received, but can't communicate to the device. Triggering all alarms!"); 328 } 329 330 if (priv->max_alert) { 331 if (priv->notify_max) 332 dev_notice(priv->dev, "got alert for HIGH temperature"); 333 priv->notify_max = false; 334 335 /* unblock alert poll */ 336 sysfs_notify(&priv->dev->kobj, NULL, "temp1_max_alarm"); 337 } 338 339 if (priv->min_alert) { 340 if (priv->notify_min) 341 dev_notice(priv->dev, "got alert for LOW temperature"); 342 priv->notify_min = false; 343 344 /* unblock alert poll */ 345 sysfs_notify(&priv->dev->kobj, NULL, "temp1_min_alarm"); 346 } 347 348 if (priv->min_alert || priv->max_alert) 349 kobject_uevent(&priv->dev->kobj, KOBJ_CHANGE); 350 351 mutex_unlock(&priv->access_lock); 352 } 353 354 static int stts751_update(struct stts751_priv *priv) 355 { 356 int ret; 357 int cache_time = msecs_to_jiffies(stts751_intervals[priv->interval]); 358 359 if (time_after(jiffies, priv->last_update + cache_time) || 360 !priv->data_valid) { 361 ret = stts751_update_temp(priv); 362 if (ret) 363 return ret; 364 365 ret = stts751_update_alert(priv); 366 if (ret) 367 return ret; 368 priv->data_valid = true; 369 priv->last_update = jiffies; 370 } 371 372 return 0; 373 } 374 375 static ssize_t max_alarm_show(struct device *dev, 376 struct device_attribute *attr, char *buf) 377 { 378 int ret; 379 struct stts751_priv *priv = dev_get_drvdata(dev); 380 381 mutex_lock(&priv->access_lock); 382 ret = stts751_update(priv); 383 if (!ret) 384 priv->notify_max = true; 385 mutex_unlock(&priv->access_lock); 386 if (ret < 0) 387 return ret; 388 389 return sysfs_emit(buf, "%d\n", priv->max_alert); 390 } 391 392 static ssize_t min_alarm_show(struct device *dev, 393 struct device_attribute *attr, char *buf) 394 { 395 int ret; 396 struct stts751_priv *priv = dev_get_drvdata(dev); 397 398 mutex_lock(&priv->access_lock); 399 ret = stts751_update(priv); 400 if (!ret) 401 priv->notify_min = true; 402 mutex_unlock(&priv->access_lock); 403 if (ret < 0) 404 return ret; 405 406 return sysfs_emit(buf, "%d\n", priv->min_alert); 407 } 408 409 static ssize_t input_show(struct device *dev, struct device_attribute *attr, 410 char *buf) 411 { 412 int ret; 413 struct stts751_priv *priv = dev_get_drvdata(dev); 414 415 mutex_lock(&priv->access_lock); 416 ret = stts751_update(priv); 417 mutex_unlock(&priv->access_lock); 418 if (ret < 0) 419 return ret; 420 421 return sysfs_emit(buf, "%d\n", priv->temp); 422 } 423 424 static ssize_t therm_show(struct device *dev, struct device_attribute *attr, 425 char *buf) 426 { 427 struct stts751_priv *priv = dev_get_drvdata(dev); 428 429 return sysfs_emit(buf, "%d\n", priv->therm); 430 } 431 432 static ssize_t therm_store(struct device *dev, struct device_attribute *attr, 433 const char *buf, size_t count) 434 { 435 int ret; 436 long temp; 437 struct stts751_priv *priv = dev_get_drvdata(dev); 438 439 if (kstrtol(buf, 10, &temp) < 0) 440 return -EINVAL; 441 442 /* HW works in range -64C to +127.937C */ 443 temp = clamp_val(temp, -64000, 127937); 444 mutex_lock(&priv->access_lock); 445 ret = stts751_set_temp_reg8(priv, temp, STTS751_REG_TLIM); 446 if (ret) 447 goto exit; 448 449 dev_dbg(&priv->client->dev, "setting therm %ld", temp); 450 451 /* 452 * hysteresis reg is relative to therm, so the HW does not need to be 453 * adjusted, we need to update our local copy only. 454 */ 455 priv->hyst = temp - (priv->therm - priv->hyst); 456 priv->therm = temp; 457 458 exit: 459 mutex_unlock(&priv->access_lock); 460 if (ret) 461 return ret; 462 463 return count; 464 } 465 466 static ssize_t hyst_show(struct device *dev, struct device_attribute *attr, 467 char *buf) 468 { 469 struct stts751_priv *priv = dev_get_drvdata(dev); 470 471 return sysfs_emit(buf, "%d\n", priv->hyst); 472 } 473 474 static ssize_t hyst_store(struct device *dev, struct device_attribute *attr, 475 const char *buf, size_t count) 476 { 477 int ret; 478 long temp; 479 480 struct stts751_priv *priv = dev_get_drvdata(dev); 481 482 if (kstrtol(buf, 10, &temp) < 0) 483 return -EINVAL; 484 485 mutex_lock(&priv->access_lock); 486 /* HW works in range -64C to +127.937C */ 487 temp = clamp_val(temp, -64000, priv->therm); 488 priv->hyst = temp; 489 dev_dbg(&priv->client->dev, "setting hyst %ld", temp); 490 temp = priv->therm - temp; 491 ret = stts751_set_temp_reg8(priv, temp, STTS751_REG_HYST); 492 mutex_unlock(&priv->access_lock); 493 if (ret) 494 return ret; 495 496 return count; 497 } 498 499 static ssize_t therm_trip_show(struct device *dev, 500 struct device_attribute *attr, char *buf) 501 { 502 int ret; 503 struct stts751_priv *priv = dev_get_drvdata(dev); 504 505 mutex_lock(&priv->access_lock); 506 ret = stts751_update(priv); 507 mutex_unlock(&priv->access_lock); 508 if (ret < 0) 509 return ret; 510 511 return sysfs_emit(buf, "%d\n", priv->therm_trip); 512 } 513 514 static ssize_t max_show(struct device *dev, struct device_attribute *attr, 515 char *buf) 516 { 517 struct stts751_priv *priv = dev_get_drvdata(dev); 518 519 return sysfs_emit(buf, "%d\n", priv->event_max); 520 } 521 522 static ssize_t max_store(struct device *dev, struct device_attribute *attr, 523 const char *buf, size_t count) 524 { 525 int ret; 526 long temp; 527 struct stts751_priv *priv = dev_get_drvdata(dev); 528 529 if (kstrtol(buf, 10, &temp) < 0) 530 return -EINVAL; 531 532 mutex_lock(&priv->access_lock); 533 /* HW works in range -64C to +127.937C */ 534 temp = clamp_val(temp, priv->event_min, 127937); 535 ret = stts751_set_temp_reg16(priv, temp, 536 STTS751_REG_HLIM_H, STTS751_REG_HLIM_L); 537 if (ret) 538 goto exit; 539 540 dev_dbg(&priv->client->dev, "setting event max %ld", temp); 541 priv->event_max = temp; 542 ret = count; 543 exit: 544 mutex_unlock(&priv->access_lock); 545 return ret; 546 } 547 548 static ssize_t min_show(struct device *dev, struct device_attribute *attr, 549 char *buf) 550 { 551 struct stts751_priv *priv = dev_get_drvdata(dev); 552 553 return sysfs_emit(buf, "%d\n", priv->event_min); 554 } 555 556 static ssize_t min_store(struct device *dev, struct device_attribute *attr, 557 const char *buf, size_t count) 558 { 559 int ret; 560 long temp; 561 struct stts751_priv *priv = dev_get_drvdata(dev); 562 563 if (kstrtol(buf, 10, &temp) < 0) 564 return -EINVAL; 565 566 mutex_lock(&priv->access_lock); 567 /* HW works in range -64C to +127.937C */ 568 temp = clamp_val(temp, -64000, priv->event_max); 569 ret = stts751_set_temp_reg16(priv, temp, 570 STTS751_REG_LLIM_H, STTS751_REG_LLIM_L); 571 if (ret) 572 goto exit; 573 574 dev_dbg(&priv->client->dev, "setting event min %ld", temp); 575 priv->event_min = temp; 576 ret = count; 577 exit: 578 mutex_unlock(&priv->access_lock); 579 return ret; 580 } 581 582 static ssize_t interval_show(struct device *dev, 583 struct device_attribute *attr, char *buf) 584 { 585 struct stts751_priv *priv = dev_get_drvdata(dev); 586 587 return sysfs_emit(buf, "%d\n", 588 stts751_intervals[priv->interval]); 589 } 590 591 static ssize_t interval_store(struct device *dev, 592 struct device_attribute *attr, const char *buf, 593 size_t count) 594 { 595 unsigned long val; 596 int idx; 597 int ret = count; 598 struct stts751_priv *priv = dev_get_drvdata(dev); 599 600 if (kstrtoul(buf, 10, &val) < 0) 601 return -EINVAL; 602 603 idx = find_closest_descending(val, stts751_intervals, 604 ARRAY_SIZE(stts751_intervals)); 605 606 dev_dbg(&priv->client->dev, "setting interval. req:%lu, idx: %d, val: %d", 607 val, idx, stts751_intervals[idx]); 608 609 mutex_lock(&priv->access_lock); 610 if (priv->interval == idx) 611 goto exit; 612 613 /* 614 * In early development stages I've become suspicious about the chip 615 * starting to misbehave if I ever set, even briefly, an invalid 616 * configuration. While I'm not sure this is really needed, be 617 * conservative and set rate/resolution in such an order that avoids 618 * passing through an invalid configuration. 619 */ 620 621 /* speed up: lower the resolution, then modify convrate */ 622 if (priv->interval < idx) { 623 dev_dbg(&priv->client->dev, "lower resolution, then modify convrate"); 624 priv->interval = idx; 625 ret = stts751_adjust_resolution(priv); 626 if (ret) 627 goto exit; 628 } 629 630 ret = i2c_smbus_write_byte_data(priv->client, STTS751_REG_RATE, idx); 631 if (ret) 632 goto exit; 633 /* slow down: modify convrate, then raise resolution */ 634 if (priv->interval != idx) { 635 dev_dbg(&priv->client->dev, "modify convrate, then raise resolution"); 636 priv->interval = idx; 637 ret = stts751_adjust_resolution(priv); 638 if (ret) 639 goto exit; 640 } 641 ret = count; 642 exit: 643 mutex_unlock(&priv->access_lock); 644 645 return ret; 646 } 647 648 static int stts751_detect(struct i2c_client *new_client, 649 struct i2c_board_info *info) 650 { 651 struct i2c_adapter *adapter = new_client->adapter; 652 const char *name; 653 int tmp; 654 655 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 656 return -ENODEV; 657 658 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_MAN_ID); 659 if (tmp != ST_MAN_ID) 660 return -ENODEV; 661 662 /* lower temperaure registers always have bits 0-3 set to zero */ 663 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_TEMP_L); 664 if (tmp & 0xf) 665 return -ENODEV; 666 667 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_HLIM_L); 668 if (tmp & 0xf) 669 return -ENODEV; 670 671 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_LLIM_L); 672 if (tmp & 0xf) 673 return -ENODEV; 674 675 /* smbus timeout register always have bits 0-7 set to zero */ 676 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_SMBUS_TO); 677 if (tmp & 0x7f) 678 return -ENODEV; 679 680 tmp = i2c_smbus_read_byte_data(new_client, STTS751_REG_PROD_ID); 681 682 switch (tmp) { 683 case STTS751_0_PROD_ID: 684 name = "STTS751-0"; 685 break; 686 case STTS751_1_PROD_ID: 687 name = "STTS751-1"; 688 break; 689 default: 690 return -ENODEV; 691 } 692 dev_dbg(&new_client->dev, "Chip %s detected", name); 693 694 strscpy(info->type, stts751_id[0].name, I2C_NAME_SIZE); 695 return 0; 696 } 697 698 static int stts751_read_chip_config(struct stts751_priv *priv) 699 { 700 int ret; 701 int tmp; 702 703 ret = i2c_smbus_read_byte_data(priv->client, STTS751_REG_CONF); 704 if (ret < 0) 705 return ret; 706 priv->config = ret; 707 priv->res = (ret & STTS751_CONF_RES_MASK) >> STTS751_CONF_RES_SHIFT; 708 709 ret = i2c_smbus_read_byte_data(priv->client, STTS751_REG_RATE); 710 if (ret < 0) 711 return ret; 712 if (ret >= ARRAY_SIZE(stts751_intervals)) { 713 dev_err(priv->dev, "Unrecognized conversion rate 0x%x\n", ret); 714 return -ENODEV; 715 } 716 priv->interval = ret; 717 718 ret = stts751_read_reg16(priv, &priv->event_max, 719 STTS751_REG_HLIM_H, STTS751_REG_HLIM_L); 720 if (ret) 721 return ret; 722 723 ret = stts751_read_reg16(priv, &priv->event_min, 724 STTS751_REG_LLIM_H, STTS751_REG_LLIM_L); 725 if (ret) 726 return ret; 727 728 ret = stts751_read_reg8(priv, &priv->therm, STTS751_REG_TLIM); 729 if (ret) 730 return ret; 731 732 ret = stts751_read_reg8(priv, &tmp, STTS751_REG_HYST); 733 if (ret) 734 return ret; 735 priv->hyst = priv->therm - tmp; 736 737 return 0; 738 } 739 740 static SENSOR_DEVICE_ATTR_RO(temp1_input, input, 0); 741 static SENSOR_DEVICE_ATTR_RW(temp1_min, min, 0); 742 static SENSOR_DEVICE_ATTR_RW(temp1_max, max, 0); 743 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, min_alarm, 0); 744 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, max_alarm, 0); 745 static SENSOR_DEVICE_ATTR_RW(temp1_crit, therm, 0); 746 static SENSOR_DEVICE_ATTR_RW(temp1_crit_hyst, hyst, 0); 747 static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, therm_trip, 0); 748 static SENSOR_DEVICE_ATTR_RW(update_interval, interval, 0); 749 750 static struct attribute *stts751_attrs[] = { 751 &sensor_dev_attr_temp1_input.dev_attr.attr, 752 &sensor_dev_attr_temp1_min.dev_attr.attr, 753 &sensor_dev_attr_temp1_max.dev_attr.attr, 754 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 755 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 756 &sensor_dev_attr_temp1_crit.dev_attr.attr, 757 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 758 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 759 &sensor_dev_attr_update_interval.dev_attr.attr, 760 NULL 761 }; 762 ATTRIBUTE_GROUPS(stts751); 763 764 static int stts751_probe(struct i2c_client *client) 765 { 766 struct stts751_priv *priv; 767 int ret; 768 bool smbus_nto; 769 int rev_id; 770 771 priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); 772 if (!priv) 773 return -ENOMEM; 774 775 priv->client = client; 776 priv->notify_max = true; 777 priv->notify_min = true; 778 i2c_set_clientdata(client, priv); 779 mutex_init(&priv->access_lock); 780 781 if (device_property_present(&client->dev, 782 "smbus-timeout-disable")) { 783 smbus_nto = device_property_read_bool(&client->dev, 784 "smbus-timeout-disable"); 785 786 ret = i2c_smbus_write_byte_data(client, STTS751_REG_SMBUS_TO, 787 smbus_nto ? 0 : 0x80); 788 if (ret) 789 return ret; 790 } 791 792 rev_id = i2c_smbus_read_byte_data(client, STTS751_REG_REV_ID); 793 if (rev_id < 0) 794 return -ENODEV; 795 if (rev_id != 0x1) { 796 dev_dbg(&client->dev, "Chip revision 0x%x is untested\n", 797 rev_id); 798 } 799 800 ret = stts751_read_chip_config(priv); 801 if (ret) 802 return ret; 803 804 priv->config &= ~(STTS751_CONF_STOP | STTS751_CONF_EVENT_DIS); 805 ret = i2c_smbus_write_byte_data(client, STTS751_REG_CONF, priv->config); 806 if (ret) 807 return ret; 808 809 priv->dev = devm_hwmon_device_register_with_groups(&client->dev, 810 client->name, priv, 811 stts751_groups); 812 return PTR_ERR_OR_ZERO(priv->dev); 813 } 814 815 MODULE_DEVICE_TABLE(i2c, stts751_id); 816 817 static struct i2c_driver stts751_driver = { 818 .class = I2C_CLASS_HWMON, 819 .driver = { 820 .name = DEVNAME, 821 .of_match_table = of_match_ptr(stts751_of_match), 822 }, 823 .probe = stts751_probe, 824 .id_table = stts751_id, 825 .detect = stts751_detect, 826 .alert = stts751_alert, 827 .address_list = normal_i2c, 828 }; 829 830 module_i2c_driver(stts751_driver); 831 832 MODULE_AUTHOR("Andrea Merello <andrea.merello@gmail.com>"); 833 MODULE_DESCRIPTION("STTS751 sensor driver"); 834 MODULE_LICENSE("GPL"); 835