drivers/hwmon/stts751.c

   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");