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 unsigned short normal_i2c
[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c,
36 0x2d, 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 i2c_client client
;
112 struct device
*hwmon_dev
;
113 struct mutex update_lock
;
114 char valid
; /* !=0 if following fields are valid */
115 unsigned long last_updated
; /* In jiffies */
117 u8 in
[7]; /* Register value */
118 u8 in_max
[7]; /* Register value */
119 u8 in_min
[7]; /* Register value */
120 u8 fan
[2]; /* Register value */
121 u8 fan_min
[2]; /* Register value */
122 u8 fan_div
[2]; /* Register encoding, shifted right */
123 u16 temp
; /* Register values, shifted right */
124 u8 temp_hot_max
; /* Register value */
125 u8 temp_hot_hyst
; /* Register value */
126 u8 temp_os_max
; /* Register value */
127 u8 temp_os_hyst
; /* Register value */
128 u16 alarms
; /* Register encoding, combined */
132 * Functions declaration
135 static int lm80_attach_adapter(struct i2c_adapter
*adapter
);
136 static int lm80_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
137 static void lm80_init_client(struct i2c_client
*client
);
138 static int lm80_detach_client(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 struct i2c_driver lm80_driver
= {
151 .attach_adapter
= lm80_attach_adapter
,
152 .detach_client
= lm80_detach_client
,
159 #define show_in(suffix, value) \
160 static ssize_t show_in_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
162 int nr = to_sensor_dev_attr(attr)->index; \
163 struct lm80_data *data = lm80_update_device(dev); \
164 return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \
170 #define set_in(suffix, value, reg) \
171 static ssize_t set_in_##suffix(struct device *dev, struct device_attribute *attr, const char *buf, \
174 int nr = to_sensor_dev_attr(attr)->index; \
175 struct i2c_client *client = to_i2c_client(dev); \
176 struct lm80_data *data = i2c_get_clientdata(client); \
177 long val = simple_strtol(buf, NULL, 10); \
179 mutex_lock(&data->update_lock);\
180 data->value[nr] = IN_TO_REG(val); \
181 lm80_write_value(client, reg(nr), data->value[nr]); \
182 mutex_unlock(&data->update_lock);\
185 set_in(min
, in_min
, LM80_REG_IN_MIN
)
186 set_in(max
, in_max
, LM80_REG_IN_MAX
)
188 #define show_fan(suffix, value) \
189 static ssize_t show_fan_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
191 int nr = to_sensor_dev_attr(attr)->index; \
192 struct lm80_data *data = lm80_update_device(dev); \
193 return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \
194 DIV_FROM_REG(data->fan_div[nr]))); \
196 show_fan(min
, fan_min
)
199 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*attr
,
202 int nr
= to_sensor_dev_attr(attr
)->index
;
203 struct lm80_data
*data
= lm80_update_device(dev
);
204 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
207 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
208 const char *buf
, size_t count
)
210 int nr
= to_sensor_dev_attr(attr
)->index
;
211 struct i2c_client
*client
= to_i2c_client(dev
);
212 struct lm80_data
*data
= i2c_get_clientdata(client
);
213 long val
= simple_strtoul(buf
, NULL
, 10);
215 mutex_lock(&data
->update_lock
);
216 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
217 lm80_write_value(client
, LM80_REG_FAN_MIN(nr
+ 1), data
->fan_min
[nr
]);
218 mutex_unlock(&data
->update_lock
);
222 /* Note: we save and restore the fan minimum here, because its value is
223 determined in part by the fan divisor. This follows the principle of
224 least surprise; the user doesn't expect the fan minimum to change just
225 because the divisor changed. */
226 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
227 const char *buf
, size_t count
)
229 int nr
= to_sensor_dev_attr(attr
)->index
;
230 struct i2c_client
*client
= to_i2c_client(dev
);
231 struct lm80_data
*data
= i2c_get_clientdata(client
);
232 unsigned long min
, val
= simple_strtoul(buf
, NULL
, 10);
236 mutex_lock(&data
->update_lock
);
237 min
= FAN_FROM_REG(data
->fan_min
[nr
],
238 DIV_FROM_REG(data
->fan_div
[nr
]));
241 case 1: data
->fan_div
[nr
] = 0; break;
242 case 2: data
->fan_div
[nr
] = 1; break;
243 case 4: data
->fan_div
[nr
] = 2; break;
244 case 8: data
->fan_div
[nr
] = 3; break;
246 dev_err(&client
->dev
, "fan_div value %ld not "
247 "supported. Choose one of 1, 2, 4 or 8!\n", val
);
248 mutex_unlock(&data
->update_lock
);
252 reg
= (lm80_read_value(client
, LM80_REG_FANDIV
) & ~(3 << (2 * (nr
+ 1))))
253 | (data
->fan_div
[nr
] << (2 * (nr
+ 1)));
254 lm80_write_value(client
, LM80_REG_FANDIV
, reg
);
256 /* Restore fan_min */
257 data
->fan_min
[nr
] = FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
258 lm80_write_value(client
, LM80_REG_FAN_MIN(nr
+ 1), data
->fan_min
[nr
]);
259 mutex_unlock(&data
->update_lock
);
264 static ssize_t
show_temp_input1(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
266 struct lm80_data
*data
= lm80_update_device(dev
);
267 return sprintf(buf
, "%ld\n", TEMP_FROM_REG(data
->temp
));
270 #define show_temp(suffix, value) \
271 static ssize_t show_temp_##suffix(struct device *dev, struct device_attribute *attr, char *buf) \
273 struct lm80_data *data = lm80_update_device(dev); \
274 return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \
276 show_temp(hot_max
, temp_hot_max
);
277 show_temp(hot_hyst
, temp_hot_hyst
);
278 show_temp(os_max
, temp_os_max
);
279 show_temp(os_hyst
, temp_os_hyst
);
281 #define set_temp(suffix, value, reg) \
282 static ssize_t set_temp_##suffix(struct device *dev, struct device_attribute *attr, const char *buf, \
285 struct i2c_client *client = to_i2c_client(dev); \
286 struct lm80_data *data = i2c_get_clientdata(client); \
287 long val = simple_strtoul(buf, NULL, 10); \
289 mutex_lock(&data->update_lock); \
290 data->value = TEMP_LIMIT_TO_REG(val); \
291 lm80_write_value(client, reg, data->value); \
292 mutex_unlock(&data->update_lock); \
295 set_temp(hot_max
, temp_hot_max
, LM80_REG_TEMP_HOT_MAX
);
296 set_temp(hot_hyst
, temp_hot_hyst
, LM80_REG_TEMP_HOT_HYST
);
297 set_temp(os_max
, temp_os_max
, LM80_REG_TEMP_OS_MAX
);
298 set_temp(os_hyst
, temp_os_hyst
, LM80_REG_TEMP_OS_HYST
);
300 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
,
303 struct lm80_data
*data
= lm80_update_device(dev
);
304 return sprintf(buf
, "%u\n", data
->alarms
);
307 static SENSOR_DEVICE_ATTR(in0_min
, S_IWUSR
| S_IRUGO
,
308 show_in_min
, set_in_min
, 0);
309 static SENSOR_DEVICE_ATTR(in1_min
, S_IWUSR
| S_IRUGO
,
310 show_in_min
, set_in_min
, 1);
311 static SENSOR_DEVICE_ATTR(in2_min
, S_IWUSR
| S_IRUGO
,
312 show_in_min
, set_in_min
, 2);
313 static SENSOR_DEVICE_ATTR(in3_min
, S_IWUSR
| S_IRUGO
,
314 show_in_min
, set_in_min
, 3);
315 static SENSOR_DEVICE_ATTR(in4_min
, S_IWUSR
| S_IRUGO
,
316 show_in_min
, set_in_min
, 4);
317 static SENSOR_DEVICE_ATTR(in5_min
, S_IWUSR
| S_IRUGO
,
318 show_in_min
, set_in_min
, 5);
319 static SENSOR_DEVICE_ATTR(in6_min
, S_IWUSR
| S_IRUGO
,
320 show_in_min
, set_in_min
, 6);
321 static SENSOR_DEVICE_ATTR(in0_max
, S_IWUSR
| S_IRUGO
,
322 show_in_max
, set_in_max
, 0);
323 static SENSOR_DEVICE_ATTR(in1_max
, S_IWUSR
| S_IRUGO
,
324 show_in_max
, set_in_max
, 1);
325 static SENSOR_DEVICE_ATTR(in2_max
, S_IWUSR
| S_IRUGO
,
326 show_in_max
, set_in_max
, 2);
327 static SENSOR_DEVICE_ATTR(in3_max
, S_IWUSR
| S_IRUGO
,
328 show_in_max
, set_in_max
, 3);
329 static SENSOR_DEVICE_ATTR(in4_max
, S_IWUSR
| S_IRUGO
,
330 show_in_max
, set_in_max
, 4);
331 static SENSOR_DEVICE_ATTR(in5_max
, S_IWUSR
| S_IRUGO
,
332 show_in_max
, set_in_max
, 5);
333 static SENSOR_DEVICE_ATTR(in6_max
, S_IWUSR
| S_IRUGO
,
334 show_in_max
, set_in_max
, 6);
335 static SENSOR_DEVICE_ATTR(in0_input
, S_IRUGO
, show_in_input
, NULL
, 0);
336 static SENSOR_DEVICE_ATTR(in1_input
, S_IRUGO
, show_in_input
, NULL
, 1);
337 static SENSOR_DEVICE_ATTR(in2_input
, S_IRUGO
, show_in_input
, NULL
, 2);
338 static SENSOR_DEVICE_ATTR(in3_input
, S_IRUGO
, show_in_input
, NULL
, 3);
339 static SENSOR_DEVICE_ATTR(in4_input
, S_IRUGO
, show_in_input
, NULL
, 4);
340 static SENSOR_DEVICE_ATTR(in5_input
, S_IRUGO
, show_in_input
, NULL
, 5);
341 static SENSOR_DEVICE_ATTR(in6_input
, S_IRUGO
, show_in_input
, NULL
, 6);
342 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
,
343 show_fan_min
, set_fan_min
, 0);
344 static SENSOR_DEVICE_ATTR(fan2_min
, S_IWUSR
| S_IRUGO
,
345 show_fan_min
, set_fan_min
, 1);
346 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan_input
, NULL
, 0);
347 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, show_fan_input
, NULL
, 1);
348 static SENSOR_DEVICE_ATTR(fan1_div
, S_IWUSR
| S_IRUGO
,
349 show_fan_div
, set_fan_div
, 0);
350 static SENSOR_DEVICE_ATTR(fan2_div
, S_IWUSR
| S_IRUGO
,
351 show_fan_div
, set_fan_div
, 1);
352 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp_input1
, NULL
);
353 static DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp_hot_max
,
355 static DEVICE_ATTR(temp1_max_hyst
, S_IWUSR
| S_IRUGO
, show_temp_hot_hyst
,
357 static DEVICE_ATTR(temp1_crit
, S_IWUSR
| S_IRUGO
, show_temp_os_max
,
359 static DEVICE_ATTR(temp1_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp_os_hyst
,
361 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
367 static int lm80_attach_adapter(struct i2c_adapter
*adapter
)
369 if (!(adapter
->class & I2C_CLASS_HWMON
))
371 return i2c_probe(adapter
, &addr_data
, lm80_detect
);
374 static struct attribute
*lm80_attributes
[] = {
375 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
376 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
377 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
378 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
379 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
380 &sensor_dev_attr_in5_min
.dev_attr
.attr
,
381 &sensor_dev_attr_in6_min
.dev_attr
.attr
,
382 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
383 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
384 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
385 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
386 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
387 &sensor_dev_attr_in5_max
.dev_attr
.attr
,
388 &sensor_dev_attr_in6_max
.dev_attr
.attr
,
389 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
390 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
391 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
392 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
393 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
394 &sensor_dev_attr_in5_input
.dev_attr
.attr
,
395 &sensor_dev_attr_in6_input
.dev_attr
.attr
,
396 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
397 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
398 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
399 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
400 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
401 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
402 &dev_attr_temp1_input
.attr
,
403 &dev_attr_temp1_max
.attr
,
404 &dev_attr_temp1_max_hyst
.attr
,
405 &dev_attr_temp1_crit
.attr
,
406 &dev_attr_temp1_crit_hyst
.attr
,
407 &dev_attr_alarms
.attr
,
412 static const struct attribute_group lm80_group
= {
413 .attrs
= lm80_attributes
,
416 static int lm80_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
419 struct i2c_client
*client
;
420 struct lm80_data
*data
;
424 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
427 /* OK. For now, we presume we have a valid client. We now create the
428 client structure, even though we cannot fill it completely yet.
429 But it allows us to access lm80_{read,write}_value. */
430 if (!(data
= kzalloc(sizeof(struct lm80_data
), GFP_KERNEL
))) {
435 client
= &data
->client
;
436 i2c_set_clientdata(client
, data
);
437 client
->addr
= address
;
438 client
->adapter
= adapter
;
439 client
->driver
= &lm80_driver
;
441 /* Now, we do the remaining detection. It is lousy. */
442 if (lm80_read_value(client
, LM80_REG_ALARM2
) & 0xc0)
444 for (i
= 0x2a; i
<= 0x3d; i
++) {
445 cur
= i2c_smbus_read_byte_data(client
, i
);
446 if ((i2c_smbus_read_byte_data(client
, i
+ 0x40) != cur
)
447 || (i2c_smbus_read_byte_data(client
, i
+ 0x80) != cur
)
448 || (i2c_smbus_read_byte_data(client
, i
+ 0xc0) != cur
))
452 /* Determine the chip type - only one kind supported! */
456 /* Fill in the remaining client fields */
457 strlcpy(client
->name
, name
, I2C_NAME_SIZE
);
458 mutex_init(&data
->update_lock
);
460 /* Tell the I2C layer a new client has arrived */
461 if ((err
= i2c_attach_client(client
)))
464 /* Initialize the LM80 chip */
465 lm80_init_client(client
);
467 /* A few vars need to be filled upon startup */
468 data
->fan_min
[0] = lm80_read_value(client
, LM80_REG_FAN_MIN(1));
469 data
->fan_min
[1] = lm80_read_value(client
, LM80_REG_FAN_MIN(2));
471 /* Register sysfs hooks */
472 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &lm80_group
)))
475 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
476 if (IS_ERR(data
->hwmon_dev
)) {
477 err
= PTR_ERR(data
->hwmon_dev
);
484 sysfs_remove_group(&client
->dev
.kobj
, &lm80_group
);
486 i2c_detach_client(client
);
493 static int lm80_detach_client(struct i2c_client
*client
)
495 struct lm80_data
*data
= i2c_get_clientdata(client
);
498 hwmon_device_unregister(data
->hwmon_dev
);
499 sysfs_remove_group(&client
->dev
.kobj
, &lm80_group
);
500 if ((err
= i2c_detach_client(client
)))
507 static int lm80_read_value(struct i2c_client
*client
, u8 reg
)
509 return i2c_smbus_read_byte_data(client
, reg
);
512 static int lm80_write_value(struct i2c_client
*client
, u8 reg
, u8 value
)
514 return i2c_smbus_write_byte_data(client
, reg
, value
);
517 /* Called when we have found a new LM80. */
518 static void lm80_init_client(struct i2c_client
*client
)
520 /* Reset all except Watchdog values and last conversion values
521 This sets fan-divs to 2, among others. This makes most other
522 initializations unnecessary */
523 lm80_write_value(client
, LM80_REG_CONFIG
, 0x80);
524 /* Set 11-bit temperature resolution */
525 lm80_write_value(client
, LM80_REG_RES
, 0x08);
527 /* Start monitoring */
528 lm80_write_value(client
, LM80_REG_CONFIG
, 0x01);
531 static struct lm80_data
*lm80_update_device(struct device
*dev
)
533 struct i2c_client
*client
= to_i2c_client(dev
);
534 struct lm80_data
*data
= i2c_get_clientdata(client
);
537 mutex_lock(&data
->update_lock
);
539 if (time_after(jiffies
, data
->last_updated
+ 2 * HZ
) || !data
->valid
) {
540 dev_dbg(&client
->dev
, "Starting lm80 update\n");
541 for (i
= 0; i
<= 6; i
++) {
543 lm80_read_value(client
, LM80_REG_IN(i
));
545 lm80_read_value(client
, LM80_REG_IN_MIN(i
));
547 lm80_read_value(client
, LM80_REG_IN_MAX(i
));
549 data
->fan
[0] = lm80_read_value(client
, LM80_REG_FAN1
);
551 lm80_read_value(client
, LM80_REG_FAN_MIN(1));
552 data
->fan
[1] = lm80_read_value(client
, LM80_REG_FAN2
);
554 lm80_read_value(client
, LM80_REG_FAN_MIN(2));
557 (lm80_read_value(client
, LM80_REG_TEMP
) << 8) |
558 (lm80_read_value(client
, LM80_REG_RES
) & 0xf0);
560 lm80_read_value(client
, LM80_REG_TEMP_OS_MAX
);
562 lm80_read_value(client
, LM80_REG_TEMP_OS_HYST
);
564 lm80_read_value(client
, LM80_REG_TEMP_HOT_MAX
);
565 data
->temp_hot_hyst
=
566 lm80_read_value(client
, LM80_REG_TEMP_HOT_HYST
);
568 i
= lm80_read_value(client
, LM80_REG_FANDIV
);
569 data
->fan_div
[0] = (i
>> 2) & 0x03;
570 data
->fan_div
[1] = (i
>> 4) & 0x03;
571 data
->alarms
= lm80_read_value(client
, LM80_REG_ALARM1
) +
572 (lm80_read_value(client
, LM80_REG_ALARM2
) << 8);
573 data
->last_updated
= jiffies
;
577 mutex_unlock(&data
->update_lock
);
582 static int __init
sensors_lm80_init(void)
584 return i2c_add_driver(&lm80_driver
);
587 static void __exit
sensors_lm80_exit(void)
589 i2c_del_driver(&lm80_driver
);
592 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
593 "Philip Edelbrock <phil@netroedge.com>");
594 MODULE_DESCRIPTION("LM80 driver");
595 MODULE_LICENSE("GPL");
597 module_init(sensors_lm80_init
);
598 module_exit(sensors_lm80_exit
);