835 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * STTS751 sensor driver4 *5 * Copyright (C) 2016-2017 Istituto Italiano di Tecnologia - RBCS - EDL6 * Robotics, Brain and Cognitive Sciences department7 * Electronic Design Laboratory8 *9 * Written by Andrea Merello <andrea.merello@gmail.com>10 *11 * Based on LM95241 driver and LM90 driver12 */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 31static 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 0x0037#define STTS751_REG_STATUS 0x0138#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 0x0242#define STTS751_REG_CONF 0x0343#define STTS751_CONF_RES_MASK 0x0C44#define STTS751_CONF_RES_SHIFT 245#define STTS751_CONF_EVENT_DIS BIT(7)46#define STTS751_CONF_STOP BIT(6)47#define STTS751_REG_RATE 0x0448#define STTS751_REG_HLIM_H 0x0549#define STTS751_REG_HLIM_L 0x0650#define STTS751_REG_LLIM_H 0x0751#define STTS751_REG_LLIM_L 0x0852#define STTS751_REG_TLIM 0x2053#define STTS751_REG_HYST 0x2154#define STTS751_REG_SMBUS_TO 0x2255 56#define STTS751_REG_PROD_ID 0xFD57#define STTS751_REG_MAN_ID 0xFE58#define STTS751_REG_REV_ID 0xFF59 60#define STTS751_0_PROD_ID 0x0061#define STTS751_1_PROD_ID 0x0162#define ST_MAN_ID 0x5363 64/*65 * Possible update intervals are (in mS):66 * 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 62.5, 31.2567 * However we are not going to complicate things too much and we stick to the68 * approx value in mS.69 */70static const int stts751_intervals[] = {71 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 3172};73 74static const struct i2c_device_id stts751_id[] = {75 { "stts751" },76 { }77};78 79static const struct of_device_id __maybe_unused stts751_of_match[] = {80 { .compatible = "st,stts751" },81 { },82};83MODULE_DEVICE_TABLE(of, stts751_of_match);84 85struct 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 and104 * vice-vers. They are (mostly) taken from lm90 driver. Unit is in mC.105 */106static int stts751_to_deg(s16 hw_val)107{108 return hw_val * 125 / 32;109}110 111static s32 stts751_to_hw(int val)112{113 return DIV_ROUND_CLOSEST(val, 125) * 32;114}115 116static 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 148static 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 two154 * registers to get the sensor temperature, but we have to beware a155 * conversion could occur between the readings. We could use the156 * one-shot conversion register, but we don't want to do this (disables157 * hardware monitoring). So the solution used here is to read the high158 * byte once, then the low byte, then the high byte again. If the new159 * high byte matches the old one, then we have a valid reading. Else we160 * have to read the low byte again, and now we believe we have a correct161 * 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 199static 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 214static 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 222static 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 240static 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 alerts255 * immediately for the sake of the alert handler; we still need to deal with256 * caching to workaround the fact that alarm flags int the status register,257 * despite what the datasheet claims, gets always cleared on read.258 */259static 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 conversion267 * 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 sure279 * we have valid data from a device conversion, or if we know280 * our cache has been never written.281 *282 * Note that when the cache has been never written the point is283 * to correctly initialize the timestamp, rather than clearing284 * the cache values.285 *286 * Note that updating the cache timestamp when we get an alarm flag287 * 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 308static 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 354static 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 375static 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 392static 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 409static 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 424static 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 432static 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 be453 * adjusted, we need to update our local copy only.454 */455 priv->hyst = temp - (priv->therm - priv->hyst);456 priv->therm = temp;457 458exit:459 mutex_unlock(&priv->access_lock);460 if (ret)461 return ret;462 463 return count;464}465 466static 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 474static 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 499static 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 514static 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 522static 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;543exit:544 mutex_unlock(&priv->access_lock);545 return ret;546}547 548static 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 556static 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;577exit:578 mutex_unlock(&priv->access_lock);579 return ret;580}581 582static 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 591static 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 chip615 * starting to misbehave if I ever set, even briefly, an invalid616 * configuration. While I'm not sure this is really needed, be617 * conservative and set rate/resolution in such an order that avoids618 * 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;642exit:643 mutex_unlock(&priv->access_lock);644 645 return ret;646}647 648static 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 698static 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 740static SENSOR_DEVICE_ATTR_RO(temp1_input, input, 0);741static SENSOR_DEVICE_ATTR_RW(temp1_min, min, 0);742static SENSOR_DEVICE_ATTR_RW(temp1_max, max, 0);743static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, min_alarm, 0);744static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, max_alarm, 0);745static SENSOR_DEVICE_ATTR_RW(temp1_crit, therm, 0);746static SENSOR_DEVICE_ATTR_RW(temp1_crit_hyst, hyst, 0);747static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, therm_trip, 0);748static SENSOR_DEVICE_ATTR_RW(update_interval, interval, 0);749 750static 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 NULL761};762ATTRIBUTE_GROUPS(stts751);763 764static 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 815MODULE_DEVICE_TABLE(i2c, stts751_id);816 817static 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 830module_i2c_driver(stts751_driver);831 832MODULE_AUTHOR("Andrea Merello <andrea.merello@gmail.com>");833MODULE_DESCRIPTION("STTS751 sensor driver");834MODULE_LICENSE("GPL");835