Merge tag 'regmap-v5.0' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[muen/linux.git] / drivers / hwmon / lm75.c
1 /*
2  * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
3  *       monitoring
4  * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/hwmon.h>
27 #include <linux/hwmon-sysfs.h>
28 #include <linux/err.h>
29 #include <linux/of_device.h>
30 #include <linux/of.h>
31 #include <linux/regmap.h>
32 #include "lm75.h"
33
34
35 /*
36  * This driver handles the LM75 and compatible digital temperature sensors.
37  */
38
39 enum lm75_type {                /* keep sorted in alphabetical order */
40         adt75,
41         ds1775,
42         ds75,
43         ds7505,
44         g751,
45         lm75,
46         lm75a,
47         lm75b,
48         max6625,
49         max6626,
50         max31725,
51         mcp980x,
52         stds75,
53         tcn75,
54         tmp100,
55         tmp101,
56         tmp105,
57         tmp112,
58         tmp175,
59         tmp275,
60         tmp75,
61         tmp75c,
62 };
63
64 /* Addresses scanned */
65 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
66                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
67
68 /* The LM75 registers */
69 #define LM75_REG_TEMP           0x00
70 #define LM75_REG_CONF           0x01
71 #define LM75_REG_HYST           0x02
72 #define LM75_REG_MAX            0x03
73
74 /* Each client has this additional data */
75 struct lm75_data {
76         struct i2c_client       *client;
77         struct regmap           *regmap;
78         u8                      orig_conf;
79         u8                      resolution;     /* In bits, between 9 and 16 */
80         u8                      resolution_limits;
81         unsigned int            sample_time;    /* In ms */
82 };
83
84 /*-----------------------------------------------------------------------*/
85
86 static inline long lm75_reg_to_mc(s16 temp, u8 resolution)
87 {
88         return ((temp >> (16 - resolution)) * 1000) >> (resolution - 8);
89 }
90
91 static int lm75_read(struct device *dev, enum hwmon_sensor_types type,
92                      u32 attr, int channel, long *val)
93 {
94         struct lm75_data *data = dev_get_drvdata(dev);
95         unsigned int regval;
96         int err, reg;
97
98         switch (type) {
99         case hwmon_chip:
100                 switch (attr) {
101                 case hwmon_chip_update_interval:
102                         *val = data->sample_time;
103                         break;
104                 default:
105                         return -EINVAL;
106                 }
107                 break;
108         case hwmon_temp:
109                 switch (attr) {
110                 case hwmon_temp_input:
111                         reg = LM75_REG_TEMP;
112                         break;
113                 case hwmon_temp_max:
114                         reg = LM75_REG_MAX;
115                         break;
116                 case hwmon_temp_max_hyst:
117                         reg = LM75_REG_HYST;
118                         break;
119                 default:
120                         return -EINVAL;
121                 }
122                 err = regmap_read(data->regmap, reg, &regval);
123                 if (err < 0)
124                         return err;
125
126                 *val = lm75_reg_to_mc(regval, data->resolution);
127                 break;
128         default:
129                 return -EINVAL;
130         }
131         return 0;
132 }
133
134 static int lm75_write(struct device *dev, enum hwmon_sensor_types type,
135                       u32 attr, int channel, long temp)
136 {
137         struct lm75_data *data = dev_get_drvdata(dev);
138         u8 resolution;
139         int reg;
140
141         if (type != hwmon_temp)
142                 return -EINVAL;
143
144         switch (attr) {
145         case hwmon_temp_max:
146                 reg = LM75_REG_MAX;
147                 break;
148         case hwmon_temp_max_hyst:
149                 reg = LM75_REG_HYST;
150                 break;
151         default:
152                 return -EINVAL;
153         }
154
155         /*
156          * Resolution of limit registers is assumed to be the same as the
157          * temperature input register resolution unless given explicitly.
158          */
159         if (data->resolution_limits)
160                 resolution = data->resolution_limits;
161         else
162                 resolution = data->resolution;
163
164         temp = clamp_val(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
165         temp = DIV_ROUND_CLOSEST(temp  << (resolution - 8),
166                                  1000) << (16 - resolution);
167
168         return regmap_write(data->regmap, reg, temp);
169 }
170
171 static umode_t lm75_is_visible(const void *data, enum hwmon_sensor_types type,
172                                u32 attr, int channel)
173 {
174         switch (type) {
175         case hwmon_chip:
176                 switch (attr) {
177                 case hwmon_chip_update_interval:
178                         return S_IRUGO;
179                 }
180                 break;
181         case hwmon_temp:
182                 switch (attr) {
183                 case hwmon_temp_input:
184                         return S_IRUGO;
185                 case hwmon_temp_max:
186                 case hwmon_temp_max_hyst:
187                         return S_IRUGO | S_IWUSR;
188                 }
189                 break;
190         default:
191                 break;
192         }
193         return 0;
194 }
195
196 /*-----------------------------------------------------------------------*/
197
198 /* device probe and removal */
199
200 /* chip configuration */
201
202 static const u32 lm75_chip_config[] = {
203         HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL,
204         0
205 };
206
207 static const struct hwmon_channel_info lm75_chip = {
208         .type = hwmon_chip,
209         .config = lm75_chip_config,
210 };
211
212 static const u32 lm75_temp_config[] = {
213         HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST,
214         0
215 };
216
217 static const struct hwmon_channel_info lm75_temp = {
218         .type = hwmon_temp,
219         .config = lm75_temp_config,
220 };
221
222 static const struct hwmon_channel_info *lm75_info[] = {
223         &lm75_chip,
224         &lm75_temp,
225         NULL
226 };
227
228 static const struct hwmon_ops lm75_hwmon_ops = {
229         .is_visible = lm75_is_visible,
230         .read = lm75_read,
231         .write = lm75_write,
232 };
233
234 static const struct hwmon_chip_info lm75_chip_info = {
235         .ops = &lm75_hwmon_ops,
236         .info = lm75_info,
237 };
238
239 static bool lm75_is_writeable_reg(struct device *dev, unsigned int reg)
240 {
241         return reg != LM75_REG_TEMP;
242 }
243
244 static bool lm75_is_volatile_reg(struct device *dev, unsigned int reg)
245 {
246         return reg == LM75_REG_TEMP;
247 }
248
249 static const struct regmap_config lm75_regmap_config = {
250         .reg_bits = 8,
251         .val_bits = 16,
252         .max_register = LM75_REG_MAX,
253         .writeable_reg = lm75_is_writeable_reg,
254         .volatile_reg = lm75_is_volatile_reg,
255         .val_format_endian = REGMAP_ENDIAN_BIG,
256         .cache_type = REGCACHE_RBTREE,
257         .use_single_read = true,
258         .use_single_write = true,
259 };
260
261 static void lm75_remove(void *data)
262 {
263         struct lm75_data *lm75 = data;
264         struct i2c_client *client = lm75->client;
265
266         i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
267 }
268
269 static int
270 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
271 {
272         struct device *dev = &client->dev;
273         struct device *hwmon_dev;
274         struct lm75_data *data;
275         int status, err;
276         u8 set_mask, clr_mask;
277         int new;
278         enum lm75_type kind;
279
280         if (client->dev.of_node)
281                 kind = (enum lm75_type)of_device_get_match_data(&client->dev);
282         else
283                 kind = id->driver_data;
284
285         if (!i2c_check_functionality(client->adapter,
286                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
287                 return -EIO;
288
289         data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
290         if (!data)
291                 return -ENOMEM;
292
293         data->client = client;
294
295         data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
296         if (IS_ERR(data->regmap))
297                 return PTR_ERR(data->regmap);
298
299         /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
300          * Then tweak to be more precise when appropriate.
301          */
302         set_mask = 0;
303         clr_mask = LM75_SHUTDOWN;               /* continuous conversions */
304
305         switch (kind) {
306         case adt75:
307                 clr_mask |= 1 << 5;             /* not one-shot mode */
308                 data->resolution = 12;
309                 data->sample_time = MSEC_PER_SEC / 8;
310                 break;
311         case ds1775:
312         case ds75:
313         case stds75:
314                 clr_mask |= 3 << 5;
315                 set_mask |= 2 << 5;             /* 11-bit mode */
316                 data->resolution = 11;
317                 data->sample_time = MSEC_PER_SEC;
318                 break;
319         case ds7505:
320                 set_mask |= 3 << 5;             /* 12-bit mode */
321                 data->resolution = 12;
322                 data->sample_time = MSEC_PER_SEC / 4;
323                 break;
324         case g751:
325         case lm75:
326         case lm75a:
327                 data->resolution = 9;
328                 data->sample_time = MSEC_PER_SEC / 2;
329                 break;
330         case lm75b:
331                 data->resolution = 11;
332                 data->sample_time = MSEC_PER_SEC / 4;
333                 break;
334         case max6625:
335                 data->resolution = 9;
336                 data->sample_time = MSEC_PER_SEC / 4;
337                 break;
338         case max6626:
339                 data->resolution = 12;
340                 data->resolution_limits = 9;
341                 data->sample_time = MSEC_PER_SEC / 4;
342                 break;
343         case max31725:
344                 data->resolution = 16;
345                 data->sample_time = MSEC_PER_SEC / 8;
346                 break;
347         case tcn75:
348                 data->resolution = 9;
349                 data->sample_time = MSEC_PER_SEC / 8;
350                 break;
351         case mcp980x:
352                 data->resolution_limits = 9;
353                 /* fall through */
354         case tmp100:
355         case tmp101:
356                 set_mask |= 3 << 5;             /* 12-bit mode */
357                 data->resolution = 12;
358                 data->sample_time = MSEC_PER_SEC;
359                 clr_mask |= 1 << 7;             /* not one-shot mode */
360                 break;
361         case tmp112:
362                 set_mask |= 3 << 5;             /* 12-bit mode */
363                 clr_mask |= 1 << 7;             /* not one-shot mode */
364                 data->resolution = 12;
365                 data->sample_time = MSEC_PER_SEC / 4;
366                 break;
367         case tmp105:
368         case tmp175:
369         case tmp275:
370         case tmp75:
371                 set_mask |= 3 << 5;             /* 12-bit mode */
372                 clr_mask |= 1 << 7;             /* not one-shot mode */
373                 data->resolution = 12;
374                 data->sample_time = MSEC_PER_SEC / 2;
375                 break;
376         case tmp75c:
377                 clr_mask |= 1 << 5;             /* not one-shot mode */
378                 data->resolution = 12;
379                 data->sample_time = MSEC_PER_SEC / 4;
380                 break;
381         }
382
383         /* configure as specified */
384         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
385         if (status < 0) {
386                 dev_dbg(dev, "Can't read config? %d\n", status);
387                 return status;
388         }
389         data->orig_conf = status;
390         new = status & ~clr_mask;
391         new |= set_mask;
392         if (status != new)
393                 i2c_smbus_write_byte_data(client, LM75_REG_CONF, new);
394
395         err = devm_add_action_or_reset(dev, lm75_remove, data);
396         if (err)
397                 return err;
398
399         dev_dbg(dev, "Config %02x\n", new);
400
401         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
402                                                          data, &lm75_chip_info,
403                                                          NULL);
404         if (IS_ERR(hwmon_dev))
405                 return PTR_ERR(hwmon_dev);
406
407         dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
408
409         return 0;
410 }
411
412 static const struct i2c_device_id lm75_ids[] = {
413         { "adt75", adt75, },
414         { "ds1775", ds1775, },
415         { "ds75", ds75, },
416         { "ds7505", ds7505, },
417         { "g751", g751, },
418         { "lm75", lm75, },
419         { "lm75a", lm75a, },
420         { "lm75b", lm75b, },
421         { "max6625", max6625, },
422         { "max6626", max6626, },
423         { "max31725", max31725, },
424         { "max31726", max31725, },
425         { "mcp980x", mcp980x, },
426         { "stds75", stds75, },
427         { "tcn75", tcn75, },
428         { "tmp100", tmp100, },
429         { "tmp101", tmp101, },
430         { "tmp105", tmp105, },
431         { "tmp112", tmp112, },
432         { "tmp175", tmp175, },
433         { "tmp275", tmp275, },
434         { "tmp75", tmp75, },
435         { "tmp75c", tmp75c, },
436         { /* LIST END */ }
437 };
438 MODULE_DEVICE_TABLE(i2c, lm75_ids);
439
440 static const struct of_device_id lm75_of_match[] = {
441         {
442                 .compatible = "adi,adt75",
443                 .data = (void *)adt75
444         },
445         {
446                 .compatible = "dallas,ds1775",
447                 .data = (void *)ds1775
448         },
449         {
450                 .compatible = "dallas,ds75",
451                 .data = (void *)ds75
452         },
453         {
454                 .compatible = "dallas,ds7505",
455                 .data = (void *)ds7505
456         },
457         {
458                 .compatible = "gmt,g751",
459                 .data = (void *)g751
460         },
461         {
462                 .compatible = "national,lm75",
463                 .data = (void *)lm75
464         },
465         {
466                 .compatible = "national,lm75a",
467                 .data = (void *)lm75a
468         },
469         {
470                 .compatible = "national,lm75b",
471                 .data = (void *)lm75b
472         },
473         {
474                 .compatible = "maxim,max6625",
475                 .data = (void *)max6625
476         },
477         {
478                 .compatible = "maxim,max6626",
479                 .data = (void *)max6626
480         },
481         {
482                 .compatible = "maxim,max31725",
483                 .data = (void *)max31725
484         },
485         {
486                 .compatible = "maxim,max31726",
487                 .data = (void *)max31725
488         },
489         {
490                 .compatible = "maxim,mcp980x",
491                 .data = (void *)mcp980x
492         },
493         {
494                 .compatible = "st,stds75",
495                 .data = (void *)stds75
496         },
497         {
498                 .compatible = "microchip,tcn75",
499                 .data = (void *)tcn75
500         },
501         {
502                 .compatible = "ti,tmp100",
503                 .data = (void *)tmp100
504         },
505         {
506                 .compatible = "ti,tmp101",
507                 .data = (void *)tmp101
508         },
509         {
510                 .compatible = "ti,tmp105",
511                 .data = (void *)tmp105
512         },
513         {
514                 .compatible = "ti,tmp112",
515                 .data = (void *)tmp112
516         },
517         {
518                 .compatible = "ti,tmp175",
519                 .data = (void *)tmp175
520         },
521         {
522                 .compatible = "ti,tmp275",
523                 .data = (void *)tmp275
524         },
525         {
526                 .compatible = "ti,tmp75",
527                 .data = (void *)tmp75
528         },
529         {
530                 .compatible = "ti,tmp75c",
531                 .data = (void *)tmp75c
532         },
533         { },
534 };
535 MODULE_DEVICE_TABLE(of, lm75_of_match);
536
537 #define LM75A_ID 0xA1
538
539 /* Return 0 if detection is successful, -ENODEV otherwise */
540 static int lm75_detect(struct i2c_client *new_client,
541                        struct i2c_board_info *info)
542 {
543         struct i2c_adapter *adapter = new_client->adapter;
544         int i;
545         int conf, hyst, os;
546         bool is_lm75a = 0;
547
548         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
549                                      I2C_FUNC_SMBUS_WORD_DATA))
550                 return -ENODEV;
551
552         /*
553          * Now, we do the remaining detection. There is no identification-
554          * dedicated register so we have to rely on several tricks:
555          * unused bits, registers cycling over 8-address boundaries,
556          * addresses 0x04-0x07 returning the last read value.
557          * The cycling+unused addresses combination is not tested,
558          * since it would significantly slow the detection down and would
559          * hardly add any value.
560          *
561          * The National Semiconductor LM75A is different than earlier
562          * LM75s.  It has an ID byte of 0xaX (where X is the chip
563          * revision, with 1 being the only revision in existence) in
564          * register 7, and unused registers return 0xff rather than the
565          * last read value.
566          *
567          * Note that this function only detects the original National
568          * Semiconductor LM75 and the LM75A. Clones from other vendors
569          * aren't detected, on purpose, because they are typically never
570          * found on PC hardware. They are found on embedded designs where
571          * they can be instantiated explicitly so detection is not needed.
572          * The absence of identification registers on all these clones
573          * would make their exhaustive detection very difficult and weak,
574          * and odds are that the driver would bind to unsupported devices.
575          */
576
577         /* Unused bits */
578         conf = i2c_smbus_read_byte_data(new_client, 1);
579         if (conf & 0xe0)
580                 return -ENODEV;
581
582         /* First check for LM75A */
583         if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
584                 /* LM75A returns 0xff on unused registers so
585                    just to be sure we check for that too. */
586                 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
587                  || i2c_smbus_read_byte_data(new_client, 5) != 0xff
588                  || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
589                         return -ENODEV;
590                 is_lm75a = 1;
591                 hyst = i2c_smbus_read_byte_data(new_client, 2);
592                 os = i2c_smbus_read_byte_data(new_client, 3);
593         } else { /* Traditional style LM75 detection */
594                 /* Unused addresses */
595                 hyst = i2c_smbus_read_byte_data(new_client, 2);
596                 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
597                  || i2c_smbus_read_byte_data(new_client, 5) != hyst
598                  || i2c_smbus_read_byte_data(new_client, 6) != hyst
599                  || i2c_smbus_read_byte_data(new_client, 7) != hyst)
600                         return -ENODEV;
601                 os = i2c_smbus_read_byte_data(new_client, 3);
602                 if (i2c_smbus_read_byte_data(new_client, 4) != os
603                  || i2c_smbus_read_byte_data(new_client, 5) != os
604                  || i2c_smbus_read_byte_data(new_client, 6) != os
605                  || i2c_smbus_read_byte_data(new_client, 7) != os)
606                         return -ENODEV;
607         }
608         /*
609          * It is very unlikely that this is a LM75 if both
610          * hysteresis and temperature limit registers are 0.
611          */
612         if (hyst == 0 && os == 0)
613                 return -ENODEV;
614
615         /* Addresses cycling */
616         for (i = 8; i <= 248; i += 40) {
617                 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
618                  || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
619                  || i2c_smbus_read_byte_data(new_client, i + 3) != os)
620                         return -ENODEV;
621                 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
622                                 != LM75A_ID)
623                         return -ENODEV;
624         }
625
626         strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
627
628         return 0;
629 }
630
631 #ifdef CONFIG_PM
632 static int lm75_suspend(struct device *dev)
633 {
634         int status;
635         struct i2c_client *client = to_i2c_client(dev);
636         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
637         if (status < 0) {
638                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
639                 return status;
640         }
641         status = status | LM75_SHUTDOWN;
642         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
643         return 0;
644 }
645
646 static int lm75_resume(struct device *dev)
647 {
648         int status;
649         struct i2c_client *client = to_i2c_client(dev);
650         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
651         if (status < 0) {
652                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
653                 return status;
654         }
655         status = status & ~LM75_SHUTDOWN;
656         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
657         return 0;
658 }
659
660 static const struct dev_pm_ops lm75_dev_pm_ops = {
661         .suspend        = lm75_suspend,
662         .resume         = lm75_resume,
663 };
664 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
665 #else
666 #define LM75_DEV_PM_OPS NULL
667 #endif /* CONFIG_PM */
668
669 static struct i2c_driver lm75_driver = {
670         .class          = I2C_CLASS_HWMON,
671         .driver = {
672                 .name   = "lm75",
673                 .of_match_table = of_match_ptr(lm75_of_match),
674                 .pm     = LM75_DEV_PM_OPS,
675         },
676         .probe          = lm75_probe,
677         .id_table       = lm75_ids,
678         .detect         = lm75_detect,
679         .address_list   = normal_i2c,
680 };
681
682 module_i2c_driver(lm75_driver);
683
684 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
685 MODULE_DESCRIPTION("LM75 driver");
686 MODULE_LICENSE("GPL");