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