2 * lm80.c - From lm_sensors, Linux kernel modules for hardware
4 * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 * and Philip Edelbrock <phil@netroedge.com>
7 * Ported to Linux 2.6 by Tiago Sousa <mirage@kaotik.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
34 /* Addresses to scan */
35 static const unsigned short normal_i2c
[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
36 0x2e, 0x2f, I2C_CLIENT_END
};
38 /* Insmod parameters */
39 I2C_CLIENT_INSMOD_1(lm80
);
41 /* Many LM80 constants specified below */
43 /* The LM80 registers */
44 #define LM80_REG_IN_MAX(nr) (0x2a + (nr) * 2)
45 #define LM80_REG_IN_MIN(nr) (0x2b + (nr) * 2)
46 #define LM80_REG_IN(nr) (0x20 + (nr))
48 #define LM80_REG_FAN1 0x28
49 #define LM80_REG_FAN2 0x29
50 #define LM80_REG_FAN_MIN(nr) (0x3b + (nr))
52 #define LM80_REG_TEMP 0x27
53 #define LM80_REG_TEMP_HOT_MAX 0x38
54 #define LM80_REG_TEMP_HOT_HYST 0x39
55 #define LM80_REG_TEMP_OS_MAX 0x3a
56 #define LM80_REG_TEMP_OS_HYST 0x3b
58 #define LM80_REG_CONFIG 0x00
59 #define LM80_REG_ALARM1 0x01
60 #define LM80_REG_ALARM2 0x02
61 #define LM80_REG_MASK1 0x03
62 #define LM80_REG_MASK2 0x04
63 #define LM80_REG_FANDIV 0x05
64 #define LM80_REG_RES 0x06
67 /* Conversions. Rounding and limit checking is only done on the TO_REG
68 variants. Note that you should be a bit careful with which arguments
69 these macros are called: arguments may be evaluated more than once.
70 Fixing this is just not worth it. */
72 #define IN_TO_REG(val) (SENSORS_LIMIT(((val)+5)/10,0,255))
73 #define IN_FROM_REG(val) ((val)*10)
75 static inline unsigned char FAN_TO_REG(unsigned rpm
, unsigned div
)
79 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
80 return SENSORS_LIMIT((1350000 + rpm
*div
/ 2) / (rpm
*div
), 1, 254);
83 #define FAN_FROM_REG(val,div) ((val)==0?-1:\
84 (val)==255?0:1350000/((div)*(val)))
86 static inline long TEMP_FROM_REG(u16 temp
)
92 res
= 625 * (long) temp
;
94 res
= ((long) temp
- 0x01000) * 625;
99 #define TEMP_LIMIT_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
101 #define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val)<0?\
102 ((val)-500)/1000:((val)+500)/1000,0,255)
104 #define DIV_FROM_REG(val) (1 << (val))
107 * Client data (each client gets its own)
111 struct device
*hwmon_dev
;
112 struct mutex update_lock
;
113 char valid
; /* !=0 if following fields are valid */
114 unsigned long last_updated
; /* In jiffies */
116 u8 in
[7]; /* Register value */
117 u8 in_max
[7]; /* Register value */
118 u8 in_min
[7]; /* Register value */
119 u8 fan
[2]; /* Register value */
120 u8 fan_min
[2]; /* Register value */
121 u8 fan_div
[2]; /* Register encoding, shifted right */
122 u16 temp
; /* Register values, shifted right */
123 u8 temp_hot_max
; /* Register value */
124 u8 temp_hot_hyst
; /* Register value */
125 u8 temp_os_max
; /* Register value */
126 u8 temp_os_hyst
; /* Register value */
127 u16 alarms
; /* Register encoding, combined */
131 * Functions declaration
134 static int lm80_probe(struct i2c_client
*client
,
135 const struct i2c_device_id
*id
);
136 static int lm80_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
137 static void lm80_init_client(struct i2c_client
*client
);
138 static int lm80_remove(struct i2c_client
*client
);
139 static struct lm80_data
*lm80_update_device(struct device
*dev
);
140 static int lm80_read_value(struct i2c_client
*client
, u8 reg
);
141 static int lm80_write_value(struct i2c_client
*client
, u8 reg
, u8 value
);
144 * Driver data (common to all clients)
147 static const struct i2c_device_id lm80_id
[] = {
151 MODULE_DEVICE_TABLE(i2c
, lm80_id
);
153 static struct i2c_driver lm80_driver
= {
154 .class = I2C_CLASS_HWMON
,
159 .remove
= lm80_remove
,
161 .detect
= lm80_detect
,
162 .address_list
= normal_i2c
,
169 #define show_in(suffix, value) \
170 static ssize_t show_in_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
172 int nr = to_sensor_dev_attr(attr)->index; \
173 struct lm80_data *data = lm80_update_device(dev); \
174 return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \
180 #define set_in(suffix, value, reg) \
181 static ssize_t set_in_##suffix(struct device *dev, struct device_attribute *attr, const char *buf, \
184 int nr = to_sensor_dev_attr(attr)->index; \
185 struct i2c_client *client = to_i2c_client(dev); \
186 struct lm80_data *data = i2c_get_clientdata(client); \
187 long val = simple_strtol(buf, NULL, 10); \
189 mutex_lock(&data->update_lock);\
190 data->value[nr] = IN_TO_REG(val); \
191 lm80_write_value(client, reg(nr), data->value[nr]); \
192 mutex_unlock(&data->update_lock);\
195 set_in(min
, in_min
, LM80_REG_IN_MIN
)
196 set_in(max
, in_max
, LM80_REG_IN_MAX
)
198 #define show_fan(suffix, value) \
199 static ssize_t show_fan_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
201 int nr = to_sensor_dev_attr(attr)->index; \
202 struct lm80_data *data = lm80_update_device(dev); \
203 return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \
204 DIV_FROM_REG(data->fan_div[nr]))); \
206 show_fan(min
, fan_min
)
209 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
212 int nr
= to_sensor_dev_attr(attr
)->index
;
213 struct lm80_data
*data
= lm80_update_device(dev
);
214 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
217 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
218 const char *buf
, size_t count
)
220 int nr
= to_sensor_dev_attr(attr
)->index
;
221 struct i2c_client
*client
= to_i2c_client(dev
);
222 struct lm80_data
*data
= i2c_get_clientdata(client
);
223 long val
= simple_strtoul(buf
, NULL
, 10);
225 mutex_lock(&data
->update_lock
);
226 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
227 lm80_write_value(client
, LM80_REG_FAN_MIN(nr
+ 1), data
->fan_min
[nr
]);
228 mutex_unlock(&data
->update_lock
);
232 /* Note: we save and restore the fan minimum here, because its value is
233 determined in part by the fan divisor. This follows the principle of
234 least surprise; the user doesn't expect the fan minimum to change just
235 because the divisor changed. */
236 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
237 const char *buf
, size_t count
)
239 int nr
= to_sensor_dev_attr(attr
)->index
;
240 struct i2c_client
*client
= to_i2c_client(dev
);
241 struct lm80_data
*data
= i2c_get_clientdata(client
);
242 unsigned long min
, val
= simple_strtoul(buf
, NULL
, 10);
246 mutex_lock(&data
->update_lock
);
247 min
= FAN_FROM_REG(data
->fan_min
[nr
],
248 DIV_FROM_REG(data
->fan_div
[nr
]));
251 case 1: data
->fan_div
[nr
] = 0; break;
252 case 2: data
->fan_div
[nr
] = 1; break;
253 case 4: data
->fan_div
[nr
] = 2; break;
254 case 8: data
->fan_div
[nr
] = 3; break;
256 dev_err(&client
->dev
, "fan_div value %ld not "
257 "supported. Choose one of 1, 2, 4 or 8!\n", val
);
258 mutex_unlock(&data
->update_lock
);
262 reg
= (lm80_read_value(client
, LM80_REG_FANDIV
) & ~(3 << (2 * (nr
+ 1))))
263 | (data
->fan_div
[nr
] << (2 * (nr
+ 1)));
264 lm80_write_value(client
, LM80_REG_FANDIV
, reg
);
266 /* Restore fan_min */
267 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
268 lm80_write_value(client
, LM80_REG_FAN_MIN(nr
+ 1), data
->fan_min
[nr
]);
269 mutex_unlock(&data
->update_lock
);
274 static ssize_t
show_temp_input1(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
276 struct lm80_data
*data
= lm80_update_device(dev
);
277 return sprintf(buf
, "%ld\n", TEMP_FROM_REG(data
->temp
));
280 #define show_temp(suffix, value) \
281 static ssize_t show_temp_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
283 struct lm80_data *data = lm80_update_device(dev); \
284 return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \
286 show_temp(hot_max
, temp_hot_max
);
287 show_temp(hot_hyst
, temp_hot_hyst
);
288 show_temp(os_max
, temp_os_max
);
289 show_temp(os_hyst
, temp_os_hyst
);
291 #define set_temp(suffix, value, reg) \
292 static ssize_t set_temp_##suffix(struct device *dev, struct device_attribute *attr, const char *buf, \
295 struct i2c_client *client = to_i2c_client(dev); \
296 struct lm80_data *data = i2c_get_clientdata(client); \
297 long val = simple_strtoul(buf, NULL, 10); \
299 mutex_lock(&data->update_lock); \
300 data->value = TEMP_LIMIT_TO_REG(val); \
301 lm80_write_value(client, reg, data->value); \
302 mutex_unlock(&data->update_lock); \
305 set_temp(hot_max
, temp_hot_max
, LM80_REG_TEMP_HOT_MAX
);
306 set_temp(hot_hyst
, temp_hot_hyst
, LM80_REG_TEMP_HOT_HYST
);
307 set_temp(os_max
, temp_os_max
, LM80_REG_TEMP_OS_MAX
);
308 set_temp(os_hyst
, temp_os_hyst
, LM80_REG_TEMP_OS_HYST
);
310 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
,
313 struct lm80_data
*data
= lm80_update_device(dev
);
314 return sprintf(buf
, "%u\n", data
->alarms
);
317 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*attr
,
320 int bitnr
= to_sensor_dev_attr(attr
)->index
;
321 struct lm80_data
*data
= lm80_update_device(dev
);
322 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
325 static SENSOR_DEVICE_ATTR(in0_min
, S_IWUSR
| S_IRUGO
,
326 show_in_min
, set_in_min
, 0);
327 static SENSOR_DEVICE_ATTR(in1_min
, S_IWUSR
| S_IRUGO
,
328 show_in_min
, set_in_min
, 1);
329 static SENSOR_DEVICE_ATTR(in2_min
, S_IWUSR
| S_IRUGO
,
330 show_in_min
, set_in_min
, 2);
331 static SENSOR_DEVICE_ATTR(in3_min
, S_IWUSR
| S_IRUGO
,
332 show_in_min
, set_in_min
, 3);
333 static SENSOR_DEVICE_ATTR(in4_min
, S_IWUSR
| S_IRUGO
,
334 show_in_min
, set_in_min
, 4);
335 static SENSOR_DEVICE_ATTR(in5_min
, S_IWUSR
| S_IRUGO
,
336 show_in_min
, set_in_min
, 5);
337 static SENSOR_DEVICE_ATTR(in6_min
, S_IWUSR
| S_IRUGO
,
338 show_in_min
, set_in_min
, 6);
339 static SENSOR_DEVICE_ATTR(in0_max
, S_IWUSR
| S_IRUGO
,
340 show_in_max
, set_in_max
, 0);
341 static SENSOR_DEVICE_ATTR(in1_max
, S_IWUSR
| S_IRUGO
,
342 show_in_max
, set_in_max
, 1);
343 static SENSOR_DEVICE_ATTR(in2_max
, S_IWUSR
| S_IRUGO
,
344 show_in_max
, set_in_max
, 2);
345 static SENSOR_DEVICE_ATTR(in3_max
, S_IWUSR
| S_IRUGO
,
346 show_in_max
, set_in_max
, 3);
347 static SENSOR_DEVICE_ATTR(in4_max
, S_IWUSR
| S_IRUGO
,
348 show_in_max
, set_in_max
, 4);
349 static SENSOR_DEVICE_ATTR(in5_max
, S_IWUSR
| S_IRUGO
,
350 show_in_max
, set_in_max
, 5);
351 static SENSOR_DEVICE_ATTR(in6_max
, S_IWUSR
| S_IRUGO
,
352 show_in_max
, set_in_max
, 6);
353 static SENSOR_DEVICE_ATTR(in0_input
, S_IRUGO
, show_in_input
, NULL
, 0);
354 static SENSOR_DEVICE_ATTR(in1_input
, S_IRUGO
, show_in_input
, NULL
, 1);
355 static SENSOR_DEVICE_ATTR(in2_input
, S_IRUGO
, show_in_input
, NULL
, 2);
356 static SENSOR_DEVICE_ATTR(in3_input
, S_IRUGO
, show_in_input
, NULL
, 3);
357 static SENSOR_DEVICE_ATTR(in4_input
, S_IRUGO
, show_in_input
, NULL
, 4);
358 static SENSOR_DEVICE_ATTR(in5_input
, S_IRUGO
, show_in_input
, NULL
, 5);
359 static SENSOR_DEVICE_ATTR(in6_input
, S_IRUGO
, show_in_input
, NULL
, 6);
360 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
,
361 show_fan_min
, set_fan_min
, 0);
362 static SENSOR_DEVICE_ATTR(fan2_min
, S_IWUSR
| S_IRUGO
,
363 show_fan_min
, set_fan_min
, 1);
364 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan_input
, NULL
, 0);
365 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan_input
, NULL
, 1);
366 static SENSOR_DEVICE_ATTR(fan1_div
, S_IWUSR
| S_IRUGO
,
367 show_fan_div
, set_fan_div
, 0);
368 static SENSOR_DEVICE_ATTR(fan2_div
, S_IWUSR
| S_IRUGO
,
369 show_fan_div
, set_fan_div
, 1);
370 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp_input1
, NULL
);
371 static DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp_hot_max
,
373 static DEVICE_ATTR(temp1_max_hyst
, S_IWUSR
| S_IRUGO
, show_temp_hot_hyst
,
375 static DEVICE_ATTR(temp1_crit
, S_IWUSR
| S_IRUGO
, show_temp_os_max
,
377 static DEVICE_ATTR(temp1_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp_os_hyst
,
379 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
380 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
381 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
382 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
383 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
384 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
385 static SENSOR_DEVICE_ATTR(in5_alarm
, S_IRUGO
, show_alarm
, NULL
, 5);
386 static SENSOR_DEVICE_ATTR(in6_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
387 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 10);
388 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
389 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
390 static SENSOR_DEVICE_ATTR(temp1_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 13);
396 static struct attribute
*lm80_attributes
[] = {
397 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
398 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
399 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
400 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
401 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
402 &sensor_dev_attr_in5_min
.dev_attr
.attr
,
403 &sensor_dev_attr_in6_min
.dev_attr
.attr
,
404 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
405 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
406 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
407 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
408 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
409 &sensor_dev_attr_in5_max
.dev_attr
.attr
,
410 &sensor_dev_attr_in6_max
.dev_attr
.attr
,
411 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
412 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
413 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
414 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
415 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
416 &sensor_dev_attr_in5_input
.dev_attr
.attr
,
417 &sensor_dev_attr_in6_input
.dev_attr
.attr
,
418 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
419 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
420 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
421 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
422 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
423 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
424 &dev_attr_temp1_input
.attr
,
425 &dev_attr_temp1_max
.attr
,
426 &dev_attr_temp1_max_hyst
.attr
,
427 &dev_attr_temp1_crit
.attr
,
428 &dev_attr_temp1_crit_hyst
.attr
,
429 &dev_attr_alarms
.attr
,
430 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
431 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
432 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
433 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
434 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
435 &sensor_dev_attr_in5_alarm
.dev_attr
.attr
,
436 &sensor_dev_attr_in6_alarm
.dev_attr
.attr
,
437 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
438 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
439 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
440 &sensor_dev_attr_temp1_crit_alarm
.dev_attr
.attr
,
444 static const struct attribute_group lm80_group
= {
445 .attrs
= lm80_attributes
,
448 /* Return 0 if detection is successful, -ENODEV otherwise */
449 static int lm80_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
451 struct i2c_adapter
*adapter
= client
->adapter
;
454 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
457 /* Now, we do the remaining detection. It is lousy. */
458 if (lm80_read_value(client
, LM80_REG_ALARM2
) & 0xc0)
460 for (i
= 0x2a; i
<= 0x3d; i
++) {
461 cur
= i2c_smbus_read_byte_data(client
, i
);
462 if ((i2c_smbus_read_byte_data(client
, i
+ 0x40) != cur
)
463 || (i2c_smbus_read_byte_data(client
, i
+ 0x80) != cur
)
464 || (i2c_smbus_read_byte_data(client
, i
+ 0xc0) != cur
))
468 strlcpy(info
->type
, "lm80", I2C_NAME_SIZE
);
473 static int lm80_probe(struct i2c_client
*client
,
474 const struct i2c_device_id
*id
)
476 struct lm80_data
*data
;
479 data
= kzalloc(sizeof(struct lm80_data
), GFP_KERNEL
);
485 i2c_set_clientdata(client
, data
);
486 mutex_init(&data
->update_lock
);
488 /* Initialize the LM80 chip */
489 lm80_init_client(client
);
491 /* A few vars need to be filled upon startup */
492 data
->fan_min
[0] = lm80_read_value(client
, LM80_REG_FAN_MIN(1));
493 data
->fan_min
[1] = lm80_read_value(client
, LM80_REG_FAN_MIN(2));
495 /* Register sysfs hooks */
496 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &lm80_group
)))
499 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
500 if (IS_ERR(data
->hwmon_dev
)) {
501 err
= PTR_ERR(data
->hwmon_dev
);
508 sysfs_remove_group(&client
->dev
.kobj
, &lm80_group
);
515 static int lm80_remove(struct i2c_client
*client
)
517 struct lm80_data
*data
= i2c_get_clientdata(client
);
519 hwmon_device_unregister(data
->hwmon_dev
);
520 sysfs_remove_group(&client
->dev
.kobj
, &lm80_group
);
526 static int lm80_read_value(struct i2c_client
*client
, u8 reg
)
528 return i2c_smbus_read_byte_data(client
, reg
);
531 static int lm80_write_value(struct i2c_client
*client
, u8 reg
, u8 value
)
533 return i2c_smbus_write_byte_data(client
, reg
, value
);
536 /* Called when we have found a new LM80. */
537 static void lm80_init_client(struct i2c_client
*client
)
539 /* Reset all except Watchdog values and last conversion values
540 This sets fan-divs to 2, among others. This makes most other
541 initializations unnecessary */
542 lm80_write_value(client
, LM80_REG_CONFIG
, 0x80);
543 /* Set 11-bit temperature resolution */
544 lm80_write_value(client
, LM80_REG_RES
, 0x08);
546 /* Start monitoring */
547 lm80_write_value(client
, LM80_REG_CONFIG
, 0x01);
550 static struct lm80_data
*lm80_update_device(struct device
*dev
)
552 struct i2c_client
*client
= to_i2c_client(dev
);
553 struct lm80_data
*data
= i2c_get_clientdata(client
);
556 mutex_lock(&data
->update_lock
);
558 if (time_after(jiffies
, data
->last_updated
+ 2 * HZ
) || !data
->valid
) {
559 dev_dbg(&client
->dev
, "Starting lm80 update\n");
560 for (i
= 0; i
<= 6; i
++) {
562 lm80_read_value(client
, LM80_REG_IN(i
));
564 lm80_read_value(client
, LM80_REG_IN_MIN(i
));
566 lm80_read_value(client
, LM80_REG_IN_MAX(i
));
568 data
->fan
[0] = lm80_read_value(client
, LM80_REG_FAN1
);
570 lm80_read_value(client
, LM80_REG_FAN_MIN(1));
571 data
->fan
[1] = lm80_read_value(client
, LM80_REG_FAN2
);
573 lm80_read_value(client
, LM80_REG_FAN_MIN(2));
576 (lm80_read_value(client
, LM80_REG_TEMP
) << 8) |
577 (lm80_read_value(client
, LM80_REG_RES
) & 0xf0);
579 lm80_read_value(client
, LM80_REG_TEMP_OS_MAX
);
581 lm80_read_value(client
, LM80_REG_TEMP_OS_HYST
);
583 lm80_read_value(client
, LM80_REG_TEMP_HOT_MAX
);
584 data
->temp_hot_hyst
=
585 lm80_read_value(client
, LM80_REG_TEMP_HOT_HYST
);
587 i
= lm80_read_value(client
, LM80_REG_FANDIV
);
588 data
->fan_div
[0] = (i
>> 2) & 0x03;
589 data
->fan_div
[1] = (i
>> 4) & 0x03;
590 data
->alarms
= lm80_read_value(client
, LM80_REG_ALARM1
) +
591 (lm80_read_value(client
, LM80_REG_ALARM2
) << 8);
592 data
->last_updated
= jiffies
;
596 mutex_unlock(&data
->update_lock
);
601 static int __init
sensors_lm80_init(void)
603 return i2c_add_driver(&lm80_driver
);
606 static void __exit
sensors_lm80_exit(void)
608 i2c_del_driver(&lm80_driver
);
611 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
612 "Philip Edelbrock <phil@netroedge.com>");
613 MODULE_DESCRIPTION("LM80 driver");
614 MODULE_LICENSE("GPL");
616 module_init(sensors_lm80_init
);
617 module_exit(sensors_lm80_exit
);