Merge tag 'staging-4.16-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[linux-2.6-microblaze.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         mcp980x,
51         stds75,
52         tcn75,
53         tmp100,
54         tmp101,
55         tmp105,
56         tmp112,
57         tmp175,
58         tmp275,
59         tmp75,
60         tmp75c,
61 };
62
63 /* Addresses scanned */
64 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
65                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
66
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 12 */
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_rw = true,
258 };
259
260 static void lm75_remove(void *data)
261 {
262         struct lm75_data *lm75 = data;
263         struct i2c_client *client = lm75->client;
264
265         i2c_smbus_write_byte_data(client, LM75_REG_CONF, lm75->orig_conf);
266 }
267
268 static int
269 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
270 {
271         struct device *dev = &client->dev;
272         struct device *hwmon_dev;
273         struct lm75_data *data;
274         int status, err;
275         u8 set_mask, clr_mask;
276         int new;
277         enum lm75_type kind;
278
279         if (client->dev.of_node)
280                 kind = (enum lm75_type)of_device_get_match_data(&client->dev);
281         else
282                 kind = id->driver_data;
283
284         if (!i2c_check_functionality(client->adapter,
285                         I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
286                 return -EIO;
287
288         data = devm_kzalloc(dev, sizeof(struct lm75_data), GFP_KERNEL);
289         if (!data)
290                 return -ENOMEM;
291
292         data->client = client;
293
294         data->regmap = devm_regmap_init_i2c(client, &lm75_regmap_config);
295         if (IS_ERR(data->regmap))
296                 return PTR_ERR(data->regmap);
297
298         /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
299          * Then tweak to be more precise when appropriate.
300          */
301         set_mask = 0;
302         clr_mask = LM75_SHUTDOWN;               /* continuous conversions */
303
304         switch (kind) {
305         case adt75:
306                 clr_mask |= 1 << 5;             /* not one-shot mode */
307                 data->resolution = 12;
308                 data->sample_time = MSEC_PER_SEC / 8;
309                 break;
310         case ds1775:
311         case ds75:
312         case stds75:
313                 clr_mask |= 3 << 5;
314                 set_mask |= 2 << 5;             /* 11-bit mode */
315                 data->resolution = 11;
316                 data->sample_time = MSEC_PER_SEC;
317                 break;
318         case ds7505:
319                 set_mask |= 3 << 5;             /* 12-bit mode */
320                 data->resolution = 12;
321                 data->sample_time = MSEC_PER_SEC / 4;
322                 break;
323         case g751:
324         case lm75:
325         case lm75a:
326                 data->resolution = 9;
327                 data->sample_time = MSEC_PER_SEC / 2;
328                 break;
329         case lm75b:
330                 data->resolution = 11;
331                 data->sample_time = MSEC_PER_SEC / 4;
332                 break;
333         case max6625:
334                 data->resolution = 9;
335                 data->sample_time = MSEC_PER_SEC / 4;
336                 break;
337         case max6626:
338                 data->resolution = 12;
339                 data->resolution_limits = 9;
340                 data->sample_time = MSEC_PER_SEC / 4;
341                 break;
342         case tcn75:
343                 data->resolution = 9;
344                 data->sample_time = MSEC_PER_SEC / 8;
345                 break;
346         case mcp980x:
347                 data->resolution_limits = 9;
348                 /* fall through */
349         case tmp100:
350         case tmp101:
351                 set_mask |= 3 << 5;             /* 12-bit mode */
352                 data->resolution = 12;
353                 data->sample_time = MSEC_PER_SEC;
354                 clr_mask |= 1 << 7;             /* not one-shot mode */
355                 break;
356         case tmp112:
357                 set_mask |= 3 << 5;             /* 12-bit mode */
358                 clr_mask |= 1 << 7;             /* not one-shot mode */
359                 data->resolution = 12;
360                 data->sample_time = MSEC_PER_SEC / 4;
361                 break;
362         case tmp105:
363         case tmp175:
364         case tmp275:
365         case tmp75:
366                 set_mask |= 3 << 5;             /* 12-bit mode */
367                 clr_mask |= 1 << 7;             /* not one-shot mode */
368                 data->resolution = 12;
369                 data->sample_time = MSEC_PER_SEC / 2;
370                 break;
371         case tmp75c:
372                 clr_mask |= 1 << 5;             /* not one-shot mode */
373                 data->resolution = 12;
374                 data->sample_time = MSEC_PER_SEC / 4;
375                 break;
376         }
377
378         /* configure as specified */
379         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
380         if (status < 0) {
381                 dev_dbg(dev, "Can't read config? %d\n", status);
382                 return status;
383         }
384         data->orig_conf = status;
385         new = status & ~clr_mask;
386         new |= set_mask;
387         if (status != new)
388                 i2c_smbus_write_byte_data(client, LM75_REG_CONF, new);
389
390         err = devm_add_action_or_reset(dev, lm75_remove, data);
391         if (err)
392                 return err;
393
394         dev_dbg(dev, "Config %02x\n", new);
395
396         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
397                                                          data, &lm75_chip_info,
398                                                          NULL);
399         if (IS_ERR(hwmon_dev))
400                 return PTR_ERR(hwmon_dev);
401
402         dev_info(dev, "%s: sensor '%s'\n", dev_name(hwmon_dev), client->name);
403
404         return 0;
405 }
406
407 static const struct i2c_device_id lm75_ids[] = {
408         { "adt75", adt75, },
409         { "ds1775", ds1775, },
410         { "ds75", ds75, },
411         { "ds7505", ds7505, },
412         { "g751", g751, },
413         { "lm75", lm75, },
414         { "lm75a", lm75a, },
415         { "lm75b", lm75b, },
416         { "max6625", max6625, },
417         { "max6626", max6626, },
418         { "mcp980x", mcp980x, },
419         { "stds75", stds75, },
420         { "tcn75", tcn75, },
421         { "tmp100", tmp100, },
422         { "tmp101", tmp101, },
423         { "tmp105", tmp105, },
424         { "tmp112", tmp112, },
425         { "tmp175", tmp175, },
426         { "tmp275", tmp275, },
427         { "tmp75", tmp75, },
428         { "tmp75c", tmp75c, },
429         { /* LIST END */ }
430 };
431 MODULE_DEVICE_TABLE(i2c, lm75_ids);
432
433 static const struct of_device_id lm75_of_match[] = {
434         {
435                 .compatible = "adi,adt75",
436                 .data = (void *)adt75
437         },
438         {
439                 .compatible = "dallas,ds1775",
440                 .data = (void *)ds1775
441         },
442         {
443                 .compatible = "dallas,ds75",
444                 .data = (void *)ds75
445         },
446         {
447                 .compatible = "dallas,ds7505",
448                 .data = (void *)ds7505
449         },
450         {
451                 .compatible = "gmt,g751",
452                 .data = (void *)g751
453         },
454         {
455                 .compatible = "national,lm75",
456                 .data = (void *)lm75
457         },
458         {
459                 .compatible = "national,lm75a",
460                 .data = (void *)lm75a
461         },
462         {
463                 .compatible = "national,lm75b",
464                 .data = (void *)lm75b
465         },
466         {
467                 .compatible = "maxim,max6625",
468                 .data = (void *)max6625
469         },
470         {
471                 .compatible = "maxim,max6626",
472                 .data = (void *)max6626
473         },
474         {
475                 .compatible = "maxim,mcp980x",
476                 .data = (void *)mcp980x
477         },
478         {
479                 .compatible = "st,stds75",
480                 .data = (void *)stds75
481         },
482         {
483                 .compatible = "microchip,tcn75",
484                 .data = (void *)tcn75
485         },
486         {
487                 .compatible = "ti,tmp100",
488                 .data = (void *)tmp100
489         },
490         {
491                 .compatible = "ti,tmp101",
492                 .data = (void *)tmp101
493         },
494         {
495                 .compatible = "ti,tmp105",
496                 .data = (void *)tmp105
497         },
498         {
499                 .compatible = "ti,tmp112",
500                 .data = (void *)tmp112
501         },
502         {
503                 .compatible = "ti,tmp175",
504                 .data = (void *)tmp175
505         },
506         {
507                 .compatible = "ti,tmp275",
508                 .data = (void *)tmp275
509         },
510         {
511                 .compatible = "ti,tmp75",
512                 .data = (void *)tmp75
513         },
514         {
515                 .compatible = "ti,tmp75c",
516                 .data = (void *)tmp75c
517         },
518         { },
519 };
520 MODULE_DEVICE_TABLE(of, lm75_of_match);
521
522 #define LM75A_ID 0xA1
523
524 /* Return 0 if detection is successful, -ENODEV otherwise */
525 static int lm75_detect(struct i2c_client *new_client,
526                        struct i2c_board_info *info)
527 {
528         struct i2c_adapter *adapter = new_client->adapter;
529         int i;
530         int conf, hyst, os;
531         bool is_lm75a = 0;
532
533         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
534                                      I2C_FUNC_SMBUS_WORD_DATA))
535                 return -ENODEV;
536
537         /*
538          * Now, we do the remaining detection. There is no identification-
539          * dedicated register so we have to rely on several tricks:
540          * unused bits, registers cycling over 8-address boundaries,
541          * addresses 0x04-0x07 returning the last read value.
542          * The cycling+unused addresses combination is not tested,
543          * since it would significantly slow the detection down and would
544          * hardly add any value.
545          *
546          * The National Semiconductor LM75A is different than earlier
547          * LM75s.  It has an ID byte of 0xaX (where X is the chip
548          * revision, with 1 being the only revision in existence) in
549          * register 7, and unused registers return 0xff rather than the
550          * last read value.
551          *
552          * Note that this function only detects the original National
553          * Semiconductor LM75 and the LM75A. Clones from other vendors
554          * aren't detected, on purpose, because they are typically never
555          * found on PC hardware. They are found on embedded designs where
556          * they can be instantiated explicitly so detection is not needed.
557          * The absence of identification registers on all these clones
558          * would make their exhaustive detection very difficult and weak,
559          * and odds are that the driver would bind to unsupported devices.
560          */
561
562         /* Unused bits */
563         conf = i2c_smbus_read_byte_data(new_client, 1);
564         if (conf & 0xe0)
565                 return -ENODEV;
566
567         /* First check for LM75A */
568         if (i2c_smbus_read_byte_data(new_client, 7) == LM75A_ID) {
569                 /* LM75A returns 0xff on unused registers so
570                    just to be sure we check for that too. */
571                 if (i2c_smbus_read_byte_data(new_client, 4) != 0xff
572                  || i2c_smbus_read_byte_data(new_client, 5) != 0xff
573                  || i2c_smbus_read_byte_data(new_client, 6) != 0xff)
574                         return -ENODEV;
575                 is_lm75a = 1;
576                 hyst = i2c_smbus_read_byte_data(new_client, 2);
577                 os = i2c_smbus_read_byte_data(new_client, 3);
578         } else { /* Traditional style LM75 detection */
579                 /* Unused addresses */
580                 hyst = i2c_smbus_read_byte_data(new_client, 2);
581                 if (i2c_smbus_read_byte_data(new_client, 4) != hyst
582                  || i2c_smbus_read_byte_data(new_client, 5) != hyst
583                  || i2c_smbus_read_byte_data(new_client, 6) != hyst
584                  || i2c_smbus_read_byte_data(new_client, 7) != hyst)
585                         return -ENODEV;
586                 os = i2c_smbus_read_byte_data(new_client, 3);
587                 if (i2c_smbus_read_byte_data(new_client, 4) != os
588                  || i2c_smbus_read_byte_data(new_client, 5) != os
589                  || i2c_smbus_read_byte_data(new_client, 6) != os
590                  || i2c_smbus_read_byte_data(new_client, 7) != os)
591                         return -ENODEV;
592         }
593         /*
594          * It is very unlikely that this is a LM75 if both
595          * hysteresis and temperature limit registers are 0.
596          */
597         if (hyst == 0 && os == 0)
598                 return -ENODEV;
599
600         /* Addresses cycling */
601         for (i = 8; i <= 248; i += 40) {
602                 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
603                  || i2c_smbus_read_byte_data(new_client, i + 2) != hyst
604                  || i2c_smbus_read_byte_data(new_client, i + 3) != os)
605                         return -ENODEV;
606                 if (is_lm75a && i2c_smbus_read_byte_data(new_client, i + 7)
607                                 != LM75A_ID)
608                         return -ENODEV;
609         }
610
611         strlcpy(info->type, is_lm75a ? "lm75a" : "lm75", I2C_NAME_SIZE);
612
613         return 0;
614 }
615
616 #ifdef CONFIG_PM
617 static int lm75_suspend(struct device *dev)
618 {
619         int status;
620         struct i2c_client *client = to_i2c_client(dev);
621         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
622         if (status < 0) {
623                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
624                 return status;
625         }
626         status = status | LM75_SHUTDOWN;
627         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
628         return 0;
629 }
630
631 static int lm75_resume(struct device *dev)
632 {
633         int status;
634         struct i2c_client *client = to_i2c_client(dev);
635         status = i2c_smbus_read_byte_data(client, LM75_REG_CONF);
636         if (status < 0) {
637                 dev_dbg(&client->dev, "Can't read config? %d\n", status);
638                 return status;
639         }
640         status = status & ~LM75_SHUTDOWN;
641         i2c_smbus_write_byte_data(client, LM75_REG_CONF, status);
642         return 0;
643 }
644
645 static const struct dev_pm_ops lm75_dev_pm_ops = {
646         .suspend        = lm75_suspend,
647         .resume         = lm75_resume,
648 };
649 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
650 #else
651 #define LM75_DEV_PM_OPS NULL
652 #endif /* CONFIG_PM */
653
654 static struct i2c_driver lm75_driver = {
655         .class          = I2C_CLASS_HWMON,
656         .driver = {
657                 .name   = "lm75",
658                 .of_match_table = of_match_ptr(lm75_of_match),
659                 .pm     = LM75_DEV_PM_OPS,
660         },
661         .probe          = lm75_probe,
662         .id_table       = lm75_ids,
663         .detect         = lm75_detect,
664         .address_list   = normal_i2c,
665 };
666
667 module_i2c_driver(lm75_driver);
668
669 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
670 MODULE_DESCRIPTION("LM75 driver");
671 MODULE_LICENSE("GPL");