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
[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END
};
62 #define LM63_REG_CONFIG1 0x03
63 #define LM63_REG_CONFIG2 0xBF
64 #define LM63_REG_CONFIG_FAN 0x4A
66 #define LM63_REG_TACH_COUNT_MSB 0x47
67 #define LM63_REG_TACH_COUNT_LSB 0x46
68 #define LM63_REG_TACH_LIMIT_MSB 0x49
69 #define LM63_REG_TACH_LIMIT_LSB 0x48
71 #define LM63_REG_PWM_VALUE 0x4C
72 #define LM63_REG_PWM_FREQ 0x4D
74 #define LM63_REG_LOCAL_TEMP 0x00
75 #define LM63_REG_LOCAL_HIGH 0x05
77 #define LM63_REG_REMOTE_TEMP_MSB 0x01
78 #define LM63_REG_REMOTE_TEMP_LSB 0x10
79 #define LM63_REG_REMOTE_OFFSET_MSB 0x11
80 #define LM63_REG_REMOTE_OFFSET_LSB 0x12
81 #define LM63_REG_REMOTE_HIGH_MSB 0x07
82 #define LM63_REG_REMOTE_HIGH_LSB 0x13
83 #define LM63_REG_REMOTE_LOW_MSB 0x08
84 #define LM63_REG_REMOTE_LOW_LSB 0x14
85 #define LM63_REG_REMOTE_TCRIT 0x19
86 #define LM63_REG_REMOTE_TCRIT_HYST 0x21
88 #define LM63_REG_ALERT_STATUS 0x02
89 #define LM63_REG_ALERT_MASK 0x16
91 #define LM63_REG_MAN_ID 0xFE
92 #define LM63_REG_CHIP_ID 0xFF
95 * Conversions and various macros
96 * For tachometer counts, the LM63 uses 16-bit values.
97 * For local temperature and high limit, remote critical limit and hysteresis
98 * value, it uses signed 8-bit values with LSB = 1 degree Celsius.
99 * For remote temperature, low and high limits, it uses signed 11-bit values
100 * with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
101 * For LM64 the actual remote diode temperature is 16 degree Celsius higher
102 * than the register reading. Remote temperature setpoints have to be
103 * adapted accordingly.
106 #define FAN_FROM_REG(reg) ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
108 #define FAN_TO_REG(val) ((val) <= 82 ? 0xFFFC : \
109 (5400000 / (val)) & 0xFFFC)
110 #define TEMP8_FROM_REG(reg) ((reg) * 1000)
111 #define TEMP8_TO_REG(val) ((val) <= -128000 ? -128 : \
112 (val) >= 127000 ? 127 : \
113 (val) < 0 ? ((val) - 500) / 1000 : \
114 ((val) + 500) / 1000)
115 #define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
116 #define TEMP11_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
117 (val) >= 127875 ? 0x7FE0 : \
118 (val) < 0 ? ((val) - 62) / 125 * 32 : \
119 ((val) + 62) / 125 * 32)
120 #define HYST_TO_REG(val) ((val) <= 0 ? 0 : \
121 (val) >= 127000 ? 127 : \
122 ((val) + 500) / 1000)
125 * Functions declaration
128 static int lm63_probe(struct i2c_client
*client
,
129 const struct i2c_device_id
*id
);
130 static int lm63_remove(struct i2c_client
*client
);
132 static struct lm63_data
*lm63_update_device(struct device
*dev
);
134 static int lm63_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
135 static void lm63_init_client(struct i2c_client
*client
);
137 enum chips
{ lm63
, lm64
};
140 * Driver data (common to all clients)
143 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 */
174 /* registers values */
175 u8 config
, config_fan
;
176 u16 fan
[2]; /* 0: input
180 s8 temp8
[3]; /* 0: local input
182 2: remote critical limit */
183 s16 temp11
[4]; /* 0: remote input
192 * Sysfs callback functions and files
195 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
198 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
199 struct lm63_data
*data
= lm63_update_device(dev
);
200 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[attr
->index
]));
203 static ssize_t
set_fan(struct device
*dev
, struct device_attribute
*dummy
,
204 const char *buf
, size_t count
)
206 struct i2c_client
*client
= to_i2c_client(dev
);
207 struct lm63_data
*data
= i2c_get_clientdata(client
);
211 err
= kstrtoul(buf
, 10, &val
);
215 mutex_lock(&data
->update_lock
);
216 data
->fan
[1] = FAN_TO_REG(val
);
217 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_LSB
,
218 data
->fan
[1] & 0xFF);
219 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_MSB
,
221 mutex_unlock(&data
->update_lock
);
225 static ssize_t
show_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
228 struct lm63_data
*data
= lm63_update_device(dev
);
229 return sprintf(buf
, "%d\n", data
->pwm1_value
>= 2 * data
->pwm1_freq
?
230 255 : (data
->pwm1_value
* 255 + data
->pwm1_freq
) /
231 (2 * data
->pwm1_freq
));
234 static ssize_t
set_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
235 const char *buf
, size_t count
)
237 struct i2c_client
*client
= to_i2c_client(dev
);
238 struct lm63_data
*data
= i2c_get_clientdata(client
);
242 if (!(data
->config_fan
& 0x20)) /* register is read-only */
245 err
= kstrtoul(buf
, 10, &val
);
249 mutex_lock(&data
->update_lock
);
250 data
->pwm1_value
= val
<= 0 ? 0 :
251 val
>= 255 ? 2 * data
->pwm1_freq
:
252 (val
* data
->pwm1_freq
* 2 + 127) / 255;
253 i2c_smbus_write_byte_data(client
, LM63_REG_PWM_VALUE
, data
->pwm1_value
);
254 mutex_unlock(&data
->update_lock
);
258 static ssize_t
show_pwm1_enable(struct device
*dev
,
259 struct device_attribute
*dummy
, char *buf
)
261 struct lm63_data
*data
= lm63_update_device(dev
);
262 return sprintf(buf
, "%d\n", data
->config_fan
& 0x20 ? 1 : 2);
266 * There are 8bit registers for both local(temp1) and remote(temp2) sensor.
267 * For remote sensor registers temp2_offset has to be considered,
268 * for local sensor it must not.
269 * So we need separate 8bit accessors for local and remote sensor.
271 static ssize_t
show_local_temp8(struct device
*dev
,
272 struct device_attribute
*devattr
,
275 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
276 struct lm63_data
*data
= lm63_update_device(dev
);
277 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[attr
->index
]));
280 static ssize_t
show_remote_temp8(struct device
*dev
,
281 struct device_attribute
*devattr
,
284 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
285 struct lm63_data
*data
= lm63_update_device(dev
);
286 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[attr
->index
])
287 + data
->temp2_offset
);
290 static ssize_t
set_local_temp8(struct device
*dev
,
291 struct device_attribute
*dummy
,
292 const char *buf
, size_t count
)
294 struct i2c_client
*client
= to_i2c_client(dev
);
295 struct lm63_data
*data
= i2c_get_clientdata(client
);
299 err
= kstrtol(buf
, 10, &val
);
303 mutex_lock(&data
->update_lock
);
304 data
->temp8
[1] = TEMP8_TO_REG(val
);
305 i2c_smbus_write_byte_data(client
, LM63_REG_LOCAL_HIGH
, data
->temp8
[1]);
306 mutex_unlock(&data
->update_lock
);
310 static ssize_t
show_temp11(struct device
*dev
, struct device_attribute
*devattr
,
313 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
314 struct lm63_data
*data
= lm63_update_device(dev
);
315 return sprintf(buf
, "%d\n", TEMP11_FROM_REG(data
->temp11
[attr
->index
])
316 + data
->temp2_offset
);
319 static ssize_t
set_temp11(struct device
*dev
, struct device_attribute
*devattr
,
320 const char *buf
, size_t count
)
322 static const u8 reg
[6] = {
323 LM63_REG_REMOTE_LOW_MSB
,
324 LM63_REG_REMOTE_LOW_LSB
,
325 LM63_REG_REMOTE_HIGH_MSB
,
326 LM63_REG_REMOTE_HIGH_LSB
,
327 LM63_REG_REMOTE_OFFSET_MSB
,
328 LM63_REG_REMOTE_OFFSET_LSB
,
331 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
332 struct i2c_client
*client
= to_i2c_client(dev
);
333 struct lm63_data
*data
= i2c_get_clientdata(client
);
336 int nr
= attr
->index
;
338 err
= kstrtol(buf
, 10, &val
);
342 mutex_lock(&data
->update_lock
);
343 data
->temp11
[nr
] = TEMP11_TO_REG(val
- data
->temp2_offset
);
344 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2],
345 data
->temp11
[nr
] >> 8);
346 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2 + 1],
347 data
->temp11
[nr
] & 0xff);
348 mutex_unlock(&data
->update_lock
);
353 * Hysteresis register holds a relative value, while we want to present
354 * an absolute to user-space
356 static ssize_t
show_temp2_crit_hyst(struct device
*dev
,
357 struct device_attribute
*dummy
, char *buf
)
359 struct lm63_data
*data
= lm63_update_device(dev
);
360 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[2])
362 - TEMP8_FROM_REG(data
->temp2_crit_hyst
));
366 * And now the other way around, user-space provides an absolute
367 * hysteresis value and we have to store a relative one
369 static ssize_t
set_temp2_crit_hyst(struct device
*dev
,
370 struct device_attribute
*dummy
,
371 const char *buf
, size_t count
)
373 struct i2c_client
*client
= to_i2c_client(dev
);
374 struct lm63_data
*data
= i2c_get_clientdata(client
);
379 err
= kstrtol(buf
, 10, &val
);
383 mutex_lock(&data
->update_lock
);
384 hyst
= TEMP8_FROM_REG(data
->temp8
[2]) + data
->temp2_offset
- val
;
385 i2c_smbus_write_byte_data(client
, LM63_REG_REMOTE_TCRIT_HYST
,
387 mutex_unlock(&data
->update_lock
);
391 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*dummy
,
394 struct lm63_data
*data
= lm63_update_device(dev
);
395 return sprintf(buf
, "%u\n", data
->alarms
);
398 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*devattr
,
401 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
402 struct lm63_data
*data
= lm63_update_device(dev
);
403 int bitnr
= attr
->index
;
405 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
408 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
409 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
, show_fan
,
412 static DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm1
, set_pwm1
);
413 static DEVICE_ATTR(pwm1_enable
, S_IRUGO
, show_pwm1_enable
, NULL
);
415 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_local_temp8
, NULL
, 0);
416 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_local_temp8
,
419 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp11
, NULL
, 0);
420 static SENSOR_DEVICE_ATTR(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
422 static SENSOR_DEVICE_ATTR(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
424 static SENSOR_DEVICE_ATTR(temp2_offset
, S_IWUSR
| S_IRUGO
, show_temp11
,
427 * On LM63, temp2_crit can be set only once, which should be job
430 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IRUGO
, show_remote_temp8
,
432 static DEVICE_ATTR(temp2_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp2_crit_hyst
,
433 set_temp2_crit_hyst
);
435 /* Individual alarm files */
436 static SENSOR_DEVICE_ATTR(fan1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
437 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
438 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 2);
439 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
440 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
441 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
442 /* Raw alarm file for compatibility */
443 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
445 static struct attribute
*lm63_attributes
[] = {
447 &dev_attr_pwm1_enable
.attr
,
448 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
449 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
450 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
451 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
452 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
453 &sensor_dev_attr_temp2_offset
.dev_attr
.attr
,
454 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
455 &dev_attr_temp2_crit_hyst
.attr
,
457 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
458 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
459 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
460 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
461 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
462 &dev_attr_alarms
.attr
,
466 static const struct attribute_group lm63_group
= {
467 .attrs
= lm63_attributes
,
470 static struct attribute
*lm63_attributes_fan1
[] = {
471 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
472 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
474 &sensor_dev_attr_fan1_min_alarm
.dev_attr
.attr
,
478 static const struct attribute_group lm63_group_fan1
= {
479 .attrs
= lm63_attributes_fan1
,
486 /* Return 0 if detection is successful, -ENODEV otherwise */
487 static int lm63_detect(struct i2c_client
*new_client
,
488 struct i2c_board_info
*info
)
490 struct i2c_adapter
*adapter
= new_client
->adapter
;
491 u8 man_id
, chip_id
, reg_config1
, reg_config2
;
492 u8 reg_alert_status
, reg_alert_mask
;
493 int address
= new_client
->addr
;
495 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
498 man_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_MAN_ID
);
499 chip_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_CHIP_ID
);
501 reg_config1
= i2c_smbus_read_byte_data(new_client
,
503 reg_config2
= i2c_smbus_read_byte_data(new_client
,
505 reg_alert_status
= i2c_smbus_read_byte_data(new_client
,
506 LM63_REG_ALERT_STATUS
);
507 reg_alert_mask
= i2c_smbus_read_byte_data(new_client
,
508 LM63_REG_ALERT_MASK
);
510 if (man_id
!= 0x01 /* National Semiconductor */
511 || (reg_config1
& 0x18) != 0x00
512 || (reg_config2
& 0xF8) != 0x00
513 || (reg_alert_status
& 0x20) != 0x00
514 || (reg_alert_mask
& 0xA4) != 0xA4) {
515 dev_dbg(&adapter
->dev
,
516 "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
521 if (chip_id
== 0x41 && address
== 0x4c)
522 strlcpy(info
->type
, "lm63", I2C_NAME_SIZE
);
523 else if (chip_id
== 0x51 && (address
== 0x18 || address
== 0x4e))
524 strlcpy(info
->type
, "lm64", I2C_NAME_SIZE
);
531 static int lm63_probe(struct i2c_client
*new_client
,
532 const struct i2c_device_id
*id
)
534 struct lm63_data
*data
;
537 data
= kzalloc(sizeof(struct lm63_data
), GFP_KERNEL
);
543 i2c_set_clientdata(new_client
, data
);
545 mutex_init(&data
->update_lock
);
547 /* Set the device type */
548 data
->kind
= id
->driver_data
;
549 if (data
->kind
== lm64
)
550 data
->temp2_offset
= 16000;
552 /* Initialize chip */
553 lm63_init_client(new_client
);
555 /* Register sysfs hooks */
556 err
= sysfs_create_group(&new_client
->dev
.kobj
, &lm63_group
);
559 if (data
->config
& 0x04) { /* tachometer enabled */
560 err
= sysfs_create_group(&new_client
->dev
.kobj
,
563 goto exit_remove_files
;
566 data
->hwmon_dev
= hwmon_device_register(&new_client
->dev
);
567 if (IS_ERR(data
->hwmon_dev
)) {
568 err
= PTR_ERR(data
->hwmon_dev
);
569 goto exit_remove_files
;
575 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group
);
576 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group_fan1
);
584 * Ideally we shouldn't have to initialize anything, since the BIOS
585 * should have taken care of everything
587 static void lm63_init_client(struct i2c_client
*client
)
589 struct lm63_data
*data
= i2c_get_clientdata(client
);
591 data
->config
= i2c_smbus_read_byte_data(client
, LM63_REG_CONFIG1
);
592 data
->config_fan
= i2c_smbus_read_byte_data(client
,
593 LM63_REG_CONFIG_FAN
);
595 /* Start converting if needed */
596 if (data
->config
& 0x40) { /* standby */
597 dev_dbg(&client
->dev
, "Switching to operational mode\n");
598 data
->config
&= 0xA7;
599 i2c_smbus_write_byte_data(client
, LM63_REG_CONFIG1
,
603 /* We may need pwm1_freq before ever updating the client data */
604 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
, LM63_REG_PWM_FREQ
);
605 if (data
->pwm1_freq
== 0)
608 /* Show some debug info about the LM63 configuration */
609 dev_dbg(&client
->dev
, "Alert/tach pin configured for %s\n",
610 (data
->config
& 0x04) ? "tachometer input" :
612 dev_dbg(&client
->dev
, "PWM clock %s kHz, output frequency %u Hz\n",
613 (data
->config_fan
& 0x08) ? "1.4" : "360",
614 ((data
->config_fan
& 0x08) ? 700 : 180000) / data
->pwm1_freq
);
615 dev_dbg(&client
->dev
, "PWM output active %s, %s mode\n",
616 (data
->config_fan
& 0x10) ? "low" : "high",
617 (data
->config_fan
& 0x20) ? "manual" : "auto");
620 static int lm63_remove(struct i2c_client
*client
)
622 struct lm63_data
*data
= i2c_get_clientdata(client
);
624 hwmon_device_unregister(data
->hwmon_dev
);
625 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group
);
626 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group_fan1
);
632 static struct lm63_data
*lm63_update_device(struct device
*dev
)
634 struct i2c_client
*client
= to_i2c_client(dev
);
635 struct lm63_data
*data
= i2c_get_clientdata(client
);
637 mutex_lock(&data
->update_lock
);
639 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
640 if (data
->config
& 0x04) { /* tachometer enabled */
641 /* order matters for fan1_input */
642 data
->fan
[0] = i2c_smbus_read_byte_data(client
,
643 LM63_REG_TACH_COUNT_LSB
) & 0xFC;
644 data
->fan
[0] |= i2c_smbus_read_byte_data(client
,
645 LM63_REG_TACH_COUNT_MSB
) << 8;
646 data
->fan
[1] = (i2c_smbus_read_byte_data(client
,
647 LM63_REG_TACH_LIMIT_LSB
) & 0xFC)
648 | (i2c_smbus_read_byte_data(client
,
649 LM63_REG_TACH_LIMIT_MSB
) << 8);
652 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
,
654 if (data
->pwm1_freq
== 0)
656 data
->pwm1_value
= i2c_smbus_read_byte_data(client
,
659 data
->temp8
[0] = i2c_smbus_read_byte_data(client
,
660 LM63_REG_LOCAL_TEMP
);
661 data
->temp8
[1] = i2c_smbus_read_byte_data(client
,
662 LM63_REG_LOCAL_HIGH
);
664 /* order matters for temp2_input */
665 data
->temp11
[0] = i2c_smbus_read_byte_data(client
,
666 LM63_REG_REMOTE_TEMP_MSB
) << 8;
667 data
->temp11
[0] |= i2c_smbus_read_byte_data(client
,
668 LM63_REG_REMOTE_TEMP_LSB
);
669 data
->temp11
[1] = (i2c_smbus_read_byte_data(client
,
670 LM63_REG_REMOTE_LOW_MSB
) << 8)
671 | i2c_smbus_read_byte_data(client
,
672 LM63_REG_REMOTE_LOW_LSB
);
673 data
->temp11
[2] = (i2c_smbus_read_byte_data(client
,
674 LM63_REG_REMOTE_HIGH_MSB
) << 8)
675 | i2c_smbus_read_byte_data(client
,
676 LM63_REG_REMOTE_HIGH_LSB
);
677 data
->temp11
[3] = (i2c_smbus_read_byte_data(client
,
678 LM63_REG_REMOTE_OFFSET_MSB
) << 8)
679 | i2c_smbus_read_byte_data(client
,
680 LM63_REG_REMOTE_OFFSET_LSB
);
681 data
->temp8
[2] = i2c_smbus_read_byte_data(client
,
682 LM63_REG_REMOTE_TCRIT
);
683 data
->temp2_crit_hyst
= i2c_smbus_read_byte_data(client
,
684 LM63_REG_REMOTE_TCRIT_HYST
);
686 data
->alarms
= i2c_smbus_read_byte_data(client
,
687 LM63_REG_ALERT_STATUS
) & 0x7F;
689 data
->last_updated
= jiffies
;
693 mutex_unlock(&data
->update_lock
);
698 static int __init
sensors_lm63_init(void)
700 return i2c_add_driver(&lm63_driver
);
703 static void __exit
sensors_lm63_exit(void)
705 i2c_del_driver(&lm63_driver
);
708 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
709 MODULE_DESCRIPTION("LM63 driver");
710 MODULE_LICENSE("GPL");
712 module_init(sensors_lm63_init
);
713 module_exit(sensors_lm63_exit
);