1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82#include <linux/module.h>
83#include <linux/init.h>
84#include <linux/slab.h>
85#include <linux/jiffies.h>
86#include <linux/i2c.h>
87#include <linux/hwmon.h>
88#include <linux/err.h>
89#include <linux/mutex.h>
90#include <linux/of_device.h>
91#include <linux/sysfs.h>
92#include <linux/interrupt.h>
93#include <linux/regulator/consumer.h>
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110static const unsigned short normal_i2c[] = {
111 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
112 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
113
114enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
115 max6646, w83l771, max6696, sa56004, g781, tmp451, max6654 };
116
117
118
119
120
121#define LM90_REG_R_MAN_ID 0xFE
122#define LM90_REG_R_CHIP_ID 0xFF
123#define LM90_REG_R_CONFIG1 0x03
124#define LM90_REG_W_CONFIG1 0x09
125#define LM90_REG_R_CONFIG2 0xBF
126#define LM90_REG_W_CONFIG2 0xBF
127#define LM90_REG_R_CONVRATE 0x04
128#define LM90_REG_W_CONVRATE 0x0A
129#define LM90_REG_R_STATUS 0x02
130#define LM90_REG_R_LOCAL_TEMP 0x00
131#define LM90_REG_R_LOCAL_HIGH 0x05
132#define LM90_REG_W_LOCAL_HIGH 0x0B
133#define LM90_REG_R_LOCAL_LOW 0x06
134#define LM90_REG_W_LOCAL_LOW 0x0C
135#define LM90_REG_R_LOCAL_CRIT 0x20
136#define LM90_REG_W_LOCAL_CRIT 0x20
137#define LM90_REG_R_REMOTE_TEMPH 0x01
138#define LM90_REG_R_REMOTE_TEMPL 0x10
139#define LM90_REG_R_REMOTE_OFFSH 0x11
140#define LM90_REG_W_REMOTE_OFFSH 0x11
141#define LM90_REG_R_REMOTE_OFFSL 0x12
142#define LM90_REG_W_REMOTE_OFFSL 0x12
143#define LM90_REG_R_REMOTE_HIGHH 0x07
144#define LM90_REG_W_REMOTE_HIGHH 0x0D
145#define LM90_REG_R_REMOTE_HIGHL 0x13
146#define LM90_REG_W_REMOTE_HIGHL 0x13
147#define LM90_REG_R_REMOTE_LOWH 0x08
148#define LM90_REG_W_REMOTE_LOWH 0x0E
149#define LM90_REG_R_REMOTE_LOWL 0x14
150#define LM90_REG_W_REMOTE_LOWL 0x14
151#define LM90_REG_R_REMOTE_CRIT 0x19
152#define LM90_REG_W_REMOTE_CRIT 0x19
153#define LM90_REG_R_TCRIT_HYST 0x21
154#define LM90_REG_W_TCRIT_HYST 0x21
155
156
157
158#define MAX6657_REG_R_LOCAL_TEMPL 0x11
159#define MAX6696_REG_R_STATUS2 0x12
160#define MAX6659_REG_R_REMOTE_EMERG 0x16
161#define MAX6659_REG_W_REMOTE_EMERG 0x16
162#define MAX6659_REG_R_LOCAL_EMERG 0x17
163#define MAX6659_REG_W_LOCAL_EMERG 0x17
164
165
166
167#define SA56004_REG_R_LOCAL_TEMPL 0x22
168
169#define LM90_MAX_CONVRATE_MS 16000
170
171
172#define TMP451_REG_R_LOCAL_TEMPL 0x15
173
174
175
176
177#define LM90_FLAG_ADT7461_EXT (1 << 0)
178
179#define LM90_HAVE_OFFSET (1 << 1)
180#define LM90_HAVE_REM_LIMIT_EXT (1 << 3)
181#define LM90_HAVE_EMERGENCY (1 << 4)
182#define LM90_HAVE_EMERGENCY_ALARM (1 << 5)
183#define LM90_HAVE_TEMP3 (1 << 6)
184#define LM90_HAVE_BROKEN_ALERT (1 << 7)
185#define LM90_PAUSE_FOR_CONFIG (1 << 8)
186
187
188#define LM90_STATUS_LTHRM (1 << 0)
189#define LM90_STATUS_RTHRM (1 << 1)
190#define LM90_STATUS_ROPEN (1 << 2)
191#define LM90_STATUS_RLOW (1 << 3)
192#define LM90_STATUS_RHIGH (1 << 4)
193#define LM90_STATUS_LLOW (1 << 5)
194#define LM90_STATUS_LHIGH (1 << 6)
195
196#define MAX6696_STATUS2_R2THRM (1 << 1)
197#define MAX6696_STATUS2_R2OPEN (1 << 2)
198#define MAX6696_STATUS2_R2LOW (1 << 3)
199#define MAX6696_STATUS2_R2HIGH (1 << 4)
200#define MAX6696_STATUS2_ROT2 (1 << 5)
201#define MAX6696_STATUS2_R2OT2 (1 << 6)
202#define MAX6696_STATUS2_LOT2 (1 << 7)
203
204
205
206
207
208static const struct i2c_device_id lm90_id[] = {
209 { "adm1032", adm1032 },
210 { "adt7461", adt7461 },
211 { "adt7461a", adt7461 },
212 { "g781", g781 },
213 { "lm90", lm90 },
214 { "lm86", lm86 },
215 { "lm89", lm86 },
216 { "lm99", lm99 },
217 { "max6646", max6646 },
218 { "max6647", max6646 },
219 { "max6649", max6646 },
220 { "max6654", max6654 },
221 { "max6657", max6657 },
222 { "max6658", max6657 },
223 { "max6659", max6659 },
224 { "max6680", max6680 },
225 { "max6681", max6680 },
226 { "max6695", max6696 },
227 { "max6696", max6696 },
228 { "nct1008", adt7461 },
229 { "w83l771", w83l771 },
230 { "sa56004", sa56004 },
231 { "tmp451", tmp451 },
232 { }
233};
234MODULE_DEVICE_TABLE(i2c, lm90_id);
235
236static const struct of_device_id __maybe_unused lm90_of_match[] = {
237 {
238 .compatible = "adi,adm1032",
239 .data = (void *)adm1032
240 },
241 {
242 .compatible = "adi,adt7461",
243 .data = (void *)adt7461
244 },
245 {
246 .compatible = "adi,adt7461a",
247 .data = (void *)adt7461
248 },
249 {
250 .compatible = "gmt,g781",
251 .data = (void *)g781
252 },
253 {
254 .compatible = "national,lm90",
255 .data = (void *)lm90
256 },
257 {
258 .compatible = "national,lm86",
259 .data = (void *)lm86
260 },
261 {
262 .compatible = "national,lm89",
263 .data = (void *)lm86
264 },
265 {
266 .compatible = "national,lm99",
267 .data = (void *)lm99
268 },
269 {
270 .compatible = "dallas,max6646",
271 .data = (void *)max6646
272 },
273 {
274 .compatible = "dallas,max6647",
275 .data = (void *)max6646
276 },
277 {
278 .compatible = "dallas,max6649",
279 .data = (void *)max6646
280 },
281 {
282 .compatible = "dallas,max6654",
283 .data = (void *)max6654
284 },
285 {
286 .compatible = "dallas,max6657",
287 .data = (void *)max6657
288 },
289 {
290 .compatible = "dallas,max6658",
291 .data = (void *)max6657
292 },
293 {
294 .compatible = "dallas,max6659",
295 .data = (void *)max6659
296 },
297 {
298 .compatible = "dallas,max6680",
299 .data = (void *)max6680
300 },
301 {
302 .compatible = "dallas,max6681",
303 .data = (void *)max6680
304 },
305 {
306 .compatible = "dallas,max6695",
307 .data = (void *)max6696
308 },
309 {
310 .compatible = "dallas,max6696",
311 .data = (void *)max6696
312 },
313 {
314 .compatible = "onnn,nct1008",
315 .data = (void *)adt7461
316 },
317 {
318 .compatible = "winbond,w83l771",
319 .data = (void *)w83l771
320 },
321 {
322 .compatible = "nxp,sa56004",
323 .data = (void *)sa56004
324 },
325 {
326 .compatible = "ti,tmp451",
327 .data = (void *)tmp451
328 },
329 { },
330};
331MODULE_DEVICE_TABLE(of, lm90_of_match);
332
333
334
335
336struct lm90_params {
337 u32 flags;
338 u16 alert_alarms;
339
340 u8 max_convrate;
341 u8 reg_local_ext;
342};
343
344static const struct lm90_params lm90_params[] = {
345 [adm1032] = {
346 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
347 | LM90_HAVE_BROKEN_ALERT,
348 .alert_alarms = 0x7c,
349 .max_convrate = 10,
350 },
351 [adt7461] = {
352 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
353 | LM90_HAVE_BROKEN_ALERT,
354 .alert_alarms = 0x7c,
355 .max_convrate = 10,
356 },
357 [g781] = {
358 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
359 | LM90_HAVE_BROKEN_ALERT,
360 .alert_alarms = 0x7c,
361 .max_convrate = 8,
362 },
363 [lm86] = {
364 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
365 .alert_alarms = 0x7b,
366 .max_convrate = 9,
367 },
368 [lm90] = {
369 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
370 .alert_alarms = 0x7b,
371 .max_convrate = 9,
372 },
373 [lm99] = {
374 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
375 .alert_alarms = 0x7b,
376 .max_convrate = 9,
377 },
378 [max6646] = {
379 .alert_alarms = 0x7c,
380 .max_convrate = 6,
381 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
382 },
383 [max6654] = {
384 .alert_alarms = 0x7c,
385 .max_convrate = 7,
386 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
387 },
388 [max6657] = {
389 .flags = LM90_PAUSE_FOR_CONFIG,
390 .alert_alarms = 0x7c,
391 .max_convrate = 8,
392 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
393 },
394 [max6659] = {
395 .flags = LM90_HAVE_EMERGENCY,
396 .alert_alarms = 0x7c,
397 .max_convrate = 8,
398 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
399 },
400 [max6680] = {
401 .flags = LM90_HAVE_OFFSET,
402 .alert_alarms = 0x7c,
403 .max_convrate = 7,
404 },
405 [max6696] = {
406 .flags = LM90_HAVE_EMERGENCY
407 | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,
408 .alert_alarms = 0x1c7c,
409 .max_convrate = 6,
410 .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
411 },
412 [w83l771] = {
413 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
414 .alert_alarms = 0x7c,
415 .max_convrate = 8,
416 },
417 [sa56004] = {
418 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
419 .alert_alarms = 0x7b,
420 .max_convrate = 9,
421 .reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,
422 },
423 [tmp451] = {
424 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
425 | LM90_HAVE_BROKEN_ALERT,
426 .alert_alarms = 0x7c,
427 .max_convrate = 9,
428 .reg_local_ext = TMP451_REG_R_LOCAL_TEMPL,
429 },
430};
431
432
433
434
435enum lm90_temp8_reg_index {
436 LOCAL_LOW = 0,
437 LOCAL_HIGH,
438 LOCAL_CRIT,
439 REMOTE_CRIT,
440 LOCAL_EMERG,
441 REMOTE_EMERG,
442 REMOTE2_CRIT,
443 REMOTE2_EMERG,
444 TEMP8_REG_NUM
445};
446
447
448
449
450enum lm90_temp11_reg_index {
451 REMOTE_TEMP = 0,
452 REMOTE_LOW,
453 REMOTE_HIGH,
454 REMOTE_OFFSET,
455 LOCAL_TEMP,
456 REMOTE2_TEMP,
457 REMOTE2_LOW,
458 REMOTE2_HIGH,
459 TEMP11_REG_NUM
460};
461
462
463
464
465
466struct lm90_data {
467 struct i2c_client *client;
468 struct device *hwmon_dev;
469 u32 channel_config[4];
470 struct hwmon_channel_info temp_info;
471 const struct hwmon_channel_info *info[3];
472 struct hwmon_chip_info chip;
473 struct mutex update_lock;
474 bool valid;
475 unsigned long last_updated;
476 int kind;
477 u32 flags;
478
479 unsigned int update_interval;
480
481 u8 config;
482 u8 config_orig;
483 u8 convrate_orig;
484 u16 alert_alarms;
485
486 u8 max_convrate;
487 u8 reg_local_ext;
488
489
490 s8 temp8[TEMP8_REG_NUM];
491 s16 temp11[TEMP11_REG_NUM];
492 u8 temp_hyst;
493 u16 alarms;
494};
495
496
497
498
499
500
501
502
503
504static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
505{
506 return i2c_smbus_xfer(client->adapter, client->addr,
507 client->flags & ~I2C_CLIENT_PEC,
508 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
509}
510
511
512
513
514
515
516
517static int lm90_read_reg(struct i2c_client *client, u8 reg)
518{
519 int err;
520
521 if (client->flags & I2C_CLIENT_PEC) {
522 err = adm1032_write_byte(client, reg);
523 if (err >= 0)
524 err = i2c_smbus_read_byte(client);
525 } else
526 err = i2c_smbus_read_byte_data(client, reg);
527
528 return err;
529}
530
531static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl)
532{
533 int oldh, newh, l;
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548 oldh = lm90_read_reg(client, regh);
549 if (oldh < 0)
550 return oldh;
551 l = lm90_read_reg(client, regl);
552 if (l < 0)
553 return l;
554 newh = lm90_read_reg(client, regh);
555 if (newh < 0)
556 return newh;
557 if (oldh != newh) {
558 l = lm90_read_reg(client, regl);
559 if (l < 0)
560 return l;
561 }
562 return (newh << 8) | l;
563}
564
565static int lm90_update_confreg(struct lm90_data *data, u8 config)
566{
567 if (data->config != config) {
568 int err;
569
570 err = i2c_smbus_write_byte_data(data->client,
571 LM90_REG_W_CONFIG1,
572 config);
573 if (err)
574 return err;
575 data->config = config;
576 }
577 return 0;
578}
579
580
581
582
583
584
585
586
587
588static int lm90_select_remote_channel(struct lm90_data *data, int channel)
589{
590 int err = 0;
591
592 if (data->kind == max6696) {
593 u8 config = data->config & ~0x08;
594
595 if (channel)
596 config |= 0x08;
597 err = lm90_update_confreg(data, config);
598 }
599 return err;
600}
601
602static int lm90_write_convrate(struct lm90_data *data, int val)
603{
604 u8 config = data->config;
605 int err;
606
607
608 if (data->flags & LM90_PAUSE_FOR_CONFIG) {
609 err = lm90_update_confreg(data, config | 0x40);
610 if (err < 0)
611 return err;
612 }
613
614
615 err = i2c_smbus_write_byte_data(data->client, LM90_REG_W_CONVRATE, val);
616
617
618 lm90_update_confreg(data, config);
619
620 return err;
621}
622
623
624
625
626
627
628static int lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
629 unsigned int interval)
630{
631 unsigned int update_interval;
632 int i, err;
633
634
635 interval <<= 6;
636
637
638 for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;
639 i < data->max_convrate; i++, update_interval >>= 1)
640 if (interval >= update_interval * 3 / 4)
641 break;
642
643 err = lm90_write_convrate(data, i);
644 data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);
645 return err;
646}
647
648static int lm90_update_limits(struct device *dev)
649{
650 struct lm90_data *data = dev_get_drvdata(dev);
651 struct i2c_client *client = data->client;
652 int val;
653
654 val = lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT);
655 if (val < 0)
656 return val;
657 data->temp8[LOCAL_CRIT] = val;
658
659 val = lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT);
660 if (val < 0)
661 return val;
662 data->temp8[REMOTE_CRIT] = val;
663
664 val = lm90_read_reg(client, LM90_REG_R_TCRIT_HYST);
665 if (val < 0)
666 return val;
667 data->temp_hyst = val;
668
669 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH);
670 if (val < 0)
671 return val;
672 data->temp11[REMOTE_LOW] = val << 8;
673
674 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) {
675 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL);
676 if (val < 0)
677 return val;
678 data->temp11[REMOTE_LOW] |= val;
679 }
680
681 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH);
682 if (val < 0)
683 return val;
684 data->temp11[REMOTE_HIGH] = val << 8;
685
686 if (data->flags & LM90_HAVE_REM_LIMIT_EXT) {
687 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL);
688 if (val < 0)
689 return val;
690 data->temp11[REMOTE_HIGH] |= val;
691 }
692
693 if (data->flags & LM90_HAVE_OFFSET) {
694 val = lm90_read16(client, LM90_REG_R_REMOTE_OFFSH,
695 LM90_REG_R_REMOTE_OFFSL);
696 if (val < 0)
697 return val;
698 data->temp11[REMOTE_OFFSET] = val;
699 }
700
701 if (data->flags & LM90_HAVE_EMERGENCY) {
702 val = lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG);
703 if (val < 0)
704 return val;
705 data->temp8[LOCAL_EMERG] = val;
706
707 val = lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG);
708 if (val < 0)
709 return val;
710 data->temp8[REMOTE_EMERG] = val;
711 }
712
713 if (data->kind == max6696) {
714 val = lm90_select_remote_channel(data, 1);
715 if (val < 0)
716 return val;
717
718 val = lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT);
719 if (val < 0)
720 return val;
721 data->temp8[REMOTE2_CRIT] = val;
722
723 val = lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG);
724 if (val < 0)
725 return val;
726 data->temp8[REMOTE2_EMERG] = val;
727
728 val = lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH);
729 if (val < 0)
730 return val;
731 data->temp11[REMOTE2_LOW] = val << 8;
732
733 val = lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH);
734 if (val < 0)
735 return val;
736 data->temp11[REMOTE2_HIGH] = val << 8;
737
738 lm90_select_remote_channel(data, 0);
739 }
740
741 return 0;
742}
743
744static int lm90_update_device(struct device *dev)
745{
746 struct lm90_data *data = dev_get_drvdata(dev);
747 struct i2c_client *client = data->client;
748 unsigned long next_update;
749 int val;
750
751 if (!data->valid) {
752 val = lm90_update_limits(dev);
753 if (val < 0)
754 return val;
755 }
756
757 next_update = data->last_updated +
758 msecs_to_jiffies(data->update_interval);
759 if (time_after(jiffies, next_update) || !data->valid) {
760 dev_dbg(&client->dev, "Updating lm90 data.\n");
761
762 data->valid = false;
763
764 val = lm90_read_reg(client, LM90_REG_R_LOCAL_LOW);
765 if (val < 0)
766 return val;
767 data->temp8[LOCAL_LOW] = val;
768
769 val = lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH);
770 if (val < 0)
771 return val;
772 data->temp8[LOCAL_HIGH] = val;
773
774 if (data->reg_local_ext) {
775 val = lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
776 data->reg_local_ext);
777 if (val < 0)
778 return val;
779 data->temp11[LOCAL_TEMP] = val;
780 } else {
781 val = lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP);
782 if (val < 0)
783 return val;
784 data->temp11[LOCAL_TEMP] = val << 8;
785 }
786 val = lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
787 LM90_REG_R_REMOTE_TEMPL);
788 if (val < 0)
789 return val;
790 data->temp11[REMOTE_TEMP] = val;
791
792 val = lm90_read_reg(client, LM90_REG_R_STATUS);
793 if (val < 0)
794 return val;
795 data->alarms = val;
796
797 if (data->kind == max6696) {
798 val = lm90_select_remote_channel(data, 1);
799 if (val < 0)
800 return val;
801
802 val = lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
803 LM90_REG_R_REMOTE_TEMPL);
804 if (val < 0) {
805 lm90_select_remote_channel(data, 0);
806 return val;
807 }
808 data->temp11[REMOTE2_TEMP] = val;
809
810 lm90_select_remote_channel(data, 0);
811
812 val = lm90_read_reg(client, MAX6696_REG_R_STATUS2);
813 if (val < 0)
814 return val;
815 data->alarms |= val << 8;
816 }
817
818
819
820
821
822 if (!(data->config_orig & 0x80) &&
823 !(data->alarms & data->alert_alarms)) {
824 if (data->config & 0x80) {
825 dev_dbg(&client->dev, "Re-enabling ALERT#\n");
826 lm90_update_confreg(data, data->config & ~0x80);
827 }
828 }
829
830 data->last_updated = jiffies;
831 data->valid = true;
832 }
833
834 return 0;
835}
836
837
838
839
840
841
842
843
844
845
846static inline int temp_from_s8(s8 val)
847{
848 return val * 1000;
849}
850
851static inline int temp_from_u8(u8 val)
852{
853 return val * 1000;
854}
855
856static inline int temp_from_s16(s16 val)
857{
858 return val / 32 * 125;
859}
860
861static inline int temp_from_u16(u16 val)
862{
863 return val / 32 * 125;
864}
865
866static s8 temp_to_s8(long val)
867{
868 if (val <= -128000)
869 return -128;
870 if (val >= 127000)
871 return 127;
872 if (val < 0)
873 return (val - 500) / 1000;
874 return (val + 500) / 1000;
875}
876
877static u8 temp_to_u8(long val)
878{
879 if (val <= 0)
880 return 0;
881 if (val >= 255000)
882 return 255;
883 return (val + 500) / 1000;
884}
885
886static s16 temp_to_s16(long val)
887{
888 if (val <= -128000)
889 return 0x8000;
890 if (val >= 127875)
891 return 0x7FE0;
892 if (val < 0)
893 return (val - 62) / 125 * 32;
894 return (val + 62) / 125 * 32;
895}
896
897static u8 hyst_to_reg(long val)
898{
899 if (val <= 0)
900 return 0;
901 if (val >= 30500)
902 return 31;
903 return (val + 500) / 1000;
904}
905
906
907
908
909
910
911
912
913
914static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
915{
916 if (data->flags & LM90_FLAG_ADT7461_EXT)
917 return (val - 64) * 1000;
918 return temp_from_s8(val);
919}
920
921static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
922{
923 if (data->flags & LM90_FLAG_ADT7461_EXT)
924 return (val - 0x4000) / 64 * 250;
925 return temp_from_s16(val);
926}
927
928static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
929{
930 if (data->flags & LM90_FLAG_ADT7461_EXT) {
931 if (val <= -64000)
932 return 0;
933 if (val >= 191000)
934 return 0xFF;
935 return (val + 500 + 64000) / 1000;
936 }
937 if (val <= 0)
938 return 0;
939 if (val >= 127000)
940 return 127;
941 return (val + 500) / 1000;
942}
943
944static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
945{
946 if (data->flags & LM90_FLAG_ADT7461_EXT) {
947 if (val <= -64000)
948 return 0;
949 if (val >= 191750)
950 return 0xFFC0;
951 return (val + 64000 + 125) / 250 * 64;
952 }
953 if (val <= 0)
954 return 0;
955 if (val >= 127750)
956 return 0x7FC0;
957 return (val + 125) / 250 * 64;
958}
959
960
961static ssize_t pec_show(struct device *dev, struct device_attribute *dummy,
962 char *buf)
963{
964 struct i2c_client *client = to_i2c_client(dev);
965
966 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
967}
968
969static ssize_t pec_store(struct device *dev, struct device_attribute *dummy,
970 const char *buf, size_t count)
971{
972 struct i2c_client *client = to_i2c_client(dev);
973 long val;
974 int err;
975
976 err = kstrtol(buf, 10, &val);
977 if (err < 0)
978 return err;
979
980 switch (val) {
981 case 0:
982 client->flags &= ~I2C_CLIENT_PEC;
983 break;
984 case 1:
985 client->flags |= I2C_CLIENT_PEC;
986 break;
987 default:
988 return -EINVAL;
989 }
990
991 return count;
992}
993
994static DEVICE_ATTR_RW(pec);
995
996static int lm90_get_temp11(struct lm90_data *data, int index)
997{
998 s16 temp11 = data->temp11[index];
999 int temp;
1000
1001 if (data->kind == adt7461 || data->kind == tmp451)
1002 temp = temp_from_u16_adt7461(data, temp11);
1003 else if (data->kind == max6646)
1004 temp = temp_from_u16(temp11);
1005 else
1006 temp = temp_from_s16(temp11);
1007
1008
1009 if (data->kind == lm99 && index <= 2)
1010 temp += 16000;
1011
1012 return temp;
1013}
1014
1015static int lm90_set_temp11(struct lm90_data *data, int index, long val)
1016{
1017 static struct reg {
1018 u8 high;
1019 u8 low;
1020 } reg[] = {
1021 [REMOTE_LOW] = { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL },
1022 [REMOTE_HIGH] = { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL },
1023 [REMOTE_OFFSET] = { LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL },
1024 [REMOTE2_LOW] = { LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL },
1025 [REMOTE2_HIGH] = { LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL }
1026 };
1027 struct i2c_client *client = data->client;
1028 struct reg *regp = ®[index];
1029 int err;
1030
1031
1032 if (data->kind == lm99 && index <= 2) {
1033
1034 val = max(val, -128000l);
1035 val -= 16000;
1036 }
1037
1038 if (data->kind == adt7461 || data->kind == tmp451)
1039 data->temp11[index] = temp_to_u16_adt7461(data, val);
1040 else if (data->kind == max6646)
1041 data->temp11[index] = temp_to_u8(val) << 8;
1042 else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
1043 data->temp11[index] = temp_to_s16(val);
1044 else
1045 data->temp11[index] = temp_to_s8(val) << 8;
1046
1047 lm90_select_remote_channel(data, index >= 3);
1048 err = i2c_smbus_write_byte_data(client, regp->high,
1049 data->temp11[index] >> 8);
1050 if (err < 0)
1051 return err;
1052 if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
1053 err = i2c_smbus_write_byte_data(client, regp->low,
1054 data->temp11[index] & 0xff);
1055
1056 lm90_select_remote_channel(data, 0);
1057 return err;
1058}
1059
1060static int lm90_get_temp8(struct lm90_data *data, int index)
1061{
1062 s8 temp8 = data->temp8[index];
1063 int temp;
1064
1065 if (data->kind == adt7461 || data->kind == tmp451)
1066 temp = temp_from_u8_adt7461(data, temp8);
1067 else if (data->kind == max6646)
1068 temp = temp_from_u8(temp8);
1069 else
1070 temp = temp_from_s8(temp8);
1071
1072
1073 if (data->kind == lm99 && index == 3)
1074 temp += 16000;
1075
1076 return temp;
1077}
1078
1079static int lm90_set_temp8(struct lm90_data *data, int index, long val)
1080{
1081 static const u8 reg[TEMP8_REG_NUM] = {
1082 LM90_REG_W_LOCAL_LOW,
1083 LM90_REG_W_LOCAL_HIGH,
1084 LM90_REG_W_LOCAL_CRIT,
1085 LM90_REG_W_REMOTE_CRIT,
1086 MAX6659_REG_W_LOCAL_EMERG,
1087 MAX6659_REG_W_REMOTE_EMERG,
1088 LM90_REG_W_REMOTE_CRIT,
1089 MAX6659_REG_W_REMOTE_EMERG,
1090 };
1091 struct i2c_client *client = data->client;
1092 int err;
1093
1094
1095 if (data->kind == lm99 && index == 3) {
1096
1097 val = max(val, -128000l);
1098 val -= 16000;
1099 }
1100
1101 if (data->kind == adt7461 || data->kind == tmp451)
1102 data->temp8[index] = temp_to_u8_adt7461(data, val);
1103 else if (data->kind == max6646)
1104 data->temp8[index] = temp_to_u8(val);
1105 else
1106 data->temp8[index] = temp_to_s8(val);
1107
1108 lm90_select_remote_channel(data, index >= 6);
1109 err = i2c_smbus_write_byte_data(client, reg[index], data->temp8[index]);
1110 lm90_select_remote_channel(data, 0);
1111
1112 return err;
1113}
1114
1115static int lm90_get_temphyst(struct lm90_data *data, int index)
1116{
1117 int temp;
1118
1119 if (data->kind == adt7461 || data->kind == tmp451)
1120 temp = temp_from_u8_adt7461(data, data->temp8[index]);
1121 else if (data->kind == max6646)
1122 temp = temp_from_u8(data->temp8[index]);
1123 else
1124 temp = temp_from_s8(data->temp8[index]);
1125
1126
1127 if (data->kind == lm99 && index == 3)
1128 temp += 16000;
1129
1130 return temp - temp_from_s8(data->temp_hyst);
1131}
1132
1133static int lm90_set_temphyst(struct lm90_data *data, long val)
1134{
1135 struct i2c_client *client = data->client;
1136 int temp;
1137 int err;
1138
1139 if (data->kind == adt7461 || data->kind == tmp451)
1140 temp = temp_from_u8_adt7461(data, data->temp8[LOCAL_CRIT]);
1141 else if (data->kind == max6646)
1142 temp = temp_from_u8(data->temp8[LOCAL_CRIT]);
1143 else
1144 temp = temp_from_s8(data->temp8[LOCAL_CRIT]);
1145
1146
1147 val = max(val, -128000l);
1148
1149 data->temp_hyst = hyst_to_reg(temp - val);
1150 err = i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
1151 data->temp_hyst);
1152 return err;
1153}
1154
1155static const u8 lm90_temp_index[3] = {
1156 LOCAL_TEMP, REMOTE_TEMP, REMOTE2_TEMP
1157};
1158
1159static const u8 lm90_temp_min_index[3] = {
1160 LOCAL_LOW, REMOTE_LOW, REMOTE2_LOW
1161};
1162
1163static const u8 lm90_temp_max_index[3] = {
1164 LOCAL_HIGH, REMOTE_HIGH, REMOTE2_HIGH
1165};
1166
1167static const u8 lm90_temp_crit_index[3] = {
1168 LOCAL_CRIT, REMOTE_CRIT, REMOTE2_CRIT
1169};
1170
1171static const u8 lm90_temp_emerg_index[3] = {
1172 LOCAL_EMERG, REMOTE_EMERG, REMOTE2_EMERG
1173};
1174
1175static const u8 lm90_min_alarm_bits[3] = { 5, 3, 11 };
1176static const u8 lm90_max_alarm_bits[3] = { 6, 4, 12 };
1177static const u8 lm90_crit_alarm_bits[3] = { 0, 1, 9 };
1178static const u8 lm90_emergency_alarm_bits[3] = { 15, 13, 14 };
1179static const u8 lm90_fault_bits[3] = { 0, 2, 10 };
1180
1181static int lm90_temp_read(struct device *dev, u32 attr, int channel, long *val)
1182{
1183 struct lm90_data *data = dev_get_drvdata(dev);
1184 int err;
1185
1186 mutex_lock(&data->update_lock);
1187 err = lm90_update_device(dev);
1188 mutex_unlock(&data->update_lock);
1189 if (err)
1190 return err;
1191
1192 switch (attr) {
1193 case hwmon_temp_input:
1194 *val = lm90_get_temp11(data, lm90_temp_index[channel]);
1195 break;
1196 case hwmon_temp_min_alarm:
1197 *val = (data->alarms >> lm90_min_alarm_bits[channel]) & 1;
1198 break;
1199 case hwmon_temp_max_alarm:
1200 *val = (data->alarms >> lm90_max_alarm_bits[channel]) & 1;
1201 break;
1202 case hwmon_temp_crit_alarm:
1203 *val = (data->alarms >> lm90_crit_alarm_bits[channel]) & 1;
1204 break;
1205 case hwmon_temp_emergency_alarm:
1206 *val = (data->alarms >> lm90_emergency_alarm_bits[channel]) & 1;
1207 break;
1208 case hwmon_temp_fault:
1209 *val = (data->alarms >> lm90_fault_bits[channel]) & 1;
1210 break;
1211 case hwmon_temp_min:
1212 if (channel == 0)
1213 *val = lm90_get_temp8(data,
1214 lm90_temp_min_index[channel]);
1215 else
1216 *val = lm90_get_temp11(data,
1217 lm90_temp_min_index[channel]);
1218 break;
1219 case hwmon_temp_max:
1220 if (channel == 0)
1221 *val = lm90_get_temp8(data,
1222 lm90_temp_max_index[channel]);
1223 else
1224 *val = lm90_get_temp11(data,
1225 lm90_temp_max_index[channel]);
1226 break;
1227 case hwmon_temp_crit:
1228 *val = lm90_get_temp8(data, lm90_temp_crit_index[channel]);
1229 break;
1230 case hwmon_temp_crit_hyst:
1231 *val = lm90_get_temphyst(data, lm90_temp_crit_index[channel]);
1232 break;
1233 case hwmon_temp_emergency:
1234 *val = lm90_get_temp8(data, lm90_temp_emerg_index[channel]);
1235 break;
1236 case hwmon_temp_emergency_hyst:
1237 *val = lm90_get_temphyst(data, lm90_temp_emerg_index[channel]);
1238 break;
1239 case hwmon_temp_offset:
1240 *val = lm90_get_temp11(data, REMOTE_OFFSET);
1241 break;
1242 default:
1243 return -EOPNOTSUPP;
1244 }
1245 return 0;
1246}
1247
1248static int lm90_temp_write(struct device *dev, u32 attr, int channel, long val)
1249{
1250 struct lm90_data *data = dev_get_drvdata(dev);
1251 int err;
1252
1253 mutex_lock(&data->update_lock);
1254
1255 err = lm90_update_device(dev);
1256 if (err)
1257 goto error;
1258
1259 switch (attr) {
1260 case hwmon_temp_min:
1261 if (channel == 0)
1262 err = lm90_set_temp8(data,
1263 lm90_temp_min_index[channel],
1264 val);
1265 else
1266 err = lm90_set_temp11(data,
1267 lm90_temp_min_index[channel],
1268 val);
1269 break;
1270 case hwmon_temp_max:
1271 if (channel == 0)
1272 err = lm90_set_temp8(data,
1273 lm90_temp_max_index[channel],
1274 val);
1275 else
1276 err = lm90_set_temp11(data,
1277 lm90_temp_max_index[channel],
1278 val);
1279 break;
1280 case hwmon_temp_crit:
1281 err = lm90_set_temp8(data, lm90_temp_crit_index[channel], val);
1282 break;
1283 case hwmon_temp_crit_hyst:
1284 err = lm90_set_temphyst(data, val);
1285 break;
1286 case hwmon_temp_emergency:
1287 err = lm90_set_temp8(data, lm90_temp_emerg_index[channel], val);
1288 break;
1289 case hwmon_temp_offset:
1290 err = lm90_set_temp11(data, REMOTE_OFFSET, val);
1291 break;
1292 default:
1293 err = -EOPNOTSUPP;
1294 break;
1295 }
1296error:
1297 mutex_unlock(&data->update_lock);
1298
1299 return err;
1300}
1301
1302static umode_t lm90_temp_is_visible(const void *data, u32 attr, int channel)
1303{
1304 switch (attr) {
1305 case hwmon_temp_input:
1306 case hwmon_temp_min_alarm:
1307 case hwmon_temp_max_alarm:
1308 case hwmon_temp_crit_alarm:
1309 case hwmon_temp_emergency_alarm:
1310 case hwmon_temp_emergency_hyst:
1311 case hwmon_temp_fault:
1312 return 0444;
1313 case hwmon_temp_min:
1314 case hwmon_temp_max:
1315 case hwmon_temp_crit:
1316 case hwmon_temp_emergency:
1317 case hwmon_temp_offset:
1318 return 0644;
1319 case hwmon_temp_crit_hyst:
1320 if (channel == 0)
1321 return 0644;
1322 return 0444;
1323 default:
1324 return 0;
1325 }
1326}
1327
1328static int lm90_chip_read(struct device *dev, u32 attr, int channel, long *val)
1329{
1330 struct lm90_data *data = dev_get_drvdata(dev);
1331 int err;
1332
1333 mutex_lock(&data->update_lock);
1334 err = lm90_update_device(dev);
1335 mutex_unlock(&data->update_lock);
1336 if (err)
1337 return err;
1338
1339 switch (attr) {
1340 case hwmon_chip_update_interval:
1341 *val = data->update_interval;
1342 break;
1343 case hwmon_chip_alarms:
1344 *val = data->alarms;
1345 break;
1346 default:
1347 return -EOPNOTSUPP;
1348 }
1349
1350 return 0;
1351}
1352
1353static int lm90_chip_write(struct device *dev, u32 attr, int channel, long val)
1354{
1355 struct lm90_data *data = dev_get_drvdata(dev);
1356 struct i2c_client *client = data->client;
1357 int err;
1358
1359 mutex_lock(&data->update_lock);
1360
1361 err = lm90_update_device(dev);
1362 if (err)
1363 goto error;
1364
1365 switch (attr) {
1366 case hwmon_chip_update_interval:
1367 err = lm90_set_convrate(client, data,
1368 clamp_val(val, 0, 100000));
1369 break;
1370 default:
1371 err = -EOPNOTSUPP;
1372 break;
1373 }
1374error:
1375 mutex_unlock(&data->update_lock);
1376
1377 return err;
1378}
1379
1380static umode_t lm90_chip_is_visible(const void *data, u32 attr, int channel)
1381{
1382 switch (attr) {
1383 case hwmon_chip_update_interval:
1384 return 0644;
1385 case hwmon_chip_alarms:
1386 return 0444;
1387 default:
1388 return 0;
1389 }
1390}
1391
1392static int lm90_read(struct device *dev, enum hwmon_sensor_types type,
1393 u32 attr, int channel, long *val)
1394{
1395 switch (type) {
1396 case hwmon_chip:
1397 return lm90_chip_read(dev, attr, channel, val);
1398 case hwmon_temp:
1399 return lm90_temp_read(dev, attr, channel, val);
1400 default:
1401 return -EOPNOTSUPP;
1402 }
1403}
1404
1405static int lm90_write(struct device *dev, enum hwmon_sensor_types type,
1406 u32 attr, int channel, long val)
1407{
1408 switch (type) {
1409 case hwmon_chip:
1410 return lm90_chip_write(dev, attr, channel, val);
1411 case hwmon_temp:
1412 return lm90_temp_write(dev, attr, channel, val);
1413 default:
1414 return -EOPNOTSUPP;
1415 }
1416}
1417
1418static umode_t lm90_is_visible(const void *data, enum hwmon_sensor_types type,
1419 u32 attr, int channel)
1420{
1421 switch (type) {
1422 case hwmon_chip:
1423 return lm90_chip_is_visible(data, attr, channel);
1424 case hwmon_temp:
1425 return lm90_temp_is_visible(data, attr, channel);
1426 default:
1427 return 0;
1428 }
1429}
1430
1431
1432static int lm90_detect(struct i2c_client *client,
1433 struct i2c_board_info *info)
1434{
1435 struct i2c_adapter *adapter = client->adapter;
1436 int address = client->addr;
1437 const char *name = NULL;
1438 int man_id, chip_id, config1, config2, convrate;
1439
1440 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1441 return -ENODEV;
1442
1443
1444 man_id = i2c_smbus_read_byte_data(client, LM90_REG_R_MAN_ID);
1445 chip_id = i2c_smbus_read_byte_data(client, LM90_REG_R_CHIP_ID);
1446 config1 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1);
1447 convrate = i2c_smbus_read_byte_data(client, LM90_REG_R_CONVRATE);
1448 if (man_id < 0 || chip_id < 0 || config1 < 0 || convrate < 0)
1449 return -ENODEV;
1450
1451 if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {
1452 config2 = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG2);
1453 if (config2 < 0)
1454 return -ENODEV;
1455 } else
1456 config2 = 0;
1457
1458 if ((address == 0x4C || address == 0x4D)
1459 && man_id == 0x01) {
1460 if ((config1 & 0x2A) == 0x00
1461 && (config2 & 0xF8) == 0x00
1462 && convrate <= 0x09) {
1463 if (address == 0x4C
1464 && (chip_id & 0xF0) == 0x20) {
1465 name = "lm90";
1466 } else
1467 if ((chip_id & 0xF0) == 0x30) {
1468 name = "lm99";
1469 dev_info(&adapter->dev,
1470 "Assuming LM99 chip at 0x%02x\n",
1471 address);
1472 dev_info(&adapter->dev,
1473 "If it is an LM89, instantiate it "
1474 "with the new_device sysfs "
1475 "interface\n");
1476 } else
1477 if (address == 0x4C
1478 && (chip_id & 0xF0) == 0x10) {
1479 name = "lm86";
1480 }
1481 }
1482 } else
1483 if ((address == 0x4C || address == 0x4D)
1484 && man_id == 0x41) {
1485 if ((chip_id & 0xF0) == 0x40
1486 && (config1 & 0x3F) == 0x00
1487 && convrate <= 0x0A) {
1488 name = "adm1032";
1489
1490
1491
1492
1493 if (i2c_check_functionality(adapter,
1494 I2C_FUNC_SMBUS_BYTE))
1495 info->flags |= I2C_CLIENT_PEC;
1496 } else
1497 if (chip_id == 0x51
1498 && (config1 & 0x1B) == 0x00
1499 && convrate <= 0x0A) {
1500 name = "adt7461";
1501 } else
1502 if (chip_id == 0x57
1503 && (config1 & 0x1B) == 0x00
1504 && convrate <= 0x0A) {
1505 name = "adt7461a";
1506 }
1507 } else
1508 if (man_id == 0x4D) {
1509 int emerg, emerg2, status2;
1510
1511
1512
1513
1514
1515
1516
1517 emerg = i2c_smbus_read_byte_data(client,
1518 MAX6659_REG_R_REMOTE_EMERG);
1519 man_id = i2c_smbus_read_byte_data(client,
1520 LM90_REG_R_MAN_ID);
1521 emerg2 = i2c_smbus_read_byte_data(client,
1522 MAX6659_REG_R_REMOTE_EMERG);
1523 status2 = i2c_smbus_read_byte_data(client,
1524 MAX6696_REG_R_STATUS2);
1525 if (emerg < 0 || man_id < 0 || emerg2 < 0 || status2 < 0)
1526 return -ENODEV;
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541 if (chip_id == man_id
1542 && (address == 0x4C || address == 0x4D || address == 0x4E)
1543 && (config1 & 0x1F) == (man_id & 0x0F)
1544 && convrate <= 0x09) {
1545 if (address == 0x4C)
1546 name = "max6657";
1547 else
1548 name = "max6659";
1549 } else
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561 if (chip_id == 0x01
1562 && (config1 & 0x10) == 0x00
1563 && (status2 & 0x01) == 0x00
1564 && emerg == emerg2
1565 && convrate <= 0x07) {
1566 name = "max6696";
1567 } else
1568
1569
1570
1571
1572
1573
1574 if (chip_id == 0x01
1575 && (config1 & 0x03) == 0x00
1576 && convrate <= 0x07) {
1577 name = "max6680";
1578 } else
1579
1580
1581
1582
1583
1584 if (chip_id == 0x59
1585 && (config1 & 0x3f) == 0x00
1586 && convrate <= 0x07) {
1587 name = "max6646";
1588 } else
1589
1590
1591
1592
1593
1594 if (chip_id == 0x08
1595 && (config1 & 0x07) == 0x00
1596 && convrate <= 0x07) {
1597 name = "max6654";
1598 }
1599 } else
1600 if (address == 0x4C
1601 && man_id == 0x5C) {
1602 if ((config1 & 0x2A) == 0x00
1603 && (config2 & 0xF8) == 0x00) {
1604 if (chip_id == 0x01
1605 && convrate <= 0x09) {
1606 name = "w83l771";
1607 } else
1608 if ((chip_id & 0xFE) == 0x10
1609 && convrate <= 0x08) {
1610 name = "w83l771";
1611 }
1612 }
1613 } else
1614 if (address >= 0x48 && address <= 0x4F
1615 && man_id == 0xA1) {
1616 if (chip_id == 0x00
1617 && (config1 & 0x2A) == 0x00
1618 && (config2 & 0xFE) == 0x00
1619 && convrate <= 0x09) {
1620 name = "sa56004";
1621 }
1622 } else
1623 if ((address == 0x4C || address == 0x4D)
1624 && man_id == 0x47) {
1625 if (chip_id == 0x01
1626 && (config1 & 0x3F) == 0x00
1627 && convrate <= 0x08)
1628 name = "g781";
1629 } else
1630 if (address == 0x4C
1631 && man_id == 0x55) {
1632 int local_ext;
1633
1634 local_ext = i2c_smbus_read_byte_data(client,
1635 TMP451_REG_R_LOCAL_TEMPL);
1636
1637 if (chip_id == 0x00
1638 && (config1 & 0x1B) == 0x00
1639 && convrate <= 0x09
1640 && (local_ext & 0x0F) == 0x00)
1641 name = "tmp451";
1642 }
1643
1644 if (!name) {
1645 dev_dbg(&adapter->dev,
1646 "Unsupported chip at 0x%02x (man_id=0x%02X, "
1647 "chip_id=0x%02X)\n", address, man_id, chip_id);
1648 return -ENODEV;
1649 }
1650
1651 strlcpy(info->type, name, I2C_NAME_SIZE);
1652
1653 return 0;
1654}
1655
1656static void lm90_restore_conf(void *_data)
1657{
1658 struct lm90_data *data = _data;
1659 struct i2c_client *client = data->client;
1660
1661
1662 lm90_write_convrate(data, data->convrate_orig);
1663 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
1664 data->config_orig);
1665}
1666
1667static int lm90_init_client(struct i2c_client *client, struct lm90_data *data)
1668{
1669 int config, convrate;
1670
1671 convrate = lm90_read_reg(client, LM90_REG_R_CONVRATE);
1672 if (convrate < 0)
1673 return convrate;
1674 data->convrate_orig = convrate;
1675
1676
1677
1678
1679 config = lm90_read_reg(client, LM90_REG_R_CONFIG1);
1680 if (config < 0)
1681 return config;
1682 data->config_orig = config;
1683 data->config = config;
1684
1685 lm90_set_convrate(client, data, 500);
1686
1687
1688 if (data->kind == adt7461 || data->kind == tmp451) {
1689 if (config & 0x04)
1690 data->flags |= LM90_FLAG_ADT7461_EXT;
1691 }
1692
1693
1694
1695
1696
1697
1698 if (data->kind == max6680)
1699 config |= 0x18;
1700
1701
1702
1703
1704
1705
1706
1707 if (data->kind == max6654)
1708 config |= 0x20;
1709
1710
1711
1712
1713 if (data->kind == max6696)
1714 config &= ~0x08;
1715
1716
1717
1718
1719
1720 if (client->irq)
1721 config &= ~0x80;
1722
1723 config &= 0xBF;
1724 lm90_update_confreg(data, config);
1725
1726 return devm_add_action_or_reset(&client->dev, lm90_restore_conf, data);
1727}
1728
1729static bool lm90_is_tripped(struct i2c_client *client, u16 *status)
1730{
1731 struct lm90_data *data = i2c_get_clientdata(client);
1732 int st, st2 = 0;
1733
1734 st = lm90_read_reg(client, LM90_REG_R_STATUS);
1735 if (st < 0)
1736 return false;
1737
1738 if (data->kind == max6696) {
1739 st2 = lm90_read_reg(client, MAX6696_REG_R_STATUS2);
1740 if (st2 < 0)
1741 return false;
1742 }
1743
1744 *status = st | (st2 << 8);
1745
1746 if ((st & 0x7f) == 0 && (st2 & 0xfe) == 0)
1747 return false;
1748
1749 if ((st & (LM90_STATUS_LLOW | LM90_STATUS_LHIGH | LM90_STATUS_LTHRM)) ||
1750 (st2 & MAX6696_STATUS2_LOT2))
1751 dev_dbg(&client->dev,
1752 "temp%d out of range, please check!\n", 1);
1753 if ((st & (LM90_STATUS_RLOW | LM90_STATUS_RHIGH | LM90_STATUS_RTHRM)) ||
1754 (st2 & MAX6696_STATUS2_ROT2))
1755 dev_dbg(&client->dev,
1756 "temp%d out of range, please check!\n", 2);
1757 if (st & LM90_STATUS_ROPEN)
1758 dev_dbg(&client->dev,
1759 "temp%d diode open, please check!\n", 2);
1760 if (st2 & (MAX6696_STATUS2_R2LOW | MAX6696_STATUS2_R2HIGH |
1761 MAX6696_STATUS2_R2THRM | MAX6696_STATUS2_R2OT2))
1762 dev_dbg(&client->dev,
1763 "temp%d out of range, please check!\n", 3);
1764 if (st2 & MAX6696_STATUS2_R2OPEN)
1765 dev_dbg(&client->dev,
1766 "temp%d diode open, please check!\n", 3);
1767
1768 if (st & LM90_STATUS_LLOW)
1769 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1770 hwmon_temp_min, 0);
1771 if (st & LM90_STATUS_RLOW)
1772 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1773 hwmon_temp_min, 1);
1774 if (st2 & MAX6696_STATUS2_R2LOW)
1775 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1776 hwmon_temp_min, 2);
1777 if (st & LM90_STATUS_LHIGH)
1778 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1779 hwmon_temp_max, 0);
1780 if (st & LM90_STATUS_RHIGH)
1781 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1782 hwmon_temp_max, 1);
1783 if (st2 & MAX6696_STATUS2_R2HIGH)
1784 hwmon_notify_event(data->hwmon_dev, hwmon_temp,
1785 hwmon_temp_max, 2);
1786
1787 return true;
1788}
1789
1790static irqreturn_t lm90_irq_thread(int irq, void *dev_id)
1791{
1792 struct i2c_client *client = dev_id;
1793 u16 status;
1794
1795 if (lm90_is_tripped(client, &status))
1796 return IRQ_HANDLED;
1797 else
1798 return IRQ_NONE;
1799}
1800
1801static void lm90_remove_pec(void *dev)
1802{
1803 device_remove_file(dev, &dev_attr_pec);
1804}
1805
1806static void lm90_regulator_disable(void *regulator)
1807{
1808 regulator_disable(regulator);
1809}
1810
1811
1812static const struct hwmon_ops lm90_ops = {
1813 .is_visible = lm90_is_visible,
1814 .read = lm90_read,
1815 .write = lm90_write,
1816};
1817
1818static int lm90_probe(struct i2c_client *client)
1819{
1820 struct device *dev = &client->dev;
1821 struct i2c_adapter *adapter = client->adapter;
1822 struct hwmon_channel_info *info;
1823 struct regulator *regulator;
1824 struct device *hwmon_dev;
1825 struct lm90_data *data;
1826 int err;
1827
1828 regulator = devm_regulator_get(dev, "vcc");
1829 if (IS_ERR(regulator))
1830 return PTR_ERR(regulator);
1831
1832 err = regulator_enable(regulator);
1833 if (err < 0) {
1834 dev_err(dev, "Failed to enable regulator: %d\n", err);
1835 return err;
1836 }
1837
1838 err = devm_add_action_or_reset(dev, lm90_regulator_disable, regulator);
1839 if (err)
1840 return err;
1841
1842 data = devm_kzalloc(dev, sizeof(struct lm90_data), GFP_KERNEL);
1843 if (!data)
1844 return -ENOMEM;
1845
1846 data->client = client;
1847 i2c_set_clientdata(client, data);
1848 mutex_init(&data->update_lock);
1849
1850
1851 if (client->dev.of_node)
1852 data->kind = (enum chips)of_device_get_match_data(&client->dev);
1853 else
1854 data->kind = i2c_match_id(lm90_id, client)->driver_data;
1855 if (data->kind == adm1032) {
1856 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
1857 client->flags &= ~I2C_CLIENT_PEC;
1858 }
1859
1860
1861
1862
1863
1864 data->alert_alarms = lm90_params[data->kind].alert_alarms;
1865
1866
1867 data->flags = lm90_params[data->kind].flags;
1868
1869 data->chip.ops = &lm90_ops;
1870 data->chip.info = data->info;
1871
1872 data->info[0] = HWMON_CHANNEL_INFO(chip,
1873 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL | HWMON_C_ALARMS);
1874 data->info[1] = &data->temp_info;
1875
1876 info = &data->temp_info;
1877 info->type = hwmon_temp;
1878 info->config = data->channel_config;
1879
1880 data->channel_config[0] = HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
1881 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM |
1882 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM;
1883 data->channel_config[1] = HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
1884 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM |
1885 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT;
1886
1887 if (data->flags & LM90_HAVE_OFFSET)
1888 data->channel_config[1] |= HWMON_T_OFFSET;
1889
1890 if (data->flags & LM90_HAVE_EMERGENCY) {
1891 data->channel_config[0] |= HWMON_T_EMERGENCY |
1892 HWMON_T_EMERGENCY_HYST;
1893 data->channel_config[1] |= HWMON_T_EMERGENCY |
1894 HWMON_T_EMERGENCY_HYST;
1895 }
1896
1897 if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
1898 data->channel_config[0] |= HWMON_T_EMERGENCY_ALARM;
1899 data->channel_config[1] |= HWMON_T_EMERGENCY_ALARM;
1900 }
1901
1902 if (data->flags & LM90_HAVE_TEMP3) {
1903 data->channel_config[2] = HWMON_T_INPUT |
1904 HWMON_T_MIN | HWMON_T_MAX |
1905 HWMON_T_CRIT | HWMON_T_CRIT_HYST |
1906 HWMON_T_EMERGENCY | HWMON_T_EMERGENCY_HYST |
1907 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM |
1908 HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY_ALARM |
1909 HWMON_T_FAULT;
1910 }
1911
1912 data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
1913
1914
1915 data->max_convrate = lm90_params[data->kind].max_convrate;
1916
1917
1918 err = lm90_init_client(client, data);
1919 if (err < 0) {
1920 dev_err(dev, "Failed to initialize device\n");
1921 return err;
1922 }
1923
1924
1925
1926
1927
1928 if (client->flags & I2C_CLIENT_PEC) {
1929 err = device_create_file(dev, &dev_attr_pec);
1930 if (err)
1931 return err;
1932 err = devm_add_action_or_reset(dev, lm90_remove_pec, dev);
1933 if (err)
1934 return err;
1935 }
1936
1937 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
1938 data, &data->chip,
1939 NULL);
1940 if (IS_ERR(hwmon_dev))
1941 return PTR_ERR(hwmon_dev);
1942
1943 data->hwmon_dev = hwmon_dev;
1944
1945 if (client->irq) {
1946 dev_dbg(dev, "IRQ: %d\n", client->irq);
1947 err = devm_request_threaded_irq(dev, client->irq,
1948 NULL, lm90_irq_thread,
1949 IRQF_ONESHOT, "lm90", client);
1950 if (err < 0) {
1951 dev_err(dev, "cannot request IRQ %d\n", client->irq);
1952 return err;
1953 }
1954 }
1955
1956 return 0;
1957}
1958
1959static void lm90_alert(struct i2c_client *client, enum i2c_alert_protocol type,
1960 unsigned int flag)
1961{
1962 u16 alarms;
1963
1964 if (type != I2C_PROTOCOL_SMBUS_ALERT)
1965 return;
1966
1967 if (lm90_is_tripped(client, &alarms)) {
1968
1969
1970
1971
1972
1973 struct lm90_data *data = i2c_get_clientdata(client);
1974
1975 if ((data->flags & LM90_HAVE_BROKEN_ALERT) &&
1976 (alarms & data->alert_alarms)) {
1977 dev_dbg(&client->dev, "Disabling ALERT#\n");
1978 lm90_update_confreg(data, data->config | 0x80);
1979 }
1980 } else {
1981 dev_dbg(&client->dev, "Everything OK\n");
1982 }
1983}
1984
1985static int __maybe_unused lm90_suspend(struct device *dev)
1986{
1987 struct lm90_data *data = dev_get_drvdata(dev);
1988 struct i2c_client *client = data->client;
1989
1990 if (client->irq)
1991 disable_irq(client->irq);
1992
1993 return 0;
1994}
1995
1996static int __maybe_unused lm90_resume(struct device *dev)
1997{
1998 struct lm90_data *data = dev_get_drvdata(dev);
1999 struct i2c_client *client = data->client;
2000
2001 if (client->irq)
2002 enable_irq(client->irq);
2003
2004 return 0;
2005}
2006
2007static SIMPLE_DEV_PM_OPS(lm90_pm_ops, lm90_suspend, lm90_resume);
2008
2009static struct i2c_driver lm90_driver = {
2010 .class = I2C_CLASS_HWMON,
2011 .driver = {
2012 .name = "lm90",
2013 .of_match_table = of_match_ptr(lm90_of_match),
2014 .pm = &lm90_pm_ops,
2015 },
2016 .probe_new = lm90_probe,
2017 .alert = lm90_alert,
2018 .id_table = lm90_id,
2019 .detect = lm90_detect,
2020 .address_list = normal_i2c,
2021};
2022
2023module_i2c_driver(lm90_driver);
2024
2025MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
2026MODULE_DESCRIPTION("LM90/ADM1032 driver");
2027MODULE_LICENSE("GPL");
2028