1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * lm75.c - Part of lm_sensors, Linux kernel modules for hardware
5 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/jiffies.h>
12 #include <linux/i2c.h>
13 #include <linux/hwmon.h>
14 #include <linux/hwmon-sysfs.h>
15 #include <linux/err.h>
16 #include <linux/of_device.h>
18 #include <linux/regmap.h>
19 #include <linux/util_macros.h>
20 #include <linux/regulator/consumer.h>
24 * This driver handles the LM75 and compatible digital temperature sensors.
27 enum lm75_type
{ /* keep sorted in alphabetical order */
58 * struct lm75_params - lm75 configuration parameters.
59 * @set_mask: Bits to set in configuration register when configuring
61 * @clr_mask: Bits to clear in configuration register when configuring
63 * @default_resolution: Default number of bits to represent the temperature
65 * @resolution_limits: Limit register resolution. Optional. Should be set if
66 * the resolution of limit registers does not match the
67 * resolution of the temperature register.
68 * @resolutions: List of resolutions associated with sample times.
69 * Optional. Should be set if num_sample_times is larger
70 * than 1, and if the resolution changes with sample times.
71 * If set, number of entries must match num_sample_times.
72 * @default_sample_time:Sample time to be set by default.
73 * @num_sample_times: Number of possible sample times to be set. Optional.
74 * Should be set if the number of sample times is larger
76 * @sample_times: All the possible sample times to be set. Mandatory if
77 * num_sample_times is larger than 1. If set, number of
78 * entries must match num_sample_times.
84 u8 default_resolution
;
86 const u8
*resolutions
;
87 unsigned int default_sample_time
;
89 const unsigned int *sample_times
;
92 /* Addresses scanned */
93 static const unsigned short normal_i2c
[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
94 0x4d, 0x4e, 0x4f, I2C_CLIENT_END
};
96 /* The LM75 registers */
97 #define LM75_REG_TEMP 0x00
98 #define LM75_REG_CONF 0x01
99 #define LM75_REG_HYST 0x02
100 #define LM75_REG_MAX 0x03
101 #define PCT2075_REG_IDLE 0x04
103 /* Each client has this additional data */
105 struct i2c_client
*client
;
106 struct regmap
*regmap
;
107 struct regulator
*vs
;
110 u8 resolution
; /* In bits, 9 to 16 */
111 unsigned int sample_time
; /* In ms */
113 const struct lm75_params
*params
;
116 /*-----------------------------------------------------------------------*/
118 static const u8 lm75_sample_set_masks
[] = { 0 << 5, 1 << 5, 2 << 5, 3 << 5 };
120 #define LM75_SAMPLE_CLEAR_MASK (3 << 5)
122 /* The structure below stores the configuration values of the supported devices.
123 * In case of being supported multiple configurations, the default one must
124 * always be the first element of the array
126 static const struct lm75_params device_params
[] = {
128 .clr_mask
= 1 << 5, /* not one-shot mode */
129 .default_resolution
= 12,
130 .default_sample_time
= MSEC_PER_SEC
/ 10,
133 .set_mask
= 3 << 5, /* 12-bit mode*/
134 .default_resolution
= 12,
135 .default_sample_time
= 200,
136 .num_sample_times
= 4,
137 .sample_times
= (unsigned int []){ 25, 50, 100, 200 },
138 .resolutions
= (u8
[]) {9, 10, 11, 12 },
142 .set_mask
= 2 << 5, /* 11-bit mode */
143 .default_resolution
= 11,
144 .default_sample_time
= 500,
145 .num_sample_times
= 4,
146 .sample_times
= (unsigned int []){ 125, 250, 500, 1000 },
147 .resolutions
= (u8
[]) {9, 10, 11, 12 },
151 .set_mask
= 2 << 5, /* 11-bit mode */
152 .default_resolution
= 11,
153 .default_sample_time
= 600,
154 .num_sample_times
= 4,
155 .sample_times
= (unsigned int []){ 150, 300, 600, 1200 },
156 .resolutions
= (u8
[]) {9, 10, 11, 12 },
160 .set_mask
= 2 << 5, /* 11-bit mode */
161 .default_resolution
= 11,
162 .default_sample_time
= 600,
163 .num_sample_times
= 4,
164 .sample_times
= (unsigned int []){ 150, 300, 600, 1200 },
165 .resolutions
= (u8
[]) {9, 10, 11, 12 },
168 .default_resolution
= 9,
169 .default_sample_time
= MSEC_PER_SEC
/ 6,
172 .set_mask
= 3 << 5, /* 12-bit mode*/
173 .default_resolution
= 12,
174 .default_sample_time
= 200,
175 .num_sample_times
= 4,
176 .sample_times
= (unsigned int []){ 25, 50, 100, 200 },
177 .resolutions
= (u8
[]) {9, 10, 11, 12 },
180 .default_resolution
= 9,
181 .default_sample_time
= MSEC_PER_SEC
/ 10,
184 .default_resolution
= 9,
185 .default_sample_time
= MSEC_PER_SEC
/ 10,
188 .default_resolution
= 9,
189 .default_sample_time
= MSEC_PER_SEC
/ 10,
192 .default_resolution
= 11,
193 .default_sample_time
= MSEC_PER_SEC
/ 10,
196 .default_resolution
= 9,
197 .default_sample_time
= MSEC_PER_SEC
/ 7,
200 .default_resolution
= 12,
201 .default_sample_time
= MSEC_PER_SEC
/ 7,
202 .resolution_limits
= 9,
205 .default_resolution
= 16,
206 .default_sample_time
= MSEC_PER_SEC
/ 20,
209 .default_resolution
= 9,
210 .default_sample_time
= MSEC_PER_SEC
/ 18,
213 .default_resolution
= 11,
214 .default_sample_time
= MSEC_PER_SEC
/ 10,
215 .num_sample_times
= 31,
216 .sample_times
= (unsigned int []){ 100, 200, 300, 400, 500, 600,
217 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700,
218 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700,
219 2800, 2900, 3000, 3100 },
222 .set_mask
= 3 << 5, /* 12-bit mode */
223 .clr_mask
= 1 << 7, /* not one-shot mode */
224 .default_resolution
= 12,
225 .resolution_limits
= 9,
226 .default_sample_time
= 240,
227 .num_sample_times
= 4,
228 .sample_times
= (unsigned int []){ 30, 60, 120, 240 },
229 .resolutions
= (u8
[]) {9, 10, 11, 12 },
232 .set_mask
= 3 << 5, /* 12-bit mode */
233 .clr_mask
= 1 << 7, /* not one-shot mode */
234 .default_resolution
= 12,
235 .default_sample_time
= 320,
236 .num_sample_times
= 4,
237 .sample_times
= (unsigned int []){ 40, 80, 160, 320 },
238 .resolutions
= (u8
[]) {9, 10, 11, 12 },
241 .set_mask
= 3 << 5, /* 12-bit mode */
242 .clr_mask
= 1 << 7, /* not one-shot mode */
243 .default_resolution
= 12,
244 .default_sample_time
= 320,
245 .num_sample_times
= 4,
246 .sample_times
= (unsigned int []){ 40, 80, 160, 320 },
247 .resolutions
= (u8
[]) {9, 10, 11, 12 },
250 .set_mask
= 3 << 5, /* 12-bit mode */
251 .clr_mask
= 1 << 7, /* not one-shot mode*/
252 .default_resolution
= 12,
253 .default_sample_time
= 220,
254 .num_sample_times
= 4,
255 .sample_times
= (unsigned int []){ 28, 55, 110, 220 },
256 .resolutions
= (u8
[]) {9, 10, 11, 12 },
259 .set_mask
= 3 << 5, /* 8 samples / second */
260 .clr_mask
= 1 << 7, /* no one-shot mode*/
261 .default_resolution
= 12,
262 .default_sample_time
= 125,
263 .num_sample_times
= 4,
264 .sample_times
= (unsigned int []){ 125, 250, 1000, 4000 },
267 .set_mask
= 3 << 5, /* 12-bit mode */
268 .clr_mask
= 1 << 7, /* not one-shot mode*/
269 .default_resolution
= 12,
270 .default_sample_time
= 220,
271 .num_sample_times
= 4,
272 .sample_times
= (unsigned int []){ 28, 55, 110, 220 },
273 .resolutions
= (u8
[]) {9, 10, 11, 12 },
276 .set_mask
= 3 << 5, /* 12-bit mode */
277 .clr_mask
= 1 << 7, /* not one-shot mode*/
278 .default_resolution
= 12,
279 .default_sample_time
= 220,
280 .num_sample_times
= 4,
281 .sample_times
= (unsigned int []){ 28, 55, 110, 220 },
282 .resolutions
= (u8
[]) {9, 10, 11, 12 },
285 .set_mask
= 3 << 5, /* 12-bit mode */
286 .clr_mask
= 1 << 7, /* not one-shot mode*/
287 .default_resolution
= 12,
288 .default_sample_time
= 220,
289 .num_sample_times
= 4,
290 .sample_times
= (unsigned int []){ 28, 55, 110, 220 },
291 .resolutions
= (u8
[]) {9, 10, 11, 12 },
293 [tmp75b
] = { /* not one-shot mode, Conversion rate 37Hz */
294 .clr_mask
= 1 << 7 | 3 << 5,
295 .default_resolution
= 12,
296 .default_sample_time
= MSEC_PER_SEC
/ 37,
297 .sample_times
= (unsigned int []){ MSEC_PER_SEC
/ 37,
299 MSEC_PER_SEC
/ 9, MSEC_PER_SEC
/ 4 },
300 .num_sample_times
= 4,
303 .clr_mask
= 1 << 5, /*not one-shot mode*/
304 .default_resolution
= 12,
305 .default_sample_time
= MSEC_PER_SEC
/ 12,
307 [tmp1075
] = { /* not one-shot mode, 27.5 ms sample rate */
308 .clr_mask
= 1 << 5 | 1 << 6 | 1 << 7,
309 .default_resolution
= 12,
310 .default_sample_time
= 28,
311 .num_sample_times
= 4,
312 .sample_times
= (unsigned int []){ 28, 55, 110, 220 },
316 static inline long lm75_reg_to_mc(s16 temp
, u8 resolution
)
318 return ((temp
>> (16 - resolution
)) * 1000) >> (resolution
- 8);
321 static int lm75_write_config(struct lm75_data
*data
, u8 set_mask
,
326 clr_mask
|= LM75_SHUTDOWN
;
327 value
= data
->current_conf
& ~clr_mask
;
330 if (data
->current_conf
!= value
) {
333 err
= i2c_smbus_write_byte_data(data
->client
, LM75_REG_CONF
,
337 data
->current_conf
= value
;
342 static int lm75_read(struct device
*dev
, enum hwmon_sensor_types type
,
343 u32 attr
, int channel
, long *val
)
345 struct lm75_data
*data
= dev_get_drvdata(dev
);
352 case hwmon_chip_update_interval
:
353 *val
= data
->sample_time
;
361 case hwmon_temp_input
:
367 case hwmon_temp_max_hyst
:
373 err
= regmap_read(data
->regmap
, reg
, ®val
);
377 *val
= lm75_reg_to_mc(regval
, data
->resolution
);
385 static int lm75_write_temp(struct device
*dev
, u32 attr
, long temp
)
387 struct lm75_data
*data
= dev_get_drvdata(dev
);
395 case hwmon_temp_max_hyst
:
403 * Resolution of limit registers is assumed to be the same as the
404 * temperature input register resolution unless given explicitly.
406 if (data
->params
->resolution_limits
)
407 resolution
= data
->params
->resolution_limits
;
409 resolution
= data
->resolution
;
411 temp
= clamp_val(temp
, LM75_TEMP_MIN
, LM75_TEMP_MAX
);
412 temp
= DIV_ROUND_CLOSEST(temp
<< (resolution
- 8),
413 1000) << (16 - resolution
);
415 return regmap_write(data
->regmap
, reg
, (u16
)temp
);
418 static int lm75_update_interval(struct device
*dev
, long val
)
420 struct lm75_data
*data
= dev_get_drvdata(dev
);
425 index
= find_closest(val
, data
->params
->sample_times
,
426 (int)data
->params
->num_sample_times
);
428 switch (data
->kind
) {
430 err
= lm75_write_config(data
, lm75_sample_set_masks
[index
],
431 LM75_SAMPLE_CLEAR_MASK
);
435 data
->sample_time
= data
->params
->sample_times
[index
];
436 if (data
->params
->resolutions
)
437 data
->resolution
= data
->params
->resolutions
[index
];
440 err
= regmap_read(data
->regmap
, LM75_REG_CONF
, ®
);
444 reg
|= (3 - index
) << 6;
445 err
= regmap_write(data
->regmap
, LM75_REG_CONF
, reg
);
448 data
->sample_time
= data
->params
->sample_times
[index
];
451 err
= i2c_smbus_write_byte_data(data
->client
, PCT2075_REG_IDLE
,
455 data
->sample_time
= data
->params
->sample_times
[index
];
461 static int lm75_write_chip(struct device
*dev
, u32 attr
, long val
)
464 case hwmon_chip_update_interval
:
465 return lm75_update_interval(dev
, val
);
472 static int lm75_write(struct device
*dev
, enum hwmon_sensor_types type
,
473 u32 attr
, int channel
, long val
)
477 return lm75_write_chip(dev
, attr
, val
);
479 return lm75_write_temp(dev
, attr
, val
);
486 static umode_t
lm75_is_visible(const void *data
, enum hwmon_sensor_types type
,
487 u32 attr
, int channel
)
489 const struct lm75_data
*config_data
= data
;
494 case hwmon_chip_update_interval
:
495 if (config_data
->params
->num_sample_times
> 1)
502 case hwmon_temp_input
:
505 case hwmon_temp_max_hyst
:
515 static const struct hwmon_channel_info
* const lm75_info
[] = {
516 HWMON_CHANNEL_INFO(chip
,
517 HWMON_C_REGISTER_TZ
| HWMON_C_UPDATE_INTERVAL
),
518 HWMON_CHANNEL_INFO(temp
,
519 HWMON_T_INPUT
| HWMON_T_MAX
| HWMON_T_MAX_HYST
),
523 static const struct hwmon_ops lm75_hwmon_ops
= {
524 .is_visible
= lm75_is_visible
,
529 static const struct hwmon_chip_info lm75_chip_info
= {
530 .ops
= &lm75_hwmon_ops
,
534 static bool lm75_is_writeable_reg(struct device
*dev
, unsigned int reg
)
536 return reg
!= LM75_REG_TEMP
;
539 static bool lm75_is_volatile_reg(struct device
*dev
, unsigned int reg
)
541 return reg
== LM75_REG_TEMP
|| reg
== LM75_REG_CONF
;
544 static const struct regmap_config lm75_regmap_config
= {
547 .max_register
= PCT2075_REG_IDLE
,
548 .writeable_reg
= lm75_is_writeable_reg
,
549 .volatile_reg
= lm75_is_volatile_reg
,
550 .val_format_endian
= REGMAP_ENDIAN_BIG
,
551 .cache_type
= REGCACHE_MAPLE
,
552 .use_single_read
= true,
553 .use_single_write
= true,
556 static void lm75_disable_regulator(void *data
)
558 struct lm75_data
*lm75
= data
;
560 regulator_disable(lm75
->vs
);
563 static void lm75_remove(void *data
)
565 struct lm75_data
*lm75
= data
;
566 struct i2c_client
*client
= lm75
->client
;
568 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, lm75
->orig_conf
);
571 static const struct i2c_device_id lm75_ids
[];
573 static int lm75_probe(struct i2c_client
*client
)
575 struct device
*dev
= &client
->dev
;
576 struct device
*hwmon_dev
;
577 struct lm75_data
*data
;
581 if (client
->dev
.of_node
)
582 kind
= (enum lm75_type
)of_device_get_match_data(&client
->dev
);
584 kind
= i2c_match_id(lm75_ids
, client
)->driver_data
;
586 if (!i2c_check_functionality(client
->adapter
,
587 I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_WORD_DATA
))
590 data
= devm_kzalloc(dev
, sizeof(struct lm75_data
), GFP_KERNEL
);
594 data
->client
= client
;
597 data
->vs
= devm_regulator_get(dev
, "vs");
598 if (IS_ERR(data
->vs
))
599 return PTR_ERR(data
->vs
);
601 data
->regmap
= devm_regmap_init_i2c(client
, &lm75_regmap_config
);
602 if (IS_ERR(data
->regmap
))
603 return PTR_ERR(data
->regmap
);
605 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
606 * Then tweak to be more precise when appropriate.
609 data
->params
= &device_params
[data
->kind
];
611 /* Save default sample time and resolution*/
612 data
->sample_time
= data
->params
->default_sample_time
;
613 data
->resolution
= data
->params
->default_resolution
;
615 /* Enable the power */
616 err
= regulator_enable(data
->vs
);
618 dev_err(dev
, "failed to enable regulator: %d\n", err
);
622 err
= devm_add_action_or_reset(dev
, lm75_disable_regulator
, data
);
626 /* Cache original configuration */
627 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
629 dev_dbg(dev
, "Can't read config? %d\n", status
);
632 data
->orig_conf
= status
;
633 data
->current_conf
= status
;
635 err
= lm75_write_config(data
, data
->params
->set_mask
,
636 data
->params
->clr_mask
);
640 err
= devm_add_action_or_reset(dev
, lm75_remove
, data
);
644 hwmon_dev
= devm_hwmon_device_register_with_info(dev
, client
->name
,
645 data
, &lm75_chip_info
,
647 if (IS_ERR(hwmon_dev
))
648 return PTR_ERR(hwmon_dev
);
650 dev_info(dev
, "%s: sensor '%s'\n", dev_name(hwmon_dev
), client
->name
);
655 static const struct i2c_device_id lm75_ids
[] = {
657 { "at30ts74", at30ts74
, },
658 { "ds1775", ds1775
, },
660 { "ds7505", ds7505
, },
665 { "max6625", max6625
, },
666 { "max6626", max6626
, },
667 { "max31725", max31725
, },
668 { "max31726", max31725
, },
669 { "mcp980x", mcp980x
, },
670 { "pct2075", pct2075
, },
671 { "stds75", stds75
, },
672 { "stlm75", stlm75
, },
674 { "tmp100", tmp100
, },
675 { "tmp101", tmp101
, },
676 { "tmp105", tmp105
, },
677 { "tmp112", tmp112
, },
678 { "tmp175", tmp175
, },
679 { "tmp275", tmp275
, },
681 { "tmp75b", tmp75b
, },
682 { "tmp75c", tmp75c
, },
683 { "tmp1075", tmp1075
, },
686 MODULE_DEVICE_TABLE(i2c
, lm75_ids
);
688 static const struct of_device_id __maybe_unused lm75_of_match
[] = {
690 .compatible
= "adi,adt75",
691 .data
= (void *)adt75
694 .compatible
= "atmel,at30ts74",
695 .data
= (void *)at30ts74
698 .compatible
= "dallas,ds1775",
699 .data
= (void *)ds1775
702 .compatible
= "dallas,ds75",
706 .compatible
= "dallas,ds7505",
707 .data
= (void *)ds7505
710 .compatible
= "gmt,g751",
714 .compatible
= "national,lm75",
718 .compatible
= "national,lm75a",
719 .data
= (void *)lm75a
722 .compatible
= "national,lm75b",
723 .data
= (void *)lm75b
726 .compatible
= "maxim,max6625",
727 .data
= (void *)max6625
730 .compatible
= "maxim,max6626",
731 .data
= (void *)max6626
734 .compatible
= "maxim,max31725",
735 .data
= (void *)max31725
738 .compatible
= "maxim,max31726",
739 .data
= (void *)max31725
742 .compatible
= "maxim,mcp980x",
743 .data
= (void *)mcp980x
746 .compatible
= "nxp,pct2075",
747 .data
= (void *)pct2075
750 .compatible
= "st,stds75",
751 .data
= (void *)stds75
754 .compatible
= "st,stlm75",
755 .data
= (void *)stlm75
758 .compatible
= "microchip,tcn75",
759 .data
= (void *)tcn75
762 .compatible
= "ti,tmp100",
763 .data
= (void *)tmp100
766 .compatible
= "ti,tmp101",
767 .data
= (void *)tmp101
770 .compatible
= "ti,tmp105",
771 .data
= (void *)tmp105
774 .compatible
= "ti,tmp112",
775 .data
= (void *)tmp112
778 .compatible
= "ti,tmp175",
779 .data
= (void *)tmp175
782 .compatible
= "ti,tmp275",
783 .data
= (void *)tmp275
786 .compatible
= "ti,tmp75",
787 .data
= (void *)tmp75
790 .compatible
= "ti,tmp75b",
791 .data
= (void *)tmp75b
794 .compatible
= "ti,tmp75c",
795 .data
= (void *)tmp75c
798 .compatible
= "ti,tmp1075",
799 .data
= (void *)tmp1075
803 MODULE_DEVICE_TABLE(of
, lm75_of_match
);
805 #define LM75A_ID 0xA1
807 /* Return 0 if detection is successful, -ENODEV otherwise */
808 static int lm75_detect(struct i2c_client
*new_client
,
809 struct i2c_board_info
*info
)
811 struct i2c_adapter
*adapter
= new_client
->adapter
;
816 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
817 I2C_FUNC_SMBUS_WORD_DATA
))
821 * Now, we do the remaining detection. There is no identification-
822 * dedicated register so we have to rely on several tricks:
823 * unused bits, registers cycling over 8-address boundaries,
824 * addresses 0x04-0x07 returning the last read value.
825 * The cycling+unused addresses combination is not tested,
826 * since it would significantly slow the detection down and would
827 * hardly add any value.
829 * The National Semiconductor LM75A is different than earlier
830 * LM75s. It has an ID byte of 0xaX (where X is the chip
831 * revision, with 1 being the only revision in existence) in
832 * register 7, and unused registers return 0xff rather than the
835 * Note that this function only detects the original National
836 * Semiconductor LM75 and the LM75A. Clones from other vendors
837 * aren't detected, on purpose, because they are typically never
838 * found on PC hardware. They are found on embedded designs where
839 * they can be instantiated explicitly so detection is not needed.
840 * The absence of identification registers on all these clones
841 * would make their exhaustive detection very difficult and weak,
842 * and odds are that the driver would bind to unsupported devices.
846 conf
= i2c_smbus_read_byte_data(new_client
, 1);
850 /* First check for LM75A */
851 if (i2c_smbus_read_byte_data(new_client
, 7) == LM75A_ID
) {
853 * LM75A returns 0xff on unused registers so
854 * just to be sure we check for that too.
856 if (i2c_smbus_read_byte_data(new_client
, 4) != 0xff
857 || i2c_smbus_read_byte_data(new_client
, 5) != 0xff
858 || i2c_smbus_read_byte_data(new_client
, 6) != 0xff)
861 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
862 os
= i2c_smbus_read_byte_data(new_client
, 3);
863 } else { /* Traditional style LM75 detection */
864 /* Unused addresses */
865 hyst
= i2c_smbus_read_byte_data(new_client
, 2);
866 if (i2c_smbus_read_byte_data(new_client
, 4) != hyst
867 || i2c_smbus_read_byte_data(new_client
, 5) != hyst
868 || i2c_smbus_read_byte_data(new_client
, 6) != hyst
869 || i2c_smbus_read_byte_data(new_client
, 7) != hyst
)
871 os
= i2c_smbus_read_byte_data(new_client
, 3);
872 if (i2c_smbus_read_byte_data(new_client
, 4) != os
873 || i2c_smbus_read_byte_data(new_client
, 5) != os
874 || i2c_smbus_read_byte_data(new_client
, 6) != os
875 || i2c_smbus_read_byte_data(new_client
, 7) != os
)
879 * It is very unlikely that this is a LM75 if both
880 * hysteresis and temperature limit registers are 0.
882 if (hyst
== 0 && os
== 0)
885 /* Addresses cycling */
886 for (i
= 8; i
<= 248; i
+= 40) {
887 if (i2c_smbus_read_byte_data(new_client
, i
+ 1) != conf
888 || i2c_smbus_read_byte_data(new_client
, i
+ 2) != hyst
889 || i2c_smbus_read_byte_data(new_client
, i
+ 3) != os
)
891 if (is_lm75a
&& i2c_smbus_read_byte_data(new_client
, i
+ 7)
896 strscpy(info
->type
, is_lm75a
? "lm75a" : "lm75", I2C_NAME_SIZE
);
902 static int lm75_suspend(struct device
*dev
)
905 struct i2c_client
*client
= to_i2c_client(dev
);
907 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
909 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
912 status
= status
| LM75_SHUTDOWN
;
913 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
917 static int lm75_resume(struct device
*dev
)
920 struct i2c_client
*client
= to_i2c_client(dev
);
922 status
= i2c_smbus_read_byte_data(client
, LM75_REG_CONF
);
924 dev_dbg(&client
->dev
, "Can't read config? %d\n", status
);
927 status
= status
& ~LM75_SHUTDOWN
;
928 i2c_smbus_write_byte_data(client
, LM75_REG_CONF
, status
);
932 static const struct dev_pm_ops lm75_dev_pm_ops
= {
933 .suspend
= lm75_suspend
,
934 .resume
= lm75_resume
,
936 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
938 #define LM75_DEV_PM_OPS NULL
939 #endif /* CONFIG_PM */
941 static struct i2c_driver lm75_driver
= {
942 .class = I2C_CLASS_HWMON
,
945 .of_match_table
= of_match_ptr(lm75_of_match
),
946 .pm
= LM75_DEV_PM_OPS
,
949 .id_table
= lm75_ids
,
950 .detect
= lm75_detect
,
951 .address_list
= normal_i2c
,
954 module_i2c_driver(lm75_driver
);
956 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
957 MODULE_DESCRIPTION("LM75 driver");
958 MODULE_LICENSE("GPL");