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