Loading...
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
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 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 */
70static const int stts751_intervals[] = {
71 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 31
72};
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 and
104 * 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 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
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 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 */
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 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
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 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
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 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;
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 NULL
761};
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");
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
40static 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 */
79static const int stts751_intervals[] = {
80 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 63, 31
81};
82
83static const struct i2c_device_id stts751_id[] = {
84 { "stts751", 0 },
85 { }
86};
87
88static const struct of_device_id stts751_of_match[] = {
89 { .compatible = "stts751" },
90 { },
91};
92MODULE_DEVICE_TABLE(of, stts751_of_match);
93
94struct 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 */
116static int stts751_to_deg(s16 hw_val)
117{
118 return hw_val * 125 / 32;
119}
120
121static s32 stts751_to_hw(int val)
122{
123 return DIV_ROUND_CLOSEST(val, 125) * 32;
124}
125
126static 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
158static 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
209static 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
224static 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
232static 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
250static 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 */
269static 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
318static 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
364static 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
385static 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, "%d\n", priv->max_alert);
400}
401
402static 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, "%d\n", priv->min_alert);
417}
418
419static 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, "%d\n", priv->temp);
432}
433
434static 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, "%d\n", priv->therm);
440}
441
442static 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
468exit:
469 mutex_unlock(&priv->access_lock);
470 if (ret)
471 return ret;
472
473 return count;
474}
475
476static 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, "%d\n", priv->hyst);
482}
483
484static 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
509static 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, "%d\n", priv->therm_trip);
522}
523
524static 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, "%d\n", priv->event_max);
530}
531
532static 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;
553exit:
554 mutex_unlock(&priv->access_lock);
555 return ret;
556}
557
558static 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, "%d\n", priv->event_min);
564}
565
566static 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;
587exit:
588 mutex_unlock(&priv->access_lock);
589 return ret;
590}
591
592static 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, "%d\n",
598 stts751_intervals[priv->interval]);
599}
600
601static 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;
651exit:
652 mutex_unlock(&priv->access_lock);
653
654 return ret;
655}
656
657static 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
707static 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
749static SENSOR_DEVICE_ATTR(temp1_input, 0444, show_input, NULL, 0);
750static SENSOR_DEVICE_ATTR(temp1_min, 0644, show_min, set_min, 0);
751static SENSOR_DEVICE_ATTR(temp1_max, 0644, show_max, set_max, 0);
752static SENSOR_DEVICE_ATTR(temp1_min_alarm, 0444, show_min_alarm, NULL, 0);
753static SENSOR_DEVICE_ATTR(temp1_max_alarm, 0444, show_max_alarm, NULL, 0);
754static SENSOR_DEVICE_ATTR(temp1_crit, 0644, show_therm, set_therm, 0);
755static SENSOR_DEVICE_ATTR(temp1_crit_hyst, 0644, show_hyst, set_hyst, 0);
756static SENSOR_DEVICE_ATTR(temp1_crit_alarm, 0444, show_therm_trip, NULL, 0);
757static SENSOR_DEVICE_ATTR(update_interval, 0644,
758 show_interval, set_interval, 0);
759
760static 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};
772ATTRIBUTE_GROUPS(stts751);
773
774static 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
826MODULE_DEVICE_TABLE(i2c, stts751_id);
827
828static 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
841module_i2c_driver(stts751_driver);
842
843MODULE_AUTHOR("Andrea Merello <andrea.merello@gmail.com>");
844MODULE_DESCRIPTION("STTS751 sensor driver");
845MODULE_LICENSE("GPL");