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>
50 #include <linux/types.h>
54 * Address is fully defined internally and cannot be changed.
57 static const unsigned short normal_i2c
[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END
};
63 #define LM63_REG_CONFIG1 0x03
64 #define LM63_REG_CONFIG2 0xBF
65 #define LM63_REG_CONFIG_FAN 0x4A
67 #define LM63_REG_TACH_COUNT_MSB 0x47
68 #define LM63_REG_TACH_COUNT_LSB 0x46
69 #define LM63_REG_TACH_LIMIT_MSB 0x49
70 #define LM63_REG_TACH_LIMIT_LSB 0x48
72 #define LM63_REG_PWM_VALUE 0x4C
73 #define LM63_REG_PWM_FREQ 0x4D
75 #define LM63_REG_LOCAL_TEMP 0x00
76 #define LM63_REG_LOCAL_HIGH 0x05
78 #define LM63_REG_REMOTE_TEMP_MSB 0x01
79 #define LM63_REG_REMOTE_TEMP_LSB 0x10
80 #define LM63_REG_REMOTE_OFFSET_MSB 0x11
81 #define LM63_REG_REMOTE_OFFSET_LSB 0x12
82 #define LM63_REG_REMOTE_HIGH_MSB 0x07
83 #define LM63_REG_REMOTE_HIGH_LSB 0x13
84 #define LM63_REG_REMOTE_LOW_MSB 0x08
85 #define LM63_REG_REMOTE_LOW_LSB 0x14
86 #define LM63_REG_REMOTE_TCRIT 0x19
87 #define LM63_REG_REMOTE_TCRIT_HYST 0x21
89 #define LM63_REG_ALERT_STATUS 0x02
90 #define LM63_REG_ALERT_MASK 0x16
92 #define LM63_REG_MAN_ID 0xFE
93 #define LM63_REG_CHIP_ID 0xFF
95 #define LM96163_REG_REMOTE_TEMP_U_MSB 0x31
96 #define LM96163_REG_REMOTE_TEMP_U_LSB 0x32
97 #define LM96163_REG_CONFIG_ENHANCED 0x45
100 * Conversions and various macros
101 * For tachometer counts, the LM63 uses 16-bit values.
102 * For local temperature and high limit, remote critical limit and hysteresis
103 * value, it uses signed 8-bit values with LSB = 1 degree Celsius.
104 * For remote temperature, low and high limits, it uses signed 11-bit values
105 * with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
106 * For LM64 the actual remote diode temperature is 16 degree Celsius higher
107 * than the register reading. Remote temperature setpoints have to be
108 * adapted accordingly.
111 #define FAN_FROM_REG(reg) ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
113 #define FAN_TO_REG(val) ((val) <= 82 ? 0xFFFC : \
114 (5400000 / (val)) & 0xFFFC)
115 #define TEMP8_FROM_REG(reg) ((reg) * 1000)
116 #define TEMP8_TO_REG(val) ((val) <= -128000 ? -128 : \
117 (val) >= 127000 ? 127 : \
118 (val) < 0 ? ((val) - 500) / 1000 : \
119 ((val) + 500) / 1000)
120 #define TEMP8U_TO_REG(val) ((val) <= 0 ? 0 : \
121 (val) >= 255000 ? 255 : \
122 ((val) + 500) / 1000)
123 #define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
124 #define TEMP11_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
125 (val) >= 127875 ? 0x7FE0 : \
126 (val) < 0 ? ((val) - 62) / 125 * 32 : \
127 ((val) + 62) / 125 * 32)
128 #define TEMP11U_TO_REG(val) ((val) <= 0 ? 0 : \
129 (val) >= 255875 ? 0xFFE0 : \
130 ((val) + 62) / 125 * 32)
131 #define HYST_TO_REG(val) ((val) <= 0 ? 0 : \
132 (val) >= 127000 ? 127 : \
133 ((val) + 500) / 1000)
136 * Functions declaration
139 static int lm63_probe(struct i2c_client
*client
,
140 const struct i2c_device_id
*id
);
141 static int lm63_remove(struct i2c_client
*client
);
143 static struct lm63_data
*lm63_update_device(struct device
*dev
);
145 static int lm63_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
146 static void lm63_init_client(struct i2c_client
*client
);
148 enum chips
{ lm63
, lm64
, lm96163
};
151 * Driver data (common to all clients)
154 static const struct i2c_device_id lm63_id
[] = {
157 { "lm96163", lm96163
},
160 MODULE_DEVICE_TABLE(i2c
, lm63_id
);
162 static struct i2c_driver lm63_driver
= {
163 .class = I2C_CLASS_HWMON
,
168 .remove
= lm63_remove
,
170 .detect
= lm63_detect
,
171 .address_list
= normal_i2c
,
175 * Client data (each client gets its own)
179 struct device
*hwmon_dev
;
180 struct mutex update_lock
;
181 char valid
; /* zero until following fields are valid */
182 unsigned long last_updated
; /* in jiffies */
186 /* registers values */
187 u8 config
, config_fan
;
188 u16 fan
[2]; /* 0: input
192 s8 temp8
[3]; /* 0: local input
194 2: remote critical limit */
195 s16 temp11
[4]; /* 0: remote input
199 u16 temp11u
; /* remote input (unsigned) */
203 bool remote_unsigned
; /* true if unsigned remote upper limits */
206 static inline int temp8_from_reg(struct lm63_data
*data
, int nr
)
208 if (data
->remote_unsigned
)
209 return TEMP8_FROM_REG((u8
)data
->temp8
[nr
]);
210 return TEMP8_FROM_REG(data
->temp8
[nr
]);
214 * Sysfs callback functions and files
217 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*devattr
,
220 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
221 struct lm63_data
*data
= lm63_update_device(dev
);
222 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[attr
->index
]));
225 static ssize_t
set_fan(struct device
*dev
, struct device_attribute
*dummy
,
226 const char *buf
, size_t count
)
228 struct i2c_client
*client
= to_i2c_client(dev
);
229 struct lm63_data
*data
= i2c_get_clientdata(client
);
233 err
= kstrtoul(buf
, 10, &val
);
237 mutex_lock(&data
->update_lock
);
238 data
->fan
[1] = FAN_TO_REG(val
);
239 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_LSB
,
240 data
->fan
[1] & 0xFF);
241 i2c_smbus_write_byte_data(client
, LM63_REG_TACH_LIMIT_MSB
,
243 mutex_unlock(&data
->update_lock
);
247 static ssize_t
show_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
250 struct lm63_data
*data
= lm63_update_device(dev
);
253 if (data
->pwm_highres
)
254 pwm
= data
->pwm1_value
;
256 pwm
= data
->pwm1_value
>= 2 * data
->pwm1_freq
?
257 255 : (data
->pwm1_value
* 255 + data
->pwm1_freq
) /
258 (2 * data
->pwm1_freq
);
260 return sprintf(buf
, "%d\n", pwm
);
263 static ssize_t
set_pwm1(struct device
*dev
, struct device_attribute
*dummy
,
264 const char *buf
, size_t count
)
266 struct i2c_client
*client
= to_i2c_client(dev
);
267 struct lm63_data
*data
= i2c_get_clientdata(client
);
271 if (!(data
->config_fan
& 0x20)) /* register is read-only */
274 err
= kstrtoul(buf
, 10, &val
);
278 val
= SENSORS_LIMIT(val
, 0, 255);
279 mutex_lock(&data
->update_lock
);
280 data
->pwm1_value
= data
->pwm_highres
? val
:
281 (val
* data
->pwm1_freq
* 2 + 127) / 255;
282 i2c_smbus_write_byte_data(client
, LM63_REG_PWM_VALUE
, data
->pwm1_value
);
283 mutex_unlock(&data
->update_lock
);
287 static ssize_t
show_pwm1_enable(struct device
*dev
,
288 struct device_attribute
*dummy
, char *buf
)
290 struct lm63_data
*data
= lm63_update_device(dev
);
291 return sprintf(buf
, "%d\n", data
->config_fan
& 0x20 ? 1 : 2);
295 * There are 8bit registers for both local(temp1) and remote(temp2) sensor.
296 * For remote sensor registers temp2_offset has to be considered,
297 * for local sensor it must not.
298 * So we need separate 8bit accessors for local and remote sensor.
300 static ssize_t
show_local_temp8(struct device
*dev
,
301 struct device_attribute
*devattr
,
304 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
305 struct lm63_data
*data
= lm63_update_device(dev
);
306 return sprintf(buf
, "%d\n", TEMP8_FROM_REG(data
->temp8
[attr
->index
]));
309 static ssize_t
show_remote_temp8(struct device
*dev
,
310 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", temp8_from_reg(data
, attr
->index
)
316 + data
->temp2_offset
);
319 static ssize_t
set_temp8(struct device
*dev
, struct device_attribute
*devattr
,
320 const char *buf
, size_t count
)
322 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
323 struct i2c_client
*client
= to_i2c_client(dev
);
324 struct lm63_data
*data
= i2c_get_clientdata(client
);
325 int nr
= attr
->index
;
326 int reg
= nr
== 2 ? LM63_REG_REMOTE_TCRIT
: LM63_REG_LOCAL_HIGH
;
331 err
= kstrtol(buf
, 10, &val
);
335 mutex_lock(&data
->update_lock
);
337 if (data
->remote_unsigned
)
338 temp
= TEMP8U_TO_REG(val
- data
->temp2_offset
);
340 temp
= TEMP8_TO_REG(val
- data
->temp2_offset
);
342 temp
= TEMP8_TO_REG(val
);
344 data
->temp8
[nr
] = temp
;
345 i2c_smbus_write_byte_data(client
, reg
, temp
);
346 mutex_unlock(&data
->update_lock
);
350 static ssize_t
show_temp11(struct device
*dev
, struct device_attribute
*devattr
,
353 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
354 struct lm63_data
*data
= lm63_update_device(dev
);
355 int nr
= attr
->index
;
360 * Use unsigned temperature unless its value is zero.
361 * If it is zero, use signed temperature.
364 temp
= TEMP11_FROM_REG(data
->temp11u
);
366 temp
= TEMP11_FROM_REG(data
->temp11
[nr
]);
368 if (data
->remote_unsigned
&& nr
== 2)
369 temp
= TEMP11_FROM_REG((u16
)data
->temp11
[nr
]);
371 temp
= TEMP11_FROM_REG(data
->temp11
[nr
]);
373 return sprintf(buf
, "%d\n", temp
+ data
->temp2_offset
);
376 static ssize_t
set_temp11(struct device
*dev
, struct device_attribute
*devattr
,
377 const char *buf
, size_t count
)
379 static const u8 reg
[6] = {
380 LM63_REG_REMOTE_LOW_MSB
,
381 LM63_REG_REMOTE_LOW_LSB
,
382 LM63_REG_REMOTE_HIGH_MSB
,
383 LM63_REG_REMOTE_HIGH_LSB
,
384 LM63_REG_REMOTE_OFFSET_MSB
,
385 LM63_REG_REMOTE_OFFSET_LSB
,
388 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
389 struct i2c_client
*client
= to_i2c_client(dev
);
390 struct lm63_data
*data
= i2c_get_clientdata(client
);
393 int nr
= attr
->index
;
395 err
= kstrtol(buf
, 10, &val
);
399 mutex_lock(&data
->update_lock
);
400 if (data
->remote_unsigned
&& nr
== 2)
401 data
->temp11
[nr
] = TEMP11U_TO_REG(val
- data
->temp2_offset
);
403 data
->temp11
[nr
] = TEMP11_TO_REG(val
- data
->temp2_offset
);
405 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2],
406 data
->temp11
[nr
] >> 8);
407 i2c_smbus_write_byte_data(client
, reg
[(nr
- 1) * 2 + 1],
408 data
->temp11
[nr
] & 0xff);
409 mutex_unlock(&data
->update_lock
);
414 * Hysteresis register holds a relative value, while we want to present
415 * an absolute to user-space
417 static ssize_t
show_temp2_crit_hyst(struct device
*dev
,
418 struct device_attribute
*dummy
, char *buf
)
420 struct lm63_data
*data
= lm63_update_device(dev
);
421 return sprintf(buf
, "%d\n", temp8_from_reg(data
, 2)
423 - TEMP8_FROM_REG(data
->temp2_crit_hyst
));
427 * And now the other way around, user-space provides an absolute
428 * hysteresis value and we have to store a relative one
430 static ssize_t
set_temp2_crit_hyst(struct device
*dev
,
431 struct device_attribute
*dummy
,
432 const char *buf
, size_t count
)
434 struct i2c_client
*client
= to_i2c_client(dev
);
435 struct lm63_data
*data
= i2c_get_clientdata(client
);
440 err
= kstrtol(buf
, 10, &val
);
444 mutex_lock(&data
->update_lock
);
445 hyst
= temp8_from_reg(data
, 2) + data
->temp2_offset
- val
;
446 i2c_smbus_write_byte_data(client
, LM63_REG_REMOTE_TCRIT_HYST
,
448 mutex_unlock(&data
->update_lock
);
452 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*dummy
,
455 struct lm63_data
*data
= lm63_update_device(dev
);
456 return sprintf(buf
, "%u\n", data
->alarms
);
459 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*devattr
,
462 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
463 struct lm63_data
*data
= lm63_update_device(dev
);
464 int bitnr
= attr
->index
;
466 return sprintf(buf
, "%u\n", (data
->alarms
>> bitnr
) & 1);
469 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, show_fan
, NULL
, 0);
470 static SENSOR_DEVICE_ATTR(fan1_min
, S_IWUSR
| S_IRUGO
, show_fan
,
473 static DEVICE_ATTR(pwm1
, S_IWUSR
| S_IRUGO
, show_pwm1
, set_pwm1
);
474 static DEVICE_ATTR(pwm1_enable
, S_IRUGO
, show_pwm1_enable
, NULL
);
476 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, show_local_temp8
, NULL
, 0);
477 static SENSOR_DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_local_temp8
,
480 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, show_temp11
, NULL
, 0);
481 static SENSOR_DEVICE_ATTR(temp2_min
, S_IWUSR
| S_IRUGO
, show_temp11
,
483 static SENSOR_DEVICE_ATTR(temp2_max
, S_IWUSR
| S_IRUGO
, show_temp11
,
485 static SENSOR_DEVICE_ATTR(temp2_offset
, S_IWUSR
| S_IRUGO
, show_temp11
,
487 static SENSOR_DEVICE_ATTR(temp2_crit
, S_IRUGO
, show_remote_temp8
,
489 static DEVICE_ATTR(temp2_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp2_crit_hyst
,
490 set_temp2_crit_hyst
);
492 /* Individual alarm files */
493 static SENSOR_DEVICE_ATTR(fan1_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
494 static SENSOR_DEVICE_ATTR(temp2_crit_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
495 static SENSOR_DEVICE_ATTR(temp2_fault
, S_IRUGO
, show_alarm
, NULL
, 2);
496 static SENSOR_DEVICE_ATTR(temp2_min_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
497 static SENSOR_DEVICE_ATTR(temp2_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
498 static SENSOR_DEVICE_ATTR(temp1_max_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
499 /* Raw alarm file for compatibility */
500 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
502 static struct attribute
*lm63_attributes
[] = {
504 &dev_attr_pwm1_enable
.attr
,
505 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
506 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
507 &sensor_dev_attr_temp2_min
.dev_attr
.attr
,
508 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
509 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
510 &sensor_dev_attr_temp2_offset
.dev_attr
.attr
,
511 &sensor_dev_attr_temp2_crit
.dev_attr
.attr
,
512 &dev_attr_temp2_crit_hyst
.attr
,
514 &sensor_dev_attr_temp2_crit_alarm
.dev_attr
.attr
,
515 &sensor_dev_attr_temp2_fault
.dev_attr
.attr
,
516 &sensor_dev_attr_temp2_min_alarm
.dev_attr
.attr
,
517 &sensor_dev_attr_temp2_max_alarm
.dev_attr
.attr
,
518 &sensor_dev_attr_temp1_max_alarm
.dev_attr
.attr
,
519 &dev_attr_alarms
.attr
,
524 * On LM63, temp2_crit can be set only once, which should be job
526 * On LM64, temp2_crit can always be set.
527 * On LM96163, temp2_crit can be set if bit 1 of the configuration
530 static umode_t
lm63_attribute_mode(struct kobject
*kobj
,
531 struct attribute
*attr
, int index
)
533 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
534 struct i2c_client
*client
= to_i2c_client(dev
);
535 struct lm63_data
*data
= i2c_get_clientdata(client
);
537 if (attr
== &sensor_dev_attr_temp2_crit
.dev_attr
.attr
538 && (data
->kind
== lm64
||
539 (data
->kind
== lm96163
&& (data
->config
& 0x02))))
540 return attr
->mode
| S_IWUSR
;
545 static const struct attribute_group lm63_group
= {
546 .is_visible
= lm63_attribute_mode
,
547 .attrs
= lm63_attributes
,
550 static struct attribute
*lm63_attributes_fan1
[] = {
551 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
552 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
554 &sensor_dev_attr_fan1_min_alarm
.dev_attr
.attr
,
558 static const struct attribute_group lm63_group_fan1
= {
559 .attrs
= lm63_attributes_fan1
,
566 /* Return 0 if detection is successful, -ENODEV otherwise */
567 static int lm63_detect(struct i2c_client
*new_client
,
568 struct i2c_board_info
*info
)
570 struct i2c_adapter
*adapter
= new_client
->adapter
;
571 u8 man_id
, chip_id
, reg_config1
, reg_config2
;
572 u8 reg_alert_status
, reg_alert_mask
;
573 int address
= new_client
->addr
;
575 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
578 man_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_MAN_ID
);
579 chip_id
= i2c_smbus_read_byte_data(new_client
, LM63_REG_CHIP_ID
);
581 reg_config1
= i2c_smbus_read_byte_data(new_client
,
583 reg_config2
= i2c_smbus_read_byte_data(new_client
,
585 reg_alert_status
= i2c_smbus_read_byte_data(new_client
,
586 LM63_REG_ALERT_STATUS
);
587 reg_alert_mask
= i2c_smbus_read_byte_data(new_client
,
588 LM63_REG_ALERT_MASK
);
590 if (man_id
!= 0x01 /* National Semiconductor */
591 || (reg_config1
& 0x18) != 0x00
592 || (reg_config2
& 0xF8) != 0x00
593 || (reg_alert_status
& 0x20) != 0x00
594 || (reg_alert_mask
& 0xA4) != 0xA4) {
595 dev_dbg(&adapter
->dev
,
596 "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
601 if (chip_id
== 0x41 && address
== 0x4c)
602 strlcpy(info
->type
, "lm63", I2C_NAME_SIZE
);
603 else if (chip_id
== 0x51 && (address
== 0x18 || address
== 0x4e))
604 strlcpy(info
->type
, "lm64", I2C_NAME_SIZE
);
605 else if (chip_id
== 0x49 && address
== 0x4c)
606 strlcpy(info
->type
, "lm96163", I2C_NAME_SIZE
);
613 static int lm63_probe(struct i2c_client
*new_client
,
614 const struct i2c_device_id
*id
)
616 struct lm63_data
*data
;
619 data
= kzalloc(sizeof(struct lm63_data
), GFP_KERNEL
);
625 i2c_set_clientdata(new_client
, data
);
627 mutex_init(&data
->update_lock
);
629 /* Set the device type */
630 data
->kind
= id
->driver_data
;
631 if (data
->kind
== lm64
)
632 data
->temp2_offset
= 16000;
634 /* Initialize chip */
635 lm63_init_client(new_client
);
637 /* Register sysfs hooks */
638 err
= sysfs_create_group(&new_client
->dev
.kobj
, &lm63_group
);
641 if (data
->config
& 0x04) { /* tachometer enabled */
642 err
= sysfs_create_group(&new_client
->dev
.kobj
,
645 goto exit_remove_files
;
648 data
->hwmon_dev
= hwmon_device_register(&new_client
->dev
);
649 if (IS_ERR(data
->hwmon_dev
)) {
650 err
= PTR_ERR(data
->hwmon_dev
);
651 goto exit_remove_files
;
657 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group
);
658 sysfs_remove_group(&new_client
->dev
.kobj
, &lm63_group_fan1
);
666 * Ideally we shouldn't have to initialize anything, since the BIOS
667 * should have taken care of everything
669 static void lm63_init_client(struct i2c_client
*client
)
671 struct lm63_data
*data
= i2c_get_clientdata(client
);
673 data
->config
= i2c_smbus_read_byte_data(client
, LM63_REG_CONFIG1
);
674 data
->config_fan
= i2c_smbus_read_byte_data(client
,
675 LM63_REG_CONFIG_FAN
);
677 /* Start converting if needed */
678 if (data
->config
& 0x40) { /* standby */
679 dev_dbg(&client
->dev
, "Switching to operational mode\n");
680 data
->config
&= 0xA7;
681 i2c_smbus_write_byte_data(client
, LM63_REG_CONFIG1
,
685 /* We may need pwm1_freq before ever updating the client data */
686 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
, LM63_REG_PWM_FREQ
);
687 if (data
->pwm1_freq
== 0)
691 * For LM96163, check if high resolution PWM
692 * and unsigned temperature format is enabled.
694 if (data
->kind
== lm96163
) {
696 = i2c_smbus_read_byte_data(client
,
697 LM96163_REG_CONFIG_ENHANCED
);
698 if ((config_enhanced
& 0x10)
699 && !(data
->config_fan
& 0x08) && data
->pwm1_freq
== 8)
700 data
->pwm_highres
= true;
701 if (config_enhanced
& 0x08)
702 data
->remote_unsigned
= true;
705 /* Show some debug info about the LM63 configuration */
706 dev_dbg(&client
->dev
, "Alert/tach pin configured for %s\n",
707 (data
->config
& 0x04) ? "tachometer input" :
709 dev_dbg(&client
->dev
, "PWM clock %s kHz, output frequency %u Hz\n",
710 (data
->config_fan
& 0x08) ? "1.4" : "360",
711 ((data
->config_fan
& 0x08) ? 700 : 180000) / data
->pwm1_freq
);
712 dev_dbg(&client
->dev
, "PWM output active %s, %s mode\n",
713 (data
->config_fan
& 0x10) ? "low" : "high",
714 (data
->config_fan
& 0x20) ? "manual" : "auto");
717 static int lm63_remove(struct i2c_client
*client
)
719 struct lm63_data
*data
= i2c_get_clientdata(client
);
721 hwmon_device_unregister(data
->hwmon_dev
);
722 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group
);
723 sysfs_remove_group(&client
->dev
.kobj
, &lm63_group_fan1
);
729 static struct lm63_data
*lm63_update_device(struct device
*dev
)
731 struct i2c_client
*client
= to_i2c_client(dev
);
732 struct lm63_data
*data
= i2c_get_clientdata(client
);
734 mutex_lock(&data
->update_lock
);
736 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
737 if (data
->config
& 0x04) { /* tachometer enabled */
738 /* order matters for fan1_input */
739 data
->fan
[0] = i2c_smbus_read_byte_data(client
,
740 LM63_REG_TACH_COUNT_LSB
) & 0xFC;
741 data
->fan
[0] |= i2c_smbus_read_byte_data(client
,
742 LM63_REG_TACH_COUNT_MSB
) << 8;
743 data
->fan
[1] = (i2c_smbus_read_byte_data(client
,
744 LM63_REG_TACH_LIMIT_LSB
) & 0xFC)
745 | (i2c_smbus_read_byte_data(client
,
746 LM63_REG_TACH_LIMIT_MSB
) << 8);
749 data
->pwm1_freq
= i2c_smbus_read_byte_data(client
,
751 if (data
->pwm1_freq
== 0)
753 data
->pwm1_value
= i2c_smbus_read_byte_data(client
,
756 data
->temp8
[0] = i2c_smbus_read_byte_data(client
,
757 LM63_REG_LOCAL_TEMP
);
758 data
->temp8
[1] = i2c_smbus_read_byte_data(client
,
759 LM63_REG_LOCAL_HIGH
);
761 /* order matters for temp2_input */
762 data
->temp11
[0] = i2c_smbus_read_byte_data(client
,
763 LM63_REG_REMOTE_TEMP_MSB
) << 8;
764 data
->temp11
[0] |= i2c_smbus_read_byte_data(client
,
765 LM63_REG_REMOTE_TEMP_LSB
);
766 data
->temp11
[1] = (i2c_smbus_read_byte_data(client
,
767 LM63_REG_REMOTE_LOW_MSB
) << 8)
768 | i2c_smbus_read_byte_data(client
,
769 LM63_REG_REMOTE_LOW_LSB
);
770 data
->temp11
[2] = (i2c_smbus_read_byte_data(client
,
771 LM63_REG_REMOTE_HIGH_MSB
) << 8)
772 | i2c_smbus_read_byte_data(client
,
773 LM63_REG_REMOTE_HIGH_LSB
);
774 data
->temp11
[3] = (i2c_smbus_read_byte_data(client
,
775 LM63_REG_REMOTE_OFFSET_MSB
) << 8)
776 | i2c_smbus_read_byte_data(client
,
777 LM63_REG_REMOTE_OFFSET_LSB
);
779 if (data
->kind
== lm96163
)
780 data
->temp11u
= (i2c_smbus_read_byte_data(client
,
781 LM96163_REG_REMOTE_TEMP_U_MSB
) << 8)
782 | i2c_smbus_read_byte_data(client
,
783 LM96163_REG_REMOTE_TEMP_U_LSB
);
785 data
->temp8
[2] = i2c_smbus_read_byte_data(client
,
786 LM63_REG_REMOTE_TCRIT
);
787 data
->temp2_crit_hyst
= i2c_smbus_read_byte_data(client
,
788 LM63_REG_REMOTE_TCRIT_HYST
);
790 data
->alarms
= i2c_smbus_read_byte_data(client
,
791 LM63_REG_ALERT_STATUS
) & 0x7F;
793 data
->last_updated
= jiffies
;
797 mutex_unlock(&data
->update_lock
);
802 static int __init
sensors_lm63_init(void)
804 return i2c_add_driver(&lm63_driver
);
807 static void __exit
sensors_lm63_exit(void)
809 i2c_del_driver(&lm63_driver
);
812 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
813 MODULE_DESCRIPTION("LM63 driver");
814 MODULE_LICENSE("GPL");
816 module_init(sensors_lm63_init
);
817 module_exit(sensors_lm63_exit
);