2 * lm63.c - driver for the National Semiconductor LM63 temperature sensor
3 * with integrated fan control
4 * Copyright (C) 2004-2008 Jean Delvare <khali@linux-fr.org>
5 * Based on the lm90 driver.
7 * The LM63 is a sensor chip made by National Semiconductor. It measures
8 * two temperatures (its own and one external one) and the speed of one
9 * fan, those speed it can additionally control. Complete datasheet can be
10 * obtained from National's website at:
11 * http://www.national.com/pf/LM/LM63.html
13 * The LM63 is basically an LM86 with fan speed monitoring and control
14 * capabilities added. It misses some of the LM86 features though:
15 * - No low limit for local temperature.
16 * - No critical limit for local temperature.
17 * - Critical limit for remote temperature can be changed only once. We
18 * will consider that the critical limit is read-only.
20 * The datasheet isn't very clear about what the tachometer reading is.
21 * I had a explanation from National Semiconductor though. The two lower
22 * bits of the read value have to be masked out. The value is still 16 bit
25 * This program is free software; you can redistribute it and/or modify
26 * it under the terms of the GNU General Public License as published by
27 * the Free Software Foundation; either version 2 of the License, or
28 * (at your option) any later version.
30 * This program is distributed in the hope that it will be useful,
31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33 * GNU General Public License for more details.
35 * You should have received a copy of the GNU General Public License
36 * along with this program; if not, write to the Free Software
37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
40 #include <linux/module.h>
41 #include <linux/init.h>
42 #include <linux/slab.h>
43 #include <linux/jiffies.h>
44 #include <linux/i2c.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon.h>
47 #include <linux/err.h>
48 #include <linux/mutex.h>
49 #include <linux/sysfs.h>
53 * Address is fully defined internally and cannot be changed.
56 static const unsigned short normal_i2c
[] = { 0x4c, I2C_CLIENT_END
};
62 I2C_CLIENT_INSMOD_1(lm63
);
68 #define LM63_REG_CONFIG1 0x03
69 #define LM63_REG_CONFIG2 0xBF
70 #define LM63_REG_CONFIG_FAN 0x4A
72 #define LM63_REG_TACH_COUNT_MSB 0x47
73 #define LM63_REG_TACH_COUNT_LSB 0x46
74 #define LM63_REG_TACH_LIMIT_MSB 0x49
75 #define LM63_REG_TACH_LIMIT_LSB 0x48
77 #define LM63_REG_PWM_VALUE 0x4C
78 #define LM63_REG_PWM_FREQ 0x4D
80 #define LM63_REG_LOCAL_TEMP 0x00
81 #define LM63_REG_LOCAL_HIGH 0x05
83 #define LM63_REG_REMOTE_TEMP_MSB 0x01
84 #define LM63_REG_REMOTE_TEMP_LSB 0x10
85 #define LM63_REG_REMOTE_OFFSET_MSB 0x11
86 #define LM63_REG_REMOTE_OFFSET_LSB 0x12
87 #define LM63_REG_REMOTE_HIGH_MSB 0x07
88 #define LM63_REG_REMOTE_HIGH_LSB 0x13
89 #define LM63_REG_REMOTE_LOW_MSB 0x08
90 #define LM63_REG_REMOTE_LOW_LSB 0x14
91 #define LM63_REG_REMOTE_TCRIT 0x19
92 #define LM63_REG_REMOTE_TCRIT_HYST 0x21
94 #define LM63_REG_ALERT_STATUS 0x02
95 #define LM63_REG_ALERT_MASK 0x16
97 #define LM63_REG_MAN_ID 0xFE
98 #define LM63_REG_CHIP_ID 0xFF
101 * Conversions and various macros
102 * For tachometer counts, the LM63 uses 16-bit values.
103 * For local temperature and high limit, remote critical limit and hysteresis
104 * value, it uses signed 8-bit values with LSB = 1 degree Celsius.
105 * For remote temperature, low and high limits, it uses signed 11-bit values
106 * with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
109 #define FAN_FROM_REG(reg) ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
111 #define FAN_TO_REG(val) ((val) <= 82 ? 0xFFFC : \
112 (5400000 / (val)) & 0xFFFC)
113 #define TEMP8_FROM_REG(reg) ((reg) * 1000)
114 #define TEMP8_TO_REG(val) ((val) <= -128000 ? -128 : \
115 (val) >= 127000 ? 127 : \
116 (val) < 0 ? ((val) - 500) / 1000 : \
117 ((val) + 500) / 1000)
118 #define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
119 #define TEMP11_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
120 (val) >= 127875 ? 0x7FE0 : \
121 (val) < 0 ? ((val) - 62) / 125 * 32 : \
122 ((val) + 62) / 125 * 32)
123 #define HYST_TO_REG(val) ((val) <= 0 ? 0 : \
124 (val) >= 127000 ? 127 : \
125 ((val) + 500) / 1000)
128 * Functions declaration
131 static int lm63_probe(struct i2c_client
*client
,
132 const struct i2c_device_id
*id
);
133 static int lm63_remove(struct i2c_client
*client
);
135 static struct lm63_data
*lm63_update_device(struct device
*dev
);
137 static int lm63_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
138 static void lm63_init_client(struct i2c_client
*client
);
141 * Driver data (common to all clients)
144 static const struct i2c_device_id lm63_id
[] = {
148 MODULE_DEVICE_TABLE(i2c
, lm63_id
);
150 static struct i2c_driver lm63_driver
= {
151 .class = I2C_CLASS_HWMON
,
156 .remove
= lm63_remove
,
158 .detect
= lm63_detect
,
159 .address_list
= normal_i2c
,
163 * Client data (each client gets its own)
167 struct device
*hwmon_dev
;
168 struct mutex update_lock
;
169 char valid
; /* zero until following fields are valid */
170 unsigned long last_updated
; /* in jiffies */
172 /* registers values */
173 u8 config
, config_fan
;
174 u16 fan
[2]; /* 0: input
178 s8 temp8
[3]; /* 0: local input
180 2: remote critical limit */
181 s16 temp11
[3]; /* 0: remote input
183 2: remote high limit */
189 * Sysfs callback functions and files
192 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
195 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
196 struct lm63_data
*data
= lm63_update_device(dev
);
197 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[attr
->index
]));
200 static ssize_t
set_fan(struct device
*dev
, struct device_attribute
*dummy
,
201 const char *buf
, size_t count
)
203 struct i2c_client
*client
= to_i2c_client(dev
);
204 struct lm63_data
*data
= i2c_get_clientdata(client
);
205 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
207 mutex_lock(&data
->update_lock
);
208 data
->fan
[1] = FAN_TO_REG(val
);
209 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_LSB
,
210 data
->fan
[1] & 0xFF);
211 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_MSB
,
213 mutex_unlock(&data
->update_lock
);
217 static ssize_t
show_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
220 struct lm63_data
*data
= lm63_update_device(dev
);
221 return sprintf(buf
, "%d\n", data
->pwm1_value
>= 2 * data
->pwm1_freq
?
222 255 : (data
->pwm1_value
* 255 + data
->pwm1_freq
) /
223 (2 * data
->pwm1_freq
));
226 static ssize_t
set_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
227 const char *buf
, size_t count
)
229 struct i2c_client
*client
= to_i2c_client(dev
);
230 struct lm63_data
*data
= i2c_get_clientdata(client
);
233 if (!(data
->config_fan
& 0x20)) /* register is read-only */
236 val
= simple_strtoul(buf
, NULL
, 10);
237 mutex_lock(&data
->update_lock
);
238 data
->pwm1_value
= val
<= 0 ? 0 :
239 val
>= 255 ? 2 * data
->pwm1_freq
:
240 (val
* data
->pwm1_freq
* 2 + 127) / 255;
241 i2c_smbus_write_byte_data(client
, LM63_REG_PWM_VALUE
, data
->pwm1_value
);
242 mutex_unlock(&data
->update_lock
);
246 static ssize_t
show_pwm1_enable(struct device
*dev
, struct device_attribute
*dummy
,
249 struct lm63_data
*data
= lm63_update_device(dev
);
250 return sprintf(buf
, "%d\n", data
->config_fan
& 0x20 ? 1 : 2);
253 static ssize_t
show_temp8(struct device
*dev
, struct device_attribute
*devattr
,
256 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
257 struct lm63_data
*data
= lm63_update_device(dev
);
258 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[attr
->index
]));
261 static ssize_t
set_temp8(struct device
*dev
, struct device_attribute
*dummy
,
262 const char *buf
, size_t count
)
264 struct i2c_client
*client
= to_i2c_client(dev
);
265 struct lm63_data
*data
= i2c_get_clientdata(client
);
266 long val
= simple_strtol(buf
, NULL
, 10);
268 mutex_lock(&data
->update_lock
);
269 data
->temp8
[1] = TEMP8_TO_REG(val
);
270 i2c_smbus_write_byte_data(client
, LM63_REG_LOCAL_HIGH
, data
->temp8
[1]);
271 mutex_unlock(&data
->update_lock
);
275 static ssize_t
show_temp11(struct device
*dev
, struct device_attribute
*devattr
,
278 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
279 struct lm63_data
*data
= lm63_update_device(dev
);
280 return sprintf(buf
, "%d\n", TEMP11_FROM_REG(data
->temp11
[attr
->index
]));
283 static ssize_t
set_temp11(struct device
*dev
, struct device_attribute
*devattr
,
284 const char *buf
, size_t count
)
286 static const u8 reg
[4] = {
287 LM63_REG_REMOTE_LOW_MSB
,
288 LM63_REG_REMOTE_LOW_LSB
,
289 LM63_REG_REMOTE_HIGH_MSB
,
290 LM63_REG_REMOTE_HIGH_LSB
,
293 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
294 struct i2c_client
*client
= to_i2c_client(dev
);
295 struct lm63_data
*data
= i2c_get_clientdata(client
);
296 long val
= simple_strtol(buf
, NULL
, 10);
297 int nr
= attr
->index
;
299 mutex_lock(&data
->update_lock
);
300 data
->temp11
[nr
] = TEMP11_TO_REG(val
);
301 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2],
302 data
->temp11
[nr
] >> 8);
303 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2 + 1],
304 data
->temp11
[nr
] & 0xff);
305 mutex_unlock(&data
->update_lock
);
309 /* Hysteresis register holds a relative value, while we want to present
310 an absolute to user-space */
311 static ssize_t
show_temp2_crit_hyst(struct device
*dev
, struct device_attribute
*dummy
,
314 struct lm63_data
*data
= lm63_update_device(dev
);
315 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[2])
316 - TEMP8_FROM_REG(data
->temp2_crit_hyst
));
319 /* And now the other way around, user-space provides an absolute
320 hysteresis value and we have to store a relative one */
321 static ssize_t
set_temp2_crit_hyst(struct device
*dev
, struct device_attribute
*dummy
,
322 const char *buf
, size_t count
)
324 struct i2c_client
*client
= to_i2c_client(dev
);
325 struct lm63_data
*data
= i2c_get_clientdata(client
);
326 long val
= simple_strtol(buf
, NULL
, 10);
329 mutex_lock(&data
->update_lock
);
330 hyst
= TEMP8_FROM_REG(data
->temp8
[2]) - val
;
331 i2c_smbus_write_byte_data(client
, LM63_REG_REMOTE_TCRIT_HYST
,
333 mutex_unlock(&data
->update_lock
);
337 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*dummy
,
340 struct lm63_data
*data
= lm63_update_device(dev
);
341 return sprintf(buf
, "%u\n", data
->alarms
);
344 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*devattr
,
347 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
348 struct lm63_data
*data
= lm63_update_device(dev
);
349 int bitnr
= attr
->index
;
351 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
354 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
355 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
, show_fan
,
358 static DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm1
, set_pwm1
);
359 static DEVICE_ATTR(pwm1_enable
, S_IRUGO
, show_pwm1_enable
, NULL
);
361 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp8
, NULL
, 0);
362 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp8
,
365 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp11
, NULL
, 0);
366 static SENSOR_DEVICE_ATTR(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
368 static SENSOR_DEVICE_ATTR(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
370 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IRUGO
, show_temp8
, NULL
, 2);
371 static DEVICE_ATTR(temp2_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp2_crit_hyst
,
372 set_temp2_crit_hyst
);
374 /* Individual alarm files */
375 static SENSOR_DEVICE_ATTR(fan1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
376 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
377 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 2);
378 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
379 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
380 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
381 /* Raw alarm file for compatibility */
382 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
384 static struct attribute
*lm63_attributes
[] = {
386 &dev_attr_pwm1_enable
.attr
,
387 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
388 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
389 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
390 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
391 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
392 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
393 &dev_attr_temp2_crit_hyst
.attr
,
395 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
396 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
397 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
398 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
399 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
400 &dev_attr_alarms
.attr
,
404 static const struct attribute_group lm63_group
= {
405 .attrs
= lm63_attributes
,
408 static struct attribute
*lm63_attributes_fan1
[] = {
409 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
410 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
412 &sensor_dev_attr_fan1_min_alarm
.dev_attr
.attr
,
416 static const struct attribute_group lm63_group_fan1
= {
417 .attrs
= lm63_attributes_fan1
,
424 /* Return 0 if detection is successful, -ENODEV otherwise */
425 static int lm63_detect(struct i2c_client
*new_client
,
426 struct i2c_board_info
*info
)
428 struct i2c_adapter
*adapter
= new_client
->adapter
;
429 u8 man_id
, chip_id
, reg_config1
, reg_config2
;
430 u8 reg_alert_status
, reg_alert_mask
;
432 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
435 man_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_MAN_ID
);
436 chip_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_CHIP_ID
);
438 reg_config1
= i2c_smbus_read_byte_data(new_client
,
440 reg_config2
= i2c_smbus_read_byte_data(new_client
,
442 reg_alert_status
= i2c_smbus_read_byte_data(new_client
,
443 LM63_REG_ALERT_STATUS
);
444 reg_alert_mask
= i2c_smbus_read_byte_data(new_client
,
445 LM63_REG_ALERT_MASK
);
447 if (man_id
!= 0x01 /* National Semiconductor */
448 || chip_id
!= 0x41 /* LM63 */
449 || (reg_config1
& 0x18) != 0x00
450 || (reg_config2
& 0xF8) != 0x00
451 || (reg_alert_status
& 0x20) != 0x00
452 || (reg_alert_mask
& 0xA4) != 0xA4) {
453 dev_dbg(&adapter
->dev
,
454 "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
459 strlcpy(info
->type
, "lm63", I2C_NAME_SIZE
);
464 static int lm63_probe(struct i2c_client
*new_client
,
465 const struct i2c_device_id
*id
)
467 struct lm63_data
*data
;
470 data
= kzalloc(sizeof(struct lm63_data
), GFP_KERNEL
);
476 i2c_set_clientdata(new_client
, data
);
478 mutex_init(&data
->update_lock
);
480 /* Initialize the LM63 chip */
481 lm63_init_client(new_client
);
483 /* Register sysfs hooks */
484 if ((err
= sysfs_create_group(&new_client
->dev
.kobj
,
487 if (data
->config
& 0x04) { /* tachometer enabled */
488 if ((err
= sysfs_create_group(&new_client
->dev
.kobj
,
490 goto exit_remove_files
;
493 data
->hwmon_dev
= hwmon_device_register(&new_client
->dev
);
494 if (IS_ERR(data
->hwmon_dev
)) {
495 err
= PTR_ERR(data
->hwmon_dev
);
496 goto exit_remove_files
;
502 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group
);
503 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group_fan1
);
510 /* Idealy we shouldn't have to initialize anything, since the BIOS
511 should have taken care of everything */
512 static void lm63_init_client(struct i2c_client
*client
)
514 struct lm63_data
*data
= i2c_get_clientdata(client
);
516 data
->config
= i2c_smbus_read_byte_data(client
, LM63_REG_CONFIG1
);
517 data
->config_fan
= i2c_smbus_read_byte_data(client
,
518 LM63_REG_CONFIG_FAN
);
520 /* Start converting if needed */
521 if (data
->config
& 0x40) { /* standby */
522 dev_dbg(&client
->dev
, "Switching to operational mode\n");
523 data
->config
&= 0xA7;
524 i2c_smbus_write_byte_data(client
, LM63_REG_CONFIG1
,
528 /* We may need pwm1_freq before ever updating the client data */
529 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
, LM63_REG_PWM_FREQ
);
530 if (data
->pwm1_freq
== 0)
533 /* Show some debug info about the LM63 configuration */
534 dev_dbg(&client
->dev
, "Alert/tach pin configured for %s\n",
535 (data
->config
& 0x04) ? "tachometer input" :
537 dev_dbg(&client
->dev
, "PWM clock %s kHz, output frequency %u Hz\n",
538 (data
->config_fan
& 0x08) ? "1.4" : "360",
539 ((data
->config_fan
& 0x08) ? 700 : 180000) / data
->pwm1_freq
);
540 dev_dbg(&client
->dev
, "PWM output active %s, %s mode\n",
541 (data
->config_fan
& 0x10) ? "low" : "high",
542 (data
->config_fan
& 0x20) ? "manual" : "auto");
545 static int lm63_remove(struct i2c_client
*client
)
547 struct lm63_data
*data
= i2c_get_clientdata(client
);
549 hwmon_device_unregister(data
->hwmon_dev
);
550 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group
);
551 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group_fan1
);
557 static struct lm63_data
*lm63_update_device(struct device
*dev
)
559 struct i2c_client
*client
= to_i2c_client(dev
);
560 struct lm63_data
*data
= i2c_get_clientdata(client
);
562 mutex_lock(&data
->update_lock
);
564 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
565 if (data
->config
& 0x04) { /* tachometer enabled */
566 /* order matters for fan1_input */
567 data
->fan
[0] = i2c_smbus_read_byte_data(client
,
568 LM63_REG_TACH_COUNT_LSB
) & 0xFC;
569 data
->fan
[0] |= i2c_smbus_read_byte_data(client
,
570 LM63_REG_TACH_COUNT_MSB
) << 8;
571 data
->fan
[1] = (i2c_smbus_read_byte_data(client
,
572 LM63_REG_TACH_LIMIT_LSB
) & 0xFC)
573 | (i2c_smbus_read_byte_data(client
,
574 LM63_REG_TACH_LIMIT_MSB
) << 8);
577 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
,
579 if (data
->pwm1_freq
== 0)
581 data
->pwm1_value
= i2c_smbus_read_byte_data(client
,
584 data
->temp8
[0] = i2c_smbus_read_byte_data(client
,
585 LM63_REG_LOCAL_TEMP
);
586 data
->temp8
[1] = i2c_smbus_read_byte_data(client
,
587 LM63_REG_LOCAL_HIGH
);
589 /* order matters for temp2_input */
590 data
->temp11
[0] = i2c_smbus_read_byte_data(client
,
591 LM63_REG_REMOTE_TEMP_MSB
) << 8;
592 data
->temp11
[0] |= i2c_smbus_read_byte_data(client
,
593 LM63_REG_REMOTE_TEMP_LSB
);
594 data
->temp11
[1] = (i2c_smbus_read_byte_data(client
,
595 LM63_REG_REMOTE_LOW_MSB
) << 8)
596 | i2c_smbus_read_byte_data(client
,
597 LM63_REG_REMOTE_LOW_LSB
);
598 data
->temp11
[2] = (i2c_smbus_read_byte_data(client
,
599 LM63_REG_REMOTE_HIGH_MSB
) << 8)
600 | i2c_smbus_read_byte_data(client
,
601 LM63_REG_REMOTE_HIGH_LSB
);
602 data
->temp8
[2] = i2c_smbus_read_byte_data(client
,
603 LM63_REG_REMOTE_TCRIT
);
604 data
->temp2_crit_hyst
= i2c_smbus_read_byte_data(client
,
605 LM63_REG_REMOTE_TCRIT_HYST
);
607 data
->alarms
= i2c_smbus_read_byte_data(client
,
608 LM63_REG_ALERT_STATUS
) & 0x7F;
610 data
->last_updated
= jiffies
;
614 mutex_unlock(&data
->update_lock
);
619 static int __init
sensors_lm63_init(void)
621 return i2c_add_driver(&lm63_driver
);
624 static void __exit
sensors_lm63_exit(void)
626 i2c_del_driver(&lm63_driver
);
629 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
630 MODULE_DESCRIPTION("LM63 driver");
631 MODULE_LICENSE("GPL");
633 module_init(sensors_lm63_init
);
634 module_exit(sensors_lm63_exit
);